![[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
2: static char *RCSid = "$Id: wgraph.c,v 1.14 1998/03/22 23:32:00 drd Exp $";
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]);
387: }
388: /* find number of solid, unit width line styles */
389: for (i=0; i<WGNUMPENS && lpgw->colorpen[i+2].lopnStyle==PS_SOLID
390: && lpgw->colorpen[i+2].lopnWidth.x==1; i++) ;
391: lpgw->numsolid = i ? i : 1; /* must be at least 1 */
392: lpgw->hbrush = CreateSolidBrush(lpgw->background);
393: for (i=0; i<WGNUMPENS+2; i++)
394: lpgw->colorbrush[i] = CreateSolidBrush(lpgw->colorpen[i].lopnColor);
395: }
396: }
397:
398: void
399: DestroyPens(LPGW lpgw)
400: {
401: int i;
402:
403: DeleteObject(lpgw->hbrush);
404: DeleteObject(lpgw->hbpen);
405: DeleteObject(lpgw->hapen);
406: for (i=0; i<WGNUMPENS; i++)
407: DeleteObject(lpgw->hpen[i]);
408: for (i=0; i<WGNUMPENS+2; i++)
409: DeleteObject(lpgw->colorbrush[i]);
410: }
411:
412: /* ================================== */
413:
414: void
415: MakeFonts(LPGW lpgw, LPRECT lprect, HDC hdc)
416: {
417: LOGFONT lf;
418: HFONT hfontold;
419: TEXTMETRIC tm;
420: int result;
421: char FAR *p;
422: int cx, cy;
423:
424: lpgw->rotate = FALSE;
425: _fmemset(&lf, 0, sizeof(LOGFONT));
426: _fstrncpy(lf.lfFaceName,lpgw->fontname,LF_FACESIZE);
427: lf.lfHeight = -MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
428: lf.lfCharSet = DEFAULT_CHARSET;
429: if ( (p = _fstrstr(lpgw->fontname," Italic")) != (LPSTR)NULL ) {
430: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
431: lf.lfItalic = TRUE;
432: }
433: if ( (p = _fstrstr(lpgw->fontname," Bold")) != (LPSTR)NULL ) {
434: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
435: lf.lfWeight = FW_BOLD;
436: }
437:
438: if (lpgw->hfonth == 0) {
439: lpgw->hfonth = CreateFontIndirect((LOGFONT FAR *)&lf);
440: }
441:
442: if (lpgw->hfontv == 0) {
443: lf.lfEscapement = 900;
444: lf.lfOrientation = 900;
445: lpgw->hfontv = CreateFontIndirect((LOGFONT FAR *)&lf);
446: }
447:
448: /* save text size */
449: hfontold = SelectObject(hdc, lpgw->hfonth);
450: #ifdef WIN32
451: {
452: SIZE size;
453: GetTextExtentPoint(hdc,"0123456789",10, (LPSIZE)&size);
454: cx = size.cx;
455: cy = size.cy;
456: }
457: #else
458: {
459: DWORD extent;
460: extent = GetTextExtent(hdc,"0123456789",10);
461: cx = LOWORD(extent);
462: cy = HIWORD(extent);
463: }
464: #endif
465: lpgw->vchar = MulDiv(cy,lpgw->ymax,lprect->bottom - lprect->top);
466: lpgw->hchar = MulDiv(cx/10,lpgw->xmax,lprect->right - lprect->left);
467: /* CMW: Base tick size on character size */
468: lpgw->htic = lpgw->hchar/2;
469: cy = MulDiv(cx/20, GetDeviceCaps(hdc,LOGPIXELSY), GetDeviceCaps(hdc,LOGPIXELSX));
470: lpgw->vtic = MulDiv(cy,lpgw->ymax,lprect->bottom - lprect->top);
471: /* find out if we can rotate text 90deg */
472: SelectObject(hdc, lpgw->hfontv);
473: result = GetDeviceCaps(hdc, TEXTCAPS);
474: if ((result & TC_CR_90) || (result & TC_CR_ANY))
475: lpgw->rotate = 1;
476: GetTextMetrics(hdc,(TEXTMETRIC FAR *)&tm);
477: if (tm.tmPitchAndFamily & TMPF_VECTOR)
478: lpgw->rotate = 1; /* vector fonts can all be rotated */
479: #if WINVER >=0x030a
480: if (tm.tmPitchAndFamily & TMPF_TRUETYPE)
481: lpgw->rotate = 1; /* truetype fonts can all be rotated */
482: #endif
483: SelectObject(hdc, hfontold);
484: return;
485: }
486:
487: void
488: DestroyFonts(LPGW lpgw)
489: {
490: if (lpgw->hfonth) {
491: DeleteObject(lpgw->hfonth);
492: lpgw->hfonth = 0;
493: }
494: if (lpgw->hfontv) {
495: DeleteObject(lpgw->hfontv);
496: lpgw->hfontv = 0;
497: }
498: return;
499: }
500:
501: void
502: SetFont(LPGW lpgw, HDC hdc)
503: {
504: if (lpgw->rotate && lpgw->angle) {
505: if (lpgw->hfontv)
506: SelectObject(hdc, lpgw->hfontv);
507: }
508: else {
509: if (lpgw->hfonth)
510: SelectObject(hdc, lpgw->hfonth);
511: }
512: return;
513: }
514:
515: void
516: SelFont(LPGW lpgw) {
517: #if WINVER >= 0x030a
518: LOGFONT lf;
519: CHOOSEFONT cf;
520: HDC hdc;
521: char lpszStyle[LF_FACESIZE];
522: char FAR *p;
523:
524: /* Set all structure fields to zero. */
525: _fmemset(&cf, 0, sizeof(CHOOSEFONT));
526: _fmemset(&lf, 0, sizeof(LOGFONT));
527: cf.lStructSize = sizeof(CHOOSEFONT);
528: cf.hwndOwner = lpgw->hWndGraph;
529: _fstrncpy(lf.lfFaceName,lpgw->fontname,LF_FACESIZE);
530: if ( (p = _fstrstr(lpgw->fontname," Bold")) != (LPSTR)NULL ) {
531: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
532: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
533: }
534: else if ( (p = _fstrstr(lpgw->fontname," Italic")) != (LPSTR)NULL ) {
535: _fstrncpy(lpszStyle,p+1,LF_FACESIZE);
536: lf.lfFaceName[ (unsigned int)(p-lpgw->fontname) ] = '\0';
537: }
538: else
539: _fstrcpy(lpszStyle,"Regular");
540: cf.lpszStyle = lpszStyle;
541: hdc = GetDC(lpgw->hWndGraph);
542: lf.lfHeight = -MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
543: ReleaseDC(lpgw->hWndGraph, hdc);
544: cf.lpLogFont = &lf;
545: cf.nFontType = SCREEN_FONTTYPE;
546: cf.Flags = CF_SCREENFONTS | CF_INITTOLOGFONTSTRUCT | CF_USESTYLE;
547: if (ChooseFont(&cf)) {
548: _fstrcpy(lpgw->fontname,lf.lfFaceName);
549: lpgw->fontsize = cf.iPointSize / 10;
550: if (cf.nFontType & BOLD_FONTTYPE)
551: lstrcat(lpgw->fontname," Bold");
552: if (cf.nFontType & ITALIC_FONTTYPE)
553: lstrcat(lpgw->fontname," Italic");
554: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_REBUILDTOOLS,0L);
555: }
556: #endif
557: }
558:
559: /* ================================== */
560:
561: static void dot(HDC hdc, int xdash, int ydash)
562: {
563: MoveTo(hdc, xdash, ydash);
564: LineTo(hdc, xdash, ydash+1);
565: }
566:
567:
568: void
569: drawgraph(LPGW lpgw, HDC hdc, LPRECT rect)
570: {
571: int xdash, ydash; /* the transformed coordinates */
572: int rr, rl, rt, rb;
573: struct GWOP FAR *curptr;
574: struct GWOPBLK *blkptr;
575: int htic, vtic;
576: int hshift, vshift;
577: unsigned int lastop=-1; /* used for plotting last point on a line */
578: int pen, numsolid;
579: int polymax = 200;
580: int polyi = 0;
581: POINT *ppt;
582: unsigned int ngwop=0;
583: BOOL isColor;
584:
585: if (lpgw->locked)
586: return;
587:
588: isColor= (GetDeviceCaps(hdc, PLANES)*GetDeviceCaps(hdc,BITSPIXEL)) > 2;
589: if (lpgw->background != RGB(255,255,255) && lpgw->color && isColor) {
590: SetBkColor(hdc,lpgw->background);
591: FillRect(hdc, rect, lpgw->hbrush);
592: }
593:
594: ppt = (POINT *)LocalAllocPtr(LHND, (polymax+1) * sizeof(POINT));
595:
596: rr = rect->right;
597: rl = rect->left;
598: rt = rect->top;
599: rb = rect->bottom;
600:
601: htic = lpgw->org_pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
602: vtic = lpgw->org_pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
603:
604: lpgw->angle = 0;
605: SetFont(lpgw, hdc);
606: SetTextAlign(hdc, TA_LEFT|TA_BOTTOM);
607: vshift = MulDiv(lpgw->vchar, rb-rt, lpgw->ymax)/2;
608: /* HBB 980630: new variable for moving rotated text to the correct
609: * position: */
610: hshift = MulDiv(lpgw->vchar, rr-rl, lpgw->xmax)/2;
611:
612: pen = 0;
613: SelectObject(hdc, lpgw->hpen[pen]);
614: SelectObject(hdc, lpgw->colorbrush[pen+2]);
615: numsolid = lpgw->numsolid;
616:
617: /* do the drawing */
618: blkptr = lpgw->gwopblk_head;
619: curptr = NULL;
620: if (blkptr) {
621: if (!blkptr->gwop)
622: blkptr->gwop = (struct GWOP FAR *)GlobalLock(blkptr->hblk);
623: if (!blkptr->gwop)
624: return;
625: curptr = (struct GWOP FAR *)blkptr->gwop;
626: }
627: while(ngwop < lpgw->nGWOP)
628: {
629: /* transform the coordinates */
630: xdash = MulDiv(curptr->x, rr-rl-1, lpgw->xmax) + rl;
631: ydash = MulDiv(curptr->y, rt-rb+1, lpgw->ymax) + rb - 1;
632: if ((lastop==W_vect) && (curptr->op!=W_vect)) {
633: if (polyi >= 2)
634: Polyline(hdc, ppt, polyi);
635: polyi = 0;
636: }
637: switch (curptr->op) {
638: case 0: /* have run past last in this block */
639: break;
640: case W_move:
641: ppt[0].x = xdash;
642: ppt[0].y = ydash;
643: polyi = 1;
644: break;
645: case W_vect:
646: ppt[polyi].x = xdash;
647: ppt[polyi].y = ydash;
648: polyi++;
649: if (polyi >= polymax) {
650: Polyline(hdc, ppt, polyi);
651: ppt[0].x = xdash;
652: ppt[0].y = ydash;
653: polyi = 1;;
654: }
655: break;
656: case W_line_type:
657: switch (curptr->x)
658: {
659: case (WORD) -2: /* black 2 pixel wide */
660: SelectObject(hdc, lpgw->hbpen);
661: if (lpgw->color && isColor)
662: SetTextColor(hdc, lpgw->colorpen[0].lopnColor);
663: break;
664: case (WORD) -1: /* black 1 pixel wide doted */
665: SelectObject(hdc, lpgw->hapen);
666: if (lpgw->color && isColor)
667: SetTextColor(hdc, lpgw->colorpen[1].lopnColor);
668: break;
669: default:
670: SelectObject(hdc, lpgw->hpen[(curptr->x)%WGNUMPENS]);
671: if (lpgw->color && isColor)
672: SetTextColor(hdc, lpgw->colorpen[(curptr->x)%WGNUMPENS + 2].lopnColor);
673: }
674: pen = curptr->x;
675: SelectObject(hdc, lpgw->colorbrush[pen%WGNUMPENS + 2]);
676: break;
677: case W_put_text:
678: {char *str;
679: str = LocalLock(curptr->htext);
680: if (str) {
681: /* HBB 980630: shift differently for rotated text: */
682: if (lpgw->angle)
683: xdash += hshift;
684: else
685: ydash += vshift;
686: SetBkMode(hdc,TRANSPARENT);
687: TextOut(hdc,xdash,ydash,str,lstrlen(str));
688: SetBkMode(hdc,OPAQUE);
689: }
690: LocalUnlock(curptr->htext);
691: }
692: break;
693: case W_text_angle:
694: lpgw->angle = curptr->x;
695: SetFont(lpgw,hdc);
696: break;
697: case W_justify:
698: switch (curptr->x)
699: {
700: case LEFT:
701: SetTextAlign(hdc, TA_LEFT|TA_BOTTOM);
702: break;
703: case RIGHT:
704: SetTextAlign(hdc, TA_RIGHT|TA_BOTTOM);
705: break;
706: case CENTRE:
707: SetTextAlign(hdc, TA_CENTER|TA_BOTTOM);
708: break;
709: }
710: break;
711: case W_pointsize:
712: /* HBB 980309: term->pointsize() passes the number as a scaled-up
713: * integer now, so we can avoid calling sscanf() here (in a Win16
714: * DLL sharing stack with the stack-starved wgnuplot.exe !).
715: */
716: if (curptr->x != 0) {
717: double pointsize = curptr->x / 100.0;
718: /* HBB 980309: the older code didn't make *any* use of the
719: * pointsize at all! That obviously can't be correct. So use it! */
720: htic = pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
721: vtic = pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
722: } else {
723: char *str;
724: str = LocalLock(curptr->htext);
725: if (str) {
726: double pointsize;
727: sscanf(str, "%lg", &pointsize);
728: htic = lpgw->org_pointsize*MulDiv(lpgw->htic, rr-rl, lpgw->xmax) + 1;
729: vtic = lpgw->org_pointsize*MulDiv(lpgw->vtic, rb-rt, lpgw->ymax) + 1;
730: }
731: LocalUnlock(curptr->htext);
732: }
733: break;
734: default: /* A plot mark */
735: if (pen >= numsolid) {
736: pen %= numsolid; /* select solid pen */
737: SelectObject(hdc, lpgw->hpen[pen]);
738: SelectObject(hdc, lpgw->colorbrush[pen+2]);
739: }
740: switch (curptr->op) {
741: case W_dot:
742: dot(hdc, xdash, ydash);
743: break;
744: case W_plus: /* do plus */
745: MoveTo(hdc,xdash-htic,ydash);
746: LineTo(hdc,xdash+htic+1,ydash);
747: MoveTo(hdc,xdash,ydash-vtic);
748: LineTo(hdc,xdash,ydash+vtic+1);
749: break;
750: case W_cross: /* do X */
751: MoveTo(hdc,xdash-htic,ydash-vtic);
752: LineTo(hdc,xdash+htic+1,ydash+vtic+1);
753: MoveTo(hdc,xdash-htic,ydash+vtic);
754: LineTo(hdc,xdash+htic+1,ydash-vtic-1);
755: break;
756: case W_star: /* do star */
757: MoveTo(hdc,xdash-htic,ydash);
758: LineTo(hdc,xdash+htic+1,ydash);
759: MoveTo(hdc,xdash,ydash-vtic);
760: LineTo(hdc,xdash,ydash+vtic+1);
761: MoveTo(hdc,xdash-htic,ydash-vtic);
762: LineTo(hdc,xdash+htic+1,ydash+vtic+1);
763: MoveTo(hdc,xdash-htic,ydash+vtic);
764: LineTo(hdc,xdash+htic+1,ydash-vtic-1);
765: break;
766: case W_circle: /* do open circle */
767: Arc(hdc, xdash-htic, ydash-vtic, xdash+htic+1, ydash+vtic+1, xdash, ydash+vtic+1, xdash, ydash+vtic+1);
768: dot(hdc, xdash, ydash);
769: break;
770: case W_fcircle: /* do filled circle */
771: Ellipse(hdc, xdash-htic, ydash-vtic, xdash+htic+1, ydash+vtic+1);
772: break;
773: default: /* Closed figure */
774: { POINT p[6];
775: int i;
776: int shape;
777: int filled = 0;
778: static float pointshapes[5][10] = {
779: {-1, -1, +1, -1, +1, +1, -1, +1, 0, 0}, /* box */
780: { 0, +1, -1, 0, 0, -1, +1, 0, 0, 0}, /* diamond */
781: { 0, -4./3, -4./3, 2./3, 4./3, 2./3, 0, 0}, /* triangle */
782: { 0, 4./3, -4./3, -2./3, 4./3, -2./3, 0, 0}, /* inverted triangle */
783: { 0, 1, 0.95106, 0.30902, 0.58779, -0.80902, -0.58779, -0.80902, -0.95106, 0.30902} /* pentagon (not used) */
784: };
785: switch (curptr->op) {
786: case W_box: shape = 0; break;
787: case W_diamond: shape = 1; break;
788: case W_itriangle: shape = 2; break;
789: case W_triangle: shape = 3; break;
790: default: shape = curptr->op-W_fbox;
791: filled = 1;
792: break;
793: }
794:
795: for ( i = 0; i<5; ++i )
796: if ( pointshapes[shape][i*2+1] == 0 && pointshapes[shape][i*2] == 0 )
797: break;
798: else {
799: p[i].x = xdash + htic*pointshapes[shape][i*2] + 0.5;
800: p[i].y = ydash + vtic*pointshapes[shape][i*2+1] + 0.5;
801: }
802: if ( filled )
803: /* Filled polygon */
804: Polygon(hdc, p, i);
805: else {
806: /* Outline polygon */
807: p[i].x = p[0].x;
808: p[i].y = p[0].y;
809: Polyline(hdc, p, i+1);
810: dot(hdc, xdash, ydash);
811: }
812: }
813: }
814: }
815: lastop = curptr->op;
816: ngwop++;
817: curptr++;
818: if ((unsigned)(curptr - blkptr->gwop) >= GWOPMAX) {
819: GlobalUnlock(blkptr->hblk);
820: blkptr->gwop = (struct GWOP FAR *)NULL;
821: blkptr = blkptr->next;
822: if (!blkptr->gwop)
823: blkptr->gwop = (struct GWOP FAR *)GlobalLock(blkptr->hblk);
824: if (!blkptr->gwop)
825: return;
826: curptr = (struct GWOP FAR *)blkptr->gwop;
827: }
828: }
829: if (polyi >= 2)
830: Polyline(hdc, ppt, polyi);
831: LocalFreePtr(ppt);
832: }
833:
834: /* ================================== */
835:
836: /* copy graph window to clipboard */
837: void
838: CopyClip(LPGW lpgw)
839: {
840: RECT rect;
841: HDC mem;
842: HBITMAP bitmap;
843: HANDLE hmf;
844: GLOBALHANDLE hGMem;
845: LPMETAFILEPICT lpMFP;
846: HWND hwnd;
847: HDC hdc;
848:
849: hwnd = lpgw->hWndGraph;
850:
851: /* view the window */
852: if (IsIconic(hwnd))
853: ShowWindow(hwnd, SW_SHOWNORMAL);
854: BringWindowToTop(hwnd);
855: UpdateWindow(hwnd);
856:
857: /* get the context */
858: hdc = GetDC(hwnd);
859: GetClientRect(hwnd, &rect);
860: /* make a bitmap and copy it there */
861: mem = CreateCompatibleDC(hdc);
862: bitmap = CreateCompatibleBitmap(hdc, rect.right - rect.left,
863: rect.bottom - rect.top);
864: if (bitmap) {
865: /* there is enough memory and the bitmaps OK */
866: SelectObject(mem, bitmap);
867: BitBlt(mem,0,0,rect.right - rect.left,
868: rect.bottom - rect.top, hdc, rect.left,
869: rect.top, SRCCOPY);
870: }
871: else {
872: MessageBeep(MB_ICONHAND);
873: MessageBox(hwnd, "Insufficient Memory to Copy Clipboard",
874: lpgw->Title, MB_ICONHAND | MB_OK);
875: }
876: DeleteDC(mem);
877: {
878: GW gwclip = *lpgw;
879: int windowfontsize = MulDiv(lpgw->fontsize, GetDeviceCaps(hdc, LOGPIXELSY), 72);
880: int i;
881: gwclip.fontsize = MulDiv(windowfontsize, lpgw->ymax, rect.bottom);
882: gwclip.hfonth = gwclip.hfontv = 0;
883:
884: /* HBB 981203: scale up pens as well... */
885: for (i=0; i<WGNUMPENS+2; i++) {
886: if(gwclip.monopen[i].lopnWidth.x > 1)
887: gwclip.monopen[i].lopnWidth.x =
888: MulDiv(gwclip.monopen[i].lopnWidth.x,
889: gwclip.xmax, rect.right-rect.left);
890: if(gwclip.colorpen[i].lopnWidth.x > 1)
891: gwclip.colorpen[i].lopnWidth.x =
892: MulDiv(gwclip.colorpen[i].lopnWidth.x,
893: gwclip.xmax, rect.right-rect.left);
894: }
895:
896: rect.right = lpgw->xmax;
897: rect.bottom = lpgw->ymax;
898:
899: MakePens(&gwclip, hdc);
900: MakeFonts(&gwclip, &rect, hdc);
901:
902: ReleaseDC(hwnd, hdc);
903:
904: hdc = CreateMetaFile((LPSTR)NULL);
905:
906: /* HBB 981203: According to Petzold, Metafiles shouldn't contain SetMapMode() calls: */
907: /*SetMapMode(hdc, MM_ANISOTROPIC);*/
908: #ifdef WIN32
909: SetWindowExtEx(hdc, rect.right, rect.bottom, (LPSIZE)NULL);
910: #else
911: SetWindowExt(hdc, rect.right, rect.bottom);
912: #endif
913: drawgraph(&gwclip, hdc, (void *) &rect);
914: hmf = CloseMetaFile(hdc);
915: DestroyFonts(&gwclip);
916: DestroyPens(&gwclip);
917: }
918:
919: hGMem = GlobalAlloc(GMEM_MOVEABLE, (DWORD)sizeof(METAFILEPICT));
920: lpMFP = (LPMETAFILEPICT) GlobalLock(hGMem);
921: hdc = GetDC(hwnd); /* get window size */
922: GetClientRect(hwnd, &rect);
923: /* in MM_ANISOTROPIC, xExt & yExt give suggested size in 0.01mm units */
924: lpMFP->mm = MM_ANISOTROPIC;
925: lpMFP->xExt = MulDiv(rect.right-rect.left, 2540, GetDeviceCaps(hdc, LOGPIXELSX));
926: /* HBB 981203: Seems it should be LOGPIXELS_Y_, here, not _X_*/
927: lpMFP->yExt = MulDiv(rect.bottom-rect.top, 2540, GetDeviceCaps(hdc, LOGPIXELSY));
928: lpMFP->hMF = hmf;
929: ReleaseDC(hwnd, hdc);
930: GlobalUnlock(hGMem);
931:
932: OpenClipboard(hwnd);
933: EmptyClipboard();
934: SetClipboardData(CF_METAFILEPICT,hGMem);
935: SetClipboardData(CF_BITMAP, bitmap);
936: CloseClipboard();
937: return;
938: }
939:
940: /* copy graph window to printer */
941: void
942: CopyPrint(LPGW lpgw)
943: {
944: #ifdef WIN32
945: DOCINFO docInfo;
946: #endif
947:
948: #if WINVER >= 0x030a
949: HDC printer;
950: DLGPROC lpfnAbortProc;
951: DLGPROC lpfnPrintDlgProc;
952: PRINTDLG pd;
953: HWND hwnd;
954: RECT rect;
955: PRINT pr;
956: UINT widabort;
957:
958: hwnd = lpgw->hWndGraph;
959:
960: _fmemset(&pd, 0, sizeof(PRINTDLG));
961: pd.lStructSize = sizeof(PRINTDLG);
962: pd.hwndOwner = hwnd;
963: pd.Flags = PD_PRINTSETUP | PD_RETURNDC;
964:
965: if (!PrintDlg(&pd))
966: return;
967: printer = pd.hDC;
968: if (NULL == printer)
969: return; /* abort */
970:
971: if (!PrintSize(printer, hwnd, &rect)) {
972: DeleteDC(printer);
973: return; /* abort */
974: }
975:
976: pr.hdcPrn = printer;
977: SetWindowLong(hwnd, 4, (LONG)((LPPRINT)&pr));
978: #ifdef WIN32
979: PrintRegister((LPPRINT)&pr);
980: #endif
981:
982: EnableWindow(hwnd,FALSE);
983: pr.bUserAbort = FALSE;
984: #ifdef WIN32
985: pr.hDlgPrint = CreateDialogParam(hdllInstance,"CancelDlgBox",hwnd,PrintDlgProc,(LPARAM)lpgw->Title);
986: SetAbortProc(printer,PrintAbortProc);
987:
988: memset(&docInfo, 0, sizeof(DOCINFO));
989: docInfo.cbSize = sizeof(DOCINFO);
990: docInfo.lpszDocName = lpgw->Title;
991:
992: if (StartDoc(printer, &docInfo) > 0) {
993: #else
994: #ifdef __DLL__
995: lpfnPrintDlgProc = (DLGPROC)GetProcAddress(hdllInstance, "PrintDlgProc");
996: lpfnAbortProc = (DLGPROC)GetProcAddress(hdllInstance, "PrintAbortProc");
997: #else
998: lpfnPrintDlgProc = (DLGPROC)MakeProcInstance((FARPROC)PrintDlgProc, hdllInstance);
999: lpfnAbortProc = (DLGPROC)MakeProcInstance((FARPROC)PrintAbortProc, hdllInstance);
1000: #endif
1001: pr.hDlgPrint = CreateDialogParam(hdllInstance,"CancelDlgBox",hwnd,lpfnPrintDlgProc,(LPARAM)lpgw->Title);
1002: Escape(printer,SETABORTPROC,0,(LPSTR)lpfnAbortProc,NULL);
1003: if (Escape(printer, STARTDOC, lstrlen(lpgw->Title),lpgw->Title, NULL) > 0) {
1004: #endif
1005: SetMapMode(printer, MM_TEXT);
1006: SetBkMode(printer,OPAQUE);
1007: #ifdef WIN32
1008: StartPage(printer);
1009: #endif
1010: DestroyFonts(lpgw);
1011: MakeFonts(lpgw, (RECT FAR *)&rect, printer);
1012: DestroyPens(lpgw); /* rebuild pens */
1013: MakePens(lpgw, printer);
1014: drawgraph(lpgw, printer, (void *) &rect);
1015: #ifdef WIN32
1016: if (EndPage(printer) > 0)
1017: EndDoc(printer);
1018: #else
1019: if (Escape(printer,NEWFRAME,0,NULL,NULL) > 0)
1020: Escape(printer,ENDDOC,0,NULL,NULL);
1021: #endif
1022: }
1023: if (!pr.bUserAbort) {
1024: EnableWindow(hwnd,TRUE);
1025: DestroyWindow(pr.hDlgPrint);
1026: }
1027: #ifndef WIN32
1028: #ifndef __DLL__
1029: FreeProcInstance((FARPROC)lpfnPrintDlgProc);
1030: FreeProcInstance((FARPROC)lpfnAbortProc);
1031: #endif
1032: #endif
1033: DeleteDC(printer);
1034: SetWindowLong(hwnd, 4, (LONG)(0L));
1035: #ifdef WIN32
1036: PrintUnregister((LPPRINT)&pr);
1037: #endif
1038: /* make certain that the screen pen set is restored */
1039: SendMessage(lpgw->hWndGraph,WM_COMMAND,M_REBUILDTOOLS,0L);
1040: #endif
1041: return;
1042: }
1043:
1044: /* ================================== */
1045: /* INI file stuff */
1046: void
1047: WriteGraphIni(LPGW lpgw)
1048: {
1049: RECT rect;
1050: int i;
1051: char entry[32];
1052: LPLOGPEN pc;
1053: LPLOGPEN pm;
1054: LPSTR file = lpgw->IniFile;
1055: LPSTR section = lpgw->IniSection;
1056: char profile[80];
1057:
1058: if ((file == (LPSTR)NULL) || (section == (LPSTR)NULL))
1059: return;
1060: if (IsIconic(lpgw->hWndGraph))
1061: ShowWindow(lpgw->hWndGraph, SW_SHOWNORMAL);
1062: GetWindowRect(lpgw->hWndGraph,&rect);
1063: wsprintf(profile, "%d %d", rect.left, rect.top);
1064: WritePrivateProfileString(section, "GraphOrigin", profile, file);
1065: wsprintf(profile, "%d %d", rect.right-rect.left, rect.bottom-rect.top);
1066: WritePrivateProfileString(section, "GraphSize", profile, file);
1067: wsprintf(profile, "%s,%d", lpgw->fontname, lpgw->fontsize);
1068: WritePrivateProfileString(section, "GraphFont", profile, file);
1069: wsprintf(profile, "%d", lpgw->color);
1070: WritePrivateProfileString(section, "GraphColor", profile, file);
1071: wsprintf(profile, "%d", lpgw->graphtotop);
1072: WritePrivateProfileString(section, "GraphToTop", profile, file);
1073: wsprintf(profile, "%d %d %d",GetRValue(lpgw->background),
1074: GetGValue(lpgw->background), GetBValue(lpgw->background));
1075: WritePrivateProfileString(section, "GraphBackground", profile, file);
1076:
1077: /* now save pens */
1078: for (i=0; i<WGNUMPENS+2; i++) {
1079: if (i==0)
1080: _fstrcpy(entry,"Border");
1081: else if (i==1)
1082: _fstrcpy(entry,"Axis");
1083: else
1084: wsprintf(entry,"Line%d",i-1);
1085: pc = &lpgw->colorpen[i];
1086: pm = &lpgw->monopen[i];
1087: wsprintf(profile, "%d %d %d %d %d",GetRValue(pc->lopnColor),
1088: GetGValue(pc->lopnColor), GetBValue(pc->lopnColor),
1089: (pc->lopnWidth.x != 1) ? -pc->lopnWidth.x : pc->lopnStyle,
1090: (pm->lopnWidth.x != 1) ? -pm->lopnWidth.x : pm->lopnStyle);
1091: WritePrivateProfileString(section, entry, profile, file);
1092: }
1093: return;
1094: }
1095:
1096: void
1097: ReadGraphIni(LPGW lpgw)
1098: {
1099: LPSTR file = lpgw->IniFile;
1100: LPSTR section = lpgw->IniSection;
1101: char profile[81];
1102: char entry[32];
1103: LPSTR p;
1104: int i,r,g,b,colorstyle,monostyle;
1105: COLORREF ref;
1106: BOOL bOKINI;
1107:
1108: bOKINI = (file != (LPSTR)NULL) && (section != (LPSTR)NULL);
1109: if (!bOKINI)
1110: profile[0] = '\0';
1111:
1112: if (bOKINI)
1113: GetPrivateProfileString(section, "GraphOrigin", "", profile, 80, file);
1114: if ( (p = GetInt(profile, (LPINT)&lpgw->Origin.x)) == NULL)
1115: lpgw->Origin.x = CW_USEDEFAULT;
1116: if ( (p = GetInt(p, (LPINT)&lpgw->Origin.y)) == NULL)
1117: lpgw->Origin.y = CW_USEDEFAULT;
1118: if (bOKINI)
1119: GetPrivateProfileString(section, "GraphSize", "", profile, 80, file);
1120: if ( (p = GetInt(profile, (LPINT)&lpgw->Size.x)) == NULL)
1121: lpgw->Size.x = CW_USEDEFAULT;
1122: if ( (p = GetInt(p, (LPINT)&lpgw->Size.y)) == NULL)
1123: lpgw->Size.y = CW_USEDEFAULT;
1124:
1125: if (bOKINI)
1126: GetPrivateProfileString(section, "GraphFont", "", profile, 80, file);
1127: {
1128: char FAR *size;
1129: size = _fstrchr(profile,',');
1130: if (size) {
1131: *size++ = '\0';
1132: if ( (p = GetInt(size, (LPINT)&lpgw->fontsize)) == NULL)
1133: lpgw->fontsize = WINFONTSIZE;
1134: }
1135: _fstrcpy(lpgw->fontname, profile);
1136: if (lpgw->fontsize == 0)
1137: lpgw->fontsize = WINFONTSIZE;
1138: if (!(*lpgw->fontname))
1139: if (LOWORD(GetVersion()) == 3)
1140: _fstrcpy(lpgw->fontname,WIN30FONT);
1141: else
1142: _fstrcpy(lpgw->fontname,WINFONT);
1143: }
1144:
1145: if (bOKINI)
1146: GetPrivateProfileString(section, "GraphColor", "", profile, 80, file);
1147: if ( (p = GetInt(profile, (LPINT)&lpgw->color)) == NULL)
1148: lpgw->color = TRUE;
1149:
1150: if (bOKINI)
1151: GetPrivateProfileString(section, "GraphToTop", "", profile, 80, file);
1152: if ( (p = GetInt(profile, (LPINT)&lpgw->graphtotop)) == NULL)
1153: lpgw->graphtotop = TRUE;
1154:
1155: lpgw->background = RGB(255,255,255);
1156: if (bOKINI)
1157: GetPrivateProfileString(section, "GraphBackground", "", profile, 80, file);
1158: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1159: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1160: ((p = GetInt(p, (LPINT)&b)) != NULL) )
1161: lpgw->background = RGB(r,g,b);
1162:
1163: StorePen(lpgw, 0,RGB(0,0,0),PS_SOLID,PS_SOLID);
1164: if (bOKINI)
1165: GetPrivateProfileString(section, "Border", "", profile, 80, file);
1166: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1167: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1168: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1169: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1170: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1171: StorePen(lpgw,0,RGB(r,g,b),colorstyle,monostyle);
1172:
1173: StorePen(lpgw, 1,RGB(192,192,192),PS_DOT,PS_DOT);
1174: if (bOKINI)
1175: GetPrivateProfileString(section, "Axis", "", profile, 80, file);
1176: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1177: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1178: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1179: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1180: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1181: StorePen(lpgw,1,RGB(r,g,b),colorstyle,monostyle);
1182:
1183: for (i=0; i<WGNUMPENS; i++)
1184: {
1185: ref = wginitcolor[ i%WGDEFCOLOR ];
1186: colorstyle = wginitstyle[ (i/WGDEFCOLOR) % WGDEFSTYLE ];
1187: monostyle = wginitstyle[ i%WGDEFSTYLE ];
1188: StorePen(lpgw, i+2,ref,colorstyle,monostyle);
1189: wsprintf(entry,"Line%d",i+1);
1190: if (bOKINI)
1191: GetPrivateProfileString(section, entry, "", profile, 80, file);
1192: if ( ((p = GetInt(profile, (LPINT)&r)) != NULL) &&
1193: ((p = GetInt(p, (LPINT)&g)) != NULL) &&
1194: ((p = GetInt(p, (LPINT)&b)) != NULL) &&
1195: ((p = GetInt(p, (LPINT)&colorstyle)) != NULL) &&
1196: ((p = GetInt(p, (LPINT)&monostyle)) != NULL) )
1197: StorePen(lpgw,i+2,RGB(r,g,b),colorstyle,monostyle);
1198: }
1199: }
1200:
1201:
1202: /* ================================== */
1203:
1204: #define LS_DEFLINE 2
1205: typedef struct tagLS {
1206: int widtype;
1207: int wid;
1208: HWND hwnd;
1209: int pen; /* current pen number */
1210: LOGPEN colorpen[WGNUMPENS+2]; /* logical color pens */
1211: LOGPEN monopen[WGNUMPENS+2]; /* logical mono pens */
1212: } LS;
1213: typedef LS FAR* LPLS;
1214:
1215:
1216: COLORREF
1217: GetColor(HWND hwnd, COLORREF ref)
1218: {
1219: CHOOSECOLOR cc;
1220: COLORREF aclrCust[16];
1221: int i;
1222:
1223: for (i=0; i<16; i++) {
1224: aclrCust[i] = RGB(0,0,0);
1225: }
1226: _fmemset(&cc, 0, sizeof(CHOOSECOLOR));
1227: cc.lStructSize = sizeof(CHOOSECOLOR);
1228: cc.hwndOwner = hwnd;
1229: cc.lpCustColors = aclrCust;
1230: cc.rgbResult = ref;
1231: cc.Flags = CC_RGBINIT;
1232: if (ChooseColor(&cc))
1233: return cc.rgbResult;
1234: return ref;
1235: }
1236:
1237:
1238: /* force update of owner draw button */
1239: void
1240: UpdateColorSample(HWND hdlg)
1241: {
1242: RECT rect;
1243: POINT ptul, ptlr;
1244: GetWindowRect( GetDlgItem(hdlg, LS_COLORSAMPLE), &rect);
1245: ptul.x = rect.left;
1246: ptul.y = rect.top;
1247: ptlr.x = rect.right;
1248: ptlr.y = rect.bottom;
1249: ScreenToClient(hdlg, &ptul);
1250: ScreenToClient(hdlg, &ptlr);
1251: rect.left = ptul.x;
1252: rect.top = ptul.y;
1253: rect.right = ptlr.x;
1254: rect.bottom = ptlr.y;
1255: InvalidateRect(hdlg, &rect, TRUE);
1256: UpdateWindow(hdlg);
1257: }
1258:
1259: BOOL CALLBACK WINEXPORT
1260: LineStyleDlgProc(HWND hdlg, UINT wmsg, WPARAM wparam, LPARAM lparam)
1261: {
1262: char buf[16];
1263: LPLS lpls;
1264: int i;
1265: UINT pen;
1266: LPLOGPEN plpm, plpc;
1267: lpls = (LPLS)GetWindowLong(GetParent(hdlg), 4);
1268:
1269: switch (wmsg) {
1270: case WM_INITDIALOG:
1271: pen = 2;
1272: for (i=0; i<WGNUMPENS+2; i++) {
1273: if (i==0)
1274: _fstrcpy(buf,"Border");
1275: else if (i==1)
1276: _fstrcpy(buf,"Axis");
1277: else
1278: wsprintf(buf,"Line%d",i-1);
1279: SendDlgItemMessage(hdlg, LS_LINENUM, LB_ADDSTRING, 0,
1280: (LPARAM)((LPSTR)buf));
1281: }
1282: SendDlgItemMessage(hdlg, LS_LINENUM, LB_SETCURSEL, pen, 0L);
1283:
1284: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1285: (LPARAM)((LPSTR)"Solid"));
1286: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1287: (LPARAM)((LPSTR)"Dash"));
1288: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1289: (LPARAM)((LPSTR)"Dot"));
1290: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1291: (LPARAM)((LPSTR)"DashDot"));
1292: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_ADDSTRING, 0,
1293: (LPARAM)((LPSTR)"DashDotDot"));
1294:
1295: plpm = &lpls->monopen[pen];
1296: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1297: plpm->lopnStyle, 0L);
1298: wsprintf(buf,"%d",plpm->lopnWidth.x);
1299: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1300:
1301: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1302: (LPARAM)((LPSTR)"Solid"));
1303: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1304: (LPARAM)((LPSTR)"Dash"));
1305: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1306: (LPARAM)((LPSTR)"Dot"));
1307: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1308: (LPARAM)((LPSTR)"DashDot"));
1309: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_ADDSTRING, 0,
1310: (LPARAM)((LPSTR)"DashDotDot"));
1311:
1312: plpc = &lpls->colorpen[pen];
1313: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1314: plpc->lopnStyle, 0L);
1315: wsprintf(buf,"%d",plpc->lopnWidth.x);
1316: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1317:
1318: return TRUE;
1319: case WM_COMMAND:
1320: pen = (UINT)SendDlgItemMessage(hdlg, LS_LINENUM, LB_GETCURSEL, 0, 0L);
1321: plpm = &lpls->monopen[pen];
1322: plpc = &lpls->colorpen[pen];
1323: switch (LOWORD(wparam)) {
1324: case LS_LINENUM:
1325: wsprintf(buf,"%d",plpm->lopnWidth.x);
1326: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1327: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1328: plpm->lopnStyle, 0L);
1329: wsprintf(buf,"%d",plpc->lopnWidth.x);
1330: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1331: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1332: plpc->lopnStyle, 0L);
1333: UpdateColorSample(hdlg);
1334: return FALSE;
1335: case LS_MONOSTYLE:
1336: plpm->lopnStyle =
1337: (UINT)SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_GETCURSEL, 0, 0L);
1338: if (plpm->lopnStyle != 0) {
1339: plpm->lopnWidth.x = 1;
1340: wsprintf(buf,"%d",plpm->lopnWidth.x);
1341: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1342: }
1343: return FALSE;
1344: case LS_MONOWIDTH:
1345: GetDlgItemText(hdlg, LS_MONOWIDTH, buf, 15);
1346: GetInt(buf, (LPINT)&plpm->lopnWidth.x);
1347: if (plpm->lopnWidth.x != 1) {
1348: plpm->lopnStyle = 0;
1349: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1350: plpm->lopnStyle, 0L);
1351: }
1352: return FALSE;
1353: case LS_CHOOSECOLOR:
1354: plpc->lopnColor = GetColor(hdlg, plpc->lopnColor);
1355: UpdateColorSample(hdlg);
1356: return FALSE;
1357: case LS_COLORSTYLE:
1358: plpc->lopnStyle =
1359: (UINT)SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_GETCURSEL, 0, 0L);
1360: if (plpc->lopnStyle != 0) {
1361: plpc->lopnWidth.x = 1;
1362: wsprintf(buf,"%d",plpc->lopnWidth.x);
1363: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1364: }
1365: return FALSE;
1366: case LS_COLORWIDTH:
1367: GetDlgItemText(hdlg, LS_COLORWIDTH, buf, 15);
1368: GetInt(buf, (LPINT)&plpc->lopnWidth.x);
1369: if (plpc->lopnWidth.x != 1) {
1370: plpc->lopnStyle = 0;
1371: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1372: plpc->lopnStyle, 0L);
1373: }
1374: return FALSE;
1375: case LS_DEFAULT:
1376: plpm = lpls->monopen;
1377: plpc = lpls->colorpen;
1378: /* border */
1379: plpc->lopnColor = RGB(0,0,0);
1380: plpc->lopnStyle = PS_SOLID;
1381: plpc->lopnWidth.x = 1;
1382: plpm->lopnStyle = PS_SOLID;
1383: plpm->lopnWidth.x = 1;
1384: plpc++; plpm++;
1385: /* axis */
1386: plpc->lopnColor = RGB(192,192,192);
1387: plpc->lopnStyle = PS_DOT;
1388: plpc->lopnWidth.x = 1;
1389: plpm->lopnStyle = PS_DOT;
1390: plpm->lopnWidth.x = 1;
1391: /* LineX */
1392: for (i=0; i<WGNUMPENS; i++) {
1393: plpc++; plpm++;
1394: plpc->lopnColor = wginitcolor[ i%WGDEFCOLOR ];
1395: plpc->lopnStyle = wginitstyle[ (i/WGDEFCOLOR) % WGDEFSTYLE ];
1396: plpc->lopnWidth.x = 1;
1397: plpm->lopnStyle = wginitstyle[ i%WGDEFSTYLE ];
1398: plpm->lopnWidth.x = 1;
1399: }
1400: /* update window */
1401: plpm = &lpls->monopen[pen];
1402: plpc = &lpls->colorpen[pen];
1403: SendDlgItemMessage(hdlg, LS_LINENUM, LB_SETCURSEL, pen, 0L);
1404: wsprintf(buf,"%d",plpm->lopnWidth.x);
1405: SetDlgItemText(hdlg, LS_MONOWIDTH, buf);
1406: SendDlgItemMessage(hdlg, LS_MONOSTYLE, CB_SETCURSEL,
1407: plpm->lopnStyle, 0L);
1408: wsprintf(buf,"%d",plpc->lopnWidth.x);
1409: SetDlgItemText(hdlg, LS_COLORWIDTH, buf);
1410: SendDlgItemMessage(hdlg, LS_COLORSTYLE, CB_SETCURSEL,
1411: plpc->lopnStyle, 0L);
1412: UpdateColorSample(hdlg);
1413: return FALSE;
1414: case IDOK:
1415: EndDialog(hdlg, IDOK);
1416: return TRUE;
1417: case IDCANCEL:
1418: EndDialog(hdlg, IDCANCEL);
1419: return TRUE;
1420: }
1421: break;
1422: case WM_DRAWITEM:
1423: {
1424: HBRUSH hBrush;
1425: LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT)lparam;
1426: pen = (UINT)SendDlgItemMessage(hdlg, LS_LINENUM, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
1427: plpc = &lpls->colorpen[pen];
1428: hBrush = CreateSolidBrush(plpc->lopnColor);
1429: FillRect(lpdis->hDC, &lpdis->rcItem, hBrush);
1430: FrameRect(lpdis->hDC, &lpdis->rcItem, (HBRUSH)GetStockObject(BLACK_BRUSH));
1431: DeleteObject(hBrush);
1432: }
1433: return FALSE;
1434: }
1435: return FALSE;
1436: }
1437:
1438:
1439:
1440: /* GetWindowLong(hwnd, 4) must be available for use */
1441: BOOL
1442: LineStyle(LPGW lpgw)
1443: {
1444: DLGPROC lpfnLineStyleDlgProc ;
1445: BOOL status = FALSE;
1446: LS ls;
1447:
1448: SetWindowLong(lpgw->hWndGraph, 4, (LONG)((LPLS)&ls));
1449: _fmemcpy(&ls.colorpen, &lpgw->colorpen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1450: _fmemcpy(&ls.monopen, &lpgw->monopen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1451:
1452: #ifdef WIN32
1453: if (DialogBox (hdllInstance, "LineStyleDlgBox", lpgw->hWndGraph, LineStyleDlgProc)
1454: #else
1455: #ifdef __DLL__
1456: lpfnLineStyleDlgProc = (DLGPROC)GetProcAddress(hdllInstance, "LineStyleDlgProc");
1457: #else
1458: lpfnLineStyleDlgProc = (DLGPROC)MakeProcInstance((FARPROC)LineStyleDlgProc, hdllInstance);
1459: #endif
1460: if (DialogBox (hdllInstance, "LineStyleDlgBox", lpgw->hWndGraph, lpfnLineStyleDlgProc)
1461: #endif
1462: == IDOK) {
1463: _fmemcpy(&lpgw->colorpen, &ls.colorpen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1464: _fmemcpy(&lpgw->monopen, &ls.monopen, (WGNUMPENS + 2) * sizeof(LOGPEN));
1465: status = TRUE;
1466: }
1467: #ifndef WIN32
1468: #ifndef __DLL__
1469: FreeProcInstance((FARPROC)lpfnLineStyleDlgProc);
1470: #endif
1471: #endif
1472: SetWindowLong(lpgw->hWndGraph, 4, (LONG)(0L));
1473: return status;
1474: }
1475:
1476: /* ================================== */
1477:
1478: LRESULT CALLBACK WINEXPORT
1479: WndGraphProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1480: {
1481: HDC hdc;
1482: PAINTSTRUCT ps;
1483: RECT rect;
1484: LPGW lpgw;
1485: HMENU sysmenu;
1486: int i;
1487:
1488: lpgw = (LPGW)GetWindowLong(hwnd, 0);
1489:
1490: switch(message)
1491: {
1492: case WM_SYSCOMMAND:
1493: switch(LOWORD(wParam))
1494: {
1495: case M_GRAPH_TO_TOP:
1496: case M_COLOR:
1497: case M_CHOOSE_FONT:
1498: case M_COPY_CLIP:
1499: case M_LINESTYLE:
1500: case M_BACKGROUND:
1501: case M_PRINT:
1502: case M_WRITEINI:
1503: case M_REBUILDTOOLS:
1504: SendMessage(hwnd, WM_COMMAND, wParam, lParam);
1505: break;
1506: case M_ABOUT:
1507: if (lpgw->lptw)
1508: AboutBox(hwnd,lpgw->lptw->AboutText);
1509: return 0;
1510: case M_COMMANDLINE:
1511: sysmenu = GetSystemMenu(lpgw->hWndGraph,0);
1512: i = GetMenuItemCount (sysmenu);
1513: DeleteMenu (sysmenu, --i, MF_BYPOSITION);
1514: DeleteMenu (sysmenu, --i, MF_BYPOSITION);
1515: ShowWindow (lpgw->lptw->hWndParent, SW_SHOW);
1516: break;
1517: }
1518: break;
1519: case WM_COMMAND:
1520: switch(LOWORD(wParam))
1521: {
1522: case M_GRAPH_TO_TOP:
1523: lpgw->graphtotop = !lpgw->graphtotop;
1524: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1525: return(0);
1526: case M_COLOR:
1527: lpgw->color = !lpgw->color;
1528: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1529: return(0);
1530: case M_CHOOSE_FONT:
1531: SelFont(lpgw);
1532: return 0;
1533: case M_COPY_CLIP:
1534: CopyClip(lpgw);
1535: return 0;
1536: case M_LINESTYLE:
1537: if (LineStyle(lpgw))
1538: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1539: return 0;
1540: case M_BACKGROUND:
1541: lpgw->background = GetColor(hwnd, lpgw->background);
1542: SendMessage(hwnd,WM_COMMAND,M_REBUILDTOOLS,0L);
1543: return 0;
1544: case M_PRINT:
1545: CopyPrint(lpgw);
1546: return 0;
1547: case M_WRITEINI:
1548: WriteGraphIni(lpgw);
1549: if (lpgw->lptw)
1550: WriteTextIni(lpgw->lptw);
1551: return 0;
1552: case M_REBUILDTOOLS:
1553: lpgw->resized = TRUE;
1554: if (lpgw->color)
1555: CheckMenuItem(lpgw->hPopMenu, M_COLOR, MF_BYCOMMAND | MF_CHECKED);
1556: else
1557: CheckMenuItem(lpgw->hPopMenu, M_COLOR, MF_BYCOMMAND | MF_UNCHECKED);
1558: if (lpgw->graphtotop)
1559: CheckMenuItem(lpgw->hPopMenu, M_GRAPH_TO_TOP, MF_BYCOMMAND | MF_CHECKED);
1560: else
1561: CheckMenuItem(lpgw->hPopMenu, M_GRAPH_TO_TOP, MF_BYCOMMAND | MF_UNCHECKED);
1562: DestroyPens(lpgw);
1563: DestroyFonts(lpgw);
1564: hdc = GetDC(hwnd);
1565: MakePens(lpgw, hdc);
1566: GetClientRect(hwnd, &rect);
1567: MakeFonts(lpgw, (LPRECT)&rect, hdc);
1568: ReleaseDC(hwnd, hdc);
1569: GetClientRect(hwnd, &rect);
1570: InvalidateRect(hwnd, (LPRECT) &rect, 1);
1571: UpdateWindow(hwnd);
1572: return 0;
1573: }
1574: return 0;
1575: case WM_RBUTTONDOWN:
1576: {
1577: POINT pt;
1578: pt.x = LOWORD(lParam);
1579: pt.y = HIWORD(lParam);
1580: ClientToScreen(hwnd,&pt);
1581: TrackPopupMenu(lpgw->hPopMenu, TPM_LEFTALIGN,
1582: pt.x, pt.y, 0, hwnd, NULL);
1583: }
1584: return(0);
1585: case WM_CREATE:
1586: lpgw = ((CREATESTRUCT FAR *)lParam)->lpCreateParams;
1587: SetWindowLong(hwnd, 0, (LONG)lpgw);
1588: lpgw->hWndGraph = hwnd;
1589: hdc = GetDC(hwnd);
1590: MakePens(lpgw, hdc);
1591: GetClientRect(hwnd, &rect);
1592: MakeFonts(lpgw, (LPRECT)&rect, hdc);
1593: ReleaseDC(hwnd, hdc);
1594: #if WINVER >= 0x030a
1595: {
1596: WORD version = LOWORD(GetVersion());
1597: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1598: if ( lpgw->lptw && (lpgw->lptw->DragPre!=(LPSTR)NULL) && (lpgw->lptw->DragPost!=(LPSTR)NULL) )
1599: DragAcceptFiles(hwnd, TRUE);
1600: }
1601: #endif
1602: return(0);
1603: case WM_PAINT:
1604: hdc = BeginPaint(hwnd, &ps);
1605: SetMapMode(hdc, MM_TEXT);
1606: SetBkMode(hdc,OPAQUE);
1607: GetClientRect(hwnd, &rect);
1608: #ifdef WIN32
1609: SetViewportExtEx(hdc, rect.right, rect.bottom, NULL);
1610: #else
1611: SetViewportExt(hdc, rect.right, rect.bottom);
1612: #endif
1613: drawgraph(lpgw, hdc, (void *) &rect);
1614: EndPaint(hwnd, &ps);
1615: return 0;
1616: case WM_SIZE:
1617: /* update font sizes if graph resized */
1618: if ((wParam == SIZE_MAXIMIZED) || (wParam == SIZE_RESTORED)) {
1619: RECT rect;
1620: SendMessage(hwnd,WM_SYSCOMMAND,M_REBUILDTOOLS,0L);
1621: GetWindowRect(hwnd,&rect);
1622: lpgw->Size.x = rect.right-rect.left;
1623: lpgw->Size.y = rect.bottom-rect.top;
1624: }
1625: break;
1626: #if WINVER >= 0x030a
1627: case WM_DROPFILES:
1628: {
1629: WORD version = LOWORD(GetVersion());
1630: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1631: if (lpgw->lptw)
1632: DragFunc(lpgw->lptw, (HDROP)wParam);
1633: }
1634: break;
1635: #endif
1636: case WM_DESTROY:
1637: DestroyPens(lpgw);
1638: DestroyFonts(lpgw);
1639: #if __TURBOC__ >= 0x410 /* Borland C++ 3.1 or later */
1640: {
1641: WORD version = LOWORD(GetVersion());
1642: if ((LOBYTE(version)*100 + HIBYTE(version)) >= 310)
1643: DragAcceptFiles(hwnd, FALSE);
1644: }
1645: #endif
1646: if (lpgw->lptw && !IsWindowVisible(lpgw->lptw->hWndParent)) {
1647: PostMessage (lpgw->lptw->hWndParent, WM_CLOSE, 0, 0);
1648: }
1649: return 0;
1650: case WM_CLOSE:
1651: GraphClose(lpgw);
1652: return 0;
1653: }
1654: return DefWindowProc(hwnd, message, wParam, lParam);
1655: }
1656: