![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to obj.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / ole / srvrdemo|
Return to obj.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / ole / srvrdemo |
1.1 root 1: /*
2: OLE SERVER DEMO
3: Obj.c
4:
5: This file contains object methods and various object-related support
6: functions.
7:
8: (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved
9: */
10:
11: /*
12: Important Note:
13:
14: No method should ever dispatch a DDE message or allow a DDE message to
15: be dispatched.
16: Therefore, no method should ever enter a message dispatch loop.
17: Also, a method should not show a dialog or message box, because the
18: processing of the dialog box messages will allow DDE messages to be
19: dispatched.
20: */
21:
22:
23: #define SERVERONLY
24: #include <windows.h>
25: #include <ole.h>
26:
27: #include "srvrdemo.h"
28:
29:
30:
31: // Static functions.
32: static HBITMAP GetBitmap (LPOBJ lpobj);
33: static HANDLE GetLink (LPOBJ lpobj);
34: static HANDLE GetMetafilePict (LPOBJ lpobj);
35: static HANDLE GetEnhMetafile (LPOBJ lpobj);
36: static HANDLE GetNative (LPOBJ lpobj);
37: static INT GetObjNum (LPOBJ lpobj);
38: static HANDLE GetText (LPOBJ lpobj);
39: static VOID DrawObj (HDC hdc, LPOBJ lpobj, RECT rc, INT dctype);
40:
41:
42:
43: /* CreateNewObj
44: * ------------
45: *
46: * BOOL fDoc_Changed - The new value for the global variable fDocChanged.
47: * When initializing a new document, we need to create
48: * a new object without the creation counting as a
49: * change to the document.
50: *
51: * RETURNS: A pointer to the new object
52: *
53: *
54: * CUSTOMIZATION: Re-implement
55: * Some applications (like Server Demo) have a finite number of
56: * fixed, distinct, non-overlapping objects. Other applications
57: * allow the user to create an object from any section of the
58: * document. For example, the user might select a portion of
59: * a bitmap from a paint program, or a few lines of text from
60: * a word processor. This latter type of application probably
61: * will not have a function like CreateNewObj.
62: *
63: */
64: LPOBJ CreateNewObj (BOOL fDoc_Changed)
65: {
66: HANDLE hObj = NULL;
67: LPOBJ lpobj = NULL;
68: // index into an array of flags indicating if that object number is used.
69: INT ifObj = 0;
70:
71: if ((hObj = LocalAlloc (LMEM_MOVEABLE|LMEM_ZEROINIT, sizeof (OBJ))) == NULL)
72: return NULL;
73:
74: if ((lpobj = (LPOBJ) LocalLock (hObj)) == NULL)
75: {
76: LocalFree (hObj);
77: return NULL;
78: }
79:
80: // Fill the fields in the object structure.
81:
82: // Find an unused number.
83: for (ifObj=1; ifObj <= cfObjNums; ifObj++)
84: {
85: if (docMain.rgfObjNums[ifObj]==FALSE)
86: {
87: docMain.rgfObjNums[ifObj]=TRUE;
88: break;
89: }
90: }
91:
92: if (ifObj==cfObjNums+1)
93: {
94: // Cannot create any more objects.
95: MessageBeep(0);
96: return NULL;
97: }
98:
99: wsprintf (lpobj->native.szName, "Object %d", ifObj);
100:
101: lpobj->aName = GlobalAddAtom (lpobj->native.szName);
102: lpobj->hObj = hObj;
103: lpobj->oleobject.lpvtbl = &objvtbl;
104: lpobj->native.idmColor = IDM_RED; // Default color
105: lpobj->native.version = version;
106: lpobj->native.nWidth = OBJECT_WIDTH; // Default size
107: lpobj->native.nHeight = OBJECT_HEIGHT;
108: SetHiMetricFields (lpobj);
109:
110: // Place object in a location corrsponding to its number, for aesthetics.
111: lpobj->native.nX = (ifObj - 1) * 20;
112: lpobj->native.nY = (ifObj - 1) * 20;
113:
114: if (!CreateWindow (
115: "ObjClass",
116: "Obj",
117: WS_BORDER | WS_THICKFRAME | WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE,
118: lpobj->native.nX,
119: lpobj->native.nY,
120: lpobj->native.nWidth,
121: lpobj->native.nHeight,
122: hwndMain,
123: NULL,
124: hInst,
125: (LPSTR) lpobj ))
126: return FALSE;
127:
128: fDocChanged = fDoc_Changed;
129:
130: return lpobj;
131: }
132:
133:
134:
135: /* CutOrCopyObj
136: * ------------
137: *
138: * Put data onto clipboard in all the formats supported. If the
139: * fOpIsCopy is TRUE, the operation is COPY, otherwise it is CUT.
140: * This is important, because we cannot put the Object Link format
141: * onto the clipboard if the object was cut from the document (there is
142: * no longer anything to link to).
143: *
144: * BOOL fOpIsCopy - TRUE if the operation is COPY; FALSE if CUT
145: *
146: * CUSTOMIZATION: None
147: *
148: *
149: */
150: VOID CutOrCopyObj (BOOL fOpIsCopy)
151: {
152: LPOBJ lpobj;
153: HANDLE hData;
154:
155: if (OpenClipboard (hwndMain))
156: {
157: EmptyClipboard ();
158:
159: lpobj = SelectedObject();
160:
161: if ((hData = GetNative (lpobj)) != NULL)
162: SetClipboardData(cfNative, hData);
163:
164: if ((hData = GetLink(lpobj)) != NULL)
165: SetClipboardData(cfOwnerLink, hData);
166:
167: if (fOpIsCopy && docMain.doctype == doctypeFromFile)
168: {
169: // Can create a link if object exists in a file.
170: if ((hData = GetLink(lpobj)) != NULL)
171: SetClipboardData(cfObjectLink, hData);
172: }
173:
174: if ((hData = GetEnhMetafile(lpobj)) != NULL)
175: {
176: SetClipboardData(CF_ENHMETAFILE, hData);
177: // GlobalFree(hData);
178: }
179:
180: if ((hData = GetBitmap(lpobj)) != NULL)
181: {
182: SetClipboardData(CF_BITMAP, hData);
183: // DeleteObject(hData);
184: }
185:
186:
187: CloseClipboard ();
188: }
189: }
190:
191:
192: /* DestroyObj
193: * ----------
194: *
195: * Revoke an object, and free all memory that had been allocated for it.
196: *
197: * HWND hwnd - The object's window
198: *
199: * CUSTOMIZATION: Re-implement, making sure you free all the memory that
200: * had been allocated for the OBJ structure and each of its
201: * fields.
202: *
203: */
204: VOID DestroyObj (HWND hwnd)
205: {
206: LPOBJ lpobj = HwndToLpobj (hwnd);
207:
208: if(lpobj->aName)
209: {
210: GlobalDeleteAtom (lpobj->aName);
211: lpobj->aName = NULL;
212: }
213:
214: if (lpobj->hpal)
215: DeleteObject (lpobj->hpal);
216: // Allow the object's number to be reused.
217: docMain.rgfObjNums [GetObjNum(lpobj)] = FALSE;
218:
219:
220: // Free the memory that had been allocated for the object structure itself.
221: LocalUnlock (lpobj->hObj);
222: LocalFree (lpobj->hObj);
223: }
224:
225:
226:
227: /* DrawObj
228: * -------
229: *
230: * This function draws an object onto the screen, into a metafile, or into
231: * a bitmap.
232: * The object will always look the same.
233: *
234: * HDC hdc - The device context to render the object into
235: * LPOBJ lpobj - The object to render
236: * RECT rc - The rectangle bounds of the object
237: * DCTYPE dctype - The type of device context.
238: *
239: * CUSTOMIZATION: Server Demo specific
240: *
241: */
242: static VOID DrawObj (HDC hdc, LPOBJ lpobj, RECT rc, INT dctype)
243: {
244: HPEN hpen;
245: HPEN hpenOld;
246: HPALETTE hpalOld = NULL;
247:
248: if (dctype == dctypeMetafile || dctype == dctypeEnhMetafile)
249: {
250: SetWindowOrgEx (hdc, 0, 0, NULL);
251: // Paint entire object into the given rectangle.
252: SetWindowExtEx (hdc, rc.right, rc.bottom, NULL);
253: }
254:
255: if (lpobj->hpal)
256: {
257: hpalOld = SelectPalette (hdc, lpobj->hpal, TRUE);
258: RealizePalette (hdc);
259: }
260:
261: // Select brush of the color specified in the native data.
262: SelectObject (hdc, hbrColor [lpobj->native.idmColor - IDM_RED] );
263:
264: hpen = CreatePen (PS_SOLID,
265: /* Width */ (rc.bottom-rc.top) / 10,
266: /* Gray */ 0x00808080);
267: hpenOld = SelectObject (hdc, hpen);
268:
269: // Draw rectangle with the gray pen and fill it in with the selected brush.
270: Rectangle(hdc, rc.left, rc.top, rc.right, rc.bottom);
271:
272: // Print name of object inside rectangle.
273: SetBkMode (hdc, TRANSPARENT);
274: SetTextAlign (hdc, TA_BASELINE | TA_CENTER);
275: TextOut (hdc,
276: rc.right/2,
277: (rc.top+rc.bottom)/2,
278: lpobj->native.szName,
279: lstrlen (lpobj->native.szName));
280:
281: // Restore original objects
282: SelectObject (hdc,
283: (dctype == dctypeMetafile || dctype == dctypeEnhMetafile)
284: ? GetStockObject (BLACK_PEN) : hpenOld);
285: if (hpalOld)
286: {
287: SelectPalette (hdc,
288: (dctype == dctypeMetafile || dctype == dctypeEnhMetafile)
289: ? GetStockObject (DEFAULT_PALETTE) : hpalOld,
290: TRUE);
291: }
292:
293: DeleteObject (hpen);
294: }
295:
296:
297:
298: /* GetBitmap
299: * ---------
300: *
301: * Return a handle to an object's picture data in bitmap format.
302: *
303: * LPOBJ lpobj - The object
304: *
305: * RETURNS: A handle to the object's picture data
306: *
307: * CUSTOMIZATION: Re-implement
308: *
309: */
310: static HBITMAP GetBitmap (LPOBJ lpobj)
311: {
312: HDC hdcObj;
313: HDC hdcMem;
314: RECT rc;
315: HBITMAP hbitmap;
316: HBITMAP hbitmapOld;
317:
318:
319: hdcObj = GetDC (lpobj->hwnd);
320: // Create a memory device context.
321: hdcMem = CreateCompatibleDC (hdcObj);
322: GetClientRect (lpobj->hwnd, (LPRECT)&rc);
323: // Create new bitmap object based on the bitmap of the OLE object.
324: hbitmap = CreateCompatibleBitmap
325: (hdcObj, rc.right - rc.left, rc.bottom - rc.top);
326: // Select new bitmap as the bitmap object for the memory device context.
327: hbitmapOld = SelectObject (hdcMem, hbitmap);
328:
329: // Paint directly into the memory dc using the new bitmap object.
330: DrawObj (hdcMem, lpobj, rc, dctypeBitmap);
331:
332: // Restore old bitmap object.
333: hbitmap = SelectObject (hdcMem, hbitmapOld);
334: DeleteDC (hdcMem);
335: ReleaseDC (lpobj->hwnd, hdcObj);
336:
337: // convert width and height to HIMETRIC units
338: rc.right = rc.right - rc.left;
339: rc.bottom = rc.bottom - rc.top;
340: DeviceToHiMetric (hwndMain, (LPPOINT) &rc.right);
341:
342: // Set the 1/10 of HIMETRIC units for the bitmap
343: SetBitmapDimensionEx (hbitmap, (DWORD) (rc.right/10), (DWORD) (rc.bottom/10), NULL);
344:
345: return hbitmap;
346: }
347:
348:
349:
350: /* GetLink
351: * -------
352: *
353: * Return a handle to an object's object or owner link data.
354: * Link information is in the form of three zero-separated strings,
355: * terminated with two zero bytes: CLASSNAME\0DOCNAME\0OBJNAME\0\0
356: *
357: * LPOBJ lpobj - The object
358: *
359: * RETURNS: A handle to the object's link data
360: *
361: * CUSTOMIZATION: Re-implement
362: *
363: */
364: static HANDLE GetLink (LPOBJ lpobj)
365: {
366:
367: CHAR sz[cchFilenameMax];
368: LPSTR lpszLink = NULL;
369: HANDLE hLink = NULL;
370: INT cchLen;
371: INT i;
372:
373: // First make the class name.
374: lstrcpy (sz, szClassName);
375: cchLen = lstrlen (sz) + 1;
376:
377: // Then the document name.
378: cchLen += GlobalGetAtomName
379: (docMain.aName, (LPSTR)sz + cchLen,
380: cchFilenameMax - cchLen) + 1;
381:
382: // Then the object name.
383: lstrcpy (sz + cchLen, lpobj->native.szName);
384: cchLen += lstrlen (lpobj->native.szName) + 1;
385:
386: // Add a second null to the end.
387: sz[cchLen++] = 0;
388:
389:
390: hLink = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, cchLen);
391: if (hLink == NULL)
392: return NULL;
393: if ((lpszLink = GlobalLock (hLink)) == NULL)
394: {
395: GlobalFree (hLink);
396: return NULL;
397: }
398:
399: for (i=0; i < cchLen; i++)
400: lpszLink[i] = sz[i];
401:
402: GlobalUnlock (hLink);
403:
404: return hLink;
405: }
406:
407:
408:
409: /* GetMetafilePict
410: * ---------------
411: *
412: * Return a handle to an object's picture data in metafile format.
413: *
414: * LPOBJ lpobj - The object
415: *
416: * RETURNS: A handle to the object's data in metafile format.
417: *
418: * CUSTOMIZATION: Re-implement
419: *
420: */
421: static HANDLE GetMetafilePict (LPOBJ lpobj)
422: {
423:
424: LPMETAFILEPICT lppict = NULL;
425: HANDLE hpict = NULL;
426: HANDLE hMF = NULL;
427: RECT rc;
428: HDC hdc;
429:
430: hdc = CreateMetaFile(NULL);
431:
432: GetClientRect (lpobj->hwnd, (LPRECT)&rc);
433:
434: // Paint directly into the metafile.
435: DrawObj (hdc, lpobj, rc, dctypeMetafile);
436:
437: // Get handle to the metafile.
438: if ((hMF = CloseMetaFile (hdc)) == NULL)
439: return NULL;
440:
441: if(!(hpict = GlobalAlloc (GMEM_DDESHARE, sizeof (METAFILEPICT))))
442: {
443: DeleteMetaFile (hMF);
444: return NULL;
445: }
446:
447: if ((lppict = (LPMETAFILEPICT)GlobalLock (hpict)) == NULL)
448: {
449: DeleteMetaFile (hMF);
450: GlobalFree (hpict);
451: return NULL;
452: }
453:
454: rc.right = rc.right - rc.left;
455: rc.bottom = rc.bottom - rc.top;
456:
457: DeviceToHiMetric (hwndMain, (LPPOINT) &rc.right);
458:
459: lppict->mm = MM_ANISOTROPIC;
460: lppict->hMF = hMF;
461: lppict->xExt = rc.right;
462: lppict->yExt = rc.bottom;
463: GlobalUnlock (hpict);
464: return hpict;
465: }
466:
467: /* GetEnhMetafile
468: * ---------------
469: *
470: * Return a handle to an object's picture data in metafile format.
471: *
472: * LPOBJ lpobj - The object
473: *
474: * RETURNS: A handle to the object's data in metafile format.
475: *
476: * CUSTOMIZATION: Re-implement
477: *
478: */
479: static HANDLE GetEnhMetafile (LPOBJ lpobj)
480: {
481:
482: LPMETAFILEPICT lppict = NULL;
483: HANDLE hemf = NULL;
484: HANDLE hMF = NULL;
485: RECT rc,rect;
486: HDC hdc;
487:
488: GetClientRect (lpobj->hwnd, (LPRECT)&rc);
489:
490: rect.left = rect.top = 0;
491: rect.right = rc.right - rc.left;
492: rect.bottom = rc.bottom - rc.top;
493:
494: DeviceToHiMetric (hwndMain, (LPPOINT) &rect.right);
495:
496: hdc = CreateEnhMetaFile(NULL, NULL, &rect, NULL);
497: DrawObj (hdc, lpobj, rc, dctypeMetafile);
498: if ((hemf = (HANDLE)CloseEnhMetaFile (hdc)) == NULL)
499: return NULL;
500:
501: return hemf;
502: }
503:
504:
505: /* GetNative
506: * ---------
507: *
508: * Return a handle to an object's native data.
509: *
510: * LPOBJ lpobj - The object whose native data is to be retrieved.
511: *
512: * RETURNS: a handle to the object's native data.
513: *
514: * CUSTOMIZATION: The line "*lpnative = lpobj->native;" will change to
515: * whatever code is necessary to copy an object's native data.
516: *
517: */
518: static HANDLE GetNative (LPOBJ lpobj)
519: {
520: LPNATIVE lpnative = NULL;
521: HANDLE hNative = NULL;
522:
523: hNative = GlobalAlloc (GMEM_DDESHARE | GMEM_ZEROINIT, sizeof (NATIVE));
524: if (hNative == NULL)
525: return NULL;
526: if ((lpnative = (LPNATIVE) GlobalLock (hNative)) == NULL)
527: {
528: GlobalFree (hNative);
529: return NULL;
530: }
531:
532: // Copy the native data.
533: *lpnative = lpobj->native;
534:
535: GlobalUnlock (hNative);
536: return hNative;
537: }
538:
539:
540:
541: /* GetObjNum
542: * ---------
543: *
544: * LPSTR lpobj - The object whose number is desired
545: *
546: * RETURNS: The number of the object, i.e., the numerical portion of its name.
547: *
548: * CUSTOMIZATION: Server Demo specific
549: */
550: static INT GetObjNum (LPOBJ lpobj)
551: {
552: LPSTR lpsz;
553: INT n=0;
554:
555: lpsz = lpobj->native.szName + 7;
556: while (*lpsz && *lpsz>='0' && *lpsz<='9')
557: n = 10*n + *lpsz++ - '0';
558: return n;
559: }
560:
561:
562:
563: /* GetText
564: * -------
565: *
566: * Return a handle to an object's data in text form.
567: * This function simply returns the name of the object.
568: *
569: * LPOBJ lpobj - The object
570: *
571: * RETURNS: A handle to the object's text.
572: *
573: * CUSTOMIZATION: Re-implement, if your application supports CF_TEXT as a
574: * presentation format.
575: *
576: */
577: static HANDLE GetText (LPOBJ lpobj)
578: {
579: HANDLE hText = NULL;
580: LPSTR lpszText = NULL;
581:
582: if(!(hText = GlobalAlloc (GMEM_DDESHARE, sizeof (lpobj->native.szName))))
583: return NULL;
584:
585: if (!(lpszText = GlobalLock (hText)))
586: return NULL;
587:
588: lstrcpy (lpszText, lpobj->native.szName);
589:
590: GlobalUnlock (hText);
591:
592: return hText;
593: }
594:
595:
596:
597: /* ObjDoVerb OBJECT "DoVerb" METHOD
598: * ---------
599: *
600: * This method is called by the client, through the library, to either
601: * PLAY, or EDIT the object. PLAY is implemented as a beep, and
602: * EDIT will bring up the server and show the object for editing.
603: *
604: * LPOLEOBJECT lpoleobject - The OLE object
605: * WORD wVerb - The verb acting on the object: PLAY or EDIT
606: * BOOL fShow - Should the object be shown?
607: * BOOL fTakeFocus - Should the object window get the focus?
608: *
609: * RETURNS: OLE_OK
610: *
611: * CUSTOMIZATION: Add any more verbs your application supports.
612: * Implement verbPlay if your application supports it.
613: *
614: */
615: OLESTATUS APIENTRY ObjDoVerb
616: (LPOLEOBJECT lpoleobject, UINT wVerb, BOOL fShow, BOOL fTakeFocus)
617: {
618: switch (wVerb)
619: {
620: case verbPlay:
621: { // The application can do whatever is appropriate for the object.
622: INT i;
623: for (i=0; i<25;i++) MessageBeep (0);
624: return OLE_OK;
625: }
626:
627: case verbEdit:
628: if (fShow)
629: return objvtbl.Show (lpoleobject, fTakeFocus);
630: else
631: return OLE_OK;
632: default:
633: // Unknown verb.
634: return OLE_ERROR_DOVERB;
635: }
636: }
637:
638:
639:
640: /* ObjEnumFormats OBJECT "EnumFormats" METHOD
641: * ---------------
642: *
643: * This method is used to enumerate all supported clipboard formats.
644: * Terminate by returning NULL.
645: *
646: * LPOLEOBJECT lpoleobject - The OLE object
647: * OLECLIPFORMAT cfFormat - The 'current' clipboard format
648: *
649: * RETURNS: The 'next' clipboard format which is supported.
650: *
651: * CUSTOMIZATION: Verify that the list of formats this function
652: * returns matches the list of formats your application
653: * supports.
654: *
655: */
656: OLECLIPFORMAT APIENTRY ObjEnumFormats
657: (LPOLEOBJECT lpoleobject, OLECLIPFORMAT cfFormat)
658: {
659: if (cfFormat == 0)
660: return cfNative;
661:
662: if (cfFormat == cfNative)
663: return cfOwnerLink;
664:
665: if (cfFormat == cfOwnerLink)
666: return CF_ENHMETAFILE;
667:
668: if (cfFormat == CF_ENHMETAFILE)
669: return CF_METAFILEPICT;
670:
671: if (cfFormat == CF_METAFILEPICT)
672: return CF_BITMAP;
673:
674: if (cfFormat == CF_BITMAP)
675: return cfObjectLink;
676:
677: if (cfFormat == cfObjectLink)
678: return NULL;
679:
680: return NULL;
681: }
682:
683:
684:
685: /* ObjGetData OBJECT "GetData" METHOD
686: * -----------
687: *
688: * Return the data requested for the specified object in the specified format.
689: *
690: * LPOLEOBJECT lpoleobject - The OLE object
691: * WORD cfFormat - The data type requested in standard
692: * clipboard format
693: * LPHANDLE lphandle - Pointer to handle to memory where data
694: * will be stored
695: *
696: * RETURNS: OLE_OK if successful
697: * OLE_ERROR_MEMORY if there was an error getting the data.
698: * OLE_ERROR_FORMAT if the requested format is unknown.
699: *
700: *
701: * CUSTOMIZATION: Add any additional formats your application supports, and
702: * remove any formats it does not support.
703: *
704: */
705: OLESTATUS APIENTRY ObjGetData
706: (LPOLEOBJECT lpoleobject, OLECLIPFORMAT cfFormat, LPHANDLE lphandle)
707: {
708:
709: LPOBJ lpobj;
710:
711: lpobj = (LPOBJ) lpoleobject;
712:
713: if (cfFormat == cfNative)
714: {
715: if (!(*lphandle = GetNative (lpobj)))
716: return OLE_ERROR_MEMORY;
717: // The client has requested the data in native format, therefore
718: // the data in the client and server are in sync.
719: fDocChanged = FALSE;
720: return OLE_OK;
721: }
722:
723: if (cfFormat == CF_ENHMETAFILE)
724: {
725: if (!(*lphandle = GetEnhMetafile (lpobj)))
726: return OLE_ERROR_MEMORY;
727: return OLE_OK;
728: }
729:
730: if (cfFormat == CF_METAFILEPICT)
731: {
732: if (!(*lphandle = GetMetafilePict (lpobj)))
733: return OLE_ERROR_MEMORY;
734: return OLE_OK;
735: }
736:
737: if (cfFormat == CF_BITMAP)
738: {
739: if (!(*lphandle = (HANDLE)GetBitmap (lpobj)))
740: return OLE_ERROR_MEMORY;
741: return OLE_OK;
742: }
743:
744: if (cfFormat == CF_TEXT)
745: {
746: if (!(*lphandle = GetText (lpobj)))
747: return OLE_ERROR_MEMORY;
748: return OLE_OK;
749: }
750:
751: if (cfFormat == cfObjectLink)
752: {
753: if (!(*lphandle = GetLink (lpobj)))
754: return OLE_ERROR_MEMORY;
755: return OLE_OK;
756: }
757:
758: if (cfFormat == cfOwnerLink)
759: {
760: if (!(*lphandle = GetLink (lpobj)))
761: return OLE_ERROR_MEMORY;
762: return OLE_OK;
763: }
764:
765: return OLE_ERROR_FORMAT;
766: }
767:
768:
769:
770: /* ObjQueryProtocol OBJECT "QueryProtocol" METHOD
771: * ----------------
772: *
773: * LPOLEOBJECT lpoleobject - The OLE object
774: * LPSTR lpszProtocol - The protocol name, either "StdFileEditing"
775: * or "StdExecute"
776: *
777: * RETURNS: If lpszProtocol is supported, return a pointer to an OLEOBJECT
778: * structure with an appropriate method table for that protocol.
779: * Otherwise, return NULL.
780: *
781: * CUSTOMIZATION: Allow any additional protocols your application supports.
782: *
783: *
784: */
785: LPVOID APIENTRY ObjQueryProtocol
786: (LPOLEOBJECT lpoleobject, LPSTR lpszProtocol)
787: {
788: return lstrcmp (lpszProtocol, "StdFileEditing") ? NULL : lpoleobject ;
789: }
790:
791:
792:
793: /* ObjRelease OBJECT "Release" METHOD
794: * -----------
795: *
796: * The server application should not destroy data when the library calls the
797: * ReleaseObj method.
798: * The library calls the ReleaseObj method when no clients are connected
799: * to the object.
800: *
801: * LPOLEOBJECT lpoleobject - The OLE object
802: *
803: * RETURNS: OLE_OK
804: *
805: * CUSTOMIZATION: Re-implement. Do whatever needs to be done, if anything,
806: * when no clients are connected to an object.
807: *
808: */
809: OLESTATUS APIENTRY ObjRelease (LPOLEOBJECT lpoleobject)
810: {
811: INT i;
812: /* No client is connected to the object so break all assocaiations
813: between clients and the object. */
814: for (i=0; i < clpoleclient; i++)
815: ((LPOBJ)lpoleobject)->lpoleclient[i] = NULL;
816: return OLE_OK;
817: }
818:
819:
820:
821: /* ObjSetBounds OBJECT "SetBounds" METHOD
822: * ------------
823: *
824: * This method is called to set new bounds for an object.
825: * The bounds are in HIMETRIC units.
826: * A call to this method is ignored for linked objects because the size of
827: * a linked object depends only on the source file.
828: *
829: * LPOLEOBJECT lpoleobject - The OLE object
830: * LPRECT lprect - The new bounds
831: *
832: * RETURNS: OLE_OK
833: *
834: * CUSTOMIZATION: Re-implement
835: * How an object is sized is application-specific. (Server Demo
836: * uses MoveWindow.)
837: *
838: */
839: OLESTATUS APIENTRY ObjSetBounds (LPOLEOBJECT lpoleobj, LPRECT lprect)
840: {
841: if (docMain.doctype == doctypeEmbedded)
842: {
843: RECT rect = *lprect;
844: LPOBJ lpobj = (LPOBJ) lpoleobj;
845:
846: // the units are in HIMETRIC
847: rect.right = rect.right - rect.left;
848: rect.bottom = rect.top - rect.bottom;
849: HiMetricToDevice (hwndMain, (LPPOINT) &rect.right);
850: MoveWindow (lpobj->hwnd, lpobj->native.nX, lpobj->native.nY,
851: rect.right + 2 * GetSystemMetrics(SM_CXFRAME),
852: rect.bottom + 2 * GetSystemMetrics(SM_CYFRAME),
853: TRUE);
854: }
855: return OLE_OK;
856: }
857:
858:
859:
860: /* ObjSetColorScheme OBJECT "SetColorScheme" METHOD
861: * -----------------
862: *
863: * The client calls this method to suggest a color scheme (palette) for
864: * the server to use for the object.
865: *
866: * LPOLEOBJECT lpoleobject - The OLE object
867: * LPLOGPALETTE lppal - Suggested palette
868: *
869: * RETURNS: OLE_ERROR_PALETTE if CreatePalette fails,
870: * OLE_OK otherwise
871: *
872: *
873: * CUSTOMIZATION: If your application supports color schemes, then this
874: * function is a good example of how to create and store
875: * a palette.
876: *
877: */
878: OLESTATUS APIENTRY ObjSetColorScheme
879: (LPOLEOBJECT lpoleobject, LPLOGPALETTE lppal)
880: {
881: HPALETTE hpal = CreatePalette (lppal);
882: LPOBJ lpobj = (LPOBJ) lpoleobject;
883:
884: if (hpal==NULL)
885: return OLE_ERROR_PALETTE;
886:
887: if (lpobj->hpal)
888: DeleteObject (lpobj->hpal);
889: lpobj->hpal = hpal;
890: return OLE_OK;
891: }
892:
893:
894:
895: /* ObjSetData OBJECT "SetData" METHOD
896: * ----------
897: *
898: * This method is used to store data into the object in the specified
899: * format. This will be called with Native format after an embedded
900: * object has been opened by the Edit method.
901: *
902: * LPOLEOBJECT lpoleobject - The OLE object
903: * WORD cfFormat - Data type, i.e., clipboard format
904: * HANDLE hdata - Handle to the data.
905: *
906: * RETURNS: OLE_OK if the data was stored properly
907: * OLE_ERROR_FORMAT if format was not cfNative.
908: * OLE_ERROR_MEMORY if memory could not be locked.
909: *
910: * CUSTOMIZATION: The large then-clause will need to be re-implemented for
911: * your application. You may wish to support additional
912: * formats besides cfNative.
913: *
914: */
915: OLESTATUS APIENTRY ObjSetData
916: (LPOLEOBJECT lpoleobject, OLECLIPFORMAT cfFormat, HANDLE hdata)
917: {
918: LPNATIVE lpnative;
919: LPOBJ lpobj;
920:
921: lpobj = (LPOBJ)lpoleobject;
922:
923: if (cfFormat != cfNative)
924: {
925: return OLE_ERROR_FORMAT;
926: }
927:
928: lpnative = (LPNATIVE) GlobalLock (hdata);
929:
930: if (lpnative)
931: {
932: lpobj->native = *lpnative;
933: if (lpobj->aName)
934: GlobalDeleteAtom (lpobj->aName);
935: lpobj->aName = GlobalAddAtom (lpnative->szName);
936: // CreateNewObj made an "Object 1" but we may be changing its number.
937: docMain.rgfObjNums[1] = FALSE;
938: docMain.rgfObjNums [GetObjNum(lpobj)] = TRUE;
939:
940: MoveWindow (lpobj->hwnd, 0, 0,
941: lpobj->native.nWidth + 2 * GetSystemMetrics(SM_CXFRAME),
942: lpobj->native.nHeight+ 2 * GetSystemMetrics(SM_CYFRAME),
943: FALSE);
944: GlobalUnlock (hdata);
945: }
946: // Server is responsible for deleting the data.
947: GlobalFree(hdata);
948: return lpnative ? OLE_OK : OLE_ERROR_MEMORY;
949: }
950:
951:
952:
953: /* ObjSetTargetDevice OBJECT "SetTargetDevice" METHOD
954: * -------------------
955: *
956: * This method is used to indicate the device type that an object
957: * will be rendered on. It is the server's responsibility to free hdata.
958: *
959: * LPOLEOBJECT lpoleobject - The OLE object
960: * HANDLE hdata - Handle to memory containing
961: * a StdTargetDevice structure
962: *
963: * RETURNS: OLE_OK
964: *
965: * CUSTOMIZATION: Implement. Server Demo currently does not do anything.
966: *
967: */
968: OLESTATUS APIENTRY ObjSetTargetDevice (LPOLEOBJECT lpoleobject, HANDLE hdata)
969: {
970: if (hdata == NULL)
971: {
972: // Rendering for the screen is requested.
973: }
974: else
975: {
976: LPSTR lpstd = (LPSTR) GlobalLock (hdata);
977: // lpstd points to a StdTargetDevice structure.
978: // Use it to do whatever is appropriate to generate the best results
979: // on the specified target device.
980: GlobalUnlock (hdata);
981: // Server is responsible for freeing the data.
982: GlobalFree (hdata);
983: }
984: return OLE_OK;
985: }
986:
987:
988:
989: /* ObjShow OBJECT "Show" METHOD
990: * --------
991: *
992: * This method is used to display the object.
993: * The server application should be activated and brought to the top.
994: * Also, in a REAL server application, the object should be scrolled
995: * into view. The object should be selected.
996: *
997: * LPOLEOBJECT lpoleobject - Pointer to the OLE object
998: * BOOL fTakeFocus - Should server window get the focus?
999: *
1000: * RETURNS: OLE_OK
1001: *
1002: *
1003: * CUSTOMIZATION: In your application, the document should be scrolled
1004: * to bring the object into view. Server Demo brings the
1005: * object to the front, in case it is a linked object inside a
1006: * document with other objects obscuring it.
1007: *
1008: */
1009: OLESTATUS APIENTRY ObjShow (LPOLEOBJECT lpoleobject, BOOL fTakeFocus)
1010: {
1011: LPOBJ lpobj;
1012: HWND hwndOldFocus;
1013:
1014: hwndOldFocus = GetFocus();
1015: lpobj = (LPOBJ) lpoleobject;
1016:
1017: if (fTakeFocus)
1018: SetForegroundWindow (lpobj->hwnd);
1019:
1020: ShowWindow(hwndMain, SW_SHOWNORMAL);
1021:
1022: SetFocus (fTakeFocus ? lpobj->hwnd : hwndOldFocus);
1023: return OLE_OK;
1024: }
1025:
1026:
1027:
1028: /* PaintObj
1029: * ---------
1030: *
1031: * This function is called by the WM_PAINT message to paint an object
1032: * on the screen.
1033: *
1034: * HWND hwnd - The object window in which to paint the object
1035: *
1036: * CUSTOMIZATION: Server Demo specific
1037: *
1038: */
1039: VOID PaintObj (HWND hwnd)
1040: {
1041: LPOBJ lpobj;
1042: RECT rc;
1043: HDC hdc;
1044: PAINTSTRUCT paintstruct;
1045:
1046: BeginPaint (hwnd, &paintstruct);
1047: hdc = GetDC (hwnd);
1048:
1049: lpobj = HwndToLpobj (hwnd);
1050: GetClientRect (hwnd, (LPRECT) &rc);
1051:
1052: DrawObj (hdc, lpobj, rc, dctypeScreen);
1053:
1054: ReleaseDC (hwnd, hdc);
1055: EndPaint (hwnd, &paintstruct);
1056: }
1057:
1058:
1059:
1060: /* RevokeObj
1061: * ---------
1062: *
1063: * Call OleRevokeObject because the user has destroyed the object.
1064: *
1065: * LPOBJ lpobj - The object which has been destroyed
1066: *
1067: *
1068: * CUSTOMIZATION: You will only need to call OleRevokeObject once if there
1069: * is only one LPOLECLIENT in your OBJ structure, which there
1070: * should be.
1071: *
1072: */
1073: VOID RevokeObj (LPOBJ lpobj)
1074: {
1075: INT i;
1076:
1077: for (i=0; i< clpoleclient; i++)
1078: {
1079: if (lpobj->lpoleclient[i])
1080: OleRevokeObject (lpobj->lpoleclient[i]);
1081: else
1082: /* if lpobj->lpoleclient[i]==NULL then there are no more non-NULLs
1083: in the array. */
1084: break;
1085: }
1086: }
1087:
1088:
1089:
1090: /* SendObjMsg
1091: * ----------
1092: *
1093: * This function sends a message to a specific object.
1094: *
1095: * LPOBJ lpobj - The object
1096: * WORD wMessage - The message to send
1097: *
1098: * CUSTOMIZATION: You will only need to call CallBack once if there
1099: * is only one LPOLECLIENT in your OBJ structure, which there
1100: * should be.
1101: *
1102: */
1103: VOID SendObjMsg (LPOBJ lpobj, WORD wMessage)
1104: {
1105: INT i;
1106: for (i=0; i < clpoleclient; i++)
1107: {
1108: if (lpobj->lpoleclient[i])
1109: {
1110: // Call the object's Callback function.
1111: lpobj->lpoleclient[i]->lpvtbl->CallBack
1112: (lpobj->lpoleclient[i], wMessage, (LPOLEOBJECT) lpobj);
1113: }
1114: else
1115: break;
1116: }
1117: }
1118:
1119:
1120:
1121: /* SizeObj
1122: * -------
1123: *
1124: * Change the size of an object.
1125: *
1126: * HWND hwnd - The object's window
1127: * RECT rect - The requested new size in device units
1128: * BOOL fMove - Should the object be moved? (or just resized?)
1129: *
1130: * CUSTOMIZATION: Server Demo specific
1131: *
1132: */
1133: VOID SizeObj (HWND hwnd, RECT rect, BOOL fMove)
1134: {
1135: LPOBJ lpobj;
1136:
1137: lpobj = HwndToLpobj (hwnd);
1138: if (fMove)
1139: {
1140: lpobj->native.nX = rect.left;
1141: lpobj->native.nY = rect.top;
1142: }
1143: lpobj->native.nWidth = rect.right - rect.left;
1144: lpobj->native.nHeight = rect.bottom - rect.top ;
1145: SetHiMetricFields (lpobj);
1146: InvalidateRect (hwnd, (LPRECT)NULL, TRUE);
1147: fDocChanged = TRUE;
1148: if (docMain.doctype == doctypeFromFile)
1149: {
1150: // If object is linked, update it in client now.
1151: SendObjMsg (lpobj, OLE_CHANGED);
1152: }
1153: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.