source: trunk/dll/avl.c@ 1180

Last change on this file since 1180 was 1180, checked in by John Small, 17 years ago

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