source: trunk/dll/avl.c@ 551

Last change on this file since 551 was 551, checked in by Gregg Young, 19 years ago

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