![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to object.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ole / clidemo|
Return to object.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ole / clidemo |
1.1 ! root 1: /* ! 2: * object.c - OLE object support routines ! 3: * ! 4: * Created by Microsoft Corporation. ! 5: * (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved ! 6: */ ! 7: ! 8: //*** INCLUDES **** ! 9: ! 10: #include <windows.h> //* WINDOWS ! 11: #include <shellapi.h> //* SHELL ! 12: #include <ole.h> //* OLE ! 13: ! 14: #include "global.h" //* global variables and structures ! 15: #include "stream.h" //* application includes: ! 16: #include "dialog.h" ! 17: #include "object.h" ! 18: #include "clidemo.h" ! 19: #include "demorc.h" ! 20: #include "utility.h" ! 21: #include "register.h" ! 22: ! 23: //*** VARIABLES *** ! 24: ! 25: //*** Globals ! 26: INT cOleWait = 0; ! 27: ! 28: ! 29: /*************************************************************************** ! 30: * CallBack() ! 31: * ! 32: * This routine will be called whenever an object has been changed, ! 33: * saved, renamed, is being painted, or an asynchronous operation has ! 34: * completed. This routine is called by the OLE client DLL in the ! 35: * above situations. A pointer to this function is kept in the client ! 36: * vtbl. It is our obligation as a client application to insure that a ! 37: * pointer to this procedure is in the vtbl. ! 38: * ! 39: * IMMPORTANT: notice that we are posting messages here rather that doing ! 40: * the work right away. Well, this is done to avoid any possibility of ! 41: * getting into another dispatch message loop. A MessageBox woul do this! ! 42: * ! 43: * Returns int - see below ! 44: * ! 45: * The return value is generally ignored, except for these notifications: ! 46: * OLE_QUERY_PAINT and OLE_QUERY_RETRY. For these two notifications, ! 47: * returning TRUE means continue the current operation(eg painting or retry) ! 48: * Returning FALSE means stop the current operation. This is useful as an ! 49: * object which takes a long time to paint can be interrupted in order to ! 50: * perform other operations. ! 51: ***************************************************************************/ ! 52: ! 53: INT APIENTRY CallBack( //* ENTRY: ! 54: LPOLECLIENT lpClient, //* client application pointer ! 55: OLE_NOTIFICATION flags, //* notification code being sent ! 56: LPOLEOBJECT lpObject //* OLE object pointer ! 57: ){ //* LOCAL: ! 58: APPITEMPTR pItem; //* application item pointer ! 59: ! 60: ! 61: pItem = (APPITEMPTR)lpClient; ! 62: switch (flags) ! 63: { ! 64: case OLE_CLOSED: //* server has closed ! 65: if (!pItem->fVisible) ! 66: { ! 67: PostMessage(hwndFrame, WM_DELETE, (DWORD)pItem,0L); ! 68: Dirty(DOC_UNDIRTY); ! 69: } ! 70: SetFocus( hwndFrame ); ! 71: break; ! 72: ! 73: case OLE_SAVED: //* server has saved object ! 74: case OLE_CHANGED: //* object has changes ! 75: cOleWait++; ! 76: pItem->fServerChangedBounds = pItem->fVisible = TRUE; ! 77: PostMessage(pItem->hwnd, WM_CHANGE, NULL, 0L); ! 78: break; ! 79: ! 80: case OLE_RELEASE: //* notification that an asynchronous ! 81: ToggleBlockTimer(FALSE); //* toggle timer off ! 82: if (hRetry) ! 83: PostMessage(hRetry,WM_COMMAND,IDCANCEL,0L); ! 84: ! 85: if (cOleWait) //* operation has completed ! 86: { ! 87: pItem->fRetry = TRUE; ! 88: if (!--cOleWait) ! 89: Hourglass(FALSE); ! 90: Release(pItem); ! 91: } ! 92: break; ! 93: ! 94: case OLE_QUERY_RETRY: //* Continue retrying. ! 95: ToggleBlockTimer(FALSE); //* toggle timer off ! 96: if (!hRetry && pItem->fRetry) ! 97: PostMessage(hwndFrame,WM_RETRY,(DWORD)pItem,0L); ! 98: return (pItem->fRetry); ! 99: ! 100: case OLE_QUERY_PAINT: //* continue repainting ! 101: return TRUE; //* a false return terminates either ! 102: ! 103: default: ! 104: break; ! 105: } ! 106: return 0; //* return value is ignored in ! 107: //* most cases, see header ! 108: } ! 109: ! 110: /*************************************************************************** ! 111: * Release() ! 112: * ! 113: * Check for an error on the OLE_RELEASE notification. ! 114: **************************************************************************/ ! 115: ! 116: static VOID Release( //* ENTRY: ! 117: APPITEMPTR pItem //* Item pointer ! 118: ){ //* LOCAL: ! 119: DWORD wParam; //* error code parameter ! 120: ! 121: if ((wParam = OleQueryReleaseError(pItem->lpObject)) == OLE_OK) ! 122: return; ! 123: ! 124: switch (OleQueryReleaseMethod(pItem->lpObject)) ! 125: { ! 126: case OLE_LNKPASTE: ! 127: pItem->fVisible = FALSE; ! 128: break; ! 129: ! 130: case OLE_CREATEFROMTEMPLATE: ! 131: case OLE_CREATE: ! 132: pItem->fVisible = FALSE; ! 133: cOleWait++; ! 134: PostMessage(hwndFrame, WM_DELETE,(DWORD)pItem,1L); ! 135: Dirty(DOC_UNDIRTY); ! 136: } ! 137: //* post a message to the main window ! 138: //* which will display a message box ! 139: PostMessage(hwndFrame,WM_ERROR,wParam,NULL); ! 140: ! 141: } ! 142: ! 143: /*************************************************************************** ! 144: * Error() ! 145: * ! 146: * This function checks for error conditions ! 147: * generated by OLE API callsFor OLE_WAIT_FOR_RELEASE, ! 148: * we keep track of the number of objects waiting, when ! 149: * this count is zero, it is safe to exit the application. ! 150: * ! 151: * Returns OLESTATUS - 0 if OLE_WAIT_FOR_RELEASE or OLE_OK ! 152: * otherwise the OLESTATUS returned after an action ! 153: * is taken. ! 154: *************************************************************************/ ! 155: ! 156: OLESTATUS FAR Error( //* ENTRY ! 157: OLESTATUS olestat //* OLE status ! 158: ){ ! 159: ! 160: switch (olestat) ! 161: { ! 162: case OLE_WAIT_FOR_RELEASE: ! 163: if (!cOleWait) ! 164: Hourglass(TRUE); ! 165: cOleWait++; //* increment wait count ! 166: ! 167: case OLE_OK: ! 168: return 0; ! 169: ! 170: case OLE_ERROR_STATIC: //* static object ! 171: ErrorMessage(W_STATIC_OBJECT); ! 172: break; ! 173: ! 174: case OLE_ERROR_REQUEST_PICT: ! 175: case OLE_ERROR_ADVISE_RENAME: ! 176: case OLE_ERROR_DOVERB: ! 177: case OLE_ERROR_SHOW: ! 178: case OLE_ERROR_OPEN: ! 179: case OLE_ERROR_NETWORK: ! 180: case OLE_ERROR_ADVISE_PICT: ! 181: case OLE_ERROR_COMM: //* Invalid links ! 182: InvalidLink(); ! 183: break; ! 184: ! 185: case OLE_BUSY: ! 186: RetryMessage(NULL,RD_CANCEL); ! 187: ! 188: default: ! 189: break; ! 190: } ! 191: return olestat; ! 192: } ! 193: ! 194: ! 195: /**************************************************************************** ! 196: * PreItemCreate() ! 197: * ! 198: * This routine allocates an application item structure. A pointer to this ! 199: * structure is passed as the client structure, therefore we need to ! 200: * have a pointer to the vtbl as the first entry. We are doing this ! 201: * to allow acess to the application item information during a OLE ! 202: * DLL callback. This approach simplifies matters. ! 203: * ! 204: * Returns APPITEMPTR - a pointer to a new application item structure ! 205: * which can operate as a client structure. ! 206: ***************************************************************************/ ! 207: ! 208: APPITEMPTR FAR PreItemCreate( //* ENTRY: ! 209: LPOLECLIENT lpClient, //* OLE client pointer ! 210: BOOL fShow, //* show/no-show flag ! 211: LHCLIENTDOC lhcDoc //* client document handle ! 212: ){ //* LOCAL: ! 213: HANDLE hitem; //* temp handle for new item ! 214: APPITEMPTR pItem; //* application item pointer ! 215: ! 216: ! 217: if (hitem = LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, sizeof(APPITEM))) ! 218: if (pItem = (APPITEMPTR)LocalLock(hitem)) ! 219: { //* set the vtbl pointer ! 220: pItem->oleclient.lpvtbl = lpClient->lpvtbl; ! 221: pItem->lpObjectUndo = NULL; ! 222: pItem->fVisible = fShow; ! 223: pItem->fServerChangedBounds = FALSE; ! 224: pItem->lhcDoc = lhcDoc; ! 225: ! 226: return pItem; //* SUCCESS return ! 227: } ! 228: ! 229: ErrorMessage(E_FAILED_TO_ALLOC); ! 230: return NULL; //* ERROR return ! 231: ! 232: } ! 233: ! 234: ! 235: /*************************************************************************** ! 236: * ItemWndProc() ! 237: * ! 238: * This function handles item window message processing. ! 239: * There is an item window for each OLE object. This was done to ! 240: * to simplify hit testing and repainting. These windows are child ! 241: * windows. ! 242: ! 243: * returns long - standard child routine ! 244: **************************************************************************/ ! 245: ! 246: LONG APIENTRY ItemWndProc( //* ENTRY: ! 247: HWND hwnd, //* standard windows parameters ! 248: UINT msg, ! 249: DWORD wParam, ! 250: LONG lParam ! 251: ){ //* LOCAL: ! 252: static POINT dragPt; //* Mouse drag point ! 253: static RECT dragRect; //* Mouse drag rectangle ! 254: static BOOL fCaptured; //* captured flag ! 255: APPITEMPTR pItem; //* application item pointer ! 256: PAINTSTRUCT ps; //* paint structure ! 257: POINT pt; //* point ! 258: RECT rc; //* bounding rectangle ! 259: ! 260: switch (msg) ! 261: { ! 262: case WM_SIZE: ! 263: if (pItem = (APPITEMPTR)GetWindowLong(hwnd,0)) ! 264: { ! 265: if (!pItem->fServerChangedBounds && pItem->otObject == OT_EMBEDDED) ! 266: ObjSetBounds(pItem); ! 267: else ! 268: pItem->fServerChangedBounds = FALSE; ! 269: } ! 270: break; ! 271: ! 272: case WM_CHANGE: ! 273: --cOleWait; ! 274: pItem = (APPITEMPTR)GetWindowLong(hwnd,0); ! 275: if (!Error(OleQueryBounds(pItem->lpObject, &rc))) ! 276: { ! 277: ConvertToClient(&rc); ! 278: ! 279: SetWindowPos( ! 280: hwnd, ! 281: NULL, ! 282: 0, ! 283: 0, ! 284: rc.right - rc.left + 2*GetSystemMetrics(SM_CXFRAME), ! 285: rc.bottom - rc.top + 2*GetSystemMetrics(SM_CYFRAME), ! 286: SWP_NOZORDER | SWP_NOMOVE | SWP_DRAWFRAME ! 287: ); ! 288: ! 289: if (!pItem->fNew && !fLoadFile) ! 290: ShowNewWindow(pItem); ! 291: else ! 292: InvalidateRect(hwnd, NULL, TRUE); ! 293: ! 294: Dirty(DOC_DIRTY); ! 295: } ! 296: break; ! 297: ! 298: case WM_NCLBUTTONDOWN: ! 299: SetTopItem((APPITEMPTR)GetWindowLong(hwnd,0)); ! 300: return (DefWindowProc(hwnd, msg, wParam, lParam)); ! 301: ! 302: case WM_PAINT: ! 303: BeginPaint(hwnd, (LPPAINTSTRUCT)&ps); ! 304: GetClientRect(hwnd, &rc); ! 305: pItem = (APPITEMPTR)GetWindowLong(hwnd, 0); ! 306: //* Call OLE draw ! 307: Error(OleDraw(pItem->lpObject, ps.hdc, &rc, NULL, NULL)); ! 308: ! 309: EndPaint(hwnd, (LPPAINTSTRUCT)&ps); ! 310: break; ! 311: ! 312: case WM_LBUTTONDBLCLK: //* execute a verb ! 313: ANY_OBJECT_BUSY; ! 314: ExecuteVerb(OLEVERB_PRIMARY,(APPITEMPTR)GetWindowLong(hwnd,0)); ! 315: break; ! 316: ! 317: case WM_LBUTTONDOWN: ! 318: GetWindowRect(hwnd, (LPRECT)&dragRect); ! 319: ScreenToClient(hwndFrame, (LPPOINT)&dragRect); ! 320: ScreenToClient(hwndFrame, (LPPOINT)&dragRect.right); ! 321: ! 322: dragPt.x = LOWORD(lParam); ! 323: dragPt.y = HIWORD(lParam); ! 324: ! 325: ClientToScreen(hwnd, (LPPOINT)&dragPt); ! 326: ScreenToClient(hwndFrame, (LPPOINT)&dragPt); ! 327: ! 328: SetCapture(hwnd); ! 329: fCaptured = TRUE; ! 330: SetTopItem((APPITEMPTR)GetWindowLong(hwnd,0)); ! 331: break; ! 332: ! 333: case WM_LBUTTONUP: ! 334: if (!fCaptured) ! 335: break; ! 336: ReleaseCapture(); ! 337: fCaptured = FALSE; ! 338: Dirty(DOC_DIRTY); ! 339: break; ! 340: ! 341: case WM_MOUSEMOVE: ! 342: if (!fCaptured) ! 343: break; ! 344: pt.x = LOWORD(lParam); ! 345: pt.y = HIWORD(lParam); ! 346: ! 347: ClientToScreen(hwnd, (LPPOINT)&pt); ! 348: ScreenToClient(hwndFrame, (LPPOINT)&pt); ! 349: ! 350: OffsetRect( ! 351: (LPRECT)&dragRect, ! 352: pt.x - dragPt.x, ! 353: pt.y - dragPt.y ! 354: ); ! 355: ! 356: MoveWindow( ! 357: hwnd, ! 358: dragRect.left, dragRect.top, ! 359: dragRect.right - dragRect.left, ! 360: dragRect.bottom - dragRect.top, TRUE ! 361: ); ! 362: ! 363: dragPt.x = pt.x; ! 364: dragPt.y = pt.y; ! 365: break; ! 366: ! 367: default: ! 368: return (DefWindowProc(hwnd, msg, wParam, lParam)); ! 369: } ! 370: return 0L; ! 371: ! 372: } ! 373: ! 374: /**************************************************************************** ! 375: * PostItemCreate() ! 376: * ! 377: * This function creates a child window which will contain the newly ! 378: * created OLE object. A pointer to our item information is stored in the ! 379: * extra bytes of this window. This is where we internally keep track ! 380: * of information related to the object as well as the ! 381: * pointer to the object for subsequent OLE API calls. This routine is ! 382: * called after an OLE object has been created by the client library. ! 383: * ! 384: * Returns BOOL - TRUE if application item has been created. ! 385: ****************************************************************************/ ! 386: ! 387: BOOL FAR PostItemCreate( //* ENTRY: ! 388: LPOLEOBJECT lpObject, //* OLE object pointer ! 389: LONG otObject, //* OLE object type ! 390: LPRECT lprcObject, //* object bounding rect ! 391: APPITEMPTR pItem //* application item pointer ! 392: ){ //* LOCAL: ! 393: INT i; //* index ! 394: RECT rc; //* bounding rectangle ! 395: CHAR pData[OBJECT_LINK_MAX];//* copy of link data ! 396: ! 397: if (lprcObject) //* if the size of the objects ! 398: rc = *lprcObject; //* bounding rectangle is not ! 399: else if (OleQueryBounds(lpObject, &rc) == OLE_OK) ! 400: ConvertToClient(&rc); ! 401: else ! 402: SetRect(&rc, 0, 0, 0, 0); ! 403: ! 404: if (!(pItem->hwnd = CreateWindow( //* Create the child window ! 405: szItemClass, "", ! 406: WS_BORDER | WS_CHILD | WS_CLIPSIBLINGS | WS_THICKFRAME, ! 407: rc.left,rc.top, ! 408: rc.right - rc.left + 2 * GetSystemMetrics(SM_CXFRAME), ! 409: rc.bottom - rc.top + 2 * GetSystemMetrics(SM_CYFRAME), ! 410: hwndFrame, NULL, hInst, NULL ! 411: ))) goto Error; ! 412: ! 413: //* in windows extra bytes ! 414: SetWindowLong(pItem->hwnd, 0, (LONG)pItem); ! 415: ! 416: pItem->otObject = otObject; ! 417: pItem->lpObject = lpObject; ! 418: pItem->fRetry = TRUE; ! 419: ! 420: if( pItem->otObject == OT_EMBEDDED )//* if object is embedded tell library ! 421: { //* the container name and object name. ! 422: UINT cb=CBOBJNAMEMAX; //* The name will be the server window title. ! 423: CHAR sz[CBOBJNAMEMAX]; //* when the object is edited. ! 424: ! 425: OleQueryName(lpObject, (LPSTR)sz, (UINT FAR *)&cb ); ! 426: ! 427: ! 428: WaitForObject(pItem); ! 429: Error(OleSetHostNames(lpObject, (LPSTR)szAppName, (LPSTR)sz )); ! 430: WaitForObject(pItem); ! 431: } ! 432: else if (pItem->otObject == OT_LINK)//* if the object is linked ! 433: { //* retrieve update options ! 434: ! 435: WaitForObject(pItem); ! 436: if(Error(OleGetLinkUpdateOptions(pItem->lpObject, &pItem->uoObject))) ! 437: goto Error; ! 438: ! 439: if (ObjGetData(pItem,pData)) ! 440: { ! 441: for (i=0; pData[i];i++); //* Skip past the server name ! 442: pItem->aLinkName = AddAtom(&pData[++i]); ! 443: } ! 444: else ! 445: pItem->aLinkName = AddAtom(""); ! 446: } ! 447: iObjects++; ! 448: Dirty(DOC_DIRTY); ! 449: //* a user interface recommendations. ! 450: return TRUE; //* SUCCESS return ! 451: ! 452: Error: //* ERROR Tag ! 453: ! 454: ErrorMessage(E_FAILED_TO_CREATE_CHILD_WINDOW); ! 455: FreeAppItem(pItem); ! 456: ! 457: return FALSE; //* ERROR return ! 458: ! 459: } ! 460: ! 461: /*************************************************************************** ! 462: * ConvertToClient() ! 463: * ! 464: * This function will convert to client from himetric. ! 465: **************************************************************************/ ! 466: ! 467: VOID FAR ConvertToClient( //* ENTRY: ! 468: LPRECT lprc //* pointer to bounding rectangle ! 469: ){ //* LOCAL ! 470: ! 471: if (!(lprc->left || lprc->top || lprc->right || lprc->bottom)) ! 472: SetRect(lprc, 0, 0, CXDEFAULT, CYDEFAULT); ! 473: else ! 474: { ! 475: HDC hdc = GetDC(NULL); ! 476: ! 477: lprc->right -= lprc->left; ! 478: lprc->bottom -= lprc->top ; ! 479: lprc->top = lprc->left = NULL; ! 480: ! 481: SetMapMode ( hdc, MM_HIMETRIC ); ! 482: LPtoDP ( hdc, (LPPOINT)&lprc->right, 1 ); ! 483: ! 484: ReleaseDC(NULL, hdc); ! 485: } ! 486: } ! 487: ! 488: /*************************************************************************** ! 489: * ObjInsert() ! 490: * ! 491: * Query the user for object type to insert and insert the new OLE object ! 492: ***************************************************************************/ ! 493: ! 494: VOID FAR ObjInsert( //* ENTRY: ! 495: LHCLIENTDOC lhcDoc, //* OLE document handle ! 496: LPOLECLIENT lpClient //* pointer to OLE client structure ! 497: ){ //* LOCAL: ! 498: LPOLEOBJECT lpObject; //* pointer to OLE object ! 499: APPITEMPTR pItem; //* item pointer ! 500: CHAR szServerName[CBPATHMAX];//* Class name for OleCreate() ! 501: CHAR szClassName[CBPATHMAX];//* Class name for OleCreate() ! 502: CHAR szTmp[CBOBJNAMEMAX]; //* buffer to unique object name ! 503: ! 504: if (DialogBoxParam(hInst, MAKEINTRESOURCE(DTCREATE),hwndFrame, ! 505: fnInsertNew, (LONG)((LPSTR)szClassName)) != IDCANCEL) ! 506: { ! 507: if (pItem = PreItemCreate(lpClient, FALSE, lhcDoc)) ! 508: { ! 509: RegGetClassId(szServerName, szClassName); ! 510: pItem->aServer = AddAtom(szServerName); ! 511: if ( Error( OleCreate(STDFILEEDITING,(LPOLECLIENT)&(pItem->oleclient), ! 512: (LPSTR)szClassName, lhcDoc,CreateNewUniqueName(szTmp), ! 513: &lpObject,olerender_draw, 0))) ! 514: { ! 515: ErrorMessage(E_FAILED_TO_CREATE_OBJECT); ! 516: FreeAppItem(pItem); ! 517: } ! 518: else ! 519: PostItemCreate(lpObject, OT_EMBEDDED, NULL, pItem); ! 520: } ! 521: } ! 522: ! 523: FreeProcInstance(lpfnInsertNew); ! 524: ! 525: } ! 526: ! 527: /*************************************************************************** ! 528: * ObjDelete() ! 529: * ! 530: * Delete an OLE object. For this application, all OLE objects ! 531: * are associated with a child window; therefore the window must be ! 532: * destroyed. ! 533: * ! 534: * NOTE: There is one case when we call OleRelease and the other when ! 535: * we call OleDelete. We call OleRelease when we are deregistering ! 536: * a document and OleDelete when removing an object from a document. ! 537: **************************************************************************/ ! 538: ! 539: VOID FAR ObjDelete( //* ENTRY: ! 540: APPITEMPTR pItem, //* pointer to application item ! 541: BOOL fDelete //* delete or release flag ! 542: ){ //* LOCAL: ! 543: ! 544: if (pItem->lpObjectUndo) ! 545: { ! 546: Error(OleDelete(pItem->lpObjectUndo)); ! 547: //* wait for asynchronous operation ! 548: WaitForObject(pItem); ! 549: } ! 550: ! 551: if (fDelete ? Error(OleDelete(pItem->lpObject)) ! 552: : Error(OleRelease(pItem->lpObject))) ! 553: { ! 554: ErrorMessage(E_FAILED_TO_DELETE_OBJECT); ! 555: return; //* ERROR return ! 556: } ! 557: ! 558: if (pItem->fVisible) ! 559: { ! 560: ShowWindow(pItem->hwnd, SW_HIDE); ! 561: pItem->fVisible = FALSE; ! 562: } ! 563: //* the operation has to complete ! 564: WaitForObject(pItem); //* before the application structure ! 565: ! 566: FreeAppItem(pItem); ! 567: iObjects--; ! 568: ! 569: } ! 570: ! 571: ! 572: /*************************************************************************** ! 573: * ObjPaste() ! 574: * ! 575: * This function obtains an object from the clipboard. ! 576: * Handles both embedded and linked objects. An item window is ! 577: * created for each new object. ! 578: * ! 579: * Returns BOOL - TRUE if object was pasted succesfully. ! 580: **************************************************************************/ ! 581: ! 582: VOID FAR ObjPaste( //* ENTRY: ! 583: BOOL fPaste, //* Paste/PasteLink flag ! 584: LHCLIENTDOC lhcDoc, //* client document handle ! 585: LPOLECLIENT lpClient //* pointer to client ! 586: ){ //* LOCAL: ! 587: LPOLEOBJECT lpObject; //* object pointer ! 588: LONG otObject; //* object type ! 589: APPITEMPTR pItem; //* application item pointer ! 590: CHAR szTmp[CBOBJNAMEMAX]; //* temporary object name string ! 591: ! 592: if (!(pItem = PreItemCreate(lpClient, TRUE, lhcDoc))) ! 593: return; //* ERROR return ! 594: ! 595: if (!OpenClipboard(hwndFrame)) ! 596: goto Error; //* ERROR jump ! 597: ! 598: ! 599: if (fPaste) //* PASTE the object. ! 600: { //* Try "StdFileEditing" protocol ! 601: if (Error(OleCreateFromClip(STDFILEEDITING,(LPOLECLIENT)&(pItem->oleclient),lhcDoc, ! 602: CreateNewUniqueName(szTmp),&lpObject, olerender_draw,0))) ! 603: { ! 604: //* next try "Static" protocol ! 605: if (Error(OleCreateFromClip( ! 606: STATICP, (LPOLECLIENT)&(pItem->oleclient), lhcDoc, ! 607: CreateNewUniqueName(szTmp), &lpObject, olerender_draw, 0))) ! 608: goto Error; //* ERROR jump ! 609: } ! 610: } ! 611: else ! 612: { //* LINK therefore must be ! 613: // "STdFileEditing" protocol ! 614: if (Error(OleCreateLinkFromClip( ! 615: STDFILEEDITING,(LPOLECLIENT)&(pItem->oleclient), lhcDoc, ! 616: CreateNewUniqueName(szTmp), &lpObject, olerender_draw, 0))) ! 617: goto Error; //* ERROR jump ! 618: } ! 619: ! 620: OleQueryType(lpObject, &otObject); ! 621: CloseClipboard(); ! 622: ! 623: if (!PostItemCreate(lpObject, otObject, NULL, pItem)) ! 624: return; //* ERROR return ! 625: ! 626: ShowNewWindow(pItem); ! 627: return; //* SUCCESS return ! 628: ! 629: ! 630: Error: //* TAG Error ! 631: ! 632: ErrorMessage(E_GET_FROM_CLIPBOARD_FAILED); ! 633: CloseClipboard(); ! 634: FreeAppItem(pItem); ! 635: ! 636: return; //* ERROR return ! 637: ! 638: } ! 639: ! 640: /*************************************************************************** ! 641: * ObjCopy() ! 642: * ! 643: * This function places an OLE object on the clipboard via the \ ! 644: * OleCopyToClipboard() function. ! 645: * ! 646: * Returns BOOL - TRUE if object successfully placed on clipboard ! 647: **************************************************************************/ ! 648: ! 649: BOOL FAR ObjCopy( //* ENTRY: ! 650: APPITEMPTR pItem //* pointer to app item ! 651: ){ //* LOCAL: ! 652: BOOL fReturn = TRUE; //* return value ! 653: ! 654: if (!OpenClipboard(hwndFrame)) ! 655: return FALSE; //* ERROR return ! 656: ! 657: EmptyClipboard(); ! 658: ! 659: if (Error(OleCopyToClipboard(pItem->lpObject))) ! 660: fReturn = FALSE; //* prepare for ERROR out ! 661: ! 662: CloseClipboard(); ! 663: return fReturn; //* ERROR or SUCCESS ! 664: ! 665: } ! 666: ! 667: /*************************************************************************** ! 668: * ObjCreateFromTemplate() ! 669: * ! 670: * Creates an embedded object from file. ! 671: **************************************************************************/ ! 672: ! 673: VOID FAR ObjCreateFromTemplate( //* ENTRY: ! 674: LHCLIENTDOC lhcDoc, //* client document handle ! 675: LPOLECLIENT lpClient //* client vtbl. pointer ! 676: ){ //* LOCAL: ! 677: LPOLEOBJECT lpObject; //* OLE object pointer ! 678: APPITEMPTR pItem; //* application item pointer ! 679: CHAR szTmp[CBOBJNAMEMAX]; //* temporary object name string ! 680: CHAR szFileName[CBPATHMAX];//* file name string ! 681: ! 682: *szFileName = NULL; ! 683: ! 684: if (!OfnGetName(hwndFrame, szFileName, IDM_INSERTFILE)) ! 685: return; //* ERROR operation aborted by user ! 686: ! 687: if (!(pItem = PreItemCreate(lpClient, FALSE, lhcDoc))) ! 688: return; //* ERROR ! 689: ! 690: if (Error(OleCreateFromTemplate(STDFILEEDITING, (LPOLECLIENT)pItem, szFileName, ! 691: lhcDoc, CreateNewUniqueName(szTmp), &lpObject, olerender_draw, 0))) ! 692: { ! 693: ErrorMessage(E_CREATE_FROM_TEMPLATE); ! 694: FreeAppItem(pItem); ! 695: return; //* ERROR ! 696: } ! 697: ! 698: PostItemCreate(lpObject, OT_EMBEDDED, NULL, pItem); ! 699: ! 700: } //* SUCCESS ! 701: ! 702: ! 703: /**************************************************************************** ! 704: * ObjGetData() ! 705: * ! 706: * Get the object link data. The data that is retrieved from OLE is copied ! 707: * into lpLinkData if lpLinkData is not NULL. Otherwise, space is dynamically ! 708: * allocated or reallocated; space is allocated if pItem->lpLinkData is NULL ! 709: * otherwise the pointer is reallocated. The data is returned is freed if ! 710: * there has been an OLE_WARN_DELETE_DATA error. ! 711: ***************************************************************************/ ! 712: ! 713: BOOL FAR ObjGetData( //* ENTRY: ! 714: APPITEMPTR pItem, //* OLE object ! 715: LPSTR lpLinkData //* pointer to linkdata ! 716: ){ //* LOCAL: ! 717: HANDLE hData; //* handle to OLE link data ! 718: LPSTR lpData; //* pointer to OLE link data ! 719: LPSTR lpWork; //* copy of OLE link data ! 720: BOOL fFree = FALSE; //* free OLE memory flag ! 721: LONG lSize; //* size of OLE link data ! 722: INT i; ! 723: ! 724: switch (Error(OleGetData(pItem->lpObject, ! 725: (OLECLIPFORMAT)(pItem->otObject == OT_LINK ? vcfLink : vcfOwnerLink), &hData))) ! 726: { ! 727: case OLE_WARN_DELETE_DATA: ! 728: fFree = TRUE; ! 729: case OLE_OK: ! 730: if(lpData = GlobalLock(hData)) ! 731: { ! 732: //* copy the link data to new buffer ! 733: lSize=SizeOfLinkData(lpData); ! 734: ! 735: if (!lpLinkData) ! 736: { ! 737: if (!pItem->lpLinkData) //* allocate ! 738: AllocLinkData(pItem,lSize); ! 739: else //* otherwise reallocate ! 740: ReallocLinkData(pItem,lSize); ! 741: lpWork = pItem->lpLinkData; ! 742: } ! 743: else ! 744: lpWork = lpLinkData; ! 745: ! 746: if (lpWork) ! 747: for (i=0L; i<(INT)lSize; i++) ! 748: *(lpWork+i)=*(lpData+i); ! 749: ! 750: GlobalUnlock(hData); //* free the linked data as needed ! 751: if (fFree) ! 752: GlobalFree(hData); ! 753: ! 754: return TRUE; //* SUCCESS ! 755: } ! 756: default: ! 757: return FALSE; //* FAILURE ! 758: } ! 759: ! 760: } ! 761: ! 762: /*************************************************************************** ! 763: * ObjChangeLink() ! 764: * ! 765: * Change the linkdata. This routine will change the document portion of ! 766: * link data to lpDoc. The old linkdata is expected to be in ! 767: * lpaItem->lpLinkData ! 768: **************************************************************************/ ! 769: ! 770: VOID FAR ObjChangeLinkData( //* ENTRY: ! 771: APPITEMPTR pItem, //* OLE object ! 772: LPSTR lpDoc //* document name ! 773: ){ //* LOCAL: ! 774: LONG lSize; //* used to link data size ! 775: LPSTR lpLinkData; //* OLE link data pointer ! 776: static CHAR pWork[OBJECT_LINK_MAX]; //* used to construct new link data ! 777: INT i; //* index ! 778: ! 779: pItem->aLinkName = AddAtom(lpDoc); ! 780: ! 781: for ( ! 782: lpLinkData = pItem->lpLinkData, i=0; ! 783: pWork[i] = *lpLinkData; ! 784: lpLinkData++, i++ ! 785: ); ! 786: //* into working buffer. ! 787: lstrcpy((LPSTR)&pWork[++i],lpDoc); //* copy new document name. ! 788: ! 789: for (; pWork[i]; i++); //* skip to end of document name ! 790: for (++lpLinkData;*lpLinkData;lpLinkData++); ! 791: //* copy item name. ! 792: lstrcpy((LPSTR)&pWork[++i],++lpLinkData); ! 793: for (; pWork[i]; i++); //* skip to end of buffer ! 794: //* which is the end of item info. ! 795: pWork[++i] = NULL; //* add extra null. ! 796: ! 797: lSize = SizeOfLinkData(pWork); //* reallocate space so there is ! 798: ReallocLinkData(pItem,lSize); //* a properly sized block of info ! 799: //* to send the linked data to the ! 800: if (lpLinkData = pItem->lpLinkData) //* OLE DLL. ! 801: for (i=0; i<(INT)lSize; i++) //* copy new linkdata into this space ! 802: *lpLinkData++ = pWork[i]; ! 803: else ! 804: return; //* ERROR return ! 805: ! 806: Error(OleSetData(pItem->lpObject, vcfLink, GlobalHandle(pItem->lpLinkData))); ! 807: ! 808: } //* SUCCESS return ! 809: ! 810: /**************************************************************************** ! 811: * ObjSaveUndo() ! 812: * ! 813: * Clone the OLE object so that any changes to object can be undone if the ! 814: * user choses to exit without update. ! 815: ***************************************************************************/ ! 816: ! 817: VOID FAR ObjSaveUndo( //* ENTRY: ! 818: APPITEMPTR pItem //* application item ! 819: ){ //* LOCAL: ! 820: CHAR szTmp[CBOBJNAMEMAX]; //* holder of object name ! 821: LPSTR lpClone; //* pointer to clond object name ! 822: UINT i=CBOBJNAMEMAX; ! 823: ! 824: if (!pItem->lpObjectUndo) ! 825: { ! 826: OleQueryName(pItem->lpObject, szTmp, &i); ! 827: //* give clone a unique name by ! 828: //* altering object name prefix. ! 829: for (lpClone = OBJCLONE, i=0; *lpClone; szTmp[i++] = *lpClone++); ! 830: ! 831: if (Error(OleClone(pItem->lpObject, (LPOLECLIENT)pItem, ! 832: pItem->lhcDoc, szTmp, &(pItem->lpObjectUndo)))) ! 833: return; //* ERROR return ! 834: ! 835: pItem->otObjectUndo = pItem->otObject; ! 836: pItem->uoObjectUndo = pItem->uoObject; ! 837: pItem->aLinkUndo = pItem->aLinkName; ! 838: ! 839: GetClientRect(pItem->hwnd, &pItem->rect); ! 840: ! 841: if (OleQueryOpen(pItem->lpObject) == OLE_OK) ! 842: pItem->fOpen = TRUE; ! 843: ! 844: } ! 845: ! 846: } //* SUCCESS return ! 847: ! 848: /**************************************************************************** ! 849: * ObjUndo() ! 850: * ! 851: * Restore an object to its state before changes. The lpObject Undo is a ! 852: * clone to the original object with a different name, therefore, all we ! 853: * have to do is rename that object and ditch the changed object. ! 854: ***************************************************************************/ ! 855: ! 856: VOID FAR ObjUndo( //* ENTRY: ! 857: APPITEMPTR pItem //* application item ! 858: ){ //* LOCAL: ! 859: CHAR szTmp[CBOBJNAMEMAX]; //* object name holder ! 860: UINT i = CBOBJNAMEMAX; ! 861: ! 862: OleQueryName(pItem->lpObject, szTmp, &i); ! 863: if (Error(OleDelete(pItem->lpObject))) ! 864: return; //* ERROR return ! 865: //* reset app item vars ! 866: pItem->lpObject = pItem->lpObjectUndo; ! 867: pItem->otObject = pItem->otObjectUndo; ! 868: pItem->uoObject = pItem->uoObjectUndo; ! 869: pItem->aLinkName = pItem->aLinkUndo; ! 870: pItem->lpObjectUndo = (LPOLEOBJECT)NULL; ! 871: pItem->otObjectUndo = (LONG)NULL; ! 872: ! 873: if (Error(OleRename(pItem->lpObject,szTmp))) ! 874: return; //* ERROR return ! 875: ! 876: if (pItem->fOpen) ! 877: { ! 878: Error(OleReconnect(pItem->lpObject)); ! 879: pItem->fOpen = FALSE; ! 880: } ! 881: ! 882: SetWindowPos( ! 883: pItem->hwnd, ! 884: NULL, 0, 0, ! 885: pItem->rect.right - pItem->rect.left + 2*GetSystemMetrics(SM_CXFRAME), ! 886: pItem->rect.bottom - pItem->rect.top + 2*GetSystemMetrics(SM_CYFRAME), ! 887: SWP_NOZORDER | SWP_NOMOVE | SWP_DRAWFRAME ! 888: ); ! 889: ! 890: InvalidateRect(pItem->hwnd,NULL,TRUE); ! 891: ! 892: } //* SUCCESS return ! 893: ! 894: ! 895: /**************************************************************************** ! 896: * ObjDelUndo() ! 897: * ! 898: * Delete the undo object if the user is happy with the changes he/she made. ! 899: ***************************************************************************/ ! 900: ! 901: VOID FAR ObjDelUndo( //* ENTRY: ! 902: APPITEMPTR pItem //* application item ! 903: ){ ! 904: ! 905: if (Error(OleDelete(pItem->lpObjectUndo))) ! 906: return; //* ERROR return ! 907: ! 908: pItem->lpObjectUndo = (LPOLEOBJECT)NULL; ! 909: pItem->otObjectUndo = (LONG)NULL; ! 910: DeleteAtom(pItem->aLinkUndo); ! 911: pItem->lpObjectUndo = NULL; ! 912: ! 913: } //* SUCCESS return ! 914: ! 915: /**************************************************************************** ! 916: * ObjFreeze() ! 917: * ! 918: * Convert an object to a static object. ! 919: ***************************************************************************/ ! 920: ! 921: VOID FAR ObjFreeze( //* ENTRY: ! 922: APPITEMPTR pItem //* application item ! 923: ){ //* LOCAL: ! 924: CHAR szTmp[CBOBJNAMEMAX]; //* temporary object name ! 925: LPSTR lpTemp; //* temporary prefix string ! 926: LPOLEOBJECT lpObjectTmp; //* temporary object pointer ! 927: UINT i=CBOBJNAMEMAX; ! 928: ! 929: OleQueryName(pItem->lpObject, szTmp, &i); ! 930: //* create a unique name by changing ! 931: //* the object name prefix ! 932: for (lpTemp = OBJTEMP, i=0; *lpTemp; szTmp[i++] = *lpTemp++); ! 933: ! 934: //* this API creates a static object ! 935: if (Error(OleObjectConvert(pItem->lpObject, STATICP, (LPOLECLIENT)pItem, ! 936: pItem->lhcDoc, szTmp, &lpObjectTmp))) ! 937: return; ! 938: //* delete old object ! 939: if (Error(OleDelete(pItem->lpObject))) ! 940: return; ! 941: ! 942: WaitForObject(pItem); ! 943: ! 944: pItem->lpObject = lpObjectTmp; ! 945: pItem->otObject = OT_STATIC; ! 946: pItem->uoObject = -1L; ! 947: ! 948: for (lpTemp = OBJPREFIX, i=0; *lpTemp; szTmp[i++] = *lpTemp++); ! 949: if (Error(OleRename(pItem->lpObject,szTmp))) ! 950: return; ! 951: ! 952: ! 953: } ! 954: ! 955: /*************************************************************************** ! 956: * ObjCreateWrap() ! 957: * ! 958: * Create a wrapped object from the drag and drop feature of the 3.1 shell. ! 959: * NOTE: We are assuming that only one file has been dropped. See the SDK ! 960: * documentation for instructions on how to deal with multiple files. ! 961: ***************************************************************************/ ! 962: ! 963: VOID FAR ObjCreateWrap( //* ENTRY: ! 964: HANDLE hdrop, //* handle to dropped object ! 965: LHCLIENTDOC lhcDoc, //* document handle ! 966: LPOLECLIENT lpClient //* pointer to client structure ! 967: ){ //* LOCAL: ! 968: CHAR szDragDrop[CBPATHMAX];//* Drag and drop file name ! 969: LPOLEOBJECT lpObject; //* pointer to OLE object ! 970: POINT pt; //* position of dropped object ! 971: RECT rc; //* object size and position ! 972: CHAR szTmp[CBOBJNAMEMAX]; //* buffer for unique object name ! 973: APPITEMPTR pItem; //* application item pointer ! 974: INT x,y; //* icon sizes ! 975: ! 976: x = GetSystemMetrics(SM_CXICON) / 2; ! 977: y = GetSystemMetrics(SM_CYICON) / 2; ! 978: //* Get the drag and drop filename ! 979: //* position ! 980: DragQueryPoint(hdrop, &pt); ! 981: DragQueryFile(hdrop, 0, szDragDrop, CBPATHMAX); ! 982: DragFinish(hdrop); ! 983: ! 984: SetRect(&rc, pt.x - x, pt.y - y, pt.x + x, pt.y + y); ! 985: ! 986: if (!(pItem = PreItemCreate(lpClient, TRUE, lhcDoc))) ! 987: return; //* ERROR return ! 988: //* create OLE object ! 989: if (Error(OleCreateFromFile(STDFILEEDITING, (LPOLECLIENT)pItem, ! 990: "Package", szDragDrop, lhcDoc, CreateNewUniqueName(szTmp), ! 991: &lpObject, olerender_draw, 0))) ! 992: { ! 993: ErrorMessage(E_FAILED_TO_CREATE_OBJECT); ! 994: FreeAppItem(pItem); ! 995: return; //* ERROR return ! 996: } ! 997: ! 998: if (PostItemCreate(lpObject, OT_EMBEDDED, &rc, pItem)) ! 999: ShowNewWindow(pItem); ! 1000: ! 1001: } //* SUCCESS return ! 1002: ! 1003: /*************************************************************************** ! 1004: * UpdateObjectMenuItem() ! 1005: * ! 1006: * Add an object popup menu for the chosen object if multiple verbs exist. ! 1007: * The registration system is used to determine which verbs exist for the ! 1008: * given object. ! 1009: **************************************************************************/ ! 1010: ! 1011: VOID FAR UpdateObjectMenuItem( //* ENTRY: ! 1012: HMENU hMenu //* main menu ! 1013: ){ //* LOCAL ! 1014: INT cVerbs; //* verb ! 1015: APPITEMPTR pItem; //* application item ponter ! 1016: DWORD dwSize = KEYNAMESIZE; ! 1017: CHAR szClass[KEYNAMESIZE], szBuffer[200]; ! 1018: CHAR szVerb[KEYNAMESIZE]; ! 1019: HMENU hPopupNew=NULL; ! 1020: HKEY hkeyTemp; ! 1021: CHAR pLinkData[OBJECT_LINK_MAX]; ! 1022: //* delete current item and submenu ! 1023: DeleteMenu(hMenu, POS_OBJECT, MF_BYPOSITION ); ! 1024: ! 1025: if (!(pItem = GetTopItem()) ) ! 1026: goto Error; //* ERROR jump ! 1027: else if (!pItem->fVisible) ! 1028: goto Error; //* ERROR jump ! 1029: //* if STATIC ? ! 1030: if ((pItem->otObject != OT_EMBEDDED) && (pItem->otObject != OT_LINK)) ! 1031: goto Error; //* ERROR jump ! 1032: ! 1033: if (!ObjGetData(pItem, pLinkData)) //* get linkdata as key reg database ! 1034: goto Error; //* ERROR jump ! 1035: //* open reg database ! 1036: szClass[0] = NULL; ! 1037: if (RegOpenKey(HKEY_CLASSES_ROOT, szClass, &hkeyTemp)) ! 1038: goto Error; //* ERROR jump ! 1039: //* check if class is reg-db ! 1040: if (RegQueryValue(HKEY_CLASSES_ROOT, pLinkData, szClass, &dwSize)) ! 1041: { ! 1042: RegCloseKey(hkeyTemp); ! 1043: goto Error; //* ERROR jump ! 1044: } ! 1045: ! 1046: for (cVerbs=0; ;++cVerbs) //* extract all verbs from reg-db ! 1047: { ! 1048: dwSize = KEYNAMESIZE; ! 1049: wsprintf(szBuffer, "%s\\protocol\\StdFileEditing\\verb\\%d", ! 1050: (LPSTR)pLinkData,cVerbs); ! 1051: ! 1052: if (RegQueryValue(HKEY_CLASSES_ROOT, szBuffer, szVerb, &dwSize)) ! 1053: break; ! 1054: ! 1055: if (!hPopupNew) ! 1056: hPopupNew = CreatePopupMenu(); ! 1057: ! 1058: InsertMenu(hPopupNew, (UINT)-1, MF_BYPOSITION, IDM_VERBMIN+cVerbs, szVerb); ! 1059: } ! 1060: ! 1061: //* NOTE: For International versions the following verb menu ! 1062: //* may need to be formatted differently. ! 1063: ! 1064: switch (cVerbs) //* determine how many verbs found ! 1065: { ! 1066: case 0: //* none ! 1067: wsprintf(szBuffer, "Edit %s %s", (LPSTR)szClass, (LPSTR)"&Object"); ! 1068: InsertMenu(hMenu, POS_OBJECT, MF_BYPOSITION, IDM_VERBMIN, szBuffer); ! 1069: break; ! 1070: ! 1071: case 1: //* one ! 1072: wsprintf(szBuffer, "%s %s %s", (LPSTR)szVerb, (LPSTR)szClass, ! 1073: (LPSTR)"&Object"); ! 1074: DestroyMenu(hPopupNew); ! 1075: InsertMenu(hMenu, POS_OBJECT, MF_BYPOSITION, IDM_VERBMIN, szBuffer); ! 1076: break; ! 1077: ! 1078: default: //* > 1 ! 1079: wsprintf(szBuffer, "%s %s", (LPSTR)szClass, (LPSTR)"&Object"); ! 1080: InsertMenu(hMenu, POS_OBJECT, MF_BYPOSITION | MF_POPUP, (UINT)hPopupNew, szBuffer); ! 1081: EnableMenuItem(hMenu, POS_OBJECT, MF_ENABLED|MF_BYPOSITION); ! 1082: break; ! 1083: } ! 1084: ! 1085: RegCloseKey(hkeyTemp); //* close reg-db ! 1086: return; //* SUCCESS return ! 1087: ! 1088: Error: //* ERROR tag ! 1089: InsertMenu(hMenu, POS_OBJECT, MF_BYPOSITION, NULL, "&Object"); ! 1090: EnableMenuItem(hMenu, POS_OBJECT, MF_GRAYED | MF_BYPOSITION); ! 1091: ! 1092: } //* ERROR return ! 1093: ! 1094: /*************************************************************************** ! 1095: * ExecuteVerb() ! 1096: * ! 1097: * Execute the verb for the given object. ! 1098: ***************************************************************************/ ! 1099: ! 1100: VOID FAR ExecuteVerb( //* ENTRY: ! 1101: UINT iVerb, //* verb ! 1102: APPITEMPTR pItem //* application item pointer ! 1103: ){ //* LOCAL ! 1104: RECT rc; //* holds client area bounding rect ! 1105: ! 1106: if (pItem->otObject == OT_STATIC) //* if the object is static beep ! 1107: { ! 1108: ErrorMessage(W_STATIC_OBJECT); ! 1109: return; //* return ! 1110: } ! 1111: //* get cliet area rectangle ! 1112: GetClientRect(hwndFrame, (LPRECT)&rc); ! 1113: //* execute OLE verb ! 1114: if (Error(OleActivate(pItem->lpObject, iVerb, TRUE, TRUE, hwndFrame, &rc))) ! 1115: return; ! 1116: ! 1117: WaitForObject(pItem); //* wait for async. operation ! 1118: ! 1119: ObjSetBounds(pItem); ! 1120: ! 1121: ! 1122: } //* SUCCESS return ! 1123: ! 1124: /**************************************************************************** ! 1125: * ObjSetBounds ! 1126: * ! 1127: * Set the object bounds. The object bounds are the child windos bounding ! 1128: * rectangle. OLE servers recieve need the bounding rectangle in HIMETRIC ! 1129: * coordinates. So, we convert from screen coordinates to HIMETRIC. ! 1130: * ! 1131: * Returns BOOL - TRUE if successful. ! 1132: ***************************************************************************/ ! 1133: ! 1134: BOOL FAR ObjSetBounds( //* ENTRY: ! 1135: APPITEMPTR pItem //* application item pointer ! 1136: ){ //* LOCAL: ! 1137: RECT itemRect; //* bounding rectangle ! 1138: HDC hdc; ! 1139: ! 1140: GetWindowRect(pItem->hwnd,&itemRect);//* get item window react ! 1141: ! 1142: itemRect.right = ( itemRect.right - itemRect.left ) - 2 * GetSystemMetrics(SM_CXFRAME); ! 1143: itemRect.bottom = ( itemRect.bottom - itemRect.top ) - 2 * GetSystemMetrics(SM_CYFRAME); ! 1144: itemRect.top = NULL; ! 1145: itemRect.left = NULL; ! 1146: ! 1147: hdc = GetDC(NULL); ! 1148: SetMapMode(hdc,MM_HIMETRIC); ! 1149: ! 1150: DPtoLP(hdc,(LPPOINT)&itemRect.right,1); ! 1151: ! 1152: ReleaseDC(NULL,hdc); ! 1153: //* set the rect for the server ! 1154: if (Error(OleSetBounds(pItem->lpObject,(LPRECT)&itemRect))) ! 1155: return FALSE; //* ERROR return ! 1156: ! 1157: WaitForObject(pItem); //* wait for async. operation ! 1158: return TRUE; //* SUCCESS return ! 1159: ! 1160: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.