Changeset 306


Ignore:
Timestamp:
Jun 27, 2006, 2:24:18 AM (19 years ago)
Author:
root
Message:

load_archivers: use get_archiver_line?(), clean nits
SBoxDlgProc: support move, add, delete
load_archivers: add reload support
load_archivers: support signatures containing 0s

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/avl.c

    r287 r306  
    77
    88  Copyright (c) 1993, 1998 M. Kimes
    9   Copyright (c) 2004, 2005 Steven H.Levine
     9  Copyright (c) 2004, 2006 Steven H.Levine
    1010
    1111  01 Aug 04 SHL Rework lstrip/rstrip usage
    … …  
    1515  18 Aug 05 SHL Comments
    1616  31 Dec 05 SHL indent -i2
     17  08 Dec 05 SHL load_archivers: allow empty startlist
     18  30 Dec 05 SHL load_archivers: use get_archiver_line?(), clean nits
     19  29 May 06 SHL SBoxDlgProc: support move, add, delete
     20  30 May 06 SHL load_archivers: add reload support
     21  16 Jun 06 SHL load_archivers: support signatures containing 0s
    1722
    1823***********************************************************************/
    1924
    2025#define INCL_WIN
     26#define INCL_WINSTDDRAG
    2127#define INCL_DOS
    2228#include <os2.h>
    … …  
    3238#include "fm3str.h"
    3339
    34 BOOL loadedarcs;
    35 
    3640#pragma alloc_text(MISC9,quick_find_type,find_type)
     41
     42static void free_arc_type(ARC_TYPE *pat);
     43static void fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect);
     44
     45//=== quick_find_type() ===
    3746
    3847ARC_TYPE *quick_find_type(CHAR * filespec, ARC_TYPE * topsig)
    … …  
    4150  CHAR *p;
    4251
    43   if (!loadedarcs)
     52  if (!arcsigsloaded)
    4453    load_archivers();
    4554  p = strrchr(filespec, '.');
    … …  
    6170  }
    6271  return found;
     72}
     73
     74//=== fill_listbox() fill or refill listbox from current archiver definitions ===
     75
     76static VOID fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect)
     77{
     78  ARC_TYPE *pat;
     79  BOOL found = FALSE;
     80  SHORT sSelect;
     81
     82  WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
     83
     84  for (pat = arcsighead; pat; pat = pat -> next)
     85  {
     86    /*
     87     * this inner loop tests for a dup signature entry and assures
     88     * that only the entry at the top of the list gets used for
     89     * conversion; editing any is okay
     90     */
     91    if (!fShowAll)
     92    {
     93      ARC_TYPE *pat2;
     94      BOOL isDup = FALSE;
     95      for (pat2 = arcsighead;
     96           pat2 && pat -> siglen && pat2 != pat && !isDup;
     97           pat2 = pat2 -> next)
     98      {
     99        isDup = pat2 -> siglen == pat -> siglen &&
     100                !memcmp(pat2 -> signature, pat -> signature, pat -> siglen);
     101      } // for
     102      if (isDup)
     103        continue;
     104    }
     105
     106    // If caller is editing archivers or entry useful to caller, show in listbox
     107    if (fShowAll || (pat -> id && pat -> extract && pat -> create))
     108    {
     109      sSelect = (SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
     110                                          MPFROM2SHORT(LIT_END, 0),
     111                                          MPFROMP(pat -> id ?
     112                                                  pat -> id : "?"));
     113      if (!found && *szDefArc && pat -> id && !strcmp(szDefArc, pat -> id))
     114      {
     115        // Highlight default
     116        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     117                          MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
     118        found = TRUE;
     119      }
     120    }
     121    else
     122    {
     123      // Complain about odd entry
     124      if (!pat -> id || !*pat -> id)
     125      {
     126        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
     127                          MPFROM2SHORT(LIT_END, 0),
     128                          MPFROMP(GetPString(IDS_UNKNOWNUNUSABLETEXT)));
     129      }
     130      else
     131      {
     132        CHAR s[81];
     133        sprintf(s, "%0.12s %s", pat -> id, GetPString(IDS_UNUSABLETEXT));
     134        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
     135                          MPFROM2SHORT(LIT_END, 0),
     136                          MPFROMP(s));
     137      }
     138    }
     139  } // while scanning
     140
     141  // Try to reselect last selection unless user wants default selection
     142  if (sOldSelect != LIT_NONE && !found) {
     143    SHORT sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
     144                                                MPVOID,MPVOID);
     145    if (sOldSelect >= sItemCount)
     146      sOldSelect = sItemCount - 1;
     147    if (sOldSelect >= 0) {
     148      WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     149                        MPFROMSHORT(sOldSelect), MPFROMSHORT(TRUE));
     150    }
     151  }
     152
     153  if (found)
     154    PosOverOkay(hwnd);
    63155}
    64156
    … …  
    73165  CHAR buffer[80];
    74166
    75   if (!loadedarcs)
     167  if (!arcsigsloaded)
    76168    load_archivers();
    77169  if (!topsig)
    … …  
    95187  for (info = topsig; info; info = info -> next)
    96188  {
    97     if (!info -> signature || !*info -> signature)
     189    if (info -> siglen == 0)
    98190    {
    99191      // No signature -- check extension
    … …  
    112204    }
    113205    // Try signature match
    114     l = strlen(info -> signature);
     206    l = info -> siglen;
    115207    l = min(l, 79);
    116208    if (!DosChgFilePtr(handle,
    … …  
    140232}
    141233
    142 #pragma alloc_text(AVL,load_archivers)
     234//=== free_arc_type() free allocated ARC_TYPE ===
     235
     236static void free_arc_type(ARC_TYPE *pat)
     237{
     238  if (pat)
     239  {
     240    if (pat -> id)
     241      free(pat -> id);
     242    if (pat -> ext)
     243      free(pat -> ext);
     244    if (pat -> list)
     245      free(pat -> list);
     246    if (pat -> extract)
     247      free(pat -> extract);
     248    if (pat -> create)
     249      free(pat -> create);
     250    if (pat -> move)
     251      free(pat -> move);
     252    if (pat -> delete)
     253      free(pat -> delete);
     254    if (pat -> signature)
     255      free(pat -> signature);
     256    if (pat -> startlist)
     257      free(pat -> startlist);
     258    if (pat -> endlist)
     259      free(pat -> endlist);
     260    if (pat -> exwdirs)
     261      free(pat -> exwdirs);
     262    if (pat -> test)
     263      free(pat -> test);
     264    if (pat -> createrecurse)
     265      free(pat -> createrecurse);
     266    if (pat -> createwdirs)
     267      free(pat -> createwdirs);
     268    if (pat -> movewdirs)
     269      free(pat -> movewdirs);
     270    free(pat);
     271  }
     272}
     273
     274#pragma alloc_text(AVL,load_archivers, get_archiver_line)
     275
     276//=== get_archiver_line() read line, strip comments and whitespace ===
     277
     278#define ARCHIVER_LINE_BYTES     256
     279
     280static PSZ get_archiver_line(PSZ pszIn, FILE * pf)
     281{
     282  PSZ psz = fgets(pszIn, ARCHIVER_LINE_BYTES, pf);
     283  PSZ psz2;
     284
     285  if (psz)
     286  {
     287    psz2 = strchr(pszIn, ';');
     288    if (psz2)
     289      *psz2 = 0;                        // Chop comment
     290    bstripcr(pszIn);                    // Strip leading white and trailing white and CR/LF
     291
     292  }
     293  return psz;
     294}
     295
     296//=== get_archiver_line2() read line, strip whitespace ===
     297
     298static PSZ get_archiver_line2(PSZ pszIn, FILE * pf)
     299{
     300  PSZ psz = fgets(pszIn, ARCHIVER_LINE_BYTES, pf);
     301
     302  if (psz)
     303    bstripcr(pszIn);                    // Strip lead white and trailing white and CR/LF
     304
     305  return psz;
     306}
     307
     308//=== load_archivers() load or reload archive definitions from archiver.bb2 ===
    143309
    144310INT load_archivers(VOID)
    145311{
    146312  FILE *handle;
    147   CHAR s[257];
     313  CHAR s[ARCHIVER_LINE_BYTES + 1];
    148314  CHAR *p;
    149   ARC_TYPE *info = NULL;
    150   ARC_TYPE *last = NULL;
     315  ARC_TYPE *pat;
     316  ARC_TYPE *patLast;
    151317  INT numlines = NUMLINES;
    152   INT x;
    153 
    154   loadedarcs = TRUE;
     318  INT i;
     319
     320  if (arcsighead) {
     321    for (pat = arcsighead; pat;) {
     322      patLast = pat;
     323      pat = pat->next;
     324      free_arc_type(patLast);
     325    }
     326    arcsighead = NULL;
     327  }
     328
     329  arcsigsmodified = FALSE;
     330
    155331  DosEnterCritSec();
    156332  p = searchpath(GetPString(IDS_ARCHIVERBB2));
    … …  
    166342  strcpy(archiverbb2, p);
    167343  // Get lines per record count
    168   if (!fgets(s, 256, handle))
     344  if (!get_archiver_line(s, handle))
    169345  {
    170346    fclose(handle);
    171347    return -3;
    172348  }
    173   p = strchr(s, ';');
    174   if (p)
    175     *p = 0;                             // Chop trailing comment
    176 
    177   bstripcr(s);
    178349  if (*s)
    179350    numlines = atoi(s);
    … …  
    181352    return -3;
    182353  // Parse rest
     354  pat = NULL;
     355  patLast = NULL;
    183356  while (!feof(handle))
    184357  {
    185     if (!fgets(s, 256, handle))
     358    if (!get_archiver_line(s, handle))
    186359      break;                            // EOF
    187 
    188     p = strchr(s, ';');
    189     if (p)
    190       *p = 0;                           // Chop comment
    191 
    192     bstripcr(s);
    193360    // 1st non-blank line starts definition
    194361    // fixme to preserve comments
    195362    // fixme to avoid allocating empty fields
     363
    196364    if (*s)
    197365    {
    198       info = malloc(sizeof(ARC_TYPE));
    199       if (!info)
     366      pat = malloc(sizeof(ARC_TYPE));
     367      if (!pat)
    200368        break;                          // fixme to complain
    201369
    202       memset(info, 0, sizeof(ARC_TYPE));
     370      memset(pat, 0, sizeof(ARC_TYPE));
     371      pat -> id = strdup(s);
     372      if (!get_archiver_line(s, handle))        // line 2
     373
     374        break;
    203375      if (*s)
    204         info -> id = strdup(s);
    205       else
    206         info -> id = NULL;
    207       if (!fgets(s, 256, handle))
    208         break;
    209       p = strchr(s, ';');
    210       if (p)
    211         *p = 0;
    212       bstripcr(s);
     376        pat -> ext = strdup(s);
     377      else
     378        pat -> ext = NULL;
     379      if (!get_archiver_line(s, handle))        // line 3
     380
     381        break;
     382      pat -> file_offset = atol(s);
     383      if (!get_archiver_line(s, handle))        // line 4
     384
     385        break;
    213386      if (*s)
    214         info -> ext = strdup(s);
    215       else
    216         info -> ext = NULL;
    217       if (!fgets(s, 256, handle))
    218         break;
    219       p = strchr(s, ';');
    220       if (p)
    221         *p = 0;
    222       info -> file_offset = atol(s);
    223       if (!fgets(s, 256, handle))
    224         break;
    225       p = strchr(s, ';');
    226       if (p)
    227         *p = 0;
    228       bstripcr(s);
     387        pat -> list = strdup(s);
     388      else
     389        pat -> list = NULL;
     390      if (!pat -> list)
     391        break;
     392      if (!get_archiver_line(s, handle))        // line 5
     393
     394        break;
    229395      if (*s)
    230         info -> list = strdup(s);
    231       else
    232         info -> list = NULL;
    233       if (!info -> list)
    234         break;
    235       if (!fgets(s, 256, handle))
    236         break;
    237       p = strchr(s, ';');
    238       if (p)
    239         *p = 0;
    240       bstripcr(s);
     396        pat -> extract = strdup(s);
     397      else
     398        pat -> extract = NULL;
     399      if (!get_archiver_line(s, handle))        // line 6
     400
     401        break;
    241402      if (*s)
    242         info -> extract = strdup(s);
    243       else
    244         info -> extract = NULL;
    245       if (!fgets(s, 256, handle))
    246         break;
    247       p = strchr(s, ';');
    248       if (p)
    249         *p = 0;
    250       bstripcr(s);
     403        pat -> exwdirs = strdup(s);
     404      else
     405        pat -> exwdirs = NULL;
     406      if (!get_archiver_line(s, handle))        // line 7
     407
     408        break;
    251409      if (*s)
    252         info -> exwdirs = strdup(s);
    253       else
    254         info -> exwdirs = NULL;
    255       if (!fgets(s, 256, handle))
    256         break;
    257       p = strchr(s, ';');
    258       if (p)
    259         *p = 0;
    260       bstripcr(s);
     410        pat -> test = strdup(s);
     411      else
     412        pat -> test = NULL;
     413      if (!get_archiver_line(s, handle))        // line 8
     414
     415        break;
    261416      if (*s)
    262         info -> test = strdup(s);
    263       else
    264         info -> test = NULL;
    265       if (!fgets(s, 256, handle))
    266         break;
    267       p = strchr(s, ';');
    268       if (p)
    269         *p = 0;
    270       bstripcr(s);
     417        pat -> create = strdup(s);
     418      else
     419        pat -> create = NULL;
     420      if (!get_archiver_line(s, handle))        // line 9
     421
     422        break;
    271423      if (*s)
    272         info -> create = strdup(s);
    273       else
    274         info -> create = NULL;
    275       if (!fgets(s, 256, handle))
    276         break;
    277       p = strchr(s, ';');
    278       if (p)
    279         *p = 0;                         // Chop comment
    280 
    281       bstripcr(s);
     424        pat -> createwdirs = strdup(s);
     425      else
     426        pat -> createwdirs = NULL;
     427      if (!get_archiver_line(s, handle))        // line 10
     428
     429        break;
    282430      if (*s)
    283         info -> createwdirs = strdup(s);
    284       else
    285         info -> createwdirs = NULL;
    286       if (!fgets(s, 256, handle))
    287         break;
    288       p = strchr(s, ';');
    289       if (p)
    290         *p = 0;
    291       bstripcr(s);
     431        pat -> createrecurse = strdup(s);
     432      else
     433        pat -> createrecurse = NULL;
     434      if (!get_archiver_line(s, handle))        // line 11
     435
     436        break;
    292437      if (*s)
    293         info -> createrecurse = strdup(s);
    294       else
    295         info -> createrecurse = NULL;
    296       if (!fgets(s, 256, handle))
    297         break;
    298       p = strchr(s, ';');
    299       if (p)
    300         *p = 0;
    301       bstripcr(s);
     438        pat -> move = strdup(s);
     439      else
     440        pat -> move = NULL;
     441      if (!get_archiver_line(s, handle))        // line 12
     442
     443        break;
    302444      if (*s)
    303         info -> move = strdup(s);
    304       else
    305         info -> move = NULL;
    306       if (!fgets(s, 256, handle))
    307         break;
    308       p = strchr(s, ';');
    309       if (p)
    310         *p = 0;
    311       bstripcr(s);
     445        pat -> movewdirs = strdup(s);
     446      else
     447        pat -> movewdirs = NULL;
     448      if (!get_archiver_line(s, handle))        // line 13
     449
     450        break;
     451      pat -> delete = strdup(s);
     452
     453      if (!get_archiver_line2(s, handle))       // line 14
     454        break;
     455      i = literal(s);                   // Translate \ escapes
     456      if (i)
     457      {
     458        pat -> siglen = i;
     459        pat -> signature = malloc(i);
     460        if (!pat -> signature)
     461          break;
     462        memcpy(pat -> signature, s, i); // signature may not be a string
     463      }
     464      else {
     465        pat -> siglen = 0;
     466        pat -> signature = NULL;
     467      }
     468      if (!get_archiver_line2(s, handle))       // line 15
     469
     470        break;
    312471      if (*s)
    313         info -> movewdirs = strdup(s);
    314       else
    315         info -> movewdirs = NULL;
    316       if (!fgets(s, 256, handle))
    317         break;
    318       p = strchr(s, ';');
    319       if (p)
    320         *p = 0;
    321       bstripcr(s);
    322       info -> delete = strdup(s);
    323       if (!fgets(s, 256, handle))
    324         break;
    325       stripcr(s);
    326       literal(s);
     472        pat -> startlist = strdup(s);
     473      else
     474        pat -> startlist = NULL;
     475      if (!get_archiver_line2(s, handle))       // line 16
     476
     477        break;
    327478      if (*s)
    328       {
    329         info -> signature = strdup(s);
    330         if (!info -> signature)
    331           break;
    332       }
    333       else
    334         info -> signature = NULL;
    335       if (!fgets(s, 256, handle))
    336         break;
    337       stripcr(s);
    338       info -> startlist = strdup(s);
    339       if (!fgets(s, 256, handle))
    340         break;
    341       stripcr(s);
    342       if (*s)
    343         info -> endlist = strdup(s);
    344       else
    345         info -> endlist = NULL;
    346       if (!fgets(s, 256, handle))
    347         break;
    348       p = strchr(s, ';');
    349       if (p)
    350         *p = 0;
    351       info -> osizepos = atoi(s);
    352       if (!fgets(s, 256, handle))
    353         break;
    354       p = strchr(s, ';');
    355       if (p)
    356         *p = 0;
    357       info -> nsizepos = atoi(s);
    358       if (!fgets(s, 256, handle))
    359         break;
    360       p = strchr(s, ';');
    361       if (p)
    362         *p = 0;
    363       info -> fdpos = atoi(s);
     479        pat -> endlist = strdup(s);
     480      else
     481        pat -> endlist = NULL;
     482      if (!get_archiver_line(s, handle))        // line 17
     483
     484        break;
     485      pat -> osizepos = atoi(s);
     486      if (!get_archiver_line(s, handle))        // line 18
     487
     488        break;
     489      pat -> nsizepos = atoi(s);
     490      if (!get_archiver_line(s, handle))        // line 19
     491
     492        break;
     493      pat -> fdpos = atoi(s);
    364494      p = strchr(s, ',');
    365495      if (p)
    366496      {
    367497        p++;
    368         info -> datetype = atoi(p);
    369       }
    370       if (!fgets(s, 256, handle))
    371         break;
    372       p = strchr(s, ';');
    373       if (p)
    374         *p = 0;
    375       info -> fdflds = atoi(s);
    376       if (!fgets(s, 256, handle))
    377         break;
    378       p = strchr(s, ';');
    379       if (p)
    380         *p = 0;
    381       info -> fnpos = atoi(s);
     498        pat -> datetype = atoi(p);
     499      }
     500      if (!get_archiver_line(s, handle))        // line 20
     501
     502        break;
     503      pat -> fdflds = atoi(s);
     504      if (!get_archiver_line(s, handle))        // line 21
     505
     506        break;
     507      pat -> fnpos = atoi(s);
    382508      p = strchr(s, ',');
    383509      if (p)
    384510      {
    385511        p++;
    386         info -> nameislast = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
     512        pat -> nameislast = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
    387513        p = strchr(p, ',');
    388514        if (p)
    389515        {
    390516          p++;
    391           info -> nameisnext = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
     517          pat -> nameisnext = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
    392518          p = strchr(p, ',');
    393519          if (p)
    394520          {
    395521            p++;
    396             info -> nameisfirst = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
     522            pat -> nameisfirst = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
    397523          }
    398524        }
    399525      }
    400526      // Ignore unknown lines - must be newer file format
    401       for (x = NUMLINES; x < numlines; x++)
    402       {
    403         if (!fgets(s, 256, handle))
     527      for (i = NUMLINES; i < numlines; i++)
     528      {
     529        if (!get_archiver_line(s, handle))
    404530          break;
    405531      }
    406532
    407       info -> next = NULL;
     533      pat -> next = NULL;
    408534
    409535      if (!arcsighead)
    410536      {
    411         arcsighead = last = info;
    412         info -> prev = NULL;
    413       }
    414       else
    415       {
    416         last -> next = info;
    417         info -> prev = last;
    418         last = info;
    419       }
    420       if (info -> extract && !*info -> extract)
    421       {
    422         free(info -> extract);
    423         info -> extract = NULL;
    424       }
    425     }                                   // if got definition
    426 
    427     info = NULL;
    428   }
     537        arcsighead = patLast = pat;
     538        pat -> prev = NULL;
     539      }
     540      else
     541      {
     542        patLast -> next = pat;
     543        pat -> prev = patLast;
     544        patLast = pat;
     545      }
     546      if (pat -> extract && !*pat -> extract)
     547      {
     548        free(pat -> extract);
     549        pat -> extract = NULL;
     550      }
     551    } // if got definition
     552
     553    pat = NULL;
     554  } // while lines
    429555  fclose(handle);
    430   if (info)
    431   {
    432     // fixme to complain about partial definition
    433     if (info -> id)
    434       free(info -> id);
    435     if (info -> ext)
    436       free(info -> ext);
    437     if (info -> list)
    438       free(info -> list);
    439     if (info -> extract)
    440       free(info -> extract);
    441     if (info -> create)
    442       free(info -> create);
    443     if (info -> move)
    444       free(info -> move);
    445     if (info -> delete)
    446       free(info -> delete);
    447     if (info -> signature)
    448       free(info -> signature);
    449     if (info -> startlist)
    450       free(info -> startlist);
    451     if (info -> endlist)
    452       free(info -> endlist);
    453     if (info -> exwdirs)
    454       free(info -> exwdirs);
    455     if (info -> test)
    456       free(info -> test);
    457     if (info -> createrecurse)
    458       free(info -> createrecurse);
    459     if (info -> createwdirs)
    460       free(info -> createwdirs);
    461     if (info -> movewdirs)
    462       free(info -> movewdirs);
    463   }
     556
     557  free_arc_type(pat);
     558
    464559  if (!arcsighead)
    465560    return -4;
     561
     562  arcsigsloaded = TRUE;
     563
    466564  return 0;
    467565}
    468566
    469 #pragma alloc_text(FMARCHIVE,SBoxDlgProc)
     567#define TEST_DRAG 0                     // fixme to gone
     568
     569#pragma alloc_text(FMARCHIVE,SBoxDlgProc,SDlgListboxSubclassProc)
     570
     571static MRESULT EXPENTRY SDlgListboxSubclassProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
     572{
     573  PFNWP pfnOldProc = (PFNWP)WinQueryWindowPtr(hwnd, QWL_USER);
     574
     575  PDRAGITEM pditem;
     576  PDRAGINFO pdinfo;
     577  BOOL ok;
     578
     579  static BOOL emphasized = FALSE;
     580  static PSZ DRMDRF_LBOX = "<DRM_LBOX,DRF_UNKNOWN>";
     581  static PSZ DRM_LBOX = "DRM_LBOX";
     582
     583  switch (msg)
     584  {
     585  case WM_BEGINDRAG:
     586    {
     587      LONG cur_ndx;
     588      DRAGITEM ditem;
     589      DRAGIMAGE dimage;
     590      HWND hwndDrop;
     591
     592      fprintf(stderr, "SDlgListboxSubclassProc: BEGINDRAG\n");
     593      cur_ndx = WinQueryLboxSelectedItem(hwnd);
     594
     595      if (cur_ndx != LIT_NONE) {
     596        pdinfo = DrgAllocDraginfo(1);
     597        if(pdinfo) {
     598          pdinfo->usOperation = DO_DEFAULT;
     599          pdinfo->hwndSource = hwnd;
     600
     601          memset(&ditem,0,sizeof(DRAGITEM));
     602          ditem.hwndItem = hwnd;
     603          ditem.ulItemID = 1;
     604          ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
     605          ditem.hstrRMF = DrgAddStrHandle(DRMDRF_LBOX);
     606          ditem.hstrContainerName = DrgAddStrHandle("");
     607          ditem.hstrSourceName = DrgAddStrHandle("");
     608          ditem.hstrTargetName = DrgAddStrHandle("");
     609          // ditem.fsControl = 0;
     610          ditem.fsSupportedOps = DO_MOVEABLE;
     611
     612          memset(&dimage,0,sizeof(DRAGIMAGE));
     613          dimage.cb = sizeof(DRAGIMAGE);
     614          dimage.hImage = hptrFile;
     615          dimage.cptl = 0;
     616          dimage.fl = DRG_ICON;
     617          dimage.sizlStretch.cx = 32;
     618          dimage.sizlStretch.cy = 32;
     619          dimage.cxOffset = -16;
     620          dimage.cyOffset = 0;
     621          DrgSetDragitem(pdinfo,
     622                         &ditem,
     623                         sizeof(DRAGITEM),
     624                         0);            /* Index of DRAGITEM */
     625          hwndDrop = DrgDrag(hwnd,
     626                             pdinfo,
     627                             &dimage,
     628                             1,         /* One DRAGIMAGE */
     629                             VK_ENDDRAG,
     630                             NULL);
     631          if (!hwndDrop) {
     632            Win_Error(hwnd,hwnd,__FILE__,__LINE__,"DrgDrag");
     633          }
     634
     635          DrgFreeDraginfo(pdinfo);
     636          // WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
     637        }
     638      }
     639      break;
     640    }
     641
     642  case DM_DRAGOVER:
     643    ok = FALSE;
     644    if (!emphasized)
     645    {
     646      POINTL ptl;
     647      POINTL ptl2;
     648      emphasized = TRUE;
     649      ptl.x = SHORT1FROMMP(mp2);
     650      ptl.y = SHORT2FROMMP(mp2);
     651      ptl2 = ptl;
     652      WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl2, 1);
     653      fprintf(stderr, "DRAGOVER mapped x y %d %d to %d %d\n", ptl.x, ptl.y, ptl2.x, ptl2.y);
     654      WinPostMsg(hwnd, WM_BUTTON1CLICK,
     655                 MPFROM2SHORT((SHORT)ptl2.x, (SHORT)ptl2.y),
     656                 MPFROM2SHORT(HT_NORMAL, KC_NONE));
     657      fprintf(stderr, "DRAGOVER posted 0x%x WM_BUTTON1CLICK x y %d %d\n", hwnd, ptl2.x, ptl2.y);
     658    }
     659    pdinfo = (PDRAGINFO)mp1;            /* Get DRAGINFO pointer */
     660    if (pdinfo) {
     661      DrgAccessDraginfo(pdinfo);
     662      pditem = DrgQueryDragitemPtr(pdinfo,0);
     663      /* Check valid rendering mechanisms and data format */
     664      ok = DrgVerifyRMF(pditem, DRM_LBOX, NULL);
     665      DrgFreeDraginfo(pdinfo);
     666      if (ok) {
     667      }
     668    }
     669    return ok ? MRFROM2SHORT(DOR_DROP, DO_MOVE) : MRFROM2SHORT(DOR_NEVERDROP, 0);
     670
     671  case DM_DRAGLEAVE:
     672    if (emphasized)
     673    {
     674      emphasized = FALSE;
     675      // fixme to draw listbox item emphasized
     676      // DrawTargetEmphasis(hwnd, emphasized);
     677      fprintf(stderr, "DRAGLEAVE\n");
     678      fflush(stderr);
     679    }
     680    return 0;
     681
     682  case DM_DROPHELP:
     683    DropHelp(mp1, mp2, hwnd, "fixme to give some help");
     684    return 0;
     685
     686  case DM_DROP:
     687    ok = FALSE;
     688    fprintf(stderr, "DROP\n");
     689    fflush(stderr);
     690    if (emphasized)
     691    {
     692      emphasized = FALSE;
     693      // DrawTargetEmphasis(hwnd, emphasized);
     694    }
     695    pdinfo = (PDRAGINFO)mp1;            /* Get DRAGINFO pointer */
     696    if (pdinfo) {
     697      DrgAccessDraginfo(pdinfo);
     698      pditem = DrgQueryDragitemPtr(pdinfo,0);
     699      if (!pditem)
     700        Win_Error(hwnd,hwnd,__FILE__,__LINE__,"DM_DROP");
     701      /* Check valid rendering mechanisms and data */
     702      ok = DrgVerifyRMF(pditem,DRM_LBOX,NULL) && ~pditem->fsControl & DC_PREPARE;
     703      if (ok) {
     704        // ret = FullDrgName(pditem,buffer,buflen);
     705        /* note: targetfail is returned to source for all items */
     706        DrgSendTransferMsg(pdinfo->hwndSource,DM_ENDCONVERSATION,
     707                           MPFROMLONG(pditem->ulItemID),
     708                           MPFROMLONG(DMFL_TARGETSUCCESSFUL));
     709      }
     710      DrgDeleteDraginfoStrHandles(pdinfo);
     711      DrgFreeDraginfo(pdinfo);
     712    }
     713    return 0;
     714  } // switch
     715  return pfnOldProc ? pfnOldProc(hwnd, msg, mp1, mp2) :
     716                      WinDefWindowProc(hwnd, msg, mp1, mp2);
     717}
     718
     719//=== SBoxDlgProc() Select archiver to use or edit, supports list reorder too ===
    470720
    471721MRESULT EXPENTRY SBoxDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    472722{
    473   /* dlg proc that allows selecting an archiver entry */
    474 
    475   ARC_TYPE **info, *temp, *test;
    476   SHORT sSelect, x;
    477   CHAR text[256];
     723  ARC_TYPE **ppatReturn;                // Where to return selected archiver
     724  ARC_TYPE *pat;
     725  SHORT sSelect;
     726  SHORT sItemCount;
     727  CHAR szItemText[256];
     728  CHAR szPCItemText[256];               // Parent or child item text
     729  SHORT i;
     730  APIRET apiret;
     731  BOOL fShowAll;
     732
     733  static SHORT sLastSelect = LIT_NONE;
    478734
    479735  switch (msg)
    480736  {
    481737  case WM_INITDLG:
    482     if (!loadedarcs)
     738    if (!arcsigsloaded)
    483739      load_archivers();
    484     if (!(ARC_TYPE **) mp2)
     740    if (!(ARC_TYPE **)mp2)
    485741    {
    486742      DosBeep(100, 100);
    … …  
    488744      break;
    489745    }
    490     info = (ARC_TYPE **) mp2;
    491     if (*info)
    492       *info = arcsighead;
    493     WinSetWindowPtr(hwnd, 0L, (PVOID) info);
    494     temp = arcsighead;
    495     WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
    496     /* this loop fills the listbox */
    497     {
    498       BOOL found = FALSE;
    499 
    500       while (temp)
    501       {
    502         /*
    503          * this inner loop tests for a dupe signature entry and assures
    504          * that only the entry at the top of the list gets used for
    505          * conversion; editing any is okay
    506          */
    507         if (*info)
    508         {
    509           test = arcsighead;
    510           while (test && test != temp)
    511           {
    512             if (test -> signature && temp -> signature &&
    513                 !strcmp(test -> signature, temp -> signature))
    514               goto ContinueHere;        // Got match
    515 
    516             test = test -> next;
    517           }
    518         }
    519 
    520         if (!*info || (temp -> id && temp -> extract && temp -> create))
    521         {
    522           sSelect = (SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
    523                                               MPFROM2SHORT(LIT_END, 0),
    524                                               MPFROMP((temp -> id) ?
    525                                                       temp -> id : "?"));
    526           if (!found && *szDefArc && temp -> id && !strcmp(szDefArc, temp -> id))
    527           {
    528             WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
    529                               MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
    530             found = TRUE;
    531           }
    532         }
     746    /* Passed arg points to where to return selected archiver definition
     747     * On input arg value controls selection list content
     748     * If non-NULL, dup names are suppressed
     749     * If NULL, all definitions are shown
     750     */
     751    ppatReturn = (ARC_TYPE **)mp2;
     752    fShowAll = *ppatReturn == NULL;
     753    if (*ppatReturn)
     754      *ppatReturn = arcsighead;         // Preset to first
     755    WinSetWindowPtr(hwnd, QWL_USER, (PVOID)ppatReturn);
     756    fill_listbox(hwnd, fShowAll, sLastSelect);
     757
     758#ifdef TEST_DRAG                        // fixme
     759    {
     760      HWND hwnd2 = WinWindowFromID(hwnd, ASEL_LISTBOX);
     761      PFNWP pfn = WinSubclassWindow(hwnd2,
     762                                    SDlgListboxSubclassProc);
     763      WinSetWindowPtr(hwnd2, QWL_USER, (PVOID) pfn);
     764    }
     765#endif // TEST_DRAG fixme
     766
     767    break;
     768
     769  case WM_COMMAND:
     770    ppatReturn = (ARC_TYPE **) WinQueryWindowPtr(hwnd, QWL_USER);
     771    switch (SHORT1FROMMP(mp1))
     772    {
     773    case DID_OK:
     774      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
     775                                        ASEL_LISTBOX,
     776                                        LM_QUERYSELECTION,
     777                                        MPFROMSHORT(LIT_FIRST),
     778                                        MPVOID);
     779      if (sSelect == LIT_NONE)
     780      {
     781        DosBeep(100, 100);
     782        return 0;
     783      }
     784      pat = arcsighead;
     785      if (*ppatReturn)
     786      {
     787        // If dups hidden, find archiver with matching id
     788        *szItemText = 0;
     789        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
     790                          MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
     791        if (!*szItemText)
     792          pat = NULL;
    533793        else
    534794        {
    535           if (!temp -> id || !*temp -> id)
    536             WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
    537                               MPFROM2SHORT(LIT_END, 0),
    538                               MPFROMP(GetPString(IDS_UNKNOWNUNUSABLETEXT)));
    539           else
     795          for (;pat; pat = pat -> next)
    540796          {
    541             CHAR s[81];
    542 
    543             sprintf(s, "%0.12s %s",
    544                     temp -> id,
    545                     GetPString(IDS_UNUSABLETEXT));
    546             WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
    547                               MPFROM2SHORT(LIT_END, 0),
    548                               MPFROMP(s));
    549           }
    550         }
    551 
    552       ContinueHere:
    553 
    554         temp = temp -> next;
    555       }
    556       if (found)
    557         PosOverOkay(hwnd);
    558     }
    559     break;
    560 
    561   case WM_COMMAND:
    562     info = (ARC_TYPE **) WinQueryWindowPtr(hwnd, 0L);
    563     switch (SHORT1FROMMP(mp1))
    564     {
    565     case DID_OK:
    566       sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
    567                                           ASEL_LISTBOX,
    568                                           LM_QUERYSELECTION,
    569                                           MPFROMSHORT(LIT_FIRST),
    570                                           MPVOID);
    571       if (sSelect >= 0)
    572       {
    573         temp = arcsighead;
    574         if (*info)
    575         {
    576           *text = 0;
    577           WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
    578                             MPFROM2SHORT(sSelect, 255), MPFROMP(text));
    579           if (*text)
    580           {
    581             while (temp)
    582             {
    583               if (temp -> id)
    584               {
    585                 if (!strcmp(text, temp -> id))
    586                   break;
    587               }
    588               temp = temp -> next;
    589             }
    590           }
    591           else
    592             temp = NULL;
    593         }
    594         else
    595         {
    596           x = 0;
    597           while (temp)
    598           {
    599             if (x >= sSelect)
    600               break;
    601             x++;
    602             temp = temp -> next;
    603           }
    604         }
    605         if (temp && (!*info || (temp -> id && temp -> extract &&
    606                                 temp -> create)))
    607         {
    608           *info = temp;
    609         }
    610         else
    611         {
    612           WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
    613                             MPFROMSHORT(LIT_NONE), FALSE);
    614           DosBeep(100, 100);
    615           temp = NULL;
    616           return 0;
    617         }
    618       }
    619       else
    620       {
     797            if (pat -> id && !strcmp(szItemText, pat -> id))
     798                break;          // Found it
     799          }
     800        }
     801      }
     802      else
     803      {
     804        // If dups not hidden, lookup by count
     805        for (i = 0; pat && i < sSelect; i++, pat = pat -> next)
     806          ; // Scan
     807      }
     808      if (pat && (!*ppatReturn ||
     809                  (pat -> id && pat -> extract && pat -> create)))
     810      {
     811        *ppatReturn = pat;
     812      }
     813      else
     814      {
     815        // Refuse to select
     816        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     817                          MPFROMSHORT(LIT_NONE), FALSE);
    621818        DosBeep(100, 100);
    622819        return 0;
    623820      }
     821      sLastSelect = sSelect;
    624822      WinDismissDlg(hwnd, TRUE);
    625823      return 0;
    626824
    627825    case DID_CANCEL:
    628       *info = NULL;
    629       PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
    630       break;
    631 
    632     default:
    633       break;
    634     }
    635     return 0;
     826      if (arcsigsmodified) {
     827        if (saymsg(MB_YESNO,
     828                   hwnd,
     829                   GetPString(IDS_ADCHANGESINMEMTEXT),
     830                   GetPString(IDS_ADREWRITETEXT),
     831                   NullStr) ==
     832            MBID_YES) {
     833          PSZ ab2 = searchpath(GetPString(IDS_ARCHIVERBB2));    // Rewrite without prompting
     834          rewrite_archiverbb2(ab2);
     835        }
     836      }
     837      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
     838                                        ASEL_LISTBOX,
     839                                        LM_QUERYSELECTION,
     840                                        MPFROMSHORT(LIT_FIRST),
     841                                        MPVOID);
     842      if (sSelect != LIT_NONE)
     843        sLastSelect = sSelect;
     844      *ppatReturn = NULL;
     845      PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);  // fixme to understand why needed
     846      return 0;
     847
     848    case ASEL_PB_ADD:
     849      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
     850                                        ASEL_LISTBOX,
     851                                        LM_QUERYSELECTION,
     852                                        MPFROMSHORT(LIT_FIRST),
     853                                        MPVOID);
     854      if (sSelect != LIT_NONE) {
     855        ARCDUMP ad;
     856        memset(&ad,0,sizeof(ARCDUMP));
     857        ad.info = malloc(sizeof(ARC_TYPE));
     858        if (ad.info) {
     859          memset(ad.info, 0, sizeof(ARC_TYPE));
     860          if (!WinDlgBox(HWND_DESKTOP,
     861                         hwnd,
     862                         ArcReviewDlgProc,
     863                         FM3ModHandle,
     864                         AD_FRAME,
     865                         MPFROMP(&ad)))
     866          {
     867            free(ad.info);
     868          }
     869          else {
     870            // Find self - assume all archivers listed since we are editing
     871            for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
     872              ; // Find self
     873
     874            if (!pat) {
     875              if (arcsighead)
     876                saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u", sSelect, __FILE__, __LINE__);
     877              else
     878                arcsighead = ad.info;
     879            }
     880            else {
     881              // Insert before
     882              if (pat->prev) {
     883                ad.info->next = pat;
     884                ad.info->prev = pat->prev;
     885                pat->prev->next = ad.info;
     886                pat->prev = ad.info;
     887              }
     888              else {
     889                arcsighead = ad.info;
     890                ad.info->next = pat;
     891                pat->prev = ad.info;
     892              }
     893            }
     894            WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
     895                              MPFROM2SHORT(sSelect, 0),
     896                              MPFROMP(ad.info -> id ? ad.info -> id : "?"));
     897            WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     898                              MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
     899            arcsigsmodified = TRUE;
     900          }
     901        }
     902      }
     903      return 0;
     904    case ASEL_PB_DELETE:
     905      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
     906                                        ASEL_LISTBOX,
     907                                        LM_QUERYSELECTION,
     908                                        MPFROMSHORT(LIT_FIRST),
     909                                        MPVOID);
     910      if (sSelect != LIT_NONE) {
     911        // Find self - assume all archivers listed since we are editing
     912        for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
     913          ; // Find self
     914
     915        if (!pat) {
     916          saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u",sSelect, __FILE__, __LINE__);
     917        }
     918        else {
     919          // Delete current
     920          if (pat->prev) {
     921            pat->prev->next = pat->next;
     922            if (pat->next)
     923              pat->next->prev = pat->prev;
     924          }
     925          else {
     926            arcsighead = pat->next;
     927            if (pat->next)
     928              pat->next->prev = pat->prev;
     929          }
     930        }
     931        free_arc_type(pat);
     932        arcsigsmodified = TRUE;
     933        WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEITEM,
     934                          MPFROM2SHORT(sSelect, 0),
     935                          MPVOID);
     936        sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
     937                                              MPVOID,MPVOID);
     938        if (sSelect >= sItemCount)
     939          sSelect--;
     940        if (sSelect >= 0) {
     941          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     942                            MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
     943        }
     944      }
     945      return 0;
     946    case ASEL_PB_UP:
     947      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
     948                                        ASEL_LISTBOX,
     949                                        LM_QUERYSELECTION,
     950                                        MPFROMSHORT(LIT_FIRST),
     951                                        MPVOID);
     952      if (sSelect != LIT_NONE && sSelect > 0) {
     953        // Find self - assume all archivers listed since we are editing
     954        for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
     955          ; // Find self
     956        if (!pat || !pat->prev) {
     957          saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u",sSelect, __FILE__, __LINE__);
     958        }
     959        else {
     960          ARC_TYPE *patGDad;
     961          ARC_TYPE *patDad;
     962          ARC_TYPE *patChild;
     963          patChild = pat->next;
     964          patDad = pat->prev;
     965          patGDad = patDad->prev;
     966          patDad->next = patChild;
     967          if (patChild)
     968            patChild->prev = patDad;
     969          patDad->prev = pat;
     970          pat->next = patDad;
     971          if (patGDad) {
     972            patGDad->next = pat;
     973            pat->prev = patGDad;
     974          }
     975          else {
     976            arcsighead = pat;
     977            pat->prev = NULL;
     978          }
     979
     980          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
     981                            MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
     982          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
     983                            MPFROM2SHORT(sSelect - 1, 255), MPFROMP(szPCItemText));
     984          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
     985                            MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
     986          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
     987                            MPFROMSHORT(sSelect - 1), MPFROMP(szItemText));
     988          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     989                            MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
     990          arcsigsmodified = TRUE;
     991        }
     992      }
     993      return 0;
     994    case ASEL_PB_DOWN:
     995      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYSELECTION,
     996                                         MPFROMSHORT(LIT_FIRST),MPVOID);
     997      sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
     998                                            MPVOID,MPVOID);
     999      if (sSelect != LIT_NONE && sSelect < sItemCount - 1) {
     1000        // Find self - assume all archivers listed since we are editing
     1001        for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
     1002          ; // Find self
     1003        if (!pat || !pat->next) {
     1004          saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d/%d at %s::%u",sSelect, sItemCount, __FILE__, __LINE__);
     1005        }
     1006        else {
     1007          ARC_TYPE *patDad;
     1008          ARC_TYPE *patChild;
     1009          patDad = pat->prev;
     1010          patChild = pat->next;
     1011          pat->next = patChild->next;
     1012          patChild->next = pat;
     1013          pat->prev = patChild;
     1014          patChild->prev = patDad;
     1015          if (patDad) {
     1016            patDad->next = patChild;
     1017            patChild->prev=patDad;
     1018          }
     1019          else {
     1020            arcsighead = patChild;
     1021            patChild->prev=NULL;
     1022          }
     1023
     1024          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
     1025                            MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
     1026          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
     1027                            MPFROM2SHORT(sSelect + 1, 255), MPFROMP(szPCItemText));
     1028          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
     1029                            MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
     1030          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
     1031                            MPFROMSHORT(sSelect + 1), MPFROMP(szItemText));
     1032          WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
     1033                            MPFROMSHORT(sSelect + 1), MPFROMSHORT(TRUE));
     1034          arcsigsmodified = TRUE;
     1035        }
     1036      }
     1037      return 0;
     1038
     1039    case ASEL_PB_REVERT:
     1040      // Reload without checking in case changed outside
     1041      sSelect = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYSELECTION,
     1042                                         MPFROMSHORT(LIT_FIRST),MPVOID);
     1043      load_archivers();
     1044      fill_listbox(hwnd, TRUE, sSelect);
     1045      return 0;
     1046
     1047    case IDM_HELP:
     1048      if (hwndHelp) {
     1049        WinSendMsg(hwndHelp,
     1050                   HM_DISPLAY_HELP,
     1051                   MPFROM2SHORT(HELP_EDITARC,0),        // fixme to be HELP_SELARC
     1052                   MPFROMSHORT(HM_RESOURCEID));
     1053      }
     1054    }
     1055    return 0;                           // WM_COMMAND
    6361056
    6371057  case WM_CONTROL:
    … …  
    6511071
    6521072/*
    653    02-08-96  23:55               1
     1073   see archiver.tmp
     1074   02-08-96  23:55              1
    6541075   8 Feb 96 23:55:32            2
    6551076   8 Feb 96  11:55p             3
    656    96-02-08 23:55:32             4
     1077   96-02-08 23:55:32            4
     1078   31-02-98  23:55              5
    6571079 */
    6581080
Note: See TracChangeset for help on using the changeset viewer.