source: trunk/dll/avl.c@ 344

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

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