source: trunk/dll/avl.c@ 418

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

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