source: trunk/dll/mainwnd2.c @ 672

Last change on this file since 672 was 672, checked in by Steven Levine, 14 years ago

Use dcd->ulItemsToUnHilite
Sync UnHilite? calls with arg mods

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 37.0 KB
Line 
1
2/***********************************************************************
3
4  $Id: mainwnd2.c 672 2007-05-13 05:57:48Z stevenhl $
5
6  fm/4 main window
7
8  Copyright (c) 1993-98 M. Kimes
9  Copyright (c) 2005, 2007 Steven H. Levine
10
11  23 May 05 SHL Use datamin.h
12  26 May 05 SHL Comments and localize code
13  06 Aug 05 SHL Renames
14  02 Jan 06 SHL Use QWL_USER more
15  02 Jan 06 SHL Map IDM_WINDOWDLG to match IBM_TWODIRS
16  17 Jul 06 SHL Use Runtime_Error
17  30 Mar 07 GKY Remove GetPString for window class names
18  12 May 07 SHL Pass ulItemsToUnHilite to UnHilite
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#include <share.h>
32
33#include "fm3dll.h"
34#include "fm3dlg.h"
35#include "fm3str.h"
36#include "tools.h"
37#include "datamin.h"
38
39typedef struct
40{
41  USHORT size;
42  USHORT dummy;
43  HWND hwndDir1;
44  HWND hwndDir2;
45  HWND hwndCurr;
46  HWND hwndLastDir;
47  HWND hwndMax;
48}
49PERSON1DATA;
50
51static PSZ pszSrcFile = __FILE__;
52
53#pragma alloc_text(PERSON11,MainFrameWndProc2,MainWndProc2)
54#pragma alloc_text(PERSON12,StartFM32,MainWMOnce2)
55#pragma alloc_text(PERSON13,MainWMCommand2)
56
57static MRESULT EXPENTRY MainFrameWndProc2(HWND hwnd, ULONG msg, MPARAM mp1,
58                                          MPARAM mp2)
59{
60  PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
61
62  switch (msg) {
63  case WM_ADJUSTWINDOWPOS:
64    {
65      SWP *pswp;
66
67      pswp = (SWP *) mp1;
68      if (pswp->fl & (SWP_SHOW | SWP_RESTORE))
69        PostMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_SIZE, MPVOID, MPVOID);
70      if (fDataMin && !fAmClosing) {
71        if (pswp->fl & (SWP_HIDE | SWP_MINIMIZE)) {
72
73          SWP swp;
74
75          WinQueryWindowPos(hwnd, &swp);
76          PostMsg(hwnd, UM_FOCUSME, MPFROMLONG(swp.fl), MPVOID);
77          HideNote();
78        }
79        else if (pswp->fl & (SWP_SHOW | SWP_RESTORE)) {
80          if (DataHwnd)
81            PostMsg(DataHwnd, WM_CLOSE, MPVOID, MPVOID);
82        }
83      }
84      if (!fAmClosing) {
85        if (pswp->fl & (SWP_HIDE | SWP_MINIMIZE))
86          HideNote();
87      }
88    }
89    break;
90
91  case UM_FOCUSME:
92    CreateDataBar(HWND_DESKTOP, (ULONG) mp1);
93    return 0;
94
95  case WM_BUTTON1UP:
96  case WM_BUTTON2UP:
97  case WM_BUTTON3UP:
98  case WM_MOUSEMOVE:
99  case WM_CHORD:
100    shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
101    break;
102
103  case WM_CHAR:
104    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
105    break;
106
107  case WM_CONTROL:
108    return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), UM_CONTROL, mp1,
109                      mp2);
110
111  case WM_COMMAND:
112    return WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), msg, mp1, mp2);
113
114  case WM_CALCFRAMERECT:
115    {
116      MRESULT mr;
117      PRECTL prectl;
118      LONG sheight = 20, bheight = 20;
119
120      mr = (oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
121        PFNWPFrame(hwnd, msg, mp1, mp2);
122
123      /*
124       * Calculate the position of the client rectangle.
125       * Otherwise,  we'll see a lot of redraw when we move the
126       * client during WM_FORMATFRAME.
127       */
128
129      if (mr && mp2) {
130        prectl = (PRECTL) mp1;
131        if (prectl->yBottom != prectl->yTop) {
132          {
133            HPS hps;
134            POINTL aptl[TXTBOX_COUNT];
135
136            hps = WinGetPS(hwndStatus);
137            GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
138            WinReleasePS(hps);
139            sheight = aptl[TXTBOX_TOPLEFT].y + 6;
140            hps = WinGetPS(hwndName);
141            GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
142            WinReleasePS(hps);
143            bheight = aptl[TXTBOX_TOPLEFT].y + 6;
144          }
145          prectl->yBottom += (sheight + 4);
146          prectl->yTop -= (sheight + 4);
147          prectl->yBottom += (bheight + 4);
148          prectl->yTop -= (bheight + 4);
149          if (fToolbar) {
150            if (!fTextTools)
151              prectl->yTop -= ((fToolTitles) ? 50 : 40);
152            else
153              prectl->yTop -= 32;
154          }
155          ResizeDrives(WinWindowFromID(hwnd, MAIN_DRIVES),
156                       ((prectl->xRight -
157                         (WinQuerySysValue(HWND_DESKTOP,
158                                           SV_CYSIZEBORDER) * 2)) - 4));
159          prectl->yTop -= (16 * (DriveLines * 18));
160          prectl->yTop -= 2;
161          if (fAutoView) {
162            AutoviewHeight = min(AutoviewHeight,
163                                 (prectl->yTop - prectl->yBottom) - 116);
164            AutoviewHeight = max(AutoviewHeight, 36);
165            prectl->yBottom += (AutoviewHeight + 6);
166          }
167        }
168      }
169      return mr;
170    }
171
172  case WM_FORMATFRAME:
173    {
174      SHORT sCount, soldCount;
175      PSWP pswp, pswpClient, pswpNew;
176      SWP swpClient;
177      ULONG theight = 48L, dheight = 20, bheight = 20, sheight = 20;
178      LONG width, lastx;
179
180      sCount = (SHORT) ((oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
181                        PFNWPFrame(hwnd, msg, mp1, mp2));
182      soldCount = sCount;
183      /*
184       * Reformat the frame to "squeeze" the client
185       * and make room for status window sibling beneath
186       * and toolbar above (if toolbar's on) and userlists
187       * (if userlists are on).
188       */
189
190      pswp = (PSWP) mp1;
191      {
192        SHORT x;
193
194        for (x = 0; x < sCount; x++) {
195          if (WinQueryWindowUShort(pswp->hwnd, QWS_ID) == FID_CLIENT) {
196            pswpClient = pswp;
197            break;
198          }
199          pswp++;
200        }
201      }
202
203      {
204        HPS hps;
205        POINTL aptl[TXTBOX_COUNT];
206
207        hps = WinGetPS(hwndStatus);
208        GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
209        WinReleasePS(hps);
210        bheight = sheight = aptl[TXTBOX_TOPLEFT].y + 6;
211        hps = WinGetPS(hwndName);
212        GpiQueryTextBox(hps, 6, "$`WjgT", TXTBOX_COUNT, aptl);
213        WinReleasePS(hps);
214        bheight = aptl[TXTBOX_TOPLEFT].y + 6;
215      }
216
217      pswpNew = (PSWP) mp1 + soldCount;
218      *pswpNew = *pswpClient;
219      swpClient = *pswpClient;
220      pswpNew->hwnd = hwndStatus;
221      pswpNew->x = swpClient.x + 3;
222      pswpNew->y = swpClient.y + 2;
223      width = (swpClient.cx / 2) - 6;
224      width = max(width, 10);
225      pswpNew->cx = width - 6;
226      pswpNew->cy = sheight;
227      pswpClient->y = pswpNew->y + pswpNew->cy + 3;
228      pswpClient->cy = (swpClient.cy - pswpNew->cy) - 3;
229      sCount++;
230
231      pswpNew = (PSWP) mp1 + (soldCount + 1);
232      *pswpNew = *pswpClient;
233      pswpNew->hwnd = hwndStatus2;
234      pswpNew->x = width + 8;
235      pswpNew->y = swpClient.y + 2;
236      pswpNew->cx = width - 6;
237      pswpNew->cy = sheight;
238      sCount++;
239
240      if (fToolbar) {
241        if (fTextTools)
242          theight = 32L;
243        else if (!fToolTitles)
244          theight = 40L;
245        pswpNew = (PSWP) mp1 + (soldCount + 2);
246        *pswpNew = *pswpClient;
247        pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_TOOLS);
248        pswpNew->x = swpClient.x + 2;
249        pswpNew->y = (swpClient.y + swpClient.cy) - (theight - 2);
250        pswpNew->cx = swpClient.cx - 4;
251        pswpNew->cy = theight - 4;
252        pswpClient->cy -= theight;
253        sCount++;
254      }
255      else
256        WinShowWindow(WinWindowFromID(hwnd, MAIN_TOOLS), FALSE);
257
258      ResizeDrives(WinWindowFromID(hwnd, MAIN_DRIVES), pswpClient->cx - 4);
259      pswpNew = (PSWP) mp1 + (soldCount + 2 + (fToolbar != FALSE));
260      *pswpNew = *pswpClient;
261      pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_DRIVES);
262      pswpNew->x = swpClient.x + 2;
263      dheight += ((dheight - 2) * DriveLines);
264      pswpNew->y = (swpClient.y + swpClient.cy) - (dheight - 2);
265      if (fToolbar)
266        pswpNew->y -= theight;
267      pswpNew->cx = swpClient.cx - 4;
268      pswpNew->cy = dheight - 4;
269      pswpClient->cy -= dheight;
270      pswpClient->cy -= 2;
271      sCount++;
272
273      if (fAutoView) {
274        pswpNew = (PSWP) mp1 + (soldCount + 3 + (fToolbar != FALSE));
275        *pswpNew = *pswpClient;
276        pswpNew->hwnd = (fComments) ? hwndAutoMLE : hwndAutoview;
277        pswpNew->x = pswpClient->x + 3;
278        pswpNew->y = pswpClient->y + 3;
279        if (fMoreButtons)
280          pswpNew->y += (bheight + 4);
281        pswpNew->cx = pswpClient->cx - 6;
282        AutoviewHeight = min(AutoviewHeight, pswpClient->cy - 116);
283        AutoviewHeight = max(AutoviewHeight, 36);
284        pswpNew->cy = AutoviewHeight;
285        pswpClient->y += (AutoviewHeight + 6);
286        pswpClient->cy -= (AutoviewHeight + 6);
287        sCount++;
288        WinShowWindow((fComments) ? hwndAutoview : hwndAutoMLE, FALSE);
289      }
290      else {
291        WinShowWindow(hwndAutoview, FALSE);
292        WinShowWindow(hwndAutoMLE, FALSE);
293      }
294
295      pswpNew = (PSWP) mp1 + (soldCount + 3 + (fToolbar != FALSE) +
296                              (fAutoView != FALSE));
297      *pswpNew = *pswpClient;
298      pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_LED);
299      pswpNew->x = (swpClient.x + swpClient.cx) - 12;
300      pswpNew->y = swpClient.y;
301      pswpNew->cx = 12;
302      pswpNew->cy = 12;
303      sCount++;
304
305      pswpNew = (PSWP) mp1 + (soldCount + 4 + (fToolbar != FALSE) +
306                              (fAutoView != FALSE));
307      *pswpNew = *pswpClient;
308      pswpNew->hwnd = WinWindowFromID(hwnd, MAIN_LEDHDR);
309      pswpNew->x = (swpClient.x + swpClient.cx) - 12;
310      pswpNew->y = swpClient.y + 12;
311      pswpNew->cx = 12;
312      pswpNew->cy = sheight - 8;
313      sCount++;
314
315      pswpNew = (PSWP) mp1 + (soldCount + 5 + (fToolbar != FALSE) +
316                              (fAutoView != FALSE));
317      *pswpNew = *pswpClient;
318      pswpNew->hwnd = hwndName;
319      pswpNew->x = swpClient.x + 3;
320      pswpNew->y = swpClient.y + (sheight + 6);
321      pswpNew->cx = ((swpClient.cx / 2) + (swpClient.cx / 5)) - 3;
322      lastx = pswpNew->x + pswpNew->cx;
323      pswpNew->cy = bheight;
324      pswpClient->y += (bheight + 4);
325      pswpClient->cy -= (bheight + 4);
326      sCount++;
327
328      pswpNew = (PSWP) mp1 + (soldCount + 6 + (fToolbar != FALSE) +
329                              (fAutoView != FALSE));
330      *pswpNew = *pswpClient;
331      pswpNew->hwnd = hwndDate;
332      pswpNew->x = lastx + 3;
333      pswpNew->y = swpClient.y + (sheight + 6);
334      pswpNew->cx = (swpClient.cx / 6) + (swpClient.cx / 16) - 3;
335      lastx = pswpNew->x + pswpNew->cx;
336      pswpNew->cy = bheight;
337      sCount++;
338
339      pswpNew = (PSWP) mp1 + (soldCount + 7 + (fToolbar != FALSE) +
340                              (fAutoView != FALSE));
341      *pswpNew = *pswpClient;
342      pswpNew->hwnd = hwndAttr;
343      pswpNew->x = lastx + 3;
344      pswpNew->y = swpClient.y + (sheight + 6);
345      pswpNew->cx = (swpClient.cx - pswpNew->x) - 1;
346      pswpNew->cy = bheight;
347      sCount++;
348
349      return MRFROMSHORT(sCount);
350    }
351
352  case WM_QUERYFRAMECTLCOUNT:
353    {
354      SHORT sCount;
355
356      sCount = (SHORT) ((oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
357                        PFNWPFrame(hwnd, msg, mp1, mp2));
358      sCount += 8;
359      if (fToolbar)
360        sCount++;
361      if (fAutoView)
362        sCount++;
363      return MRFROMSHORT(sCount);
364    }
365
366  case WM_CLOSE:
367    WinSendMsg(WinWindowFromID(hwnd, FID_CLIENT), msg, mp1, mp2);
368    return 0;
369  }
370  return (oldproc) ? oldproc(hwnd, msg, mp1, mp2) :
371    PFNWPFrame(hwnd, msg, mp1, mp2);
372}
373
374static MRESULT EXPENTRY MainWMCommand2(HWND hwnd, ULONG msg, MPARAM mp1,
375                                       MPARAM mp2)
376{
377  PERSON1DATA *pd;
378
379  SetShiftState();
380  switch (SHORT1FROMMP(mp1)) {
381  case IDM_TOAUTOMLE:
382  case IDM_CLI:
383  case IDM_CREATETOOL:
384  case IDM_ABOUT:
385  case IDM_WINFULLSCREEN:
386  case IDM_DOSCOMMANDLINE:
387  case IDM_INIVIEWER:
388  case IDM_EDITASSOC:
389  case IDM_COMMANDLINE:
390  case IDM_KILLPROC:
391  case IDM_TOOLBAR:
392  case IDM_TEXTTOOLS:
393  case IDM_TOOLTITLES:
394  case IDM_TOOLLEFT:
395  case IDM_TOOLRIGHT:
396  case IDM_AUTOVIEWCOMMENTS:
397  case IDM_AUTOVIEWFILE:
398  case IDM_AUTOVIEW:
399//    case IDM_SYSINFO:
400  case IDM_HIDENOTEWND:
401  case IDM_SHOWNOTEWND:
402  case IDM_INSTANT:
403  case IDM_HELPCONTEXT:
404  case IDM_HELPHINTS:
405  case IDM_HELPPIX:
406  case IDM_KILLME:
407  case IDM_EXIT:
408  case IDM_HELPTUTOR:
409  case IDM_HELPCONTENTS:
410  case IDM_HELPGENERAL:
411  case IDM_HELPKEYS:
412  case IDM_HELPMOUSE:
413  case IDM_HELP:
414    return MainWMCommand(hwnd, msg, mp1, mp2);
415
416  case IDM_REMAP:
417    WinDlgBox(HWND_DESKTOP,
418              hwnd, RemapDlgProc, FM3ModHandle, MAP_FRAME, NULL);
419    break;
420
421  case IDM_TWODIRS:                     // Menu action
422  case IDM_WINDOWDLG:                   // Toolbar action
423    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
424    if (pd) {
425
426      WALK2 wa;
427
428      memset(&wa, 0, sizeof(wa));
429      wa.size = sizeof(wa);
430      *wa.szCurrentPath1 = 0;
431      WinSendMsg(pd->hwndDir1,
432                 UM_CONTAINERDIR, MPFROMP(wa.szCurrentPath1), MPVOID);
433      MakeValidDir(wa.szCurrentPath1);
434      *wa.szCurrentPath2 = 0;
435      WinSendMsg(pd->hwndDir2,
436                 UM_CONTAINERDIR, MPFROMP(wa.szCurrentPath2), MPVOID);
437      MakeValidDir(wa.szCurrentPath2);
438      if (WinDlgBox(HWND_DESKTOP,
439                    hwnd,
440                    WalkTwoSetDlgProc,
441                    FM3ModHandle,
442                    WALK2_FRAME,
443                    MPFROMP(&wa)) &&
444          (IsRoot(wa.szCurrentPath1) ||
445           !IsFile(wa.szCurrentPath1)) &&
446          (IsRoot(wa.szCurrentPath2) || !IsFile(wa.szCurrentPath2))) {
447        WinSendMsg(WinWindowFromID(WinWindowFromID(pd->hwndDir1,
448                                                   FID_CLIENT), DIR_CNR),
449                   UM_SETDIR, MPFROMP(wa.szCurrentPath1), MPVOID);
450        WinSendMsg(WinWindowFromID(WinWindowFromID(pd->hwndDir2,
451                                                   FID_CLIENT), DIR_CNR),
452                   UM_SETDIR, MPFROMP(wa.szCurrentPath2), MPVOID);
453      }
454    }
455    break;
456
457  case IDM_COMPARE:
458    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
459    if (pd) {
460
461      WALK2 wa;
462
463      memset(&wa, 0, sizeof(wa));
464      wa.size = sizeof(wa);
465      *wa.szCurrentPath1 = 0;
466      WinSendMsg(pd->hwndDir1,
467                 UM_CONTAINERDIR, MPFROMP(wa.szCurrentPath1), MPVOID);
468      MakeValidDir(wa.szCurrentPath1);
469      *wa.szCurrentPath2 = 0;
470      WinSendMsg(pd->hwndDir2,
471                 UM_CONTAINERDIR, MPFROMP(wa.szCurrentPath2), MPVOID);
472      MakeValidDir(wa.szCurrentPath2);
473      if (WinDlgBox(HWND_DESKTOP,
474                    hwnd,
475                    WalkTwoCmpDlgProc,
476                    FM3ModHandle,
477                    WALK2_FRAME,
478                    MPFROMP(&wa)) &&
479          (IsRoot(wa.szCurrentPath1) ||
480           !IsFile(wa.szCurrentPath1)) &&
481          (IsRoot(wa.szCurrentPath2) || !IsFile(wa.szCurrentPath2))) {
482        if (!*dircompare) {
483
484          COMPARE *cmp;
485
486          cmp = xmallocz(sizeof(COMPARE), pszSrcFile, __LINE__);
487          if (cmp) {
488            cmp->size = sizeof(COMPARE);
489            strcpy(cmp->leftdir, wa.szCurrentPath1);
490            strcpy(cmp->rightdir, wa.szCurrentPath2);
491            cmp->hwndParent = hwnd;
492            cmp->dcd.hwndParent = hwnd;
493            WinDlgBox(HWND_DESKTOP,
494                      HWND_DESKTOP,
495                      CompareDlgProc, FM3ModHandle, COMP_FRAME, MPFROMP(cmp));
496          }
497        }
498        else {
499
500          CHAR *d1 = "\"", *d2 = "\"";
501
502          if (!needs_quoting(wa.szCurrentPath1))
503            *d1 = 0;
504          if (!needs_quoting(wa.szCurrentPath2))
505            *d2 = 0;
506          runemf2(SEPARATE,
507                  HWND_DESKTOP,
508                  NULL,
509                  NULL,
510                  "%s %s%s%s %s%s%s",
511                  dircompare,
512                  d1, wa.szCurrentPath1, d1, d2, wa.szCurrentPath2, d2);
513        }
514      }
515    }
516    break;
517
518  case IDM_VTREE:
519    WinSendMsg(hwnd, UM_SETUP2, MPFROMLONG(1), MPVOID);
520    if (hwndTree) {
521      WinShowWindow(hwndTree, FALSE);
522      PostMsg(hwndTree, WM_CLOSE, MPVOID, MPVOID);
523      hwndTree = (HWND) 0;
524    }
525    else {
526
527      ULONG size = sizeof(ULONG);
528
529      hwndTree = StartTreeCnr(hwnd, 3);
530      PrfQueryProfileData(fmprof,
531                          realappname,
532                          "FM/4 TreeWidth", (PVOID) & TreeWidth, &size);
533      TreeWidth = max(TreeWidth, 80);
534    }
535    {
536      BOOL dummy = (hwndTree != (HWND) 0);
537
538      PrfWriteProfileData(fmprof,
539                          realappname,
540                          "FM/4 TreeUp", (PVOID) & dummy, sizeof(dummy));
541    }
542    PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
543    break;
544
545  case IDM_TILEBACKWARDS:
546    WinSendMsg(hwnd, UM_SETUP2, MPFROMLONG(1), MPVOID);
547    fTileBackwards = (fTileBackwards) ? FALSE : TRUE;
548    PrfWriteProfileData(fmprof,
549                        FM3Str,
550                        "TileBackwards",
551                        (PVOID) & fTileBackwards, sizeof(BOOL));
552    PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
553    break;
554
555  case IDM_NEXTWINDOW:
556  case IDM_PREVWINDOW:
557    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
558    if (pd) {
559
560      HWND hwndFocus;
561
562      if (hwndTree) {
563        if (pd->hwndMax) {
564          if (hwndTree == pd->hwndCurr)
565            hwndFocus = pd->hwndMax;
566          else
567            hwndFocus = hwndTree;
568        }
569        else {
570          if (hwndTree == pd->hwndCurr)
571            hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
572              pd->hwndDir1 : pd->hwndDir2;
573          else if (pd->hwndDir1 == pd->hwndCurr)
574            hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
575              pd->hwndDir2 : hwndTree;
576          else
577            hwndFocus = (SHORT1FROMMP(mp1) == IDM_PREVWINDOW) ?
578              hwndTree : pd->hwndDir1;
579        }
580      }
581      else {
582        if (pd->hwndMax)
583          hwndFocus = pd->hwndMax;
584        else
585          hwndFocus = (pd->hwndCurr == pd->hwndDir1) ?
586            pd->hwndDir2 : pd->hwndDir1;
587      }
588      WinSetFocus(HWND_DESKTOP, hwndFocus);
589    }
590    break;
591
592  case IDM_NOTEBOOK:
593    WinDlgBox(HWND_DESKTOP,
594              hwnd,
595              CfgDlgProc, FM3ModHandle, CFG_FRAME, MPFROMP(realappname));
596    PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
597    break;
598
599  case IDM_SEEALL:
600  case IDM_GREP:
601  case IDM_COLLECTOR:
602    {
603      HWND hwndC;
604
605      hwndC = StartCollector(HWND_DESKTOP, 4);
606      if (hwndC) {
607        WinSetWindowPos(hwndC,
608                        HWND_TOP,
609                        0, 0, 0, 0, SWP_SHOW | SWP_RESTORE | SWP_ACTIVATE);
610        if (SHORT1FROMMP(mp1) == IDM_GREP)
611          PostMsg(WinWindowFromID(hwndC, FID_CLIENT),
612                  WM_COMMAND, MPFROM2SHORT(IDM_GREP, 0), MPVOID);
613        if (SHORT1FROMMP(mp1) == IDM_SEEALL)
614          PostMsg(WinWindowFromID(hwndC, FID_CLIENT),
615                  WM_COMMAND, MPFROM2SHORT(IDM_SEEALL, 0), MPVOID);
616      }
617    }
618    break;
619
620  case IDM_EDITCOMMANDS:
621    EditCommands(hwnd);
622    break;
623
624  default:
625    if (SHORT1FROMMP(mp1) >= IDM_SWITCHSTART &&
626        SHORT1FROMMP(mp1) < IDM_SWITCHSTART + 499) {
627      if (SHORT1FROMMP(mp1) - IDM_SWITCHSTART < numswitches)
628        WinSwitchToProgram(switches[SHORT1FROMMP(mp1) - IDM_SWITCHSTART]);
629      break;
630    }
631    else if (SHORT1FROMMP(mp1) >= IDM_COMMANDSTART &&
632             SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART) {
633
634      INT x;
635      HWND hwndCnr;
636
637      if (!cmdloaded)
638        load_commands();
639      hwndCnr = TopWindow(hwnd, (HWND) 0);
640      hwndCnr = (HWND) WinSendMsg(WinWindowFromID(hwndCnr, FID_CLIENT),
641                                  UM_CONTAINERHWND, MPVOID, MPVOID);
642      if (!hwndCnr) {
643        Runtime_Error2(pszSrcFile, __LINE__, IDS_NOWINDOWTEXT);
644        break;
645      }
646      x = SHORT1FROMMP(mp1) - IDM_COMMANDSTART;
647      if (x >= 0) {
648        x++;
649        RunCommand(hwndCnr, x);
650        if (fUnHilite) {
651
652          PCNRITEM pci;
653          DIRCNRDATA *dcd = NULL;
654
655          if (WinQueryWindowUShort(hwndCnr, QWS_ID) != TREE_CNR)
656            dcd = INSTDATA(hwndCnr);
657          pci = (PCNRITEM) WinSendMsg(hwndCnr,
658                                      CM_QUERYRECORDEMPHASIS,
659                                      MPFROMLONG(CMA_FIRST),
660                                      MPFROMSHORT(CRA_CURSORED));
661          if (pci && (INT) pci != -1 && (pci->rc.flRecordAttr & CRA_SELECTED)) {
662            UnHilite(hwnd,
663                     TRUE,
664                     dcd ? &dcd->lastselection : NULL,
665                     dcd ? dcd->ulItemsToUnHilite : 0);
666          }
667        }
668      }
669    }
670    else if (SHORT1FROMMP(mp1) >= IDM_QUICKTOOLSTART &&
671             SHORT1FROMMP(mp1) < IDM_QUICKTOOLSTART + 50) {
672      if (!qtloaded)
673        load_quicktools();
674      if (quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART]) {
675        if (fToolsChanged)
676          save_tools(NULL);
677        if (!load_tools(quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART]))
678          load_tools(NULL);
679        else {
680          strcpy(lasttoolbox,
681                 quicktool[SHORT1FROMMP(mp1) - IDM_QUICKTOOLSTART]);
682          PrfWriteProfileString(fmprof, FM3Str, "LastToolBox", lasttoolbox);
683        }
684        BuildTools(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
685                                   MAIN_TOOLS), TRUE);
686      }
687    }
688    else {
689
690      HWND hwndActive;
691
692      hwndActive = TopWindow(hwnd, (HWND) 0);
693      if (hwndActive)
694        PostMsg(WinWindowFromID(hwndActive, FID_CLIENT), msg, mp1, mp2);
695    }
696    break;
697  }
698  return 0;
699}
700
701static MRESULT EXPENTRY MainWMOnce2(HWND hwnd, ULONG msg, MPARAM mp1,
702                                    MPARAM mp2)
703{
704  PERSON1DATA *pd;
705
706  switch (msg) {
707  case WM_CREATE:
708    {
709      TID tid;
710
711      WinQueryWindowProcess(hwnd, &mypid, &tid);
712    }
713    hwndMain = hwnd;
714    WinSetWindowUShort(hwnd, QWL_USER + 8, 0);
715    WinSetWindowUShort(hwnd, QWL_USER + 10, 0);
716    WinSetWindowUShort(hwnd, QWL_USER + 12, 0);
717    WinSetWindowUShort(hwnd, QWL_USER + 16, 0);
718    if (_beginthread(MakeMainObjWin, NULL, 245760, MPVOID) == -1) {
719      Runtime_Error(pszSrcFile, __LINE__,
720                    GetPString(IDS_COULDNTSTARTTHREADTEXT));
721      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
722      return 0;
723    }
724    else
725      DosSleep(64);
726
727    pd = xmallocz(sizeof(PERSON1DATA), pszSrcFile, __LINE__);
728    if (!pd)
729      WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
730    else {
731      pd->size = sizeof(PERSON1DATA);
732      WinSetWindowPtr(hwnd, QWL_USER + 4, (PVOID) pd);
733    }
734    {
735      SWP swp;
736      PFNWP oldproc;
737
738      /*
739       * create frame children (not client children, frame children)
740       */
741      DosSleep(1L);
742      WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
743      oldproc = WinSubclassWindow(WinQueryWindow(hwnd, QW_PARENT),
744                                  (PFNWP) MainFrameWndProc2);
745      if (oldproc)
746        WinSetWindowPtr(WinQueryWindow(hwnd, QW_PARENT), QWL_USER, (PVOID) oldproc);
747      CommonCreateMainChildren(hwnd, &swp);
748
749      {
750        HWND hwndMenu;
751
752        hwndMenu = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_MENU);
753        WinSetWindowULong(hwnd, 0, hwndMenu);
754        SetConditionalCascade(hwndMenu, IDM_COMMANDSMENU, IDM_DOITYOURSELF);
755        SetConditionalCascade(hwndMenu, IDM_TOOLSUBMENU, IDM_TOOLBAR);
756      }
757    }
758    WinSetWindowText(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
759                                     FID_TITLEBAR), "FM/2 Lite");
760    FixSwitchList(WinQueryWindow(hwnd, QW_PARENT), NULL);
761    SetSysMenu(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT), FID_SYSMENU));
762    break;
763
764  case UM_SETUP:
765    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
766    if (pd) {
767
768      CHAR s[CCHMAXPATH];
769      ULONG size;
770      DIRCNRDATA *dcd;
771      HWND hwndC;
772      BOOL dummy = TRUE;
773
774      size = sizeof(BOOL);
775      PrfQueryProfileData(fmprof,
776                          realappname, "FM/4 TreeUp", (PVOID) & dummy, &size);
777      if (dummy) {
778        size = sizeof(ULONG);
779        hwndTree = StartTreeCnr(hwnd, 3);
780        PrfQueryProfileData(fmprof,
781                            realappname,
782                            "FM/4 TreeWidth", (PVOID) & TreeWidth, &size);
783        TreeWidth = max(TreeWidth, 80);
784      }
785      size = sizeof(BOOL);
786      if (PrfQueryProfileData(fmprof,
787                              FM3Str,
788                              "Toolbar", &dummy, &size) && size && !dummy)
789        WinSendMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_TOOLBAR, 0), MPVOID);
790
791      size = sizeof(s);
792      *s = 0;
793      if (PrfQueryProfileData(fmprof,
794                              realappname, "FM/4 Dir1", s, &size) && *s)
795        MakeValidDir(s);
796      else
797        save_dir(s);
798      pd->hwndLastDir = pd->hwndCurr = pd->hwndDir1 =
799        StartDirCnr(hwnd, s, (HWND) 0, 3);
800      size = sizeof(s);
801      *s = 0;
802      if (PrfQueryProfileData(fmprof,
803                              realappname, "FM/4 Dir2", s, &size) && *s)
804        MakeValidDir(s);
805      else
806        save_dir(s);
807      pd->hwndDir2 = StartDirCnr(hwnd, s, (HWND) 0, 3);
808      WinSetFocus(HWND_DESKTOP, pd->hwndCurr);
809
810      hwndC = WinWindowFromID(pd->hwndDir1, FID_CLIENT);
811      if (hwndC) {
812        dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), QWL_USER);
813        if (dcd) {
814          size = sizeof(INT);
815          if (PrfQueryProfileData(fmprof,
816                                  realappname,
817                                  "FM/4 Dir1.Sort",
818                                  (PVOID) & dcd->sortFlags,
819                                  &size) && size == sizeof(INT)) {
820            if (!dcd->sortFlags)
821              dcd->sortFlags = SORT_PATHNAME;
822          }
823          size = sizeof(MASK);
824          if (PrfQueryProfileData(fmprof,
825                                  realappname,
826                                  "FM/4 Dir1.Filter",
827                                  (PVOID) & dcd->mask, &size) && size) {
828            if (*dcd->mask.szMask)
829              WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
830                         UM_FILTER, MPFROMP(dcd->mask.szMask), MPVOID);
831          }
832          *(dcd->mask.prompt) = 0;
833          size = sizeof(ULONG);
834          if (PrfQueryProfileData(fmprof,
835                                  realappname,
836                                  "FM/4 Dir1.View",
837                                  (PVOID) & dcd->flWindowAttr,
838                                  &size) && size == sizeof(ULONG)) {
839
840            CNRINFO cnri;
841
842            memset(&cnri, 0, sizeof(CNRINFO));
843            cnri.cb = sizeof(CNRINFO);
844            if (WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
845                           CM_QUERYCNRINFO,
846                           MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
847              cnri.flWindowAttr = dcd->flWindowAttr;
848              WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
849                         CM_SETCNRINFO,
850                         MPFROMP(&cnri), MPFROMLONG(CMA_FLWINDOWATTR));
851            }
852          }
853        }
854      }
855
856      hwndC = WinWindowFromID(pd->hwndDir2, FID_CLIENT);
857      if (hwndC) {
858        dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), QWL_USER);
859        if (dcd) {
860          size = sizeof(INT);
861          if (PrfQueryProfileData(fmprof,
862                                  realappname,
863                                  "FM/4 Dir2.Sort",
864                                  (PVOID) & dcd->sortFlags,
865                                  &size) && size == sizeof(INT)) {
866            if (!dcd->sortFlags)
867              dcd->sortFlags = SORT_PATHNAME;
868          }
869          size = sizeof(MASK);
870          if (PrfQueryProfileData(fmprof,
871                                  realappname,
872                                  "FM/4 Dir2.Filter",
873                                  (PVOID) & dcd->mask, &size) && size) {
874            if (*dcd->mask.szMask)
875              WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
876                         UM_FILTER, MPFROMP(dcd->mask.szMask), MPVOID);
877          }
878          *(dcd->mask.prompt) = 0;
879          size = sizeof(ULONG);
880          if (PrfQueryProfileData(fmprof,
881                                  realappname,
882                                  "FM/4 Dir2.View",
883                                  (PVOID) & dcd->flWindowAttr,
884                                  &size) && size == sizeof(ULONG)) {
885
886            CNRINFO cnri;
887
888            memset(&cnri, 0, sizeof(CNRINFO));
889            cnri.cb = sizeof(CNRINFO);
890            if (WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
891                           CM_QUERYCNRINFO,
892                           MPFROMP(&cnri), MPFROMLONG(sizeof(CNRINFO)))) {
893              cnri.flWindowAttr = dcd->flWindowAttr;
894              WinSendMsg(WinWindowFromID(hwndC, DIR_CNR),
895                         CM_SETCNRINFO,
896                         MPFROMP(&cnri), MPFROMLONG(CMA_FLWINDOWATTR));
897            }
898          }
899        }
900      }
901    }
902    {
903      ULONG which = 0, size = sizeof(ULONG);
904
905      if (PrfQueryProfileData(fmprof,
906                              realappname,
907                              "FM/4 Max",
908                              (PVOID) & which,
909                              &size) && size == sizeof(ULONG) && which) {
910        PostMsg(hwnd,
911                UM_MAXIMIZE,
912                MPFROMLONG(((which == 1) ?
913                            pd->hwndDir1 : pd->hwndDir2)), MPVOID);
914      }
915    }
916    PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
917    if (!hwndTree)
918      PostMsg(hwnd, UM_BUILDDRIVEBAR, MPVOID, MPVOID);
919    load_tools(NULL);
920    BuildTools(WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
921                               MAIN_TOOLS), TRUE);
922    fRunning = TRUE;
923    return 0;
924
925  case WM_SAVEAPPLICATION:
926    WinStoreWindowPos(FM2Str,
927                      "MainWindowPos2", WinQueryWindow(hwnd, QW_PARENT));
928    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
929    if (pd) {
930
931      CHAR s[CCHMAXPATH];
932      HWND hwndC;
933      DIRCNRDATA *dcd;
934      ULONG flWindowAttr;
935
936      *s = 0;
937      WinSendMsg(pd->hwndDir1, UM_CONTAINERDIR, MPFROMP(s), MPVOID);
938      if (*s) {
939        MakeValidDir(s);
940        PrfWriteProfileString(fmprof, realappname, "FM/4 Dir1", s);
941      }
942      *s = 0;
943      WinSendMsg(pd->hwndDir2, UM_CONTAINERDIR, MPFROMP(s), MPVOID);
944      if (*s) {
945        MakeValidDir(s);
946        PrfWriteProfileString(fmprof, realappname, "FM/4 Dir2", s);
947      }
948      flWindowAttr = (pd->hwndMax == pd->hwndDir1) ?
949        1 : (pd->hwndMax == pd->hwndDir2) ? 2 : 0;
950      PrfWriteProfileData(fmprof,
951                          realappname,
952                          "FM/4 Max", &flWindowAttr, sizeof(flWindowAttr));
953      hwndC = WinWindowFromID(pd->hwndDir1, FID_CLIENT);
954      if (hwndC) {
955        dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), QWL_USER);
956        if (dcd) {
957          flWindowAttr = dcd->flWindowAttr;
958          if (!fLeaveTree && (flWindowAttr & CV_TREE)) {
959            flWindowAttr &= (~(CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
960            if (dcd->lastattr) {
961              if (dcd->lastattr & CV_TEXT)
962                flWindowAttr |= CV_TEXT;
963              else if (dcd->lastattr & CV_DETAIL)
964                flWindowAttr |= CV_DETAIL;
965              else if (dcd->lastattr & CV_ICON)
966                flWindowAttr |= CV_ICON;
967              else
968                flWindowAttr |= CV_NAME;
969            }
970            else
971              flWindowAttr |= CV_NAME;
972          }
973          PrfWriteProfileData(fmprof,
974                              realappname,
975                              "FM/4 Dir1.Sort",
976                              (PVOID) & dcd->sortFlags, sizeof(INT));
977          PrfWriteProfileData(fmprof,
978                              realappname,
979                              "FM/4 Dir1.Filter",
980                              (PVOID) & dcd->mask, sizeof(MASK));
981          PrfWriteProfileData(fmprof,
982                              realappname,
983                              "FM/4 Dir1.View",
984                              (PVOID) & flWindowAttr, sizeof(ULONG));
985        }
986      }
987
988      hwndC = WinWindowFromID(pd->hwndDir2, FID_CLIENT);
989      if (hwndC) {
990        dcd = WinQueryWindowPtr(WinWindowFromID(hwndC, DIR_CNR), QWL_USER);
991        if (dcd) {
992          flWindowAttr = dcd->flWindowAttr;
993          if (!fLeaveTree && (flWindowAttr & CV_TREE)) {
994            flWindowAttr &= (~(CV_TREE | CV_ICON | CV_DETAIL | CV_TEXT));
995            if (dcd->lastattr) {
996              if (dcd->lastattr & CV_TEXT)
997                flWindowAttr |= CV_TEXT;
998              else if (dcd->lastattr & CV_DETAIL)
999                flWindowAttr |= CV_DETAIL;
1000              else if (dcd->lastattr & CV_ICON)
1001                flWindowAttr |= CV_ICON;
1002              else
1003                flWindowAttr |= CV_NAME;
1004            }
1005            else
1006              flWindowAttr |= CV_NAME;
1007          }
1008          PrfWriteProfileData(fmprof,
1009                              realappname,
1010                              "FM/4 Dir2.Sort",
1011                              (PVOID) & dcd->sortFlags, sizeof(INT));
1012          PrfWriteProfileData(fmprof,
1013                              realappname,
1014                              "FM/4 Dir2.Filter",
1015                              (PVOID) & dcd->mask, sizeof(MASK));
1016          PrfWriteProfileData(fmprof,
1017                              realappname,
1018                              "FM/4 Dir2.View",
1019                              (PVOID) & flWindowAttr, sizeof(ULONG));
1020        }
1021      }
1022    }
1023    break;
1024  }
1025  return WinDefWindowProc(hwnd, msg, mp1, mp2);
1026}
1027
1028MRESULT EXPENTRY MainWndProc2(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
1029{
1030  PERSON1DATA *pd;
1031
1032  switch (msg) {
1033  case WM_SAVEAPPLICATION:
1034  case UM_SETUP:
1035  case WM_CREATE:
1036    return MainWMOnce2(hwnd, msg, mp1, mp2);
1037
1038  case UM_THREADUSE:
1039  case UM_LOADFILE:
1040  case UM_BUILDDRIVEBAR:
1041    return CommonMainWndProc(hwnd, msg, mp1, mp2);
1042
1043  case UM_SETUP2:
1044    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1045    if (pd) {
1046      if (mp1) {
1047        if (pd->hwndDir1 && (!pd->hwndMax || pd->hwndMax == pd->hwndDir1))
1048          BoxWindow(pd->hwndDir1, (HPS) 0, CLR_PALEGRAY);
1049        if (pd->hwndDir2 && (!pd->hwndMax || pd->hwndMax == pd->hwndDir2))
1050          BoxWindow(pd->hwndDir2, (HPS) 0, CLR_PALEGRAY);
1051        if (hwndTree)
1052          BoxWindow(hwndTree, (HPS) 0, CLR_PALEGRAY);
1053      }
1054      else {
1055        if (hwndTree)
1056          BoxWindow(hwndTree,
1057                    (HPS) 0,
1058                    (pd->hwndCurr == hwndTree) ? CLR_RED : CLR_WHITE);
1059        if (!pd->hwndMax || pd->hwndMax == pd->hwndDir1)
1060          BoxWindow(pd->hwndDir1,
1061                    (HPS) 0,
1062                    (pd->hwndDir1 == pd->hwndCurr) ?
1063                    CLR_RED :
1064                    (pd->hwndDir1 == pd->hwndLastDir) ?
1065                    CLR_DARKRED : CLR_PALEGRAY);
1066        if (!pd->hwndMax || pd->hwndMax == pd->hwndDir2)
1067          BoxWindow(pd->hwndDir2,
1068                    (HPS) 0,
1069                    (pd->hwndDir2 == pd->hwndCurr) ?
1070                    CLR_RED :
1071                    (pd->hwndDir2 == pd->hwndLastDir) ?
1072                    CLR_DARKRED : CLR_PALEGRAY);
1073      }
1074    }
1075    return 0;
1076
1077  case WM_BUTTON1DOWN:
1078    shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
1079    if (hwndTree) {
1080
1081      SWP swp;
1082
1083      WinQueryWindowPos(hwndTree, &swp);
1084      if (SHORT1FROMMP(mp1) > (swp.x + swp.cx) - 3 &&
1085          SHORT1FROMMP(mp1) < (swp.x + swp.cx) + 3) {
1086
1087        SWP swpC;
1088        TRACKINFO track;
1089
1090        WinQueryWindowPos(hwnd, &swpC);
1091        track.cxBorder = 4;
1092        track.cyBorder = 4;
1093        track.cxGrid = 1;
1094        track.cyGrid = 1;
1095        track.cxKeyboard = 8;
1096        track.cyKeyboard = 8;
1097        track.rclTrack.yBottom = 2;
1098        track.rclTrack.yTop = swpC.cy - 4;
1099        track.rclTrack.xLeft = 2;
1100        track.rclTrack.xRight = swp.x + swp.cx + 2;
1101        track.rclBoundary = track.rclTrack;
1102        track.rclBoundary.xRight = swpC.cx - 80;
1103        track.ptlMinTrackSize.x = 80;
1104        track.ptlMinTrackSize.y = swpC.cy - 4;
1105        track.ptlMaxTrackSize.x = swpC.cx - 80;
1106        track.ptlMaxTrackSize.y = swpC.cy - 4;
1107        track.fs = TF_RIGHT;
1108        if (WinTrackRect(hwnd, (HPS) 0, &track)) {
1109          TreeWidth = track.rclTrack.xRight - track.rclTrack.xLeft;
1110          PrfWriteProfileData(fmprof,
1111                              realappname,
1112                              "FM/4 TreeWidth", &TreeWidth, sizeof(ULONG));
1113          WinSendMsg(hwnd, UM_SETUP2, MPFROMLONG(1), MPVOID);
1114          PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
1115        }
1116        return (MRESULT) TRUE;
1117      }
1118    }
1119    break;
1120
1121  case WM_MOUSEMOVE:
1122    shiftstate = (SHORT2FROMMP(mp2) & (KC_ALT | KC_SHIFT | KC_CTRL));
1123    if (hwndTree) {
1124
1125      SWP swp;
1126
1127      if (WinQueryWindowPos(hwndTree, &swp)) {
1128        if (SHORT1FROMMP(mp1) > (swp.x + swp.cx) - 3 &&
1129            SHORT1FROMMP(mp1) < (swp.x + swp.cx) + 3)
1130          WinSetPointer(HWND_DESKTOP, hptrEW);
1131        else
1132          WinSetPointer(HWND_DESKTOP, hptrArrow);
1133      }
1134      else
1135        WinSetPointer(HWND_DESKTOP, hptrArrow);
1136    }
1137    return (MRESULT) TRUE;
1138
1139  case WM_BUTTON1UP:
1140  case WM_BUTTON2UP:
1141  case WM_BUTTON3UP:
1142  case WM_CHAR:
1143    shiftstate = (SHORT1FROMMP(mp1) & (KC_SHIFT | KC_ALT | KC_CTRL));
1144    break;
1145
1146  case UM_ADVISEFOCUS:
1147    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1148    if (mp1 && pd && (HWND) mp1 != pd->hwndCurr) {
1149      if ((HWND) mp1 != hwndTree)
1150        pd->hwndLastDir = (HWND) mp1;
1151      pd->hwndCurr = (HWND) mp1;
1152      WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
1153    }
1154    return 0;
1155
1156  case UM_MAXIMIZE:
1157    if (mp1) {
1158      pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1159      if (pd) {
1160        WinSendMsg(hwnd, UM_SETUP2, MPFROMLONG(1), MPVOID);
1161        if (pd->hwndMax != (HWND) mp1) {
1162          pd->hwndMax = (HWND) mp1;
1163          WinSetFocus(HWND_DESKTOP, pd->hwndMax);
1164        }
1165        else
1166          pd->hwndMax = (HWND) 0;
1167        PostMsg(hwnd, UM_SIZE, MPVOID, MPVOID);
1168      }
1169    }
1170    return 0;
1171
1172  case WM_INITMENU:
1173    switch (SHORT1FROMMP(mp1)) {
1174    case IDM_FILESMENU:
1175    case IDM_VIEWSMENU:
1176    case IDM_DETAILSSETUP:
1177    case IDM_COMMANDSMENU:
1178    case IDM_SORTSUBMENU:
1179      pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1180      if (pd)
1181        WinSendMsg(pd->hwndCurr, UM_INITMENU, mp1, mp2);
1182      break;
1183    case IDM_CONFIGMENU:
1184      WinCheckMenuItem((HWND) mp2, IDM_TOOLSUBMENU, fToolbar);
1185      WinCheckMenuItem((HWND) mp2, IDM_AUTOVIEW, fAutoView);
1186      break;
1187    case IDM_TOOLSUBMENU:
1188      WinCheckMenuItem((HWND) mp2, IDM_TOOLBAR, fToolbar);
1189      WinCheckMenuItem((HWND) mp2, IDM_TEXTTOOLS, fTextTools);
1190      WinCheckMenuItem((HWND) mp2, IDM_TOOLTITLES, fToolTitles);
1191      break;
1192    case IDM_WINDOWSMENU:
1193      WinCheckMenuItem((HWND) mp2, IDM_VTREE, (hwndTree != (HWND) 0));
1194      WinCheckMenuItem((HWND) mp2, IDM_TILEBACKWARDS, fTileBackwards);
1195      SetupWinList((HWND) mp2, hwnd, WinQueryWindow(hwnd, QW_PARENT));
1196      break;
1197    }
1198    break;
1199
1200  case WM_SETFOCUS:
1201    if (mp2)
1202      PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
1203    break;
1204
1205  case UM_FOCUSME:
1206    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1207    if (pd)
1208      WinSetFocus(HWND_DESKTOP, pd->hwndCurr);
1209    return 0;
1210
1211  case UM_RESCAN:
1212    return 0;
1213
1214  case UM_SIZE:
1215    {
1216      SWP swp;
1217
1218      if (WinQueryWindowPos(hwnd, &swp)) {
1219        mp1 = MPFROM2SHORT(swp.cx, swp.cy);
1220        mp2 = MPFROM2SHORT(swp.cx, swp.cy);
1221      }
1222      else
1223        return 0;
1224    }
1225    /* intentional fallthru */
1226  case WM_SIZE:
1227    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1228    if (mp1 && mp2 && pd && pd->hwndDir1 && pd->hwndDir2) {
1229      if (hwndTree)
1230        WinSetWindowPos(hwndTree,
1231                        HWND_TOP,
1232                        2,
1233                        2,
1234                        TreeWidth - 4,
1235                        SHORT2FROMMP(mp2) - 4,
1236                        SWP_SHOW | SWP_MOVE | SWP_SIZE);
1237      else
1238        TreeWidth = 0;
1239      if (!pd->hwndMax) {
1240        if (fTileBackwards) {
1241          WinSetWindowPos(pd->hwndDir1, HWND_TOP,
1242                          (((SHORT1FROMMP(mp2) - TreeWidth) / 2) +
1243                           TreeWidth) + 2,
1244                          2,
1245                          ((SHORT1FROMMP(mp2) - TreeWidth) / 2) - 4,
1246                          SHORT2FROMMP(mp2) - 4,
1247                          SWP_SHOW | SWP_MOVE | SWP_SIZE);
1248          WinSetWindowPos(pd->hwndDir2, HWND_TOP,
1249                          TreeWidth + 2,
1250                          2,
1251                          ((SHORT1FROMMP(mp2) - TreeWidth) / 2) - 4,
1252                          SHORT2FROMMP(mp2) - 4,
1253                          SWP_SHOW | SWP_MOVE | SWP_SIZE);
1254        }
1255        else {
1256          WinSetWindowPos(pd->hwndDir1, HWND_TOP,
1257                          TreeWidth + 2,
1258                          2,
1259                          (SHORT1FROMMP(mp2) - TreeWidth) - 4,
1260                          (SHORT2FROMMP(mp2) / 2) - 4,
1261                          SWP_SHOW | SWP_MOVE | SWP_SIZE);
1262          WinSetWindowPos(pd->hwndDir2, HWND_TOP,
1263                          TreeWidth + 2,
1264                          (SHORT2FROMMP(mp2) / 2) + 2,
1265                          (SHORT1FROMMP(mp2) - TreeWidth) - 4,
1266                          (SHORT2FROMMP(mp2) / 2) - 4,
1267                          SWP_SHOW | SWP_MOVE | SWP_SIZE);
1268        }
1269      }
1270      else {
1271
1272        HWND hwndOther;
1273
1274        WinSetWindowPos(pd->hwndMax, HWND_TOP,
1275                        TreeWidth + 2,
1276                        2,
1277                        (SHORT1FROMMP(mp2) - TreeWidth) - 4,
1278                        SHORT2FROMMP(mp2) - 4,
1279                        SWP_SHOW | SWP_MOVE | SWP_SIZE);
1280        hwndOther = (pd->hwndMax == pd->hwndDir1) ?
1281          pd->hwndDir2 : pd->hwndDir1;
1282        WinSetWindowPos(hwndOther, HWND_BOTTOM, 0, 0, 0, 0, SWP_HIDE);
1283      }
1284      WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
1285    }
1286    if (msg == UM_SIZE)
1287      return 0;
1288    break;
1289
1290  case WM_ERASEBACKGROUND:
1291    WinFillRect((HPS) mp1, (PRECTL) mp2, 0x00d0d0d0);
1292    return 0;
1293
1294  case WM_PAINT:
1295    {
1296      HPS hps;
1297      RECTL rcl;
1298
1299      hps = WinBeginPaint(hwnd, NULLHANDLE, NULL);
1300      if (hps) {
1301        WinQueryWindowRect(hwnd, &rcl);
1302        WinFillRect(hps, (PRECTL) & rcl, CLR_PALEGRAY);
1303        WinEndPaint(hps);
1304        WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
1305      }
1306    }
1307    break;
1308
1309  case UM_COMMAND:
1310  case WM_COMMAND:
1311    return MainWMCommand2(hwnd, msg, mp1, mp2);
1312
1313  case WM_CLOSE:
1314    fAmClosing = TRUE;
1315    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
1316    CloseChildren(hwnd);
1317    PostMsg(hwnd, UM_CLOSE, MPVOID, MPVOID);
1318    DosSleep(1L);
1319    return 0;
1320
1321  case UM_CLOSE:
1322    WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
1323    return 0;
1324
1325  case WM_DESTROY:
1326    hwndMain = (HWND) 0;
1327    pd = WinQueryWindowPtr(hwnd, QWL_USER + 4);
1328    if (pd)
1329      free(pd);
1330    if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
1331      WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
1332    break;
1333  }
1334  return WinDefWindowProc(hwnd, msg, mp1, mp2);
1335}
1336
1337HWND StartFM32(HAB hab, INT argc, CHAR ** argv)
1338{
1339  HWND hwndFrame, hwndClient;
1340  ULONG FrameFlags = FCF_TITLEBAR | FCF_SYSMENU |
1341    FCF_SIZEBORDER | FCF_MINMAX |
1342    FCF_ACCELTABLE | FCF_MENU | FCF_ICON | FCF_TASKLIST | FCF_NOBYTEALIGN;
1343
1344  {
1345    INT x;
1346
1347    for (x = 1; x < argc; x++) {
1348      if (*argv[x] == '+' && !argv[x][1])
1349        fLogFile = TRUE;
1350      if (*argv[x] == '-') {
1351        if (argv[x][1])
1352          strcpy(profile, &argv[x][1]);
1353      }
1354    }
1355  }
1356  {
1357    CHAR inipath[CCHMAXPATH], fullpath[CCHMAXPATH];
1358    FILESTATUS3 fsa;
1359
1360    if (PrfQueryProfileString(HINI_USERPROFILE,
1361                              FM2Str,
1362                              "Home", NULL, inipath, sizeof(inipath))) {
1363      if (!DosQueryPathInfo(inipath, FIL_STANDARD, &fsa, (ULONG) sizeof(fsa))) {
1364        if (fsa.attrFile & FILE_DIRECTORY) {
1365          if (DosQueryPathInfo(inipath,
1366                               FIL_QUERYFULLNAME, fullpath, sizeof(fullpath)))
1367            strcpy(fullpath, inipath);
1368          switch_to(fullpath);
1369        }
1370      }
1371    }
1372  }
1373
1374  hwndFrame = WinCreateStdWindow(HWND_DESKTOP,
1375                                 WS_VISIBLE,
1376                                 &FrameFlags,
1377                                 WC_MAINWND2,
1378                                 NULL,
1379                                 WS_VISIBLE | WS_ANIMATE,
1380                                 FM3ModHandle, MAIN2_FRAME, &hwndClient);
1381  if (hwndFrame) {
1382    if (!WinRestoreWindowPos(FM2Str, "MainWindowPos2", hwndFrame)) {
1383
1384      ULONG fl = SWP_MOVE | SWP_SIZE;
1385      RECTL rcl;
1386      ULONG icz = WinQuerySysValue(HWND_DESKTOP, SV_CYICON) * 3L;
1387      ULONG bsz = WinQuerySysValue(HWND_DESKTOP, SV_CYSIZEBORDER);
1388
1389      WinQueryWindowRect(HWND_DESKTOP, &rcl);
1390      rcl.yBottom += icz;
1391      rcl.yTop -= bsz;
1392      rcl.xLeft += bsz;
1393      rcl.xRight -= bsz;
1394      WinSetWindowPos(hwndFrame,
1395                      HWND_TOP,
1396                      rcl.xLeft,
1397                      rcl.yBottom,
1398                      rcl.xRight - rcl.xLeft, rcl.yTop - rcl.yBottom, fl);
1399    }
1400    if (fLogFile)
1401      LogFileHandle = _fsopen("FM2.LOG", "a+", SH_DENYWR);
1402    if (hwndHelp)
1403      WinAssociateHelpInstance(hwndHelp, hwndFrame);
1404    PostMsg(hwndClient, UM_SETUP, MPFROMLONG(argc), MPFROMP(argv));
1405  }
1406  return hwndFrame;
1407}
Note: See TracBrowser for help on using the repository browser.