source: trunk/dll/mainwnd2.c @ 593

Last change on this file since 593 was 593, checked in by Gregg Young, 14 years ago

Changes to remove GetPString from window class names

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