sal/workben/clipboardwben/testpaste/cbptest.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 // TestWin32.cpp : Defines the entry point for the application
  22 //
  23
  24 #define _WIN32_DCOM
  25
  26 #include "stdafx.h"
  27
  28 #include <windows.h>
  29
  30 #include <ole2.h>
  31 #include <objidl.h>
  32 #include <objbase.h>
  33 #include <process.h>
  34 #include <olectl.h>
  35 #include <stdlib.h>
  36 #include <malloc.h>
  37 #include <..\..\inc\systools\win32\MtaOleClipb.h>
  38
  39 #include "resource.h"
  40
  41 #define MAX_LOADSTRING 100
  42
  43 // Global variables:
  44 HINSTANCE           hInst;                      // current instance
  45 WCHAR               szTitle[MAX_LOADSTRING];            // Text for title
  46 WCHAR               szWindowClass[MAX_LOADSTRING];  // Text for title
  47 ATOM                MyRegisterClass( HINSTANCE hInstance );
  48 BOOL                InitInstance( HINSTANCE, int );
  49 LRESULT CALLBACK    WndProc( HWND, UINT, WPARAM, LPARAM );
  50 LRESULT CALLBACK    About( HWND, UINT, WPARAM, LPARAM );
  51 void                PasteClipboardData(HWND hwndParent);
  52 void                PasteClipboardData2(HWND hwndParent);
  53
  54 LPSTREAM            g_pStm    = NULL;
  55 char*               pTextBuff = NULL;
  56 DWORD               lData     = 0;
  57
  58 //----------------------------------------------------
  59 // a thread function
  60 //----------------------------------------------------
  61
  62 unsigned int _stdcall ThreadProc(LPVOID pParam)
  63 {
  64     IDataObject* pIDataObj = NULL;
  65     FORMATETC    formatETC;
  66     STGMEDIUM    stgMedium;
  67     LPVOID       pGlobMem;
  68     HWND         hwnd;
  69     DWORD        sizeGlobBuff;
  70     HRESULT      hr;
  71
  72     hwnd = (HWND)pParam;
  73
  74     OleInitialize( NULL );
  75
  76     hr = OleGetClipboard( &pIDataObj );
  77
  78     hr = CoGetInterfaceAndReleaseStream(
  79         g_pStm,
  80         __uuidof(IDataObject),
  81         reinterpret_cast<LPVOID*>(&pIDataObj));
  82
  83     formatETC.cfFormat = CF_TEXT;
  84     formatETC.ptd      = NULL;
  85     formatETC.dwAspect = DVASPECT_CONTENT;
  86     formatETC.lindex   = -1;
  87     formatETC.tymed    = TYMED_HGLOBAL;
  88
  89     hr = pIDataObj->GetData( &formatETC, &stgMedium );
  90     pGlobMem = GlobalLock( stgMedium.hGlobal );
  91     if ( NULL != pGlobMem )
  92     {
  93         if ( NULL != pTextBuff )
  94         {
  95             free( pTextBuff );
  96         }
  97
  98         sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
  99         pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
 100         ZeroMemory( pTextBuff, sizeGlobBuff + 1 );
 101
 102         memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
 103         lData = sizeGlobBuff;
 104
 105         InvalidateRect( hwnd, NULL, TRUE );
 106         UpdateWindow( hwnd );
 107     }
 108
 109     GlobalUnlock( stgMedium.hGlobal );
 110
 111     ReleaseStgMedium( &stgMedium );
 112
 113     pIDataObj->Release();
 114
 115     //CoUninitialize( );
 116
 117     OleUninitialize( );
 118
 119     return 0;
 120 }
 121
 122 //----------------------------------------------------
 123 // WinMain
 124 //----------------------------------------------------
 125
 126 int APIENTRY WinMain(HINSTANCE hInstance,
 127                      HINSTANCE hPrevInstance,
 128                      LPSTR     lpCmdLine,
 129                      int       nCmdShow )
 130 {
 131     // TODO: Add code here.
 132     MSG     msg;
 133     HACCEL  hAccelTable;
 134     HRESULT hr = E_FAIL;
 135
 136     // it's important to initialize ole
 137     // in order to use the clipboard
 138     //hr = OleInitialize( NULL );
 139     hr = CoInitializeEx( NULL, COINIT_MULTITHREADED );
 140     //hr = CoInitializeEx( NULL, COINIT_APARTMENTTHREADED );
 141
 142     // Initialize global strings
 143     LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 144     LoadStringW(hInstance, IDC_TESTWIN32, szWindowClass, MAX_LOADSTRING);
 145     MyRegisterClass(hInstance);
 146
 147     // Initialization of the application to perform:
 148     if( !InitInstance( hInstance, nCmdShow ) )
 149     {
 150         return FALSE;
 151     }
 152
 153     hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TESTWIN32);
 154
 155     // Main message loop:
 156     while( GetMessage(&msg, NULL, 0, 0) )
 157     {
 158         if( !TranslateAccelerator (msg.hwnd, hAccelTable, &msg) )
 159         {
 160             TranslateMessage( &msg );
 161             DispatchMessage( &msg );
 162         }
 163     }
 164
 165     // uninitializing the ole libraries
 166     //OleUninitialize( );
 167     CoUninitialize( );
 168
 169     return msg.wParam;
 170 }
 171
 172
 173
 174 //
 175 //  FUNCTION: MyRegisterClass()
 176 //
 177 //  PURPOSE: Registers the window class
 178 //
 179 //  COMMENTS:
 180 //    This function and its usage are only necessary if this code
 181 //    needs to be compatible with Win32 systems prior to 'RegisterClassEx'
 182 //    function, which was added to Windows 95. If it important to call
 183 //    this function to allow the use of small icons in the correct proportions.
 184
 185 ATOM MyRegisterClass( HINSTANCE hInstance )
 186 {
 187     WNDCLASSEXW wcex;
 188
 189     wcex.cbSize = sizeof(WNDCLASSEX);
 190
 191     wcex.style          = CS_HREDRAW | CS_VREDRAW;
 192     wcex.lpfnWndProc    = (WNDPROC)WndProc;
 193     wcex.cbClsExtra     = 0;
 194     wcex.cbWndExtra     = 0;
 195     wcex.hInstance      = hInstance;
 196     wcex.hIcon          = LoadIcon(hInstance, (LPCTSTR)IDI_TESTWIN32);
 197     wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
 198     wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
 199     wcex.lpszMenuName   = (LPCWSTR)IDC_TESTWIN32;
 200     wcex.lpszClassName  = szWindowClass;
 201     wcex.hIconSm        = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_SMALL);
 202
 203     return RegisterClassExW(&wcex);
 204 }
 205
 206 //
 207 //   FUNCTION: InitInstance(HANDLE, int)
 208 //
 209 //   PURPOSE: Saves instance handle and creates main window
 210 //
 211 //   COMMENTS:
 212 //        In this function, the instance access number is stored in a global variable
 213 //        and the main program window is displayed.
 214 //
 215 BOOL InitInstance( HINSTANCE hInstance, int nCmdShow )
 216 {
 217    HWND hWnd;
 218
 219    hInst = hInstance; // Store instance access number in our global variable
 220
 221    hWnd = CreateWindowExW(0, szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
 222       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 223
 224    if( !hWnd )
 225    {
 226       return FALSE;
 227    }
 228
 229    ShowWindow( hWnd, nCmdShow );
 230    UpdateWindow( hWnd );
 231
 232    return TRUE;
 233 }
 234
 235 //
 236 //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
 237 //
 238 //  PURPOSE: Processes messages for the main window.
 239 //
 240 //  WM_COMMAND  - Handle application menu
 241 //  WM_PAINT    - Display main windows
 242 //  WM_DESTROY  - Output completion message and return
 243 //
 244
 245 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 246 {
 247     int         wmId;
 248     PAINTSTRUCT ps;
 249     HDC         hdc;
 250     TCHAR       szHello[MAX_LOADSTRING];
 251
 252
 253     LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
 254
 255     switch( message )
 256     {
 257         case WM_COMMAND:
 258             wmId    = LOWORD(wParam);
 259             // Analyze menu selections
 260             switch( wmId )
 261             {
 262                 case IDD_PASTE:
 263                     //PasteClipboardData(hWnd);
 264                     PasteClipboardData2(hWnd);
 265                     break;
 266
 267                 case IDM_EXIT:
 268                    DestroyWindow( hWnd );
 269                    break;
 270
 271                 default:
 272                    return DefWindowProc( hWnd, message, wParam, lParam );
 273             }
 274             break;
 275
 276         case WM_PAINT:
 277             hdc = BeginPaint (hWnd, &ps);
 278             // TODO: Add any code for drawing
 279             RECT rt;
 280             GetClientRect( hWnd, &rt );
 281
 282             if ( NULL != pTextBuff )
 283             {
 284                 DrawText( hdc, pTextBuff, lData, &rt, DT_CENTER );
 285             }
 286             else
 287             {
 288                 DrawText( hdc, szHello, strlen(szHello), &rt, DT_CENTER );
 289             }
 290
 291             EndPaint( hWnd, &ps );
 292             break;
 293
 294         case WM_DESTROY:
 295             PostQuitMessage( 0 );
 296             break;
 297
 298         default:
 299             return DefWindowProc( hWnd, message, wParam, lParam );
 300    }
 301    return 0;
 302 }
 303
 304 void PasteClipboardData2(HWND hwndParent)
 305 {
 306     IDataObject* pIDataObject;
 307     HRESULT      hr;
 308     FORMATETC    formatETC;
 309     STGMEDIUM    stgMedium;
 310     LPVOID       pGlobMem;
 311     HWND         hwnd;
 312     DWORD        sizeGlobBuff;
 313
 314     hr = MTAGetClipboard( &pIDataObject );
 315     if ( SUCCEEDED( hr ) )
 316     {
 317         formatETC.cfFormat = CF_TEXT;
 318         formatETC.ptd      = NULL;
 319         formatETC.dwAspect = DVASPECT_CONTENT;
 320         formatETC.lindex   = -1;
 321         formatETC.tymed    = TYMED_HGLOBAL;
 322
 323         hr = pIDataObject->GetData( &formatETC, &stgMedium );
 324         pGlobMem = GlobalLock( stgMedium.hGlobal );
 325         if ( NULL != pGlobMem )
 326         {
 327             if ( NULL != pTextBuff )
 328             {
 329                 free( pTextBuff );
 330             }
 331
 332             sizeGlobBuff = GlobalSize( stgMedium.hGlobal );
 333             pTextBuff = (char*)malloc( sizeGlobBuff + 1 );
 334             ZeroMemory( pTextBuff, sizeGlobBuff + 1 );
 335
 336             memcpy( pTextBuff, pGlobMem, sizeGlobBuff );
 337             lData = sizeGlobBuff;
 338
 339             InvalidateRect( hwndParent, NULL, TRUE );
 340             UpdateWindow( hwndParent );
 341         }
 342
 343         GlobalUnlock( stgMedium.hGlobal );
 344
 345         ReleaseStgMedium( &stgMedium );
 346
 347         pIDataObject->Release();
 348     }
 349 }
 350
 351 //----------------------------------------------------
 352 // clipboard handling
 353 //----------------------------------------------------
 354
 355 /*
 356 void PasteClipboardData(HWND hwndParent)
 357 {
 358     IDataObject* pIDataObj = NULL;
 359     HRESULT      hr        = E_FAIL;
 360     unsigned int dwId;
 361
 362     hr = OleGetClipboard( &pIDataObj );
 363     if ( SUCCEEDED( hr ) )
 364     {
 365         HRESULT hr = CoMarshalInterThreadInterfaceInStream(
 366             __uuidof(IDataObject), //The IID of inteface to be marshaled
 367             pIDataObj,       //The interface pointer
 368             &g_pStm          //IStream pointer
 369             );
 370
 371         HANDLE hThread = (HANDLE)_beginthreadex(
 372                 NULL,       //Security
 373                 0,          //Stack Size
 374                 ThreadProc, //Start Address
 375                 NULL,       //Parmeter
 376                 (unsigned int)hwndParent,   //Creation Flag
 377                 &dwId       //Thread Id
 378                 );
 379
 380         //Wait for the thread to finish execution
 381         //A thread handle is signaled is thread execution
 382         //is complete
 383         for(;;)
 384         {
 385             DWORD dwRet = ::MsgWaitForMultipleObjects(
 386                                     1,          //Count of objects
 387                                     &hThread,   //pointer to the array of objects
 388                                     FALSE,      //Wait for all objects?
 389                                     INFINITE,   //Wait How Long?
 390                                     QS_ALLINPUT //Wait for all messges
 391                                     );
 392
 393             //This means that the object is signaled
 394             if ( dwRet != WAIT_OBJECT_0 + 1 )
 395                 break;
 396
 397             //Remove the messages from the queue
 398             MSG msg;
 399
 400             while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) > 0)
 401             {
 402                 //Not essential
 403                 TranslateMessage(&msg);
 404                 //Let the windowproc handle the message
 405                 DispatchMessage(&msg);
 406             }
 407         }
 408
 409         CloseHandle( hThread );
 410         pIDataObj->Release();
 411     }
 412 }
 413 */
 414
 415 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */