1 /*---------------------------------------------------------------------------
2
3 rpng - simple PNG display program rpng-win.c
4
5 This program decodes and displays PNG images, with gamma correction and
6 optionally with a user-specified background color (in case the image has
7 transparency). It is very nearly the most basic PNG viewer possible.
8 This version is for 32-bit Windows; it may compile under 16-bit Windows
9 with a little tweaking (or maybe not).
10
11 to do:
12 - handle quoted command-line args (especially filenames with spaces)
13 - have minimum window width: oh well
14 - use %.1023s to simplify truncation of title-bar string?
15
16 ---------------------------------------------------------------------------
17
18 Changelog:
19 - 1.00: initial public release
20 - 1.01: modified to allow abbreviated options; fixed long/ulong mis-
21 match; switched to png_jmpbuf() macro
22 - 1.02: added extra set of parentheses to png_jmpbuf() macro; fixed
23 command-line parsing bug
24 - 1.10: enabled "message window"/console (thanks to David Geldreich)
25 - 2.00: dual-licensed (added GNU GPL)
26 - 2.01: fixed improper display of usage screen on PNG error(s)
27 - 2.02: check for integer overflow (Glenn R-P)
28
29 ---------------------------------------------------------------------------
30
31 Copyright (c) 1998-2008, 2017 Greg Roelofs. All rights reserved.
32
33 This software is provided "as is," without warranty of any kind,
34 express or implied. In no event shall the author or contributors
35 be held liable for any damages arising in any way from the use of
36 this software.
37
38 The contents of this file are DUAL-LICENSED. You may modify and/or
39 redistribute this software according to the terms of one of the
40 following two licenses (at your option):
41
42
43 LICENSE 1 ("BSD-like with advertising clause"):
44
45 Permission is granted to anyone to use this software for any purpose,
46 including commercial applications, and to alter it and redistribute
47 it freely, subject to the following restrictions:
48
49 1. Redistributions of source code must retain the above copyright
50 notice, disclaimer, and this list of conditions.
51 2. Redistributions in binary form must reproduce the above copyright
52 notice, disclaimer, and this list of conditions in the documenta-
53 tion and/or other materials provided with the distribution.
54 3. All advertising materials mentioning features or use of this
55 software must display the following acknowledgment:
56
57 This product includes software developed by Greg Roelofs
58 and contributors for the book, "PNG: The Definitive Guide,"
59 published by O'Reilly and Associates.
60
61
62 LICENSE 2 (GNU GPL v2 or later):
63
64 This program is free software; you can redistribute it and/or modify
65 it under the terms of the GNU General Public License as published by
66 the Free Software Foundation; either version 2 of the License, or
67 (at your option) any later version.
68
69 This program is distributed in the hope that it will be useful,
70 but WITHOUT ANY WARRANTY; without even the implied warranty of
71 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
72 GNU General Public License for more details.
73
74 You should have received a copy of the GNU General Public License
75 along with this program; if not, write to the Free Software Foundation,
76 Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
77
78 ---------------------------------------------------------------------------*/
79
80 #define PROGNAME "rpng-win"
81 #define LONGNAME "Simple PNG Viewer for Windows"
82 #define VERSION "2.01 of 16 March 2008"
83
84 #include <stdio.h>
85 #include <stdlib.h>
86 #include <string.h>
87 #include <time.h>
88 #include <windows.h>
89 #ifdef __CYGWIN__
90 /* getch replacement. Turns out, we don't really need this,
91 * but leave it here if we ever enable any of the uses of
92 * _getch in the main code
93 */
94 #include <unistd.h>
95 #include <termio.h>
96 #include <sys/ioctl.h>
97 int repl_getch( void )
98 {
99 char ch;
100 int fd = fileno(stdin);
101 struct termio old_tty, new_tty;
102
103 ioctl(fd, TCGETA, &old_tty);
104 new_tty = old_tty;
105 new_tty.c_lflag &= ~(ICANON | ECHO | ISIG);
106 ioctl(fd, TCSETA, &new_tty);
107 fread(&ch, 1, sizeof(ch), stdin);
108 ioctl(fd, TCSETA, &old_tty);
109
110 return ch;
111 }
112 #define _getch repl_getch
113 #else
114 #include <conio.h> /* only for _getch() */
115 #endif
116
117 /* #define DEBUG : this enables the Trace() macros */
118
119 #include "readpng.h" /* typedefs, common macros, readpng prototypes */
120
121
122 /* could just include png.h, but this macro is the only thing we need
123 * (name and typedefs changed to local versions); note that side effects
124 * only happen with alpha (which could easily be avoided with
125 * "ush acopy = (alpha);") */
126
127 #define alpha_composite(composite, fg, alpha, bg) { \
128 ush temp = ((ush)(fg)*(ush)(alpha) + \
129 (ush)(bg)*(ush)(255 - (ush)(alpha)) + (ush)128); \
130 (composite) = (uch)((temp + (temp >> 8)) >> 8); \
131 }
132
133
134 /* local prototypes */
135 static int rpng_win_create_window(HINSTANCE hInst, int showmode);
136 static int rpng_win_display_image(void);
137 static void rpng_win_cleanup(void);
138 LRESULT CALLBACK rpng_win_wndproc(HWND, UINT, WPARAM, LPARAM);
139
140
141 static char titlebar[1024];
142 static char *progname = PROGNAME;
143 static char *appname = LONGNAME;
144 static char *filename;
145 static FILE *infile;
146
147 static char *bgstr;
148 static uch bg_red=0, bg_green=0, bg_blue=0;
149
150 static double display_exponent;
151
152 static ulg image_width, image_height, image_rowbytes;
153 static int image_channels;
154 static uch *image_data;
155
156 /* Windows-specific variables */
157 static ulg wimage_rowbytes;
158 static uch *dib;
159 static uch *wimage_data;
160 static BITMAPINFOHEADER *bmih;
161
162 static HWND global_hwnd;
163
164
165
166
167 int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR cmd, int showmode)
168 {
169 char *args[1024]; /* arbitrary limit, but should suffice */
170 char *p, *q, **argv = args;
171 int argc = 0;
172 int rc, alen, flen;
173 int error = 0;
174 int have_bg = FALSE;
175 double LUT_exponent; /* just the lookup table */
176 double CRT_exponent = 2.2; /* just the monitor */
177 double default_display_exponent; /* whole display system */
178 MSG msg;
179
180
181 filename = (char *)NULL;
182
183 #ifndef __CYGWIN__
184 /* First reenable console output, which normally goes to the bit bucket
185 * for windowed apps. Closing the console window will terminate the
186 * app. Thanks to David.Geldreich at realviz.com for supplying the magical
187 * incantation. */
188
189 AllocConsole();
190 freopen("CONOUT$", "a", stderr);
191 freopen("CONOUT$", "a", stdout);
192 #endif
193
194
195 /* Next set the default value for our display-system exponent, i.e.,
196 * the product of the CRT exponent and the exponent corresponding to
197 * the frame-buffer's lookup table (LUT), if any. This is not an
198 * exhaustive list of LUT values (e.g., OpenStep has a lot of weird
199 * ones), but it should cover 99% of the current possibilities. And
200 * yes, these ifdefs are completely wasted in a Windows program... */
201
202 #if defined(NeXT)
203 LUT_exponent = 1.0 / 2.2;
204 /*
205 if (some_next_function_that_returns_gamma(&next_gamma))
206 LUT_exponent = 1.0 / next_gamma;
207 */
208 #elif defined(sgi)
209 LUT_exponent = 1.0 / 1.7;
210 /* there doesn't seem to be any documented function to get the
211 * "gamma" value, so we do it the hard way */
212 infile = fopen("/etc/config/system.glGammaVal", "r");
213 if (infile) {
214 double sgi_gamma;
215
216 fgets(tmpline, 80, infile);
217 fclose(infile);
218 sgi_gamma = atof(tmpline);
219 if (sgi_gamma > 0.0)
220 LUT_exponent = 1.0 / sgi_gamma;
221 }
222 #elif defined(Macintosh)
223 LUT_exponent = 1.8 / 2.61;
224 /*
225 if (some_mac_function_that_returns_gamma(&mac_gamma))
226 LUT_exponent = mac_gamma / 2.61;
227 */
228 #else
229 LUT_exponent = 1.0; /* assume no LUT: most PCs */
230 #endif
231
232 /* the defaults above give 1.0, 1.3, 1.5 and 2.2, respectively: */
233 default_display_exponent = LUT_exponent * CRT_exponent;
234
235
236 /* If the user has set the SCREEN_GAMMA environment variable as suggested
237 * (somewhat imprecisely) in the libpng documentation, use that; otherwise
238 * use the default value we just calculated. Either way, the user may
239 * override this via a command-line option. */
240
241 if ((p = getenv("SCREEN_GAMMA")) != NULL)
242 display_exponent = atof(p);
243 else
244 display_exponent = default_display_exponent;
245
246
247 /* Windows really hates command lines, so we have to set up our own argv.
248 * Note that we do NOT bother with quoted arguments here, so don't use
249 * filenames with spaces in 'em! */
250
251 argv[argc++] = PROGNAME;
252 p = cmd;
253 for (;;) {
254 if (*p == ' ')
255 while (*++p == ' ')
256 ;
257 /* now p points at the first non-space after some spaces */
258 if (*p == '\0')
259 break; /* nothing after the spaces: done */
260 argv[argc++] = q = p;
261 while (*q && *q != ' ')
262 ++q;
263 /* now q points at a space or the end of the string */
264 if (*q == '\0')
265 break; /* last argv already terminated; quit */
266 *q = '\0'; /* change space to terminator */
267 p = q + 1;
268 }
269 argv[argc] = NULL; /* terminate the argv array itself */
270
271
272 /* Now parse the command line for options and the PNG filename. */
273
274 while (*++argv && !error) {
275 if (!strncmp(*argv, "-gamma", 2)) {
276 if (!*++argv)
277 ++error;
278 else {
279 display_exponent = atof(*argv);
280 if (display_exponent <= 0.0)
281 ++error;
282 }
283 } else if (!strncmp(*argv, "-bgcolor", 2)) {
284 if (!*++argv)
285 ++error;
286 else {
287 bgstr = *argv;
288 if (strlen(bgstr) != 7 || bgstr[0] != '#')
289 ++error;
290 else
291 have_bg = TRUE;
292 }
293 } else {
294 if (**argv != '-') {
295 filename = *argv;
296 if (argv[1]) /* shouldn't be any more args after filename */
297 ++error;
298 } else
299 ++error; /* not expecting any other options */
300 }
301 }
302
303 if (!filename)
304 ++error;
305
306
307 /* print usage screen if any errors up to this point */
308
309 if (error) {
310 #ifndef __CYGWIN__
311 int ch;
312 #endif
313
314 fprintf(stderr, "\n%s %s: %s\n\n", PROGNAME, VERSION, appname);
315 readpng_version_info();
316 fprintf(stderr, "\n"
317 "Usage: %s [-gamma exp] [-bgcolor bg] file.png\n"
318 " exp \ttransfer-function exponent (``gamma'') of the display\n"
319 "\t\t system in floating-point format (e.g., ``%.1f''); equal\n"
320 "\t\t to the product of the lookup-table exponent (varies)\n"
321 "\t\t and the CRT exponent (usually 2.2); must be positive\n"
322 " bg \tdesired background color in 7-character hex RGB format\n"
323 "\t\t (e.g., ``#ff7700'' for orange: same as HTML colors);\n"
324 "\t\t used with transparent images\n"
325 "\nPress Q, Esc or mouse button 1 after image is displayed to quit.\n"
326 #ifndef __CYGWIN__
327 "Press Q or Esc to quit this usage screen.\n"
328 #endif
329 "\n", PROGNAME, default_display_exponent);
330 #ifndef __CYGWIN__
331 do
332 ch = _getch();
333 while (ch != 'q' && ch != 'Q' && ch != 0x1B);
334 #endif
335 exit(1);
336 }
337
338
339 if (!(infile = fopen(filename, "rb"))) {
340 fprintf(stderr, PROGNAME ": can't open PNG file [%s]\n", filename);
341 ++error;
342 } else {
343 if ((rc = readpng_init(infile, &image_width, &image_height)) != 0) {
344 switch (rc) {
345 case 1:
346 fprintf(stderr, PROGNAME
347 ": [%s] is not a PNG file: incorrect signature\n",
348 filename);
349 break;
350 case 2:
351 fprintf(stderr, PROGNAME
352 ": [%s] has bad IHDR (libpng longjmp)\n", filename);
353 break;
354 case 4:
355 fprintf(stderr, PROGNAME ": insufficient memory\n");
356 break;
357 default:
358 fprintf(stderr, PROGNAME
359 ": unknown readpng_init() error\n");
360 break;
361 }
362 ++error;
363 }
364 if (error)
365 fclose(infile);
366 }
367
368
369 if (error) {
370 #ifndef __CYGWIN__
371 int ch;
372 #endif
373
374 fprintf(stderr, PROGNAME ": aborting.\n");
375 #ifndef __CYGWIN__
376 do
377 ch = _getch();
378 while (ch != 'q' && ch != 'Q' && ch != 0x1B);
379 #endif
380 exit(2);
381 } else {
382 fprintf(stderr, "\n%s %s: %s\n", PROGNAME, VERSION, appname);
383 #ifndef __CYGWIN__
384 fprintf(stderr,
385 "\n [console window: closing this window will terminate %s]\n\n",
386 PROGNAME);
387 #endif
388 }
389
390
391 /* set the title-bar string, but make sure buffer doesn't overflow */
392
393 alen = strlen(appname);
394 flen = strlen(filename);
395 if (alen + flen + 3 > 1023)
396 sprintf(titlebar, "%s: ...%s", appname, filename+(alen+flen+6-1023));
397 else
398 sprintf(titlebar, "%s: %s", appname, filename);
399
400
401 /* if the user didn't specify a background color on the command line,
402 * check for one in the PNG file--if not, the initialized values of 0
403 * (black) will be used */
404
405 if (have_bg) {
406 unsigned r, g, b; /* this approach quiets compiler warnings */
407
408 sscanf(bgstr+1, "%2x%2x%2x", &r, &g, &b);
409 bg_red = (uch)r;
410 bg_green = (uch)g;
411 bg_blue = (uch)b;
412 } else if (readpng_get_bgcolor(&bg_red, &bg_green, &bg_blue) > 1) {
413 readpng_cleanup(TRUE);
414 fprintf(stderr, PROGNAME
415 ": libpng error while checking for background color\n");
416 exit(2);
417 }
418
419
420 /* do the basic Windows initialization stuff, make the window and fill it
421 * with the background color */
422
423 if (rpng_win_create_window(hInst, showmode))
424 exit(2);
425
426
427 /* decode the image, all at once */
428
429 Trace((stderr, "calling readpng_get_image()\n"))
430 image_data = readpng_get_image(display_exponent, &image_channels,
431 &image_rowbytes);
432 Trace((stderr, "done with readpng_get_image()\n"))
433
434
435 /* done with PNG file, so clean up to minimize memory usage (but do NOT
436 * nuke image_data!) */
437
438 readpng_cleanup(FALSE);
439 fclose(infile);
440
441 if (!image_data) {
442 fprintf(stderr, PROGNAME ": unable to decode PNG image\n");
443 exit(3);
444 }
445
446
447 /* display image (composite with background if requested) */
448
449 Trace((stderr, "calling rpng_win_display_image()\n"))
450 if (rpng_win_display_image()) {
451 free(image_data);
452 exit(4);
453 }
454 Trace((stderr, "done with rpng_win_display_image()\n"))
455
456
457 /* wait for the user to tell us when to quit */
458
459 printf(
460 #ifndef __CYGWIN__
461 "Done. Press Q, Esc or mouse button 1 (within image window) to quit.\n"
462 #else
463 "Done. Press mouse button 1 (within image window) to quit.\n"
464 #endif
465 );
466 fflush(stdout);
467
468 while (GetMessage(&msg, NULL, 0, 0)) {
469 TranslateMessage(&msg);
470 DispatchMessage(&msg);
471 }
472
473
474 /* OK, we're done: clean up all image and Windows resources and go away */
475
476 rpng_win_cleanup();
477
478 return msg.wParam;
479 }
480
481
482
483
484
485 static int rpng_win_create_window(HINSTANCE hInst, int showmode)
486 {
487 uch *dest;
488 int extra_width, extra_height;
489 ulg i, j;
490 WNDCLASSEX wndclass;
491
492
493 /*---------------------------------------------------------------------------
494 Allocate memory for the display-specific version of the image (round up
495 to multiple of 4 for Windows DIB).
496 ---------------------------------------------------------------------------*/
497
498 wimage_rowbytes = ((3*image_width + 3L) >> 2) << 2;
499
500 /* Guard against integer overflow */
501 if (image_height > ((size_t)(-1))/wimage_rowbytes) {
502 fprintf(stderr, PROGNAME ": image_data buffer would be too large\n");
503 return 4; /* fail */
504 }
505
506 if (!(dib = (uch *)malloc(sizeof(BITMAPINFOHEADER) +
507 wimage_rowbytes*image_height)))
508 {
509 return 4; /* fail */
510 }
511
512 /*---------------------------------------------------------------------------
513 Initialize the DIB. Negative height means to use top-down BMP ordering
514 (must be uncompressed, but that's what we want). Bit count of 1, 4 or 8
515 implies a colormap of RGBX quads, but 24-bit BMPs just use B,G,R values
516 directly => wimage_data begins immediately after BMP header.
517 ---------------------------------------------------------------------------*/
518
519 memset(dib, 0, sizeof(BITMAPINFOHEADER));
520 bmih = (BITMAPINFOHEADER *)dib;
521 bmih->biSize = sizeof(BITMAPINFOHEADER);
522 bmih->biWidth = image_width;
523 bmih->biHeight = -((long)image_height);
524 bmih->biPlanes = 1;
525 bmih->biBitCount = 24;
526 bmih->biCompression = 0;
527 wimage_data = dib + sizeof(BITMAPINFOHEADER);
528
529 /*---------------------------------------------------------------------------
530 Fill in background color (black by default); data are in BGR order.
531 ---------------------------------------------------------------------------*/
532
533 for (j = 0; j < image_height; ++j) {
534 dest = wimage_data + j*wimage_rowbytes;
535 for (i = image_width; i > 0; --i) {
536 *dest++ = bg_blue;
537 *dest++ = bg_green;
538 *dest++ = bg_red;
539 }
540 }
541
542 /*---------------------------------------------------------------------------
543 Set the window parameters.
544 ---------------------------------------------------------------------------*/
545
546 memset(&wndclass, 0, sizeof(wndclass));
547
548 wndclass.cbSize = sizeof(wndclass);
549 wndclass.style = CS_HREDRAW | CS_VREDRAW;
550 wndclass.lpfnWndProc = rpng_win_wndproc;
551 wndclass.hInstance = hInst;
552 wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
553 wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
554 wndclass.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
555 wndclass.lpszMenuName = NULL;
556 wndclass.lpszClassName = progname;
557 wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
558
559 RegisterClassEx(&wndclass);
560
561 /*---------------------------------------------------------------------------
562 Finally, create the window.
563 ---------------------------------------------------------------------------*/
564
565 extra_width = 2*(GetSystemMetrics(SM_CXBORDER) +
566 GetSystemMetrics(SM_CXDLGFRAME));
567 extra_height = 2*(GetSystemMetrics(SM_CYBORDER) +
568 GetSystemMetrics(SM_CYDLGFRAME)) +
569 GetSystemMetrics(SM_CYCAPTION);
570
571 global_hwnd = CreateWindow(progname, titlebar, WS_OVERLAPPEDWINDOW,
572 CW_USEDEFAULT, CW_USEDEFAULT, image_width+extra_width,
573 image_height+extra_height, NULL, NULL, hInst, NULL);
574
575 ShowWindow(global_hwnd, showmode);
576 UpdateWindow(global_hwnd);
577
578 return 0;
579
580 } /* end function rpng_win_create_window() */
581
582
583
584
585
586 static int rpng_win_display_image()
587 {
588 uch *src, *dest;
589 uch r, g, b, a;
590 ulg i, row, lastrow;
591 RECT rect;
592
593
594 Trace((stderr, "beginning display loop (image_channels == %d)\n",
595 image_channels))
596 Trace((stderr, "(width = %ld, rowbytes = %ld, wimage_rowbytes = %d)\n",
597 image_width, image_rowbytes, wimage_rowbytes))
598
599
600 /*---------------------------------------------------------------------------
601 Blast image data to buffer. This whole routine takes place before the
602 message loop begins, so there's no real point in any pseudo-progressive
603 display...
604 ---------------------------------------------------------------------------*/
605
606 for (lastrow = row = 0; row < image_height; ++row) {
607 src = image_data + row*image_rowbytes;
608 dest = wimage_data + row*wimage_rowbytes;
609 if (image_channels == 3) {
610 for (i = image_width; i > 0; --i) {
611 r = *src++;
612 g = *src++;
613 b = *src++;
614 *dest++ = b;
615 *dest++ = g; /* note reverse order */
616 *dest++ = r;
617 }
618 } else /* if (image_channels == 4) */ {
619 for (i = image_width; i > 0; --i) {
620 r = *src++;
621 g = *src++;
622 b = *src++;
623 a = *src++;
624 if (a == 255) {
625 *dest++ = b;
626 *dest++ = g;
627 *dest++ = r;
628 } else if (a == 0) {
629 *dest++ = bg_blue;
630 *dest++ = bg_green;
631 *dest++ = bg_red;
632 } else {
633 /* this macro (copied from png.h) composites the
634 * foreground and background values and puts the
635 * result into the first argument; there are no
636 * side effects with the first argument */
637 alpha_composite(*dest++, b, a, bg_blue);
638 alpha_composite(*dest++, g, a, bg_green);
639 alpha_composite(*dest++, r, a, bg_red);
640 }
641 }
642 }
643 /* display after every 16 lines */
644 if (((row+1) & 0xf) == 0) {
645 rect.left = 0L;
646 rect.top = (LONG)lastrow;
647 rect.right = (LONG)image_width; /* possibly off by one? */
648 rect.bottom = (LONG)lastrow + 16L; /* possibly off by one? */
649 InvalidateRect(global_hwnd, &rect, FALSE);
650 UpdateWindow(global_hwnd); /* similar to XFlush() */
651 lastrow = row + 1;
652 }
653 }
654
655 Trace((stderr, "calling final image-flush routine\n"))
656 if (lastrow < image_height) {
657 rect.left = 0L;
658 rect.top = (LONG)lastrow;
659 rect.right = (LONG)image_width; /* possibly off by one? */
660 rect.bottom = (LONG)image_height; /* possibly off by one? */
661 InvalidateRect(global_hwnd, &rect, FALSE);
662 UpdateWindow(global_hwnd); /* similar to XFlush() */
663 }
664
665 /*
666 last param determines whether or not background is wiped before paint
667 InvalidateRect(global_hwnd, NULL, TRUE);
668 UpdateWindow(global_hwnd);
669 */
670
671 return 0;
672 }
673
674
675
676
677
678 static void rpng_win_cleanup()
679 {
680 if (image_data) {
681 free(image_data);
682 image_data = NULL;
683 }
684
685 if (dib) {
686 free(dib);
687 dib = NULL;
688 }
689 }
690
691
692
693
694
695 LRESULT CALLBACK rpng_win_wndproc(HWND hwnd, UINT iMsg, WPARAM wP, LPARAM lP)
696 {
697 HDC hdc;
698 PAINTSTRUCT ps;
699 int rc;
700
701 switch (iMsg) {
702 case WM_CREATE:
703 /* one-time processing here, if any */
704 return 0;
705
706 case WM_PAINT:
707 hdc = BeginPaint(hwnd, &ps);
708 /* dest */
709 rc = StretchDIBits(hdc, 0, 0, image_width, image_height,
710 /* source */
711 0, 0, image_width, image_height,
712 wimage_data, (BITMAPINFO *)bmih,
713 /* iUsage: no clue */
714 0, SRCCOPY);
715 EndPaint(hwnd, &ps);
716 return 0;
717
718 /* wait for the user to tell us when to quit */
719 case WM_CHAR:
720 switch (wP) { /* only need one, so ignore repeat count */
721 case 'q':
722 case 'Q':
723 case 0x1B: /* Esc key */
724 PostQuitMessage(0);
725 }
726 return 0;
727
728 case WM_LBUTTONDOWN: /* another way of quitting */
729 case WM_DESTROY:
730 PostQuitMessage(0);
731 return 0;
732 }
733
734 return DefWindowProc(hwnd, iMsg, wP, lP);
735 }