ATL / WTL / STL

Rajeesh MP wrote:

but i would like to know any alternate trik is there or not..like adding reference or linking

CABCModule _AtlModule;

STDAPI DllRegisterServer(void)
{
    // registers object, typelib and all interfaces in typelib
    HRESULT hr = _AtlModule.DllRegisterServer();
    return hr;
}


// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
	HRESULT hr = _AtlModule.DllUnregisterServer();
	return hr;
}

CComModule _Module;

BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_ABCPP, CABCPP)
END_OBJECT_MAP()

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);
}

Rajeesh MP wrote:

CABCModule _AtlModule;
and
CComModule _Module

Rajeesh MP wrote:

i think becouse of this my dll is not working properly

std::pair<size_t, size_t> find_first_subsequence(std::vector<std::string> const& v1,
                                                 std::vector<std::string> const& v2)
{
   std::vector<std::string>::const_iterator pos = std::find(v1.begin(), v1.end(), v2[0]);
   const size_t firstPos = pos-v1.begin();
   if (pos == v1.end()) return std::make_pair(-1, -1);
   size_t numEqual = 0;
   while(numEqual < v2.size() && pos != v1.end() && *pos == v2[numEqual])
   {
      ++numEqual;
      ++pos;
   }
   return std::make_pair(firstPos, numEqual);
}

#include <string>
#include <windows.h>
#include <exdisp.h>
#include <mshtmlc.h>

#include <atlbase.h>
#include <atlcom.h>
#include <atlwin.h>

using std::string;

#import "PROGID:ShockwaveFlash.ShockwaveFlash" no_namespace raw_interfaces_only

typedef HRESULT (WINAPI *LPAtlAxWinInit) ();
typedef HRESULT (WINAPI *LPAtlAxGetControl)(HWND hwnd, IUnknown** unk);


int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmd, int show)
{
	LPAtlAxWinInit AtlAxWinInit3 = (LPAtlAxWinInit)GetProcAddress(LoadLibrary("atl"), "AtlAxWinInit");
	LPAtlAxGetControl AtlAxGetControl3 = (LPAtlAxGetControl)GetProcAddress(LoadLibrary("atl"), "AtlAxGetControl");

	MSG msg;
	HRESULT hr = AtlAxWinInit3();

	HWND hwnd = CreateWindow("AtlAxWin", "", WS_VISIBLE|WS_POPUP, 0, 0, 1024, 768, 0, 0, 0, 0);

	IShockwaveFlash* flash = 0;
	IViewObject* view = 0;

	hr = CoCreateInstance(__uuidof(ShockwaveFlash), 0, CLSCTX_ALL, __uuidof(IShockwaveFlash), (void **)&flash);
	hr = flash->put_WMode(L"transparent");
	hr = flash->put_Loop(true);
	

	hr = AtlAxAttachControl(flash, hwnd, NULL);
	hr = flash->put_Movie(L"c:\\FrontEnd.swf");
	hr = flash->QueryInterface(__uuidof(IViewObject), (void **) &view);

	long pVal = -1;
	flash->get_ReadyState(&pVal);

	BSTR val = L"Null", var = L"GetLastButton";
	string cval;

	while(GetMessage(&msg, 0, 0, 0) && flash)
	{
		hr = flash->CallFunction(L"<invoke name=\"GetLastButton\" returntype=\"string\"></invoke>" , &val);
		cval = _com_util::ConvertBSTRToString(val);
		
		if (cval.compare("<string>btnQuit</string>") == 0 )
		{
			PostMessage(hwnd, WM_QUIT, NULL, NULL); 
		}
		DispatchMessage(&msg);
	}
};

WIN32APP.H

#define WIN32_LEAN_AND_MEAN

#include <windows.h>

#pragma once

#define SCREEN_WIDTH	1024
#define SCREEN_HEIGHT	768
#define COLOR_DEPTH		32

#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

class Win32App
{
public:
	Win32App()	{	};
	~Win32App()	{	};
	void Start(HINSTANCE hInst, bool isFullscreen);
	char const * Title;
	char const * ClassName;
	bool isFullscreen;

	static HINSTANCE hInst;
	static HWND hWnd;
private:
	//Windows Requirements
	WNDCLASS localWndClass;
	static LRESULT CALLBACK WindowsProcedure(HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam);
protected:
	virtual void PreInitialize() 	{	};
	virtual void PostInitialize() 	{	};
	virtual void Main() 			{	};
	virtual void CleanUp()			{	};

	void StartMessagePump();
	void Quit()
	{
		PostMessage(hWnd, WM_QUIT, 0, 0);
	}
};

HINSTANCE Win32App::hInst;
HWND Win32App::hWnd;

void Win32App::Start(HINSTANCE hInst, bool isFullscreen)
{
	this->hInst = hInst;
	
	this->Title = "Win32App";
	this->ClassName = "Win32";

	this->isFullscreen = isFullscreen;

	this->PreInitialize();

	//Register the windows class
	localWndClass.style = 0;
	localWndClass.lpfnWndProc = WindowsProcedure;
	localWndClass.cbClsExtra = 0;
	localWndClass.cbWndExtra = 0;
	localWndClass.hInstance = this->hInst;
	localWndClass.hIcon = 0;
	localWndClass.hCursor = LoadCursor(0, IDC_ARROW);

	localWndClass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
	localWndClass.lpszMenuName = 0;
	localWndClass.lpszClassName = ClassName;
	
	RegisterClass(&localWndClass);

	//Create The Window
	if (!isFullscreen)
		this->hWnd = CreateWindow(
			this->ClassName,
			this->Title,
			WS_OVERLAPPEDWINDOW,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			CW_USEDEFAULT,
			NULL,
			NULL,
			hInst,
			NULL);
	else
		this->hWnd = CreateWindow(
			this->ClassName,
			this->Title,
			WS_EX_TOPMOST | WS_POPUP,
			0,
			0,
			SCREEN_WIDTH,
			SCREEN_HEIGHT,
			NULL,
			NULL,
			hInst,
			NULL);

	ShowWindow(this->hWnd, 1);
	UpdateWindow(this->hWnd);

	this->PostInitialize();//----------------------------------CALLS THE DDINITIALIZE() FUNCTION-------------------------

	StartMessagePump();
}

