![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clipview.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / clipview|
Return to clipview.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / clipview |
1.1 root 1: /*
2: * CLIPVIEW.C -- Clipboard Viewing application
3: * Created by Microsoft, IBM Corporation, 1990
4: *
5: * DISCLAIMER OF WARRANTIES. The following [enclosed] code is
6: * sample code created by Microsoft Corporation and/or IBM
7: * Corporation. This sample code is not part of any standard
8: * Microsoft or IBM product and is provided to you solely for
9: * the purpose of assisting you in the development of your
10: * applications. The code is provided "AS IS", without
11: * warranty of any kind. Neither Microsoft nor IBM shall be
12: * liable for any damages arising out of your use of the sample
13: * code, even if they have been advised of the possibility of
14: * such damages.
15: *
16: * This program registers itself as the clipboard viewer, if no clipboard
17: * viewer exists. Then, it intercepts WM_DRAWCLIPBOARD messages.
18: *
19: * This file contains the routines which handle the client/frame windows,
20: * the dialog routines, and the clipboard rendering code.
21: */
22:
23:
24: /* Currently MLE control are not implemented in OS/2 2.0 therefore
25: * all references to MLE have been #defined out of the picture
26: * as soon as they become implemented uncomment MLE_OK and everything
27: * should work as originally intended
28: */
29:
30:
31: /*****************
32:
33:
34: #define MLE_OK
35:
36:
37: ******************/
38:
39:
40:
41:
42: #define INCL_GPIBITMAPS
43: #define INCL_GPIMETAFILES
44: #define INCL_WINATOM
45: #define INCL_WINCLIPBOARD
46: #define INCL_WINFRAMEMGR
47: #define INCL_WINLISTBOXES
48: #define INCL_WINMENUS
49: #define INCL_WINMLE
50: #define INCL_WINSCROLLBARS
51: #define INCL_WINSYS
52: #define INCL_WINWINDOWMGR
53: #define INCL_GPILCIDS
54: #include <os2.h>
55: #include <string.h>
56: #include <ctype.h>
57: #include "clipview.h"
58: /*
59: * Globals
60: */
61: BITMAPINFOHEADER vbmp; // Dimensions of current BITMAP
62: BOOL vfUpdate = FALSE; // Are we updating the clipboard?
63: BOOL vfViewBitmap = FALSE; // Are we currently viewing a...?
64: BOOL vfViewText = FALSE; // Are we currently viewing text
65: HAB vhab; // Anchor block
66: HDC vhdcMemory; // A memory DC for BitBlt-ing images
67: HDC vhdcWindow = NULL; // Client window DC
68: HMQ vhmqClip; // Message queue
69: HPS vhpsMemory; // A PS associated with vhdcMemory
70: HWND vhwndClient; // Main client area
71: HWND vhwndClipFrame = NULL; // Main frame window
72: HWND vhwndHSB = NULL; // Horizontal scroll bar
73:
74:
75:
76: HWND vhwndMLE = NULL; // Handle to the MLE
77:
78:
79:
80: HWND vhwndTitlebar = NULL; // Title-bar handle
81: HWND vhwndVSB = NULL; // Vertical scroll bar
82: SHORT vcMaxHSB; // Maximum scroll range for HSB
83: SHORT vcMaxVSB; // ...and for the VSB
84: SHORT vcUpdate = -1; // Counter for scroll bar updating
85: USHORT vausFormats[MAXFORMATS]; // All available formats
86: USHORT vcFmts; // How many formats?
87: USHORT vusFormat; // What is the current format?
88: USHORT vfsFmtInfo; // Clipboard Format Information
89: /*
90: Macros
91: */
92: #define LOADSTRING(id, sz) WinLoadString(vhab, NULL, id, MAXLEN, sz)
93: #define MESSAGE(sz) WinMessageBox(HWND_DESKTOP, vhwndClient, sz, NULL, NULL, \
94: MB_OK | MB_ICONASTERISK | MB_SYSTEMMODAL);
95: /*
96: * Main routine...initializes window and message queue
97: */
98: int cdecl main( ) {
99: QMSG qmsg; /* Message queue */
100: ULONG ctldata; /* FCF_ flags */
101: BOOL fViewer; /* Does a viewer already exist? */
102: UCHAR szAlready[MAXLEN]; /* Already extant... message */
103: UCHAR szClassName[MAXLEN]; /* New class name */
104: /*
105: Start up our PM application
106: */
107: vhab = WinInitialize(NULL);
108: vhmqClip = WinCreateMsgQueue(vhab, 0);
109: /*
110: We create the client window first to try to avoid
111: synchronization problems.
112: */
113: LOADSTRING(IDS_CLIPCLASS, szClassName);
114: if (!WinRegisterClass( vhab, (PCH)szClassName, (PFNWP)ClipWndProc,
115: CS_SIZEREDRAW, 0))
116: return( 0 );
117: /*
118: Create the window (hidden)
119: */
120: ctldata = (FCF_STANDARD | FCF_HORZSCROLL | FCF_VERTSCROLL)
121: & ~(FCF_ACCELTABLE);
122:
123: vhwndClipFrame = WinCreateStdWindow( HWND_DESKTOP, WS_VISIBLE, &ctldata,
124: szClassName, "",
125: WS_VISIBLE, NULL, ID_RESOURCE,
126: (PHWND) &vhwndClient );
127: /*
128: If there is no other clipboard viewer...
129: */
130: if (fViewer = !WinQueryClipbrdViewer(vhab, FALSE)) {
131: /*
132: ...we'll be the viewer. Show the clipboard window.
133: */
134: WinSetClipbrdViewer(vhab, vhwndClient);
135: /*
136: Poll messages from event queue
137: */
138: while( WinGetMsg( vhab, (PQMSG)&qmsg, (HWND)NULL, 0, 0 ) )
139: WinDispatchMsg( vhab, (PQMSG)&qmsg );
140: /*
141: Stop being the clipboard viewer.
142: */
143:
144:
145: #ifdef MLE_OK
146:
147: if (vhwndMLE)
148: WinDestroyWindow(vhwndMLE);
149:
150: #endif
151:
152:
153: WinSetClipbrdViewer(vhab, NULL);
154:
155: } else {
156: /*
157: ...otherwise, notify the user, then terminate.
158: */
159: LOADSTRING(IDS_ALREADY, szAlready);
160: MESSAGE(szAlready);
161: }
162: /*
163: Clean up
164: */
165: WinDestroyWindow( vhwndClipFrame );
166: WinDestroyMsgQueue( vhmqClip );
167: WinTerminate( vhab );
168:
169: return !fViewer;
170: }
171:
172: MRESULT EXPENTRY ClipWndProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
173: /*
174:
175: * This routine processes WM_COMMAND, WM_CREATE, WM_DRAWCLIPBOARD, WM_PAINT.
176: * Everything else is passed to the Default Window Procedure.
177: */
178: HPS hpsWindow;
179: RECTL rcl;
180: SWP swp;
181: SIZEL sizl;
182: UCHAR szMessage[MAXLEN];
183:
184: switch (msg) {
185:
186: case WM_CREATE:
187: /*
188: Create a memory DC/PS to BitBlt BITMAPs around.
189: */
190: sizl.cx = sizl.cy = 0L;
191: vhdcMemory = DevOpenDC(vhab, OD_MEMORY, "*", 0L, NULL, NULL);
192: vhpsMemory = GpiCreatePS(vhab, vhdcMemory, &sizl,
193: GPIA_ASSOC | GPIF_DEFAULT | GPIT_MICRO | PU_PELS);
194: break;
195:
196: case WM_COMMAND:
197: switch ((USHORT) SHORT1FROMMP (mp1)) {
198: /*
199: About... dialog box
200: */
201: case IDM_ABOUT:
202: WinDlgBox(HWND_DESKTOP, hwnd, AboutDlgProc,
203: NULL, IDD_ABOUT, NULL);
204: return 0;
205: /*
206: Render... dialog box
207: */
208: case IDM_RENDER:
209: WinDlgBox(HWND_DESKTOP, hwnd, RenderDlgProc,
210: NULL, IDD_RENDER, NULL);
211: return 0;
212: /*
213: Save... dialog box
214: */
215: case IDM_SAVE:
216: if (!SaveClipboard(hwnd, vusFormat)) {
217: LOADSTRING(IDS_NOTSAVED, szMessage);
218: MESSAGE(szMessage);
219: }
220: return 0;
221:
222: default: break;
223: }
224: break;
225:
226: case WM_ERASEBACKGROUND:
227: return MRFROMSHORT (TRUE) ;
228: break;
229:
230: case WM_PAINT:
231: /* Open the presentation space */
232: hpsWindow = WinBeginPaint(hwnd, NULL, &rcl);
233:
234: /* Fill in the background */
235: WinFillRect(hpsWindow, &rcl, CLR_BACKGROUND);
236:
237: /* Paint in the clipboard */
238: UpdateScreen(hwnd, vusFormat);
239:
240: /* Finish painting */
241: WinEndPaint(hpsWindow);
242: break;
243:
244: case WM_DRAWCLIPBOARD:
245: /* Update the clipboard contents */
246: GetAllFormats();
247: vfUpdate = TRUE;
248: WinPostMsg(hwnd, WM_PAINT, 0L, 0L);
249: break;
250:
251: case WM_HSCROLL:
252: if (vfViewBitmap) {
253: /*
254: Handle the appropriate scrolling messages
255: */
256: DoScrolling(hwnd, TRUE, HIUSHORT(mp2));
257: }
258: else if ( vfViewText ) {
259: DoScrolling(hwnd, TRUE, HIUSHORT(mp2));
260: } else
261: /*
262: If an ownerdraw format, let the owner handle it.
263: */
264: SendOwnerMsg(WM_HSCROLLCLIPBOARD, (MPARAM) hwnd, mp2);
265: break;
266:
267: case WM_VSCROLL:
268: if (vfViewBitmap) {
269: /*
270: Handle the appropriate scrolling messages
271: */
272: DoScrolling(hwnd, FALSE, HIUSHORT(mp2));
273: }
274: else if ( vfViewText ) {
275: DoScrolling(hwnd, FALSE, HIUSHORT(mp2));
276: } else
277: /*
278: If an ownerdraw format, let the owner handle it.
279: */
280: SendOwnerMsg(WM_VSCROLLCLIPBOARD, (MPARAM) hwnd, mp2);
281: break;
282:
283: case WM_SIZE:
284:
285:
286: /*
287: If the MLE is processing a text selector,
288: tell it to resize itself. If we have
289: owner-draw data, tell the clipboard owner.
290: If we have a BITMAP, readjust the scroll
291: bar ranges.
292: */
293:
294:
295: if (vhwndMLE) {
296: WinQueryWindowPos(vhwndMLE, &swp);
297: swp.cx = SHORT1FROMMP(mp2);
298: swp.cy = SHORT2FROMMP(mp2);
299: WinSetMultWindowPos(vhab, &swp, 1);
300: } else if (vfViewBitmap) {
301: WinQueryWindowPos(hwnd, &swp);
302: if ((vcMaxHSB = vbmp.cx - swp.cx) < 0)
303: vcMaxHSB = 0;
304: if ((vcMaxVSB = vbmp.cy - swp.cy) < 0)
305: vcMaxVSB = 0;
306: WinSendMsg(vhwndHSB, SBM_SETSCROLLBAR,
307: 0L, MPFROM2SHORT(0, vcMaxHSB));
308: WinSendMsg(vhwndVSB, SBM_SETSCROLLBAR,
309: MPFROMSHORT(vcMaxVSB),
310: MPFROM2SHORT(0, vcMaxVSB));
311: } else {
312: rcl.xLeft = rcl.yBottom = 0L;
313: rcl.xLeft = (LONG) SHORT1FROMMP(mp2) - 1;
314: rcl.yTop = (LONG) SHORT2FROMMP(mp2) - 1;
315: SendOwnerMsg(WM_SIZECLIPBOARD, (MPARAM) hwnd, &rcl);
316: }
317:
318:
319: break;
320:
321: default:
322: return WinDefWindowProc(hwnd, msg, mp1, mp2);
323: break;
324: }
325: return 0L;
326: }
327:
328: MRESULT EXPENTRY RenderDlgProc(HWND hwndDlg, USHORT msg, MPARAM mp1, MPARAM mp2)
329: {
330: /*
331: Render... dialog procedure
332: */
333: HWND hwndListbox; /* Listbox of possible formats */
334: UCHAR szFmtName[MAXLEN]; /* Format name */
335: UCHAR szMessage[MAXLEN];
336: USHORT i;
337: USHORT usFormat; /* Format to render */
338: MRESULT mrItem; /* Which listbox item selected? */
339:
340: switch(msg) {
341:
342: case WM_INITDLG:
343: /*
344: Put all the possible formats into the listbox, and
345: select the first item by default.
346: */
347: hwndListbox = WinWindowFromID(hwndDlg, IDL_RENDER);
348: WinSendMsg(hwndListbox, LM_DELETEALL, 0L, 0L);
349: for (i = 0; i < vcFmts; i++) {
350: GetFormatName(vausFormats[i], szFmtName);
351: WinSendMsg(hwndListbox, LM_INSERTITEM,
352: MPFROMSHORT(LIT_END), MPFROMP((PVOID) szFmtName));
353: }
354: WinSendMsg(hwndListbox, LM_SELECTITEM, 0L, MPFROMSHORT(TRUE));
355: break;
356:
357: case WM_CONTROL:
358: /*
359: If the user makes a selection, quit!
360: */
361: if ((SHORT1FROMMP(mp1) == IDL_RENDER)
362: && (SHORT2FROMMP(mp1) == LN_ENTER))
363: WinPostMsg(hwndDlg, WM_COMMAND, MPFROMSHORT(DID_OK), 0L);
364: break;
365:
366: case WM_COMMAND:
367: switch( (USHORT) SHORT1FROMMP (mp1) ) {
368: case DID_OK:
369: /*
370: Since the user chose a selection, try to render it.
371: */
372: hwndListbox = WinWindowFromID(hwndDlg, IDL_RENDER);
373: mrItem = WinSendMsg(hwndListbox, LM_QUERYSELECTION, 0L, 0L);
374: if (mrItem != MPFROMSHORT (LIT_NONE) ) {
375: usFormat = vausFormats[(USHORT) mrItem];
376: if (usFormat != vusFormat) {
377: /*
378: If the clipboard format is not rendered,
379: tell the user.
380: */
381: vfUpdate = TRUE;
382: if (!UpdateScreen(vhwndClient, usFormat)) {
383: LOADSTRING(IDS_NODISPLAY, szMessage);
384: MESSAGE(szMessage);
385: }
386: }
387: }
388:
389: /* fall through */
390:
391: case DID_CANCEL:
392: WinDismissDlg(hwndDlg, TRUE);
393:
394: default: break;
395: }
396: default: return WinDefDlgProc(hwndDlg, msg, mp1, mp2);
397: }
398: return FALSE;
399: }
400:
401: MRESULT EXPENTRY AboutDlgProc(HWND hwndDlg, USHORT msg, MPARAM mp1, MPARAM mp2)
402: {
403: /*
404: About... dialog procedure
405: */
406: switch(msg) {
407: case WM_COMMAND:
408: switch( (USHORT) SHORT1FROMMP (mp1) ) {
409: case DID_OK: WinDismissDlg(hwndDlg, TRUE);
410: default: break;
411: }
412: default: return WinDefDlgProc(hwndDlg, msg, mp1, mp2);
413: }
414: return FALSE;
415: }
416:
417:
418:
419:
420: #ifdef MLE_OK
421:
422: VOID ReadSelector(HWND hwndMLE, PSZ pszText) {
423: /*
424: Compute the length of the text selector, in bytes.
425: Allocate space, and copy the text selector into an MLE.
426: */
427: IPT ipt = 0L ;
428: ULONG ulcch = 0;
429: PSZ pszCounter;
430:
431: pszCounter = pszText;
432: while (*pszCounter++) ulcch++;
433: WinSendMsg(hwndMLE, MLM_FORMAT, MPFROMSHORT(MLFIE_CFTEXT), 0L);
434: WinSendMsg(hwndMLE, MLM_SETIMPORTEXPORT, pszText, (MPARAM) ulcch);
435: WinSendMsg(hwndMLE, MLM_IMPORT, (MPARAM) &ipt, (MPARAM) ulcch);
436: }
437:
438: #endif
439:
440:
441:
442: VOID FixFrame(VOID) {
443: /*
444: This routine tells the frame to update the scroll bars.
445:
446: First, make it so that the scroll bars cannot update themselves.
447: Let the frame update the controls. Then, re-enable the scroll bars.
448: */
449: if (!(vcUpdate--)) {
450: WinEnableWindowUpdate(vhwndHSB, FALSE);
451: WinEnableWindowUpdate(vhwndVSB, FALSE);
452: }
453:
454:
455: WinSendMsg(vhwndClipFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_HORZSCROLL), 0L);
456: WinSendMsg(vhwndClipFrame, WM_UPDATEFRAME, MPFROMLONG(FCF_VERTSCROLL), 0L);
457:
458:
459: if (!(++vcUpdate)) {
460: WinEnableWindowUpdate(vhwndHSB, TRUE);
461: WinEnableWindowUpdate(vhwndVSB, TRUE);
462: }
463: }
464:
465: VOID NeedScrollBars(BOOL fNeed) {
466: /*
467: This routine hides changes the scroll bar state to correspond with
468: fNeed, showing or hiding them as necessary.
469: */
470: static BOOL fNeeded = TRUE; /* The last scroll bar state */
471:
472: /*
473: Get the scroll bar handles, if we haven't already.
474: */
475: if (!vhwndHSB) {
476: vhwndHSB = WinWindowFromID(vhwndClipFrame, FID_HORZSCROLL);
477: vhwndVSB = WinWindowFromID(vhwndClipFrame, FID_VERTSCROLL);
478: }
479: /*
480: Case 1: We need scroll bars, so enable them.
481: */
482: if (fNeed) {
483: if (!fNeeded) {
484: WinSetParent(vhwndHSB, vhwndClipFrame, TRUE);
485: WinSetParent(vhwndVSB, vhwndClipFrame, TRUE);
486: FixFrame();
487: }
488: /*
489: Case 2: We don't need scroll bars, so hide them.
490: */
491: } else {
492: if (fNeeded) {
493: WinSetParent(vhwndHSB, HWND_OBJECT, TRUE);
494: WinSetParent(vhwndVSB, HWND_OBJECT, TRUE);
495: FixFrame();
496: }
497: }
498: /*
499: Save state for next invocation
500: */
501: fNeeded = fNeed;
502: }
503:
504: /*
505: RenderFormat()
506:
507: Input: Clipboard format to render, and handle to client area
508: Side effects: Renders the image in the client area
509: */
510: BOOL RenderFormat(HWND hwnd, USHORT usFormat) {
511: BOOL fRendered = TRUE;
512: HMF hmfCopy;
513: HPS hpsWindow;
514: LONG alOptions[8];
515: RECTL rclWindow;
516: SIZEL sizl;
517: SWP swpWindow;
518: ULONG hItem;
519: POINTL aptl[3];
520:
521:
522: #ifndef MLE_OK
523:
524:
525: HPS hps ;
526: RECTL rcl ;
527: POINTL ptl ;
528: FONTMETRICS fm ;
529: PSZ pszText ;
530: SHORT cxCaps, cyChar, cyDesc, line ;
531:
532: #endif
533:
534: /*
535: Open the clipboard
536: */
537: if (!WinOpenClipbrd(vhab))
538: return FALSE;
539: /*
540: Open up the window DC and PS
541: */
542: if (!vhdcWindow)
543: vhdcWindow = WinOpenWindowDC(hwnd);
544:
545: sizl.cx = sizl.cy = 0L;
546: hpsWindow = GpiCreatePS(vhab, vhdcWindow, &sizl, GPIA_ASSOC | PU_ARBITRARY);
547: /*
548: Enable the scroll bars, if necessary. This affects the size
549: of the client area.
550: */
551: if (vfUpdate)
552: NeedScrollBars( (vfViewBitmap =
553: (usFormat == CF_BITMAP) || (usFormat == CF_DSPBITMAP) ||
554:
555: /* The following line should be deleted when MLE are implemented */
556:
557: (usFormat == CF_DSPTEXT) || (usFormat == CF_TEXT) ) );
558:
559: WinQueryWindowRect(hwnd, &rclWindow);
560: /*
561: Get the clipboard data
562: */
563: WinQueryClipbrdFmtInfo(vhab, usFormat, &vfsFmtInfo);
564: if (!(hItem = WinQueryClipbrdData(vhab, usFormat))) {
565: fRendered = FALSE;
566: } else {
567: /*
568: Display the new format, as appropriate.
569: */
570: switch (usFormat) {
571: case CF_TEXT:
572: case CF_DSPTEXT:
573: if (vfUpdate) {
574:
575:
576: #ifdef MLE_OK
577:
578:
579: Create a new MLE and read the text into it.
580:
581: vhwndMLE = WinCreateWindow(hwnd, WC_MLE, "",
582: WS_VISIBLE | MLS_READONLY | MLS_HSCROLL | MLS_VSCROLL,
583: 0, 0,
584: (SHORT) rclWindow.xRight, (SHORT) rclWindow.yTop,
585: hwnd, HWND_TOP, 0, NULL, NULL);
586:
587: ReadSelector(vhwndMLE, (PSZ) hItem ) ;
588:
589: #else
590: vfViewText = TRUE ;
591: hps = WinGetPS ( hwnd ) ;
592: WinQueryWindowRect ( hwnd, &rcl ) ;
593: GpiQueryFontMetrics ( hps, (LONG) sizeof (fm), &fm ) ;
594: cxCaps = (SHORT) fm.lEmInc ;
595: cyChar = (SHORT) fm.lMaxBaselineExt ;
596: cyDesc = (SHORT) fm.lMaxDescender ;
597: line = 0 ;
598:
599: while ( *(PSZ) hItem ) {
600: pszText = (PSZ) hItem ;
601: ptl.x = cxCaps ;
602: ptl.y = rcl.yTop - cyChar * (line + 1) + cyDesc ;
603:
604: while ( isprint ( *(PSZ) hItem) )
605: hItem++ ;
606:
607: if ( *(PSZ) hItem )
608: GpiCharStringAt ( hps,
609: &ptl,
610: hItem - (ULONG) pszText,
611: pszText ) ;
612:
613: while ( isspace ( *(PSZ) hItem ) )
614: hItem++ ;
615:
616: line += 1 ;
617: }
618:
619: hItem = (ULONG) pszText ;
620: while ( isprint ( *(PSZ) hItem ) )
621: hItem++ ;
622:
623: GpiCharStringAt ( hps, &ptl, hItem - (ULONG) pszText, pszText ) ;
624:
625: WinReleasePS ( hps ) ;
626: #endif
627:
628:
629: }
630: break;
631:
632: case CF_BITMAP:
633: case CF_DSPBITMAP:
634: if (vfUpdate) {
635: /*
636: Get the BITMAP dimensions, for scroll bar processing
637: */
638: if (GpiQueryBitmapParameters((HBITMAP) hItem, &vbmp)
639: != GPI_OK) {
640: return FALSE;
641: }
642: /*
643: Set the scroll bar ranges from 0 to vbmp.max - client.max
644: */
645: WinQueryWindowPos(hwnd, &swpWindow);
646:
647: if ((vcMaxHSB = vbmp.cx - swpWindow.cx) < 0)
648: vcMaxHSB = 0;
649: if ((vcMaxVSB = vbmp.cy - swpWindow.cy) < 0)
650: vcMaxVSB = 0;
651: WinSendMsg(vhwndHSB, SBM_SETSCROLLBAR,
652: 0L, MPFROM2SHORT(0, vcMaxHSB));
653: WinSendMsg(vhwndVSB, SBM_SETSCROLLBAR,
654: MPFROMSHORT(vcMaxVSB),
655: MPFROM2SHORT(0, vcMaxVSB));
656: }
657: /*
658: Draw the BITMAP, based on the scroll bar settings.
659: */
660: GpiSetBitmap(vhpsMemory, (HBITMAP) hItem);
661:
662: aptl[0].x = rclWindow.xLeft; /* Target bottom left */
663: aptl[0].y = rclWindow.yBottom;
664: aptl[1].x = rclWindow.xRight; /* Target top right */
665: aptl[1].y = rclWindow.yTop;
666: /* Source bottom left */
667: aptl[2].x = (LONG) WinSendMsg(vhwndHSB, SBM_QUERYPOS, 0L, 0L);
668: aptl[2].y = vcMaxVSB
669: - (LONG) WinSendMsg(vhwndVSB, SBM_QUERYPOS, 0L, 0L);
670:
671: GpiBitBlt(hpsWindow, vhpsMemory, 3L, aptl, ROP_SRCCOPY, 0L);
672: GpiSetBitmap(vhpsMemory, NULL);
673: break;
674:
675: case CF_METAFILE:
676: case CF_DSPMETAFILE:
677: /*
678: Set up the alOptions for displaying the metafile, and
679: let the system do the rest of the work.
680: */
681: alOptions[PMF_SEGBASE] = 0L;
682: alOptions[PMF_LOADTYPE] = LT_DEFAULT;
683: alOptions[PMF_RESOLVE] = 0L;
684: alOptions[PMF_LCIDS] = LC_LOADDISC;
685: alOptions[PMF_RESET] = RES_DEFAULT;
686: alOptions[PMF_SUPPRESS] = SUP_DEFAULT;
687: alOptions[PMF_COLORTABLES] = CTAB_NOMODIFY;
688: alOptions[PMF_COLORREALIZABLE] = CREA_DEFAULT;
689: hmfCopy = GpiCopyMetaFile((HMF) hItem);
690: GpiPlayMetaFile(hpsWindow, hmfCopy, 8L, alOptions, 0L, 0L, NULL);
691: break;
692:
693: case CF_EMPTY:
694: /*
695: Don't do anything.
696: */
697: break;
698:
699: default:
700: /*
701: If it's an owner-draw format that we can display...
702: ...try to get the owner to paint the clipboard.
703: (return if we were successful or not)
704: */
705: fRendered = SendOwnerMsg(WM_PAINTCLIPBOARD, MPFROMHWND(hwnd), 0L);
706: break;
707: }
708: }
709: /*
710: Tell everybody that the client area is valid now
711: */
712: WinValidateRect(hwnd, (PRECTL) NULL, FALSE);
713: /*
714: Clean up
715: */
716: GpiAssociate(hpsWindow, NULL);
717: GpiDestroyPS(hpsWindow);
718: WinCloseClipbrd(vhab);
719: return fRendered;
720: }
721:
722: BOOL UpdateScreen(HWND hwnd, USHORT usFormat) {
723: /*
724: Render the format, change the title bar.
725: The title bar will look like: "<appname> (<format>)"
726: */
727: BOOL fRendered = TRUE;
728: HPS hpsWindow;
729: RECTL rcl;
730: UCHAR szFormat[MAXLEN];
731: UCHAR szTitle[MAXTITLELEN];
732:
733: if (vfUpdate) {
734:
735:
736: #ifdef MLE_OK
737:
738: /* If the MLE exists, destroy it */
739: if (vhwndMLE) {
740: WinDestroyWindow(vhwndMLE);
741: vhwndMLE = NULL;
742: }
743: #endif
744:
745: /* Clear the client area */
746: WinQueryWindowRect(hwnd, &rcl);
747: WinInvalidateRect(hwnd, &rcl, FALSE);
748: hpsWindow = WinBeginPaint(hwnd, NULL, NULL);
749: WinFillRect(hpsWindow, &rcl, CLR_BACKGROUND);
750: WinEndPaint(hpsWindow);
751: }
752: if (usFormat) // Check that usFormat != CF_EMPTY
753: fRendered = RenderFormat(hwnd, usFormat);
754: /*
755: Set the title bar appropriately
756: */
757: if (!vhwndTitlebar && vhwndClipFrame)
758: vhwndTitlebar = WinWindowFromID(vhwndClipFrame, FID_TITLEBAR);
759:
760: if (vhwndTitlebar) {
761: GetFormatName(usFormat, szFormat);
762: LOADSTRING(IDS_APPNAME, szTitle);
763: strcat(szTitle, "("); strcat(szTitle, szFormat); strcat(szTitle, ")");
764: WinSetWindowText(vhwndTitlebar, szTitle);
765: }
766: /*
767: Save the rendered format.
768: */
769: vusFormat = usFormat;
770: return fRendered;
771: }
772:
773: VOID GetAllFormats(VOID) {
774: USHORT usFormat; // Temporary used when enumerating
775: /*
776: Put ourselves into a clean state
777: */
778: usFormat = vcFmts = 0;
779: /*
780: Cycle through the available clipboard formats
781: */
782: while (usFormat = WinEnumClipbrdFmts(vhab, usFormat)) {
783: vausFormats[vcFmts++] = usFormat;
784: }
785: /*
786: Set the current clipboard format to the first one, if possible
787: (in preparation for the WM_PAINT which will follow).
788: */
789: vusFormat = (vcFmts ? vausFormats[0] : CF_EMPTY);
790: }
791:
792: VOID GetFormatName(USHORT usFormat, UCHAR szFmtName[]) {
793: /*
794: GetFormatName()
795:
796: This routine returns a format name in szFmtName which corresponds
797: to the format usFormat. Basically, either we know the format, or
798: we get the name from the system atom table. If we can't find it,
799: we set it to CF_UNKNOWN.
800: */
801: switch (usFormat) {
802: /*
803: If we know the format, we can read it from the string table.
804: */
805: case CF_EMPTY:
806: case CF_TEXT:
807: case CF_DSPTEXT:
808: case CF_BITMAP:
809: case CF_DSPBITMAP:
810: case CF_METAFILE:
811: case CF_DSPMETAFILE:
812: LOADSTRING(usFormat, szFmtName);
813: break;
814:
815: default:
816: /*
817: Get the format name from the system atom table.
818: If not found, tag it as an unknown format.
819: */
820: if (!WinQueryAtomName(WinQuerySystemAtomTable(),
821: usFormat, szFmtName, MAXLEN))
822:
823: LOADSTRING(CF_UNKNOWN, szFmtName);
824:
825: break;
826: }
827: }
828:
829: BOOL SendOwnerMsg(USHORT msg, MPARAM mp1, MPARAM mp2) {
830: BOOL rc;
831: HWND hwndOwner;
832: /*
833: If we are an OWNERDISPLAY format,
834: lock the owner window, tell it to perform the operation, return
835: */
836: if ( rc = ( (vfsFmtInfo & CFI_OWNERDISPLAY)
837: && (hwndOwner = WinQueryClipbrdOwner(vhab, TRUE)) ) ) {
838:
839: WinSendMsg(hwndOwner, msg, mp1, mp2);
840: WinLockWindow(hwndOwner, FALSE);
841: }
842: return rc;
843: }
844:
845: BOOL DoScrolling(HWND hwnd, BOOL fHorz, USHORT sbCmd) {
846: /*
847: This routine depends on the fact that the thumb cannot be set past the
848: range of the scroll bar. Since this is handled in the system SBM_SETPOS
849: code already, we need not worry about it.
850:
851: We return TRUE if the scroll bar message is processed.
852: */
853: HWND hwndSB; /* Scroll bar handle */
854: USHORT cpels; /* Page length/width for PAGExxxx commands */
855: SWP swp; /* Dimensions of the client area */
856: USHORT usOld; /* The current scroll bar position */
857: USHORT usNew; /* The new scroll bar position */
858: /*
859: Set the scroll bar-specific parameters
860: */
861: WinQueryWindowPos(hwnd, &swp);
862: if (fHorz) { /* Horizontal scroll bar */
863: hwndSB = vhwndHSB;
864: cpels = swp.cx;
865: } else { /* Vertical scroll bar */
866: hwndSB = vhwndVSB;
867: cpels = swp.cy;
868: }
869: /*
870: Handle both scroll bars with one common routine
871:
872: Basically, the scroll bar has been set so that
873: the thumb value corresponds to the offset that
874: the bitmap is drawn from. So, to scroll by a
875: page, compute the number of pels of the page,
876: and move the thumb by that amount.
877:
878: This code is simplified by the fact that SB_SETPOS
879: will not allow the thumb to be set outside of the
880: range of the scroll bar, but will "stop" it at the
881: appropriate bound.
882: */
883: usOld = (USHORT) WinSendMsg(hwndSB, SBM_QUERYPOS, 0L, 0L);
884:
885: switch (sbCmd) {
886: case SB_PAGERIGHT: /* SB_PAGEDOWN */
887: WinSendMsg(hwndSB, SBM_SETPOS, MPFROMSHORT(usOld + cpels), 0L);
888: break;
889:
890: case SB_PAGELEFT: /* SB_PAGEUP */
891: WinSendMsg(hwndSB, SBM_SETPOS, MPFROMSHORT(usOld - cpels), 0L);
892: break;
893:
894: case SB_LINERIGHT: /* SB_LINEDOWN */
895: WinSendMsg(hwndSB, SBM_SETPOS, MPFROMSHORT(usOld + LINE), 0L);
896: break;
897:
898: case SB_LINELEFT: /* SB_LINEUP */
899: WinSendMsg(hwndSB, SBM_SETPOS, MPFROMSHORT(usOld - LINE), 0L);
900: break;
901:
902: case SB_SLIDERPOSITION:
903: /*
904: It would be nice to be consistent with the other
905: SB_ cases, but the problem is that when this message
906: is sent, the position is *already* set to "usPosition".
907:
908: So, just invalidate the entire region, and hope that most
909: of these types of operations will be large scrolls.
910: */
911: // WinSendMsg(hwndSB, SBM_SETPOS, MPFROMSHORT(LOUSHORT(mp2)), 0L);
912: WinInvalidateRect(hwnd, NULL, TRUE);
913: break;
914:
915: default:
916: return FALSE;
917: }
918: /*
919: Now, we find out where the new thumb position is,
920: scroll the window contents appropriately, and specify
921: SW_INVALIDATERGN so that the remainder will be
922: invalidated/repainted.
923: */
924: usNew = (USHORT) WinSendMsg(hwndSB, SBM_QUERYPOS, 0L, 0L);
925: if (fHorz)
926: WinScrollWindow(hwnd, (SHORT) (usOld - usNew), 0,
927: NULL, NULL, NULL, NULL, SW_INVALIDATERGN);
928: else
929: WinScrollWindow(hwnd, 0, (SHORT) (usNew - usOld),
930: NULL, NULL, NULL, NULL, SW_INVALIDATERGN);
931:
932: return TRUE;
933: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.