AOO410/main/sal/workben/clipboardwben/testpaste/cbptest.cxx - openoffice - Git at Google

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


 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_sal.hxx"
 // TestWin32.cpp : Definiert den Einsprungpunkt für die Anwendung.
 //

 #define _WIN32_DCOM

 #include "stdafx.h"

 #include <windows.h>

 #include <ole2.h>
 #include <objidl.h>
 #include <objbase.h>
 #include <process.h>
 #include <olectl.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <..\..\inc\systools\win32\MtaOleClipb.h>

 #include "resource.h"

 #define MAX_LOADSTRING 100

 // Globale Variablen:
 HINSTANCE			hInst;						// aktuelle Instanz
 WCHAR				szTitle[MAX_LOADSTRING];			// Text der Titelzeile
 WCHAR				szWindowClass[MAX_LOADSTRING];	// Text der Titelzeile
 ATOM				MyRegisterClass( HINSTANCE hInstance );
 BOOL				InitInstance( HINSTANCE, int );
 LRESULT CALLBACK	WndProc( HWND, UINT, WPARAM, LPARAM );
 LRESULT CALLBACK	About( HWND, UINT, WPARAM, LPARAM );
 void				PasteClipboardData(HWND hwndParent);
 void				PasteClipboardData2(HWND hwndParent);

 LPSTREAM			g_pStm    = NULL;
 char*				pTextBuff = NULL;
 DWORD				lData     = 0;

 //----------------------------------------------------
 // a thread function
 //----------------------------------------------------

 unsigned int _stdcall ThreadProc(LPVOID pParam)
 {
 	IDataObject* pIDataObj = NULL;
 	FORMATETC    formatETC;
 	STGMEDIUM	 stgMedium;
 	LPVOID		 pGlobMem;
 	HWND		 hwnd;
 	DWORD		 sizeGlobBuff;
 	HRESULT		 hr;

 	hwnd = (HWND)pParam;

 	OleInitialize( NULL );

 	hr = OleGetClipboard( &pIDataObj );

 	hr = CoGetInterfaceAndReleaseStream(
 		g_pStm,
 		__uuidof(IDataObject),
 		reinterpret_cast<LPVOID*>(&pIDataObj));

 	formatETC.cfFormat = CF_TEXT;
 	formatETC.ptd      = NULL;
 	formatETC.dwAspect = DVASPECT_CONTENT;
 	formatETC.lindex   = -1;
 	formatETC.tymed    = TYMED_HGLOBAL;

 	hr = pIDataObj->GetData( &formatETC, &stgMedium );
 	pGlobMem = GlobalLock( stgMedium.hGlobal );
 	if ( NULL != pGlobMem )
 	{
 		if ( NULL != pTextBuff )
 		{
 			free( pTextBuff );
 		}

 		sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
 		pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
 		ZeroMemory( pTextBuff, sizeGlobBuff + 1 );

 		memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
 		lData = sizeGlobBuff;

 		InvalidateRect( hwnd, NULL, TRUE );
 		UpdateWindow( hwnd );
 	}

 	GlobalUnlock( stgMedium.hGlobal );

 	ReleaseStgMedium( &stgMedium );

 	pIDataObj->Release();

 	//CoUninitialize( );

 	OleUninitialize( );

 	return 0;
 }

 //----------------------------------------------------
 // WinMain
 //----------------------------------------------------

 int APIENTRY WinMain(HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPSTR     lpCmdLine,
                      int       nCmdShow )
 {
  	// ZU ERLEDIGEN: Fügen Sie hier den Code ein.
 	MSG     msg;
 	HACCEL  hAccelTable;
 	HRESULT hr = E_FAIL;

 	// it's important to initialize ole
 	// in order to use the clipboard
 	//hr = OleInitialize( NULL );
 	hr = CoInitializeEx( NULL, COINIT_MULTITHREADED );
 	//hr = CoInitializeEx( NULL, COINIT_APARTMENTTHREADED );

 	// Globale Zeichenfolgen initialisieren
 	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 	LoadStringW(hInstance, IDC_TESTWIN32, szWindowClass, MAX_LOADSTRING);
 	MyRegisterClass(hInstance);

 	// Initialisierung der Anwendung durchführen:
 	if( !InitInstance( hInstance, nCmdShow ) )
 	{
 		return FALSE;
 	}

 	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TESTWIN32);

 	// Hauptnachrichtenschleife:
 	while( GetMessage(&msg, NULL, 0, 0) )
 	{
 		if( !TranslateAccelerator (msg.hwnd, hAccelTable, &msg) )
 		{
 			TranslateMessage( &msg );
 			DispatchMessage( &msg );
 		}
 	}

 	// uninitializing the ole libraries
 	//OleUninitialize( );
 	CoUninitialize( );

 	return msg.wParam;
 }


 //
 //  FUNKTION: MyRegisterClass()
 //
 //  AUFGABE: Registriert die Fensterklasse.
 //
 //  KOMMENTARE:
 //
 //    Diese Funktion und ihre Verwendung sind nur notwendig, wenn dieser Code
 //    mit Win32-Systemen vor der 'RegisterClassEx'-Funktion kompatibel sein soll,
 //    die zu Windows 95 hinzugefügt wurde. Es ist wichtig diese Funktion aufzurufen,
 //    damit der Anwendung kleine Symbole mit den richtigen Proportionen zugewiesen
 //    werden.
 //
 ATOM MyRegisterClass( HINSTANCE hInstance )
 {
 	WNDCLASSEXW wcex;

 	wcex.cbSize = sizeof(WNDCLASSEX);

 	wcex.style			= CS_HREDRAW | CS_VREDRAW;
 	wcex.lpfnWndProc	= (WNDPROC)WndProc;
 	wcex.cbClsExtra		= 0;
 	wcex.cbWndExtra		= 0;
 	wcex.hInstance		= hInstance;
 	wcex.hIcon			= LoadIcon(hInstance, (LPCTSTR)IDI_TESTWIN32);
 	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
 	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
 	wcex.lpszMenuName	= (LPCWSTR)IDC_TESTWIN32;
 	wcex.lpszClassName	= szWindowClass;
 	wcex.hIconSm		= LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

 	return RegisterClassExW(&wcex);
 }

 //
 //   FUNKTION: InitInstance(HANDLE, int)
 //
 //   AUFGABE: Speichert die Instanzzugriffsnummer und erstellt das Hauptfenster
 //
 //   KOMMENTARE:
 //
 //        In dieser Funktion wird die Instanzzugriffsnummer in einer globalen Variable
 //        gespeichert und das Hauptprogrammfenster erstellt und angezeigt.
 //
 BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
 {
    HWND hWnd;

    hInst = hInstance; // Instanzzugriffsnummer in unserer globalen Variable speichern

    hWnd = CreateWindowExW(0, szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

    if( !hWnd )
    {
       return FALSE;
    }

    ShowWindow( hWnd, nCmdShow );
    UpdateWindow( hWnd );

    return TRUE;
 }

 //
 //  FUNKTION: WndProc(HWND, unsigned, WORD, LONG)
 //
 //  AUFGABE:  Verarbeitet Nachrichten für das Hauptfenster.
 //
 //  WM_COMMAND	- Anwendungsmenü verarbeiten
 //  WM_PAINT	- Hauptfenster darstellen
 //  WM_DESTROY	- Beendigungsnachricht ausgeben und zurückkehren
 //
 //
 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
 	int         wmId;
 	int         wmEvent;
 	PAINTSTRUCT ps;
 	HDC         hdc;
 	TCHAR       szHello[MAX_LOADSTRING];


 	LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);

 	switch( message )
 	{
 		case WM_COMMAND:
 			wmId    = LOWORD(wParam);
 			wmEvent = HIWORD(wParam);
 			// Menüauswahlen analysieren:
 			switch( wmId )
 			{
 				case IDD_PASTE:
 					//PasteClipboardData(hWnd);
 					PasteClipboardData2(hWnd);
 					break;

 				case IDM_EXIT:
 				   DestroyWindow( hWnd );
 				   break;

 				default:
 				   return DefWindowProc( hWnd, message, wParam, lParam );
 			}
 			break;

 		case WM_PAINT:
 			hdc = BeginPaint (hWnd, &ps);
 			// ZU ERLEDIGEN: Hier beliebigen Code zum Zeichnen hinzufügen...
 			RECT rt;
 			GetClientRect( hWnd, &rt );

 			if ( NULL != pTextBuff )
 			{
 				DrawText( hdc, pTextBuff, lData, &rt, DT_CENTER );
 			}
 			else
 			{
 				DrawText( hdc, szHello, strlen(szHello), &rt, DT_CENTER );
 			}

 			EndPaint( hWnd, &ps );
 			break;

 		case WM_DESTROY:
 			PostQuitMessage( 0 );
 			break;

 		default:
 			return DefWindowProc( hWnd, message, wParam, lParam );
    }
    return 0;
 }

 void PasteClipboardData2(HWND hwndParent)
 {
 	IDataObject* pIDataObject;
 	HRESULT		 hr;
 	FORMATETC    formatETC;
 	STGMEDIUM	 stgMedium;
 	LPVOID		 pGlobMem;
 	HWND		 hwnd;
 	DWORD		 sizeGlobBuff;

 	hr = MTAGetClipboard( &pIDataObject );
 	if ( SUCCEEDED( hr ) )
 	{
 		formatETC.cfFormat = CF_TEXT;
 		formatETC.ptd      = NULL;
 		formatETC.dwAspect = DVASPECT_CONTENT;
 		formatETC.lindex   = -1;
 		formatETC.tymed    = TYMED_HGLOBAL;

 		hr = pIDataObject->GetData( &formatETC, &stgMedium );
 		pGlobMem = GlobalLock( stgMedium.hGlobal );
 		if ( NULL != pGlobMem )
 		{
 			if ( NULL != pTextBuff )
 			{
 				free( pTextBuff );
 			}

 			sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
 			pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
 			ZeroMemory( pTextBuff, sizeGlobBuff + 1 );

 			memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
 			lData = sizeGlobBuff;

 			InvalidateRect( hwndParent, NULL, TRUE );
 			UpdateWindow( hwndParent );
 		}

 		GlobalUnlock( stgMedium.hGlobal );

 		ReleaseStgMedium( &stgMedium );

 		pIDataObject->Release();
 	}
 }

 //----------------------------------------------------
 // clipboard handling
 //----------------------------------------------------

 /*
 void PasteClipboardData(HWND hwndParent)
 {
 	IDataObject* pIDataObj = NULL;
 	HRESULT      hr        = E_FAIL;
 	unsigned int dwId;

 	hr = OleGetClipboard( &pIDataObj );
 	if ( SUCCEEDED( hr ) )
 	{
 		HRESULT hr = CoMarshalInterThreadInterfaceInStream(
 			__uuidof(IDataObject), //The IID of inteface to be marshaled
 			pIDataObj,       //The interface pointer
 			&g_pStm          //IStream pointer
 			);

 		HANDLE hThread = (HANDLE)_beginthreadex(
 				NULL,		//Security
 				0,			//Stack Size
 				ThreadProc,	//Start Address
 				NULL,	    //Parmeter
 				(unsigned int)hwndParent,	//Creation Flag
 				&dwId		//Thread Id
 				);

 		//Wait for the thread to finish execution
 		//A thread handle is signaled is thread execution
 		//is complete
 		for(;;)
 		{
 			DWORD dwRet = ::MsgWaitForMultipleObjects(
 									1,			//Count of objects
 									&hThread,	//pointer to the array of objects
 									FALSE,		//Wait for all objects?
 									INFINITE,	//Wait How Long?
 									QS_ALLINPUT //Wait for all messges
 									);

 			//This means that the object is signaled
 			if ( dwRet != WAIT_OBJECT_0 + 1 )
 				break;

 			//Remove the messages from the queue
 			MSG msg;

 			while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) > 0)
 			{
 				//Not essential
 				TranslateMessage(&msg);
 				//Let the windowproc handle the message
 				DispatchMessage(&msg);
 			}
 		}

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




	// MARKER(update_precomp.py): autogen include statement, do not remove
	#include "precompiled_sal.hxx"
	// TestWin32.cpp : Definiert den Einsprungpunkt für die Anwendung.
	//

	#define _WIN32_DCOM

	#include "stdafx.h"

	#include <windows.h>

	#include <ole2.h>
	#include <objidl.h>
	#include <objbase.h>
	#include <process.h>
	#include <olectl.h>
	#include <stdlib.h>
	#include <malloc.h>
	#include <..\..\inc\systools\win32\MtaOleClipb.h>

	#include "resource.h"

	#define MAX_LOADSTRING 100

	// Globale Variablen:
	HINSTANCE hInst; // aktuelle Instanz
	WCHAR szTitle[MAX_LOADSTRING]; // Text der Titelzeile
	WCHAR szWindowClass[MAX_LOADSTRING]; // Text der Titelzeile
	ATOM MyRegisterClass( HINSTANCE hInstance );
	BOOL InitInstance( HINSTANCE, int );
	LRESULT CALLBACK WndProc( HWND, UINT, WPARAM, LPARAM );
	LRESULT CALLBACK About( HWND, UINT, WPARAM, LPARAM );
	void PasteClipboardData(HWND hwndParent);
	void PasteClipboardData2(HWND hwndParent);

	LPSTREAM g_pStm = NULL;
	char* pTextBuff = NULL;
	DWORD lData = 0;

	//----------------------------------------------------
	// a thread function
	//----------------------------------------------------

	unsigned int _stdcall ThreadProc(LPVOID pParam)
	{
	IDataObject* pIDataObj = NULL;
	FORMATETC formatETC;
	STGMEDIUM stgMedium;
	LPVOID pGlobMem;
	HWND hwnd;
	DWORD sizeGlobBuff;
	HRESULT hr;

	hwnd = (HWND)pParam;

	OleInitialize( NULL );

	hr = OleGetClipboard( &pIDataObj );

	hr = CoGetInterfaceAndReleaseStream(
	g_pStm,
	__uuidof(IDataObject),
	reinterpret_cast<LPVOID*>(&pIDataObj));

	formatETC.cfFormat = CF_TEXT;
	formatETC.ptd = NULL;
	formatETC.dwAspect = DVASPECT_CONTENT;
	formatETC.lindex = -1;
	formatETC.tymed = TYMED_HGLOBAL;

	hr = pIDataObj->GetData( &formatETC, &stgMedium );
	pGlobMem = GlobalLock( stgMedium.hGlobal );
	if ( NULL != pGlobMem )
	{
	if ( NULL != pTextBuff )
	{
	free( pTextBuff );
	}

	sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
	pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
	ZeroMemory( pTextBuff, sizeGlobBuff + 1 );

	memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
	lData = sizeGlobBuff;

	InvalidateRect( hwnd, NULL, TRUE );
	UpdateWindow( hwnd );
	}

	GlobalUnlock( stgMedium.hGlobal );

	ReleaseStgMedium( &stgMedium );

	pIDataObj->Release();

	//CoUninitialize( );

	OleUninitialize( );

	return 0;
	}

	//----------------------------------------------------
	// WinMain
	//----------------------------------------------------

	int APIENTRY WinMain(HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
	LPSTR lpCmdLine,
	int nCmdShow )
	{
	// ZU ERLEDIGEN: Fügen Sie hier den Code ein.
	MSG msg;
	HACCEL hAccelTable;
	HRESULT hr = E_FAIL;

	// it's important to initialize ole
	// in order to use the clipboard
	//hr = OleInitialize( NULL );
	hr = CoInitializeEx( NULL, COINIT_MULTITHREADED );
	//hr = CoInitializeEx( NULL, COINIT_APARTMENTTHREADED );

	// Globale Zeichenfolgen initialisieren
	LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadStringW(hInstance, IDC_TESTWIN32, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Initialisierung der Anwendung durchführen:
	if( !InitInstance( hInstance, nCmdShow ) )
	{
	return FALSE;
	}

	hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TESTWIN32);

	// Hauptnachrichtenschleife:
	while( GetMessage(&msg, NULL, 0, 0) )
	{
	if( !TranslateAccelerator (msg.hwnd, hAccelTable, &msg) )
	{
	TranslateMessage( &msg );
	DispatchMessage( &msg );
	}
	}

	// uninitializing the ole libraries
	//OleUninitialize( );
	CoUninitialize( );

	return msg.wParam;
	}



	//
	// FUNKTION: MyRegisterClass()
	//
	// AUFGABE: Registriert die Fensterklasse.
	//
	// KOMMENTARE:
	//
	// Diese Funktion und ihre Verwendung sind nur notwendig, wenn dieser Code
	// mit Win32-Systemen vor der 'RegisterClassEx'-Funktion kompatibel sein soll,
	// die zu Windows 95 hinzugefügt wurde. Es ist wichtig diese Funktion aufzurufen,
	// damit der Anwendung kleine Symbole mit den richtigen Proportionen zugewiesen
	// werden.
	//
	ATOM MyRegisterClass( HINSTANCE hInstance )
	{
	WNDCLASSEXW wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style = CS_HREDRAW \| CS_VREDRAW;
	wcex.lpfnWndProc = (WNDPROC)WndProc;
	wcex.cbClsExtra = 0;
	wcex.cbWndExtra = 0;
	wcex.hInstance = hInstance;
	wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_TESTWIN32);
	wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName = (LPCWSTR)IDC_TESTWIN32;
	wcex.lpszClassName = szWindowClass;
	wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);

	return RegisterClassExW(&wcex);
	}

	//
	// FUNKTION: InitInstance(HANDLE, int)
	//
	// AUFGABE: Speichert die Instanzzugriffsnummer und erstellt das Hauptfenster
	//
	// KOMMENTARE:
	//
	// In dieser Funktion wird die Instanzzugriffsnummer in einer globalen Variable
	// gespeichert und das Hauptprogrammfenster erstellt und angezeigt.
	//
	BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
	{
	HWND hWnd;

	hInst = hInstance; // Instanzzugriffsnummer in unserer globalen Variable speichern

	hWnd = CreateWindowExW(0, szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
	CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

	if( !hWnd )
	{
	return FALSE;
	}

	ShowWindow( hWnd, nCmdShow );
	UpdateWindow( hWnd );

	return TRUE;
	}

	//
	// FUNKTION: WndProc(HWND, unsigned, WORD, LONG)
	//
	// AUFGABE: Verarbeitet Nachrichten für das Hauptfenster.
	//
	// WM_COMMAND - Anwendungsmenü verarbeiten
	// WM_PAINT - Hauptfenster darstellen
	// WM_DESTROY - Beendigungsnachricht ausgeben und zurückkehren
	//
	//
	LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
	{
	int wmId;
	int wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
	TCHAR szHello[MAX_LOADSTRING];


	LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);

	switch( message )
	{
	case WM_COMMAND:
	wmId = LOWORD(wParam);
	wmEvent = HIWORD(wParam);
	// Menüauswahlen analysieren:
	switch( wmId )
	{
	case IDD_PASTE:
	//PasteClipboardData(hWnd);
	PasteClipboardData2(hWnd);
	break;

	case IDM_EXIT:
	DestroyWindow( hWnd );
	break;

	default:
	return DefWindowProc( hWnd, message, wParam, lParam );
	}
	break;

	case WM_PAINT:
	hdc = BeginPaint (hWnd, &ps);
	// ZU ERLEDIGEN: Hier beliebigen Code zum Zeichnen hinzufügen...
	RECT rt;
	GetClientRect( hWnd, &rt );

	if ( NULL != pTextBuff )
	{
	DrawText( hdc, pTextBuff, lData, &rt, DT_CENTER );
	}
	else
	{
	DrawText( hdc, szHello, strlen(szHello), &rt, DT_CENTER );
	}

	EndPaint( hWnd, &ps );
	break;

	case WM_DESTROY:
	PostQuitMessage( 0 );
	break;

	default:
	return DefWindowProc( hWnd, message, wParam, lParam );
	}
	return 0;
	}

	void PasteClipboardData2(HWND hwndParent)
	{
	IDataObject* pIDataObject;
	HRESULT hr;
	FORMATETC formatETC;
	STGMEDIUM stgMedium;
	LPVOID pGlobMem;
	HWND hwnd;
	DWORD sizeGlobBuff;

	hr = MTAGetClipboard( &pIDataObject );
	if ( SUCCEEDED( hr ) )
	{
	formatETC.cfFormat = CF_TEXT;
	formatETC.ptd = NULL;
	formatETC.dwAspect = DVASPECT_CONTENT;
	formatETC.lindex = -1;
	formatETC.tymed = TYMED_HGLOBAL;

	hr = pIDataObject->GetData( &formatETC, &stgMedium );
	pGlobMem = GlobalLock( stgMedium.hGlobal );
	if ( NULL != pGlobMem )
	{
	if ( NULL != pTextBuff )
	{
	free( pTextBuff );
	}

	sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
	pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
	ZeroMemory( pTextBuff, sizeGlobBuff + 1 );

	memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
	lData = sizeGlobBuff;

	InvalidateRect( hwndParent, NULL, TRUE );
	UpdateWindow( hwndParent );
	}

	GlobalUnlock( stgMedium.hGlobal );

	ReleaseStgMedium( &stgMedium );

	pIDataObject->Release();
	}
	}

	//----------------------------------------------------
	// clipboard handling
	//----------------------------------------------------

	/*
	void PasteClipboardData(HWND hwndParent)
	{
	IDataObject* pIDataObj = NULL;
	HRESULT hr = E_FAIL;
	unsigned int dwId;

	hr = OleGetClipboard( &pIDataObj );
	if ( SUCCEEDED( hr ) )
	{
	HRESULT hr = CoMarshalInterThreadInterfaceInStream(
	__uuidof(IDataObject), //The IID of inteface to be marshaled
	pIDataObj, //The interface pointer
	&g_pStm //IStream pointer
	);

	HANDLE hThread = (HANDLE)_beginthreadex(
	NULL, //Security
	0, //Stack Size
	ThreadProc, //Start Address
	NULL, //Parmeter
	(unsigned int)hwndParent, //Creation Flag
	&dwId //Thread Id
	);

	//Wait for the thread to finish execution
	//A thread handle is signaled is thread execution
	//is complete
	for(;;)
	{
	DWORD dwRet = ::MsgWaitForMultipleObjects(
	1, //Count of objects
	&hThread, //pointer to the array of objects
	FALSE, //Wait for all objects?
	INFINITE, //Wait How Long?
	QS_ALLINPUT //Wait for all messges
	);

	//This means that the object is signaled
	if ( dwRet != WAIT_OBJECT_0 + 1 )
	break;

	//Remove the messages from the queue
	MSG msg;

	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) > 0)
	{
	//Not essential
	TranslateMessage(&msg);
	//Let the windowproc handle the message
	DispatchMessage(&msg);
	}
	}

	CloseHandle( hThread );
	pIDataObj->Release();
	}
	}
	*/