source: trunk/dll/avl.c@ 342

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

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