source: trunk/dll/autoview.c@ 551

Last change on this file since 551 was 551, checked in by Gregg Young, 19 years ago

Indentation cleanup
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.8 KB
Line 
1
2/***********************************************************************
3
4 $Id: autoview.c 551 2007-02-28 01:33:51Z gyoung $
5
6 Auto view
7
8 Copyright (c) 1993-98 M. Kimes
9 Copyright (c) 2001, 2006 Steven H.Levine
10
11 12 Sep 02 SHL AutoObjProc: catch buff2 overflows
12 25 Oct 02 SHL CreateHexDump: catch buffer overflow
13 12 Feb 03 SHL AutoObjProc: standardize EA math
14 23 May 05 SHL Use QWL_USER
15 29 May 06 SHL Sync with archiver.bb2 mods
16 22 Jul 06 SHL Check more run time errors
17 15 Aug 06 SHL Use Runtime_Error more
18 03 Nov 06 SHL Renames
19
20***********************************************************************/
21
22#define INCL_DOS
23#define INCL_WIN
24#define INCL_GPI
25#include <os2.h>
26
27#include <stdlib.h>
28#include <stdio.h>
29#include <string.h>
30#include <ctype.h>
31
32#include "fm3dll.h"
33#include "fm3dlg.h"
34#include "fm3str.h"
35#include "mle.h"
36
37#pragma data_seg(DATA1)
38
39static PSZ pszSrcFile = __FILE__;
40
41#pragma alloc_text(AUTOVIEW,AutoViewProc,CreateHexDump,AutoObjProc)
42#pragma alloc_text(AUTOVIEW2,MakeAutoWinThread,WriteEA,PutComments)
43
44static HWND hwndAutoObj;
45static CHAR stopflag;
46static CHAR currfile[CCHMAXPATH];
47
48BOOL WriteEA(HWND hwnd, CHAR * filename, CHAR * eaname, USHORT type,
49 CHAR * data)
50{
51 /* save an ea to disk */
52
53 FEA2LIST *pfealist = NULL;
54 EAOP2 eaop;
55 APIRET rc;
56 ULONG ealen;
57 USHORT len, *num, *plen, usCodepage;
58 CHAR *p, *eaval;
59 BOOL ret = FALSE;
60
61 if (!filename || !eaname)
62 return ret;
63 usCodepage = (USHORT) WinQueryCp(WinQueryWindowULong(hwnd, QWL_HMQ));
64 len = (data) ? strlen(data) : 0;
65 ealen = sizeof(FEA2LIST) + 24L + strlen(eaname) + 1L + (ULONG) len + 4L;
66 switch (type) {
67 case EAT_EA:
68 case EAT_ASCII:
69 break;
70 case EAT_MVST:
71 if (data) {
72 ealen += sizeof(USHORT) * 5;
73 p = data;
74 while (*p) {
75 if (*p == '\n' && *(p + 1))
76 ealen += sizeof(USHORT);
77 p++;
78 }
79 }
80 break;
81 case EAT_MVMT:
82 if (data) {
83 ealen += sizeof(USHORT) * 5;
84 p = data;
85 while (*p) {
86 if (*p == '\n' && *(p + 1))
87 ealen += (sizeof(USHORT) * 2);
88 p++;
89 }
90 }
91 break;
92 default:
93 return ret;
94 }
95
96 rc = DosAllocMem((PPVOID) & pfealist, ealen, PAG_COMMIT | PAG_READ |
97 PAG_WRITE | OBJ_TILE);
98 if (rc || !pfealist)
99 Dos_Error(MB_CANCEL, rc, hwnd, pszSrcFile, __LINE__,
100 GetPString(IDS_OUTOFMEMORY));
101 else {
102 memset(pfealist, 0, ealen);
103 pfealist->list[0].cbName = strlen(eaname);
104 memcpy(pfealist->list[0].szName, eaname, pfealist->list[0].cbName + 1);
105 eaval = pfealist->list[0].szName + pfealist->list[0].cbName + 1;
106 switch (type) {
107 case EAT_EA:
108 case EAT_ASCII:
109 if (data) {
110 *(USHORT *) eaval = (USHORT) type;
111 eaval += sizeof(USHORT);
112 *(USHORT *) eaval = (USHORT) len;
113 eaval += sizeof(USHORT);
114 memcpy(eaval, data, len);
115 eaval += len;
116 }
117 break;
118 case EAT_MVST:
119 if (data) {
120 *(USHORT *) eaval = (USHORT) EAT_MVST;
121 eaval += sizeof(USHORT);
122 *(USHORT *) eaval = usCodepage;
123 eaval += sizeof(USHORT);
124 num = (USHORT *) eaval;
125 *num = 0;
126 eaval += sizeof(USHORT);
127 *(USHORT *) eaval = (USHORT) EAT_ASCII;
128 eaval += sizeof(USHORT);
129 plen = (USHORT *) eaval;
130 *plen = 0;
131 eaval += sizeof(USHORT);
132 p = data;
133 while (*p) {
134 while (*p) {
135 if (*p == '\n') {
136 p++;
137 break;
138 }
139 *eaval++ = *p++;
140 (*plen)++;
141 }
142 if (*p || *plen)
143 (*num)++;
144 if (*p) {
145 plen = (USHORT *) eaval;
146 *plen = 0;
147 eaval += sizeof(USHORT);
148 }
149 }
150 }
151 break;
152 case EAT_MVMT:
153 if (data) {
154 *(USHORT *) eaval = (USHORT) EAT_MVMT;
155 eaval += sizeof(USHORT);
156 *(USHORT *) eaval = usCodepage;
157 eaval += sizeof(USHORT);
158 num = (USHORT *) eaval;
159 *num = 0;
160 eaval += sizeof(USHORT);
161 *(USHORT *) eaval = (USHORT) EAT_ASCII;
162 eaval += sizeof(USHORT);
163 plen = (USHORT *) eaval;
164 *plen = 0;
165 eaval += sizeof(USHORT);
166 p = data;
167 while (*p) {
168 while (*p) {
169 if (*p == '\n') {
170 p++;
171 break;
172 }
173 *eaval++ = *p++;
174 (*plen)++;
175 }
176 if (*p || *plen)
177 (*num)++;
178 if (*p) {
179 *(USHORT *) eaval = (USHORT) EAT_ASCII;
180 eaval += sizeof(USHORT);
181 plen = (USHORT *) eaval;
182 *plen = 0;
183 eaval += sizeof(USHORT);
184 }
185 }
186 }
187 break;
188 }
189 pfealist->list[0].cbValue = (ULONG) (eaval -
190 (pfealist->list[0].szName +
191 pfealist->list[0].cbName + 1));
192 memset(&eaop, 0, sizeof(eaop));
193 eaop.fpFEA2List = pfealist;
194 pfealist->cbList = 13L + (ULONG) pfealist->list[0].cbName +
195 (ULONG) pfealist->list[0].cbValue;
196 rc = DosSetPathInfo(filename, FIL_QUERYEASIZE, (PVOID) & eaop,
197 (ULONG) sizeof(EAOP2), DSPI_WRTTHRU);
198 DosFreeMem(pfealist);
199 if (!rc)
200 ret = TRUE;
201 }
202 return ret;
203}
204
205BOOL PutComments(HWND hwnd, CHAR * filename, CHAR * comments)
206{
207 register CHAR *p;
208
209 if (comments) { /* check -- is it empty? */
210 p = comments;
211 while (*p && isspace(*p))
212 p++;
213 if (!*p)
214 comments = NULL;
215 }
216 return WriteEA(hwnd, filename, ".COMMENTS", EAT_MVMT, comments);
217}
218
219static PSZ pszBufOvfMsg = "Buffer overflow";
220
221ULONG CreateHexDump(CHAR * pchInBuf, ULONG cbInBuf,
222 CHAR * pchOutBuf, ULONG cbOutBuf,
223 ULONG cOffset, BOOL fLongAddr)
224{
225 register CHAR *pchIn, *pchReset, *pchOut;
226 register ULONG ibIn = 0, ibIn2, ibInFill;
227 ULONG cbOutLine = 6 + (fLongAddr ? 4 : 0) + 16 * 3 + 1 + 16 + 1;
228
229 if (pchInBuf && cbInBuf && pchOutBuf && cbOutBuf) {
230 pchIn = pchInBuf;
231 pchOut = pchOutBuf;
232 if (cOffset)
233 *pchOut++ = '\n';
234 while (ibIn < cbInBuf) {
235 if (pchOut - pchOutBuf + cbOutLine >= cbOutBuf) {
236 Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
237 break;
238 }
239 pchReset = pchIn;
240 ibIn2 = ibIn;
241 if (fLongAddr)
242 sprintf(pchOut, "%08lx ", ibIn + cOffset);
243 else
244 sprintf(pchOut, "%04lx ", ibIn + cOffset);
245 pchOut += 6 + (fLongAddr ? 4 : 0);
246 do {
247 sprintf(pchOut, "%02hx ", *pchIn);
248 pchOut += 3;
249 pchIn++;
250 ibIn++;
251 } while (ibIn < cbInBuf && (ibIn % 16));
252 if (ibIn % 16) {
253 ibInFill = ibIn;
254 while (ibInFill % 16) {
255 *pchOut++ = ' ';
256 *pchOut++ = ' ';
257 *pchOut++ = ' ';
258 ibInFill++;
259 }
260 }
261 *pchOut++ = ' ';
262 pchIn = pchReset;
263 do {
264 if (*pchIn && *pchIn != '\n' && *pchIn != '\r' && *pchIn != '\t'
265 && *pchIn != '\x1a')
266 *pchOut++ = *pchIn++;
267 else {
268 *pchOut++ = '.';
269 pchIn++;
270 }
271 ibIn2++;
272 } while (ibIn2 < ibIn);
273 if (ibIn < cbInBuf)
274 *pchOut++ = '\n';
275 } // while ibIn
276 *pchOut = 0;
277 return (ULONG) (pchOut - pchOutBuf);
278 }
279 return 0L;
280}
281
282MRESULT EXPENTRY AutoObjProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
283{
284 switch (msg) {
285 case UM_LOADFILE:
286 *currfile = 0;
287 stopflag--;
288 if (fAutoView) {
289 WinSetWindowText((fComments) ? hwndAutoMLE : hwndAutoview, "");
290 MLEsetreadonly(hwndAutoMLE, TRUE);
291 MLEsetchanged(hwndAutoMLE, FALSE);
292 }
293 if (mp1) {
294 if (fAutoView) {
295 strcpy(currfile, (CHAR *) mp1);
296 if (!fComments) {
297 if (IsFile((CHAR *) mp1) == 1) {
298
299 HFILE handle;
300 ULONG action, olen, ibufflen, obufflen, l;
301 CHAR *ibuff, *obuff, *p, buffer[80];
302 ARC_TYPE *info;
303
304 if (!DosOpen((CHAR *) mp1,
305 &handle,
306 &action,
307 0L,
308 0L,
309 OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
310 OPEN_FLAGS_FAIL_ON_ERROR | OPEN_FLAGS_NOINHERIT |
311 OPEN_FLAGS_RANDOMSEQUENTIAL | OPEN_SHARE_DENYNONE |
312 OPEN_ACCESS_READONLY, 0L)) {
313 ibufflen = (AutoviewHeight < 96) ? 512 : 3072;
314 ibuff = xmalloc(ibufflen + 2, pszSrcFile, __LINE__);
315 if (ibuff) {
316 // Depends on CreateHexDump line width
317 obufflen = (ibufflen / 16) * (6 + 3 * 16 + 1 + 16 + 1) + 80;
318 obuff = xmalloc(obufflen + 1, pszSrcFile, __LINE__);
319 if (obuff) {
320 *obuff = 0;
321 if (!DosRead(handle,
322 ibuff, ibufflen, &ibufflen) && ibufflen) {
323 ibuff[ibufflen] = 0;
324 p = obuff;
325 if (IsBinary(ibuff, ibufflen)) {
326 olen = ibufflen;
327 // Check archive
328 if (!arcsigsloaded)
329 load_archivers();
330 info = arcsighead;
331 while (info) {
332 if (info->signature && *info->signature) {
333 l = strlen(info->signature);
334 l = min(l, 79);
335 if (!DosChgFilePtr(handle, abs(info->file_offset),
336 (info->file_offset >= 0L) ?
337 FILE_BEGIN :
338 FILE_END, &ibufflen)) {
339 if (!DosRead(handle,
340 buffer,
341 l, &ibufflen) && ibufflen == l) {
342 if (!memcmp(info->signature, buffer, l))
343 break;
344 }
345 }
346 }
347 info = info->next;
348 }
349 if (info) {
350 sprintf(p, "**%s%s%s\n",
351 (info->id) ? info->id : "",
352 (info->id) ? " " : "",
353 GetPString(IDS_ARCHIVETEXT));
354 p += strlen(p);
355 }
356 CreateHexDump(ibuff, // Input buffer
357 olen, // Input buffer size
358 p, // Output buffer
359 obufflen - (p - obuff), // Output buffer size
360 0, // Address offest
361 FALSE); // Short addresses
362 }
363 else {
364 // Text file
365 register CHAR *src, *dest;
366 CHAR *endsrc;
367
368 src = ibuff;
369 dest = obuff;
370 endsrc = ibuff + ibufflen;
371 while (src < endsrc) {
372 if (dest == obuff && (*src == '\t' || *src == ' ' ||
373 *src == '\r' || *src == '\n')) {
374 src++;
375 }
376 else if (*src == '\t' || !*src) {
377 *dest = ' ';
378 dest++;
379 src++;
380 }
381 else if (*src == '\r' || *src == '\n') {
382 *dest = *src;
383 while (*(src + 1) == '\r' || *(src + 1) == '\n' ||
384 *(src + 1) == ' ' || *(src + 1) == '\t')
385 src++;
386 dest++;
387 src++;
388 }
389 else {
390 *dest = *src;
391 src++;
392 dest++;
393 }
394 } // while
395 *dest = 0;
396 if (dest - obuff >= obufflen)
397 Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
398 }
399 if (*obuff)
400 WinSetWindowText(hwndAutoview, obuff);
401 }
402 free(obuff);
403 }
404 free(ibuff);
405 }
406 DosClose(handle);
407 }
408 }
409 else if (!IsFile(currfile)) {
410
411 static FILEFINDBUF4 ffb[130];
412 static char fullname[CCHMAXPATH + 4];
413 HDIR hdir = HDIR_CREATE;
414 ULONG x, nm, ml, mc, bufflen;
415 PBYTE fb;
416 PFILEFINDBUF4 pffbFile;
417 char *buff, *p;
418 APIRET rc;
419
420 sprintf(fullname,
421 "%s%s*",
422 currfile,
423 (currfile[strlen(currfile) - 1] == '\\') ? "" : "\\");
424 DosError(FERR_DISABLEHARDERR);
425 nm = sizeof(ffb) / sizeof(FILEFINDBUF4);
426 if (AutoviewHeight < 96)
427 nm /= 2;
428 rc = DosFindFirst(fullname,
429 &hdir,
430 FILE_NORMAL | FILE_DIRECTORY |
431 FILE_READONLY | FILE_ARCHIVED |
432 FILE_SYSTEM | FILE_HIDDEN,
433 &ffb, sizeof(ffb), &nm, FIL_QUERYEASIZE);
434 if (!rc && nm) {
435 fb = (PBYTE) & ffb;
436 x = ml = 0;
437 while (x < nm) {
438 pffbFile = (PFILEFINDBUF4) fb;
439 mc = (ULONG) pffbFile->cchName +
440 ((pffbFile->attrFile & FILE_DIRECTORY) != 0);
441 ml = max(ml, mc);
442 if (!pffbFile->oNextEntryOffset)
443 break;
444 fb += pffbFile->oNextEntryOffset;
445 x++;
446 }
447 bufflen = (CCHMAXPATHCOMP + 42) * nm;
448 buff = xmalloc(bufflen, pszSrcFile, __LINE__);
449 if (buff) {
450 p = buff;
451 *p = 0;
452 fb = (PBYTE) & ffb;
453 x = 0;
454 while (x < nm) {
455 pffbFile = (PFILEFINDBUF4) fb;
456 if (!(!*pffbFile->achName ||
457 (((pffbFile->attrFile & FILE_DIRECTORY) &&
458 pffbFile->achName[0] == '.') &&
459 (!pffbFile->achName[1] ||
460 (pffbFile->achName[1] == '.' &&
461 !pffbFile->achName[2]))))) {
462 sprintf(p,
463 "%s%-*.*s %-8lu [%s%s%s%s] %04lu/%02lu/%02lu "
464 "%02lu:%02lu:%02lu\r",
465 ((pffbFile->attrFile & FILE_DIRECTORY) != 0) ?
466 "\\" : " ",
467 ml,
468 ml,
469 pffbFile->achName,
470 pffbFile->cbFile +
471 CBLIST_TO_EASIZE(pffbFile->cbList),
472 ((pffbFile->attrFile & FILE_READONLY) != 0) ?
473 "R" : "-",
474 ((pffbFile->attrFile & FILE_ARCHIVED) != 0) ?
475 "A" : "-",
476 ((pffbFile->attrFile & FILE_HIDDEN) != 0) ?
477 "H" : "-",
478 ((pffbFile->attrFile & FILE_SYSTEM) != 0) ?
479 "S" : "-",
480 pffbFile->fdateLastWrite.year + 1980,
481 pffbFile->fdateLastWrite.month,
482 pffbFile->fdateLastWrite.day,
483 pffbFile->ftimeLastWrite.hours,
484 pffbFile->ftimeLastWrite.minutes,
485 pffbFile->ftimeLastWrite.twosecs * 2);
486 p += strlen(p);
487 }
488 if (!pffbFile->oNextEntryOffset)
489 break;
490 fb += pffbFile->oNextEntryOffset;
491 x++;
492 } // while
493 if (p - buff >= bufflen)
494 Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
495 if (*buff)
496 WinSetWindowText(hwndAutoview, buff);
497 free(buff);
498 }
499 }
500 if (!rc)
501 DosFindClose(hdir);
502 }
503 }
504 else {
505
506 APIRET rc;
507 EAOP2 eaop;
508 PGEA2LIST pgealist;
509 PFEA2LIST pfealist;
510 PGEA2 pgea;
511 PFEA2 pfea;
512 CHAR *value, *buff, *p, *data;
513 USHORT len, type, plen, dlen;
514 BOOL readonly = FALSE;
515
516 pgealist = xmallocz(sizeof(GEA2LIST) + 64, pszSrcFile, __LINE__);
517 if (pgealist) {
518 pgea = &pgealist->list[0];
519 strcpy(pgea->szName, ".COMMENTS");
520 pgea->cbName = strlen(pgea->szName);
521 pgea->oNextEntryOffset = 0L;
522 pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
523 pfealist = xmallocz(65536, pszSrcFile, __LINE__);
524 if (pfealist) {
525 pfealist->cbList = 65536;
526 eaop.fpGEA2List = pgealist;
527 eaop.fpFEA2List = pfealist;
528 eaop.oError = 0L;
529 rc = DosQueryPathInfo((CHAR *) mp1, FIL_QUERYEASFROMLIST,
530 (PVOID) & eaop, (ULONG) sizeof(EAOP2));
531 free(pgealist);
532 if (!rc) {
533 pfea = &eaop.fpFEA2List->list[0];
534 if (pfea->cbName && pfea->cbValue) {
535 value = pfea->szName + pfea->cbName + 1;
536 value[pfea->cbValue] = 0;
537 if (*(USHORT *) value == EAT_MVMT) {
538 buff = xmalloc(65536, pszSrcFile, __LINE__);
539 if (buff) {
540 p = buff;
541 *buff = 0;
542 data = value + (sizeof(USHORT) * 3);
543 type = *(USHORT *) data;
544 data += sizeof(USHORT);
545 len = *(USHORT *) data;
546 data += sizeof(USHORT);
547 while ((data - value) - len < pfea->cbValue) {
548 if (type == EAT_ASCII) {
549 dlen = plen = 0;
550 while (dlen < len) {
551 if (data[dlen] == '\r') {
552 dlen++;
553 if (dlen < len && data[dlen] != '\n')
554 p[plen++] = '\n';
555 }
556 else
557 p[plen++] = data[dlen++];
558 }
559 if ((!len || !plen || p[plen - 1] != '\n') &&
560 (data - value) + len < pfea->cbValue)
561 p[plen++] = '\n';
562 p += plen;
563 *p = 0;
564 }
565 else
566 readonly = TRUE;
567 data += len;
568 if (data - value >= pfea->cbValue)
569 break;
570 type = *(USHORT *) data;
571 data += sizeof(USHORT);
572 len = *(USHORT *) data;
573 data += sizeof(USHORT);
574 } // while
575 if (p - buff >= 65536) {
576 Runtime_Error(pszSrcFile, __LINE__, pszBufOvfMsg);
577 buff[65535] = 0; // Try to stay alive
578 break;
579 }
580 WinSetWindowText(hwndAutoMLE, buff);
581 free(buff);
582 }
583 }
584 else
585 readonly = TRUE;
586 }
587 /* else EA not present */
588 MLEsetchanged(hwndAutoMLE, FALSE);
589 MLEsetreadonly(hwndAutoMLE, readonly);
590 }
591 else {
592 MLEsetchanged(hwndAutoMLE, FALSE);
593 MLEsetreadonly(hwndAutoMLE, FALSE);
594 }
595 free(pfealist);
596 }
597 }
598 }
599 }
600 free((CHAR *) mp1);
601 }
602 return 0;
603
604 case UM_CLOSE:
605 if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
606 WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
607 WinDestroyWindow(hwnd);
608 return 0;
609 }
610 return WinDefWindowProc(hwnd, msg, mp1, mp2);
611}
612
613static VOID MakeAutoWinThread(VOID * args)
614{
615 HAB hab2;
616 HMQ hmq2;
617 HWND hwndParent = (HWND) args;
618 QMSG qmsg2;
619
620 hab2 = WinInitialize(0);
621 if (hab2) {
622 hmq2 = WinCreateMsgQueue(hab2, 128);
623 if (hmq2) {
624 DosError(FERR_DISABLEHARDERR);
625 WinRegisterClass(hab2,
626 GetPString(IDS_WCOBJECTWINDOW),
627 AutoObjProc, 0, sizeof(PVOID));
628 hwndAutoObj = WinCreateWindow(HWND_OBJECT,
629 GetPString(IDS_WCOBJECTWINDOW),
630 (PSZ) NULL,
631 0,
632 0L,
633 0L,
634 0L,
635 0L, 0L, HWND_TOP, OBJ_FRAME, NULL, NULL);
636 if (!hwndAutoObj) {
637 Win_Error2(HWND_OBJECT, HWND_DESKTOP, pszSrcFile, __LINE__,
638 IDS_WINCREATEWINDOW);
639 if (!PostMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID))
640 WinSendMsg(hwndParent, UM_CLOSE, MPVOID, MPVOID);
641 }
642 else {
643 WinSetWindowULong(hwndAutoObj, QWL_USER, hwndParent);
644 priority_normal();
645 while (WinGetMsg(hab2, &qmsg2, (HWND) 0, 0, 0))
646 WinDispatchMsg(hab2, &qmsg2);
647 WinDestroyWindow(hwndAutoObj);
648 hwndAutoObj = (HWND) 0;
649 }
650 WinDestroyMsgQueue(hmq2);
651 }
652 else
653 WinTerminate(hab2);
654 }
655}
656
657MRESULT EXPENTRY AutoViewProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
658{
659 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
660
661 switch (msg) {
662 case WM_CREATE:
663 {
664 MRESULT mr;
665
666 if (!hwndAutoObj) {
667 if (_beginthread(MakeAutoWinThread, NULL, 65536, (PVOID) hwnd) == -1) {
668 Runtime_Error(pszSrcFile, __LINE__,
669 GetPString(IDS_COULDNTSTARTTHREADTEXT));
670 PostMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
671 }
672 }
673 mr = PFNWPStatic(hwnd, msg, mp1, mp2);
674 SetPresParams(hwnd,
675 &RGBGREY,
676 &RGBBLACK, &RGBGREY, GetPString(IDS_4SYSTEMVIOTEXT));
677 stopflag = 0;
678 return mr;
679 }
680
681 case UM_SETUP:
682 MLEsetlimit(hwnd, 32768);
683 MLEsetformat(hwnd, MLFIE_NOTRANS);
684 MLEsetchanged(hwnd, FALSE);
685 return 0;
686
687 case WM_BUTTON1DOWN:
688 {
689 SWP swp;
690
691 WinQueryWindowPos(hwnd, &swp);
692 if (SHORT2FROMMP(mp1) > swp.cy - 4) {
693
694 HPS hps = WinGetPS(WinQueryWindow(hwnd, QW_PARENT));
695 SWP swpC;
696 TRACKINFO track;
697
698 if (hps) {
699 WinQueryWindowPos(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
700 FID_CLIENT), &swpC);
701 track.cxBorder = 4;
702 track.cyBorder = 4;
703 track.cxGrid = 1;
704 track.cyGrid = 8;
705 track.cxKeyboard = 8;
706 track.rclTrack.yBottom = swp.y;
707 track.rclTrack.yTop = swp.y + swp.cy;
708 track.rclTrack.xLeft = swp.x;
709 track.rclTrack.xRight = swp.x + swp.cx;
710 track.rclBoundary = track.rclTrack;
711 track.rclBoundary.yTop = (swpC.cy + swp.y + swp.cy) - 116;
712 track.ptlMinTrackSize.x = swp.x + swp.cx;
713 track.ptlMinTrackSize.y = 36;
714 track.ptlMaxTrackSize.x = swp.x + swp.cx;
715 track.ptlMaxTrackSize.y = (swpC.cy + swp.cy) - 116;
716 track.fs = TF_TOP;
717 if (WinTrackRect(hwnd, hps, &track)) {
718 AutoviewHeight = track.rclTrack.yTop - track.rclTrack.yBottom;
719 PrfWriteProfileData(fmprof,
720 FM3Str,
721 "AutoviewHeight",
722 &AutoviewHeight, sizeof(ULONG));
723 WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
724 WM_UPDATEFRAME, MPFROMLONG(FCF_SIZEBORDER), MPVOID);
725 }
726 WinReleasePS(hps);
727 }
728 return (MRESULT) TRUE;
729 }
730 else if (id != MAIN_AUTOVIEWMLE)
731 return CommonTextButton(hwnd, msg, mp1, mp2);
732 }
733 break;
734
735 case WM_BUTTON3DOWN:
736 case WM_BUTTON1UP:
737 case WM_BUTTON3UP:
738 if (id != MAIN_AUTOVIEWMLE)
739 return CommonTextButton(hwnd, msg, mp1, mp2);
740 break;
741
742 case WM_MOUSEMOVE:
743 shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
744 {
745 SWP swp;
746
747 WinQueryWindowPos(hwnd, &swp);
748 if (SHORT2FROMMP(mp1) > swp.cy - 4) {
749 WinSetPointer(HWND_DESKTOP, hptrNS);
750 return (MRESULT) TRUE;
751 }
752 }
753 break;
754
755 case WM_PAINT:
756 PostMsg(hwnd, UM_PAINT, MPVOID, MPVOID);
757 break;
758
759 case UM_PAINT:
760 PaintRecessedWindow(hwnd, (HPS) 0, TRUE, TRUE);
761 return 0;
762
763 case WM_SETFOCUS:
764 switch (id) {
765 case MAIN_AUTOVIEWMLE:
766 if (!mp2 && !AutoMenu) {
767 if (*currfile) {
768 if (MLEgetchanged(hwnd)) {
769 CHAR *ea = xmalloc(32768, pszSrcFile, __LINE__);
770
771 if (ea) {
772 *ea = 0;
773 WinQueryWindowText(hwnd, 32767, ea);
774 PutComments(hwnd, currfile, ea);
775 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_RESCAN, 0), MPVOID);
776 free(ea);
777 }
778 }
779 }
780 }
781 break;
782 default:
783 if (mp2)
784 PostMsg(hwnd, UM_FOCUSME, mp1, mp2);
785 break;
786 }
787 break;
788
789 case UM_FOCUSME:
790 if (mp2) {
791
792 PID pid;
793 TID tid;
794
795 if (WinQueryWindowProcess((HWND) mp1, &pid, &tid) && pid == mypid)
796 WinSetFocus(HWND_DESKTOP, (HWND) mp1);
797 else
798 WinSetFocus(HWND_DESKTOP, hwndTree);
799 }
800 return 0;
801
802 case UM_CLICKED:
803 case UM_CLICKED3:
804 if (id != MAIN_AUTOVIEWMLE) {
805 PostMsg(hwnd,
806 WM_COMMAND,
807 MPFROM2SHORT(((msg == UM_CLICKED3) ?
808 IDM_EAS : IDM_VIEWORARC), 0), MPVOID);
809 }
810 return 0;
811
812 case WM_COMMAND:
813 PostMsg(hwnd, UM_COMMAND, mp1, mp2);
814 return 0;
815
816 case UM_COMMAND:
817 switch (SHORT1FROMMP(mp1)) {
818 case IDM_RESCAN:
819 if (*currfile) {
820
821 CHAR *cf = xstrdup(currfile, pszSrcFile, __LINE__);
822
823 if (cf) {
824 stopflag++;
825 if (!PostMsg(hwndAutoObj, UM_LOADFILE, MPFROMP(cf), MPVOID))
826 free(cf);
827 }
828 }
829 break;
830
831 case IDM_INFO:
832 DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 16, currfile);
833 break;
834
835 case IDM_VIEW:
836 DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 0, currfile);
837 break;
838
839 case IDM_EDIT:
840 DefaultView(hwnd, (HWND) 0, hwndMain, NULL, 8, currfile);
841 break;
842
843 case IDM_EAS:
844 {
845 char *list[2];
846
847 list[0] = currfile;
848 list[1] = NULL;
849
850 WinDlgBox(HWND_DESKTOP,
851 hwndMain,
852 DisplayEAsProc, FM3ModHandle, EA_FRAME, (PVOID) list);
853 }
854 break;
855
856 default:
857 PostMsg(hwndMain, msg, mp1, mp2);
858 }
859 return 0;
860
861 case WM_MENUEND:
862 if ((HWND) mp2 == AutoMenu) {
863 WinDestroyWindow(AutoMenu);
864 AutoMenu = (HWND) 0;
865 }
866 break;
867
868 case WM_CONTEXTMENU:
869 CheckMenu(&AutoMenu, (id == MAIN_AUTOVIEWMLE) ?
870 IDM_AUTOVIEWMLE : IDM_AUTOVIEW);
871 WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWFILE, !fComments);
872 WinCheckMenuItem(AutoMenu, IDM_AUTOVIEWCOMMENTS, fComments);
873 WinEnableMenuItem(AutoMenu, IDM_VIEW, (IsFile(currfile) == 1));
874 WinEnableMenuItem(AutoMenu, IDM_EDIT, (IsFile(currfile) == 1));
875 WinEnableMenuItem(AutoMenu, IDM_INFO, (*currfile != 0));
876 PopupMenu(hwnd, hwnd, AutoMenu);
877 break;
878
879 case UM_LOADFILE:
880 stopflag++;
881 if (!PostMsg(hwndAutoObj, msg, mp1, mp2)) {
882 if (mp1)
883 free((CHAR *) mp1);
884 }
885 return 0;
886
887 case UM_CLOSE:
888 if (AutoMenu) {
889 WinDestroyWindow(AutoMenu);
890 AutoMenu = (HWND) 0;
891 }
892 WinDestroyWindow(hwnd);
893 return 0;
894
895 case WM_CLOSE:
896 WinSendMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
897 return 0;
898
899 case WM_DESTROY:
900 if (id != MAIN_AUTOVIEWMLE) {
901 if (hwndAutoObj)
902 if (!PostMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID))
903 WinSendMsg(hwndAutoObj, WM_CLOSE, MPVOID, MPVOID);
904 break;
905 }
906 break;
907 }
908
909 if (id == MAIN_AUTOVIEWMLE)
910 return PFNWPMLE(hwnd, msg, mp1, mp2);
911 return PFNWPStatic(hwnd, msg, mp1, mp2);
912}
Note: See TracBrowser for help on using the repository browser.