source: trunk/dll/avl.c@ 546

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

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