added some old plugins

git-svn-id: http://svn.miranda-ng.org/main/trunk@4123 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 338 insertions, 0 deletions

diff --git a/plugins/!NotAdopted/WinPopup/dllLoaderMinimal.h b/plugins/!NotAdopted/WinPopup/dllLoaderMinimal.h
new file mode 100644
index 0000000000..218a5a114c
--- /dev/null
+++ b/plugins/!NotAdopted/WinPopup/dllLoaderMinimal.h
@@ -0,0 +1,338 @@
+/*

+ * This software is the original work of DKLT.

+ * Copyright (c) 2002 DKLT. All rights reserved.

+ * email: dtung@eng.monash.edu.au

+ *

+ */

+/* 

+ * Permission to make digital or hard copies of all or part of this work for personal 

+ * or classroom use is granted without fee provided that copies are not distributed 

+ * for profit or commercial advantage.

+ */

+

+#ifndef LOADDLL_H

+#define LOADDLL_H

+

+/// proof of concept code follows

+///////

+/////// class DllLoader and class DllFunctor<...> 

+/////// 

+/////// Two classes are designed to provide the functionality to load a function, 

+/////// using the "function name" as an identifier, from a Win32 .dll file.

+/////// Sample code are attached at the end of this file.

+///////

+/////// -04Oct2003 <Sat> 11.52pm

+///////   reworked article and sample code to be posted on codeproject.com

+///////   better defined behaviours with refined logics idealistic goals yet to be completed 

+///////

+/////// -29Mar2003 <Sat> 1.47pm

+///////   Polishing code for public release. minimizing code size, removing redundent 

+///////   comments, eliminating deprecated funcs.

+///////

+/////// -29Mar2003 <Sat> 12.47am

+///////   Revising the src tree. Using redundent code to achieve src level compatibility

+///////   (ie: same set of calls for both funcs attached with apps or reside in dlls)

+///////

+/////// -12Nov2002 <Mon> 1.35am

+///////   My first attempt to tidy the code for another public release. 

+///////

+/////// -14Oct2002 <Mon> 1.40am

+///////   created and tested briefly inside \DKLT TestApp\

+///////

+///////

+///////

+

+//template <char* DllName>

+

+///

+/// No error message for you

+///

+#ifndef ERRORMSG

+#define DEBUGMSG(aMesg) ;

+#define ERRORMSG(aMesg) ;	

+#endif						

+

+///

+/// protos

+///

+class DllLoader;

+template <typename T> class DllFunctor;

+

+

+/*

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+// For Current release, you write code like these 

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+	///

+	/// u can load a dll function in two differnt ways

+	///

+	DllLoader dll("testDll.dll", false);	

+	DllFunctor<int(*)(int,int)> fAdd("Add");

+	fAdd.SetDll(dll);

+

+	int b;

+	b = fSub()(b,1);		// with delay load, but not src level compatible

+

+	OR

+

+

+	DllLoader dll("testDll.dll");

+	FuncPtrType( int(*)(int,int) ) Add;

+	dll.LoadFunc(Add,"Add");

+	int a=90;

+	a = Add(a,1);			// src level compatible, but no delay load

+

+

+

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+// For previous release, you write code like these 

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+

+	//

+	// sample code for demonstrating class DllLoader {...}; and DllFunctor<...> {...};

+	//

+	FuncPtrType( int(*)(int) ) a;							// define a new variable "a" of type "int(*)(int)"

+

+	DllLoader Dlldshow("dlls.dll");							// expect a dll name "dlls.dll"

+	Dllshow.LoadFunc( a, "test");							// load func named "test" from dll file

+	int i =a(10);

+

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+// For initial release, you write code like these 

+//++++++++++++++++++++++++++++++++++++++++++++++++++++

+	This version enables a delay-load behaviour. Note the double ()() call on last line.

+

+	//

+	// sample code for demonstrating class DllLoader {...}; and DllFunctor<...> {...};

+	//

+

+	DllLoader Dlldshow("dlls.dll");

+	DllFunctor<void(*)(POINT*)> update("UpdatePoint");

+	

+	Dlldshow.find(update);

+

+	update() (&pt);

+

+

+*/

+

+/*

+	A little comment here

+	

+	My previous attempts to use operator()(...) and operator FuncPtrType () with MSVC

+    failed, where FuncPtrType is a function pointer typedef. That technique, enables

+	more control over a functor object. ie: can implement delay load among many exciting

+	features. That technique, however, works with g++ line of compilers.

+

+	This current implementation is design for use with MSVC line of compilers only. 

+

+	It seems, from the MSVC compiler error message, that "operator FuncPtrType ()" is 

+	never a candidate function, not to mention viability. I guess this is how they 

+	design and implemented MSVC6. ".net" version doesnt "evaluate" 

+	"operator FuncPtrType()" properly as well.

+

+	- DKLT March 2003

+*/

+	

+

+//////

+//////++++++++++++++++++++++++++++++++++++++++++++++++++

+////// This marco is for performing the following task...  GoodJob! creative man!!

+//////++++++++++++++++++++++++++++++++++++++++++++++++++

+////// normally, u define a function pointer variable this way

+////// 

+//////    int (*c) (int) = test;	// c pointing to "int test(int) {...}"

+////// 

+////// This marco enables u define a function pointer this way

+////// 

+//////    FuncPtrType( int(*)(int) ) c =test;

+//////

+//////

+////// took me a while to come up with this one.

+//////

