source: trunk/dll/avl.c@ 329

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

load_archivers: remember where comments are
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 32.1 KB
Line 
1
2/***********************************************************************
3
4 $Id: avl.c 312 2006-06-28 21:35:26Z root $
5
6 archiver.bb2 search, load, save and date parse
7
8 Copyright (c) 1993, 1998 M. Kimes
9 Copyright (c) 2004, 2006 Steven H.Levine
10
11 01 Aug 04 SHL Rework lstrip/rstrip usage
12 13 Aug 05 SHL Beautify with indent
13 13 Aug 05 SHL find_type: correct no sig exists bypass logic
14 13 Aug 05 SHL SBoxDlgProc: avoid dereferencing NULL signature
15 18 Aug 05 SHL Comments
16 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
22 26 Jun 06 SHL load_archivers: remember where comments are
23
24***********************************************************************/
25
26#define INCL_WIN
27#define INCL_WINSTDDRAG
28#define INCL_DOS
29#include <os2.h>
30
31#include <stdlib.h>
32#include <stdio.h>
33#include <string.h>
34#include <share.h>
35#include <ctype.h>
36
37#include "fm3dll.h"
38#include "fm3dlg.h"
39#include "fm3str.h"
40
41#pragma alloc_text(MISC9,quick_find_type,find_type)
42
43static void free_arc_type(ARC_TYPE *pat);
44static void fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect);
45
46//=== quick_find_type() ===
47
48ARC_TYPE *quick_find_type(CHAR *filespec, ARC_TYPE *topsig)
49{
50 ARC_TYPE *info, *found = NULL;
51 CHAR *p;
52
53 if (!arcsigsloaded)
54 load_archivers();
55 p = strrchr(filespec, '.');
56 if (p)
57 {
58 p++;
59 info = (topsig) ? topsig : arcsighead;
60 while (info)
61 {
62 if (info -> ext &&
63 *(info -> ext) &&
64 !stricmp(p, info -> ext))
65 {
66 found = find_type(filespec, topsig);
67 break;
68 }
69 info = info -> next;
70 }
71 }
72 return found;
73}
74
75//=== fill_listbox() fill or refill listbox from current archiver definitions ===
76
77static VOID fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect)
78{
79 ARC_TYPE *pat;
80 BOOL found = FALSE;
81 SHORT sSelect;
82
83 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
84
85 for (pat = arcsighead; pat; pat = pat -> next)
86 {
87 /*
88 * this inner loop tests for a dup signature entry and assures
89 * that only the entry at the top of the list gets used for
90 * conversion; editing any is okay
91 */
92 if (!fShowAll)
93 {
94 ARC_TYPE *pat2;
95 BOOL isDup = FALSE;
96 for (pat2 = arcsighead;
97 pat2 && pat -> siglen && pat2 != pat && !isDup;
98 pat2 = pat2 -> next)
99 {
100 isDup = pat2 -> siglen == pat -> siglen &&
101 !memcmp(pat2 -> signature, pat -> signature, pat -> siglen);
102 } // for
103 if (isDup)
104 continue;
105 }
106
107 // If caller is editing archivers or entry useful to caller, show in listbox
108 if (fShowAll || (pat -> id && pat -> extract && pat -> create))
109 {
110 sSelect = (SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
111 MPFROM2SHORT(LIT_END, 0),
112 MPFROMP(pat -> id ?
113 pat -> id : "?"));
114 if (!found && *szDefArc && pat -> id && !strcmp(szDefArc, pat -> id))
115 {
116 // Highlight default
117 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
118 MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
119 found = TRUE;
120 }
121 }
122 else
123 {
124 // Complain about odd entry
125 if (!pat -> id || !*pat -> id)
126 {
127 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
128 MPFROM2SHORT(LIT_END, 0),
129 MPFROMP(GetPString(IDS_UNKNOWNUNUSABLETEXT)));
130 }
131 else
132 {
133 CHAR s[81];
134 sprintf(s, "%0.12s %s", pat -> id, GetPString(IDS_UNUSABLETEXT));
135 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
136 MPFROM2SHORT(LIT_END, 0),
137 MPFROMP(s));
138 }
139 }
140 } // while scanning
141
142 // Try to reselect last selection unless user wants default selection
143 if (sOldSelect != LIT_NONE && !found) {
144 SHORT sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
145 MPVOID,MPVOID);
146 if (sOldSelect >= sItemCount)
147 sOldSelect = sItemCount - 1;
148 if (sOldSelect >= 0) {
149 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
150 MPFROMSHORT(sOldSelect), MPFROMSHORT(TRUE));
151 }
152 }
153
154 if (found)
155 PosOverOkay(hwnd);
156}
157
158ARC_TYPE *find_type(CHAR *filespec, ARC_TYPE *topsig)
159{
160 HFILE handle;
161 ULONG action;
162 ULONG len;
163 ULONG l;
164 ARC_TYPE *info;
165 CHAR *p;
166 CHAR buffer[80];
167
168 if (!arcsigsloaded)
169 load_archivers();
170 if (!topsig)
171 topsig = arcsighead;
172 DosError(FERR_DISABLEHARDERR);
173 if (DosOpen(filespec,
174 &handle,
175 &action,
176 0L,
177 0L,
178 OPEN_ACTION_FAIL_IF_NEW |
179 OPEN_ACTION_OPEN_IF_EXISTS,
180 OPEN_FLAGS_FAIL_ON_ERROR |
181 OPEN_FLAGS_NOINHERIT |
182 OPEN_FLAGS_RANDOMSEQUENTIAL |
183 OPEN_SHARE_DENYNONE |
184 OPEN_ACCESS_READONLY,
185 0L))
186 return NULL;
187 // Scan signatures
188 for (info = topsig; info; info = info -> next)
189 {
190 if (info -> siglen == 0)
191 {
192 // No signature -- check extension
193 p = strrchr(filespec, '.');
194 if (p)
195 {
196 p++;
197 if (info -> ext &&
198 *(info -> ext) &&
199 !stricmp(p, info -> ext))
200 break; // Matched
201
202 }
203 continue; // Next sig
204
205 }
206 // Try signature match
207 l = info -> siglen;
208 l = min(l, 79);
209 if (!DosChgFilePtr(handle,
210 abs(info -> file_offset),
211 (info -> file_offset >= 0L) ?
212 FILE_BEGIN :
213 FILE_END,
214 &len))
215 {
216 if (!DosRead(handle,
217 buffer,
218 l,
219 &len) &&
220 len == l)
221 {
222 if (!memcmp(info -> signature,
223 buffer,
224 l))
225 break; // Matched
226
227 }
228 }
229 } // for
230
231 DosClose(handle); /* Either way, we're done for now */
232 return info; /* Return signature, if any */
233}
234
235//=== free_arc_type() free allocated ARC_TYPE ===
236
237static void free_arc_type(ARC_TYPE *pat)
238{
239 if (pat)
240 {
241 if (pat -> id)
242 free(pat -> id);
243 if (pat -> ext)
244 free(pat -> ext);
245 if (pat -> list)
246 free(pat -> list);
247 if (pat -> extract)
248 free(pat -> extract);
249 if (pat -> create)
250 free(pat -> create);
251 if (pat -> move)
252 free(pat -> move);
253 if (pat -> delete)
254 free(pat -> delete);
255 if (pat -> signature)
256 free(pat -> signature);
257 if (pat -> startlist)
258 free(pat -> startlist);
259 if (pat -> endlist)
260 free(pat -> endlist);
261 if (pat -> exwdirs)
262 free(pat -> exwdirs);
263 if (pat -> test)
264 free(pat -> test);
265 if (pat -> createrecurse)
266 free(pat -> createrecurse);
267 if (pat -> createwdirs)
268 free(pat -> createwdirs);
269 if (pat -> movewdirs)
270 free(pat -> movewdirs);
271 free(pat);
272 }
273}
274
275static UINT cur_line_num; // Input file line counter
276
277#pragma alloc_text(AVL,load_archivers, get_line_strip_comments, get_line_strip_white)
278
279//=== get_line_strip_comments() read line, strip comments and whitespace ===
280
281#define ARCHIVER_LINE_BYTES 256
282
283static PSZ get_line_strip_comments(PSZ pszIn, FILE *fp)
284{
285 PSZ psz = fgets(pszIn, ARCHIVER_LINE_BYTES, fp);
286 PSZ psz2;
287
288 if (psz) {
289 cur_line_num++;
290 psz2 = strchr(pszIn, ';');
291 if (psz2)
292 *psz2 = 0; // Chop comment
293 bstripcr(pszIn); // Strip leading white and trailing white and CR/LF
294
295 }
296 return psz;
297}
298
299//=== get_line_strip_white() read line, strip whitespace ===
300
301static PSZ get_line_strip_white(PSZ pszIn, FILE *fp)
302{
303 PSZ psz = fgets(pszIn, ARCHIVER_LINE_BYTES, fp);
304
305 if (psz) {
306 cur_line_num++;
307 bstripcr(pszIn); // Strip lead white and trailing white and CR/LF
308 }
309
310 return psz;
311}
312
313//=== load_archivers() load or reload archive definitions from archiver.bb2 ===
314
315INT load_archivers(VOID)
316{
317 FILE *fp;
318 CHAR sz[ARCHIVER_LINE_BYTES + 1];
319 CHAR *psz;
320 ARC_TYPE *pat = NULL;
321 ARC_TYPE *patLast = NULL;
322 UINT lines_per_arcsig = LINES_PER_ARCSIG;
323 UINT per_sig_comment_line_num = 0;
324 INT i;
325
326 // Free current signatures
327 if (arcsighead) {
328 for (pat = arcsighead; pat;) {
329 patLast = pat;
330 pat = pat->next;
331 free_arc_type(patLast);
332 }
333 arcsighead = NULL;
334 }
335
336 arcsigsmodified = FALSE;
337 arcsigs_header_lines = 0;
338 arcsigs_trailer_line_num = 0;
339
340 DosEnterCritSec();
341 psz = searchpath(GetPString(IDS_ARCHIVERBB2));
342 if (!psz || !*psz)
343 {
344 DosExitCritSec();
345 return -1;
346 }
347 fp = _fsopen(psz, "r", SH_DENYWR);
348 DosExitCritSec();
349 if (!fp)
350 return -2;
351 strcpy(archiverbb2, psz); // Remember full path
352
353 cur_line_num = 0;
354
355 // Line 1 must contain number of lines per signature definition
356 if (!get_line_strip_comments(sz, fp))
357 {
358 fclose(fp);
359 return -3;
360 }
361 if (*sz)
362 lines_per_arcsig = atoi(sz);
363 if (!*sz || lines_per_arcsig < LINES_PER_ARCSIG)
364 return -3;
365
366 // Parse rest of file
367 // 1st non-blank line starts definition
368 // Need to determine header size and start of trailer
369
370 while (!feof(fp))
371 {
372 // If reading header
373 if (!arcsigs_header_lines) {
374 // Reading header - find header size and start of signtures
375 if (!get_line_strip_white(sz, fp))
376 break; // Unexpected EOF
377 if (stristr(sz, "-- Current Archivers --")) {
378 arcsigs_header_lines = cur_line_num;
379 continue;
380 }
381 if (!*sz || *sz == ';')
382 continue; // Header comment or blank line
383 else {
384 // Not a comment, must be start of signatures
385 PSZ psz2 = strchr(sz, ';');
386 if (psz2) {
387 *psz2 = 0; // Chop trailing comment
388 bstripcr(sz); // Strip leading white and trailing white and CR/LF
389 }
390 arcsigs_header_lines = cur_line_num - 1;
391 }
392 }
393 else {
394 // Reading defintiions
395 if (!get_line_strip_comments(sz, fp))
396 break; // EOF
397 }
398
399 // fixme to avoid allocating empty fields
400
401 // Remember start of per sig comments for next definition
402 if (per_sig_comment_line_num == 0)
403 per_sig_comment_line_num = cur_line_num;
404
405 if (*sz)
406 {
407 // At start of defintion
408
409 pat = malloc(sizeof(ARC_TYPE));
410 if (!pat)
411 break; // fixme to complain
412
413 memset(pat, 0, sizeof(ARC_TYPE));
414 pat -> id = strdup(sz);
415
416 pat -> comment_line_num = per_sig_comment_line_num;
417 pat -> defn_line_num = cur_line_num;
418
419 if (!get_line_strip_comments(sz, fp)) // line 2 - extension
420 break;
421 if (*sz)
422 pat -> ext = strdup(sz);
423 else
424 pat -> ext = NULL;
425 if (!get_line_strip_comments(sz, fp)) // line 3 - offset to signature
426 break;
427 pat -> file_offset = atol(sz);
428 if (!get_line_strip_comments(sz, fp)) // line 4 - list command
429 break;
430 if (*sz)
431 pat -> list = strdup(sz);
432 else
433 pat -> list = NULL;
434 if (!pat -> list)
435 break; // Must have list command - fixme to complain
436 if (!get_line_strip_comments(sz, fp)) // line 5
437 break;
438 if (*sz)
439 pat -> extract = strdup(sz);
440 else
441 pat -> extract = NULL;
442 if (!get_line_strip_comments(sz, fp)) // line 6
443 break;
444 if (*sz)
445 pat -> exwdirs = strdup(sz);
446 else
447 pat -> exwdirs = NULL;
448 if (!get_line_strip_comments(sz, fp)) // line 7
449 break;
450 if (*sz)
451 pat -> test = strdup(sz);
452 else
453 pat -> test = NULL;
454 if (!get_line_strip_comments(sz, fp)) // line 8
455 break;
456 if (*sz)
457 pat -> create = strdup(sz);
458 else
459 pat -> create = NULL;
460 if (!get_line_strip_comments(sz, fp)) // line 9
461 break;
462 if (*sz)
463 pat -> createwdirs = strdup(sz);
464 else
465 pat -> createwdirs = NULL;
466 if (!get_line_strip_comments(sz, fp)) // line 10
467 break;
468 if (*sz)
469 pat -> createrecurse = strdup(sz);
470 else
471 pat -> createrecurse = NULL;
472 if (!get_line_strip_comments(sz, fp)) // line 11
473 break;
474 if (*sz)
475 pat -> move = strdup(sz);
476 else
477 pat -> move = NULL;
478 if (!get_line_strip_comments(sz, fp)) // line 12
479 break;
480 if (*sz)
481 pat -> movewdirs = strdup(sz);
482 else
483 pat -> movewdirs = NULL;
484 if (!get_line_strip_comments(sz, fp)) // line 13
485 break;
486 if (*sz)
487 pat -> delete = strdup(sz);
488 else
489 pat -> delete = NULL;
490 if (!get_line_strip_white(sz, fp)) // line 14
491 break;
492 i = literal(sz); // Translate \ escapes
493 if (i)
494 {
495 pat -> siglen = i;
496 pat -> signature = malloc(i);
497 if (!pat -> signature)
498 break;
499 memcpy(pat -> signature, sz, i); // signature may not be a string
500 }
501 else {
502 pat -> siglen = 0;
503 pat -> signature = NULL;
504 }
505 if (!get_line_strip_white(sz, fp)) // line 15
506 break;
507 if (*sz)
508 pat -> startlist = strdup(sz);
509 else
510 pat -> startlist = NULL;
511 if (!get_line_strip_white(sz, fp)) // line 16
512 break;
513 if (*sz)
514 pat -> endlist = strdup(sz);
515 else
516 pat -> endlist = NULL;
517 if (!get_line_strip_comments(sz, fp)) // line 17
518 break;
519 pat -> osizepos = atoi(sz);
520 if (!get_line_strip_comments(sz, fp)) // line 18
521 break;
522 pat -> nsizepos = atoi(sz);
523 if (!get_line_strip_comments(sz, fp)) // line 19
524 break;
525 pat -> fdpos = atoi(sz);
526 psz = strchr(sz, ',');
527 if (psz)
528 {
529 psz++;
530 pat -> datetype = atoi(psz);
531 }
532 if (!get_line_strip_comments(sz, fp)) // line 20
533 break;
534 pat -> fdflds = atoi(sz);
535 if (!get_line_strip_comments(sz, fp)) // line 21
536 break;
537 pat -> fnpos = atoi(sz);
538 psz = strchr(sz, ',');
539 if (psz)
540 {
541 psz++;
542 pat -> nameislast = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
543 psz = strchr(psz, ',');
544 if (psz)
545 {
546 psz++;
547 pat -> nameisnext = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
548 psz = strchr(psz, ',');
549 if (psz)
550 {
551 psz++;
552 pat -> nameisfirst = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
553 }
554 }
555 }
556 // Ignore unknown lines - must be newer file format
557 for (i = LINES_PER_ARCSIG; i < lines_per_arcsig; i++)
558 {
559 if (!get_line_strip_comments(sz, fp))
560 break; // Unexpected EOF - fixme to complain
561 }
562
563 // Add to list, assume next and prev already NULL
564 if (!arcsighead)
565 arcsighead = patLast = pat;
566 else
567 {
568 patLast -> next = pat;
569 pat -> prev = patLast;
570 patLast = pat;
571 }
572 pat = NULL; // Done with this defintion
573
574 arcsigs_trailer_line_num = cur_line_num + 1; // In case this is last defintion
575 per_sig_comment_line_num = 0;
576 } // if got definition
577
578 } // while more lines
579
580 fclose(fp);
581
582 free_arc_type(pat); // In case partial definition in progress
583
584 if (!arcsighead)
585 return -4;
586
587 arcsigsloaded = TRUE;
588
589 return 0;
590}
591
592#define TEST_DRAG 0 // fixme to gone
593
594#pragma alloc_text(FMARCHIVE,SBoxDlgProc,SDlgListboxSubclassProc)
595
596static MRESULT EXPENTRY SDlgListboxSubclassProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
597{
598 PFNWP pfnOldProc = (PFNWP)WinQueryWindowPtr(hwnd, QWL_USER);
599
600 PDRAGITEM pditem;
601 PDRAGINFO pdinfo;
602 BOOL ok;
603
604 static BOOL emphasized = FALSE;
605 static PSZ DRMDRF_LBOX = "<DRM_LBOX,DRF_UNKNOWN>";
606 static PSZ DRM_LBOX = "DRM_LBOX";
607
608 switch (msg)
609 {
610 case WM_BEGINDRAG:
611 {
612 LONG cur_ndx;
613 DRAGITEM ditem;
614 DRAGIMAGE dimage;
615 HWND hwndDrop;
616
617 fprintf(stderr, "SDlgListboxSubclassProc: BEGINDRAG\n");
618 cur_ndx = WinQueryLboxSelectedItem(hwnd);
619
620 if (cur_ndx != LIT_NONE) {
621 pdinfo = DrgAllocDraginfo(1);
622 if(pdinfo) {
623 pdinfo->usOperation = DO_DEFAULT;
624 pdinfo->hwndSource = hwnd;
625
626 memset(&ditem,0,sizeof(DRAGITEM));
627 ditem.hwndItem = hwnd;
628 ditem.ulItemID = 1;
629 ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
630 ditem.hstrRMF = DrgAddStrHandle(DRMDRF_LBOX);
631 ditem.hstrContainerName = DrgAddStrHandle("");
632 ditem.hstrSourceName = DrgAddStrHandle("");
633 ditem.hstrTargetName = DrgAddStrHandle("");
634 // ditem.fsControl = 0;
635 ditem.fsSupportedOps = DO_MOVEABLE;
636
637 memset(&dimage,0,sizeof(DRAGIMAGE));
638 dimage.cb = sizeof(DRAGIMAGE);
639 dimage.hImage = hptrFile;
640 dimage.cptl = 0;
641 dimage.fl = DRG_ICON;
642 dimage.sizlStretch.cx = 32;
643 dimage.sizlStretch.cy = 32;
644 dimage.cxOffset = -16;
645 dimage.cyOffset = 0;
646 DrgSetDragitem(pdinfo,
647 &ditem,
648 sizeof(DRAGITEM),
649 0); /* Index of DRAGITEM */
650 hwndDrop = DrgDrag(hwnd,
651 pdinfo,
652 &dimage,
653 1, /* One DRAGIMAGE */
654 VK_ENDDRAG,
655 NULL);
656 if (!hwndDrop) {
657 Win_Error(hwnd,hwnd,__FILE__,__LINE__,"DrgDrag");
658 }
659
660 DrgFreeDraginfo(pdinfo);
661 // WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
662 }
663 }
664 break;
665 }
666
667 case DM_DRAGOVER:
668 ok = FALSE;
669 if (!emphasized)
670 {
671 POINTL ptl;
672 POINTL ptl2;
673 emphasized = TRUE;
674 ptl.x = SHORT1FROMMP(mp2);
675 ptl.y = SHORT2FROMMP(mp2);
676 ptl2 = ptl;
677 WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl2, 1);
678 fprintf(stderr, "DRAGOVER mapped x y %d %d to %d %d\n", ptl.x, ptl.y, ptl2.x, ptl2.y);
679 WinPostMsg(hwnd, WM_BUTTON1CLICK,
680 MPFROM2SHORT((SHORT)ptl2.x, (SHORT)ptl2.y),
681 MPFROM2SHORT(HT_NORMAL, KC_NONE));
682 fprintf(stderr, "DRAGOVER posted 0x%x WM_BUTTON1CLICK x y %d %d\n", hwnd, ptl2.x, ptl2.y);
683 }
684 pdinfo = (PDRAGINFO)mp1; /* Get DRAGINFO pointer */
685 if (pdinfo) {
686 DrgAccessDraginfo(pdinfo);
687 pditem = DrgQueryDragitemPtr(pdinfo,0);
688 /* Check valid rendering mechanisms and data format */
689 ok = DrgVerifyRMF(pditem, DRM_LBOX, NULL);
690 DrgFreeDraginfo(pdinfo);
691 if (ok) {
692 }
693 }
694 return ok ? MRFROM2SHORT(DOR_DROP, DO_MOVE) : MRFROM2SHORT(DOR_NEVERDROP, 0);
695
696 case DM_DRAGLEAVE:
697 if (emphasized)
698 {
699 emphasized = FALSE;
700 // fixme to draw listbox item emphasized
701 // DrawTargetEmphasis(hwnd, emphasized);
702 fprintf(stderr, "DRAGLEAVE\n");
703 fflush(stderr);
704 }
705 return 0;
706
707 case DM_DROPHELP:
708 DropHelp(mp1, mp2, hwnd, "fixme to give some help");
709 return 0;
710
711 case DM_DROP:
712 ok = FALSE;
713 fprintf(stderr, "DROP\n");
714 fflush(stderr);
715 if (emphasized)
716 {
717 emphasized = FALSE;
718 // DrawTargetEmphasis(hwnd, emphasized);
719 }
720 pdinfo = (PDRAGINFO)mp1; /* Get DRAGINFO pointer */
721 if (pdinfo) {
722 DrgAccessDraginfo(pdinfo);
723 pditem = DrgQueryDragitemPtr(pdinfo,0);
724 if (!pditem)
725 Win_Error(hwnd,hwnd,__FILE__,__LINE__,"DM_DROP");
726 /* Check valid rendering mechanisms and data */
727 ok = DrgVerifyRMF(pditem,DRM_LBOX,NULL) && ~pditem->fsControl & DC_PREPARE;
728 if (ok) {
729 // ret = FullDrgName(pditem,buffer,buflen);
730 /* note: targetfail is returned to source for all items */
731 DrgSendTransferMsg(pdinfo->hwndSource,DM_ENDCONVERSATION,
732 MPFROMLONG(pditem->ulItemID),
733 MPFROMLONG(DMFL_TARGETSUCCESSFUL));
734 }
735 DrgDeleteDraginfoStrHandles(pdinfo);
736 DrgFreeDraginfo(pdinfo);
737 }
738 return 0;
739 } // switch
740 return pfnOldProc ? pfnOldProc(hwnd, msg, mp1, mp2) :
741 WinDefWindowProc(hwnd, msg, mp1, mp2);
742}
743
744//=== SBoxDlgProc() Select archiver to use or edit, supports list reorder too ===
745
746MRESULT EXPENTRY SBoxDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
747{
748 ARC_TYPE **ppatReturn; // Where to return selected archiver
749 ARC_TYPE *pat;
750 SHORT sSelect;
751 SHORT sItemCount;
752 CHAR szItemText[256];
753 CHAR szPCItemText[256]; // Parent or child item text
754 SHORT i;
755 APIRET apiret;
756 BOOL fShowAll;
757
758 static SHORT sLastSelect = LIT_NONE;
759
760 switch (msg)
761 {
762 case WM_INITDLG:
763 if (!arcsigsloaded)
764 load_archivers();
765 if (!(ARC_TYPE **)mp2)
766 {
767 DosBeep(100, 100);
768 WinDismissDlg(hwnd, 0);
769 break;
770 }
771 /* Passed arg points to where to return selected archiver definition
772 * On input arg value controls selection list content
773 * If non-NULL, dup names are suppressed
774 * If NULL, all definitions are shown
775 */
776 ppatReturn = (ARC_TYPE **)mp2;
777 fShowAll = *ppatReturn == NULL;
778 if (*ppatReturn)
779 *ppatReturn = arcsighead; // Preset to first
780 WinSetWindowPtr(hwnd, QWL_USER, (PVOID)ppatReturn);
781 fill_listbox(hwnd, fShowAll, sLastSelect);
782
783#ifdef TEST_DRAG // fixme
784 {
785 HWND hwnd2 = WinWindowFromID(hwnd, ASEL_LISTBOX);
786 PFNWP pfn = WinSubclassWindow(hwnd2,
787 SDlgListboxSubclassProc);
788 WinSetWindowPtr(hwnd2, QWL_USER, (PVOID) pfn);
789 }
790#endif // TEST_DRAG fixme
791
792 break;
793
794 case WM_COMMAND:
795 ppatReturn = (ARC_TYPE **) WinQueryWindowPtr(hwnd, QWL_USER);
796 switch (SHORT1FROMMP(mp1))
797 {
798 case DID_OK:
799 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
800 ASEL_LISTBOX,
801 LM_QUERYSELECTION,
802 MPFROMSHORT(LIT_FIRST),
803 MPVOID);
804 if (sSelect == LIT_NONE)
805 {
806 DosBeep(100, 100);
807 return 0;
808 }
809 pat = arcsighead;
810 if (*ppatReturn)
811 {
812 // If dups hidden, find archiver with matching id
813 *szItemText = 0;
814 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
815 MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
816 if (!*szItemText)
817 pat = NULL;
818 else
819 {
820 for (;pat; pat = pat -> next)
821 {
822 if (pat -> id && !strcmp(szItemText, pat -> id))
823 break; // Found it
824 }
825 }
826 }
827 else
828 {
829 // If dups not hidden, lookup by count
830 for (i = 0; pat && i < sSelect; i++, pat = pat -> next)
831 ; // Scan
832 }
833 if (pat && (!*ppatReturn ||
834 (pat -> id && pat -> extract && pat -> create)))
835 {
836 *ppatReturn = pat;
837 }
838 else
839 {
840 // Refuse to select
841 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
842 MPFROMSHORT(LIT_NONE), FALSE);
843 DosBeep(100, 100);
844 return 0;
845 }
846 sLastSelect = sSelect;
847 WinDismissDlg(hwnd, TRUE);
848 return 0;
849
850 case DID_CANCEL:
851 if (arcsigsmodified) {
852 if (saymsg(MB_YESNO,
853 hwnd,
854 GetPString(IDS_ADCHANGESINMEMTEXT),
855 GetPString(IDS_ADREWRITETEXT),
856 NullStr) ==
857 MBID_YES) {
858 PSZ ab2 = searchpath(GetPString(IDS_ARCHIVERBB2)); // Rewrite without prompting
859 rewrite_archiverbb2(ab2);
860 }
861 }
862 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
863 ASEL_LISTBOX,
864 LM_QUERYSELECTION,
865 MPFROMSHORT(LIT_FIRST),
866 MPVOID);
867 if (sSelect != LIT_NONE)
868 sLastSelect = sSelect;
869 *ppatReturn = NULL;
870 PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID); // fixme to understand why needed
871 return 0;
872
873 case ASEL_PB_ADD:
874 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
875 ASEL_LISTBOX,
876 LM_QUERYSELECTION,
877 MPFROMSHORT(LIT_FIRST),
878 MPVOID);
879 if (sSelect != LIT_NONE) {
880 ARCDUMP ad;
881 memset(&ad,0,sizeof(ARCDUMP));
882 ad.info = malloc(sizeof(ARC_TYPE));
883 if (ad.info) {
884 memset(ad.info, 0, sizeof(ARC_TYPE));
885 if (!WinDlgBox(HWND_DESKTOP,
886 hwnd,
887 ArcReviewDlgProc,
888 FM3ModHandle,
889 AD_FRAME,
890 MPFROMP(&ad)))
891 {
892 free(ad.info);
893 }
894 else {
895 // Find self - assume all archivers listed since we are editing
896 for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
897 ; // Find self
898
899 if (!pat) {
900 if (arcsighead)
901 saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u", sSelect, __FILE__, __LINE__);
902 else
903 arcsighead = ad.info;
904 }
905 else {
906 // Insert before
907 if (pat->prev) {
908 ad.info->next = pat;
909 ad.info->prev = pat->prev;
910 pat->prev->next = ad.info;
911 pat->prev = ad.info;
912 }
913 else {
914 arcsighead = ad.info;
915 ad.info->next = pat;
916 pat->prev = ad.info;
917 }
918 }
919 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
920 MPFROM2SHORT(sSelect, 0),
921 MPFROMP(ad.info -> id ? ad.info -> id : "?"));
922 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
923 MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
924 arcsigsmodified = TRUE;
925 }
926 }
927 }
928 return 0;
929 case ASEL_PB_DELETE:
930 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
931 ASEL_LISTBOX,
932 LM_QUERYSELECTION,
933 MPFROMSHORT(LIT_FIRST),
934 MPVOID);
935 if (sSelect != LIT_NONE) {
936 // Find self - assume all archivers listed since we are editing
937 for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
938 ; // Find self
939
940 if (!pat) {
941 saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u",sSelect, __FILE__, __LINE__);
942 }
943 else {
944 // Delete current
945 if (pat->prev) {
946 pat->prev->next = pat->next;
947 if (pat->next)
948 pat->next->prev = pat->prev;
949 }
950 else {
951 arcsighead = pat->next;
952 if (pat->next)
953 pat->next->prev = pat->prev;
954 }
955 }
956 free_arc_type(pat);
957 arcsigsmodified = TRUE;
958 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEITEM,
959 MPFROM2SHORT(sSelect, 0),
960 MPVOID);
961 sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
962 MPVOID,MPVOID);
963 if (sSelect >= sItemCount)
964 sSelect--;
965 if (sSelect >= 0) {
966 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
967 MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
968 }
969 }
970 return 0;
971 case ASEL_PB_UP:
972 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,
973 ASEL_LISTBOX,
974 LM_QUERYSELECTION,
975 MPFROMSHORT(LIT_FIRST),
976 MPVOID);
977 if (sSelect != LIT_NONE && sSelect > 0) {
978 // Find self - assume all archivers listed since we are editing
979 for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
980 ; // Find self
981 if (!pat || !pat->prev) {
982 saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d at %s::%u",sSelect, __FILE__, __LINE__);
983 }
984 else {
985 ARC_TYPE *patGDad;
986 ARC_TYPE *patDad;
987 ARC_TYPE *patChild;
988 patChild = pat->next;
989 patDad = pat->prev;
990 patGDad = patDad->prev;
991 patDad->next = patChild;
992 if (patChild)
993 patChild->prev = patDad;
994 patDad->prev = pat;
995 pat->next = patDad;
996 if (patGDad) {
997 patGDad->next = pat;
998 pat->prev = patGDad;
999 }
1000 else {
1001 arcsighead = pat;
1002 pat->prev = NULL;
1003 }
1004
1005 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1006 MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1007 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1008 MPFROM2SHORT(sSelect - 1, 255), MPFROMP(szPCItemText));
1009 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1010 MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1011 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1012 MPFROMSHORT(sSelect - 1), MPFROMP(szItemText));
1013 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1014 MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
1015 arcsigsmodified = TRUE;
1016 }
1017 }
1018 return 0;
1019 case ASEL_PB_DOWN:
1020 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYSELECTION,
1021 MPFROMSHORT(LIT_FIRST),MPVOID);
1022 sItemCount = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYITEMCOUNT,
1023 MPVOID,MPVOID);
1024 if (sSelect != LIT_NONE && sSelect < sItemCount - 1) {
1025 // Find self - assume all archivers listed since we are editing
1026 for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++)
1027 ; // Find self
1028 if (!pat || !pat->next) {
1029 saymsg(0,NULLHANDLE,"*Debug*","Can not find self at %d/%d at %s::%u",sSelect, sItemCount, __FILE__, __LINE__);
1030 }
1031 else {
1032 ARC_TYPE *patDad;
1033 ARC_TYPE *patChild;
1034 patDad = pat->prev;
1035 patChild = pat->next;
1036 pat->next = patChild->next;
1037 patChild->next = pat;
1038 pat->prev = patChild;
1039 patChild->prev = patDad;
1040 if (patDad) {
1041 patDad->next = patChild;
1042 patChild->prev=patDad;
1043 }
1044 else {
1045 arcsighead = patChild;
1046 patChild->prev=NULL;
1047 }
1048
1049 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1050 MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1051 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1052 MPFROM2SHORT(sSelect + 1, 255), MPFROMP(szPCItemText));
1053 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1054 MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1055 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1056 MPFROMSHORT(sSelect + 1), MPFROMP(szItemText));
1057 WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1058 MPFROMSHORT(sSelect + 1), MPFROMSHORT(TRUE));
1059 arcsigsmodified = TRUE;
1060 }
1061 }
1062 return 0;
1063
1064 case ASEL_PB_REVERT:
1065 // Reload without checking in case changed outside
1066 sSelect = (SHORT)WinSendDlgItemMsg(hwnd,ASEL_LISTBOX,LM_QUERYSELECTION,
1067 MPFROMSHORT(LIT_FIRST),MPVOID);
1068 load_archivers();
1069 fill_listbox(hwnd, TRUE, sSelect);
1070 return 0;
1071
1072 case IDM_HELP:
1073 if (hwndHelp) {
1074 WinSendMsg(hwndHelp,
1075 HM_DISPLAY_HELP,
1076 MPFROM2SHORT(HELP_EDITARC,0), // fixme to be HELP_SELARC
1077 MPFROMSHORT(HM_RESOURCEID));
1078 }
1079 }
1080 return 0; // WM_COMMAND
1081
1082 case WM_CONTROL:
1083 if (SHORT1FROMMP(mp1) == ASEL_LISTBOX && SHORT2FROMMP(mp1) == LN_ENTER)
1084 PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
1085 return 0;
1086
1087 case WM_CLOSE:
1088 WinDismissDlg(hwnd, FALSE);
1089 return 0;
1090
1091 default:
1092 break;
1093 }
1094 return WinDefDlgProc(hwnd, msg, mp1, mp2);
1095}
1096
1097/*
1098 see archiver.tmp
1099 02-08-96 23:55 1
1100 8 Feb 96 23:55:32 2
1101 8 Feb 96 11:55p 3
1102 96-02-08 23:55:32 4
1103 31-02-98 23:55 5
1104 */
1105
1106#pragma alloc_text(ARCCNRS,ArcDateTime)
1107
1108BOOL ArcDateTime(CHAR *dt, INT type, CDATE *cdate, CTIME *ctime)
1109{
1110 INT x;
1111 BOOL ret = FALSE;
1112 CHAR *p, *pp, *pd;
1113
1114 if (dt && cdate && ctime)
1115 {
1116 memset(cdate, 0, sizeof(CDATE));
1117 memset(ctime, 0, sizeof(CTIME));
1118 if (type)
1119 {
1120 p = dt;
1121 while (*p && *p == ' ')
1122 p++;
1123 pd = dt;
1124 switch (type)
1125 {
1126 case 1:
1127 cdate -> month = atoi(pd);
1128 p = to_delim(pd, "-/.");
1129 if (p)
1130 {
1131 p++;
1132 cdate -> day = atoi(p);
1133 pd = p;
1134 p = to_delim(pd, "-/.");
1135 if (p)
1136 {
1137 p++;
1138 cdate -> year = atoi(p);
1139 if (cdate -> year > 80 && cdate -> year < 1900)
1140 cdate -> year += 1900;
1141 else if (cdate -> year < 1900)
1142 cdate -> year += 2000;
1143 ret = TRUE;
1144 p = strchr(p, ' ');
1145 if (p)
1146 {
1147 while (*p && *p == ' ')
1148 p++;
1149 ctime -> hours = atoi(p);
1150 p = to_delim(pd, ":.");
1151 if (p)
1152 {
1153 p++;
1154 ctime -> minutes = atoi(p);
1155 p = to_delim(pd, ":.");
1156 if (p)
1157 {
1158 p++;
1159 ctime -> seconds = atoi(p);
1160 }
1161 }
1162 }
1163 }
1164 }
1165 break;
1166
1167 case 2:
1168 cdate -> day = atoi(p);
1169 p = strchr(p, ' ');
1170 if (p)
1171 {
1172 p++;
1173 for (x = 0; x < 12; x++)
1174 {
1175 if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1176 break;
1177 }
1178 if (x < 12)
1179 {
1180 cdate -> month = x;
1181 p = strchr(p, ' ');
1182 if (p)
1183 {
1184 p++;
1185 cdate -> year = atoi(p);
1186 if (cdate -> year > 80 && cdate -> year < 1900)
1187 cdate -> year += 1900;
1188 else if (cdate -> year < 1900)
1189 cdate -> year += 2000;
1190 ret = TRUE;
1191 p = strchr(p, ' ');
1192 if (p)
1193 {
1194 while (*p && *p == ' ')
1195 p++;
1196 ctime -> hours = atoi(p);
1197 p = to_delim(pd, ":.");
1198 if (p)
1199 {
1200 p++;
1201 ctime -> minutes = atoi(p);
1202 p = to_delim(pd, ":.");
1203 if (p)
1204 {
1205 p++;
1206 ctime -> seconds = atoi(p);
1207 }
1208 }
1209 }
1210 }
1211 }
1212 }
1213 break;
1214
1215 case 3:
1216 cdate -> day = atoi(p);
1217 p = strchr(p, ' ');
1218 if (p)
1219 {
1220 p++;
1221 for (x = 0; x < 12; x++)
1222 {
1223 if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1224 break;
1225 }
1226 if (x < 12)
1227 {
1228 cdate -> month = x;
1229 p = strchr(p, ' ');
1230 if (p)
1231 {
1232 p++;
1233 cdate -> year = atoi(p);
1234 if (cdate -> year > 80 && cdate -> year < 1900)
1235 cdate -> year += 1900;
1236 else if (cdate -> year < 1900)
1237 cdate -> year += 2000;
1238 ret = TRUE;
1239 p = strchr(p, ' ');
1240 if (p)
1241 {
1242 while (*p && *p == ' ')
1243 p++;
1244 ctime -> hours = atoi(p);
1245 p = to_delim(pd, ":.");
1246 if (p)
1247 {
1248 p++;
1249 pp = p;
1250 ctime -> minutes = atoi(p);
1251 p = to_delim(pd, ":.");
1252 if (p)
1253 {
1254 p++;
1255 ctime -> seconds = atoi(p);
1256 p += 2;
1257 if (toupper(*p) == 'P')
1258 ctime -> hours += 12;
1259 }
1260 else
1261 {
1262 p = pp;
1263 p += 2;
1264 if (toupper(*p) == 'P')
1265 ctime -> hours += 12;
1266 }
1267 }
1268 }
1269 }
1270 }
1271 }
1272 break;
1273
1274 case 4:
1275 cdate -> year = atoi(p);
1276 if (cdate -> year > 80 && cdate -> year < 1900)
1277 cdate -> year += 1900;
1278 else if (cdate -> year < 1900)
1279 cdate -> year += 2000;
1280 p = to_delim(pd, "-/.");
1281 if (p)
1282 {
1283 p++;
1284 cdate -> month = atoi(p);
1285 pd = p;
1286 p = to_delim(pd, "-/.");
1287 if (p)
1288 {
1289 p++;
1290 cdate -> day = atoi(p);
1291 ret = TRUE;
1292 p = strchr(p, ' ');
1293 if (p)
1294 {
1295 while (*p && *p == ' ')
1296 p++;
1297 ctime -> hours = atoi(p);
1298 p = to_delim(pd, ":.");
1299 if (p)
1300 {
1301 p++;
1302 ctime -> minutes = atoi(p);
1303 p = to_delim(pd, ":.");
1304 if (p)
1305 {
1306 p++;
1307 ctime -> seconds = atoi(p);
1308 }
1309 }
1310 }
1311 }
1312 }
1313 break;
1314
1315 case 5:
1316 cdate -> day = atoi(pd);
1317 p = to_delim(pd, "-/.");
1318 if (p)
1319 {
1320 p++;
1321 cdate -> month = atoi(p);
1322 pd = p;
1323 p = to_delim(pd, "-/.");
1324 if (p)
1325 {
1326 p++;
1327 cdate -> year = atoi(p);
1328 if (cdate -> year > 80 && cdate -> year < 1900)
1329 cdate -> year += 1900;
1330 else if (cdate -> year < 1900)
1331 cdate -> year += 2000;
1332 ret = TRUE;
1333 p = strchr(p, ' ');
1334 if (p)
1335 {
1336 while (*p && *p == ' ')
1337 p++;
1338 ctime -> hours = atoi(p);
1339 p = to_delim(pd, ":.");
1340 if (p)
1341 {
1342 p++;
1343 ctime -> minutes = atoi(p);
1344 p = to_delim(pd, ":.");
1345 if (p)
1346 {
1347 p++;
1348 ctime -> seconds = atoi(p);
1349 }
1350 }
1351 }
1352 }
1353 }
1354 break;
1355
1356 default:
1357 break;
1358 }
1359 }
1360 }
1361 return ret;
1362}
Note: See TracBrowser for help on using the repository browser.