source: trunk/dll/avl.c@ 306

Last change on this file since 306 was 306, checked in by root, 19 years ago

load_archivers: use get_archiver_line?(), clean nits
SBoxDlgProc: support move, add, delete
load_archivers: add reload support
load_archivers: support signatures containing 0s
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 30.3 KB
RevLine 
[123]1
2/***********************************************************************
3
4 $Id: avl.c 306 2006-06-27 00:24:18Z root $
5
[251]6 archiver.bb2 search, load, save and date parse
[123]7
[251]8 Copyright (c) 1993, 1998 M. Kimes
[306]9 Copyright (c) 2004, 2006 Steven H.Levine
[123]10
[247]11 01 Aug 04 SHL Rework lstrip/rstrip usage
12 13 Aug 05 SHL Beautify with indent
[248]13 13 Aug 05 SHL find_type: correct no sig exists bypass logic
[251]14 13 Aug 05 SHL SBoxDlgProc: avoid dereferencing NULL signature
[279]15 18 Aug 05 SHL Comments
[287]16 31 Dec 05 SHL indent -i2
[306]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
[123]22
23***********************************************************************/
24
[2]25#define INCL_WIN
[306]26#define INCL_WINSTDDRAG
[2]27#define INCL_DOS
[251]28#include <os2.h>
[2]29
30#include <stdlib.h>
31#include <stdio.h>
32#include <string.h>
33#include <share.h>
34#include <ctype.h>
[251]35
[2]36#include "fm3dll.h"
37#include "fm3dlg.h"
38#include "fm3str.h"
39
40#pragma alloc_text(MISC9,quick_find_type,find_type)
41
[306]42static void free_arc_type(ARC_TYPE *pat);
43static void fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect);
44
45//=== quick_find_type() ===
46
[247]47ARC_TYPE *quick_find_type(CHAR * filespec, ARC_TYPE * topsig)
48{
[287]49 ARC_TYPE *info, *found = NULL;
50 CHAR *p;
[2]51
[306]52 if (!arcsigsloaded)
[287]53 load_archivers();
54 p = strrchr(filespec, '.');
55 if (p)
56 {
57 p++;
58 info = (topsig) ? topsig : arcsighead;
59 while (info)
[247]60 {
[287]61 if (info -> ext &&
62 *(info -> ext) &&
63 !stricmp(p, info -> ext))
64 {
65 found = find_type(filespec, topsig);
66 break;
67 }
68 info = info -> next;
[2]69 }
[287]70 }
71 return found;
[2]72}
73
[306]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);
155}
156
[247]157ARC_TYPE *find_type(CHAR * filespec, ARC_TYPE * topsig)
158{
[287]159 HFILE handle;
160 ULONG action;
161 ULONG len;
162 ULONG l;
163 ARC_TYPE *info;
164 CHAR *p;
165 CHAR buffer[80];
[2]166
[306]167 if (!arcsigsloaded)
[287]168 load_archivers();
169 if (!topsig)
170 topsig = arcsighead;
171 DosError(FERR_DISABLEHARDERR);
172 if (DosOpen(filespec,
173 &handle,
174 &action,
175 0L,
176 0L,
177 OPEN_ACTION_FAIL_IF_NEW |
178 OPEN_ACTION_OPEN_IF_EXISTS,
179 OPEN_FLAGS_FAIL_ON_ERROR |
180 OPEN_FLAGS_NOINHERIT |
181 OPEN_FLAGS_RANDOMSEQUENTIAL |
182 OPEN_SHARE_DENYNONE |
183 OPEN_ACCESS_READONLY,
184 0L))
185 return NULL;
186 // Scan signatures
187 for (info = topsig; info; info = info -> next)
188 {
[306]189 if (info -> siglen == 0)
[247]190 {
[287]191 // No signature -- check extension
192 p = strrchr(filespec, '.');
193 if (p)
194 {
195 p++;
196 if (info -> ext &&
197 *(info -> ext) &&
198 !stricmp(p, info -> ext))
199 break; // Matched
200
201 }
202 continue; // Next sig
203
204 }
205 // Try signature match
[306]206 l = info -> siglen;
[287]207 l = min(l, 79);
208 if (!DosChgFilePtr(handle,
209 abs(info -> file_offset),
210 (info -> file_offset >= 0L) ?
211 FILE_BEGIN :
212 FILE_END,
213 &len))
214 {
215 if (!DosRead(handle,
216 buffer,
217 l,
218 &len) &&
219 len == l)
220 {
221 if (!memcmp(info -> signature,
222 buffer,
223 l))
224 break; // Matched
225
226 }
227 }
228 } // for
229
230 DosClose(handle); /* Either way, we're done for now */
231 return info; /* Return signature, if any */
[2]232}
233
[306]234//=== free_arc_type() free allocated ARC_TYPE ===
[2]235
[306]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 ===
309
[247]310INT load_archivers(VOID)
311{
[287]312 FILE *handle;
[306]313 CHAR s[ARCHIVER_LINE_BYTES + 1];
[287]314 CHAR *p;
[306]315 ARC_TYPE *pat;
316 ARC_TYPE *patLast;
[287]317 INT numlines = NUMLINES;
[306]318 INT i;
[2]319
[306]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
[287]331 DosEnterCritSec();
332 p = searchpath(GetPString(IDS_ARCHIVERBB2));
333 if (!p || !*p)
334 {
[2]335 DosExitCritSec();
[287]336 return -1;
337 }
338 handle = _fsopen(p, "r", SH_DENYWR);
339 DosExitCritSec();
340 if (!handle)
341 return -2;
342 strcpy(archiverbb2, p);
343 // Get lines per record count
[306]344 if (!get_archiver_line(s, handle))
[287]345 {
346 fclose(handle);
347 return -3;
348 }
349 if (*s)
350 numlines = atoi(s);
351 if (!*s || numlines < NUMLINES)
352 return -3;
353 // Parse rest
[306]354 pat = NULL;
355 patLast = NULL;
[287]356 while (!feof(handle))
357 {
[306]358 if (!get_archiver_line(s, handle))
[287]359 break; // EOF
360 // 1st non-blank line starts definition
361 // fixme to preserve comments
362 // fixme to avoid allocating empty fields
[306]363
[247]364 if (*s)
365 {
[306]366 pat = malloc(sizeof(ARC_TYPE));
367 if (!pat)
[287]368 break; // fixme to complain
369
[306]370 memset(pat, 0, sizeof(ARC_TYPE));
371 pat -> id = strdup(s);
372 if (!get_archiver_line(s, handle)) // line 2
373
[287]374 break;
375 if (*s)
[306]376 pat -> ext = strdup(s);
[287]377 else
[306]378 pat -> ext = NULL;
379 if (!get_archiver_line(s, handle)) // line 3
380
[287]381 break;
[306]382 pat -> file_offset = atol(s);
383 if (!get_archiver_line(s, handle)) // line 4
384
[287]385 break;
386 if (*s)
[306]387 pat -> list = strdup(s);
[287]388 else
[306]389 pat -> list = NULL;
390 if (!pat -> list)
[287]391 break;
[306]392 if (!get_archiver_line(s, handle)) // line 5
393
[287]394 break;
395 if (*s)
[306]396 pat -> extract = strdup(s);
[287]397 else
[306]398 pat -> extract = NULL;
399 if (!get_archiver_line(s, handle)) // line 6
400
[287]401 break;
402 if (*s)
[306]403 pat -> exwdirs = strdup(s);
[287]404 else
[306]405 pat -> exwdirs = NULL;
406 if (!get_archiver_line(s, handle)) // line 7
407
[287]408 break;
409 if (*s)
[306]410 pat -> test = strdup(s);
[287]411 else
[306]412 pat -> test = NULL;
413 if (!get_archiver_line(s, handle)) // line 8
414
[287]415 break;
416 if (*s)
[306]417 pat -> create = strdup(s);
[287]418 else
[306]419 pat -> create = NULL;
420 if (!get_archiver_line(s, handle)) // line 9
421
[287]422 break;
423 if (*s)
[306]424 pat -> createwdirs = strdup(s);
[287]425 else
[306]426 pat -> createwdirs = NULL;
427 if (!get_archiver_line(s, handle)) // line 10
428
[287]429 break;
430 if (*s)
[306]431 pat -> createrecurse = strdup(s);
[287]432 else
[306]433 pat -> createrecurse = NULL;
434 if (!get_archiver_line(s, handle)) // line 11
435
[287]436 break;
437 if (*s)
[306]438 pat -> move = strdup(s);
[287]439 else
[306]440 pat -> move = NULL;
441 if (!get_archiver_line(s, handle)) // line 12
442
[287]443 break;
444 if (*s)
[306]445 pat -> movewdirs = strdup(s);
[287]446 else
[306]447 pat -> movewdirs = NULL;
448 if (!get_archiver_line(s, handle)) // line 13
449
[287]450 break;
[306]451 pat -> delete = strdup(s);
452
453 if (!get_archiver_line2(s, handle)) // line 14
[287]454 break;
[306]455 i = literal(s); // Translate \ escapes
456 if (i)
[287]457 {
[306]458 pat -> siglen = i;
459 pat -> signature = malloc(i);
460 if (!pat -> signature)
[287]461 break;
[306]462 memcpy(pat -> signature, s, i); // signature may not be a string
[287]463 }
[306]464 else {
465 pat -> siglen = 0;
466 pat -> signature = NULL;
467 }
468 if (!get_archiver_line2(s, handle)) // line 15
469
470 break;
471 if (*s)
472 pat -> startlist = strdup(s);
[287]473 else
[306]474 pat -> startlist = NULL;
475 if (!get_archiver_line2(s, handle)) // line 16
476
[287]477 break;
478 if (*s)
[306]479 pat -> endlist = strdup(s);
[287]480 else
[306]481 pat -> endlist = NULL;
482 if (!get_archiver_line(s, handle)) // line 17
483
[287]484 break;
[306]485 pat -> osizepos = atoi(s);
486 if (!get_archiver_line(s, handle)) // line 18
487
[287]488 break;
[306]489 pat -> nsizepos = atoi(s);
490 if (!get_archiver_line(s, handle)) // line 19
491
[287]492 break;
[306]493 pat -> fdpos = atoi(s);
[287]494 p = strchr(s, ',');
495 if (p)
496 {
497 p++;
[306]498 pat -> datetype = atoi(p);
[287]499 }
[306]500 if (!get_archiver_line(s, handle)) // line 20
501
[287]502 break;
[306]503 pat -> fdflds = atoi(s);
504 if (!get_archiver_line(s, handle)) // line 21
505
[287]506 break;
[306]507 pat -> fnpos = atoi(s);
[287]508 p = strchr(s, ',');
509 if (p)
510 {
511 p++;
[306]512 pat -> nameislast = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
[287]513 p = strchr(p, ',');
[247]514 if (p)
515 {
[287]516 p++;
[306]517 pat -> nameisnext = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
[287]518 p = strchr(p, ',');
519 if (p)
520 {
521 p++;
[306]522 pat -> nameisfirst = (BOOL) (*p && atol(p) == 0) ? FALSE : TRUE;
[287]523 }
524 }
525 }
526 // Ignore unknown lines - must be newer file format
[306]527 for (i = NUMLINES; i < numlines; i++)
[287]528 {
[306]529 if (!get_archiver_line(s, handle))
[287]530 break;
531 }
[247]532
[306]533 pat -> next = NULL;
[279]534
[287]535 if (!arcsighead)
536 {
[306]537 arcsighead = patLast = pat;
538 pat -> prev = NULL;
[287]539 }
540 else
541 {
[306]542 patLast -> next = pat;
543 pat -> prev = patLast;
544 patLast = pat;
[287]545 }
[306]546 if (pat -> extract && !*pat -> extract)
[287]547 {
[306]548 free(pat -> extract);
549 pat -> extract = NULL;
[287]550 }
[306]551 } // if got definition
[279]552
[306]553 pat = NULL;
554 } // while lines
[287]555 fclose(handle);
[306]556
557 free_arc_type(pat);
558
[287]559 if (!arcsighead)
560 return -4;
[306]561
562 arcsigsloaded = TRUE;
563
[287]564 return 0;
[2]565}
566
[306]567#define TEST_DRAG 0 // fixme to gone
[2]568
[306]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 ===
720
[247]721MRESULT EXPENTRY SBoxDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
722{
[306]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;
[2]732
[306]733 static SHORT sLastSelect = LIT_NONE;
[2]734
[287]735 switch (msg)
736 {
737 case WM_INITDLG:
[306]738 if (!arcsigsloaded)
[287]739 load_archivers();
[306]740 if (!(ARC_TYPE **)mp2)
[247]741 {
[287]742 DosBeep(100, 100);
743 WinDismissDlg(hwnd, 0);
744 break;
745 }
[306]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
[287]759 {
[306]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
[287]766
[306]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)
[287]780 {
[306]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;
793 else
[247]794 {
[306]795 for (;pat; pat = pat -> next)
[287]796 {
[306]797 if (pat -> id && !strcmp(szItemText, pat -> id))
798 break; // Found it
[287]799 }
800 }
[306]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);
818 DosBeep(100, 100);
819 return 0;
820 }
821 sLastSelect = sSelect;
822 WinDismissDlg(hwnd, TRUE);
823 return 0;
[2]824
[306]825 case DID_CANCEL:
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)))
[287]866 {
[306]867 free(ad.info);
[287]868 }
[306]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
[2]873
[306]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 }
[287]894 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
[306]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;
[287]900 }
901 }
902 }
[306]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
[2]914
[306]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;
[287]924 }
[306]925 else {
926 arcsighead = pat->next;
927 if (pat->next)
928 pat->next->prev = pat->prev;
929 }
[247]930 }
[306]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;
[287]974 }
[306]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;
[287]991 }
[306]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__);
[287]1005 }
[306]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));
[287]1032 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
[306]1033 MPFROMSHORT(sSelect + 1), MPFROMSHORT(TRUE));
1034 arcsigsmodified = TRUE;
[287]1035 }
1036 }
1037 return 0;
[2]1038
[306]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;
[2]1046
[306]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 }
[247]1054 }
[306]1055 return 0; // WM_COMMAND
[287]1056
1057 case WM_CONTROL:
1058 if (SHORT1FROMMP(mp1) == ASEL_LISTBOX && SHORT2FROMMP(mp1) == LN_ENTER)
1059 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
1060 return 0;
1061
1062 case WM_CLOSE:
1063 WinDismissDlg(hwnd, FALSE);
1064 return 0;
1065
1066 default:
1067 break;
1068 }
1069 return WinDefDlgProc(hwnd, msg, mp1, mp2);
[2]1070}
1071
1072/*
[306]1073 see archiver.tmp
1074 02-08-96 23:55 1
[247]1075 8 Feb 96 23:55:32 2
1076 8 Feb 96 11:55p 3
[306]1077 96-02-08 23:55:32 4
1078 31-02-98 23:55 5
[247]1079 */
[2]1080
1081#pragma alloc_text(ARCCNRS,ArcDateTime)
1082
[247]1083BOOL ArcDateTime(CHAR * dt, INT type, CDATE * cdate, CTIME * ctime)
1084{
[287]1085 INT x;
1086 BOOL ret = FALSE;
1087 CHAR *p, *pp, *pd;
[2]1088
[287]1089 if (dt && cdate && ctime)
1090 {
1091 memset(cdate, 0, sizeof(CDATE));
1092 memset(ctime, 0, sizeof(CTIME));
1093 if (type)
[247]1094 {
[287]1095 p = dt;
1096 while (*p && *p == ' ')
1097 p++;
1098 pd = dt;
1099 switch (type)
1100 {
1101 case 1:
1102 cdate -> month = atoi(pd);
1103 p = to_delim(pd, "-/.");
1104 if (p)
[247]1105 {
[287]1106 p++;
1107 cdate -> day = atoi(p);
1108 pd = p;
1109 p = to_delim(pd, "-/.");
1110 if (p)
1111 {
1112 p++;
1113 cdate -> year = atoi(p);
1114 if (cdate -> year > 80 && cdate -> year < 1900)
1115 cdate -> year += 1900;
1116 else if (cdate -> year < 1900)
1117 cdate -> year += 2000;
1118 ret = TRUE;
1119 p = strchr(p, ' ');
1120 if (p)
1121 {
1122 while (*p && *p == ' ')
[247]1123 p++;
[287]1124 ctime -> hours = atoi(p);
1125 p = to_delim(pd, ":.");
1126 if (p)
1127 {
1128 p++;
1129 ctime -> minutes = atoi(p);
1130 p = to_delim(pd, ":.");
[247]1131 if (p)
1132 {
[287]1133 p++;
1134 ctime -> seconds = atoi(p);
[247]1135 }
[287]1136 }
1137 }
1138 }
1139 }
1140 break;
[2]1141
[287]1142 case 2:
1143 cdate -> day = atoi(p);
1144 p = strchr(p, ' ');
1145 if (p)
1146 {
1147 p++;
1148 for (x = 0; x < 12; x++)
1149 {
1150 if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1151 break;
1152 }
1153 if (x < 12)
1154 {
1155 cdate -> month = x;
1156 p = strchr(p, ' ');
1157 if (p)
1158 {
1159 p++;
1160 cdate -> year = atoi(p);
1161 if (cdate -> year > 80 && cdate -> year < 1900)
1162 cdate -> year += 1900;
1163 else if (cdate -> year < 1900)
1164 cdate -> year += 2000;
1165 ret = TRUE;
1166 p = strchr(p, ' ');
1167 if (p)
1168 {
1169 while (*p && *p == ' ')
1170 p++;
1171 ctime -> hours = atoi(p);
1172 p = to_delim(pd, ":.");
[247]1173 if (p)
1174 {
[287]1175 p++;
1176 ctime -> minutes = atoi(p);
1177 p = to_delim(pd, ":.");
1178 if (p)
1179 {
[247]1180 p++;
[287]1181 ctime -> seconds = atoi(p);
1182 }
[247]1183 }
[287]1184 }
1185 }
1186 }
1187 }
1188 break;
[2]1189
[287]1190 case 3:
1191 cdate -> day = atoi(p);
1192 p = strchr(p, ' ');
1193 if (p)
1194 {
1195 p++;
1196 for (x = 0; x < 12; x++)
1197 {
1198 if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1199 break;
1200 }
1201 if (x < 12)
1202 {
1203 cdate -> month = x;
1204 p = strchr(p, ' ');
1205 if (p)
1206 {
1207 p++;
1208 cdate -> year = atoi(p);
1209 if (cdate -> year > 80 && cdate -> year < 1900)
1210 cdate -> year += 1900;
1211 else if (cdate -> year < 1900)
1212 cdate -> year += 2000;
1213 ret = TRUE;
1214 p = strchr(p, ' ');
1215 if (p)
1216 {
1217 while (*p && *p == ' ')
1218 p++;
1219 ctime -> hours = atoi(p);
1220 p = to_delim(pd, ":.");
[247]1221 if (p)
1222 {
[287]1223 p++;
1224 pp = p;
1225 ctime -> minutes = atoi(p);
1226 p = to_delim(pd, ":.");
1227 if (p)
1228 {
[247]1229 p++;
[287]1230 ctime -> seconds = atoi(p);
1231 p += 2;
1232 if (toupper(*p) == 'P')
1233 ctime -> hours += 12;
1234 }
1235 else
1236 {
1237 p = pp;
1238 p += 2;
1239 if (toupper(*p) == 'P')
1240 ctime -> hours += 12;
1241 }
[247]1242 }
[287]1243 }
1244 }
1245 }
1246 }
1247 break;
[2]1248
[287]1249 case 4:
1250 cdate -> year = atoi(p);
1251 if (cdate -> year > 80 && cdate -> year < 1900)
1252 cdate -> year += 1900;
1253 else if (cdate -> year < 1900)
1254 cdate -> year += 2000;
1255 p = to_delim(pd, "-/.");
1256 if (p)
1257 {
1258 p++;
1259 cdate -> month = atoi(p);
1260 pd = p;
1261 p = to_delim(pd, "-/.");
1262 if (p)
1263 {
1264 p++;
1265 cdate -> day = atoi(p);
1266 ret = TRUE;
1267 p = strchr(p, ' ');
1268 if (p)
1269 {
1270 while (*p && *p == ' ')
1271 p++;
1272 ctime -> hours = atoi(p);
1273 p = to_delim(pd, ":.");
1274 if (p)
1275 {
1276 p++;
1277 ctime -> minutes = atoi(p);
1278 p = to_delim(pd, ":.");
[247]1279 if (p)
1280 {
[287]1281 p++;
1282 ctime -> seconds = atoi(p);
[247]1283 }
[287]1284 }
1285 }
1286 }
1287 }
1288 break;
[2]1289
[287]1290 case 5:
1291 cdate -> day = atoi(pd);
1292 p = to_delim(pd, "-/.");
1293 if (p)
1294 {
1295 p++;
1296 cdate -> month = atoi(p);
1297 pd = p;
1298 p = to_delim(pd, "-/.");
1299 if (p)
1300 {
1301 p++;
1302 cdate -> year = atoi(p);
1303 if (cdate -> year > 80 && cdate -> year < 1900)
1304 cdate -> year += 1900;
1305 else if (cdate -> year < 1900)
1306 cdate -> year += 2000;
1307 ret = TRUE;
1308 p = strchr(p, ' ');
1309 if (p)
1310 {
1311 while (*p && *p == ' ')
1312 p++;
1313 ctime -> hours = atoi(p);
1314 p = to_delim(pd, ":.");
1315 if (p)
1316 {
1317 p++;
1318 ctime -> minutes = atoi(p);
1319 p = to_delim(pd, ":.");
[247]1320 if (p)
1321 {
[287]1322 p++;
1323 ctime -> seconds = atoi(p);
[247]1324 }
[287]1325 }
[247]1326 }
[287]1327 }
[247]1328 }
[287]1329 break;
1330
1331 default:
1332 break;
1333 }
[2]1334 }
[287]1335 }
1336 return ret;
[2]1337}
Note: See TracBrowser for help on using the repository browser.