From 940b4d1848e8c70ab7642901a68594e8016caffc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:51:28 +0200 Subject: Adding upstream version 1:7.0.4. Signed-off-by: Daniel Baumann --- extensions/test/ole/unoTocomCalls/Test/StdAfx.cpp | 28 + extensions/test/ole/unoTocomCalls/Test/StdAfx.h | 47 ++ extensions/test/ole/unoTocomCalls/Test/Test.cpp | 240 ++++++ extensions/test/ole/unoTocomCalls/Test/Test.dsp | 114 +++ extensions/test/ole/unoTocomCalls/Test/Test.sln | 19 + extensions/test/ole/unoTocomCalls/Test/Test.vcproj | 247 +++++++ .../ole/unoTocomCalls/XCallback_Impl/Basic.rgs | 27 + .../ole/unoTocomCalls/XCallback_Impl/BasicTest.rgs | 27 + .../ole/unoTocomCalls/XCallback_Impl/Callback.cpp | 505 +++++++++++++ .../ole/unoTocomCalls/XCallback_Impl/Callback.h | 129 ++++ .../ole/unoTocomCalls/XCallback_Impl/Callback.rgs | 27 + .../ole/unoTocomCalls/XCallback_Impl/Simple.cpp | 73 ++ .../test/ole/unoTocomCalls/XCallback_Impl/Simple.h | 58 ++ .../ole/unoTocomCalls/XCallback_Impl/Simple.rgs | 27 + .../ole/unoTocomCalls/XCallback_Impl/StdAfx.cpp | 32 + .../test/ole/unoTocomCalls/XCallback_Impl/StdAfx.h | 45 ++ .../XCallback_Impl/XCallback_Impl.cpp | 94 +++ .../XCallback_Impl/XCallback_Impl.def | 10 + .../XCallback_Impl/XCallback_Impl.dsp | 337 +++++++++ .../XCallback_Impl/XCallback_Impl.idl | 144 ++++ .../unoTocomCalls/XCallback_Impl/XCallback_Impl.rc | 154 ++++ .../XCallback_Impl/XCallback_Impl.sln | 31 + .../XCallback_Impl/XCallback_Impl.vcproj | 816 +++++++++++++++++++++ .../ole/unoTocomCalls/XCallback_Impl/resource.h | 39 + extensions/test/ole/unoTocomCalls/readme.txt | 9 + 25 files changed, 3279 insertions(+) create mode 100644 extensions/test/ole/unoTocomCalls/Test/StdAfx.cpp create mode 100644 extensions/test/ole/unoTocomCalls/Test/StdAfx.h create mode 100644 extensions/test/ole/unoTocomCalls/Test/Test.cpp create mode 100644 extensions/test/ole/unoTocomCalls/Test/Test.dsp create mode 100644 extensions/test/ole/unoTocomCalls/Test/Test.sln create mode 100644 extensions/test/ole/unoTocomCalls/Test/Test.vcproj create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Basic.rgs create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/BasicTest.rgs create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.cpp create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.h create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.rgs create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.cpp create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.h create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.rgs create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.cpp create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.h create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.cpp create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.def create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.dsp create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.idl create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.rc create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.sln create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.vcproj create mode 100644 extensions/test/ole/unoTocomCalls/XCallback_Impl/resource.h create mode 100644 extensions/test/ole/unoTocomCalls/readme.txt (limited to 'extensions/test/ole/unoTocomCalls') diff --git a/extensions/test/ole/unoTocomCalls/Test/StdAfx.cpp b/extensions/test/ole/unoTocomCalls/Test/StdAfx.cpp new file mode 100644 index 000000000..fcefb8f0c --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/StdAfx.cpp @@ -0,0 +1,28 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// stdafx.cpp : source file that includes just the standard includes +// Test.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/Test/StdAfx.h b/extensions/test/ole/unoTocomCalls/Test/StdAfx.h new file mode 100644 index 000000000..0274335ce --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/StdAfx.h @@ -0,0 +1,47 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently + +#if !defined(AFX_STDAFX_H__180FF568_6F5C_11D4_8330_005004526AB4__INCLUDED_) +#define AFX_STDAFX_H__180FF568_6F5C_11D4_8330_005004526AB4__INCLUDED_ + +#ifdef _MSC_VER +#pragma once +#endif + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include +#include +#include +#include +extern CComModule _Module; +#include +#include + +// TODO: reference additional headers your program requires here + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__180FF568_6F5C_11D4_8330_005004526AB4__INCLUDED_) + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/Test/Test.cpp b/extensions/test/ole/unoTocomCalls/Test/Test.cpp new file mode 100644 index 000000000..b10900dbc --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/Test.cpp @@ -0,0 +1,240 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// Test.cpp : Defines the entry point for the console application. + + +#include "stdafx.h" +#include "../XCallback_Impl/XCallback_Impl.h" +#include "../XCallback_Impl/XCallback_Impl_i.c" + +CComModule _Module; +BEGIN_OBJECT_MAP(ObjectMap) +END_OBJECT_MAP() + +HRESULT doTest(); + +int main(int argc, char* argv[]) +{ + HRESULT hr; + if( FAILED( hr=CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))) + { + _tprintf(_T("CoInitializeEx failed \n")); + return -1; + } + + + _Module.Init( ObjectMap, GetModuleHandle( NULL)); + + if( FAILED(hr=doTest())) + { + _com_error err( hr); + const TCHAR * errMsg= err.ErrorMessage(); + MessageBox( NULL, errMsg, "Test failed", MB_ICONERROR); + } + + + _Module.Term(); + CoUninitialize(); + + + return 0; +} + + +HRESULT doTest() +{ + HRESULT hr= S_OK; + + CComPtr spUnk; + hr= spUnk.CoCreateInstance(L"com.sun.star.ServiceManager"); + if( FAILED( hr)) + return hr; + + CComDispatchDriver manager( spUnk); + CComVariant param( L"oletest.OleTest"); + CComVariant retVal; + hr= manager.Invoke1((LPCOLESTR)L"createInstance", ¶m, &retVal ); + + CComDispatchDriver oletest( retVal.punkVal); + + spUnk.Release(); + + hr= spUnk.CoCreateInstance(L"XCallback_Impl.Callback"); + if( FAILED( hr)) + return hr; + + CComQIPtr paramDisp(spUnk); + + + + // out parameters + + CComVariant param1( paramDisp); + CComVariant param2(1); + + // oletest calls XCallback::func1 + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::returnInterface + param2= 2; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outInterface + param2= 3; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outStruct + param2= 4; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outEnum + param2= 5; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outSeqAny + param2= 6; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outAny + param2= 7; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outBool + param2= 8; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outChar + param2= 9; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outString + param2= 10; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outFloat + param2= 11; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outDouble + param2= 12; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outByte + param2= 13; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outShort + param2= 14; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outLong + param2= 15; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outValuesMixed + param2= 30; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::outValuesAll + param2= 31; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + // XCallback::outSeqByte + // Does not work currently because Sequences are always converted to + // SAFEARRAY( VARIANT) + // param2= 32; + // hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + + // in / out parameters + + // XCallback::inoutInterface + param2= 100; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutStruct + param2= 101; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutEnum + param2= 102; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutSeqAny + param2= 103; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutAny + param2= 104; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutBool + param2= 105; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutChar + param2= 106; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutString + param2= 107; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutFloat + param2= 108; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutDouble + param2= 109; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutByte + param2= 110; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutShort + param2= 111; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutLong + param2= 112; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutValuesAll + param2=120; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + // in parameters + + // XCallback::inValues + param2= 200; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inSeqByte + // SAFEARRAY( VARIANT) + param2= 201; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + //XCallback::inSeqXEventListener + param2= 202; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + // The UNO test component OleTest calls on XCallback_Impl.Callback directly + // that is the COM object has not been past a parameter but rather OleTest + // creates the COM object itself + + // XCallback::outValuesAll + // does not work currently + param2= 300; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutValuesAll + param2= 301; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + // XCallback::inoutValues + param2= 302; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + // XCallback::inValues + param2= 303; + hr= oletest.Invoke2(L"testInterface", ¶m1, ¶m2); + + // Test a COM object which implements several interfaces. + + + CComQIPtr dispSimple; + hr= dispSimple.CoCreateInstance(L"XCallback_Impl.Simple"); + CComVariant varSimple( dispSimple); + param2= 0; + hr= oletest.Invoke2(L"testInterface2", &varSimple, ¶m2); + + return hr; +} +// VARIANT CComVariant VT_UNKNOWN VT_DISPATCH V_UI1 CComDispatchDriver WINAPI + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/Test/Test.dsp b/extensions/test/ole/unoTocomCalls/Test/Test.dsp new file mode 100644 index 000000000..d9ef4e865 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/Test.dsp @@ -0,0 +1,114 @@ +# Microsoft Developer Studio Project File - Name="Test" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Console Application" 0x0103 + +CFG=Test - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "Test.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "Test.mak" CFG="Test - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "Test - Win32 Release" (based on "Win32 (x86) Console Application") +!MESSAGE "Test - Win32 Debug" (based on "Win32 (x86) Console Application") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +RSC=rc.exe + +!IF "$(CFG)" == "Test - Win32 Release" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "Release" +# PROP BASE Intermediate_Dir "Release" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "Release" +# PROP Intermediate_Dir "Release" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 + +!ELSEIF "$(CFG)" == "Test - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /Yu"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept + +!ENDIF + +# Begin Target + +# Name "Test - Win32 Release" +# Name "Test - Win32 Debug" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\StdAfx.cpp +# ADD CPP /Yc"stdafx.h" +# End Source File +# Begin Source File + +SOURCE=.\Test.cpp +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\StdAfx.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# End Group +# Begin Source File + +SOURCE=.\ReadMe.txt +# End Source File +# End Target +# End Project + diff --git a/extensions/test/ole/unoTocomCalls/Test/Test.sln b/extensions/test/ole/unoTocomCalls/Test/Test.sln new file mode 100644 index 000000000..428b73625 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/Test.sln @@ -0,0 +1,19 @@ +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Test", "Test.vcproj", "{13AE4BE8-2467-4B35-800F-154379D54C24}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release|Win32 = Release|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {13AE4BE8-2467-4B35-800F-154379D54C24}.Debug|Win32.ActiveCfg = Debug|Win32 + {13AE4BE8-2467-4B35-800F-154379D54C24}.Debug|Win32.Build.0 = Debug|Win32 + {13AE4BE8-2467-4B35-800F-154379D54C24}.Release|Win32.ActiveCfg = Release|Win32 + {13AE4BE8-2467-4B35-800F-154379D54C24}.Release|Win32.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/extensions/test/ole/unoTocomCalls/Test/Test.vcproj b/extensions/test/ole/unoTocomCalls/Test/Test.vcproj new file mode 100644 index 000000000..f31d1ffc4 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/Test/Test.vcproj @@ -0,0 +1,247 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Basic.rgs b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Basic.rgs new file mode 100644 index 000000000..bc1525d7e --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Basic.rgs @@ -0,0 +1,27 @@ +HKCR +{ + XCallback_Impl.Basic.1 = s 'Basic Class' + { + CLSID = s '{A0F04CB7-8494-11D4-8335-005004526AB4}' + } + XCallback_Impl.Basic = s 'Basic Class' + { + CLSID = s '{A0F04CB7-8494-11D4-8335-005004526AB4}' + CurVer = s 'XCallback_Impl.Basic.1' + } + NoRemove CLSID + { + ForceRemove {A0F04CB7-8494-11D4-8335-005004526AB4} = s 'Basic Class' + { + ProgID = s 'XCallback_Impl.Basic.1' + VersionIndependentProgID = s 'XCallback_Impl.Basic' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{180FF553-6F5C-11D4-8330-005004526AB4}' + } + } +} + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/BasicTest.rgs b/extensions/test/ole/unoTocomCalls/XCallback_Impl/BasicTest.rgs new file mode 100644 index 000000000..ee718304d --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/BasicTest.rgs @@ -0,0 +1,27 @@ +HKCR +{ + XCallback_Impl.BasicTest.1 = s 'BasicTest Class' + { + CLSID = s '{A0F04CBD-8494-11D4-8335-005004526AB4}' + } + XCallback_Impl.BasicTest = s 'BasicTest Class' + { + CLSID = s '{A0F04CBD-8494-11D4-8335-005004526AB4}' + CurVer = s 'XCallback_Impl.BasicTest.1' + } + NoRemove CLSID + { + ForceRemove {A0F04CBD-8494-11D4-8335-005004526AB4} = s 'BasicTest Class' + { + ProgID = s 'XCallback_Impl.BasicTest.1' + VersionIndependentProgID = s 'XCallback_Impl.BasicTest' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{180FF553-6F5C-11D4-8330-005004526AB4}' + } + } +} + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.cpp b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.cpp new file mode 100644 index 000000000..c60a18219 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.cpp @@ -0,0 +1,505 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// Callback.cpp : Implementation of CCallback +#include "stdafx.h" +#include "XCallback_Impl.h" +#include "Callback.h" + + +// CCallback + + +STDMETHODIMP CCallback::func1() +{ + MessageBox( NULL, _T("Callback::func1 called"),_T(""), MB_OK); + return S_OK; +} + +STDMETHODIMP CCallback::returnInterface(IDispatch **ppdisp) +{ + if( ! ppdisp) + return E_POINTER; + CComPtr spDisp; + spDisp.CoCreateInstance( L"XCallback_Impl.Simple"); + *ppdisp= spDisp; + (*ppdisp)->AddRef(); + return S_OK; +} + +STDMETHODIMP CCallback::outInterface(IDispatch **ppdisp) +{ +// return S_OK; + if( ! ppdisp) + return E_POINTER; + CComPtr spDisp; + spDisp.CoCreateInstance( L"XCallback_Impl.Simple"); + *ppdisp= spDisp; + (*ppdisp)->AddRef(); + +// MessageBox( NULL, _T("CCallback::outInterface"), _T(""), MB_OK); + return S_OK; +} + +STDMETHODIMP CCallback::outValuesMixed(long val, long *pval, BSTR string) +{ + USES_CONVERSION; + char buff[1024]; + *pval = val+1; + sprintf( buff, "param1: %d, param2 out: %d, param3: %S", val, *pval, string); + MessageBox( NULL, A2T(buff), A2T("XCallback_Impl.Callback"), MB_OK); + return S_OK; +} + + +STDMETHODIMP CCallback::outValuesAll( + /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppdisp, + /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppSimpleStruct, + /* [out] */ long __RPC_FAR *aSimpleEnum, + /* [out] */ SAFEARRAY __RPC_FAR * __RPC_FAR *outSeq, + /* [out] */ VARIANT __RPC_FAR *varAny, + /* [out] */ VARIANT_BOOL __RPC_FAR *aBool, + /* [out] */ short __RPC_FAR *aChar, + /* [out] */ BSTR __RPC_FAR *aString, + /* [out] */ float __RPC_FAR *aFloat, + /* [out] */ double __RPC_FAR *aDouble, + /* [out] */ unsigned char __RPC_FAR *aByte, + /* [out] */ short __RPC_FAR *aShort, + /* [out] */ long __RPC_FAR *aLong) +//) +{ +// if( ! ppdisp || ! ppSimpleStruct || ! aSimpleEnum || +// ! outSeq || !varAny ||! aBool || ! aChar || +// ! aString || ! aFloat || ! aDouble || ! aByte || +// ! aShort || ! aLong || ! aUShort || ! aULong) +// return E_POINTER; + + HRESULT hr=S_OK; + hr= outInterface( ppdisp); + hr= outStruct( ppSimpleStruct); + hr= outEnum( aSimpleEnum); + hr= outSeqAny( outSeq); + hr= outAny( varAny); + hr= outBool( aBool); + hr= outChar( aChar); + hr= outString( aString); + hr= outFloat( aFloat); + hr= outDouble( aDouble); + hr= outByte( aByte); + hr= outShort( aShort); + hr= outLong( aLong); + return hr; +} + +STDMETHODIMP CCallback::outStruct(IDispatch **outStruct) +{ +// return S_OK; + if( !outStruct) + return E_POINTER; + HRESULT hr= E_FAIL; +// MessageBox( NULL, _T("CCallback::outStruct"), _T(""), MB_OK); + + CComPtr _dispMgr; + if( SUCCEEDED(hr= _dispMgr.CoCreateInstance(L"com.sun.star.ServiceManager"))) + { + CComDispatchDriver manager( _dispMgr); + CComVariant param1(L"com.sun.star.reflection.CoreReflection"); + CComVariant varRet; + hr= manager.Invoke1( L"createInstance", ¶m1, &varRet); + + CComDispatchDriver reflection( varRet.pdispVal); + param1= L"oletest.SimpleStruct"; + varRet.Clear(); + hr= reflection.Invoke1( L"forName", ¶m1, &varRet); + + CComDispatchDriver classSimpleStruct( varRet.pdispVal); + + CComPtr dispStruct; + param1.vt= VT_DISPATCH | VT_BYREF; + param1.ppdispVal= &dispStruct; + if( SUCCEEDED( hr= classSimpleStruct.Invoke1(L"createObject", ¶m1))) + { + // Set the value + CComDispatchDriver simpleStruct( dispStruct); + param1=L" this is a property string"; + hr= simpleStruct.PutPropertyByName(L"message", ¶m1); + *outStruct= dispStruct; + (*outStruct)->AddRef(); + hr= S_OK; + } + } + return hr; +} + +STDMETHODIMP CCallback::outEnum(long *outEnum) +{ + if( !outEnum) + return E_POINTER; + *outEnum= 1; + return S_OK; +} + +STDMETHODIMP CCallback::outSeqAny(LPSAFEARRAY* outSeq) +{ +// _CrtDbgBreak(); + SAFEARRAY* pArr= SafeArrayCreateVector( VT_VARIANT, 0, 3); + CComVariant var[3]; + var[0]=L" variant 0"; + var[1]=L" variant 1"; + var[2]=L"variant 2"; + for( long i=0; i<3; i++) + { + SafeArrayPutElement( pArr, &i, (void*)&var[i]); + } + + *outSeq= pArr; + return S_OK; +} + +// ATLASSERT //VT_EMPTY + + +STDMETHODIMP CCallback::outAny(VARIANT *outAny) +{ + if( ! outAny) + return E_POINTER; + outAny->vt= VT_BSTR; + outAny->bstrVal= SysAllocString( L"This is a string in a VARIANT"); + + return S_OK; +} + +STDMETHODIMP CCallback::outBool(VARIANT_BOOL *outBool) +{ + if( ! outBool) + return E_POINTER; + *outBool= VARIANT_TRUE; + return S_OK; +} + +STDMETHODIMP CCallback::outChar(short *outChar) +{ + if( !outChar) + return E_POINTER; + *outChar= (short)L'A'; + return S_OK; +} + +STDMETHODIMP CCallback::outString(BSTR *outString) +{ + if( !outString) + return E_POINTER; + *outString= SysAllocString(L"This is a BSTR"); + return S_OK; +} + +STDMETHODIMP CCallback::outFloat(float *outFloat) +{ + if( !outFloat) + return E_POINTER; + *outFloat= 3.14f; + return S_OK; +} + +STDMETHODIMP CCallback::outDouble(double *outDouble) +{ + if(!outDouble) + return E_POINTER; + + *outDouble= 3.145; + return S_OK; +} + + + +STDMETHODIMP CCallback::outShort(short *outShort) +{ + if(!outShort) + return E_POINTER; + *outShort= -1; + return S_OK; +} + +STDMETHODIMP CCallback::outLong(long *outLong) +{ + if(!outLong) + return E_POINTER; + *outLong= 0xffffffff; + return S_OK; +} + + + +STDMETHODIMP CCallback::outByte(unsigned char* outByte) +{ + if(!outByte) + return E_POINTER; + *outByte= 0xff; + return S_OK; +} + +STDMETHODIMP CCallback::inoutInterface(IDispatch **ppdisp) +{ + if( !ppdisp) + return E_POINTER; + CComDispatchDriver disp( *ppdisp); + CComVariant param1(L""); + disp.Invoke1(L"func", ¶m1); + + (*ppdisp)->Release(); + + CComPtr outDisp; + outDisp.CoCreateInstance( L"XCallback_Impl.Simple"); + *ppdisp= outDisp; + (*ppdisp)->AddRef(); + + return S_OK; +} + +STDMETHODIMP CCallback::inoutStruct(IDispatch **inoutVal) +{ + if( !inoutVal) + return E_POINTER; + HRESULT hr= S_OK; + USES_CONVERSION; + CComVariant var; + CComDispatchDriver disp( *inoutVal); + + hr= disp.GetPropertyByName(L"message", &var); + MessageBox( NULL, W2T(var.bstrVal), _T("XCallback_Impl.Callback"), MB_OK); + + (*inoutVal)->Release(); + + CComDispatchDriver dispStruct; + hr= outStruct( &dispStruct.p); + var.Clear(); + var= L"This struct was created in XCallback_Imp.Callback"; + hr= dispStruct.PutPropertyByName(L"message", &var); + + *inoutVal= dispStruct; + (*inoutVal)->AddRef(); + return hr; +} + +STDMETHODIMP CCallback::inoutEnum(long *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal= *inoutVal+1; + + return S_OK; +} + +STDMETHODIMP CCallback::inoutSeqAny(LPSAFEARRAY *pArray) +{ + if( !pArray) + return E_POINTER; + HRESULT hr= S_OK; + long lbound=0; + long ubound=0; + hr= SafeArrayGetLBound( *pArray, 1, &lbound); + hr= SafeArrayGetUBound( *pArray, 1, &ubound); + long count= ubound - lbound + 1; + + // the Array is supposet to contain variants + CComVariant var; + for( long i=0; ivt= VT_BSTR) + MessageBox( NULL, W2T( inoutVal->bstrVal), _T("XCallback_Impl.Callback"), MB_OK); + + VariantClear( inoutVal); + inoutVal->vt= VT_BSTR; + inoutVal->bstrVal=SysAllocString( L" [string] XCallback_Impl.Callback inoutAny"); + return S_OK; +} + +STDMETHODIMP CCallback::inoutBool(VARIANT_BOOL *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + + *inoutVal= *inoutVal == VARIANT_TRUE ? VARIANT_FALSE : VARIANT_TRUE; + return S_OK; +} + +STDMETHODIMP CCallback::inoutChar(short *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + USES_CONVERSION; + char buff[256]; + sprintf( buff, "character value: %C", *inoutVal); + MessageBox( NULL, A2T(buff), _T("XCallback_Impl.Callback"), MB_OK); + *inoutVal= L'B'; + return S_OK; +} + +STDMETHODIMP CCallback::inoutString(BSTR *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + USES_CONVERSION; + MessageBox( NULL, W2T(*inoutVal), _T("XCallback_Impl.Callback"), MB_OK); + SysFreeString(*inoutVal); + *inoutVal= SysAllocString(L"a string from XCallback_Impl.Callback"); + + return S_OK; +} + +STDMETHODIMP CCallback::inoutFloat(float *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal = *inoutVal+1; + return S_OK; +} + +STDMETHODIMP CCallback::inoutDouble(double *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal= *inoutVal+1; + return S_OK; +} + +STDMETHODIMP CCallback::inoutByte(unsigned char *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal= 0xff; + return S_OK; +} + +STDMETHODIMP CCallback::inoutShort(short *inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal= -1; + return S_OK; +} + +STDMETHODIMP CCallback::inoutLong(long* inoutVal) +{ + if( !inoutVal) + return E_POINTER; + *inoutVal= 0xffffffff; + return S_OK; +} + +STDMETHODIMP CCallback::inoutValuesAll( + /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aXSimple, + /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aStruct, + /* [out][in] */ long __RPC_FAR *aEnum, + /* [out][in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *aSeq, + /* [out][in] */ VARIANT __RPC_FAR *aAny, + /* [out][in] */ VARIANT_BOOL __RPC_FAR *aBool, + /* [out][in] */ short __RPC_FAR *aChar, + /* [out][in] */ BSTR __RPC_FAR *aString, + /* [out][in] */ float __RPC_FAR *aFloat, + /* [out][in] */ double __RPC_FAR *aDouble, + /* [out][in] */ unsigned char __RPC_FAR *aByte, + /* [out][in] */ short __RPC_FAR *aShort, + /* [out][in] */ long __RPC_FAR *aLong) +{ + inoutInterface( aXSimple); + inoutStruct( aStruct); + inoutEnum( aEnum); + inoutSeqAny( aSeq); + inoutAny( aAny); + inoutBool( aBool); + inoutChar( aChar); + inoutString( aString); + inoutFloat( aFloat); + inoutDouble( aDouble); + inoutByte( aByte); + inoutShort( aShort); + inoutLong( aLong); + + return S_OK; +} + + +STDMETHODIMP CCallback::inValues(short aChar, long aLong, BSTR aString) +{ + USES_CONVERSION; + wchar_t _char= (wchar_t) aChar; + char buff[1024]; + sprintf( buff, "Parameters: char= %C, long= %d, string= %s", _char, aLong, W2A(aString)); + MessageBox( NULL, A2T(buff), _T("XCallback_Impl.Callback"), MB_OK); + return S_OK; +} + +STDMETHODIMP CCallback::outSeqByte(LPSAFEARRAY * outVal) +{ + // TODO: Add your implementation code here + + return S_OK; +} + +STDMETHODIMP CCallback::inSeqByte( LPSAFEARRAY listeners) +{ + + return S_OK; +} + +STDMETHODIMP CCallback::inSeqXEventListener( LPSAFEARRAY listeners, LPSAFEARRAY events) +{ + HRESULT hr= S_OK; + long ubound= 0; + long lbound= 0; + long count= 0; + hr= SafeArrayGetUBound( listeners, 1, &ubound); + hr= SafeArrayGetLBound( listeners, 1, &lbound); + count= ubound - lbound +1; + + // We assume that the count of EventObjects in events is the same + for( long i = 0; i < count; i++) + { + CComVariant varListener; + CComVariant varEvent; + hr= SafeArrayGetElement( listeners, &i, &varListener); + hr= SafeArrayGetElement( events, &i, &varEvent); + if( varListener.vt == VT_DISPATCH && varEvent.vt == VT_DISPATCH) + { + CComDispatchDriver disp( varListener.pdispVal); + hr= disp.Invoke1(L"disposing", &varEvent); + } + + } + + return S_OK; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.h b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.h new file mode 100644 index 000000000..810c1a896 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.h @@ -0,0 +1,129 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// Callback.h : Declaration of the CCallback + +#ifndef INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_CALLBACK_H +#define INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_CALLBACK_H + +#include "resource.h" + + +// CCallback +class ATL_NO_VTABLE CCallback : + public CComObjectRootEx, + public CComCoClass, + public IDispatchImpl +{ +public: + CCallback() + { + } + +DECLARE_REGISTRY_RESOURCEID(IDR_CALLBACK) + +DECLARE_PROTECT_FINAL_CONSTRUCT() + +BEGIN_COM_MAP(CCallback) + COM_INTERFACE_ENTRY(ICallback) + COM_INTERFACE_ENTRY(IDispatch) +END_COM_MAP() + +// ICallback +public: + STDMETHOD(inSeqByte)(/*[in]*/ LPSAFEARRAY val); + STDMETHOD(inSeqXEventListener)(/*[in]*/ LPSAFEARRAY listener, LPSAFEARRAY event); + STDMETHOD(outSeqByte)(/*[out]*/ LPSAFEARRAY* outVal); + STDMETHOD(inValues)(/*[in]*/short aChar, /*[in]*/ long aLong, /*[in]*/ BSTR aString); + STDMETHOD(inoutLong)(/*[in,out]*/ long* inoutVal); + STDMETHOD(inoutShort)(/*[in,out]*/ short* inoutVal); + STDMETHOD(inoutByte)(/*[in,out]*/ unsigned char* inoutVal); + STDMETHOD(inoutDouble)(/*[in,out]*/ double* inoutVal); + STDMETHOD(inoutFloat)(/*[in,out]*/ float* inoutVal); + STDMETHOD(inoutString)(/*[in,out]*/ BSTR *inoutVal); + STDMETHOD(inoutChar)(/*[in,out]*/ short* inoutVal); + STDMETHOD(inoutBool)(/*[in,out]*/ VARIANT_BOOL * inoutVal); + STDMETHOD(inoutAny)(/*[in,out]*/ VARIANT* inoutVal); + STDMETHOD(inoutSeqAny)(/*[in,out]*/ LPSAFEARRAY* pArray); + STDMETHOD(inoutEnum)(/*[in,out]*/ long * inoutVal); + STDMETHOD(inoutStruct)(/*[in,out]*/ IDispatch** inoutVal); + STDMETHOD(inoutInterface)(/*[in,out]*/ IDispatch** ppdisp); + STDMETHOD(inoutValuesAll)( + /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aXSimple, + /* [out][in] */ IDispatch __RPC_FAR *__RPC_FAR *aStruct, + /* [out][in] */ long __RPC_FAR *aEnum, + /* [out][in] */ SAFEARRAY __RPC_FAR * __RPC_FAR *aSeq, + /* [out][in] */ VARIANT __RPC_FAR *aAny, + /* [out][in] */ VARIANT_BOOL __RPC_FAR *aBool, + /* [out][in] */ short __RPC_FAR *aChar, + /* [out][in] */ BSTR __RPC_FAR *aString, + /* [out][in] */ float __RPC_FAR *aFloat, + /* [out][in] */ double __RPC_FAR *aDouble, + /* [out][in] */ unsigned char __RPC_FAR *aByte, + /* [out][in] */ short __RPC_FAR *aShort, + /* [out][in] */ long __RPC_FAR *aLong); + + STDMETHOD(outByte)( unsigned char* outByte); + STDMETHOD(outLong)(/*[out]*/ long* outLong); + STDMETHOD(outShort)(/*[out]*/ short *outShort); + STDMETHOD(outDouble)(/*[out]*/ double* outDouble); + STDMETHOD(outFloat)(/*[out]*/ float* outFloat); + STDMETHOD(outString)(/*[out]*/ BSTR * outString); + STDMETHOD(outChar)(short* outChar); + STDMETHOD(outBool)(VARIANT_BOOL* outBool); + STDMETHOD(outAny)(VARIANT* outAny); + STDMETHOD(outSeqAny)(/*[out]*/LPSAFEARRAY* outSeq); + STDMETHOD(outEnum)(/*[out]*/ long* outEnum); + STDMETHOD(outStruct)(/*[out]*/ IDispatch** outStruct); + virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE outValuesAll( + /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppdisp, + /* [out] */ IDispatch __RPC_FAR *__RPC_FAR *ppSimpleStruct, + /* [out] */ long __RPC_FAR *aSimpleEnum, + /* [out] */ LPSAFEARRAY* outSeq, + /* [out] */ VARIANT __RPC_FAR *varAny, + /* [out] */ VARIANT_BOOL __RPC_FAR *aBool, + /* [out] */ short __RPC_FAR *aChar, + /* [out] */ BSTR __RPC_FAR *aString, + /* [out] */ float __RPC_FAR *aFloat, + /* [out] */ double __RPC_FAR *aDouble, + /* [out] */ unsigned char __RPC_FAR *aByte, + /* [out] */ short __RPC_FAR *aShort, + /* [out] */ long __RPC_FAR *aLong); +// ); + +// STDMETHOD(outValuesAll)( +// /*[out]*/ IDispatch** ppdisp, +// /*[out]*/ IUnknown** ppSimpleStruct, +// /*[out]*/ long* aSimpleEnum, +// /*[out]*/ VARIANT* ArrayAny, +// /*[out]*/ VARIANT* varAny, +// /*[out]*/ VARIANT_BOOL * aBool, +// /*[out]*/ unsigned short* aChar, +// /*[out]*/ BSTR* aString, /*[out]*/ float* aFloat, +// /*[out]*/ double* aDouble, +// /*[out]*/ signed char* aByte, /*[out]*/ short* aShort, /*[out]*/long* aLong, /*[out]*/ unsigned short* aUShort, /*[out]*/ unsigned long* aULong); + STDMETHOD(outValuesMixed)(/*[in]*/ long val, /*[out]*/ long* pval, /*[in]*/ BSTR string); + STDMETHOD(outInterface)(/*[out]*/ IDispatch** ppdisp); + STDMETHOD(returnInterface)(/*[out, retval]*/ IDispatch** ppdisp); + STDMETHOD(func1)(); +}; + +#endif // INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_CALLBACK_H + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.rgs b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.rgs new file mode 100644 index 000000000..b3f9e071b --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Callback.rgs @@ -0,0 +1,27 @@ +HKCR +{ + XCallback_Impl.Callback.1 = s 'Callback Class' + { + CLSID = s '{180FF560-6F5C-11D4-8330-005004526AB4}' + } + XCallback_Impl.Callback = s 'Callback Class' + { + CLSID = s '{180FF560-6F5C-11D4-8330-005004526AB4}' + CurVer = s 'XCallback_Impl.Callback.1' + } + NoRemove CLSID + { + ForceRemove {180FF560-6F5C-11D4-8330-005004526AB4} = s 'Callback Class' + { + ProgID = s 'XCallback_Impl.Callback.1' + VersionIndependentProgID = s 'XCallback_Impl.Callback' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{180FF553-6F5C-11D4-8330-005004526AB4}' + } + } +} + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.cpp b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.cpp new file mode 100644 index 000000000..5b7183cdb --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.cpp @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// Simple.cpp : Implementation of CSimple +#include "stdafx.h" +#include "XCallback_Impl.h" +#include "Simple.h" + + +// CSimple + + +STDMETHODIMP CSimple::func(BSTR message) +{ + USES_CONVERSION; + MessageBox( NULL, W2T( message), _T("XCallback_Impl.Simple"), MB_OK); + return S_OK; +} + + +STDMETHODIMP CSimple::func2(BSTR message) +{ + USES_CONVERSION; + MessageBox( NULL, W2T( message), _T("XCallback_Impl.Simple"), MB_OK); + return S_OK; +} + +STDMETHODIMP CSimple::func3(BSTR message) +{ + USES_CONVERSION; + MessageBox( NULL, W2T( message), _T("XCallback_Impl.Simple"), MB_OK); + return S_OK; +} + + +STDMETHODIMP CSimple::get__implementedInterfaces(LPSAFEARRAY *pVal) +{ + HRESULT hr= S_OK; + SAFEARRAY *pArr= SafeArrayCreateVector( VT_BSTR, 0, 3); + if( pArr) + { long index=0; + BSTR name1= SysAllocString(L"oletest.XSimple"); + BSTR name2= SysAllocString(L"oletest.XSimple2"); + BSTR name3= SysAllocString(L"oletest.XSimple3"); + + hr= SafeArrayPutElement( pArr, & index, name1); + index++; + hr|= SafeArrayPutElement( pArr, &index, name2); + index++; + hr|= SafeArrayPutElement( pArr, &index, name3); + *pVal= pArr; + + } + *pVal= pArr; + return hr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.h b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.h new file mode 100644 index 000000000..cf140245e --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.h @@ -0,0 +1,58 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// Simple.h : Declaration of the CSimple + +#ifndef INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_SIMPLE_H +#define INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_SIMPLE_H + +#include "resource.h" + + +// CSimple +class ATL_NO_VTABLE CSimple : + public CComObjectRootEx, + public CComCoClass, + public IDispatchImpl +{ +public: + CSimple() + { + } + +DECLARE_REGISTRY_RESOURCEID(IDR_SIMPLE) + +DECLARE_PROTECT_FINAL_CONSTRUCT() + +BEGIN_COM_MAP(CSimple) + COM_INTERFACE_ENTRY(ISimple) + COM_INTERFACE_ENTRY(IDispatch) +END_COM_MAP() + +// ISimple +public: + + STDMETHOD(get__implementedInterfaces)(/*[out, retval]*/ LPSAFEARRAY *pVal); + STDMETHOD(func3)(/*[in]*/ BSTR message); + STDMETHOD(func2)(/*[in]*/ BSTR message); + STDMETHOD(func)( BSTR message); +}; + +#endif // INCLUDED_EXTENSIONS_TEST_OLE_UNOTOCOMCALLS_XCALLBACK_IMPL_SIMPLE_H + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.rgs b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.rgs new file mode 100644 index 000000000..19237bf36 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/Simple.rgs @@ -0,0 +1,27 @@ +HKCR +{ + XCallback_Impl.Simple.1 = s 'Simple Class' + { + CLSID = s '{180FF565-6F5C-11D4-8330-005004526AB4}' + } + XCallback_Impl.Simple = s 'Simple Class' + { + CLSID = s '{180FF565-6F5C-11D4-8330-005004526AB4}' + CurVer = s 'XCallback_Impl.Simple.1' + } + NoRemove CLSID + { + ForceRemove {180FF565-6F5C-11D4-8330-005004526AB4} = s 'Simple Class' + { + ProgID = s 'XCallback_Impl.Simple.1' + VersionIndependentProgID = s 'XCallback_Impl.Simple' + ForceRemove 'Programmable' + InprocServer32 = s '%MODULE%' + { + val ThreadingModel = s 'Apartment' + } + 'TypeLib' = s '{180FF553-6F5C-11D4-8330-005004526AB4}' + } + } +} + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.cpp b/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.cpp new file mode 100644 index 000000000..da0608bfd --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.cpp @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// stdafx.cpp : source file that includes just the standard includes +// stdafx.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +#ifdef _ATL_STATIC_REGISTRY +#include +#include +#endif + +#include + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.h b/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.h new file mode 100644 index 000000000..678114bae --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/StdAfx.h @@ -0,0 +1,45 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, +// but are changed infrequently + +#if !defined(AFX_STDAFX_H__180FF556_6F5C_11D4_8330_005004526AB4__INCLUDED_) +#define AFX_STDAFX_H__180FF556_6F5C_11D4_8330_005004526AB4__INCLUDED_ + +#ifdef _MSC_VER +#pragma once +#endif + +#define STRICT +#define _ATL_APARTMENT_THREADED + +#include +#include +//You may derive a class from CComModule and use it if you want to override +//something, but do not change the name of _Module +extern CComModule _Module; +#include + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__180FF556_6F5C_11D4_8330_005004526AB4__INCLUDED) + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.cpp b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.cpp new file mode 100644 index 000000000..2d44a5937 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.cpp @@ -0,0 +1,94 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// XCallback_Impl.cpp : Implementation of DLL Exports. + + +// Note: Proxy/Stub Information +// To build a separate proxy/stub DLL, +// run nmake -f XCallback_Implps.mk in the project directory. + +#include "stdafx.h" +#include "resource.h" +#include +#include "XCallback_Impl.h" + +#include "XCallback_Impl_i.c" +#include "Callback.h" +#include "Simple.h" + + +CComModule _Module; + +BEGIN_OBJECT_MAP(ObjectMap) +OBJECT_ENTRY(CLSID_Callback, CCallback) +OBJECT_ENTRY(CLSID_Simple, CSimple) +END_OBJECT_MAP() + + +// DLL Entry Point + +extern "C" +BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) +{ + if (dwReason == DLL_PROCESS_ATTACH) + { + _Module.Init(ObjectMap, hInstance, &LIBID_XCALLBACK_IMPLLib); + DisableThreadLibraryCalls(hInstance); + } + else if (dwReason == DLL_PROCESS_DETACH) + _Module.Term(); + return TRUE; // ok +} + + +// Used to determine whether the DLL can be unloaded by OLE + +STDAPI DllCanUnloadNow(void) +{ + return (_Module.GetLockCount()==0) ? S_OK : S_FALSE; +} + + +// Returns a class factory to create an object of the requested type + +STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv) +{ + return _Module.GetClassObject(rclsid, riid, ppv); +} + + +// DllRegisterServer - Adds entries to the system registry + +STDAPI DllRegisterServer(void) +{ + // registers object, typelib and all interfaces in typelib + return _Module.RegisterServer(TRUE); +} + + +// DllUnregisterServer - Removes entries from the system registry + +STDAPI DllUnregisterServer(void) +{ + return _Module.UnregisterServer(TRUE); +} + + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.def b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.def new file mode 100644 index 000000000..b2d5e9627 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.def @@ -0,0 +1,10 @@ +; XCallback_Impl.def : Declares the module parameters. + +LIBRARY "XCallback_Impl.DLL" + +EXPORTS + DllCanUnloadNow PRIVATE + DllGetClassObject PRIVATE + DllRegisterServer PRIVATE + DllUnregisterServer PRIVATE + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.dsp b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.dsp new file mode 100644 index 000000000..6897d0d81 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.dsp @@ -0,0 +1,337 @@ +# Microsoft Developer Studio Project File - Name="XCallback_Impl" - Package Owner=<4> +# Microsoft Developer Studio Generated Build File, Format Version 6.00 +# ** DO NOT EDIT ** + +# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102 + +CFG=XCallback_Impl - Win32 Debug +!MESSAGE This is not a valid makefile. To build this project using NMAKE, +!MESSAGE use the Export Makefile command and run +!MESSAGE +!MESSAGE NMAKE /f "XCallback_Impl.mak". +!MESSAGE +!MESSAGE You can specify a configuration when running NMAKE +!MESSAGE by defining the macro CFG on the command line. For example: +!MESSAGE +!MESSAGE NMAKE /f "XCallback_Impl.mak" CFG="XCallback_Impl - Win32 Debug" +!MESSAGE +!MESSAGE Possible choices for configuration are: +!MESSAGE +!MESSAGE "XCallback_Impl - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "XCallback_Impl - Win32 Unicode Debug" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "XCallback_Impl - Win32 Release MinSize" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "XCallback_Impl - Win32 Release MinDependency" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "XCallback_Impl - Win32 Unicode Release MinSize" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE "XCallback_Impl - Win32 Unicode Release MinDependency" (based on "Win32 (x86) Dynamic-Link Library") +!MESSAGE + +# Begin Project +# PROP AllowPerConfigDependencies 0 +# PROP Scc_ProjName "" +# PROP Scc_LocalPath "" +CPP=cl.exe +MTL=midl.exe +RSC=rc.exe + +!IF "$(CFG)" == "XCallback_Impl - Win32 Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "Debug" +# PROP BASE Intermediate_Dir "Debug" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "Debug" +# PROP Intermediate_Dir "Debug" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MTd /W3 /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MTd /W3 /Gm /ZI /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /FR /Yu"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept +# Begin Custom Build - Performing registration +OutDir=.\Debug +TargetPath=.\Debug\XCallback_Impl.dll +InputPath=.\Debug\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + +# End Custom Build + +!ELSEIF "$(CFG)" == "XCallback_Impl - Win32 Unicode Debug" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 1 +# PROP BASE Output_Dir "DebugU" +# PROP BASE Intermediate_Dir "DebugU" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 1 +# PROP Output_Dir "DebugU" +# PROP Intermediate_Dir "DebugU" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MTd /W3 /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /Yu"stdafx.h" /FD /GZ /c +# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /Yu"stdafx.h" /FD /GZ /c +# ADD BASE RSC /l 0x409 /d "_DEBUG" +# ADD RSC /l 0x409 /d "_DEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /debug /machine:I386 /pdbtype:sept +# Begin Custom Build - Performing registration +OutDir=.\DebugU +TargetPath=.\DebugU\XCallback_Impl.dll +InputPath=.\DebugU\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + if "%OS%"=="" goto NOTNT + if not "%OS%"=="Windows_NT" goto NOTNT + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + goto end + :NOTNT + echo Warning : Cannot register Unicode DLL on Windows 95 + :end + +# End Custom Build + +!ELSEIF "$(CFG)" == "XCallback_Impl - Win32 Release MinSize" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "ReleaseMinSize" +# PROP BASE Intermediate_Dir "ReleaseMinSize" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "ReleaseMinSize" +# PROP Intermediate_Dir "ReleaseMinSize" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "_ATL_DLL" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "_ATL_DLL" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# Begin Custom Build - Performing registration +OutDir=.\ReleaseMinSize +TargetPath=.\ReleaseMinSize\XCallback_Impl.dll +InputPath=.\ReleaseMinSize\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + +# End Custom Build + +!ELSEIF "$(CFG)" == "XCallback_Impl - Win32 Release MinDependency" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "ReleaseMinDependency" +# PROP BASE Intermediate_Dir "ReleaseMinDependency" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "ReleaseMinDependency" +# PROP Intermediate_Dir "ReleaseMinDependency" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "_ATL_STATIC_REGISTRY" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "_ATL_STATIC_REGISTRY" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# Begin Custom Build - Performing registration +OutDir=.\ReleaseMinDependency +TargetPath=.\ReleaseMinDependency\XCallback_Impl.dll +InputPath=.\ReleaseMinDependency\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + +# End Custom Build + +!ELSEIF "$(CFG)" == "XCallback_Impl - Win32 Unicode Release MinSize" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "ReleaseUMinSize" +# PROP BASE Intermediate_Dir "ReleaseUMinSize" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "ReleaseUMinSize" +# PROP Intermediate_Dir "ReleaseUMinSize" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /D "_ATL_DLL" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /D "_ATL_DLL" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# Begin Custom Build - Performing registration +OutDir=.\ReleaseUMinSize +TargetPath=.\ReleaseUMinSize\XCallback_Impl.dll +InputPath=.\ReleaseUMinSize\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + if "%OS%"=="" goto NOTNT + if not "%OS%"=="Windows_NT" goto NOTNT + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + goto end + :NOTNT + echo Warning : Cannot register Unicode DLL on Windows 95 + :end + +# End Custom Build + +!ELSEIF "$(CFG)" == "XCallback_Impl - Win32 Unicode Release MinDependency" + +# PROP BASE Use_MFC 0 +# PROP BASE Use_Debug_Libraries 0 +# PROP BASE Output_Dir "ReleaseUMinDependency" +# PROP BASE Intermediate_Dir "ReleaseUMinDependency" +# PROP BASE Target_Dir "" +# PROP Use_MFC 0 +# PROP Use_Debug_Libraries 0 +# PROP Output_Dir "ReleaseUMinDependency" +# PROP Intermediate_Dir "ReleaseUMinDependency" +# PROP Target_Dir "" +# ADD BASE CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /D "_ATL_STATIC_REGISTRY" /D "_ATL_MIN_CRT" /Yu"stdafx.h" /FD /c +# ADD CPP /nologo /MT /W3 /O1 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_USRDLL" /D "_UNICODE" /D "_ATL_STATIC_REGISTRY" /Yu"stdafx.h" /FD /c +# ADD BASE RSC /l 0x409 /d "NDEBUG" +# ADD RSC /l 0x409 /d "NDEBUG" +BSC32=bscmake.exe +# ADD BASE BSC32 /nologo +# ADD BSC32 /nologo +LINK32=link.exe +# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:windows /dll /machine:I386 +# Begin Custom Build - Performing registration +OutDir=.\ReleaseUMinDependency +TargetPath=.\ReleaseUMinDependency\XCallback_Impl.dll +InputPath=.\ReleaseUMinDependency\XCallback_Impl.dll +SOURCE="$(InputPath)" + +"$(OutDir)\regsvr32.trg" : $(SOURCE) "$(INTDIR)" "$(OUTDIR)" + if "%OS%"=="" goto NOTNT + if not "%OS%"=="Windows_NT" goto NOTNT + regsvr32 /s /c "$(TargetPath)" + echo regsvr32 exec. time > "$(OutDir)\regsvr32.trg" + goto end + :NOTNT + echo Warning : Cannot register Unicode DLL on Windows 95 + :end + +# End Custom Build + +!ENDIF + +# Begin Target + +# Name "XCallback_Impl - Win32 Debug" +# Name "XCallback_Impl - Win32 Unicode Debug" +# Name "XCallback_Impl - Win32 Release MinSize" +# Name "XCallback_Impl - Win32 Release MinDependency" +# Name "XCallback_Impl - Win32 Unicode Release MinSize" +# Name "XCallback_Impl - Win32 Unicode Release MinDependency" +# Begin Group "Source Files" + +# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" +# Begin Source File + +SOURCE=.\Callback.cpp +# End Source File +# Begin Source File + +SOURCE=.\Simple.cpp +# End Source File +# Begin Source File + +SOURCE=.\StdAfx.cpp +# ADD CPP /Yc"stdafx.h" +# End Source File +# Begin Source File + +SOURCE=.\XCallback_Impl.cpp +# End Source File +# Begin Source File + +SOURCE=.\XCallback_Impl.def +# End Source File +# Begin Source File + +SOURCE=.\XCallback_Impl.idl +# ADD MTL /tlb ".\XCallback_Impl.tlb" /h "XCallback_Impl.h" /iid "XCallback_Impl_i.c" /Oicf +# End Source File +# Begin Source File + +SOURCE=.\XCallback_Impl.rc +# End Source File +# End Group +# Begin Group "Header Files" + +# PROP Default_Filter "h;hpp;hxx;hm;inl" +# Begin Source File + +SOURCE=.\Callback.h +# End Source File +# Begin Source File + +SOURCE=.\Resource.h +# End Source File +# Begin Source File + +SOURCE=.\Simple.h +# End Source File +# Begin Source File + +SOURCE=.\StdAfx.h +# End Source File +# End Group +# Begin Group "Resource Files" + +# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" +# Begin Source File + +SOURCE=.\Callback.rgs +# End Source File +# Begin Source File + +SOURCE=.\Simple.rgs +# End Source File +# End Group +# End Target +# End Project + + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.idl b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.idl new file mode 100644 index 000000000..de56aac45 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.idl @@ -0,0 +1,144 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +// XCallback_Impl.idl : IDL source for XCallback_Impl.dll + + +// This file will be processed by the MIDL tool to +// produce the type library (XCallback_Impl.tlb) and marshalling code. + +import "oaidl.idl"; +import "ocidl.idl"; + [ + object, + uuid(180FF55F-6F5C-11D4-8330-005004526AB4), + dual, + helpstring("ICallback Interface"), + pointer_default(unique) + ] + interface ICallback : IDispatch + { + [id(1), helpstring("method func1")] HRESULT func1(); + [id(2), helpstring("method returnInterface")] HRESULT returnInterface([out, retval] IDispatch** ppdisp); + [id(3), helpstring("method outInterface")] HRESULT outInterface([out] IDispatch** ppdisp); + [id(4), helpstring("method outValuesMixed")] HRESULT outValuesMixed([in] long val, [out] long* pval, [in] BSTR string); + [id(5), helpstring("method outValuesAll")] HRESULT outValuesAll([out] IDispatch** ppdisp, [out] IDispatch** ppSimpleStruct, [out] long* aSimpleEnum, + [out] SAFEARRAY( VARIANT)* outSeq, + [out] VARIANT* varAny, + [out] VARIANT_BOOL * aBool, + [out] short* aChar, + [out] BSTR* aString , + [out] float* aFloat, + [out] double* aDouble, + [out] unsigned char* aByte, + [out] short* aShort, + [out]long* aLong); +// ); + [id(6), helpstring("method outStruct")] HRESULT outStruct([out] IDispatch** outStruct); + [id(7), helpstring("method outEnum")] HRESULT outEnum([out] long* outEnum); + [id(8), helpstring("method outSeqAny")] HRESULT outSeqAny([out] SAFEARRAY( VARIANT)* outSeq); + [id(9), helpstring("method outAny")] HRESULT outAny([out] VARIANT* outAny); + [id(10), helpstring("method outBool")] HRESULT outBool([out]VARIANT_BOOL* outBool); + [id(11), helpstring("method outChar")] HRESULT outChar([out] short* outChar); + [id(12), helpstring("method outString")] HRESULT outString([out] BSTR * outString); + [id(13), helpstring("method outFloat")] HRESULT outFloat([out] float* outFloat); + [id(14), helpstring("method outDouble")] HRESULT outDouble([out] double* outDouble); + [id(16), helpstring("method outShort")] HRESULT outShort([out] short *outShort); + [id(17), helpstring("method outLong")] HRESULT outLong([out] long* outLong); + [id(20), helpstring("method outByte")] HRESULT outByte([out] unsigned char* outByte); + [id(21), helpstring("method inoutInterface")] HRESULT inoutInterface([in,out] IDispatch** ppdisp); + [id(22), helpstring("method inoutStruct")] HRESULT inoutStruct([in,out] IDispatch** inoutVal); + [id(23), helpstring("method inoutEnum")] HRESULT inoutEnum([in,out] long * inoutVal); + [id(24), helpstring("method inoutSeqAny")] HRESULT inoutSeqAny([in,out] SAFEARRAY(VARIANT)* pArray); + [id(25), helpstring("method inoutAny")] HRESULT inoutAny([in,out] VARIANT* inoutVal); + [id(26), helpstring("method inoutBool")] HRESULT inoutBool([in,out] VARIANT_BOOL * inoutVal); + [id(27), helpstring("method inoutChar")] HRESULT inoutChar([in,out] short* inoutVal); + [id(28), helpstring("method inoutString")] HRESULT inoutString([in,out] BSTR *inoutVal); + [id(29), helpstring("method inoutFloat")] HRESULT inoutFloat([in,out] float* inoutVal); + [id(30), helpstring("method inoutDouble")] HRESULT inoutDouble([in,out] double* inoutVal); + [id(31), helpstring("method inoutByte")] HRESULT inoutByte([in,out] unsigned char* inoutVal); + [id(32), helpstring("method inoutShort")] HRESULT inoutShort([in,out] short* inoutVal); + [id(33), helpstring("method inoutLong")] HRESULT inoutLong([in,out] long* inoutVal); + [id(34), helpstring("method inoutValueAll")] HRESULT inoutValuesAll( + [in,out] IDispatch** aXSimple, + [in,out] IDispatch** aStruct, + [in,out] long* aEnum, + [in,out] SAFEARRAY( VARIANT)* aSeq, + [in,out] VARIANT* aAny, + [in,out] VARIANT_BOOL* aBool, + [in,out] short* aChar, + [in,out] BSTR* aString, + [in,out] float* aFloat, + [in,out] double* aDouble, + [in,out] unsigned char* aByte, + [in,out] short* aShort, + [in,out] long* aLong); + [id(35), helpstring("method inValues")] HRESULT inValues([in]short aChar, [in] long aLong, [in] BSTR aString); + [id(36), helpstring("method outSeqByte")] HRESULT outSeqByte([out] SAFEARRAY(unsigned char)* outVal); + [id(37), helpstring("method inSeqByte")] HRESULT inSeqByte([in] SAFEARRAY(VARIANT) val); + [id(38), helpstring("method inSeqXEventListener")] HRESULT inSeqXEventListener([in] SAFEARRAY(VARIANT) listener, + [in] SAFEARRAY(VARIANT) event); + + }; + [ + object, + uuid(180FF564-6F5C-11D4-8330-005004526AB4), + dual, + helpstring("ISimple Interface"), + pointer_default(unique) + ] + interface ISimple : IDispatch + { + [id(1), helpstring("method func")] HRESULT func( [in] BSTR message); + [id(2), helpstring("method func2")] HRESULT func2([in] BSTR message); + [id(3), helpstring("method func3")] HRESULT func3([in] BSTR message); + [propget, id(4), helpstring("property _implementedInterfaces")] HRESULT _implementedInterfaces([out, retval] SAFEARRAY(BSTR) *pVal); + }; + + + +[ + uuid(180FF553-6F5C-11D4-8330-005004526AB4), + version(1.0), + helpstring("XCallback_Impl 1.0 Type Library") +] +library XCALLBACK_IMPLLib +{ + importlib("stdole32.tlb"); + importlib("stdole2.tlb"); + + [ + uuid(180FF560-6F5C-11D4-8330-005004526AB4), + helpstring("Callback Class") + ] + coclass Callback + { + [default] interface ICallback; + }; + [ + uuid(180FF565-6F5C-11D4-8330-005004526AB4), + helpstring("Simple Class") + ] + coclass Simple + { + [default] interface ISimple; + }; +}; + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.rc b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.rc new file mode 100644 index 000000000..f544b17ca --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.rc @@ -0,0 +1,154 @@ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ + +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS + + +// Generated from the TEXTINCLUDE 2 resource. + +#include "winres.h" + + +#undef APSTUDIO_READONLY_SYMBOLS + + +// German (Germany) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU) +#ifdef _WIN32 +LANGUAGE LANG_GERMAN, SUBLANG_GERMAN +#pragma code_page(1252) +#endif //_WIN32 + + + +// REGISTRY + + +IDR_CALLBACK REGISTRY DISCARDABLE "Callback.rgs" +IDR_SIMPLE REGISTRY DISCARDABLE "Simple.rgs" +#endif // German (Germany) resources + + + + +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED + + +// TEXTINCLUDE + + +1 TEXTINCLUDE DISCARDABLE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE DISCARDABLE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE DISCARDABLE +BEGIN + "1 TYPELIB ""XCallback_Impl.tlb""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +#ifndef _MAC + + +// Version + + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 1,0,0,1 + PRODUCTVERSION 1,0,0,1 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904B0" + BEGIN + VALUE "CompanyName", "\0" + VALUE "FileDescription", "XCallback_Impl Module\0" + VALUE "FileVersion", "1, 0, 0, 1\0" + VALUE "InternalName", "XCallback_Impl\0" + VALUE "LegalCopyright", "Copyright 2000\0" + VALUE "OriginalFilename", "XCallback_Impl.DLL\0" + VALUE "ProductName", "XCallback_Impl Module\0" + VALUE "ProductVersion", "1, 0, 0, 1\0" + VALUE "OLESelfRegister", "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + +#endif // !_MAC + + + + +// String Table + + +STRINGTABLE DISCARDABLE +BEGIN + IDS_PROJNAME "XCallback_Impl" +END + +#endif // English (U.S.) resources + + + + +#ifndef APSTUDIO_INVOKED + + +// Generated from the TEXTINCLUDE 3 resource. + +1 TYPELIB "XCallback_Impl.tlb" + + +#endif // not APSTUDIO_INVOKED + + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.sln b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.sln new file mode 100644 index 000000000..62b109fe4 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.sln @@ -0,0 +1,31 @@ +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "XCallback_Impl", "XCallback_Impl.vcproj", "{92A6B531-401E-4900-8217-169A96F4168D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Release MinDependency|Win32 = Release MinDependency|Win32 + Release MinSize|Win32 = Release MinSize|Win32 + Unicode Debug|Win32 = Unicode Debug|Win32 + Unicode Release MinDependency|Win32 = Unicode Release MinDependency|Win32 + Unicode Release MinSize|Win32 = Unicode Release MinSize|Win32 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {92A6B531-401E-4900-8217-169A96F4168D}.Debug|Win32.ActiveCfg = Debug|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Debug|Win32.Build.0 = Debug|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Release MinDependency|Win32.ActiveCfg = Release MinDependency|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Release MinDependency|Win32.Build.0 = Release MinDependency|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Release MinSize|Win32.ActiveCfg = Release MinSize|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Release MinSize|Win32.Build.0 = Release MinSize|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Debug|Win32.ActiveCfg = Unicode Debug|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Debug|Win32.Build.0 = Unicode Debug|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Release MinDependency|Win32.ActiveCfg = Unicode Release MinDependency|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Release MinDependency|Win32.Build.0 = Unicode Release MinDependency|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Release MinSize|Win32.ActiveCfg = Unicode Release MinSize|Win32 + {92A6B531-401E-4900-8217-169A96F4168D}.Unicode Release MinSize|Win32.Build.0 = Unicode Release MinSize|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.vcproj b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.vcproj new file mode 100644 index 000000000..1a9068d31 --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/XCallback_Impl.vcproj @@ -0,0 +1,816 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/extensions/test/ole/unoTocomCalls/XCallback_Impl/resource.h b/extensions/test/ole/unoTocomCalls/XCallback_Impl/resource.h new file mode 100644 index 000000000..2864478cd --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/XCallback_Impl/resource.h @@ -0,0 +1,39 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * 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 . + */ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by XCallback_Impl.rc + +#define IDS_PROJNAME 100 +#define IDR_CALLBACK 101 +#define IDR_SIMPLE 102 +#define IDR_SIMPLESTRUCT 103 + +// Next default values for new objects + +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 201 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 104 +#endif +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/extensions/test/ole/unoTocomCalls/readme.txt b/extensions/test/ole/unoTocomCalls/readme.txt new file mode 100644 index 000000000..feb46b11e --- /dev/null +++ b/extensions/test/ole/unoTocomCalls/readme.txt @@ -0,0 +1,9 @@ +The directory XCallback_Impl contains a MSDEV project that +creates a dll containing the ActiveX components +XCallback_Impl.Simple and XCallback_Impl.Callback +Callback implements functions defined in oletest.XCallback +and Simple implements functions defined in oletest.XSimple. +These interfaces are build in extensions/test/ole/cpnt + +The projects in unoToComCalls test the functionality of COM +and JScript object which implement UNO interfaces. -- cgit v1.2.3