source: trunk/dll/avl.c@ 689

Last change on this file since 689 was 689, checked in by Steven Levine, 18 years ago

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