LRESULT CALLBACK Win32App::WindowsProcedure(HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam)
{
	switch(message)
	{
	case WM_DESTROY:
		{
		PostQuitMessage(0);
		return 0;
		} break;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}
void Win32App::StartMessagePump()
{
	MSG msg;
	DWORD startTime;

	while (true)
	{
		startTime = GetTickCount();
		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if (msg.message == WM_QUIT)
				break;

			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		if(KEY_DOWN(VK_ESCAPE))
			PostMessage(hWnd, WM_QUIT, 0, 0);
		this->Main();
		//while ((GetTickCount() - startTime) < 25);
	}
	this->CleanUp();
	this->~Win32App();
}

DDAPP.H
#pragma once
#pragma comment (lib, "ddraw.lib")
#pragma comment (lib, "dxguid.lib")

#include <ddraw.h>
#include "Win32App.h"

#define INIT_DXSTRUCT(dxs) {ZeroMemory(&dxs, sizeof(dxs)); dxs.dwSize = sizeof(dxs);}

class DDApp : public Win32App
{
public:
	DDApp()
	{
	}
	static void LoadBitmap(LPDIRECTDRAWSURFACE7 lpdds, int xDest, int yDest, LPCSTR Filename);
	void Restore();
protected:
	//DD specific functions
	virtual void DDInitialize() {} //-------------------CALLS THE FlashViewer::Init() function---------------
	virtual void Update() {}
	virtual void RenderFrame() {}
	virtual void Release() {}
	//Overridden functions
	virtual void PostInitialize();//--------------------OVERLOADED FROM WIN32APP-----------------------------
	virtual void Main();
	virtual void CleanUp();
	
	//Internally Accessable variables
	LPDIRECTDRAW7 lpDD7;
	
	LPDIRECTDRAWSURFACE7 lpddsPrimary;
	LPDIRECTDRAWSURFACE7 lpddsBack;

	DDSURFACEDESC2 ddsd;
};

void DDApp::PostInitialize()//--------------------OVERLOADED FROM WIN32APP-----------------------------
{
	CoInitialize(NULL);
	CoCreateInstance(CLSID_DirectDraw, NULL, CLSCTX_ALL, IID_IDirectDraw7, (void**)&lpDD7);
	lpDD7->Initialize(NULL);
	if (isFullscreen)
		lpDD7->SetCooperativeLevel(hWnd, DDSCL_ALLOWREBOOT | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
	else
		lpDD7->SetCooperativeLevel(hWnd, DDSCL_NORMAL);
	lpDD7->SetDisplayMode(SCREEN_WIDTH, SCREEN_HEIGHT, COLOR_DEPTH, 0, 0);

	lpddsPrimary = NULL;
	lpddsBack = NULL;

	INIT_DXSTRUCT(ddsd);

	ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
	ddsd.dwBackBufferCount = 1;
	ddsd.ddsCaps.dwCaps =	DDSCAPS_PRIMARYSURFACE |	//Primary Surface
							DDSCAPS_COMPLEX |			//Chained backbuffer
							DDSCAPS_FLIP |				//Allow page flipping
							DDSCAPS_VIDEOMEMORY;		//Create in video memory

	lpDD7->CreateSurface(&ddsd, &lpddsPrimary, NULL);  

	ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;
	lpddsPrimary->GetAttachedSurface(&ddsd.ddsCaps, &lpddsBack);
	DDInitialize();     //----------------------------CALLS THE FlashViewer::Init() function-----------------------------------
}
void DDApp::Main()
{
	Update();
	RenderFrame();
	HRESULT r = lpddsPrimary->Flip(NULL, DDFLIP_WAIT);
}
void DDApp::CleanUp()
{
	Release();
	lpddsBack->Release();
	lpddsPrimary->Release();
	lpDD7->Release();
}
void DDApp::LoadBitmap(LPDIRECTDRAWSURFACE7 lpdds, int xDest, int yDest, LPCSTR Filename)
{
	HDC hSrcDC;
	HDC hDestDC;
	HBITMAP hbitmap;
	BITMAP bmp;
	int nHeight, nWidth;

	hbitmap = (HBITMAP)LoadImage(hInst, Filename, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_LOADFROMFILE);
	hSrcDC = CreateCompatibleDC(NULL);
	SelectObject(hSrcDC, hbitmap);
	GetObject(hbitmap, sizeof(BITMAP), &bmp);
	nWidth = bmp.bmWidth;
	nHeight = bmp.bmHeight;

	lpdds->GetDC(&hDestDC);

	BOOL isSuccess = BitBlt(hDestDC, xDest, yDest, nWidth, nHeight, hSrcDC, 0, 0, SRCCOPY);

	lpdds->ReleaseDC(hDestDC);
}
void DDApp::Restore()
{
	lpddsPrimary->Restore();
	lpddsBack->Restore();
}

if (FV.Init(this->hWnd, SCREEN_WIDTH, SCREEN_HEIGHT))
		FV.OpenFlash("C:\\FrontEnd.swf");

<br />
CComModule   _Module; //global<br />

<br />
CoInitialize(0); <br />
_Module.Init(0,GetModuleHandle(NULL));       <br />
AtlAxWinInit();   <br />