Changeset 195 for trunk/dll/uudecode.c


Ignore:
Timestamp:
Jun 7, 2005, 12:32:16 AM (20 years ago)
Author:
root
Message:

Indent -i2

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/uudecode.c

    r2 r195  
     1
     2/***********************************************************************
     3
     4  $Id$
     5
     6  uudecode
     7
     8  Copyright (c) 1993-98 M. Kimes
     9  Copyright (c) 2005 Steven H. Levine
     10
     11  06 Jun 05 SHL Indent -i2
     12
     13***********************************************************************/
     14
    115#define INCL_DOS
    216#define INCL_WIN
    … …  
    1226
    1327/* prototypes */
    14 static BOOL decode (FILE *in, FILE *out);
    15 static void outdec (char *p, FILE *f, int n);
     28static BOOL decode(FILE * in, FILE * out);
     29static void outdec(char *p, FILE * f, int n);
    1630
    1731/* single character decode */
    … …  
    2135#pragma alloc_text(MERGE,MergeDlgProc)
    2236
    23 
    24 int UUD (char *filename,CHAR *dest) {
    25 
    26         FILE *in, *out;
    27   int   mode,ret = 0;
    28   char  buf[80];
    29   char  fakedest[CCHMAXPATH];
    30 
    31   if(!dest)
     37int UUD(char *filename, CHAR * dest)
     38{
     39  FILE *in, *out;
     40  int mode, ret = 0;
     41  char buf[80];
     42  char fakedest[CCHMAXPATH];
     43
     44  if (!dest)
    3245    dest = fakedest;
    33   in = _fsopen(filename,"r",SH_DENYWR);
    34   if(!in) {
     46  in = _fsopen(filename, "r", SH_DENYWR);
     47  if (!in)
     48  {
    3549    saymsg(MB_CANCEL,
    36            HWND_DESKTOP,
    37            GetPString(IDS_ERRORTEXT),
    38            GetPString(IDS_COMPCANTOPENTEXT),
    39            filename);
     50           HWND_DESKTOP,
     51           GetPString(IDS_ERRORTEXT),
     52           GetPString(IDS_COMPCANTOPENTEXT),
     53           filename);
    4054    return ret;
    4155  }
    4256
    43         /* search for header line */
    44   for(;;) {
    45     if(!fgets(buf,sizeof(buf),in)) {
     57  /* search for header line */
     58  for (;;)
     59  {
     60    if (!fgets(buf, sizeof(buf), in))
     61    {
    4662      fclose(in);
    4763      saymsg(MB_CANCEL,
    48              HWND_DESKTOP,
    49              GetPString(IDS_ERRORTEXT),
    50              GetPString(IDS_UUDNOBEGINTEXT),
    51              filename);
     64             HWND_DESKTOP,
     65             GetPString(IDS_ERRORTEXT),
     66             GetPString(IDS_UUDNOBEGINTEXT),
     67             filename);
    5268      return ret;
    53                 }
     69    }
    5470    buf[sizeof(buf) - 1] = 0;
    55     if(!strncmp(buf,"begin ",6))
    56                         break;
    57         }
     71    if (!strncmp(buf, "begin ", 6))
     72      break;
     73  }
    5874  *dest = 0;
    59   sscanf(buf,"begin %o %259s",&mode,dest);
     75  sscanf(buf, "begin %o %259s", &mode, dest);
    6076  dest[CCHMAXPATH - 1] = 0;
    61   { /* place dest in same directory as filename by default... */
    62     char build[CCHMAXPATH],*p;
    63 
    64     strcpy(build,filename);
    65     p = strrchr(build,'\\');
    66     if(p) {
     77  {                                     /* place dest in same directory as filename by default... */
     78    char build[CCHMAXPATH], *p;
     79
     80    strcpy(build, filename);
     81    p = strrchr(build, '\\');
     82    if (p)
     83    {
    6784      p++;
    6885      *p = 0;
    6986    }
    7087    else
    71       strcat(build,"\\");
    72     strncat(build,dest,CCHMAXPATH - strlen(dest));
    73     strcpy(dest,build);
    74   }
    75 
    76   if(!export_filename(HWND_DESKTOP,dest,FALSE)) {
     88      strcat(build, "\\");
     89    strncat(build, dest, CCHMAXPATH - strlen(dest));
     90    strcpy(dest, build);
     91  }
     92
     93  if (!export_filename(HWND_DESKTOP, dest, FALSE))
     94  {
    7795    fclose(in);
    7896    return ret;
    7997  }
    8098
    81         /* create output file */
    82   out = _fsopen(dest,"ab+",SH_DENYWR);
    83   if(!out) {
     99  /* create output file */
     100  out = _fsopen(dest, "ab+", SH_DENYWR);
     101  if (!out)
     102  {
    84103    fclose(in);
    85104    saymsg(MB_CANCEL,
    86            HWND_DESKTOP,
    87            GetPString(IDS_ERRORTEXT),
    88            GetPString(IDS_UUDCANTOPENFORTEXT),
    89            dest,
    90            filename);
     105           HWND_DESKTOP,
     106           GetPString(IDS_ERRORTEXT),
     107           GetPString(IDS_UUDCANTOPENFORTEXT),
     108           dest,
     109           filename);
    91110    return ret;
    92         }
     111  }
    93112
    94113//  chmod(dest,mode);
    95114
    96115  ret = 1;
    97   if(decode(in,out)) {
     116  if (decode(in, out))
     117  {
    98118//    saymsg(MB_ENTER,HWND_DESKTOP,"UUD error","File \"%s\" is short.",filename);
    99 //    ret = -1;
    100   }
    101   if(!fgets(buf,sizeof(buf),in) || strcmp(buf,"end\n")) {
     119    //    ret = -1;
     120  }
     121  if (!fgets(buf, sizeof(buf), in) || strcmp(buf, "end\n"))
     122  {
    102123//    saymsg(MB_ENTER,HWND_DESKTOP,"UUD error","No end line or garbage at end of \"%s\"",
    103 //           filename);
    104 //    ret = -1;
    105         }
     124    //           filename);
     125    //    ret = -1;
     126  }
    106127  fclose(in);
    107128  fclose(out);
    … …  
    109130}
    110131
    111 
    112132/*
    113133 * copy from in to out, decoding as you go along.
    114134 */
    115 static BOOL decode (FILE *in, FILE *out) {
    116 
    117   char  buf[80];
    118         char *bp;
    119   int   n;
    120 
    121   for(;;) {
    122                 /* for each input line */
    123     if(!fgets(buf,sizeof(buf),in))
     135static BOOL decode(FILE * in, FILE * out)
     136{
     137  char buf[80];
     138  char *bp;
     139  int n;
     140
     141  for (;;)
     142  {
     143    /* for each input line */
     144    if (!fgets(buf, sizeof(buf), in))
    124145      return FALSE;
    125146    buf[sizeof(buf) - 1] = 0;
    126147    n = DEC(buf[0]);
    127     if(n <= 0)
    128                         break;
    129                 bp = &buf[1];
    130                 while (n > 0) {
    131                         outdec(bp, out, n);
    132                         bp += 4;
    133                         n -= 3;
    134                 }
    135         }
     148    if (n <= 0)
     149      break;
     150    bp = &buf[1];
     151    while (n > 0)
     152    {
     153      outdec(bp, out, n);
     154      bp += 4;
     155      n -= 3;
     156    }
     157  }
    136158  return TRUE;
    137159}
    … …  
    143165 * output all of them at the end of the file.
    144166 */
    145 static void outdec (char *p, FILE *f, int n) {
    146 
    147         int c1, c2, c3;
    148 
    149   c1 = DEC(*p)   << 2 | DEC(p[1]) >> 4;
    150         c2 = DEC(p[1]) << 4 | DEC(p[2]) >> 2;
    151         c3 = DEC(p[2]) << 6 | DEC(p[3]);
    152   if(n >= 1)
    153                 putc(c1, f);
    154   if(n >= 2)
    155                 putc(c2, f);
    156   if(n >= 3)
    157                 putc(c3, f);
     167static void outdec(char *p, FILE * f, int n)
     168{
     169  int c1, c2, c3;
     170
     171  c1 = DEC(*p) << 2 | DEC(p[1]) >> 4;
     172  c2 = DEC(p[1]) << 4 | DEC(p[2]) >> 2;
     173  c3 = DEC(p[2]) << 6 | DEC(p[3]);
     174  if (n >= 1)
     175    putc(c1, f);
     176  if (n >= 2)
     177    putc(c2, f);
     178  if (n >= 3)
     179    putc(c3, f);
    158180}
    159181
    160 
    161 MRESULT EXPENTRY MergeDlgProc (HWND hwnd,ULONG msg,MPARAM mp1,MPARAM mp2) {
    162 
     182MRESULT EXPENTRY MergeDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     183{
    163184  WORKER *wk;
    164185
    165   switch(msg) {
    166     case WM_INITDLG:
    167       if(mp2) {
    168         WinSetWindowPtr(hwnd,0,mp2);
    169         wk = (WORKER *)mp2;
    170         if(wk->li && wk->li->list && wk->li->list[0]) {
    171           WinSendDlgItemMsg(hwnd,MRG_TARGETNAME,EM_SETTEXTLIMIT,
    172                             MPFROM2SHORT(CCHMAXPATH,0),MPVOID);
    173           PostMsg(hwnd,UM_UNDO,MPVOID,MPVOID);
    174         }
    175         else
    176           WinDismissDlg(hwnd,0);
     186  switch (msg)
     187  {
     188  case WM_INITDLG:
     189    if (mp2)
     190    {
     191      WinSetWindowPtr(hwnd, 0, mp2);
     192      wk = (WORKER *) mp2;
     193      if (wk -> li && wk -> li -> list && wk -> li -> list[0])
     194      {
     195        WinSendDlgItemMsg(hwnd, MRG_TARGETNAME, EM_SETTEXTLIMIT,
     196                          MPFROM2SHORT(CCHMAXPATH, 0), MPVOID);
     197        PostMsg(hwnd, UM_UNDO, MPVOID, MPVOID);
    177198      }
    178199      else
    179         WinDismissDlg(hwnd,0);
    180       break;
    181 
    182     case UM_UNDO:
    183       WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_DELETEALL,MPVOID,MPVOID);
    184       wk = WinQueryWindowPtr(hwnd,0);
    185       if(wk) {
    186 
    187         INT   x,numfiles = 0;
    188         SHORT start;
    189         CHAR *p;
    190 
    191         WinSetDlgItemText(hwnd,MRG_TARGETNAME,wk->li->targetpath);
    192         start = 0;
    193         p = strrchr(wk->li->targetpath,'\\');
    194         if(p)
    195           start = (p + 1) - wk->li->targetpath;
    196         WinSendDlgItemMsg(hwnd,MRG_TARGETNAME,EM_SETSEL,
    197                           MPFROM2SHORT(start,CCHMAXPATH),MPVOID);
    198         for(x = 0;wk->li->list[x];x++) {
    199           if(IsFile(wk->li->list[x]) == 1) {
    200             numfiles++;
    201             WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_INSERTITEM,
    202                               MPFROM2SHORT(LIT_END,0),
    203                               MPFROMP(wk->li->list[x]));
    204           }
    205         }
    206         WinCheckButton(hwnd,MRG_BINARY,(wk->li->type == IDM_MERGEBINARY));
    207         if(!numfiles) {
    208           saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
    209                  hwnd,
    210                  GetPString(IDS_SILLYERRORTEXT),
    211                  GetPString(IDS_MERGEWASTETEXT));
    212           WinDismissDlg(hwnd,0);
    213         }
    214       }
    215       return 0;
    216 
    217     case WM_CONTROL:
    218       switch(SHORT1FROMMP(mp1)) {
    219         case MRG_LISTBOX:
    220           switch(SHORT2FROMMP(mp1)) {
    221             case LN_ENTER:
    222               {
    223                 SHORT x;
    224                 CHAR  szBuffer[CCHMAXPATH];
    225 
    226                 x = (SHORT)WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_QUERYSELECTION,
    227                                              MPFROMSHORT(LIT_FIRST),MPVOID);
    228                 if(x >= 0) {
    229                   *szBuffer = 0;
    230                   WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_QUERYITEMTEXT,
    231                                     MPFROM2SHORT(x,CCHMAXPATH),
    232                                     MPFROMP(szBuffer));
    233                   if(*szBuffer)
    234                     QuickEdit(hwnd,szBuffer);
    235                 }
    236               }
    237               break;
    238           }
    239           break;
    240       }
    241       break;
    242 
    243     case WM_ADJUSTWINDOWPOS:
    244       PostMsg(hwnd,UM_SETDIR,MPVOID,MPVOID);
    245       break;
    246 
    247     case UM_SETDIR:
    248       PaintRecessedWindow(WinWindowFromID(hwnd,MRG_HELP),(HPS)0,FALSE,TRUE);
    249       return 0;
    250 
    251     case WM_COMMAND:
    252       switch(SHORT1FROMMP(mp1)) {
    253         case IDM_UNDO:
    254           PostMsg(hwnd,UM_UNDO,MPVOID,MPVOID);
    255           break;
    256 
    257         case MRG_CHANGETARGET:
    258           wk = WinQueryWindowPtr(hwnd,0);
    259           if(wk) {
    260 
    261             CHAR filename[CCHMAXPATH];
    262 
    263             strcpy(filename,wk->li->targetpath);
    264             if(export_filename(HWND_DESKTOP,filename,FALSE) && *filename) {
    265               strcpy(wk->li->targetpath,filename);
    266               WinSetDlgItemText(hwnd,MRG_TARGETNAME,wk->li->targetpath);
    267             }
    268           }
    269           break;
    270 
    271         case MRG_REMOVE:
    272           {
    273             SHORT x;
    274 
    275             x = (SHORT)WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_QUERYSELECTION,
    276                                          MPFROMSHORT(LIT_FIRST),MPVOID);
    277             if(x >= 0)
    278               WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_DELETEITEM,
    279                                 MPFROMSHORT(x),MPVOID);
    280           }
    281           break;
    282 
    283         case MRG_BOTTOM:
    284         case MRG_TOP:
    285           {
    286             SHORT x;
    287             CHAR  szBuffer[CCHMAXPATH];
    288 
    289             x = (SHORT)WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_QUERYSELECTION,
    290                                          MPFROMSHORT(LIT_FIRST),MPVOID);
    291             if(x >= 0) {
    292               *szBuffer = 0;
    293               WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_QUERYITEMTEXT,
    294                                 MPFROM2SHORT(x,CCHMAXPATH),
    295                                 MPFROMP(szBuffer));
    296               if(*szBuffer) {
    297                 WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_DELETEITEM,
    298                                   MPFROMSHORT(x),MPVOID);
    299                 if(SHORT1FROMMP(mp1) == MRG_TOP)
    300                   WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_INSERTITEM,
    301                                     MPFROM2SHORT(0,0),
    302                                     MPFROMP(szBuffer));
    303                 else
    304                   WinSendDlgItemMsg(hwnd,MRG_LISTBOX,LM_INSERTITEM,
    305                                     MPFROM2SHORT(LIT_END,0),
    306                                     MPFROMP(szBuffer));
    307               }
    308             }
    309           }
    310           break;
    311 
    312         case DID_CANCEL:
    313           WinDismissDlg(hwnd,0);
    314           break;
    315 
    316         case IDM_HELP:
    317           if(hwndHelp)
    318             WinSendMsg(hwndHelp,HM_DISPLAY_HELP,
    319                        MPFROM2SHORT(HELP_MERGE,0),
    320                        MPFROMSHORT(HM_RESOURCEID));
    321           break;
    322 
    323         case DID_OK:
    324           wk = WinQueryWindowPtr(hwnd,0);
    325           if(wk) {
    326 
    327             BOOL   append,binary;
    328             CHAR **list = NULL,**test,szBuffer[CCHMAXPATH];
    329             INT    numfiles = 0,numalloc = 0,error;
    330             SHORT  x,y;
    331 
    332             *szBuffer = 0;
    333             WinQueryDlgItemText(hwnd,
    334                                 MRG_TARGETNAME,
    335                                 CCHMAXPATH,
    336                                 szBuffer);
    337             if(!*szBuffer) {
    338               DosBeep(50,100);
    339               WinSetFocus(HWND_DESKTOP,
    340                           WinWindowFromID(hwnd,MRG_TARGETNAME));
    341               break;
    342             }
    343             if(DosQueryPathInfo(szBuffer,
    344                                 FIL_QUERYFULLNAME,
    345                                 wk->li->targetpath,
    346                                 CCHMAXPATH)) {
    347               DosBeep(50,100);
    348               WinSetFocus(HWND_DESKTOP,
    349                           WinWindowFromID(hwnd,MRG_TARGETNAME));
    350               break;
    351             }
    352             WinSetDlgItemText(hwnd,
    353                               MRG_TARGETNAME,
    354                               szBuffer);
    355             append = WinQueryButtonCheckstate(hwnd,MRG_APPEND);
    356             binary = WinQueryButtonCheckstate(hwnd,MRG_BINARY);
    357             wk->li->type = (append && binary) ? IDM_MERGEBINARYAPPEND :
    358                             (append) ? IDM_MERGETEXTAPPEND :
    359                              (binary) ? IDM_MERGEBINARY :
    360                                         IDM_MERGETEXT;
    361             x = (SHORT)WinSendDlgItemMsg(hwnd,
    362                                          MRG_LISTBOX,
    363                                          LM_QUERYITEMCOUNT,
    364                                          MPVOID,
    365                                          MPVOID);
    366             for(y = 0;y < x;y++) {
    367               *szBuffer = 0;
    368               WinSendDlgItemMsg(hwnd,
    369                                 MRG_LISTBOX,
    370                                 LM_QUERYITEMTEXT,
    371                                 MPFROM2SHORT(y,CCHMAXPATH),
    372                                 MPFROMP(szBuffer));
    373               if(*szBuffer) {
    374                 error = AddToList(szBuffer,
    375                                   &list,
    376                                   &numfiles,
    377                                   &numalloc);
    378                 if(error) {
    379                   DosBeep(250,100);
    380                   break;
    381                 }
    382               }
    383             }
    384             if(numfiles && list && numfiles + 1 < numalloc) {
    385               test = realloc(list,sizeof(CHAR *) * (numfiles + 1));
    386               if(test)
    387                 list = test;
    388             }
    389             if(list && list[0]) {
    390               FreeList(wk->li->list);
    391               wk->li->list = list;
    392             }
    393             else {
    394               DosBeep(50,100);
    395               break;
    396             }
    397           }
    398           WinDismissDlg(hwnd,1);
    399           break;
    400       }
    401       return 0;
    402   }
    403   return WinDefDlgProc(hwnd,msg,mp1,mp2);
     200        WinDismissDlg(hwnd, 0);
     201    }
     202    else
     203      WinDismissDlg(hwnd, 0);
     204    break;
     205
     206  case UM_UNDO:
     207    WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
     208    wk = WinQueryWindowPtr(hwnd, 0);
     209    if (wk)
     210    {
     211
     212      INT x, numfiles = 0;
     213      SHORT start;
     214      CHAR *p;
     215
     216      WinSetDlgItemText(hwnd, MRG_TARGETNAME, wk -> li -> targetpath);
     217      start = 0;
     218      p = strrchr(wk -> li -> targetpath, '\\');
     219      if (p)
     220        start = (p + 1) - wk -> li -> targetpath;
     221      WinSendDlgItemMsg(hwnd, MRG_TARGETNAME, EM_SETSEL,
     222                        MPFROM2SHORT(start, CCHMAXPATH), MPVOID);
     223      for (x = 0; wk -> li -> list[x]; x++)
     224      {
     225        if (IsFile(wk -> li -> list[x]) == 1)
     226        {
     227          numfiles++;
     228          WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_INSERTITEM,
     229                            MPFROM2SHORT(LIT_END, 0),
     230                            MPFROMP(wk -> li -> list[x]));
     231        }
     232      }
     233      WinCheckButton(hwnd, MRG_BINARY, (wk -> li -> type == IDM_MERGEBINARY));
     234      if (!numfiles)
     235      {
     236        saymsg(MB_CANCEL | MB_ICONEXCLAMATION,
     237               hwnd,
     238               GetPString(IDS_SILLYERRORTEXT),
     239               GetPString(IDS_MERGEWASTETEXT));
     240        WinDismissDlg(hwnd, 0);
     241      }
     242    }
     243    return 0;
     244
     245  case WM_CONTROL:
     246    switch (SHORT1FROMMP(mp1))
     247    {
     248    case MRG_LISTBOX:
     249      switch (SHORT2FROMMP(mp1))
     250      {
     251      case LN_ENTER:
     252        {
     253          SHORT x;
     254          CHAR szBuffer[CCHMAXPATH];
     255
     256          x = (SHORT) WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_QUERYSELECTION,
     257                                        MPFROMSHORT(LIT_FIRST), MPVOID);
     258          if (x >= 0)
     259          {
     260            *szBuffer = 0;
     261            WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_QUERYITEMTEXT,
     262                              MPFROM2SHORT(x, CCHMAXPATH),
     263                              MPFROMP(szBuffer));
     264            if (*szBuffer)
     265              QuickEdit(hwnd, szBuffer);
     266          }
     267        }
     268        break;
     269      }
     270      break;
     271    }
     272    break;
     273
     274  case WM_ADJUSTWINDOWPOS:
     275    PostMsg(hwnd, UM_SETDIR, MPVOID, MPVOID);
     276    break;
     277
     278  case UM_SETDIR:
     279    PaintRecessedWindow(WinWindowFromID(hwnd, MRG_HELP), (HPS) 0, FALSE, TRUE);
     280    return 0;
     281
     282  case WM_COMMAND:
     283    switch (SHORT1FROMMP(mp1))
     284    {
     285    case IDM_UNDO:
     286      PostMsg(hwnd, UM_UNDO, MPVOID, MPVOID);
     287      break;
     288
     289    case MRG_CHANGETARGET:
     290      wk = WinQueryWindowPtr(hwnd, 0);
     291      if (wk)
     292      {
     293
     294        CHAR filename[CCHMAXPATH];
     295
     296        strcpy(filename, wk -> li -> targetpath);
     297        if (export_filename(HWND_DESKTOP, filename, FALSE) && *filename)
     298        {
     299          strcpy(wk -> li -> targetpath, filename);
     300          WinSetDlgItemText(hwnd, MRG_TARGETNAME, wk -> li -> targetpath);
     301        }
     302      }
     303      break;
     304
     305    case MRG_REMOVE:
     306      {
     307        SHORT x;
     308
     309        x = (SHORT) WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_QUERYSELECTION,
     310                                      MPFROMSHORT(LIT_FIRST), MPVOID);
     311        if (x >= 0)
     312          WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_DELETEITEM,
     313                            MPFROMSHORT(x), MPVOID);
     314      }
     315      break;
     316
     317    case MRG_BOTTOM:
     318    case MRG_TOP:
     319      {
     320        SHORT x;
     321        CHAR szBuffer[CCHMAXPATH];
     322
     323        x = (SHORT) WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_QUERYSELECTION,
     324                                      MPFROMSHORT(LIT_FIRST), MPVOID);
     325        if (x >= 0)
     326        {
     327          *szBuffer = 0;
     328          WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_QUERYITEMTEXT,
     329                            MPFROM2SHORT(x, CCHMAXPATH),
     330                            MPFROMP(szBuffer));
     331          if (*szBuffer)
     332          {
     333            WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_DELETEITEM,
     334                              MPFROMSHORT(x), MPVOID);
     335            if (SHORT1FROMMP(mp1) == MRG_TOP)
     336              WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_INSERTITEM,
     337                                MPFROM2SHORT(0, 0),
     338                                MPFROMP(szBuffer));
     339            else
     340              WinSendDlgItemMsg(hwnd, MRG_LISTBOX, LM_INSERTITEM,
     341                                MPFROM2SHORT(LIT_END, 0),
     342                                MPFROMP(szBuffer));
     343          }
     344        }
     345      }
     346      break;
     347
     348    case DID_CANCEL:
     349      WinDismissDlg(hwnd, 0);
     350      break;
     351
     352    case IDM_HELP:
     353      if (hwndHelp)
     354        WinSendMsg(hwndHelp, HM_DISPLAY_HELP,
     355                   MPFROM2SHORT(HELP_MERGE, 0),
     356                   MPFROMSHORT(HM_RESOURCEID));
     357      break;
     358
     359    case DID_OK:
     360      wk = WinQueryWindowPtr(hwnd, 0);
     361      if (wk)
     362      {
     363
     364        BOOL append, binary;
     365        CHAR **list = NULL, **test, szBuffer[CCHMAXPATH];
     366        INT numfiles = 0, numalloc = 0, error;
     367        SHORT x, y;
     368
     369        *szBuffer = 0;
     370        WinQueryDlgItemText(hwnd,
     371                            MRG_TARGETNAME,
     372                            CCHMAXPATH,
     373                            szBuffer);
     374        if (!*szBuffer)
     375        {
     376          DosBeep(50, 100);
     377          WinSetFocus(HWND_DESKTOP,
     378                      WinWindowFromID(hwnd, MRG_TARGETNAME));
     379          break;
     380        }
     381        if (DosQueryPathInfo(szBuffer,
     382                             FIL_QUERYFULLNAME,
     383                             wk -> li -> targetpath,
     384                             CCHMAXPATH))
     385        {
     386          DosBeep(50, 100);
     387          WinSetFocus(HWND_DESKTOP,
     388                      WinWindowFromID(hwnd, MRG_TARGETNAME));
     389          break;
     390        }
     391        WinSetDlgItemText(hwnd,
     392                          MRG_TARGETNAME,
     393                          szBuffer);
     394        append = WinQueryButtonCheckstate(hwnd, MRG_APPEND);
     395        binary = WinQueryButtonCheckstate(hwnd, MRG_BINARY);
     396        wk -> li -> type = (append && binary) ? IDM_MERGEBINARYAPPEND :
     397          (append) ? IDM_MERGETEXTAPPEND :
     398          (binary) ? IDM_MERGEBINARY :
     399          IDM_MERGETEXT;
     400        x = (SHORT) WinSendDlgItemMsg(hwnd,
     401                                      MRG_LISTBOX,
     402                                      LM_QUERYITEMCOUNT,
     403                                      MPVOID,
     404                                      MPVOID);
     405        for (y = 0; y < x; y++)
     406        {
     407          *szBuffer = 0;
     408          WinSendDlgItemMsg(hwnd,
     409                            MRG_LISTBOX,
     410                            LM_QUERYITEMTEXT,
     411                            MPFROM2SHORT(y, CCHMAXPATH),
     412                            MPFROMP(szBuffer));
     413          if (*szBuffer)
     414          {
     415            error = AddToList(szBuffer,
     416                              &list,
     417                              &numfiles,
     418                              &numalloc);
     419            if (error)
     420            {
     421              DosBeep(250, 100);
     422              break;
     423            }
     424          }
     425        }
     426        if (numfiles && list && numfiles + 1 < numalloc)
     427        {
     428          test = realloc(list, sizeof(CHAR *) * (numfiles + 1));
     429          if (test)
     430            list = test;
     431        }
     432        if (list && list[0])
     433        {
     434          FreeList(wk -> li -> list);
     435          wk -> li -> list = list;
     436        }
     437        else
     438        {
     439          DosBeep(50, 100);
     440          break;
     441        }
     442      }
     443      WinDismissDlg(hwnd, 1);
     444      break;
     445    }
     446    return 0;
     447  }
     448  return WinDefDlgProc(hwnd, msg, mp1, mp2);
    404449}
Note: See TracChangeset for help on using the changeset viewer.