/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/


#ifndef __com_sun_star_bridge_OleBridgeSupplier2_idl__
#define __com_sun_star_bridge_OleBridgeSupplier2_idl__

#ifndef __com_sun_star_bridge_XBridgeSupplier2_idl__
#include <com/sun/star/bridge/XBridgeSupplier2.idl>
#endif


//=============================================================================

module com { module sun { module star { module bridge {

//=============================================================================
/** maps UNO types to oleautomation types and vice versa.<p>

	The XBridgeSupplier2 interface provides the function <code>createBridge</code> which
	maps a value of an UNO or Automation type to the desired target type. If an UNO interface
	was mapped  to IDispatch, then all objects (interfaces, structs) and other
	types which
	are obtained from that Automation object are automatically mapped to the corresponding
	 Automation types. Hence, if one provides an initial object which forms the root of all
	 other objects, such as a service manager, then only that object needs to be explicitly
	 mapped by a call to <code>createBridge</code>. The same holds true if an automation
	 object is mapped to an UNO interface.<br>
	<p>The Automation types <code>VT_CY</code> and <code>VT_DATE</code> are not supported.
	For Automation objects to be mapped they have to implement IDispatch interface. Other
	COM interfaces,
	except for IUnknown, are not supported.UNO interfaces and structs are mapped to IDispatch.

	<p>The service implements the <type>XBridgeSupplier2</type> interface
	and handles the model types
	<const>com::sun::star::bridge::ModelDependent::UNO</const> and
	<const>com::sun::star::bridge::ModelDependent::OLE</const>.
	The service does not specify any
	requirements for registering OLE objects and class factories. </p>

    @deprecated
*/
published service OleBridgeSupplier2
{
	interface com::sun::star::bridge::XBridgeSupplier2;

};

//=============================================================================

}; }; }; };

#endif
