Changeset 551 for trunk/dll/viewer.c


Ignore:
Timestamp:
Feb 28, 2007, 2:33:51 AM (18 years ago)
Author:
Gregg Young
Message:

Indentation cleanup

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/dll/viewer.c

    r470 r551  
    4444#define COLORS_BACKGROUND            1
    4545
    46 static LONG   Colors[COLORS_MAX] = {COLR_BLACK,COLR_PALEGRAY};
    47 static BOOL   Firsttime = TRUE;
    48 
    49 
    50 HWND StartMLEEditor (HWND hwndClient,INT flags,CHAR *filename,
    51                      HWND hwndRestore) {
     46static LONG Colors[COLORS_MAX] = { COLR_BLACK, COLR_PALEGRAY };
     47static BOOL Firsttime = TRUE;
     48
     49HWND StartMLEEditor(HWND hwndClient, INT flags, CHAR * filename,
     50                    HWND hwndRestore)
     51{
    5252
    5353  /*
     
    6161   */
    6262
    63   HWND        hwndFrame,hwnd;
     63  HWND hwndFrame, hwnd;
    6464  XMLEWNDPTR *vw;
    65   ULONG    flFrameFlags = FCF_SYSMENU    | FCF_SIZEBORDER | FCF_ICON |
    66                           FCF_TITLEBAR   | FCF_MINMAX     | FCF_MENU |
    67                           FCF_ACCELTABLE | FCF_NOBYTEALIGN;
    68 
    69   if(fExternalViewer || strcmp(realappname,FM3Str))
     65  ULONG flFrameFlags = FCF_SYSMENU | FCF_SIZEBORDER | FCF_ICON |
     66    FCF_TITLEBAR | FCF_MINMAX | FCF_MENU | FCF_ACCELTABLE | FCF_NOBYTEALIGN;
     67
     68  if (fExternalViewer || strcmp(realappname, FM3Str))
    7069    hwndClient = HWND_DESKTOP;
    71   if((flags & 1) && fUseNewViewer)
    72     return StartViewer(hwndClient,(USHORT)flags,filename,hwndRestore);
    73 
    74   vw = xmallocz(sizeof(XMLEWNDPTR),pszSrcFile,__LINE__);
    75   if(!vw)
    76     return (HWND)0;
     70  if ((flags & 1) && fUseNewViewer)
     71    return StartViewer(hwndClient, (USHORT) flags, filename, hwndRestore);
     72
     73  vw = xmallocz(sizeof(XMLEWNDPTR), pszSrcFile, __LINE__);
     74  if (!vw)
     75    return (HWND) 0;
    7776  vw->size = sizeof(XMLEWNDPTR);
    78   if(flags & 1) {
    79     if(flags & 8)
     77  if (flags & 1) {
     78    if (flags & 8)
    8079      vw->hex = 2;
    81     else if(flags & 16)
     80    else if (flags & 16)
    8281      vw->hex = 1;
    83     else if(!fGuessType)
     82    else if (!fGuessType)
    8483      vw->hex = 2;
    8584  }
     
    8887  vw->hwndParent = (hwndClient) ? hwndClient : HWND_DESKTOP;
    8988  vw->srch.size = sizeof(SRCHPTR);
    90   if(flags & 4)
     89  if (flags & 4)
    9190    vw->dontclose = TRUE;
    92   if(filename)
    93     strcpy(vw->exportfilename,filename);
     91  if (filename)
     92    strcpy(vw->exportfilename, filename);
    9493  vw->hwndRestore = hwndRestore;
    95   if(ParentIsDesktop(hwndClient,hwndClient))
     94  if (ParentIsDesktop(hwndClient, hwndClient))
    9695    flFrameFlags |= FCF_TASKLIST;
    9796  hwndFrame = WinCreateStdWindow(hwndClient,
    98                                  WS_VISIBLE,
    99                                  &flFrameFlags,
    100                                  GetPString(IDS_WCMLEEDITOR),
    101                                  NullStr,
    102                                  WS_VISIBLE | fwsAnimate,
    103                                  FM3ModHandle,
    104                                  MLE_FRAME,
    105                                  &hwnd);
    106   if(hwndFrame) {
     97                                 WS_VISIBLE,
     98                                 &flFrameFlags,
     99                                 GetPString(IDS_WCMLEEDITOR),
     100                                 NullStr,
     101                                 WS_VISIBLE | fwsAnimate,
     102                                 FM3ModHandle, MLE_FRAME, &hwnd);
     103  if (hwndFrame) {
    107104    vw->hwndFrame = hwndFrame;
    108     if(!ParentIsDesktop(hwndFrame,hwndClient) && !(flags & 2)) {
     105    if (!ParentIsDesktop(hwndFrame, hwndClient) && !(flags & 2)) {
    109106
    110107      SWP swp;
    111108
    112       FillClient(hwndClient,&swp,NULL,FALSE);
     109      FillClient(hwndClient, &swp, NULL, FALSE);
    113110      WinSetWindowPos(hwndFrame,
    114                       HWND_TOP,
    115                       swp.x,
    116                       swp.y,
    117                       swp.cx,
    118                       swp.cy,
    119                       SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ACTIVATE |
    120                       SWP_ZORDER);
    121     }
    122     else if(flFrameFlags & FCF_TASKLIST) {
    123 
    124       SWP   swp,swpD;
     111                      HWND_TOP,
     112                      swp.x,
     113                      swp.y,
     114                      swp.cx,
     115                      swp.cy,
     116                      SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ACTIVATE |
     117                      SWP_ZORDER);
     118    }
     119    else if (flFrameFlags & FCF_TASKLIST) {
     120
     121      SWP swp, swpD;
    125122      ULONG size = sizeof(swp);
    126       LONG  cxScreen,cyScreen;
    127 
    128       WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame),
    129                           0,
    130                           &swp);
    131       if(PrfQueryProfileData(fmprof,
    132                              appname,
    133                              "ViewSizePos",
    134                              &swpD,
    135                              &size)) {
    136         cxScreen = WinQuerySysValue(HWND_DESKTOP,
    137                                     SV_CXSCREEN);
    138         cyScreen = WinQuerySysValue(HWND_DESKTOP,
    139                                     SV_CYSCREEN);
    140         if(swp.x + swpD.cx > cxScreen)
    141           swp.x = cxScreen - swpD.cx;
    142         if(swp.y + swpD.cy > cyScreen)
    143           swp.y = cyScreen - swpD.cy;
    144         swp.cx = swpD.cx;
    145         swp.cy = swpD.cy;
     123      LONG cxScreen, cyScreen;
     124
     125      WinQueryTaskSizePos(WinQueryAnchorBlock(hwndFrame), 0, &swp);
     126      if (PrfQueryProfileData(fmprof, appname, "ViewSizePos", &swpD, &size)) {
     127        cxScreen = WinQuerySysValue(HWND_DESKTOP, SV_CXSCREEN);
     128        cyScreen = WinQuerySysValue(HWND_DESKTOP, SV_CYSCREEN);
     129        if (swp.x + swpD.cx > cxScreen)
     130          swp.x = cxScreen - swpD.cx;
     131        if (swp.y + swpD.cy > cyScreen)
     132          swp.y = cyScreen - swpD.cy;
     133        swp.cx = swpD.cx;
     134        swp.cy = swpD.cy;
    146135      }
    147136      WinSetWindowPos(hwndFrame,
    148                       HWND_TOP,
    149                       swp.x,
    150                       swp.y,
    151                       swp.cx,
    152                       swp.cy,
    153                       SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
    154                       SWP_ACTIVATE);
    155     }
    156     MLEsetreadonly(hwndMLE,((flags & 1) != 0));
    157     WinSetWindowPtr(hwnd,QWL_USER,(PVOID)vw);
    158     if(!PostMsg(hwnd,
    159                 UM_SETUP,
    160                 MPVOID,
    161                 MPFROMLONG(hwndClient)))
    162       WinSendMsg(hwnd,
    163                  UM_SETUP,
    164                  MPVOID,
    165                  MPFROMLONG(hwndClient));
     137                      HWND_TOP,
     138                      swp.x,
     139                      swp.y,
     140                      swp.cx,
     141                      swp.cy,
     142                      SWP_SIZE | SWP_MOVE | SWP_SHOW | SWP_ZORDER |
     143                      SWP_ACTIVATE);
     144    }
     145    MLEsetreadonly(hwndMLE, ((flags & 1) != 0));
     146    WinSetWindowPtr(hwnd, QWL_USER, (PVOID) vw);
     147    if (!PostMsg(hwnd, UM_SETUP, MPVOID, MPFROMLONG(hwndClient)))
     148      WinSendMsg(hwnd, UM_SETUP, MPVOID, MPFROMLONG(hwndClient));
    166149  }
    167150  return hwndFrame;
    168151}
    169152
    170 
    171 MRESULT EXPENTRY MLESubProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    172 
    173   PFNWP       oldproc = (PFNWP)WinQueryWindowPtr(hwnd,QWL_USER);
     153MRESULT EXPENTRY MLESubProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     154{
     155
     156  PFNWP oldproc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
    174157  XMLEWNDPTR *vw;
    175158
    176   switch(msg) {
    177     case WM_SETFOCUS:
    178       if(mp2)
    179         PostMsg(WinQueryWindow(hwnd,QW_PARENT),UM_SELECT,mp1,mp2);
    180       break;
    181 
    182     case WM_CHAR:
    183       vw = WinQueryWindowPtr(WinQueryWindow(hwnd,QW_PARENT),QWL_USER);
    184       if(vw && vw->size == sizeof(XMLEWNDPTR) && vw->hex == 1) {
    185         if(!MLEgetreadonly(hwnd)) {
    186           WinSetSysValue(HWND_DESKTOP,SV_INSERTMODE,FALSE);
    187           if(vw->fWrap) {
    188             vw->fWrap = FALSE;
    189             MLEsetwrap(hwnd,FALSE);
    190           }
    191           MLEanctocur(hwnd);
    192           {
    193             static ULONG  badoff[] = {11,14,17,20,23,26,29,32,35,38,41,44,
    194                                       47,0};
    195             ULONG         line,pos,offset,len,x;
    196             MRESULT       mr;
    197 
    198             mr = oldproc(hwnd,msg,mp1,mp2);
    199 
    200             len = MLEcurlinelen(hwnd);
    201             line = MLEcurline(hwnd);
    202             pos = MLEcurpos(hwnd);
    203             offset = len - MLElinelenleft(hwnd,pos);
    204             if(offset < 9) {
    205               if(!line || offset == 8 || line == MLEnumlines(hwnd) - 1)
    206                 MLEsetcurpos(hwnd,pos + (9 - offset));
    207               else
    208                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line + 1) + 9);
    209             }
    210             else if(offset >= 71) {
    211               if(vw->lastpos == offset - 1) {
    212                 if(line < MLEnumlines(hwnd) - 1)
    213                   MLEsetcurpos(hwnd,MLEstartofline(hwnd,line + 2) + 55);
    214                 else
    215                   MLEsetcurpos(hwnd,MLEstartofline(hwnd,line + 1) + 55);
    216               }
    217               else
    218                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line) + 70);
    219             }
    220             else if(offset == 53) {
    221               if(line < MLEnumlines(hwnd) - 1)
    222                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line + 1) + 9);
    223               else
    224                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line) + 9);
    225             }
    226             else if(offset == 54) {
    227               if(line < MLEnumlines(hwnd) - 1)
    228                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line + 1) + 70);
    229               else
    230                 MLEsetcurpos(hwnd,MLEstartofline(hwnd,line) + 70);
    231             }
    232             else {
    233               for(x = 0;badoff[x];x++) {
    234                 if(offset == badoff[x]) {
    235                   if(vw->lastpos < pos)
    236                     MLEsetcurpos(hwnd,pos + 1);
    237                   else
    238                     MLEsetcurpos(hwnd,pos - 1);
    239                 }
    240               }
    241             }
    242             {
    243               CHAR s[80];
    244 
    245               sprintf(s,
    246                       GetPString(IDS_VIEWPOSSTUFFTEXT),
    247                       len,
    248                       line,
    249                       pos,
    250                       offset);
    251               if(hwndStatus)
    252                 WinSetWindowText(hwndStatus,s);
    253             }
    254             vw->lastpos = MLEcurpos(hwnd);
    255             return mr;
    256           }
    257         }
    258       }
    259       break;
    260 
    261     case WM_MENUEND:
    262       vw = WinQueryWindowPtr(WinQueryWindow(hwnd,QW_PARENT),QWL_USER);
    263       if(vw && vw->size == sizeof(XMLEWNDPTR)) {
    264         if(vw->hwndPopupMenu == (HWND)mp2) {
    265           WinDestroyWindow(vw->hwndPopupMenu);
    266           vw->hwndPopupMenu = (HWND)0;
    267         }
    268       }
    269       break;
    270 
    271     case WM_CONTEXTMENU:
    272       vw = WinQueryWindowPtr(WinQueryWindow(hwnd,QW_PARENT),QWL_USER);
    273       if(vw && vw->size == sizeof(XMLEWNDPTR)) {
    274         if(!vw->hwndPopupMenu)
    275           vw->hwndPopupMenu = WinLoadMenu(HWND_DESKTOP,FM3ModHandle,MLE_POPUP);
    276         if(vw->hwndPopupMenu) {
    277           if(MLEgetreadonly(hwnd)) {
    278             WinEnableMenuItem(vw->hwndPopupMenu,MLE_UNDO,FALSE);
    279             WinEnableMenuItem(vw->hwndPopupMenu,MLE_CUTCLIP,FALSE);
    280             WinEnableMenuItem(vw->hwndPopupMenu,MLE_PASTECLIP,FALSE);
    281             WinEnableMenuItem(vw->hwndPopupMenu,MLE_CLEAR,FALSE);
    282             WinEnableMenuItem(vw->hwndPopupMenu,MLE_BLOCKMENU,FALSE);
    283           }
    284           else {
    285             WinEnableMenuItem(vw->hwndPopupMenu,MLE_UNDO,TRUE);
    286             WinEnableMenuItem(vw->hwndPopupMenu,MLE_CUTCLIP,TRUE);
    287             WinEnableMenuItem(vw->hwndPopupMenu,MLE_PASTECLIP,TRUE);
    288             WinEnableMenuItem(vw->hwndPopupMenu,MLE_CLEAR,TRUE);
    289             WinEnableMenuItem(vw->hwndPopupMenu,MLE_BLOCKMENU,TRUE);
    290           }
    291           if(!*ftprun)
    292             WinSendMsg(vw->hwndPopupMenu,MM_DELETEITEM,
    293                        MPFROM2SHORT(MLE_VIEWFTP,FALSE),MPVOID);
    294           if(!*httprun)
    295             WinSendMsg(vw->hwndPopupMenu,MM_DELETEITEM,
    296                        MPFROM2SHORT(MLE_VIEWHTTP,FALSE),MPVOID);
    297           PopupMenu(WinQueryWindow(hwnd,QW_PARENT),
    298                     WinQueryWindow(hwnd,QW_PARENT),
    299                     vw->hwndPopupMenu);
    300         }
    301       }
    302       break;
     159  switch (msg) {
     160  case WM_SETFOCUS:
     161    if (mp2)
     162      PostMsg(WinQueryWindow(hwnd, QW_PARENT), UM_SELECT, mp1, mp2);
     163    break;
     164
     165  case WM_CHAR:
     166    vw = WinQueryWindowPtr(WinQueryWindow(hwnd, QW_PARENT), QWL_USER);
     167    if (vw && vw->size == sizeof(XMLEWNDPTR) && vw->hex == 1) {
     168      if (!MLEgetreadonly(hwnd)) {
     169        WinSetSysValue(HWND_DESKTOP, SV_INSERTMODE, FALSE);
     170        if (vw->fWrap) {
     171          vw->fWrap = FALSE;
     172          MLEsetwrap(hwnd, FALSE);
     173        }
     174        MLEanctocur(hwnd);
     175        {
     176          static ULONG badoff[] =
     177            { 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44,
     178            47, 0
     179          };
     180          ULONG line, pos, offset, len, x;
     181          MRESULT mr;
     182
     183          mr = oldproc(hwnd, msg, mp1, mp2);
     184
     185          len = MLEcurlinelen(hwnd);
     186          line = MLEcurline(hwnd);
     187          pos = MLEcurpos(hwnd);
     188          offset = len - MLElinelenleft(hwnd, pos);
     189          if (offset < 9) {
     190            if (!line || offset == 8 || line == MLEnumlines(hwnd) - 1)
     191              MLEsetcurpos(hwnd, pos + (9 - offset));
     192            else
     193              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line + 1) + 9);
     194          }
     195          else if (offset >= 71) {
     196            if (vw->lastpos == offset - 1) {
     197              if (line < MLEnumlines(hwnd) - 1)
     198                MLEsetcurpos(hwnd, MLEstartofline(hwnd, line + 2) + 55);
     199              else
     200                MLEsetcurpos(hwnd, MLEstartofline(hwnd, line + 1) + 55);
     201            }
     202            else
     203              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line) + 70);
     204          }
     205          else if (offset == 53) {
     206            if (line < MLEnumlines(hwnd) - 1)
     207              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line + 1) + 9);
     208            else
     209              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line) + 9);
     210          }
     211          else if (offset == 54) {
     212            if (line < MLEnumlines(hwnd) - 1)
     213              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line + 1) + 70);
     214            else
     215              MLEsetcurpos(hwnd, MLEstartofline(hwnd, line) + 70);
     216          }
     217          else {
     218            for (x = 0; badoff[x]; x++) {
     219              if (offset == badoff[x]) {
     220                if (vw->lastpos < pos)
     221                  MLEsetcurpos(hwnd, pos + 1);
     222                else
     223                  MLEsetcurpos(hwnd, pos - 1);
     224              }
     225            }
     226          }
     227          {
     228            CHAR s[80];
     229
     230            sprintf(s,
     231                    GetPString(IDS_VIEWPOSSTUFFTEXT), len, line, pos, offset);
     232            if (hwndStatus)
     233              WinSetWindowText(hwndStatus, s);
     234          }
     235          vw->lastpos = MLEcurpos(hwnd);
     236          return mr;
     237        }
     238      }
     239    }
     240    break;
     241
     242  case WM_MENUEND:
     243    vw = WinQueryWindowPtr(WinQueryWindow(hwnd, QW_PARENT), QWL_USER);
     244    if (vw && vw->size == sizeof(XMLEWNDPTR)) {
     245      if (vw->hwndPopupMenu == (HWND) mp2) {
     246        WinDestroyWindow(vw->hwndPopupMenu);
     247        vw->hwndPopupMenu = (HWND) 0;
     248      }
     249    }
     250    break;
     251
     252  case WM_CONTEXTMENU:
     253    vw = WinQueryWindowPtr(WinQueryWindow(hwnd, QW_PARENT), QWL_USER);
     254    if (vw && vw->size == sizeof(XMLEWNDPTR)) {
     255      if (!vw->hwndPopupMenu)
     256        vw->hwndPopupMenu =
     257          WinLoadMenu(HWND_DESKTOP, FM3ModHandle, MLE_POPUP);
     258      if (vw->hwndPopupMenu) {
     259        if (MLEgetreadonly(hwnd)) {
     260          WinEnableMenuItem(vw->hwndPopupMenu, MLE_UNDO, FALSE);
     261          WinEnableMenuItem(vw->hwndPopupMenu, MLE_CUTCLIP, FALSE);
     262          WinEnableMenuItem(vw->hwndPopupMenu, MLE_PASTECLIP, FALSE);
     263          WinEnableMenuItem(vw->hwndPopupMenu, MLE_CLEAR, FALSE);
     264          WinEnableMenuItem(vw->hwndPopupMenu, MLE_BLOCKMENU, FALSE);
     265        }
     266        else {
     267          WinEnableMenuItem(vw->hwndPopupMenu, MLE_UNDO, TRUE);
     268          WinEnableMenuItem(vw->hwndPopupMenu, MLE_CUTCLIP, TRUE);
     269          WinEnableMenuItem(vw->hwndPopupMenu, MLE_PASTECLIP, TRUE);
     270          WinEnableMenuItem(vw->hwndPopupMenu, MLE_CLEAR, TRUE);
     271          WinEnableMenuItem(vw->hwndPopupMenu, MLE_BLOCKMENU, TRUE);
     272        }
     273        if (!*ftprun)
     274          WinSendMsg(vw->hwndPopupMenu, MM_DELETEITEM,
     275                     MPFROM2SHORT(MLE_VIEWFTP, FALSE), MPVOID);
     276        if (!*httprun)
     277          WinSendMsg(vw->hwndPopupMenu, MM_DELETEITEM,
     278                     MPFROM2SHORT(MLE_VIEWHTTP, FALSE), MPVOID);
     279        PopupMenu(WinQueryWindow(hwnd, QW_PARENT),
     280                  WinQueryWindow(hwnd, QW_PARENT), vw->hwndPopupMenu);
     281      }
     282    }
     283    break;
    303284  }
    304   return oldproc(hwnd,msg,mp1,mp2);
     285  return oldproc(hwnd, msg, mp1, mp2);
    305286}
    306287
    307 
    308 MRESULT EXPENTRY MLEEditorProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
     288MRESULT EXPENTRY MLEEditorProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     289{
    309290
    310291  XMLEWNDPTR *vw;
    311292
    312   if(msg != WM_CREATE &&
    313      msg != UM_SETUP)
    314     vw = (XMLEWNDPTR *)WinQueryWindowPtr(hwnd,QWL_USER);
     293  if (msg != WM_CREATE && msg != UM_SETUP)
     294    vw = (XMLEWNDPTR *) WinQueryWindowPtr(hwnd, QWL_USER);
    315295  else
    316296    vw = NULL;
    317297
    318   switch(msg) {
    319     case WM_CREATE:
    320       /* create MLE window */
    321       if (!WinCreateWindow(hwnd,
    322                       WC_MLE,
    323                       (PSZ)NULL,
    324                       MLS_HSCROLL | MLS_VSCROLL | MLS_BORDER |
    325                       WS_VISIBLE,
    326                       0L,
    327                       0L,
    328                       0L,
    329                       0L,
    330                       hwnd,
    331                       HWND_TOP,
    332                       MLE_MLE,
    333                       MPVOID,
    334                       MPVOID))
     298  switch (msg) {
     299  case WM_CREATE:
     300    /* create MLE window */
     301    if (!WinCreateWindow(hwnd,
     302                         WC_MLE,
     303                         (PSZ) NULL,
     304                         MLS_HSCROLL | MLS_VSCROLL | MLS_BORDER |
     305                         WS_VISIBLE,
     306                         0L,
     307                         0L,
     308                         0L, 0L, hwnd, HWND_TOP, MLE_MLE, MPVOID, MPVOID)) {
     309      Win_Error2(hwnd, hwnd, pszSrcFile, __LINE__, IDS_WINCREATEWINDOW);
     310    }
     311    else {
     312      PFNWP oldproc;
     313
     314      oldproc = WinSubclassWindow(WinWindowFromID(hwnd, MLE_MLE), MLESubProc);
     315      WinSetWindowPtr(WinWindowFromID(hwnd, MLE_MLE),
     316                      QWL_USER, (PVOID) oldproc);
     317    }
     318    break;
     319
     320  case WM_INITMENU:
     321    switch (SHORT1FROMMP(mp1)) {
     322    case MLE_EDITMENU:
    335323      {
    336         Win_Error2(hwnd,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
     324        ULONG ret;
     325        CHAR lbl[162];
     326
     327        strcpy(lbl, GetPString(IDS_UNDOTEXT));
     328        ret = (ULONG) WinSendMsg(hwndMLE, MLM_QUERYUNDO, MPVOID, MPVOID);
     329        switch (HIUSHORT(ret)) {
     330        case WM_CHAR:
     331        case MLM_CUT:
     332        case MLM_CLEAR:
     333        case MLM_PASTE:
     334          WinEnableMenuItem((HWND) mp2, MLE_UNDO, TRUE);
     335          if (!LOUSHORT(ret))
     336            strcpy(lbl, GetPString(IDS_REDOTEXT));
     337          switch (HIUSHORT(ret)) {
     338          case WM_CHAR:
     339            strcat(lbl, GetPString(IDS_KEYSTROKEMENUTEXT));
     340            break;
     341          case MLM_CUT:
     342            strcat(lbl, GetPString(IDS_CUTTOCLIPMENUTEXT));
     343            break;
     344          case MLM_CLEAR:
     345            strcat(lbl, GetPString(IDS_CLEARSELMENUTEXT));
     346            break;
     347          case MLM_PASTE:
     348            strcat(lbl, GetPString(IDS_PASTEFROMCLIPMENUTEXT));
     349            break;
     350          }
     351          WinSetMenuItemText((HWND) mp2, MLE_UNDO, lbl);
     352          break;
     353        default:
     354          WinEnableMenuItem((HWND) mp2, MLE_UNDO, FALSE);
     355          break;
     356        }
     357      }
     358      break;
     359    }
     360    break;
     361
     362  case UM_SETUP2:
     363    vw = WinQueryWindowPtr(hwnd, QWL_USER);
     364    if (vw) {
     365
     366      CHAR s[CCHMAXPATH + 8];
     367
     368      sprintf(s,
     369              "%s: %s",
     370              FM2Str,
     371              (*vw->exportfilename) ?
     372              vw->exportfilename : GetPString(IDS_UNTITLEDTEXT));
     373      WinSetWindowText(WinQueryWindow(hwnd, QW_PARENT), s);
     374      if (WinQueryWindow(hwnd, QW_PARENT) ==
     375          WinQueryActiveWindow(WinQueryWindow(WinQueryWindow(hwnd,
     376                                                             QW_PARENT),
     377                                              QW_PARENT)) &&
     378          !ParentIsDesktop(WinQueryWindow(hwnd, QW_PARENT), (HWND) 0)) {
     379        if (hwndStatus2)
     380          WinSetWindowText(hwndStatus2,
     381                           (*vw->exportfilename) ?
     382                           vw->exportfilename : GetPString(IDS_UNTITLEDTEXT));
     383        if (fMoreButtons) {
     384          WinSetWindowText(hwndName,
     385                           (*vw->exportfilename) ?
     386                           vw->exportfilename : GetPString(IDS_UNTITLEDTEXT));
     387          WinSetWindowText(hwndDate, NullStr);
     388          WinSetWindowText(hwndAttr, NullStr);
     389        }
     390        if (hwndStatus)
     391          WinSetWindowText(hwndStatus,
     392                           GetPString(IDS_INTERNALVIEWEREDITORTITLETEXT));
     393      }
     394    }
     395    return 0;
     396
     397  case UM_SETUP:
     398    vw = WinQueryWindowPtr(hwnd, QWL_USER);
     399    if (vw) {
     400      vw->hab = WinQueryAnchorBlock(hwnd);
     401      WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     402      /* set up initial MLE conditions */
     403      vw->srch.hwndmle = hwndMLE;
     404      MLEsetcurpos(hwndMLE, 0L);
     405      MLEclearall(hwndMLE);
     406      MLEsetlimit(hwndMLE, -1L);
     407      MLEsetformat(hwndMLE, MLFIE_NOTRANS);
     408      WinSetSysValue(HWND_DESKTOP, SV_INSERTMODE, TRUE);
     409      vw->fWrap = TRUE;
     410      vw->fStripTrail = TRUE;
     411      vw->fStripTrailLines = TRUE;
     412      vw->srch.fInsensitive = TRUE;
     413      vw->ExpandTabs = 4;
     414      vw->TabStops = 32;
     415      {
     416        ULONG size;
     417
     418        size = sizeof(BOOL);
     419        PrfQueryProfileData(fmprof,
     420                            FM3Str, "MLEWrap", (PVOID) & vw->fWrap, &size);
     421        size = sizeof(BOOL);
     422        PrfQueryProfileData(fmprof,
     423                            FM3Str,
     424                            "MLEstriptrail",
     425                            (PVOID) & vw->fStripTrail, &size);
     426        size = sizeof(BOOL);
     427        PrfQueryProfileData(fmprof,
     428                            FM3Str,
     429                            "MLEstriptraillines",
     430                            (PVOID) & vw->fStripTrailLines, &size);
     431        size = sizeof(BOOL);
     432        PrfQueryProfileData(fmprof,
     433                            FM3Str,
     434                            "MLEInsensitve",
     435                            (PVOID) & vw->srch.fInsensitive, &size);
     436        size = sizeof(INT);
     437        PrfQueryProfileData(fmprof,
     438                            FM3Str,
     439                            "MLEExpandTabs", (PVOID) & vw->ExpandTabs, &size);
     440        size = sizeof(INT);
     441        PrfQueryProfileData(fmprof,
     442                            FM3Str,
     443                            "MLETabStops", (PVOID) & vw->TabStops, &size);
     444      }
     445      vw->accel = WinQueryAccelTable(vw->hab,
     446                                     WinQueryWindow(hwnd, QW_PARENT));
     447      vw->hwndMenu = WinWindowFromID(WinQueryWindow(hwnd, QW_PARENT),
     448                                     FID_MENU);
     449      vw->ch = FALSE;
     450      MLEsetchanged(hwndMLE, FALSE);
     451      {
     452        MRESULT ret = 0;
     453
     454        if (vw->hwndMenu) {
     455          SetMenuCheck(vw->hwndMenu, MLE_TOGWRAP, &vw->fWrap, FALSE, NULL);
     456          SetMenuCheck(vw->hwndMenu,
     457                       MLE_STRIPTRAILBLANKS, &vw->fStripTrail, FALSE, NULL);
     458          SetMenuCheck(vw->hwndMenu,
     459                       MLE_STRIPTRAILLINES,
     460                       &vw->fStripTrailLines, FALSE, NULL);
     461          {
     462            BOOL tempbool = (vw->ExpandTabs != 0);
     463
     464            SetMenuCheck(vw->hwndMenu,
     465                         MLE_EXPANDTABS, &tempbool, FALSE, NULL);
     466          }
     467          SetMenuCheck(vw->hwndMenu,
     468                       MLE_SENSITIVE, &vw->srch.fInsensitive, FALSE, NULL);
     469        }
     470        MLEsetwrap(hwndMLE, vw->fWrap);
     471        {
     472          ULONG CpList[2];
     473          ULONG CpSize;
     474
     475          if (!DosQueryCp(sizeof(CpList), CpList, &CpSize) && CpSize)
     476            vw->cp = CpList[0];
     477        }
     478        {
     479          ULONG size = sizeof(FATTRS), cps[50], len, x;
     480          HMQ hmq;
     481
     482          if (!PrfQueryProfileData(fmprof,
     483                                   FM3Str,
     484                                   "MLEFont",
     485                                   &vw->fattrs,
     486                                   &size) || size != sizeof(FATTRS)) {
     487            vw->fattrs.usRecordLength = sizeof(FATTRS);
     488            vw->fattrs.lMaxBaselineExt = 16;
     489            vw->fattrs.lAveCharWidth = 8;
     490            strcpy(vw->fattrs.szFacename, GetPString(IDS_SYSMONOTEXT));
     491            vw->fattrs.usCodePage = (USHORT) vw->cp;
     492          }
     493          else
     494            vw->cp = vw->fattrs.usCodePage;
     495          if (!DosQueryCp(sizeof(cps), cps, &len)) {
     496            for (x = 0; x < len / sizeof(ULONG); x++) {
     497              if (cps[x] == (ULONG) vw->cp) {
     498                hmq = WinQueryWindowULong(hwnd, QWL_HMQ);
     499                WinSetCp(hmq, vw->cp);
     500                break;
     501              }
     502            }
     503          }
     504          DosSetProcessCp(vw->cp);
     505          WinSendMsg(hwndMLE, MLM_SETFONT, MPFROMP(&vw->fattrs), MPVOID);
     506        }
     507        if (Firsttime) {
     508
     509          ULONG size;
     510
     511          Firsttime = FALSE;
     512          size = sizeof(ULONG);
     513          PrfQueryProfileData(fmprof,
     514                              FM3Str,
     515                              "MLEBackgroundcolor",
     516                              &Colors[COLORS_BACKGROUND], &size);
     517          size = sizeof(ULONG);
     518          PrfQueryProfileData(fmprof,
     519                              FM3Str,
     520                              "MLEForegroundcolor",
     521                              &Colors[COLORS_FOREGROUND], &size);
     522        }
     523        WinSendMsg(hwndMLE,
     524                   MLM_SETBACKCOLOR,
     525                   MPFROMLONG(standardcolors[Colors[COLORS_BACKGROUND]]),
     526                   MPVOID);
     527        WinSendMsg(hwndMLE,
     528                   MLM_SETTEXTCOLOR,
     529                   MPFROMLONG(standardcolors[Colors[COLORS_FOREGROUND]]),
     530                   MPVOID);
     531        if (*vw->exportfilename)
     532          if (MLEbackgroundload(hwnd,
     533                                UM_CONTAINER_FILLED,
     534                                hwndMLE, vw->exportfilename, vw->hex) != -1) {
     535            vw->busy = TRUE;
     536            WinEnableWindow(vw->hwndMenu, FALSE);
     537          }
     538        if (vw->busy || MLEgetreadonly(hwndMLE)) {
     539          disable_menuitem(vw->hwndMenu, MLE_FILEMENU, TRUE);
     540          disable_menuitem(vw->hwndMenu, MLE_CUTCLIP, TRUE);
     541          disable_menuitem(vw->hwndMenu, MLE_PASTECLIP, TRUE);
     542          disable_menuitem(vw->hwndMenu, MLE_CLEAR, TRUE);
     543          disable_menuitem(vw->hwndMenu, MLE_CUTLINE, TRUE);
     544          disable_menuitem(vw->hwndMenu, MLE_BLOCKMENU, TRUE);
     545        }
     546        return ret;
     547      }
     548    }
     549    return 0;
     550
     551  case UM_CONTAINER_FILLED:             /* file was loaded */
     552    WinEnableWindow(vw->hwndMenu, TRUE);
     553    vw->busy = FALSE;
     554    if (vw->killme) {
     555      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     556      return 0;
     557    }
     558    if (!MLEgetreadonly(hwndMLE)) {
     559      disable_menuitem(vw->hwndMenu, MLE_FILEMENU, FALSE);
     560      disable_menuitem(vw->hwndMenu, MLE_CUTCLIP, FALSE);
     561      disable_menuitem(vw->hwndMenu, MLE_PASTECLIP, FALSE);
     562      disable_menuitem(vw->hwndMenu, MLE_CLEAR, FALSE);
     563      disable_menuitem(vw->hwndMenu, MLE_CUTLINE, FALSE);
     564      disable_menuitem(vw->hwndMenu, MLE_BLOCKMENU, FALSE);
     565    }
     566    if (mp1) {
     567      if (mp2) {
     568        vw->ch = FALSE;
     569        strcpy(vw->exportfilename, (CHAR *) mp2);
     570      }
     571    }
     572    else {
     573      vw->ch = FALSE;
     574      *vw->exportfilename = 0;
     575    }
     576    WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     577    return 0;
     578
     579  case WM_SIZE:
     580    WinSetWindowPos(hwndMLE,
     581                    HWND_TOP,
     582                    0,
     583                    0,
     584                    SHORT1FROMMP(mp2),
     585                    SHORT2FROMMP(mp2), SWP_MOVE | SWP_SIZE);
     586    break;
     587
     588  case UM_SELECT:
     589  case WM_SETFOCUS:                     /* sling focus to MLE */
     590    if (mp2) {
     591      if (hwndMain && fAutoView)
     592        PostMsg(hwndMain, UM_LOADFILE, MPVOID, MPVOID);
     593      WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     594      if (msg != UM_SELECT)
     595        PostMsg(hwnd, UM_FOCUSME, MPVOID, MPVOID);
     596    }
     597    if (msg == WM_SETFOCUS)
     598      break;
     599    return 0;
     600
     601  case UM_FOCUSME:
     602    WinSetFocus(HWND_DESKTOP, hwndMLE);
     603    return 0;
     604
     605  case WM_ERASEBACKGROUND:
     606    WinFillRect((HPS) mp1, (PRECTL) mp2, 0x00d0d0d0);
     607    return 0;
     608
     609  case WM_PAINT:
     610    {
     611      RECTL rcl;
     612      HPS hps;
     613
     614      hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
     615      WinQueryWindowRect(hwnd, &rcl);
     616      WinFillRect(hps, &rcl, CLR_PALEGRAY);
     617      WinEndPaint(hps);
     618    }
     619    break;
     620
     621  case UM_LOADFILE:
     622    if ((CHAR *) mp1) {
     623//        switch_to(mp1);
     624      if (MLEbackgroundload(hwnd,
     625                            UM_CONTAINER_FILLED,
     626                            hwndMLE, (CHAR *) mp1, vw->hex) != -1) {
     627        vw->busy = TRUE;
     628        WinEnableWindow(vw->hwndMenu, FALSE);
     629      }
     630    }
     631    return 0;
     632
     633  case WM_CONTROL:
     634    switch (SHORT1FROMMP(mp1)) {
     635    case MLE_MLE:
     636      switch (SHORT2FROMMP(mp1)) {
     637      case MLN_CHANGE:
     638        if (!vw->ch)
     639          vw->ch = TRUE;
     640        break;
     641      }
     642      break;
     643    }
     644    return 0;
     645
     646  case WM_COMMAND:
     647    if (vw->busy && SHORT1FROMMP(mp1) != MLE_QUIT) {
     648      DosBeep(50, 100);
     649      return 0;
     650    }
     651    switch (SHORT1FROMMP(mp1)) {
     652      /*
     653         case MLE_PREVIEW:
     654         preview_text(hwndMLE);
     655         break;
     656       */
     657    case MLE_VIEWFTP:
     658      MLEinternet(hwndMLE, TRUE);
     659      break;
     660
     661    case MLE_VIEWHTTP:
     662      MLEinternet(hwndMLE, FALSE);
     663      break;
     664
     665    case IDM_NEXTWINDOW:
     666      WinSendMsg(hwndMLE,
     667                 WM_CHAR,
     668                 MPFROM2SHORT((KC_CHAR | KC_VIRTUALKEY),
     669                              MAKEUSHORT(1, 9)), MPFROM2SHORT(9, VK_TAB));
     670      break;
     671
     672    case IDM_COLORPALETTE:
     673      {
     674        COLORS co;
     675        LONG temp[COLORS_MAX];
     676
     677        memset(&co, 0, sizeof(co));
     678        co.size = sizeof(co);
     679        co.numcolors = COLORS_MAX;
     680        co.colors = Colors;
     681        co.descriptions = IDS_EDCOLORS1TEXT;
     682        co.origs = temp;
     683        co.prompt = IDS_EDCOLORSPROMPTTEXT;
     684        memcpy(temp, Colors, sizeof(LONG) * COLORS_MAX);
     685        if (WinDlgBox(HWND_DESKTOP,
     686                      hwnd,
     687                      ColorDlgProc,
     688                      FM3ModHandle, COLOR_FRAME, (PVOID) & co)) {
     689          WinSendMsg(hwndMLE,
     690                     MLM_SETTEXTCOLOR,
     691                     MPFROMLONG(standardcolors[Colors[COLORS_FOREGROUND]]),
     692                     MPVOID);
     693          PrfWriteProfileData(fmprof,
     694                              FM3Str,
     695                              "MLEForegroundcolor",
     696                              &Colors[COLORS_FOREGROUND], sizeof(LONG));
     697          WinSendMsg(hwndMLE,
     698                     MLM_SETBACKCOLOR,
     699                     MPFROMLONG(standardcolors[Colors[COLORS_BACKGROUND]]),
     700                     MPVOID);
     701          PrfWriteProfileData(fmprof,
     702                              FM3Str,
     703                              "MLEBackgroundcolor",
     704                              &Colors[COLORS_BACKGROUND], sizeof(LONG));
     705        }
     706      }
     707      break;
     708
     709    case IDM_HELP:
     710      if (hwndHelp)
     711        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     712                   MPFROM2SHORT(HELP_EDITOR, 0), MPFROMSHORT(HM_RESOURCEID));
     713      break;
     714
     715    case MLE_CODEPAGE:
     716      vw->cp = PickCodepage(hwnd);
     717      vw->fattrs.usCodePage = (USHORT) vw->cp;
     718      WinSendMsg(hwndMLE, MLM_SETFONT, MPFROMP(&vw->fattrs), MPVOID);
     719      PrfWriteProfileData(fmprof,
     720                          FM3Str, "MLEFont", &vw->fattrs, sizeof(FATTRS));
     721      break;
     722
     723    case MLE_NEWFILE:
     724      if (!MLEgetreadonly(hwndMLE)) {
     725        if (vw->ch) {
     726
     727          APIRET temp;
     728
     729          temp = saymsg(MB_YESNOCANCEL | MB_ICONEXCLAMATION,
     730                        hwnd, NullStr, GetPString(IDS_SAVECHANGESTEXT));
     731          if (temp == MBID_CANCEL)
     732            break;
     733          if (temp == MBID_YES)
     734            WinSendMsg(hwnd,
     735                       WM_COMMAND, MPFROM2SHORT(MLE_EXPORTFILE, 0), MPVOID);
     736        }
     737        MLEclearall(hwndMLE);
     738        *vw->exportfilename = 0;
     739        vw->ch = FALSE;
     740        MLEsetchanged(hwndMLE, FALSE);
     741        WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     742      }
     743      break;
     744
     745    case MLE_TOGGLEREADONLY:
     746      if (vw->busy || vw->hex == 1) {
     747        DosBeep(50, 100);
    337748      }
    338749      else {
    339         PFNWP oldproc;
    340         oldproc = WinSubclassWindow(WinWindowFromID(hwnd,MLE_MLE),
    341                                     MLESubProc);
    342         WinSetWindowPtr(WinWindowFromID(hwnd,MLE_MLE),
    343                         QWL_USER,
    344                         (PVOID)oldproc);
    345       }
    346       break;
    347 
    348     case WM_INITMENU:
    349       switch(SHORT1FROMMP(mp1)) {
    350         case MLE_EDITMENU:
    351           {
    352             ULONG ret;
    353             CHAR  lbl[162];
    354 
    355             strcpy(lbl,GetPString(IDS_UNDOTEXT));
    356             ret = (ULONG)WinSendMsg(hwndMLE,MLM_QUERYUNDO,MPVOID,MPVOID);
    357             switch(HIUSHORT(ret)) {
    358               case WM_CHAR:
    359               case MLM_CUT:
    360               case MLM_CLEAR:
    361               case MLM_PASTE:
    362                 WinEnableMenuItem((HWND)mp2,MLE_UNDO,TRUE);
    363                 if(!LOUSHORT(ret))
    364                   strcpy(lbl,GetPString(IDS_REDOTEXT));
    365                 switch(HIUSHORT(ret)) {
    366                   case WM_CHAR:
    367                     strcat(lbl,GetPString(IDS_KEYSTROKEMENUTEXT));
    368                     break;
    369                   case MLM_CUT:
    370                     strcat(lbl,GetPString(IDS_CUTTOCLIPMENUTEXT));
    371                     break;
    372                   case MLM_CLEAR:
    373                     strcat(lbl,GetPString(IDS_CLEARSELMENUTEXT));
    374                     break;
    375                   case MLM_PASTE:
    376                     strcat(lbl,GetPString(IDS_PASTEFROMCLIPMENUTEXT));
    377                     break;
    378                 }
    379                 WinSetMenuItemText((HWND)mp2,MLE_UNDO,lbl);
    380                 break;
    381               default:
    382                 WinEnableMenuItem((HWND)mp2,MLE_UNDO,FALSE);
    383                 break;
    384             }
    385           }
    386           break;
    387       }
    388       break;
    389 
    390     case UM_SETUP2:
    391       vw = WinQueryWindowPtr(hwnd,QWL_USER);
    392       if(vw) {
    393 
    394         CHAR s[CCHMAXPATH + 8];
    395 
    396         sprintf(s,
    397                 "%s: %s",
    398                 FM2Str,
    399                 (*vw->exportfilename) ?
    400                  vw->exportfilename :
    401                  GetPString(IDS_UNTITLEDTEXT));
    402         WinSetWindowText(WinQueryWindow(hwnd,
    403                                         QW_PARENT),
    404                          s);
    405         if(WinQueryWindow(hwnd,QW_PARENT) ==
    406            WinQueryActiveWindow(WinQueryWindow(WinQueryWindow(hwnd,
    407                                                               QW_PARENT),
    408                                 QW_PARENT)) &&
    409            !ParentIsDesktop(WinQueryWindow(hwnd,QW_PARENT),(HWND)0)) {
    410           if(hwndStatus2)
    411             WinSetWindowText(hwndStatus2,
    412                              (*vw->exportfilename) ?
    413                               vw->exportfilename :
    414                               GetPString(IDS_UNTITLEDTEXT));
    415           if(fMoreButtons) {
    416             WinSetWindowText(hwndName,
    417                              (*vw->exportfilename) ?
    418                               vw->exportfilename :
    419                               GetPString(IDS_UNTITLEDTEXT));
    420             WinSetWindowText(hwndDate,NullStr);
    421             WinSetWindowText(hwndAttr,NullStr);
    422           }
    423           if(hwndStatus)
    424             WinSetWindowText(hwndStatus,
    425                              GetPString(IDS_INTERNALVIEWEREDITORTITLETEXT));
    426         }
    427       }
    428       return 0;
    429 
    430     case UM_SETUP:
    431       vw = WinQueryWindowPtr(hwnd,QWL_USER);
    432       if(vw) {
    433         vw->hab = WinQueryAnchorBlock(hwnd);
    434         WinSendMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    435         /* set up initial MLE conditions */
    436         vw->srch.hwndmle = hwndMLE;
    437         MLEsetcurpos(hwndMLE,0L);
    438         MLEclearall(hwndMLE);
    439         MLEsetlimit(hwndMLE,-1L);
    440         MLEsetformat(hwndMLE,MLFIE_NOTRANS);
    441         WinSetSysValue(HWND_DESKTOP,SV_INSERTMODE,TRUE);
    442         vw->fWrap = TRUE;
    443         vw->fStripTrail = TRUE;
    444         vw->fStripTrailLines = TRUE;
    445         vw->srch.fInsensitive = TRUE;
    446         vw->ExpandTabs = 4;
    447         vw->TabStops = 32;
    448         {
    449           ULONG size;
    450 
    451           size = sizeof(BOOL);
    452           PrfQueryProfileData(fmprof,
    453                               FM3Str,
    454                               "MLEWrap",
    455                               (PVOID)&vw->fWrap,
    456                               &size);
    457           size = sizeof(BOOL);
    458           PrfQueryProfileData(fmprof,
    459                               FM3Str,
    460                               "MLEstriptrail",
    461                               (PVOID)&vw->fStripTrail,
    462                               &size);
    463           size = sizeof(BOOL);
    464           PrfQueryProfileData(fmprof,
    465                               FM3Str,
    466                               "MLEstriptraillines",
    467                               (PVOID)&vw->fStripTrailLines,
    468                               &size);
    469           size = sizeof(BOOL);
    470           PrfQueryProfileData(fmprof,
    471                               FM3Str,
    472                               "MLEInsensitve",
    473                               (PVOID)&vw->srch.fInsensitive,
    474                               &size);
    475           size = sizeof(INT);
    476           PrfQueryProfileData(fmprof,
    477                               FM3Str,
    478                               "MLEExpandTabs",
    479                               (PVOID)&vw->ExpandTabs,
    480                               &size);
    481           size = sizeof(INT);
    482           PrfQueryProfileData(fmprof,
    483                               FM3Str,
    484                               "MLETabStops",
    485                               (PVOID)&vw->TabStops,
    486                               &size);
    487         }
    488         vw->accel = WinQueryAccelTable(vw->hab,
    489                                        WinQueryWindow(hwnd,QW_PARENT));
    490         vw->hwndMenu = WinWindowFromID(WinQueryWindow(hwnd,QW_PARENT),
    491                                        FID_MENU);
    492         vw->ch = FALSE;
    493         MLEsetchanged(hwndMLE,FALSE);
    494         {
    495           MRESULT ret = 0;
    496 
    497           if(vw->hwndMenu) {
    498             SetMenuCheck(vw->hwndMenu,
    499                          MLE_TOGWRAP,
    500                          &vw->fWrap,
    501                          FALSE,
    502                          NULL);
    503             SetMenuCheck(vw->hwndMenu,
    504                          MLE_STRIPTRAILBLANKS,
    505                          &vw->fStripTrail,
    506                          FALSE,
    507                          NULL);
    508             SetMenuCheck(vw->hwndMenu,
    509                          MLE_STRIPTRAILLINES,
    510                          &vw->fStripTrailLines,
    511                          FALSE,
    512                          NULL);
    513             {
    514               BOOL tempbool = (vw->ExpandTabs != 0);
    515 
    516               SetMenuCheck(vw->hwndMenu,
    517                            MLE_EXPANDTABS,
    518                            &tempbool,
    519                            FALSE,
    520                            NULL);
    521             }
    522             SetMenuCheck(vw->hwndMenu,
    523                          MLE_SENSITIVE,
    524                          &vw->srch.fInsensitive,
    525                          FALSE,
    526                          NULL);
    527           }
    528           MLEsetwrap(hwndMLE,vw->fWrap);
    529           {
    530             ULONG CpList[2];
    531             ULONG CpSize;
    532 
    533             if(!DosQueryCp(sizeof(CpList),
    534                            CpList,
    535                            &CpSize) &&
    536                CpSize)
    537               vw->cp = CpList[0];
    538           }
    539           {
    540             ULONG size = sizeof(FATTRS),cps[50],len,x;
    541             HMQ hmq;
    542 
    543             if(!PrfQueryProfileData(fmprof,
    544                                     FM3Str,
    545                                     "MLEFont",
    546                                     &vw->fattrs,
    547                &size) || size != sizeof(FATTRS)) {
    548               vw->fattrs.usRecordLength = sizeof(FATTRS);
    549               vw->fattrs.lMaxBaselineExt = 16;
    550               vw->fattrs.lAveCharWidth   = 8;
    551               strcpy(vw->fattrs.szFacename,
    552                      GetPString(IDS_SYSMONOTEXT));
    553               vw->fattrs.usCodePage = (USHORT)vw->cp;
    554             }
    555             else
    556               vw->cp = vw->fattrs.usCodePage;
    557             if(!DosQueryCp(sizeof(cps),
    558                            cps,
    559                            &len)) {
    560               for(x = 0;x < len / sizeof(ULONG);x++) {
    561                 if(cps[x] == (ULONG)vw->cp) {
    562                   hmq = WinQueryWindowULong(hwnd,
    563                                             QWL_HMQ);
    564                   WinSetCp(hmq,vw->cp);
    565                   break;
    566                 }
    567               }
    568             }
    569             DosSetProcessCp(vw->cp);
    570             WinSendMsg(hwndMLE,
    571                        MLM_SETFONT,
    572                        MPFROMP(&vw->fattrs),
    573                        MPVOID);
    574           }
    575           if(Firsttime) {
    576 
    577             ULONG size;
    578 
    579             Firsttime = FALSE;
    580             size = sizeof(ULONG);
    581             PrfQueryProfileData(fmprof,
    582                                 FM3Str,
    583                                 "MLEBackgroundcolor",
    584                                 &Colors[COLORS_BACKGROUND],
    585                                 &size);
    586             size = sizeof(ULONG);
    587             PrfQueryProfileData(fmprof,
    588                                 FM3Str,
    589                                 "MLEForegroundcolor",
    590                                 &Colors[COLORS_FOREGROUND],
    591                                 &size);
    592           }
    593           WinSendMsg(hwndMLE,
    594                      MLM_SETBACKCOLOR,
    595                      MPFROMLONG(standardcolors[Colors[COLORS_BACKGROUND]]),
    596                      MPVOID);
    597           WinSendMsg(hwndMLE,
    598                      MLM_SETTEXTCOLOR,
    599                      MPFROMLONG(standardcolors[Colors[COLORS_FOREGROUND]]),
    600                      MPVOID);
    601           if(*vw->exportfilename)
    602             if(MLEbackgroundload(hwnd,
    603                                  UM_CONTAINER_FILLED,
    604                                  hwndMLE,
    605                                  vw->exportfilename,vw->hex) !=
    606                -1) {
    607               vw->busy = TRUE;
    608               WinEnableWindow(vw->hwndMenu,
    609                               FALSE);
    610             }
    611           if(vw->busy || MLEgetreadonly(hwndMLE)) {
    612             disable_menuitem(vw->hwndMenu,
    613                              MLE_FILEMENU,
    614                              TRUE);
    615             disable_menuitem(vw->hwndMenu,
    616                              MLE_CUTCLIP,
    617                              TRUE);
    618             disable_menuitem(vw->hwndMenu,
    619                              MLE_PASTECLIP,
    620                              TRUE);
    621             disable_menuitem(vw->hwndMenu,
    622                              MLE_CLEAR,
    623                              TRUE);
    624             disable_menuitem(vw->hwndMenu,
    625                              MLE_CUTLINE,
    626                              TRUE);
    627             disable_menuitem(vw->hwndMenu,
    628                              MLE_BLOCKMENU,
    629                              TRUE);
    630           }
    631           return ret;
    632         }
    633       }
    634       return 0;
    635 
    636     case UM_CONTAINER_FILLED: /* file was loaded */
    637       WinEnableWindow(vw->hwndMenu,
    638                       TRUE);
    639       vw->busy = FALSE;
    640       if(vw->killme) {
    641         PostMsg(hwnd,
    642                 WM_CLOSE,
    643                 MPVOID,
    644                 MPVOID);
    645         return 0;
    646       }
    647       if(!MLEgetreadonly(hwndMLE)) {
    648         disable_menuitem(vw->hwndMenu,
    649                          MLE_FILEMENU,
    650                          FALSE);
    651         disable_menuitem(vw->hwndMenu,
    652                          MLE_CUTCLIP,
    653                          FALSE);
    654         disable_menuitem(vw->hwndMenu,
    655                          MLE_PASTECLIP,
    656                          FALSE);
    657         disable_menuitem(vw->hwndMenu,
    658                          MLE_CLEAR,
    659                          FALSE);
    660         disable_menuitem(vw->hwndMenu,
    661                          MLE_CUTLINE,
    662                          FALSE);
    663         disable_menuitem(vw->hwndMenu,
    664                          MLE_BLOCKMENU,
    665                          FALSE);
    666       }
    667       if(mp1) {
    668         if(mp2) {
    669           vw->ch = FALSE;
    670           strcpy(vw->exportfilename,(CHAR *)mp2);
    671         }
    672       }
    673       else {
    674         vw->ch = FALSE;
    675         *vw->exportfilename = 0;
    676       }
    677       WinSendMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    678       return 0;
    679 
    680     case WM_SIZE:
    681       WinSetWindowPos(hwndMLE,
    682                       HWND_TOP,
    683                       0,
    684                       0,
    685                       SHORT1FROMMP(mp2),
    686                       SHORT2FROMMP(mp2),
    687                       SWP_MOVE | SWP_SIZE);
    688       break;
    689 
    690     case UM_SELECT:
    691     case WM_SETFOCUS:       /* sling focus to MLE */
    692       if(mp2) {
    693         if(hwndMain && fAutoView)
    694           PostMsg(hwndMain,
    695                   UM_LOADFILE,
    696                   MPVOID,
    697                   MPVOID);
    698         WinSendMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    699         if(msg != UM_SELECT)
    700           PostMsg(hwnd,
    701                   UM_FOCUSME,
    702                   MPVOID,
    703                   MPVOID);
    704       }
    705       if(msg == WM_SETFOCUS)
    706         break;
    707       return 0;
    708 
    709     case UM_FOCUSME:
    710       WinSetFocus(HWND_DESKTOP, hwndMLE);
    711       return 0;
    712 
    713     case WM_ERASEBACKGROUND:
    714       WinFillRect((HPS)mp1,(PRECTL)mp2,0x00d0d0d0);
    715       return 0;
    716 
    717     case WM_PAINT:
     750        /* I dunno why I gotta reset the colors... */
     751        BOOL ro;
     752        LONG fColor, bColor;
     753
     754        fColor = (LONG) WinSendMsg(hwndMLE,
     755                                   MLM_QUERYTEXTCOLOR, MPVOID, MPVOID);
     756        bColor = (LONG) WinSendMsg(hwndMLE,
     757                                   MLM_QUERYBACKCOLOR, MPVOID, MPVOID);
     758        ro = MLEgetreadonly(hwndMLE);
     759        ro = (ro) ? FALSE : TRUE;
     760        MLEsetreadonly(hwndMLE, ro);
     761        disable_menuitem(vw->hwndMenu, MLE_FILEMENU, ro);
     762        disable_menuitem(vw->hwndMenu, MLE_CUTCLIP, ro);
     763        disable_menuitem(vw->hwndMenu, MLE_PASTECLIP, ro);
     764        disable_menuitem(vw->hwndMenu, MLE_CLEAR, ro);
     765        disable_menuitem(vw->hwndMenu, MLE_CUTLINE, ro);
     766        disable_menuitem(vw->hwndMenu, MLE_BLOCKMENU, ro);
     767        WinSendMsg(hwndMLE, MLM_SETTEXTCOLOR, MPFROMLONG(fColor), MPVOID);
     768        WinSendMsg(hwndMLE, MLM_SETBACKCOLOR, MPFROMLONG(bColor), MPVOID);
     769      }
     770      break;
     771
     772    case IDM_RENAME:
     773    case MLE_SETEXPORTFILE:
     774      if (vw && !MLEgetreadonly(hwndMLE)) {
     775
     776        CHAR filename[1027];
     777
     778        strcpy(filename, vw->exportfilename);
     779        if (export_filename(hwnd, filename, 1)) {
     780          if (stricmp(filename, vw->exportfilename)) {
     781            vw->ch = TRUE;
     782            MLEsetchanged(hwndMLE, TRUE);
     783            strcpy(vw->exportfilename, filename);
     784            WinSendMsg(hwnd, UM_SETUP2, MPVOID, MPVOID);
     785          }
     786        }
     787      }
     788      break;
     789
     790    case MLE_EXPORTFILE:
     791      if (!MLEgetreadonly(hwndMLE)) {
     792
     793        LONG oldsize;
     794
     795        if (!*vw->exportfilename ||
     796            strchr(vw->exportfilename, '?') ||
     797            strchr(vw->exportfilename, '*')) {
     798          WinSendMsg(hwnd,
     799                     WM_COMMAND, MPFROM2SHORT(MLE_SETEXPORTFILE, 0), MPVOID);
     800          if (!*vw->exportfilename ||
     801              strchr(vw->exportfilename, '?') ||
     802              strchr(vw->exportfilename, '*'))
     803            break;
     804        }
     805        {
     806          /* zero file length instead of unlink (protects EAs from loss) */
     807          FILE *fp;
     808
     809          fp = xfopen(vw->exportfilename, "r+", pszSrcFile, __LINE__);
     810          if (fp) {
     811            oldsize = filelength(fileno(fp));
     812            DosSetFileSize(fileno(fp), 0L);
     813            fclose(fp);
     814          }
     815        }
     816        if (!MLEexportfile(hwndMLE,
     817                           vw->exportfilename,
     818                           vw->ExpandTabs,
     819                           vw->fStripTrailLines, vw->fStripTrail)) {
     820          FILE *fp;
     821
     822          Runtime_Error(pszSrcFile, __LINE__, "MLEexportfile");
     823          fp = xfopen(vw->exportfilename, "r+", pszSrcFile, __LINE__);
     824          if (fp) {
     825            DosSetFileSize(fileno(fp), oldsize);
     826            fclose(fp);
     827          }
     828        }
     829        else {
     830          vw->ch = FALSE;
     831          MLEsetchanged(hwndMLE, FALSE);
     832        }
     833      }
     834      break;
     835
     836    case IDM_EDIT:
     837    case IDM_VIEW:
     838    case MLE_LOADFILE:
     839      if (vw->ch && !MLEgetreadonly(hwndMLE)) {
     840
     841        APIRET temp;
     842
     843        temp = saymsg(MB_YESNO, hwnd, NullStr, GetPString(IDS_LOADOVERTEXT));
     844        if (temp != MBID_YES)
     845          break;
     846      }
     847      /* intentional fallthru */
     848    case MLE_INSERTFILE:
     849      if (!MLEgetreadonly(hwndMLE)) {
     850
     851        CHAR filename[1027];
     852
     853        strcpy(filename, vw->importfilename);
     854        if (insert_filename(hwnd,
     855                            filename,
     856                            (SHORT1FROMMP(mp1) == MLE_INSERTFILE) ?
     857                            FALSE : TRUE, FALSE)) {
     858          strcpy(vw->importfilename, filename);
     859          if (SHORT1FROMMP(mp1) == MLE_INSERTFILE)
     860            MLEinsertfile(hwndMLE, filename);
     861          else {
     862//                switch_to(filename);
     863            if (MLEbackgroundload(hwnd,
     864                                  UM_CONTAINER_FILLED,
     865                                  hwndMLE, filename, vw->hex) != -1) {
     866              vw->busy = TRUE;
     867              WinEnableWindow(vw->hwndMenu, FALSE);
     868            }
     869          }
     870        }
     871      }
     872      break;
     873
     874    case MLE_STRIPTRAILBLANKS:
     875      SetMenuCheck(vw->hwndMenu,
     876                   MLE_STRIPTRAILBLANKS,
     877                   &vw->fStripTrail, TRUE, "MLEstriptrail");
     878      break;
     879
     880    case MLE_STRIPTRAILLINES:
     881      SetMenuCheck(vw->hwndMenu,
     882                   MLE_STRIPTRAILLINES,
     883                   &vw->fStripTrailLines, TRUE, "MLEstriptraillines");
     884      break;
     885
     886    case MLE_TAB:
    718887      {
    719         RECTL rcl;
    720         HPS hps;
    721 
    722         hps = WinBeginPaint(hwnd,(HPS)0,NULL);
    723         WinQueryWindowRect(hwnd,&rcl);
    724         WinFillRect(hps,&rcl,CLR_PALEGRAY);
    725         WinEndPaint(hps);
    726       }
    727       break;
    728 
    729     case UM_LOADFILE:
    730       if((CHAR *)mp1) {
    731 //        switch_to(mp1);
    732         if(MLEbackgroundload(hwnd,
    733                              UM_CONTAINER_FILLED,
    734                              hwndMLE,
    735                              (CHAR *)mp1,
    736                              vw->hex) !=
    737            -1) {
    738           vw->busy = TRUE;
    739           WinEnableWindow(vw->hwndMenu,
    740                           FALSE);
    741         }
    742       }
    743       return 0;
    744 
    745     case WM_CONTROL:
    746       switch(SHORT1FROMMP(mp1)) {
    747         case MLE_MLE:
    748           switch(SHORT2FROMMP(mp1)) {
    749             case MLN_CHANGE:
    750               if(!vw->ch)
    751                 vw->ch = TRUE;
    752               break;
    753           }
    754           break;
    755       }
    756       return 0;
    757 
    758     case WM_COMMAND:
    759       if(vw->busy && SHORT1FROMMP(mp1) != MLE_QUIT) {
    760         DosBeep(50,100);
    761         return 0;
    762       }
    763       switch(SHORT1FROMMP(mp1)) {
    764         /*
    765         case MLE_PREVIEW:
    766           preview_text(hwndMLE);
    767           break;
    768         */
    769         case MLE_VIEWFTP:
    770           MLEinternet(hwndMLE,TRUE);
    771           break;
    772 
    773         case MLE_VIEWHTTP:
    774           MLEinternet(hwndMLE,FALSE);
    775           break;
    776 
    777         case IDM_NEXTWINDOW:
    778           WinSendMsg(hwndMLE,
    779                      WM_CHAR,
    780                      MPFROM2SHORT((KC_CHAR | KC_VIRTUALKEY),
    781                                   MAKEUSHORT(1,9)),
    782                      MPFROM2SHORT(9,VK_TAB));
    783           break;
    784 
    785         case IDM_COLORPALETTE:
    786           {
    787             COLORS co;
    788             LONG   temp[COLORS_MAX];
    789 
    790             memset(&co,0,sizeof(co));
    791             co.size = sizeof(co);
    792             co.numcolors = COLORS_MAX;
    793             co.colors = Colors;
    794             co.descriptions = IDS_EDCOLORS1TEXT;
    795             co.origs = temp;
    796             co.prompt = IDS_EDCOLORSPROMPTTEXT;
    797             memcpy(temp,
    798                    Colors,
    799                    sizeof(LONG) * COLORS_MAX);
    800             if(WinDlgBox(HWND_DESKTOP,
    801                          hwnd,
    802                          ColorDlgProc,
    803                          FM3ModHandle,
    804                          COLOR_FRAME,
    805                          (PVOID)&co)) {
    806               WinSendMsg(hwndMLE,
    807                          MLM_SETTEXTCOLOR,
    808                          MPFROMLONG(standardcolors[Colors[COLORS_FOREGROUND]]),
    809                          MPVOID);
    810               PrfWriteProfileData(fmprof,
    811                                   FM3Str,
    812                                   "MLEForegroundcolor",
    813                                   &Colors[COLORS_FOREGROUND],
    814                                   sizeof(LONG));
    815               WinSendMsg(hwndMLE,
    816                          MLM_SETBACKCOLOR,
    817                          MPFROMLONG(standardcolors[Colors[COLORS_BACKGROUND]]),
    818                          MPVOID);
    819               PrfWriteProfileData(fmprof,
    820                                   FM3Str,
    821                                   "MLEBackgroundcolor",
    822                                   &Colors[COLORS_BACKGROUND],
    823                                   sizeof(LONG));
    824             }
    825           }
    826           break;
    827 
    828         case IDM_HELP:
    829           if(hwndHelp)
    830             WinSendMsg(hwndHelp,HM_DISPLAY_HELP,
    831                        MPFROM2SHORT(HELP_EDITOR,0),
    832                        MPFROMSHORT(HM_RESOURCEID));
    833           break;
    834 
    835         case MLE_CODEPAGE:
    836           vw->cp = PickCodepage(hwnd);
    837           vw->fattrs.usCodePage = (USHORT)vw->cp;
    838           WinSendMsg(hwndMLE,
    839                      MLM_SETFONT,
    840                      MPFROMP(&vw->fattrs),
    841                      MPVOID);
    842           PrfWriteProfileData(fmprof,
    843                               FM3Str,
    844                               "MLEFont",
    845                               &vw->fattrs,
    846                               sizeof(FATTRS));
    847           break;
    848 
    849         case MLE_NEWFILE:
    850           if(!MLEgetreadonly(hwndMLE)) {
    851             if(vw->ch) {
    852 
    853               APIRET temp;
    854 
    855               temp = saymsg(MB_YESNOCANCEL | MB_ICONEXCLAMATION,
    856                             hwnd,
    857                             NullStr,
    858                             GetPString(IDS_SAVECHANGESTEXT));
    859               if(temp == MBID_CANCEL)
    860                 break;
    861               if(temp == MBID_YES)
    862                 WinSendMsg(hwnd,
    863                            WM_COMMAND,
    864                            MPFROM2SHORT(MLE_EXPORTFILE,0),
    865                            MPVOID);
    866             }
    867             MLEclearall(hwndMLE);
    868             *vw->exportfilename = 0;
    869             vw->ch = FALSE;
    870             MLEsetchanged(hwndMLE,
    871                           FALSE);
    872             WinSendMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    873           }
    874           break;
    875 
    876         case MLE_TOGGLEREADONLY:
    877           if (vw->busy || vw->hex == 1) {
    878             DosBeep(50,100);
    879           }
    880           else {
    881             /* I dunno why I gotta reset the colors... */
    882             BOOL ro;
    883             LONG fColor,bColor;
    884 
    885             fColor = (LONG)WinSendMsg(hwndMLE,
    886                                       MLM_QUERYTEXTCOLOR,
    887                                       MPVOID,
    888                                       MPVOID);
    889             bColor = (LONG)WinSendMsg(hwndMLE,
    890                                       MLM_QUERYBACKCOLOR,
    891                                       MPVOID,
    892                                       MPVOID);
    893             ro = MLEgetreadonly(hwndMLE);
    894             ro = (ro) ? FALSE : TRUE;
    895             MLEsetreadonly(hwndMLE,ro);
    896             disable_menuitem(vw->hwndMenu,
    897                              MLE_FILEMENU,
    898                              ro);
    899             disable_menuitem(vw->hwndMenu,
    900                              MLE_CUTCLIP,
    901                              ro);
    902             disable_menuitem(vw->hwndMenu,
    903                              MLE_PASTECLIP,
    904                              ro);
    905             disable_menuitem(vw->hwndMenu,
    906                              MLE_CLEAR,
    907                              ro);
    908             disable_menuitem(vw->hwndMenu,
    909                              MLE_CUTLINE,
    910                              ro);
    911             disable_menuitem(vw->hwndMenu,
    912                              MLE_BLOCKMENU,
    913                              ro);
    914             WinSendMsg(hwndMLE,
    915                        MLM_SETTEXTCOLOR,
    916                        MPFROMLONG(fColor),
    917                        MPVOID);
    918             WinSendMsg(hwndMLE,
    919                        MLM_SETBACKCOLOR,
    920                        MPFROMLONG(bColor),
    921                        MPVOID);
    922           }
    923           break;
    924 
    925         case IDM_RENAME:
    926         case MLE_SETEXPORTFILE:
    927           if(vw && !MLEgetreadonly(hwndMLE)) {
    928 
    929             CHAR filename[1027];
    930 
    931             strcpy(filename,vw->exportfilename);
    932             if(export_filename(hwnd,filename,1)) {
    933               if(stricmp(filename,vw->exportfilename)) {
    934                 vw->ch = TRUE;
    935                 MLEsetchanged(hwndMLE,TRUE);
    936                 strcpy(vw->exportfilename,filename);
    937                 WinSendMsg(hwnd,UM_SETUP2,MPVOID,MPVOID);
    938               }
    939             }
    940           }
    941           break;
    942 
    943         case MLE_EXPORTFILE:
    944           if(!MLEgetreadonly(hwndMLE)) {
    945 
    946             LONG oldsize;
    947 
    948             if(!*vw->exportfilename ||
    949                strchr(vw->exportfilename,'?') ||
    950                strchr(vw->exportfilename,'*')) {
    951               WinSendMsg(hwnd,
    952                          WM_COMMAND,
    953                          MPFROM2SHORT(MLE_SETEXPORTFILE,0),
    954                          MPVOID);
    955               if(!*vw->exportfilename ||
    956                  strchr(vw->exportfilename,'?') ||
    957                  strchr(vw->exportfilename,'*'))
    958                 break;
    959             }
    960             {
    961               /* zero file length instead of unlink (protects EAs from loss) */
    962               FILE *fp;
    963 
    964               fp = xfopen(vw->exportfilename,"r+",pszSrcFile,__LINE__);
    965               if (fp) {
    966                 oldsize = filelength(fileno(fp));
    967                 DosSetFileSize(fileno(fp),0L);
    968                 fclose(fp);
    969               }
    970             }
    971             if (!MLEexportfile(hwndMLE,
    972                               vw->exportfilename,
    973                               vw->ExpandTabs,
    974                               vw->fStripTrailLines,
    975                               vw->fStripTrail)) {
    976               FILE *fp;
    977               Runtime_Error(pszSrcFile, __LINE__, "MLEexportfile");
    978               fp = xfopen(vw->exportfilename,"r+",pszSrcFile,__LINE__);
    979               if (fp) {
    980                 DosSetFileSize(fileno(fp),oldsize);
    981                 fclose(fp);
    982               }
    983             }
    984             else {
    985               vw->ch = FALSE;
    986               MLEsetchanged(hwndMLE,FALSE);
    987             }
    988           }
    989           break;
    990 
    991         case IDM_EDIT:
    992         case IDM_VIEW:
    993         case MLE_LOADFILE:
    994           if(vw->ch && !MLEgetreadonly(hwndMLE)) {
    995 
    996             APIRET temp;
    997 
    998             temp = saymsg(MB_YESNO,
    999                           hwnd,
    1000                           NullStr,
    1001                           GetPString(IDS_LOADOVERTEXT));
    1002             if(temp != MBID_YES)
    1003               break;
    1004           }
    1005           /* intentional fallthru */
    1006         case MLE_INSERTFILE:
    1007           if(!MLEgetreadonly(hwndMLE)) {
    1008 
    1009             CHAR filename[1027];
    1010 
    1011             strcpy(filename,vw->importfilename);
    1012             if(insert_filename(hwnd,
    1013                                filename,
    1014                                (SHORT1FROMMP(mp1) == MLE_INSERTFILE) ?
    1015                                 FALSE :
    1016                                 TRUE,
    1017                                FALSE)) {
    1018               strcpy(vw->importfilename,filename);
    1019               if(SHORT1FROMMP(mp1) == MLE_INSERTFILE)
    1020                 MLEinsertfile(hwndMLE,filename);
    1021               else {
    1022 //                switch_to(filename);
    1023                 if(MLEbackgroundload(hwnd,
    1024                                      UM_CONTAINER_FILLED,
    1025                                      hwndMLE,
    1026                                      filename,
    1027                                      vw->hex) !=
    1028                    -1) {
    1029                   vw->busy = TRUE;
    1030                   WinEnableWindow(vw->hwndMenu,
    1031                                   FALSE);
    1032                 }
    1033               }
    1034             }
    1035           }
    1036           break;
    1037 
    1038         case MLE_STRIPTRAILBLANKS:
    1039           SetMenuCheck(vw->hwndMenu,
    1040                        MLE_STRIPTRAILBLANKS,
    1041                        &vw->fStripTrail,
    1042                        TRUE,
    1043                        "MLEstriptrail");
    1044           break;
    1045 
    1046         case MLE_STRIPTRAILLINES:
    1047           SetMenuCheck(vw->hwndMenu,
    1048                        MLE_STRIPTRAILLINES,
    1049                        &vw->fStripTrailLines,
    1050                        TRUE,
    1051                        "MLEstriptraillines");
    1052           break;
    1053 
    1054         case MLE_TAB:
    1055           {
    1056             STRINGINPARMS sip;
    1057             CHAR s[35];
    1058 
    1059             sip.help = GetPString(IDS_TABSTOPHELPTEXT);
    1060             sip.ret = s;
    1061             sprintf(s,
    1062                     "%u",
    1063                     vw->TabStops);
    1064             sip.prompt = GetPString(IDS_TABSTOPPROMPTTEXT);
    1065             sip.inputlen = 34;
    1066             sip.title = GetPString(IDS_TABSTOPTITLETEXT);
    1067             WinDlgBox(HWND_DESKTOP,
    1068                       hwnd,
    1069                       InputDlgProc,
    1070                       FM3ModHandle,
    1071                       STR_FRAME,
    1072                       &sip);
    1073             if(*s && atoi(s) > -1 && atoi(s) < 512) {
    1074               vw->TabStops = atoi(s);
    1075               WinSendMsg(hwndMLE,
    1076                          MLM_SETTABSTOP,
    1077                          MPFROMLONG(vw->TabStops),
    1078                          MPVOID);
    1079               PrfWriteProfileData(fmprof,
    1080                                   FM3Str,
    1081                                   "MLETabStops",
    1082                                   &vw->TabStops,
    1083                                   sizeof(INT));
    1084             }
    1085           }
    1086           break;
    1087 
    1088         case MLE_EXPANDTABS:
    1089           {
    1090             BOOL          tempbool;
    1091             STRINGINPARMS sip;
    1092             CHAR          s[35];
    1093 
    1094             sip.help = GetPString(IDS_EXTABHELPTEXT);
    1095             sip.ret = s;
    1096             sprintf(s,
    1097                     "%u",
    1098                     vw->ExpandTabs);
    1099             sip.prompt = GetPString(IDS_EXTABPROMPTTEXT);
    1100             sip.inputlen = 34;
    1101             sip.title = GetPString(IDS_EXTABTITLETEXT);
    1102             WinDlgBox(HWND_DESKTOP,
    1103                       hwnd,
    1104                       InputDlgProc,
    1105                       FM3ModHandle,
    1106                       STR_FRAME,
    1107                       &sip);
    1108             if(*s && atoi(s) > -1 && atoi(s) < 33) {
    1109               vw->ExpandTabs = atoi(s);
    1110               tempbool = (vw->ExpandTabs != 0);
    1111               SetMenuCheck(vw->hwndMenu,
    1112                            MLE_EXPANDTABS,
    1113                            &tempbool,
    1114                            FALSE,
    1115                            NULL);
    1116               PrfWriteProfileData(fmprof,
    1117                                   FM3Str,
    1118                                   "MLEExpandTabs",
    1119                                   &vw->ExpandTabs,
    1120                                   sizeof(INT));
    1121             }
    1122           }
    1123           break;
    1124 
    1125         case MLE_APPENDCLIP:
    1126           MLEdoblock(hwndMLE,
    1127                      APPENDCLIP,
    1128                      NULL);
    1129           break;
    1130 
    1131         case MLE_WRITEBLOCK:
    1132           {
    1133             CHAR filename[1027];
    1134 
    1135             strcpy(filename,vw->exportfilename);
    1136             if(export_filename(hwnd,filename,1))
    1137               MLEdoblock(hwndMLE,
    1138                          WRITE,
    1139                          filename);
    1140           }
    1141           break;
    1142 
    1143         case MLE_FORMAT:
    1144           if(!MLEgetreadonly(hwndMLE))
    1145             MLEdoblock(hwndMLE,
    1146                        FORMAT,
    1147                        NULL);
    1148           break;
    1149 
    1150         case MLE_XOR:
    1151           if(!MLEgetreadonly(hwndMLE))
    1152             MLEdoblock(hwndMLE,
    1153                        XOR,
    1154                        NULL);
    1155           break;
    1156 
    1157         case MLE_ROT13:
    1158           if(!MLEgetreadonly(hwndMLE))
    1159             MLEdoblock(hwndMLE,
    1160                        ROT13,
    1161                        NULL);
    1162           break;
    1163 
    1164         case MLE_UPPERCASE:
    1165           if(!MLEgetreadonly(hwndMLE))
    1166             MLEdoblock(hwndMLE,
    1167                        UPPERCASE,
    1168                        NULL);
    1169           break;
    1170 
    1171         case MLE_LOWERCASE:
    1172           if(!MLEgetreadonly(hwndMLE))
    1173             MLEdoblock(hwndMLE,
    1174                        LOWERCASE,
    1175                        NULL);
    1176           break;
    1177 
    1178         case MLE_TOGGLECASE:
    1179           if(!MLEgetreadonly(hwndMLE))
    1180             MLEdoblock(hwndMLE,
    1181                        TOGGLECASE,
    1182                        NULL);
    1183           break;
    1184 
    1185         case MLE_JUMP:
    1186           {
    1187             ULONG         numlines,linenum;
    1188             CHAR          s[35],ss[133];
    1189             STRINGINPARMS sip;
    1190 
    1191             sip.help = GetPString(IDS_NVLINEJUMPTEXT);
    1192             sip.ret = s;
    1193             *s = 0;
    1194             sip.prompt = ss;
    1195             sip.inputlen = 34;
    1196             sip.title = GetPString(IDS_NVLINEJUMPTITLETEXT);
    1197             numlines = MLEnumlines(hwndMLE);
    1198             if(!numlines)
    1199               DosBeep(50,100);
    1200             else {
    1201               sprintf(sip.prompt,
    1202                       GetPString(IDS_NVJUMPTEXT),
    1203                       GetPString(IDS_LINETEXT),
    1204                       1,
    1205                       numlines);
    1206               WinDlgBox(HWND_DESKTOP,
    1207                         hwnd,
    1208                         InputDlgProc,
    1209                         FM3ModHandle,
    1210                         STR_FRAME,
    1211                         &sip);
    1212               if (*s) {
    1213                 linenum = atol(s);
    1214                 if (linenum > 0 && linenum <= numlines) {
    1215                   MLEsettopline(hwndMLE,
    1216                                 MLEstartofline(hwndMLE,
    1217                                                linenum));
    1218                   MLEsetcurpos(hwndMLE,
    1219                                MLEstartofline(hwndMLE,
    1220                                               linenum));
    1221                 }
    1222               }
    1223             }
    1224           }
    1225           break;
    1226 
    1227         case MLE_CUTLINE:          /* delete current line */
    1228           if(!MLEgetreadonly(hwndMLE))
    1229             MLEdeletecurline(hwndMLE);
    1230           break;
    1231 
    1232         case IDM_DELETE:
    1233         case MLE_CLEAR:
    1234           if(!MLEgetreadonly(hwndMLE))
    1235             MLEclear(hwndMLE);
    1236           break;
    1237 
    1238         case DID_CANCEL:            /* escape */
    1239           if(MLEgetreadonly(hwndMLE))
    1240             PostMsg(hwnd,
    1241                     WM_CLOSE,
    1242                     MPVOID,
    1243                     MPVOID);
    1244           else
    1245             PostMsg(hwnd,
    1246                     WM_COMMAND,
    1247                     MPFROM2SHORT(MLE_DESELECTALL,0),
    1248                     MPVOID);
    1249           break;
    1250 
    1251         case MLE_QUIT:             /* outtahere */
    1252           MLEsetchanged(hwndMLE,
    1253                         FALSE);
    1254           vw->ch = FALSE;
    1255           /* intentional fallthru */
    1256         case MLE_END:
    1257           PostMsg(hwnd,
    1258                   WM_CLOSE,
    1259                   MPVOID,
    1260                   MPVOID);
    1261           break;
    1262 
    1263         case MLE_SETFONT:          /* select a new font */
    1264           SetMLEFont(hwndMLE,
    1265                      &vw->fattrs,
    1266                      0);
    1267           PrfWriteProfileData(fmprof,
    1268                               FM3Str,
    1269                               "MLEFont",
    1270                               &vw->fattrs,
    1271                               sizeof(FATTRS));
    1272           break;
    1273 
    1274         case MLE_SELECTALL:
    1275           MLEselectall(hwndMLE);
    1276           break;
    1277 
    1278         case MLE_DESELECTALL:
    1279           MLEsetcurpos(hwndMLE,
    1280                        MLEcurpos(hwndMLE));
    1281           break;
    1282 
    1283         case MLE_UNDO:
    1284           if(!MLEgetreadonly(hwndMLE))
    1285             MLEundo(hwndMLE);
    1286           break;
    1287 
    1288         case IDM_SAVETOCLIP:
    1289         case MLE_COPYCLIP:
    1290           MLEcopy(hwndMLE);
    1291           break;
    1292 
    1293         case MLE_CUTCLIP:
    1294           if(!MLEgetreadonly(hwndMLE))
    1295             MLEcut(hwndMLE);
    1296           break;
    1297 
    1298         case IDM_COLLECTFROMCLIP:
    1299         case MLE_PASTECLIP:
    1300           if(!MLEgetreadonly(hwndMLE))
    1301             MLEpaste(hwndMLE);
    1302           break;
    1303 
    1304         case MLE_SENSITIVE:
    1305           SetMenuCheck(vw->hwndMenu,
    1306                        MLE_SENSITIVE,
    1307                        &vw->srch.fInsensitive,
    1308                        TRUE,
    1309                        "MLEInsensitive");
    1310           break;
    1311 
    1312         case MLE_FINDFIRST:         /* search */
    1313           if(MLEfindfirst(hwnd,&vw->srch))
    1314             PostMsg(hwnd,
    1315                     WM_COMMAND,
    1316                     MPFROM2SHORT(MLE_FINDNEXT,0),
    1317                     MPVOID);
    1318           break;
    1319 
    1320         case IDM_GREP:
    1321         case MLE_FINDNEXT:
    1322           {
    1323             INT temp;
    1324 
    1325             temp = MLEfindnext(hwnd,&vw->srch);
    1326             if(temp < 0)
    1327               PostMsg(hwnd,
    1328                       WM_COMMAND,
    1329                       MPFROM2SHORT(MLE_FINDFIRST,0),
    1330                       MPVOID);
    1331             else if(temp > 0)
    1332               PostMsg(hwnd,
    1333                       WM_COMMAND,
    1334                       MPFROM2SHORT(MLE_FINDNEXT,0),
    1335                       MPVOID);
    1336           }
    1337           break;
    1338 
    1339         case MLE_TOGWRAP:     /* toggle wrap mode */
    1340           if(vw->hex != 1) {
    1341             SetMenuCheck(vw->hwndMenu,
    1342                          MLE_TOGWRAP,
    1343                          &vw->fWrap,
    1344                          TRUE,
    1345                          "MLEWrap");
    1346             MLEsetwrap(hwndMLE,
    1347                        vw->fWrap);
    1348           }
    1349           break;
    1350 
    1351         case IDM_ABOUT:
    1352         case MLE_ABOUT:
    1353           saymsg(MB_ENTER | MB_ICONASTERISK,
    1354                  hwnd,
    1355                  GetPString(IDS_VIEWABOUTTITLETEXT),
    1356                  GetPString(IDS_VIEWABOUTTEXT));
    1357           break;
    1358       }
    1359       return 0;
    1360 
    1361     case WM_SAVEAPPLICATION:
    1362       if(vw &&
    1363          ParentIsDesktop(hwnd,vw->hwndParent)) {
    1364 
    1365         SWP swp;
    1366 
    1367         WinQueryWindowPos(vw->hwndFrame,
    1368                           &swp);
    1369         if(!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
    1370           PrfWriteProfileData(fmprof,
    1371                               appname,
    1372                               "ViewSizePos",
    1373                               &swp,
    1374                               sizeof(swp));
    1375       }
    1376       break;
    1377 
    1378     case WM_CLOSE:    /* outtahere */
    1379       WinSendMsg(hwnd,
    1380                  WM_SAVEAPPLICATION,
    1381                  MPVOID,
    1382                  MPVOID);
    1383       if(vw) {
    1384         if(vw->busy) {
    1385           vw->killme = TRUE;
    1386           return 0;
    1387         }
    1388         if(vw->ch &&
    1389            !MLEgetreadonly(hwndMLE)) {
    1390 
    1391           APIRET temp;
    1392 
    1393           temp = saymsg(MB_YESNOCANCEL | MB_ICONEXCLAMATION,
    1394                         hwnd,
    1395                         NullStr,
    1396                         GetPString(IDS_SAVECHANGESTEXT));
    1397           if(temp == MBID_CANCEL)
    1398             return 0;
    1399           if(temp == MBID_YES)
    1400             WinSendMsg(hwnd,
    1401                        WM_COMMAND,
    1402                        MPFROM2SHORT(MLE_EXPORTFILE,0),
    1403                        MPVOID);
    1404         }
    1405       }
    1406       WinDestroyWindow(WinQueryWindow(hwnd,QW_PARENT));
    1407       return 0;
    1408 
    1409     case WM_DESTROY:
    1410        DosPostEventSem(CompactSem);
     888        STRINGINPARMS sip;
     889        CHAR s[35];
     890
     891        sip.help = GetPString(IDS_TABSTOPHELPTEXT);
     892        sip.ret = s;
     893        sprintf(s, "%u", vw->TabStops);
     894        sip.prompt = GetPString(IDS_TABSTOPPROMPTTEXT);
     895        sip.inputlen = 34;
     896        sip.title = GetPString(IDS_TABSTOPTITLETEXT);
     897        WinDlgBox(HWND_DESKTOP,
     898                  hwnd, InputDlgProc, FM3ModHandle, STR_FRAME, &sip);
     899        if (*s && atoi(s) > -1 && atoi(s) < 512) {
     900          vw->TabStops = atoi(s);
     901          WinSendMsg(hwndMLE,
     902                     MLM_SETTABSTOP, MPFROMLONG(vw->TabStops), MPVOID);
     903          PrfWriteProfileData(fmprof,
     904                              FM3Str,
     905                              "MLETabStops", &vw->TabStops, sizeof(INT));
     906        }
     907      }
     908      break;
     909
     910    case MLE_EXPANDTABS:
    1411911      {
    1412         BOOL dontclose = FALSE;
    1413 
    1414         if(vw) {
    1415           if(vw->hwndPopupMenu)
    1416             WinDestroyWindow(vw->hwndPopupMenu);
    1417           if(vw->accel)
    1418             WinDestroyAccelTable(vw->accel);
    1419           dontclose = vw->dontclose;
    1420           WinSetWindowPtr(hwnd,QWL_USER,NULL);
    1421           if(vw->hwndRestore) {
    1422 
    1423             ULONG fl = SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER;
    1424             SWP   swp;
    1425 
    1426             if(WinQueryWindowPos(vw->hwndRestore,
    1427                                  &swp)) {
    1428               if(!(swp.fl & SWP_MAXIMIZE))
    1429                 fl |= SWP_RESTORE;
    1430               WinSetWindowPos(vw->hwndRestore,
    1431                               HWND_TOP,
    1432                               0,
    1433                               0,
    1434                               0,
    1435                               0,
    1436                               fl);
    1437             }
    1438           }
    1439           free(vw);
    1440         }
    1441         if (!dontclose &&
    1442             ParentIsDesktop(hwnd,WinQueryWindow(WinQueryWindow(hwnd,
    1443                             QW_PARENT),QW_PARENT))) {
    1444           if (!PostMsg((HWND)0,WM_QUIT,MPVOID,MPVOID))
    1445             DosExit(EXIT_PROCESS,1);
    1446         }
    1447       }
    1448       break;
     912        BOOL tempbool;
     913        STRINGINPARMS sip;
     914        CHAR s[35];
     915
     916        sip.help = GetPString(IDS_EXTABHELPTEXT);
     917        sip.ret = s;
     918        sprintf(s, "%u", vw->ExpandTabs);
     919        sip.prompt = GetPString(IDS_EXTABPROMPTTEXT);
     920        sip.inputlen = 34;
     921        sip.title = GetPString(IDS_EXTABTITLETEXT);
     922        WinDlgBox(HWND_DESKTOP,
     923                  hwnd, InputDlgProc, FM3ModHandle, STR_FRAME, &sip);
     924        if (*s && atoi(s) > -1 && atoi(s) < 33) {
     925          vw->ExpandTabs = atoi(s);
     926          tempbool = (vw->ExpandTabs != 0);
     927          SetMenuCheck(vw->hwndMenu, MLE_EXPANDTABS, &tempbool, FALSE, NULL);
     928          PrfWriteProfileData(fmprof,
     929                              FM3Str,
     930                              "MLEExpandTabs", &vw->ExpandTabs, sizeof(INT));
     931        }
     932      }
     933      break;
     934
     935    case MLE_APPENDCLIP:
     936      MLEdoblock(hwndMLE, APPENDCLIP, NULL);
     937      break;
     938
     939    case MLE_WRITEBLOCK:
     940      {
     941        CHAR filename[1027];
     942
     943        strcpy(filename, vw->exportfilename);
     944        if (export_filename(hwnd, filename, 1))
     945          MLEdoblock(hwndMLE, WRITE, filename);
     946      }
     947      break;
     948
     949    case MLE_FORMAT:
     950      if (!MLEgetreadonly(hwndMLE))
     951        MLEdoblock(hwndMLE, FORMAT, NULL);
     952      break;
     953
     954    case MLE_XOR:
     955      if (!MLEgetreadonly(hwndMLE))
     956        MLEdoblock(hwndMLE, XOR, NULL);
     957      break;
     958
     959    case MLE_ROT13:
     960      if (!MLEgetreadonly(hwndMLE))
     961        MLEdoblock(hwndMLE, ROT13, NULL);
     962      break;
     963
     964    case MLE_UPPERCASE:
     965      if (!MLEgetreadonly(hwndMLE))
     966        MLEdoblock(hwndMLE, UPPERCASE, NULL);
     967      break;
     968
     969    case MLE_LOWERCASE:
     970      if (!MLEgetreadonly(hwndMLE))
     971        MLEdoblock(hwndMLE, LOWERCASE, NULL);
     972      break;
     973
     974    case MLE_TOGGLECASE:
     975      if (!MLEgetreadonly(hwndMLE))
     976        MLEdoblock(hwndMLE, TOGGLECASE, NULL);
     977      break;
     978
     979    case MLE_JUMP:
     980      {
     981        ULONG numlines, linenum;
     982        CHAR s[35], ss[133];
     983        STRINGINPARMS sip;
     984
     985        sip.help = GetPString(IDS_NVLINEJUMPTEXT);
     986        sip.ret = s;
     987        *s = 0;
     988        sip.prompt = ss;
     989        sip.inputlen = 34;
     990        sip.title = GetPString(IDS_NVLINEJUMPTITLETEXT);
     991        numlines = MLEnumlines(hwndMLE);
     992        if (!numlines)
     993          DosBeep(50, 100);
     994        else {
     995          sprintf(sip.prompt,
     996                  GetPString(IDS_NVJUMPTEXT),
     997                  GetPString(IDS_LINETEXT), 1, numlines);
     998          WinDlgBox(HWND_DESKTOP,
     999                    hwnd, InputDlgProc, FM3ModHandle, STR_FRAME, &sip);
     1000          if (*s) {
     1001            linenum = atol(s);
     1002            if (linenum > 0 && linenum <= numlines) {
     1003              MLEsettopline(hwndMLE, MLEstartofline(hwndMLE, linenum));
     1004              MLEsetcurpos(hwndMLE, MLEstartofline(hwndMLE, linenum));
     1005            }
     1006          }
     1007        }
     1008      }
     1009      break;
     1010
     1011    case MLE_CUTLINE:                   /* delete current line */
     1012      if (!MLEgetreadonly(hwndMLE))
     1013        MLEdeletecurline(hwndMLE);
     1014      break;
     1015
     1016    case IDM_DELETE:
     1017    case MLE_CLEAR:
     1018      if (!MLEgetreadonly(hwndMLE))
     1019        MLEclear(hwndMLE);
     1020      break;
     1021
     1022    case DID_CANCEL:                    /* escape */
     1023      if (MLEgetreadonly(hwndMLE))
     1024        PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1025      else
     1026        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MLE_DESELECTALL, 0), MPVOID);
     1027      break;
     1028
     1029    case MLE_QUIT:                      /* outtahere */
     1030      MLEsetchanged(hwndMLE, FALSE);
     1031      vw->ch = FALSE;
     1032      /* intentional fallthru */
     1033    case MLE_END:
     1034      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
     1035      break;
     1036
     1037    case MLE_SETFONT:                   /* select a new font */
     1038      SetMLEFont(hwndMLE, &vw->fattrs, 0);
     1039      PrfWriteProfileData(fmprof,
     1040                          FM3Str, "MLEFont", &vw->fattrs, sizeof(FATTRS));
     1041      break;
     1042
     1043    case MLE_SELECTALL:
     1044      MLEselectall(hwndMLE);
     1045      break;
     1046
     1047    case MLE_DESELECTALL:
     1048      MLEsetcurpos(hwndMLE, MLEcurpos(hwndMLE));
     1049      break;
     1050
     1051    case MLE_UNDO:
     1052      if (!MLEgetreadonly(hwndMLE))
     1053        MLEundo(hwndMLE);
     1054      break;
     1055
     1056    case IDM_SAVETOCLIP:
     1057    case MLE_COPYCLIP:
     1058      MLEcopy(hwndMLE);
     1059      break;
     1060
     1061    case MLE_CUTCLIP:
     1062      if (!MLEgetreadonly(hwndMLE))
     1063        MLEcut(hwndMLE);
     1064      break;
     1065
     1066    case IDM_COLLECTFROMCLIP:
     1067    case MLE_PASTECLIP:
     1068      if (!MLEgetreadonly(hwndMLE))
     1069        MLEpaste(hwndMLE);
     1070      break;
     1071
     1072    case MLE_SENSITIVE:
     1073      SetMenuCheck(vw->hwndMenu,
     1074                   MLE_SENSITIVE,
     1075                   &vw->srch.fInsensitive, TRUE, "MLEInsensitive");
     1076      break;
     1077
     1078    case MLE_FINDFIRST:         /* search */
     1079      if (MLEfindfirst(hwnd, &vw->srch))
     1080        PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MLE_FINDNEXT, 0), MPVOID);
     1081      break;
     1082
     1083    case IDM_GREP:
     1084    case MLE_FINDNEXT:
     1085      {
     1086        INT temp;
     1087
     1088        temp = MLEfindnext(hwnd, &vw->srch);
     1089        if (temp < 0)
     1090          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MLE_FINDFIRST, 0), MPVOID);
     1091        else if (temp > 0)
     1092          PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MLE_FINDNEXT, 0), MPVOID);
     1093      }
     1094      break;
     1095
     1096    case MLE_TOGWRAP:                   /* toggle wrap mode */
     1097      if (vw->hex != 1) {
     1098        SetMenuCheck(vw->hwndMenu, MLE_TOGWRAP, &vw->fWrap, TRUE, "MLEWrap");
     1099        MLEsetwrap(hwndMLE, vw->fWrap);
     1100      }
     1101      break;
     1102
     1103    case IDM_ABOUT:
     1104    case MLE_ABOUT:
     1105      saymsg(MB_ENTER | MB_ICONASTERISK,
     1106             hwnd,
     1107             GetPString(IDS_VIEWABOUTTITLETEXT),
     1108             GetPString(IDS_VIEWABOUTTEXT));
     1109      break;
     1110    }
     1111    return 0;
     1112
     1113  case WM_SAVEAPPLICATION:
     1114    if (vw && ParentIsDesktop(hwnd, vw->hwndParent)) {
     1115
     1116      SWP swp;
     1117
     1118      WinQueryWindowPos(vw->hwndFrame, &swp);
     1119      if (!(swp.fl & (SWP_HIDE | SWP_MINIMIZE | SWP_MAXIMIZE)))
     1120        PrfWriteProfileData(fmprof,
     1121                            appname, "ViewSizePos", &swp, sizeof(swp));
     1122    }
     1123    break;
     1124
     1125  case WM_CLOSE:                        /* outtahere */
     1126    WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
     1127    if (vw) {
     1128      if (vw->busy) {
     1129        vw->killme = TRUE;
     1130        return 0;
     1131      }
     1132      if (vw->ch && !MLEgetreadonly(hwndMLE)) {
     1133
     1134        APIRET temp;
     1135
     1136        temp = saymsg(MB_YESNOCANCEL | MB_ICONEXCLAMATION,
     1137                      hwnd, NullStr, GetPString(IDS_SAVECHANGESTEXT));
     1138        if (temp == MBID_CANCEL)
     1139          return 0;
     1140        if (temp == MBID_YES)
     1141          WinSendMsg(hwnd,
     1142                     WM_COMMAND, MPFROM2SHORT(MLE_EXPORTFILE, 0), MPVOID);
     1143      }
     1144    }
     1145    WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
     1146    return 0;
     1147
     1148  case WM_DESTROY:
     1149    DosPostEventSem(CompactSem);
     1150    {
     1151      BOOL dontclose = FALSE;
     1152
     1153      if (vw) {
     1154        if (vw->hwndPopupMenu)
     1155          WinDestroyWindow(vw->hwndPopupMenu);
     1156        if (vw->accel)
     1157          WinDestroyAccelTable(vw->accel);
     1158        dontclose = vw->dontclose;
     1159        WinSetWindowPtr(hwnd, QWL_USER, NULL);
     1160        if (vw->hwndRestore) {
     1161
     1162          ULONG fl = SWP_SHOW | SWP_ACTIVATE | SWP_ZORDER;
     1163          SWP swp;
     1164
     1165          if (WinQueryWindowPos(vw->hwndRestore, &swp)) {
     1166            if (!(swp.fl & SWP_MAXIMIZE))
     1167              fl |= SWP_RESTORE;
     1168            WinSetWindowPos(vw->hwndRestore, HWND_TOP, 0, 0, 0, 0, fl);
     1169          }
     1170        }
     1171        free(vw);
     1172      }
     1173      if (!dontclose &&
     1174          ParentIsDesktop(hwnd, WinQueryWindow(WinQueryWindow(hwnd,
     1175                                                              QW_PARENT),
     1176                                               QW_PARENT))) {
     1177        if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
     1178          DosExit(EXIT_PROCESS, 1);
     1179      }
     1180    }
     1181    break;
    14491182  }
    1450   return WinDefWindowProc(hwnd,msg,mp1,mp2);
     1183  return WinDefWindowProc(hwnd, msg, mp1, mp2);
    14511184}
    1452 
Note: See TracChangeset for help on using the changeset viewer.