![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to wgraph.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot / win|
Return to wgraph.c CVS log | Up to [local] / OpenXM_contrib / gnuplot / win |
1.1 maekawa 1: #ifndef lint
1.1.1.2 ! maekawa 2: static char *RCSid = "$Id: wgraph.c,v 1.5.2.1 1999/08/19 14:13:09 lhecking Exp $";
1.1 maekawa 3: #endif
4:
5: /* GNUPLOT - win/wgraph.c */
6: /*[
7: * Copyright 1992, 1993, 1998 Maurice Castro, Russell Lang
8: *
9: * Permission to use, copy, and distribute this software and its
10: * documentation for any purpose with or without fee is hereby granted,
11: * provided that the above copyright notice appear in all copies and
12: * that both that copyright notice and this permission notice appear
13: * in supporting documentation.
14: *
15: * Permission to modify the software is granted, but not the right to
16: * distribute the complete modified source code. Modifications are to
17: * be distributed as patches to the released version. Permission to
18: * distribute binaries produced by compiling modified sources is granted,
19: * provided you
20: * 1. distribute the corresponding source modifications from the
21: * released version in the form of a patch file along with the binaries,
22: * 2. add special version identification to distinguish your version
23: * in addition to the base release version number,
24: * 3. provide your name and address as the primary contact for the
25: * support of your modified version, and
26: * 4. retain our contact information in regard to use of the base
27: * software.
28: * Permission to distribute the released version of the source code along
29: * with corresponding source modifications in the form of a patch file is
30: * granted with same provisions 2 through 4 for binary distributions.
31: *
32: * This software is provided "as is" without express or implied warranty
33: * to the extent permitted by applicable law.
34: ]*/
35:
36: /*
37: * AUTHORS
38: *
39: * Maurice Castro
40: * Russell Lang
41: *
42: * Send your comments or suggestions to
43: * info-gnuplot@dartmouth.edu.
44: * This is a mailing list; to join it send a note to
45: * majordomo@dartmouth.edu.
46: * Send bug reports to
47: * bug-gnuplot@dartmouth.edu.
48: */
49:
50: #define STRICT
51: #include <windows.h>
52: #include <windowsx.h>
53: #if WINVER >= 0x030a
54: #include <commdlg.h>
55: #endif
56: #ifndef __MSC__
57: #include <mem.h>
58: #endif
59: #include <stdio.h>
60: #include <string.h>
61: #include "wgnuplib.h"
62: #include "wresourc.h"
63: #include "wcommon.h"
64:
65: LRESULT CALLBACK WINEXPORT WndGraphProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
66:
67: void ReadGraphIni(LPGW lpgw);
68:
69: /* ================================== */
70:
71: #define MAXSTR 255
72:
73: #define WGDEFCOLOR 15
74: COLORREF wginitcolor[WGDEFCOLOR] = {
75: RGB(255,0,0), /* red */
76: RGB(0,255,0), /* green */
77: RGB(0,0,255), /* blue */
78: RGB(255,0,255), /* magenta */
79: RGB(0,0,128), /* dark blue */
80: RGB(128,0,0), /* dark red */
81: RGB(0,128,128), /* dark cyan */
82: RGB(0,0,0), /* black */
83: RGB(128,128,128), /* grey */
84: RGB(0,128,64), /* very dark cyan */
85: RGB(128,128,0), /* dark yellow */
86: RGB(128,0,128), /* dark magenta */
87: RGB(192,192,192), /* light grey */
88: RGB(0,255,255), /* cyan */
89: RGB(255,255,0), /* yellow */
90: };
91: #define WGDEFSTYLE 5
92: int wginitstyle[WGDEFSTYLE] = {PS_SOLID, PS_DASH, PS_DOT, PS_DASHDOT, PS_DASHDOTDOT};
93:
94: /* ================================== */
95:
96: /* destroy memory blocks holding graph operations */
97: void
98: DestroyBlocks(LPGW lpgw)
99: {
100: struct GWOPBLK *this, *next;
101: struct GWOP FAR *gwop;
102: unsigned int i;
103:
104: this = lpgw->gwopblk_head;
105: while (this != NULL) {
106: next = this->next;
107: if (!this->gwop) {
108: this->gwop = (struct GWOP FAR *)GlobalLock(this->hblk);
109: }
110: if (this->gwop) {
111: /* free all text strings within this block */
112: gwop = this->gwop;
113: for (i=0; i<GWOPMAX; i++) {
114: if (gwop->htext)
115: LocalFree(gwop->htext);
116: gwop++;
117: }
118: }
119: GlobalUnlock(this->hblk);
120: GlobalFree(this->hblk);
121: LocalFreePtr(this);
122: this = next;
123: }
124: lpgw->gwopblk_head = NULL;
125: lpgw->gwopblk_tail = NULL;
126: lpgw->nGWOP = 0;
127: }
128:
129:
130: /* add a new memory block for graph operations */
131: /* returns TRUE if block allocated */
132: BOOL
133: AddBlock(LPGW lpgw)
134: {
135: HGLOBAL hblk;
136: struct GWOPBLK *next, *this;
137:
138: /* create new block */
139: next = (struct GWOPBLK *)LocalAllocPtr(LHND, sizeof(struct GWOPBLK) );
140: if (next == NULL)
141: return FALSE;
142: hblk = GlobalAlloc(GHND, GWOPMAX*sizeof(struct GWOP));
143: if (hblk == NULL)
144: return FALSE;
145: next->hblk = hblk;
146: next->gwop = (struct GWOP FAR *)NULL;
147: next->next = (struct GWOPBLK *)NULL;
148: next->used = 0;
149:
150: /* attach it to list */
151: this = lpgw->gwopblk_tail;
152: if (this == NULL) {
153: lpgw->gwopblk_head = next;
154: }
155: else {
156: this->next = next;
157: this->gwop = (struct GWOP FAR *)NULL;
158: GlobalUnlock(this->hblk);
159: }
160: lpgw->gwopblk_tail = next;
161: next->gwop = (struct GWOP FAR *)GlobalLock(next->hblk);
162: if (next->gwop == (struct GWOP FAR *)NULL)
163: return FALSE;
164:
165: return TRUE;
166: }
167:
168:
169: void WDPROC
170: GraphOp(LPGW lpgw, WORD op, WORD x, WORD y, LPSTR str)
171: {
172: struct GWOPBLK *this;
173: struct GWOP FAR *gwop;
174: char *npstr;
175:
176: this = lpgw->gwopblk_tail;
177: if ( (this==NULL) || (this->used >= GWOPMAX) ) {
178: /* not enough space so get new block */
179: if (!AddBlock(lpgw))
180: return;
181: this = lpgw->gwopblk_tail;
182: }
183: gwop = &this->gwop[this->used];
184: gwop->op = op;
185: gwop->x = x;
186: gwop->y = y;
187: gwop->htext = 0;
188: if (str) {
189: gwop->htext = LocalAlloc(LHND, _fstrlen(str)+1);
190: npstr = LocalLock(gwop->htext);
191: if (gwop->htext && (npstr != (char *)NULL))
192: lstrcpy(npstr, str);
193: LocalUnlock(gwop->htext);
194: }
195: this->used++;
196: lpgw->nGWOP++;
197: return;
198: }
199:
200: /* ================================== */
201:
202: void WDPROC
203: GraphInit(LPGW lpgw)
204: {
205: HMENU sysmenu;
206: WNDCLASS wndclass;
207: char buf[80];
208:
209: if (!lpgw->hPrevInstance) {
210: wndclass.style = CS_HREDRAW | CS_VREDRAW;
211: wndclass.lpfnWndProc = WndGraphProc;
212: wndclass.cbClsExtra = 0;
213: wndclass.cbWndExtra = 2 * sizeof(void FAR *);
214: wndclass.hInstance = lpgw->hInstance;
215: wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
216: wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
217: wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
218: wndclass.lpszMenuName = NULL;
219: wndclass.lpszClassName = szGraphClass;
220: RegisterClass(&wndclass);
221: }
222:
223: ReadGraphIni(lpgw);
224:
225: lpgw->hWndGraph = CreateWindow(szGraphClass, lpgw->Title,
226: WS_OVERLAPPEDWINDOW,
227: lpgw->Origin.x, lpgw->Origin.y,
228: lpgw->Size.x, lpgw->Size.y,
229: NULL, NULL, lpgw->hInstance, lpgw);
230:
231: lpgw->hPopMenu = CreatePopupMenu();
232: AppendMenu(lpgw->hPopMenu, MF_STRING | (lpgw->graphtotop ? MF_CHECKED : MF_UNCHECKED),
233: M_GRAPH_TO_TOP, "Bring to &Top");
234: AppendMenu(lpgw->hPopMenu, MF_STRING | (lpgw->color ? MF_CHECKED : MF_UNCHECKED),
235: M_COLOR, "C&olor");
236: AppendMenu(lpgw->hPopMenu, MF_STRING, M_COPY_CLIP, "&Copy to Clipboard");
237: #if WINVER >= 0x030a
238: AppendMenu(lpgw->hPopMenu, MF_STRING, M_BACKGROUND, "&Background...");
239: AppendMenu(lpgw->hPopMenu, MF_STRING, M_CHOOSE_FONT, "Choose &Font...");
240: AppendMenu(lpgw->hPopMenu, MF_STRING, M_LINESTYLE, "&Line Styles...");
241: #endif
242: AppendMenu(lpgw->hPopMenu, MF_STRING, M_PRINT, "&Print...");
243: if (lpgw->IniFile != (LPSTR)NULL) {
244: wsprintf(buf,"&Update %s",lpgw->IniFile);
245: AppendMenu(lpgw->hPopMenu, MF_STRING, M_WRITEINI, (LPSTR)buf);
246: }
247:
248: /* modify the system menu to have the new items we want */
249: sysmenu = GetSystemMenu(lpgw->hWndGraph,0);
250: AppendMenu(sysmenu, MF_SEPARATOR, 0, NULL);
251: AppendMenu(sysmenu, MF_POPUP, (UINT)lpgw->hPopMenu, "&Options");
252: AppendMenu(sysmenu, MF_STRING, M_ABOUT, "&About");
253:
254: if (!IsWindowVisible(lpgw->lptw->hWndParent)) {
255: AppendMenu(sysmenu, MF_SEPARATOR, 0, NULL);
256: AppendMenu(sysmenu, MF_STRING, M_COMMANDLINE, "C&ommand Line");
257: }
258:
259: ShowWindow(lpgw->hWndGraph, SW_SHOWNORMAL);
260: }
261:
262: /* close a graph window */
263: void WDPROC
264: GraphClose(LPGW lpgw)
265: {
266: /* close window */
267: if (lpgw->hWndGraph)
268: DestroyWindow(lpgw->hWndGraph);
269: TextMessage();
270: lpgw->hWndGraph = NULL;
271:
272: lpgw->locked = TRUE;
273: DestroyBlocks(lpgw);
274: lpgw->locked = FALSE;
275:
276: }
277:
278:
279: void WDPROC
280: GraphStart(LPGW lpgw, double pointsize)
281: {
282: lpgw->locked = TRUE;
283: DestroyBlocks(lpgw);
284: lpgw->org_pointsize = pointsize;
285: if ( !lpgw->hWndGraph || !IsWindow(lpgw->hWndGraph) )
286: GraphInit(lpgw);
287: if (IsIconic(lpgw->hWndGraph))
288: ShowWindow(lpgw->hWndGraph, SW_SHOWNORMAL);
289: if (lpgw->graphtotop)
290: BringWindowToTop(lpgw->hWndGraph);
291:
292: }
293:
294: void WDPROC
295: GraphEnd(LPGW lpgw)
296: {
297: RECT rect;
298: GetClientRect(lpgw->hWndGraph, &rect);
299: InvalidateRect(lpgw->hWndGraph, (LPRECT) &rect, 1);
300: lpgw->locked = FALSE;
301: UpdateWindow(lpgw->hWndGraph);
302: }
303:
304: void WDPROC
305: GraphResume(LPGW lpgw)
306: {
307: lpgw->locked = TRUE;
308: }
309:
310: void WDPROC
311: GraphPrint(LPGW lpgw)
312: {
313: if (lpgw->hWndGraph && IsWindow(lpgw->hWndGraph))
314: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_PRINT,0L);
315: }
316:
317: void WDPROC
318: GraphRedraw(LPGW lpgw)
319: {
320: if (lpgw->hWndGraph && IsWindow(lpgw->hWndGraph))
321: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_REBUILDTOOLS,0L);
322: }
323: /* ================================== */
324:
325: void
326: StorePen(LPGW lpgw, int i, COLORREF ref, int colorstyle, int monostyle)
327: {
328: LOGPEN FAR *plp;
329:
330: plp = &lpgw->colorpen[i];
331: plp->lopnColor = ref;
332: if (colorstyle < 0) {
333: plp->lopnWidth.x = -colorstyle;
334: plp->lopnStyle = 0;
335: }
336: else {
337: plp->lopnWidth.x = 1;
338: plp->lopnStyle = colorstyle % 5;
339: }
340: plp->lopnWidth.y = 0;
341:
342: plp = &lpgw->monopen[i];
343: plp->lopnColor = RGB(0,0,0);
344: if (monostyle < 0) {
345: plp->lopnWidth.x = -monostyle;
346: plp->lopnStyle = 0;
347: }
348: else {
349: plp->lopnWidth.x = 1;
350: plp->lopnStyle = monostyle % 5;
351: }
352: plp->lopnWidth.y = 0;
353: }
354:
355: void
356: MakePens(LPGW lpgw, HDC hdc)
357: {
358: int i;
359:
360: if ((GetDeviceCaps(hdc,NUMCOLORS) == 2) || !lpgw->color) {
361: /* Monochrome Device */
362: /* create border pens */
363: lpgw->hbpen = CreatePenIndirect((LOGPEN FAR *)&lpgw->monopen[0]); /* border */
364: lpgw->hapen = CreatePenIndirect((LOGPEN FAR *)&lpgw->monopen[1]); /* axis */
365: /* create drawing pens */
366: for (i=0; i<WGNUMPENS; i++)
367: {
368: lpgw->hpen[i] = CreatePenIndirect((LOGPEN FAR *)&lpgw->monopen[i+2]);
369: }
370: /* find number of solid, unit width line styles */
371: for (i=0; i<WGNUMPENS && lpgw->monopen[i+2].lopnStyle==PS_SOLID
372: && lpgw->monopen[i+2].lopnWidth.x==1; i++) ;
373: lpgw->numsolid = i ? i : 1; /* must be at least 1 */
374: lpgw->hbrush = CreateSolidBrush(RGB(255,255,255));
375: for (i=0; i<WGNUMPENS+2; i++)
376: lpgw->colorbrush[i] = CreateSolidBrush(RGB(0,0,0));
377: }
378: else {
379: /* Color Device */
380: /* create border pens */
381: lpgw->hbpen = CreatePenIndirect((LOGPEN FAR *)&lpgw->colorpen[0]); /* border */
382: lpgw->hapen = CreatePenIndirect((LOGPEN FAR *)&lpgw->colorpen[1]); /* axis */
383: /* create drawing pens */
384: for (i=0; i<WGNUMPENS; i++)
385: {
386: lpgw->hpen[i] = CreatePenIndirect((LOGPEN FAR *)&lpgw->colorpen[i+2]);
1.1.1.2 ! maekawa 387: #if 1 /* HBB 980118 fix 'numsolid' problem */
! 388: lpgw->hsolidpen[i] = CreatePen(PS_SOLID, 1, lpgw->colorpen[i+2].lopnColor);
! 389: #endif
1.1 maekawa 390: }
391: /* find number of solid, unit width line styles */
392: for (i=0; i<WGNUMPENS && lpgw->colorpen[i+2].lopnStyle==PS_SOLID
393: && lpgw->colorpen[i+2].lopnWidth.x==1; i++) ;
394: lpgw->numsolid = i ? i : 1; /* must be at least 1 */
395: lpgw->hbrush = CreateSolidBrush(lpgw->background);
396: for (i=0; i<WGNUMPENS+2; i++)
397: lpgw->colorbrush[i] = CreateSolidBrush(lpgw->colorpen[i].lopnColor);
398: }
399: }
400:
401: void
402: DestroyPens(LPGW lpgw)
403: {
404: int i;
405:
406: DeleteObject(lpgw->hbrush);
407: DeleteObject(lpgw->hbpen);
408: DeleteObject(lpgw->hapen);
409: for (i=0; i<WGNUMPENS; i++)
410: DeleteObject(lpgw->hpen[i]);
1.1.1.2 ! maekawa 411: #if 1 /* HBB 980118: fix 'numsolid' gotcha */
! 412: for (i=0; i<WGNUMPENS; i++)
! 413: DeleteObject(lpgw->hsolidpen[i]);
! 414: #endif
1.1 maekawa 415: for (i=0; i<WGNUMPENS+2; i++)
416: DeleteObject(lpgw->colorbrush[i]);
417: }
418:
419: /* ================================== */
420:
421: void
422: MakeFonts(LPGW lpgw, LPRECT lprect, HDC hdc)
423: {
424: LOGFONT lf;
425: HFONT hfontold;
426: TEXTMETRIC tm;
427: int result;
428: char FAR *p;
429: int cx, cy;
430:
431: lpgw->rotate = FALSE;
432: _fmemset(&lf, 0, sizeof(LOGFONT));
433: _fstrncpy(lf.lfFaceName,lpgw->fontname,LF_FACESIZE);
434: lf.lfHeight = -MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
435: lf.lfCharSet = DEFAULT_CHARSET;
436: if ( (p = _fstrstr(lpgw->fontname," Italic")) != (LPSTR)NULL ) {
437: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
438: lf.lfItalic = TRUE;
439: }
440: if ( (p = _fstrstr(lpgw->fontname," Bold")) != (LPSTR)NULL ) {
441: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
442: lf.lfWeight = FW_BOLD;
443: }
444:
445: if (lpgw->hfonth == 0) {
446: lpgw->hfonth = CreateFontIndirect((LOGFONT FAR *)&lf);
447: }
448:
449: if (lpgw->hfontv == 0) {
450: lf.lfEscapement = 900;
451: lf.lfOrientation = 900;
452: lpgw->hfontv = CreateFontIndirect((LOGFONT FAR *)&lf);
453: }
454:
455: /* save text size */
456: hfontold = SelectObject(hdc, lpgw->hfonth);
457: #ifdef WIN32
458: {
459: SIZE size;
460: GetTextExtentPoint(hdc,"0123456789",10, (LPSIZE)&size);
461: cx = size.cx;
462: cy = size.cy;
463: }
464: #else
465: {
466: DWORD extent;
467: extent = GetTextExtent(hdc,"0123456789",10);
468: cx = LOWORD(extent);
469: cy = HIWORD(extent);
470: }
471: #endif
472: lpgw->vchar = MulDiv(cy,lpgw->ymax,lprect->bottom - lprect->top);
473: lpgw->hchar = MulDiv(cx/10,lpgw->xmax,lprect->right - lprect->left);
474: /* CMW: Base tick size on character size */
475: lpgw->htic = lpgw->hchar/2;
476: cy = MulDiv(cx/20, GetDeviceCaps(hdc,LOGPIXELSY), GetDeviceCaps(hdc,LOGPIXELSX));
477: lpgw->vtic = MulDiv(cy,lpgw->ymax,lprect->bottom - lprect->top);
478: /* find out if we can rotate text 90deg */
479: SelectObject(hdc, lpgw->hfontv);
480: result = GetDeviceCaps(hdc, TEXTCAPS);
481: if ((result & TC_CR_90) || (result & TC_CR_ANY))
482: lpgw->rotate = 1;
483: GetTextMetrics(hdc,(TEXTMETRIC FAR *)&tm);
484: if (tm.tmPitchAndFamily & TMPF_VECTOR)
485: lpgw->rotate = 1; /* vector fonts can all be rotated */
486: #if WINVER >=0x030a
487: if (tm.tmPitchAndFamily & TMPF_TRUETYPE)
488: lpgw->rotate = 1; /* truetype fonts can all be rotated */
489: #endif
490: SelectObject(hdc, hfontold);
491: return;
492: }
493:
494: void
495: DestroyFonts(LPGW lpgw)
496: {
497: if (lpgw->hfonth) {
498: DeleteObject(lpgw->hfonth);
499: lpgw->hfonth = 0;
500: }
501: if (lpgw->hfontv) {
502: DeleteObject(lpgw->hfontv);
503: lpgw->hfontv = 0;
504: }
505: return;
506: }
507:
508: void
509: SetFont(LPGW lpgw, HDC hdc)
510: {
511: if (lpgw->rotate && lpgw->angle) {
512: if (lpgw->hfontv)
513: SelectObject(hdc, lpgw->hfontv);
514: }
515: else {
516: if (lpgw->hfonth)
517: SelectObject(hdc, lpgw->hfonth);
518: }
519: return;
520: }
521:
522: void
523: SelFont(LPGW lpgw) {
524: #if WINVER >= 0x030a
525: LOGFONT lf;
526: CHOOSEFONT cf;
527: HDC hdc;
528: char lpszStyle[LF_FACESIZE];
529: char FAR *p;
530:
531: /* Set all structure fields to zero. */
532: _fmemset(&cf, 0, sizeof(CHOOSEFONT));
533: _fmemset(&lf, 0, sizeof(LOGFONT));
534: cf.lStructSize = sizeof(CHOOSEFONT);
535: cf.hwndOwner = lpgw->hWndGraph;
536: _fstrncpy(lf.lfFaceName,lpgw->fontname,LF_FACESIZE);
537: if ( (p = _fstrstr(lpgw->fontname," Bold")) != (LPSTR)NULL ) {
538: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
539: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
540: }
541: else if ( (p = _fstrstr(lpgw->fontname," Italic")) != (LPSTR)NULL ) {
542: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
543: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
544: }
545: else
546: _fstrcpy(lpszStyle,"Regular");
547: cf.lpszStyle = lpszStyle;
548: hdc = GetDC(lpgw->hWndGraph);
549: lf.lfHeight = -MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
550: ReleaseDC(lpgw->hWndGraph, hdc);
551: cf.lpLogFont = &lf;
552: cf.nFontType = SCREEN_FONTTYPE;
553: cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_USESTYLE;
554: if (ChooseFont(&cf)) {
555: _fstrcpy(lpgw->fontname,lf.lfFaceName);
556: lpgw->fontsize = cf.iPointSize / 10;
557: if (cf.nFontType & BOLD_FONTTYPE)
558: lstrcat(lpgw->fontname," Bold");
559: if (cf.nFontType & ITALIC_FONTTYPE)
560: lstrcat(lpgw->fontname," Italic");
561: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_REBUILDTOOLS,0L);
562: }
563: #endif
564: }
565:
566: /* ================================== */
567:
568: static void dot(HDC hdc, int xdash, int ydash)
569: {
570: MoveTo(hdc, xdash, ydash);
571: LineTo(hdc, xdash, ydash+1);
572: }
573:
574:
575: void
576: drawgraph(LPGW lpgw, HDC hdc, LPRECT rect)
577: {
578: int xdash, ydash; /* the transformed coordinates */
579: int rr, rl, rt, rb;
580: struct GWOP FAR *curptr;
581: struct GWOPBLK *blkptr;
582: int htic, vtic;
583: int hshift, vshift;
584: unsigned int lastop=-1; /* used for plotting last point on a line */
585: int pen, numsolid;
586: int polymax = 200;
587: int polyi = 0;
588: POINT *ppt;
589: unsigned int ngwop=0;
590: BOOL isColor;
591:
592: if (lpgw->locked)
593: return;
594:
595: isColor= (GetDeviceCaps(hdc, PLANES)*GetDeviceCaps(hdc,BITSPIXEL)) > 2;
596: if (lpgw->background != RGB(255,255,255) && lpgw->color && isColor) {
597: SetBkColor(hdc,lpgw->background);
598: FillRect(hdc, rect, lpgw->hbrush);
599: }
600:
601: ppt = (POINT *)LocalAllocPtr(LHND, (polymax+1) * sizeof(POINT));
602:
603: rr = rect->right;
604: rl = rect->left;
605: rt = rect->top;
606: rb = rect->bottom;
607:
608: htic = lpgw->org_pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
609: vtic = lpgw->org_pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
610:
611: lpgw->angle = 0;
612: SetFont(lpgw, hdc);
613: SetTextAlign(hdc, TA_LEFT|TA_BOTTOM);
614: vshift = MulDiv(lpgw->vchar, rb-rt, lpgw->ymax)/2;
615: /* HBB 980630: new variable for moving rotated text to the correct
616: * position: */
617: hshift = MulDiv(lpgw->vchar, rr-rl, lpgw->xmax)/2;
618:
619: pen = 0;
620: SelectObject(hdc, lpgw->hpen[pen]);
621: SelectObject(hdc, lpgw->colorbrush[pen+2]);
622: numsolid = lpgw->numsolid;
623:
624: /* do the drawing */
625: blkptr = lpgw->gwopblk_head;
626: curptr = NULL;
627: if (blkptr) {
628: if (!blkptr->gwop)
629: blkptr->gwop = (struct GWOP FAR *)GlobalLock(blkptr->hblk);
630: if (!blkptr->gwop)
631: return;
632: curptr = (struct GWOP FAR *)blkptr->gwop;
633: }
634: while(ngwop < lpgw->nGWOP)
635: {
636: /* transform the coordinates */
637: xdash = MulDiv(curptr->x, rr-rl-1, lpgw->xmax) + rl;
638: ydash = MulDiv(curptr->y, rt-rb+1, lpgw->ymax) + rb - 1;
639: if ((lastop==W_vect) && (curptr->op!=W_vect)) {
640: if (polyi >= 2)
641: Polyline(hdc, ppt, polyi);
642: polyi = 0;
643: }
644: switch (curptr->op) {
645: case 0: /* have run past last in this block */
646: break;
647: case W_move:
648: ppt[0].x = xdash;
649: ppt[0].y = ydash;
650: polyi = 1;
651: break;
652: case W_vect:
653: ppt[polyi].x = xdash;
654: ppt[polyi].y = ydash;
655: polyi++;
656: if (polyi >= polymax) {
657: Polyline(hdc, ppt, polyi);
658: ppt[0].x = xdash;
659: ppt[0].y = ydash;
660: polyi = 1;;
661: }
662: break;
663: case W_line_type:
664: switch (curptr->x)
665: {
666: case (WORD) -2: /* black 2 pixel wide */
667: SelectObject(hdc, lpgw->hbpen);
668: if (lpgw->color && isColor)
669: SetTextColor(hdc, lpgw->colorpen[0].lopnColor);
670: break;
671: case (WORD) -1: /* black 1 pixel wide doted */
672: SelectObject(hdc, lpgw->hapen);
673: if (lpgw->color && isColor)
674: SetTextColor(hdc, lpgw->colorpen[1].lopnColor);
675: break;
676: default:
677: SelectObject(hdc, lpgw->hpen[(curptr->x)%WGNUMPENS]);
678: if (lpgw->color && isColor)
679: SetTextColor(hdc, lpgw->colorpen[(curptr->x)%WGNUMPENS + 2].lopnColor);
680: }
681: pen = curptr->x;
682: SelectObject(hdc, lpgw->colorbrush[pen%WGNUMPENS + 2]);
683: break;
684: case W_put_text:
685: {char *str;
686: str = LocalLock(curptr->htext);
687: if (str) {
688: /* HBB 980630: shift differently for rotated text: */
689: if (lpgw->angle)
690: xdash += hshift;
691: else
692: ydash += vshift;
693: SetBkMode(hdc,TRANSPARENT);
694: TextOut(hdc,xdash,ydash,str,lstrlen(str));
695: SetBkMode(hdc,OPAQUE);
696: }
697: LocalUnlock(curptr->htext);
698: }
699: break;
700: case W_text_angle:
701: lpgw->angle = curptr->x;
702: SetFont(lpgw,hdc);
703: break;
704: case W_justify:
705: switch (curptr->x)
706: {
707: case LEFT:
708: SetTextAlign(hdc, TA_LEFT|TA_BOTTOM);
709: break;
710: case RIGHT:
711: SetTextAlign(hdc, TA_RIGHT|TA_BOTTOM);
712: break;
713: case CENTRE:
714: SetTextAlign(hdc, TA_CENTER|TA_BOTTOM);
715: break;
716: }
717: break;
718: case W_pointsize:
719: /* HBB 980309: term->pointsize() passes the number as a scaled-up
720: * integer now, so we can avoid calling sscanf() here (in a Win16
721: * DLL sharing stack with the stack-starved wgnuplot.exe !).
722: */
723: if (curptr->x != 0) {
724: double pointsize = curptr->x / 100.0;
725: /* HBB 980309: the older code didn't make *any* use of the
726: * pointsize at all! That obviously can't be correct. So use it! */
727: htic = pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
728: vtic = pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
729: } else {
730: char *str;
731: str = LocalLock(curptr->htext);
732: if (str) {
733: double pointsize;
734: sscanf(str, "%lg", &pointsize);
735: htic = lpgw->org_pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
736: vtic = lpgw->org_pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
737: }
738: LocalUnlock(curptr->htext);
739: }
740: break;
741: default: /* A plot mark */
1.1.1.2 ! maekawa 742: #if 0 /* HBB 980118: fix 'sumsolid' gotcha: */
1.1 maekawa 743: if (pen >= numsolid) {
744: pen %= numsolid; /* select solid pen */
745: SelectObject(hdc, lpgw->hpen[pen]);
746: SelectObject(hdc, lpgw->colorbrush[pen+2]);
747: }
1.1.1.2 ! maekawa 748: #else
! 749: SelectObject(hdc, lpgw->hsolidpen[pen%WGNUMPENS]);
! 750: #endif
1.1 maekawa 751: switch (curptr->op) {
752: case W_dot:
753: dot(hdc, xdash, ydash);
754: break;
755: case W_plus: /* do plus */
756: MoveTo(hdc,xdash-htic,ydash);
757: LineTo(hdc,xdash+htic+1,ydash);
758: MoveTo(hdc,xdash,ydash-vtic);
759: LineTo(hdc,xdash,ydash+vtic+1);
760: break;
761: case W_cross: /* do X */
762: MoveTo(hdc,xdash-htic,ydash-vtic);
763: LineTo(hdc,xdash+htic+1,ydash+vtic+1);
764: MoveTo(hdc,xdash-htic,ydash+vtic);
765: LineTo(hdc,xdash+htic+1,ydash-vtic-1);
766: break;
767: case W_star: /* do star */
768: MoveTo(hdc,xdash-htic,ydash);
769: LineTo(hdc,xdash+htic+1,ydash);
770: MoveTo(hdc,xdash,ydash-vtic);
771: LineTo(hdc,xdash,ydash+vtic+1);
772: MoveTo(hdc,xdash-htic,ydash-vtic);
773: LineTo(hdc,xdash+htic+1,ydash+vtic+1);
774: MoveTo(hdc,xdash-htic,ydash+vtic);
775: LineTo(hdc,xdash+htic+1,ydash-vtic-1);
776: break;
777: case W_circle: /* do open circle */
778: Arc(hdc, xdash-htic, ydash-vtic, xdash+htic+1, ydash+vtic+1, xdash, ydash+vtic+1, xdash, ydash+vtic+1);
779: dot(hdc, xdash, ydash);
780: break;
781: case W_fcircle: /* do filled circle */
782: Ellipse(hdc, xdash-htic, ydash-vtic, xdash+htic+1, ydash+vtic+1);
783: break;
784: default: /* Closed figure */
785: { POINT p[6];
786: int i;
787: int shape;
788: int filled = 0;
789: static float pointshapes[5][10] = {
790: {-1, -1, +1, -1, +1, +1, -1, +1, 0, 0}, /* box */
791: { 0, +1, -1, 0, 0, -1, +1, 0, 0, 0}, /* diamond */
792: { 0, -4./3, -4./3, 2./3, 4./3, 2./3, 0, 0}, /* triangle */
793: { 0, 4./3, -4./3, -2./3, 4./3, -2./3, 0, 0}, /* inverted triangle */
794: { 0, 1, 0.95106, 0.30902, 0.58779, -0.80902, -0.58779, -0.80902, -0.95106, 0.30902} /* pentagon (not used) */
795: };
796: switch (curptr->op) {
797: case W_box: shape = 0; break;
798: case W_diamond: shape = 1; break;
799: case W_itriangle: shape = 2; break;
800: case W_triangle: shape = 3; break;
801: default: shape = curptr->op-W_fbox;
802: filled = 1;
803: break;
804: }
805:
806: for ( i = 0; i<5; ++i )
807: if ( pointshapes[shape][i*2+1] == 0 && pointshapes[shape][i*2] == 0 )
808: break;
809: else {
810: p[i].x = xdash + htic*pointshapes[shape][i*2] + 0.5;
811: p[i].y = ydash + vtic*pointshapes[shape][i*2+1] + 0.5;
812: }
813: if ( filled )
814: /* Filled polygon */
815: Polygon(hdc, p, i);
816: else {
817: /* Outline polygon */
818: p[i].x = p[0].x;
819: p[i].y = p[0].y;
820: Polyline(hdc, p, i+1);
821: dot(hdc, xdash, ydash);
822: }
823: }
824: }
825: }
826: lastop = curptr->op;
827: ngwop++;
828: curptr++;
829: if ((unsigned)(curptr - blkptr->gwop) >= GWOPMAX) {
830: GlobalUnlock(blkptr->hblk);
831: blkptr->gwop = (struct GWOP FAR *)NULL;
832: blkptr = blkptr->next;
833: if (!blkptr->gwop)
834: blkptr->gwop = (struct GWOP FAR *)GlobalLock(blkptr->hblk);
835: if (!blkptr->gwop)
836: return;
837: curptr = (struct GWOP FAR *)blkptr->gwop;
838: }
839: }
840: if (polyi >= 2)
841: Polyline(hdc, ppt, polyi);
842: LocalFreePtr(ppt);
843: }
844:
845: /* ================================== */
846:
847: /* copy graph window to clipboard */
848: void
849: CopyClip(LPGW lpgw)
850: {
851: RECT rect;
852: HDC mem;
853: HBITMAP bitmap;
854: HANDLE hmf;
855: GLOBALHANDLE hGMem;
856: LPMETAFILEPICT lpMFP;
857: HWND hwnd;
858: HDC hdc;
859:
860: hwnd = lpgw->hWndGraph;
861:
862: /* view the window */
863: if (IsIconic(hwnd))
864: ShowWindow(hwnd, SW_SHOWNORMAL);
865: BringWindowToTop(hwnd);
866: UpdateWindow(hwnd);
867:
868: /* get the context */
869: hdc = GetDC(hwnd);
870: GetClientRect(hwnd, &rect);
871: /* make a bitmap and copy it there */
872: mem = CreateCompatibleDC(hdc);
873: bitmap = CreateCompatibleBitmap(hdc, rect.right - rect.left,
874: rect.bottom - rect.top);
875: if (bitmap) {
876: /* there is enough memory and the bitmaps OK */
877: SelectObject(mem, bitmap);
878: BitBlt(mem,0,0,rect.right - rect.left,
879: rect.bottom - rect.top, hdc, rect.left,
880: rect.top, SRCCOPY);
881: }
882: else {
883: MessageBeep(MB_ICONHAND);
884: MessageBox(hwnd, "Insufficient Memory to Copy Clipboard",
885: lpgw->Title, MB_ICONHAND | MB_OK);
886: }
887: DeleteDC(mem);
888: {
889: GW gwclip = *lpgw;
890: int windowfontsize = MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
891: int i;
892: gwclip.fontsize = MulDiv(windowfontsize, lpgw->ymax, rect.bottom);
893: gwclip.hfonth = gwclip.hfontv = 0;
894:
895: /* HBB 981203: scale up pens as well... */
896: for (i=0; i<WGNUMPENS+2; i++) {
897: if(gwclip.monopen[i].lopnWidth.x > 1)
898: gwclip.monopen[i].lopnWidth.x =
899: MulDiv(gwclip.monopen[i].lopnWidth.x,
900: gwclip.xmax, rect.right-rect.left);
901: if(gwclip.colorpen[i].lopnWidth.x > 1)
902: gwclip.colorpen[i].lopnWidth.x =
903: MulDiv(gwclip.colorpen[i].lopnWidth.x,
904: gwclip.xmax, rect.right-rect.left);
905: }
906:
907: rect.right = lpgw->xmax;
908: rect.bottom = lpgw->ymax;
909:
910: MakePens(&gwclip, hdc);
911: MakeFonts(&gwclip, &rect, hdc);
912:
913: ReleaseDC(hwnd, hdc);
914:
915: hdc = CreateMetaFile((LPSTR)NULL);
916:
917: /* HBB 981203: According to Petzold, Metafiles shouldn't contain SetMapMode() calls: */
918: /*SetMapMode(hdc, MM_ANISOTROPIC);*/
919: #ifdef WIN32
920: SetWindowExtEx(hdc, rect.right, rect.bottom, (LPSIZE)NULL);
921: #else
922: SetWindowExt(hdc, rect.right, rect.bottom);
923: #endif
924: drawgraph(&gwclip, hdc, (void *) &rect);
925: hmf = CloseMetaFile(hdc);
926: DestroyFonts(&gwclip);
927: DestroyPens(&gwclip);
928: }
929:
930: hGMem = GlobalAlloc(GMEM_MOVEABLE, (DWORD)sizeof(METAFILEPICT));
931: lpMFP = (LPMETAFILEPICT) GlobalLock(hGMem);
932: hdc = GetDC(hwnd); /* get window size */
933: GetClientRect(hwnd, &rect);
934: /* in MM_ANISOTROPIC, xExt & yExt give suggested size in 0.01mm units */
935: lpMFP->mm = MM_ANISOTROPIC;
936: lpMFP->xExt = MulDiv(rect.right-rect.left, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
937: /* HBB 981203: Seems it should be LOGPIXELS_Y_, here, not _X_*/
938: lpMFP->yExt = MulDiv(rect.bottom-rect.top, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
939: lpMFP->hMF = hmf;
940: ReleaseDC(hwnd, hdc);
941: GlobalUnlock(hGMem);
942:
943: OpenClipboard(hwnd);
944: EmptyClipboard();
945: SetClipboardData(CF_METAFILEPICT,hGMem);
946: SetClipboardData(CF_BITMAP, bitmap);
947: CloseClipboard();
948: return;
949: }
950:
951: /* copy graph window to printer */
952: void
953: CopyPrint(LPGW lpgw)
954: {
955: #ifdef WIN32
956: DOCINFO docInfo;
957: #endif
958:
959: #if WINVER >= 0x030a
960: HDC printer;
961: DLGPROC lpfnAbortProc;
962: DLGPROC lpfnPrintDlgProc;
963: PRINTDLG pd;
964: HWND hwnd;
965: RECT rect;
966: PRINT pr;
967: UINT widabort;
968:
969: hwnd = lpgw->hWndGraph;
970:
971: _fmemset(&pd, 0, sizeof(PRINTDLG));
972: pd.lStructSize = sizeof(PRINTDLG);
973: pd.hwndOwner = hwnd;
974: pd.Flags = PD_PRINTSETUP | PD_RETURNDC;
975:
976: if (!PrintDlg(&pd))
977: return;
978: printer = pd.hDC;
979: if (NULL == printer)
980: return; /* abort */
981:
982: if (!PrintSize(printer, hwnd, &rect)) {
983: DeleteDC(printer);
984: return; /* abort */
985: }
986:
987: pr.hdcPrn = printer;
988: SetWindowLong(hwnd, 4, (LONG)((LPPRINT)&pr));
989: #ifdef WIN32
990: PrintRegister((LPPRINT)&pr);
991: #endif
992:
993: EnableWindow(hwnd,FALSE);
994: pr.bUserAbort = FALSE;
995: #ifdef WIN32
996: pr.hDlgPrint = CreateDialogParam(hdllInstance,"CancelDlgBox",hwnd,PrintDlgProc,(LPARAM)lpgw->Title);
997: SetAbortProc(printer,PrintAbortProc);
998:
999: memset(&docInfo, 0, sizeof(DOCINFO));
1000: docInfo.cbSize = sizeof(DOCINFO);
1001: docInfo.lpszDocName = lpgw->Title;
1002:
1003: if (StartDoc(printer, &docInfo) > 0) {
1004: #else
1005: #ifdef __DLL__
1006: lpfnPrintDlgProc = (DLGPROC)GetProcAddress(hdllInstance, "PrintDlgProc");
1007: lpfnAbortProc = (DLGPROC)GetProcAddress(hdllInstance, "PrintAbortProc");
1008: #else
1009: lpfnPrintDlgProc = (DLGPROC)MakeProcInstance((FARPROC)PrintDlgProc, hdllInstance);
1010: lpfnAbortProc = (DLGPROC)MakeProcInstance((FARPROC)PrintAbortProc, hdllInstance);
1011: #endif
1012: pr.hDlgPrint = CreateDialogParam(hdllInstance,"CancelDlgBox",hwnd,lpfnPrintDlgProc,(LPARAM)lpgw->Title);
1013: Escape(printer,SETABORTPROC,0,(LPSTR)lpfnAbortProc,NULL);
1014: if (Escape(printer, STARTDOC, lstrlen(lpgw->Title),lpgw->Title, NULL) > 0) {
1015: #endif
1016: SetMapMode(printer, MM_TEXT);
1017: SetBkMode(printer,OPAQUE);
1018: #ifdef WIN32
1019: StartPage(printer);
1020: #endif
1021: DestroyFonts(lpgw);
1022: MakeFonts(lpgw, (RECT FAR *)&rect, printer);
1023: DestroyPens(lpgw); /* rebuild pens */
1024: MakePens(lpgw, printer);
1025: drawgraph(lpgw, printer, (void *) &rect);
1026: #ifdef WIN32
1027: if (EndPage(printer) > 0)
1028: EndDoc(printer);
1029: #else
1030: if (Escape(printer,NEWFRAME,0,NULL,NULL) > 0)
1031: Escape(printer,ENDDOC,0,NULL,NULL);
1032: #endif
1033: }
1034: if (!pr.bUserAbort) {
1035: EnableWindow(hwnd,TRUE);
1036: DestroyWindow(pr.hDlgPrint);
1037: }
1038: #ifndef WIN32
1039: #ifndef __DLL__
1040: FreeProcInstance((FARPROC)lpfnPrintDlgProc);
1041: FreeProcInstance((FARPROC)lpfnAbortProc);
1042: #endif
1043: #endif
1044: DeleteDC(printer);
1045: SetWindowLong(hwnd, 4, (LONG)(0L));
1046: #ifdef WIN32
1047: PrintUnregister((LPPRINT)&pr);
1048: #endif
1049: /* make certain that the screen pen set is restored */
1050: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_REBUILDTOOLS,0L);
1051: #endif
1052: return;
1053: }
1054:
1055: /* ================================== */
1056: /* INI file stuff */
1057: void
1058: WriteGraphIni(LPGW lpgw)
1059: {
1060: RECT rect;
1061: int i;
1062: char entry[32];
1063: LPLOGPEN pc;
1064: LPLOGPEN pm;
1065: LPSTR file = lpgw->IniFile;
1066: LPSTR section = lpgw->IniSection;
1067: char profile[80];
1068:
1069: if ((file == (LPSTR)NULL) || (section == (LPSTR)NULL))
1070: return;
1071: if (IsIconic(lpgw->hWndGraph))
1072: ShowWindow(lpgw->hWndGraph, SW_SHOWNORMAL);
1073: GetWindowRect(lpgw->hWndGraph,&rect);
1074: wsprintf(profile, "%d %d", rect.left, rect.top);
1075: WritePrivateProfileString(section, "GraphOrigin", profile, file);
1076: wsprintf(profile, "%d %d", rect.right-rect.left, rect.bottom-rect.top);
1077: WritePrivateProfileString(section, "GraphSize", profile, file);
1078: wsprintf(profile, "%s,%d", lpgw->fontname, lpgw->fontsize);
1079: WritePrivateProfileString(section, "GraphFont", profile, file);
1080: wsprintf(profile, "%d", lpgw->color);
1081: WritePrivateProfileString(section, "GraphColor", profile, file);
1082: wsprintf(profile, "%d", lpgw->graphtotop);
1083: WritePrivateProfileString(section, "GraphToTop", profile, file);
1084: wsprintf(profile, "%d %d %d",GetRValue(lpgw->background),
1085: GetGValue(lpgw->background), GetBValue(lpgw->background));
1086: WritePrivateProfileString(section, "GraphBackground", profile, file);
1087:
1088: /* now save pens */
1089: for (i=0; i<WGNUMPENS+2; i++) {
1090: if (i==0)
1091: _fstrcpy(entry,"Border");
1092: else if (i==1)
1093: _fstrcpy(entry,"Axis");
1094: else
1095: wsprintf(entry,"Line%d",i-1);
1096: pc = &lpgw->colorpen[i];
1097: pm = &lpgw->monopen[i];
1098: wsprintf(profile, "%d %d %d %d %d",GetRValue(pc->lopnColor),
1099: GetGValue(pc->lopnColor), GetBValue(pc->lopnColor),
1100: (pc->lopnWidth.x != 1) ? -pc->lopnWidth.x : pc->lopnStyle,
1101: (pm->lopnWidth.x != 1) ? -pm->lopnWidth.x : pm->lopnStyle);
1102: WritePrivateProfileString(section, entry, profile, file);
1103: }
1104: return;
1105: }
1106:
1107: void
1108: ReadGraphIni(LPGW lpgw)
1109: {
1110: LPSTR file = lpgw->IniFile;
1111: LPSTR section = lpgw->IniSection;
1112: char profile[81];
1113: char entry[32];
1114: LPSTR p;
1115: int i,r,g,b,colorstyle,monostyle;
1116: COLORREF ref;
1117: BOOL bOKINI;
1118:
1119: bOKINI = (file != (LPSTR)NULL) && (section != (LPSTR)NULL);
1120: if (!bOKINI)
1121: profile[0] = '\0';
1122:
1123: if (bOKINI)
1124: GetPrivateProfileString(section, "GraphOrigin", "", profile, 80, file);
1125: if ( (p = GetInt(profile, (LPINT)&lpgw->Origin.x)) == NULL)
1126: lpgw->Origin.x = CW_USEDEFAULT;
1127: if ( (p = GetInt(p, (LPINT)&lpgw->Origin.y)) == NULL)
1128: lpgw->Origin.y = CW_USEDEFAULT;
1129: if (bOKINI)
1130: GetPrivateProfileString(section, "GraphSize", "", profile, 80, file);
1131: if ( (p = GetInt(profile, (LPINT)&lpgw->Size.x)) == NULL)
1132: lpgw->Size.x = CW_USEDEFAULT;
1133: if ( (p = GetInt(p, (LPINT)&lpgw->Size.y)) == NULL)
1134: lpgw->Size.y = CW_USEDEFAULT;
1135:
1136: if (bOKINI)
1137: GetPrivateProfileString(section, "GraphFont", "", profile, 80, file);
1138: {
1139: char FAR *size;
1140: size = _fstrchr(profile,',');
1141: if (size) {
1142: *size++ = '\0';
1143: if ( (p = GetInt(size, (LPINT)&lpgw->fontsize)) == NULL)
1144: lpgw->fontsize = WINFONTSIZE;
1145: }
1146: _fstrcpy(lpgw->fontname, profile);
1147: if (lpgw->fontsize == 0)
1148: lpgw->fontsize = WINFONTSIZE;
1149: if (!(*lpgw->fontname))
1150: if (LOWORD(GetVersion()) == 3)
1151: _fstrcpy(lpgw->fontname,WIN30FONT);
1152: else
1153: _fstrcpy(lpgw->fontname,WINFONT);
1154: }
1155:
1156: if (bOKINI)
1157: GetPrivateProfileString(section, "GraphColor", "", profile, 80, file);
1158: if ( (p = GetInt(profile, (LPINT)&lpgw->color)) == NULL)
1159: lpgw->color = TRUE;
1160:
1161: if (bOKINI)
1162: GetPrivateProfileString(section, "GraphToTop", "", profile, 80, file);
1163: if ( (p = GetInt(profile, (LPINT)&lpgw->graphtotop)) == NULL)
1164: lpgw->graphtotop = TRUE;
1165:
1166: lpgw->background = RGB(255,255,255);
1167: if (bOKINI)
1168: GetPrivateProfileString(section, "GraphBackground", "", profile, 80, file);
1169: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1170: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1171: ((p = GetInt(p, (LPINT)&b)) != NULL) )
1172: lpgw->background = RGB(r,g,b);
1173:
1174: StorePen(lpgw, 0,RGB(0,0,0),PS_SOLID,PS_SOLID);
1175: if (bOKINI)
1176: GetPrivateProfileString(section, "Border", "", profile, 80, file);
1177: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1178: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1179: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1180: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1181: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1182: StorePen(lpgw,0,RGB(r,g,b),colorstyle,monostyle);
1183:
1184: StorePen(lpgw, 1,RGB(192,192,192),PS_DOT,PS_DOT);
1185: if (bOKINI)
1186: GetPrivateProfileString(section, "Axis", "", profile, 80, file);
1187: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1188: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1189: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1190: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1191: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1192: StorePen(lpgw,1,RGB(r,g,b),colorstyle,monostyle);
1193:
1194: for (i=0; i<WGNUMPENS; i++)
1195: {
1196: ref = wginitcolor[ i%WGDEFCOLOR ];
1197: colorstyle = wginitstyle[ (i/WGDEFCOLOR) % WGDEFSTYLE ];
1198: monostyle = wginitstyle[ i%WGDEFSTYLE ];
1199: StorePen(lpgw, i+2,ref,colorstyle,monostyle);
1200: wsprintf(entry,"Line%d",i+1);
1201: if (bOKINI)
1202: GetPrivateProfileString(section, entry, "", profile, 80, file);
1203: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1204: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1205: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1206: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1207: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1208: StorePen(lpgw,i+2,RGB(r,g,b),colorstyle,monostyle);
1209: }
1210: }
1211:
1212:
1213: /* ================================== */
1214:
1215: #define LS_DEFLINE 2
1216: typedef struct tagLS {
1217: int widtype;
1218: int wid;
1219: HWND hwnd;
1220: int pen; /* current pen number */
1221: LOGPEN colorpen[WGNUMPENS+2]; /* logical color pens */
1222: LOGPEN monopen[WGNUMPENS+2]; /* logical mono pens */
1223: } LS;
1224: typedef LS FAR* LPLS;
1225:
1226:
1227: COLORREF
1228: GetColor(HWND hwnd, COLORREF ref)
1229: {
1230: CHOOSECOLOR cc;
1231: COLORREF aclrCust[16];
1232: int i;
1233:
1234: for (i=0; i<16; i++) {
1235: aclrCust[i] = RGB(0,0,0);
1236: }
1237: _fmemset(&cc, 0, sizeof(CHOOSECOLOR));
1238: cc.lStructSize = sizeof(CHOOSECOLOR);
1239: cc.hwndOwner = hwnd;
1240: cc.lpCustColors = aclrCust;
1241: cc.rgbResult = ref;
1242: cc.Flags = CC_RGBINIT;
1243: if (ChooseColor(&cc))
1244: return cc.rgbResult;
1245: return ref;
1246: }
1247:
1248:
1249: /* force update of owner draw button */
1250: void
1251: UpdateColorSample(HWND hdlg)
1252: {
1253: RECT rect;
1254: POINT ptul, ptlr;
1255: GetWindowRect( GetDlgItem(hdlg, LS_COLORSAMPLE), &rect);
1256: ptul.x = rect.left;
1257: ptul.y = rect.top;
1258: ptlr.x = rect.right;
1259: ptlr.y = rect.bottom;
1260: ScreenToClient(hdlg, &ptul);
1261: ScreenToClient(hdlg, &ptlr);
1262: rect.left = ptul.x;
1263: rect.top = ptul.y;
1264: rect.right = ptlr.x;
1265: rect.bottom = ptlr.y;
1266: InvalidateRect(hdlg, &rect, TRUE);
1267: UpdateWindow(hdlg);
1268: }
1269:
1270: BOOL CALLBACK WINEXPORT
1271: LineStyleDlgProc(HWND hdlg, UINT wmsg, WPARAM wparam, LPARAM lparam)
1272: {
1273: char buf[16];
1274: LPLS lpls;
1275: int i;
1276: UINT pen;
1277: LPLOGPEN plpm, plpc;
1278: lpls = (LPLS)GetWindowLong(GetParent(hdlg), 4);
1279:
1280: switch (wmsg) {
1281: case WM_INITDIALOG:
1282: pen = 2;
1283: for (i=0; i<WGNUMPENS+2; i++) {
1284: if (i==0)
1285: _fstrcpy(buf,"Border");
1286: else if (i==1)
1287: _fstrcpy(buf,"Axis");
1288: else
1289: wsprintf(buf,"Line%d",i-1);
1290: SendDlgItemMessage(hdlg, LS_LINENUM, LB_ADDSTRING, 0,
1291: (LPARAM)((LPSTR)buf));
1292: }
1293: SendDlgItemMessage(hdlg, LS_LINENUM, LB_SETCURSEL, pen, 0L);
1294:
1295: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1296: (LPARAM)((LPSTR)"Solid"));
1297: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1298: (LPARAM)((LPSTR)"Dash"));
1299: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1300: (LPARAM)((LPSTR)"Dot"));
1301: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1302: (LPARAM)((LPSTR)"DashDot"));
1303: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1304: (LPARAM)((LPSTR)"DashDotDot"));
1305:
1306: plpm = &lpls->monopen[pen];
1307: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1308: plpm->lopnStyle, 0L);
1309: wsprintf(buf,"%d",plpm->lopnWidth.x);
1310: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1311:
1312: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1313: (LPARAM)((LPSTR)"Solid"));
1314: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1315: (LPARAM)((LPSTR)"Dash"));
1316: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1317: (LPARAM)((LPSTR)"Dot"));
1318: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1319: (LPARAM)((LPSTR)"DashDot"));
1320: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1321: (LPARAM)((LPSTR)"DashDotDot"));
1322:
1323: plpc = &lpls->colorpen[pen];
1324: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1325: plpc->lopnStyle, 0L);
1326: wsprintf(buf,"%d",plpc->lopnWidth.x);
1327: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1328:
1329: return TRUE;
1330: case WM_COMMAND:
1331: pen = (UINT)SendDlgItemMessage(hdlg, LS_LINENUM, LB_GETCURSEL, 0, 0L);
1332: plpm = &lpls->monopen[pen];
1333: plpc = &lpls->colorpen[pen];
1334: switch (LOWORD(wparam)) {
1335: case LS_LINENUM:
1336: wsprintf(buf,"%d",plpm->lopnWidth.x);
1337: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1338: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1339: plpm->lopnStyle, 0L);
1340: wsprintf(buf,"%d",plpc->lopnWidth.x);
1341: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1342: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1343: plpc->lopnStyle, 0L);
1344: UpdateColorSample(hdlg);
1345: return FALSE;
1346: case LS_MONOSTYLE:
1347: plpm->lopnStyle =
1348: (UINT)SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_GETCURSEL, 0, 0L);
1349: if (plpm->lopnStyle != 0) {
1350: plpm->lopnWidth.x = 1;
1351: wsprintf(buf,"%d",plpm->lopnWidth.x);
1352: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1353: }
1354: return FALSE;
1355: case LS_MONOWIDTH:
1356: GetDlgItemText(hdlg, LS_MONOWIDTH, buf, 15);
1357: GetInt(buf, (LPINT)&plpm->lopnWidth.x);
1358: if (plpm->lopnWidth.x != 1) {
1359: plpm->lopnStyle = 0;
1360: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1361: plpm->lopnStyle, 0L);
1362: }
1363: return FALSE;
1364: case LS_CHOOSECOLOR:
1365: plpc->lopnColor = GetColor(hdlg, plpc->lopnColor);
1366: UpdateColorSample(hdlg);
1367: return FALSE;
1368: case LS_COLORSTYLE:
1369: plpc->lopnStyle =
1370: (UINT)SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_GETCURSEL, 0, 0L);
1371: if (plpc->lopnStyle != 0) {
1372: plpc->lopnWidth.x = 1;
1373: wsprintf(buf,"%d",plpc->lopnWidth.x);
1374: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1375: }
1376: return FALSE;
1377: case LS_COLORWIDTH:
1378: GetDlgItemText(hdlg, LS_COLORWIDTH, buf, 15);
1379: GetInt(buf, (LPINT)&plpc->lopnWidth.x);
1380: if (plpc->lopnWidth.x != 1) {
1381: plpc->lopnStyle = 0;
1382: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1383: plpc->lopnStyle, 0L);
1384: }
1385: return FALSE;
1386: case LS_DEFAULT:
1387: plpm = lpls->monopen;
1388: plpc = lpls->colorpen;
1389: /* border */
1390: plpc->lopnColor = RGB(0,0,0);
1391: plpc->lopnStyle = PS_SOLID;
1392: plpc->lopnWidth.x = 1;
1393: plpm->lopnStyle = PS_SOLID;
1394: plpm->lopnWidth.x = 1;
1395: plpc++; plpm++;
1396: /* axis */
1397: plpc->lopnColor = RGB(192,192,192);
1398: plpc->lopnStyle = PS_DOT;
1399: plpc->lopnWidth.x = 1;
1400: plpm->lopnStyle = PS_DOT;
1401: plpm->lopnWidth.x = 1;
1402: /* LineX */
1403: for (i=0; i<WGNUMPENS; i++) {
1404: plpc++; plpm++;
1405: plpc->lopnColor = wginitcolor[ i%WGDEFCOLOR ];
1406: plpc->lopnStyle = wginitstyle[ (i/WGDEFCOLOR) % WGDEFSTYLE ];
1407: plpc->lopnWidth.x = 1;
1408: plpm->lopnStyle = wginitstyle[ i%WGDEFSTYLE ];
1409: plpm->lopnWidth.x = 1;
1410: }
1411: /* update window */
1412: plpm = &lpls->monopen[pen];
1413: plpc = &lpls->colorpen[pen];
1414: SendDlgItemMessage(hdlg, LS_LINENUM, LB_SETCURSEL, pen, 0L);
1415: wsprintf(buf,"%d",plpm->lopnWidth.x);
1416: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1417: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1418: plpm->lopnStyle, 0L);
1419: wsprintf(buf,"%d",plpc->lopnWidth.x);
1420: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1421: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1422: plpc->lopnStyle, 0L);
1423: UpdateColorSample(hdlg);
1424: return FALSE;
1425: case IDOK:
1426: EndDialog(hdlg, IDOK);
1427: return TRUE;
1428: case IDCANCEL:
1429: EndDialog(hdlg, IDCANCEL);
1430: return TRUE;
1431: }
1432: break;
1433: case WM_DRAWITEM:
1434: {
1435: HBRUSH hBrush;
1436: LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lparam;
1437: pen = (UINT)SendDlgItemMessage(hdlg, LS_LINENUM, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
1438: plpc = &lpls->colorpen[pen];
1439: hBrush = CreateSolidBrush(plpc->lopnColor);
1440: FillRect(lpdis->hDC, &lpdis->rcItem, hBrush);
1441: FrameRect(lpdis->hDC, &lpdis->rcItem, (HBRUSH)GetStockObject(BLACK_BRUSH));
1442: DeleteObject(hBrush);
1443: }
1444: return FALSE;
1445: }
1446: return FALSE;
1447: }
1448:
1449:
1450:
1451: /* GetWindowLong(hwnd, 4) must be available for use */
1452: BOOL
1453: LineStyle(LPGW lpgw)
1454: {
1455: DLGPROC lpfnLineStyleDlgProc ;
1456: BOOL status = FALSE;
1457: LS ls;
1458:
1459: SetWindowLong(lpgw->hWndGraph, 4, (LONG)((LPLS)&ls));
1460: _fmemcpy(&ls.colorpen, &lpgw->colorpen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1461: _fmemcpy(&ls.monopen, &lpgw->monopen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1462:
1463: #ifdef WIN32
1464: if (DialogBox (hdllInstance, "LineStyleDlgBox", lpgw->hWndGraph, LineStyleDlgProc)
1465: #else
1466: #ifdef __DLL__
1467: lpfnLineStyleDlgProc = (DLGPROC)GetProcAddress(hdllInstance, "LineStyleDlgProc");
1468: #else
1469: lpfnLineStyleDlgProc = (DLGPROC)MakeProcInstance((FARPROC)LineStyleDlgProc, hdllInstance);
1470: #endif
1471: if (DialogBox (hdllInstance, "LineStyleDlgBox", lpgw->hWndGraph, lpfnLineStyleDlgProc)
1472: #endif
1473: == IDOK) {
1474: _fmemcpy(&lpgw->colorpen, &ls.colorpen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1475: _fmemcpy(&lpgw->monopen, &ls.monopen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1476: status = TRUE;
1477: }
1478: #ifndef WIN32
1479: #ifndef __DLL__
1480: FreeProcInstance((FARPROC)lpfnLineStyleDlgProc);
1481: #endif
1482: #endif
1483: SetWindowLong(lpgw->hWndGraph, 4, (LONG)(0L));
1484: return status;
1485: }
1486:
1487: /* ================================== */
1488:
1489: LRESULT CALLBACK WINEXPORT
1490: WndGraphProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1491: {
1492: HDC hdc;
1493: PAINTSTRUCT ps;
1494: RECT rect;
1495: LPGW lpgw;
1496: HMENU sysmenu;
1497: int i;
1498:
1499: lpgw = (LPGW)GetWindowLong(hwnd, 0);
1500:
1501: switch(message)
1502: {
1503: case WM_SYSCOMMAND:
1504: switch(LOWORD(wParam))
1505: {
1506: case M_GRAPH_TO_TOP:
1507: case M_COLOR:
1508: case M_CHOOSE_FONT:
1509: case M_COPY_CLIP:
1510: case M_LINESTYLE:
1511: case M_BACKGROUND:
1512: case M_PRINT:
1513: case M_WRITEINI:
1514: case M_REBUILDTOOLS:
1515: SendMessage(hwnd, WM_COMMAND, wParam, lParam);
1516: break;
1517: case M_ABOUT:
1518: if (lpgw->lptw)
1519: AboutBox(hwnd,lpgw->lptw->AboutText);
1520: return 0;
1521: case M_COMMANDLINE:
1522: sysmenu = GetSystemMenu(lpgw->hWndGraph,0);
1523: i = GetMenuItemCount (sysmenu);
1524: DeleteMenu (sysmenu, --i, MF_BYPOSITION);
1525: DeleteMenu (sysmenu, --i, MF_BYPOSITION);
1526: ShowWindow (lpgw->lptw->hWndParent, SW_SHOW);
1527: break;
1528: }
1529: break;
1530: case WM_COMMAND:
1531: switch(LOWORD(wParam))
1532: {
1533: case M_GRAPH_TO_TOP:
1534: lpgw->graphtotop = !lpgw->graphtotop;
1535: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1536: return(0);
1537: case M_COLOR:
1538: lpgw->color = !lpgw->color;
1539: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1540: return(0);
1541: case M_CHOOSE_FONT:
1542: SelFont(lpgw);
1543: return 0;
1544: case M_COPY_CLIP:
1545: CopyClip(lpgw);
1546: return 0;
1547: case M_LINESTYLE:
1548: if (LineStyle(lpgw))
1549: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1550: return 0;
1551: case M_BACKGROUND:
1552: lpgw->background = GetColor(hwnd, lpgw->background);
1553: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1554: return 0;
1555: case M_PRINT:
1556: CopyPrint(lpgw);
1557: return 0;
1558: case M_WRITEINI:
1559: WriteGraphIni(lpgw);
1560: if (lpgw->lptw)
1561: WriteTextIni(lpgw->lptw);
1562: return 0;
1563: case M_REBUILDTOOLS:
1564: lpgw->resized = TRUE;
1565: if (lpgw->color)
1566: CheckMenuItem(lpgw->hPopMenu, M_COLOR, MF_BYCOMMAND | MF_CHECKED);
1567: else
1568: CheckMenuItem(lpgw->hPopMenu, M_COLOR, MF_BYCOMMAND | MF_UNCHECKED);
1569: if (lpgw->graphtotop)
1570: CheckMenuItem(lpgw->hPopMenu, M_GRAPH_TO_TOP, MF_BYCOMMAND | MF_CHECKED);
1571: else
1572: CheckMenuItem(lpgw->hPopMenu, M_GRAPH_TO_TOP, MF_BYCOMMAND | MF_UNCHECKED);
1573: DestroyPens(lpgw);
1574: DestroyFonts(lpgw);
1575: hdc = GetDC(hwnd);
1576: MakePens(lpgw, hdc);
1577: GetClientRect(hwnd, &rect);
1578: MakeFonts(lpgw, (LPRECT)&rect, hdc);
1579: ReleaseDC(hwnd, hdc);
1580: GetClientRect(hwnd, &rect);
1581: InvalidateRect(hwnd, (LPRECT) &rect, 1);
1582: UpdateWindow(hwnd);
1583: return 0;
1584: }
1585: return 0;
1586: case WM_RBUTTONDOWN:
1587: {
1588: POINT pt;
1589: pt.x = LOWORD(lParam);
1590: pt.y = HIWORD(lParam);
1591: ClientToScreen(hwnd,&pt);
1592: TrackPopupMenu(lpgw->hPopMenu, TPM_LEFTALIGN,
1593: pt.x, pt.y, 0, hwnd, NULL);
1594: }
1595: return(0);
1596: case WM_CREATE:
1597: lpgw = ((CREATESTRUCT FAR *)lParam)->lpCreateParams;
1598: SetWindowLong(hwnd, 0, (LONG)lpgw);
1599: lpgw->hWndGraph = hwnd;
1600: hdc = GetDC(hwnd);
1601: MakePens(lpgw, hdc);
1602: GetClientRect(hwnd, &rect);
1603: MakeFonts(lpgw, (LPRECT)&rect, hdc);
1604: ReleaseDC(hwnd, hdc);
1605: #if WINVER >= 0x030a
1606: {
1607: WORD version = LOWORD(GetVersion());
1608: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1609: if ( lpgw->lptw && (lpgw->lptw->DragPre!=(LPSTR)NULL) && (lpgw->lptw->DragPost!=(LPSTR)NULL) )
1610: DragAcceptFiles(hwnd, TRUE);
1611: }
1612: #endif
1613: return(0);
1614: case WM_PAINT:
1615: hdc = BeginPaint(hwnd, &ps);
1616: SetMapMode(hdc, MM_TEXT);
1617: SetBkMode(hdc,OPAQUE);
1618: GetClientRect(hwnd, &rect);
1619: #ifdef WIN32
1620: SetViewportExtEx(hdc, rect.right, rect.bottom, NULL);
1621: #else
1622: SetViewportExt(hdc, rect.right, rect.bottom);
1623: #endif
1624: drawgraph(lpgw, hdc, (void *) &rect);
1625: EndPaint(hwnd, &ps);
1626: return 0;
1627: case WM_SIZE:
1628: /* update font sizes if graph resized */
1629: if ((wParam == SIZE_MAXIMIZED) || (wParam == SIZE_RESTORED)) {
1630: RECT rect;
1631: SendMessage(hwnd,WM_SYSCOMMAND,M_REBUILDTOOLS,0L);
1632: GetWindowRect(hwnd,&rect);
1633: lpgw->Size.x = rect.right-rect.left;
1634: lpgw->Size.y = rect.bottom-rect.top;
1635: }
1636: break;
1637: #if WINVER >= 0x030a
1638: case WM_DROPFILES:
1639: {
1640: WORD version = LOWORD(GetVersion());
1641: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1642: if (lpgw->lptw)
1643: DragFunc(lpgw->lptw, (HDROP)wParam);
1644: }
1645: break;
1646: #endif
1647: case WM_DESTROY:
1648: DestroyPens(lpgw);
1649: DestroyFonts(lpgw);
1650: #if __TURBOC__ >= 0x410 /* Borland C++ 3.1 or later */
1651: {
1652: WORD version = LOWORD(GetVersion());
1653: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1654: DragAcceptFiles(hwnd, FALSE);
1655: }
1656: #endif
1657: if (lpgw->lptw && !IsWindowVisible(lpgw->lptw->hWndParent)) {
1658: PostMessage (lpgw->lptw->hWndParent, WM_CLOSE, 0, 0);
1659: }
1660: return 0;
1661: case WM_CLOSE:
1662: GraphClose(lpgw);
1663: return 0;
1664: }
1665: return DefWindowProc(hwnd, message, wParam, lParam);
1666: }
1667: