source: trunk/dll/avl.c@ 405

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

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