+////// - DKLT 2003 March

+

+template <typename FuncTypeTTT>

+struct TypeOnlyStruct {

+typedef FuncTypeTTT FuncType;

+};

+

+#define FuncPtrType(funcType) \

+	TypeOnlyStruct<funcType>::FuncType 

+

+//////

+////// potential problems

+////// - an instantiation for every differnt type on the template class

+////// thus bloated executable? need to fully test it out. not sure about

+////// behaviour at this stage.

+////// - DKLT March 2003

+

+

+//////

+////// class DllLoader {...}

+//////   -init a dll file with LoadLibrary() so that its mapped into dll memory 

+//////	  space. this class is designed to use with class DllFunctor<...>.

+//////

+//////

+/////////////////////////////////////////////////////////

+class DllLoader

+{

+/////////////////////////////////////////////////////////

+

+private:

+	TCHAR dllName[ MAX_PATH ];

+

+public:

+	 HINSTANCE dll;

+

+	 DllLoader (LPCTSTR n, bool loadNow = true) :

+		dll(0)

+	 {

+		 lstrcpy( dllName, n );

+		 if (loadNow)

+			 LoadLibrary();

+	 }

+	 ~DllLoader ()

+	 {

+		 FreeLibrary();

+	 }

+

+	// test to see if dll is loaded already

+	operator bool () const

+	{

+		return (dll != 0);

+	}

+

+//  FuncTypePtr(int(*)(int)) a;

+//	Dllshow.LoadFunc( a, "test") ;

+//	int i =a(10);

+

+	/// This is my latest implementation

+	///----------------------------------------------------------

+	/// public:

+	/// template <typename FuncTTT>

+	///          DllLoader::LoadFunc(FuncTTT& c, string fNameStr) 

+	///----------------------------------------------------------

+	///	This function loads a function named "fNameStr" from a DllLoader object

+	/// and put the address of that function into c.

+	///

+	///  - template type is derived(deduced) from 1st param.

+	///

+	///note: bloated executable is possible

+	template <typename FuncTTT>

+	//--------------------------

+	FuncTTT LoadFunc(FuncTTT& c, LPCSTR fNameStr) {

+	//--------------------------

+		FuncTTT fPtr;

+

+		// existing lib loaded?

+		if (!dll)

+			if (!this->LoadLibrary())

+				return (FuncTTT) NULL;

+

+		// load func from dll

+		fPtr =(FuncTTT)GetProcAddress (

+			  dll,			// handle to DLL module

+			  fNameStr		// name of function

+			);

+		if (!fPtr) {

+			/// return a pointer to a base generic function would be good. ie: ERROR prompt

+			return (FuncTTT) NULL;

+		}

+		c = fPtr;

+		return fPtr;

+	}

+

+public:

+	///

+	/// decrement dll ref count via win32 ::FreeLibrary(...)

+	///

+	//--------------------------

+	void FreeLibrary() {

+	//--------------------------

+		if (dll) {	

+			::FreeLibrary(dll);    

+			dll=0;

+		}

+	}

+

+public:

+	///

+	/// find the dll file and attempt to load it

+	///

+	//------------------------

+	bool LoadLibrary (HINSTANCE hInstance = NULL) {

+	//------------------------

+

+		// existing lib loaded?

+		if (dll !=0 ) 

+			this->FreeLibrary();

+

+		// load from:

+		// 1. The directory from which the application loaded. 

+		// 2. The current directory. 

+		// 3. The Windows system directory.

+		// 4. The Windows directory.

+		// 5. The directories that are listed in the PATH environment variable. 

+		dll = ::LoadLibrary( dllName );

+		if ( ! dll )

+		{

+			// 6. The module directory (if dll).

+			if ( hInstance )

+			{

+				TCHAR self[ MAX_PATH ];

+				GetModuleFileName( hInstance, self, MAX_PATH );

+				lstrcpy( lstrnrchr( self, _T('\\'), lstrlen( self )) + 1, dllName );

+				dll = ::LoadLibrary( self );

+			}

+			if ( ! dll )

+			{

+				return false;

+			}

+		}

+		return true;

+	}

+

+	////// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+	////// All class functions below are for backward compatibility....

+	////// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+	////// U may delete all of them if u dont need them

+	//////

+	///

+	/// find() is deprecated. Do not use it anymore.

+	/// locate the functor inside a dll. let a DllFunctor object to do the job 

+	/// instead... double dispatch??

+	///

+public:template <typename QQ>

+	bool find(DllFunctor<QQ>& functor) {

+		return functor.LoadFromDll(this);

+	}

+

+};

+

+///

+/// DllFunctor<> is templated on the function type

+///

+template <typename FuncPtrType>

+class DllFunctor {

+	FuncPtrType fp;		// pointer to dll function

+	DllLoader* dll;		// which dllLoader to load from

+	CString fname;	// name of function as char array

+

+public:

+	DllFunctor(FuncPtrType f, DllLoader* d=0): fp(f), dll(d) {;}

+	DllFunctor(LPCTSTR n): fname(n),fp(0), dll(0) {;}

+	FuncPtrType operator()() { 

+		if (!*dll) {

+			if (!dll->LoadLibrary())

+				return (FuncPtrType) NULL;

+		}

+		if (fp == 0) {

+			dll->LoadFunc (fp, fname.c_str());

+		}

+		return fp;

+	}

+	void SetDll(DllLoader& d) { dll=&d; }	

+};

+

+#endif