![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cffile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / newcard|
Return to cffile.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / newcard |
1.1 root 1: #define NOCOMM
2: #define NOVIRTUALKEYCODES
3: #define NOWINMESSAGES
4: #include "cardfile.h"
5:
6: /*********************************************************************/
7: /* Windows/PM Cardfile Shared Code */
8: /* */
9: /* (c) Copyright Microsoft Corp. 1987,1988 - All Rights Reserved */
10: /*********************************************************************/
11:
12: /*********************************************************************/
13: /* The following shared code was developed from the original */
14: /* Cardfile application. This code can be compiled to run under */
15: /* either the Windows or the PM manager environment. All */
16: /* functionality associated with bitmaps or printing has been */
17: /* deleted. Some comments refering to these functions may still be */
18: /* present in the code and should be disregarded. jw. */
19: /*********************************************************************/
20:
21:
22: /*********************************************************************/
23: /* This file contains the routines for writing and reading */
24: /* information to the disk. All of the procedures in this file */
25: /* consist entirely of shared code. */
26: /*********************************************************************/
27:
28:
29:
30: /*********************************************************************/
31: /* */
32: /* cardfile data files are layed out with the following format: */
33: /* three magic bytes "MGC" */
34: /* a word count of cards in the file */
35: /* array of cardheaders, each one containing: */
36: /* */
37: /* char reserved[6]; bytes available for future use */
38: /* unsigned long lfData; file offset of data */
39: /* unsigned char flags; flags */
40: /* char line[LINELENGTH+1]; 40 character lines plus null */
41: /* */
42: /* These are stored sorted in alphabetical order on the */
43: /* header (line). */
44: /* */
45: /* Following the headers are the cards' data. lfData in a card's */
46: /* header points to somewhere in this area. Each card's data is */
47: /* layed out like this: */
48: /* */
49: /* unsigned bmSize; size in bytes of the bitmap */
50: /* Ooops, this won't work so well when we get 64K bitmaps */
51: /* (Must be 0 for this time round!) */
52: /* */
53: /* If bmSize is > 0 then the card has a bitmap, and then next */
54: /* bytes contain: */
55: /* */
56: /* int cxBitmap; cx in pixels of bitmap */
57: /* int cyBitmap; cy in pixels of bitmap */
58: /* int cxEighths; (x coord of bitmap * 8) / cxFont */
59: /* int cyEighths; (y coord of bitmap * 8) / cyFont */
60: /* BYTE bmBits[bmSize] bitmap bits */
61: /* */
62: /* The x and y coords are in the funny format so that the bitmap */
63: /* will appear in roughly the same place on the card on different */
64: /* displays. */
65: /* */
66: /* Following the bitmap information is the card's text */
67: /* */
68: /* unsigned tSize; size in bytes */
69: /* char Text[tSize]; text characters */
70: /* */
71: /* */
72: /*********************************************************************/
73:
74:
75: /*********************************************************************/
76: /* MergeCardFile - */
77: /* Merges the file specified by pchName into the current file. */
78: /* */
79: /* Same for PM and Windows */
80: /*********************************************************************/
81:
82: BOOL FAR MergeCardFile(pchName)
83: PSTR pchName;
84: {
85: int fh;
86: unsigned i;
87: char buf[PATHMAX];
88: char MaGiC[4];
89: OFSTRUCT mergereopen;
90: LPSTR lpText;
91: HANDLE hText;
92: unsigned cMergeCards;
93: unsigned tSize;
94: unsigned lTemp;
95: unsigned long lCurPos;
96: int result = FALSE;
97:
98: /* if no extension, append the default one */
99: AppendExtension(pchName, buf);
100:
101: /* open file */
102: if ((fh = OpenFile((LPSTR)buf, (LPOFSTRUCT)&mergereopen,
103: OF_PROMPT | OF_CANCEL)) < 0)
104: return(FALSE);
105:
106: /* now read it in */
107: /* check that the first three bytes signify a Cardfile */
108: MaGiC[3] = 0;
109: myread(fh, MaGiC, 3);
110: if (Mylstrcmp(MaGiC, "MGC"))
111: {
112: CardfileOkError(IDS_ENOTVALIDFILE);
113: goto MergeClean;
114: }
115:
116: /* read the number of cards in the file */
117: myread(fh, (PSTR)&cMergeCards, sizeof(int));
118:
119: /* allocate enough memory for the file */
120: lTemp = (cCards+cMergeCards)*sizeof(CARDHEADER);
121: if (!GlobalReAlloc(hCards, lTemp, GMEM_MOVEABLE))
122: {
123: MergeInsMem:
124: CardfileOkError(IDS_EINSMEMORY);
125: goto MergeClean;
126: }
127:
128: /* allocate a buffer for the text on the cards */
129: hText = GlobalAlloc(GHND, (long)CARDTEXTSIZE);
130: if (!hText)
131: goto MergeInsMem;
132: lpText = GlobalLock(hText);
133:
134: /* for each card in the merged file */
135: for(i = 0; i < cMergeCards; ++i)
136: {
137: /* read its header */
138: myread(fh, (PSTR)&CurCardHead, sizeof(CARDHEADER));
139: /* save current position, and seek to the data */
140: lCurPos = MyLseek(fh, 0L, 1);
141: MyLseek(fh, CurCardHead.lfData, 0);
142:
143: CurCard.hBitmap = 0;
144:
145: /* if there's a bitmap, display an error */
146: myread(fh, (PSTR)&CurCard.bmSize, sizeof(int));
147: if (CurCard.bmSize)
148: {
149: CardfileOkError( IDS_NOBITMAP );
150: goto MergeClean;
151: }
152:
153: /* read text size */
154: myread(fh, (PSTR)&tSize, sizeof(int));
155:
156: /* make sure text is no bigger than buffer */
157: if (tSize >= CARDTEXTSIZE)
158: tSize = CARDTEXTSIZE-1;
159:
160: /* read text */
161: mylread(fh, (LPSTR)lpText, tSize);
162: *(lpText+tSize) = 0;
163:
164: /* write out the card, so we'll be able to get it in the future */
165: if (tSize = WriteCurCard(&CurCardHead, &CurCard, lpText))
166: {
167: iFirstCard = AddCurCard();
168: }
169:
170: /* seek to next header */
171: MyLseek(fh, lCurPos, 0);
172: if (!tSize)
173: goto MergeClean;
174: }
175: GlobalUnlock(hText);
176: GlobalFree(hText);
177: fFileDirty = TRUE;
178: result = TRUE;
179: MergeClean:
180: MyClose(fh);
181: return(result);
182: }
183:
184: /*********************************************************************/
185: /* ReadCardFile - */
186: /* Reads specified cardfile. */
187: /* */
188: /* Same for PM and Windows */
189: /*********************************************************************/
190:
191: BOOL FAR ReadCardFile(pchName)
192: PSTR pchName;
193: {
194: int fh;
195: LPCARDHEADER lpTCards;
196: unsigned i;
197: char buf[PATHMAX];
198: char MaGiC[4];
199: unsigned cNewCards;
200: unsigned lTemp;
201: int result = FALSE;
202: OFSTRUCT tmpmain;
203:
204: /* if no extension, append the default */
205: AppendExtension(pchName, buf);
206:
207: /* open file */
208: if ((fh = OpenFile((LPSTR)buf, (LPOFSTRUCT)&tmpmain,
209: OF_PROMPT | OF_CANCEL)) < 0)
210: return(FALSE);
211:
212: /* now read it in, and verify that it's a cardfile */
213: MaGiC[3] = 0;
214: myread(fh, (PSTR)MaGiC, 3);
215: if (Mylstrcmp(MaGiC, "MGC"))
216: {
217: CardfileOkError(IDS_ENOTVALIDFILE);
218: goto ReadClean;
219: }
220:
221: /* read the number of cards in the file */
222: myread(fh, (PSTR)&cNewCards, sizeof(int));
223:
224: /* allocate the object to hold all the headers */
225: lTemp = cNewCards * sizeof(CARDHEADER);
226: if (!GlobalReAlloc(hCards, lTemp, GMEM_MOVEABLE))
227: {
228: CardfileOkError(IDS_EINSMEMORY);
229: goto ReadClean;
230: }
231: /* save card count */
232: cCards = cNewCards;
233: lpTCards = (LPCARDHEADER) GlobalLock(hCards);
234:
235: /* for all cards */
236: for(i = 0; i < cNewCards; ++i)
237: {
238: /* read the header, and save it */
239: myread(fh, (PSTR)&CurCardHead, sizeof(CARDHEADER));
240: *lpTCards++ = CurCardHead;
241: }
242: GlobalUnlock(hCards);
243: fFileDirty = FALSE;
244:
245: mainreopen = tmpmain; /* save new OFSTRUCT */
246: Mylstrcpy((LPSTR)CurIFile, (LPSTR)mainreopen.szPathName);
247: result = TRUE;
248: ReadClean:
249: MyClose(fh);
250: return(result);
251: }
252:
253: /*********************************************************************/
254: /* AppendExtension - */
255: /* This routine checks for an extension, and if none exists, */
256: /* appends the default (CRD). A single '.' denotes an extension, so */
257: /* here is what this routine will do: */
258: /* FOO -> FOO.CRD */
259: /* FOO. -> FOO. */
260: /* FOO.BAR -> FOO.BAR */
261: /* */
262: /* Same for PM and Windows */
263: /*********************************************************************/
264:
265: void FAR AppendExtension(pchName, pchBuf)
266: PSTR pchName;
267: PSTR pchBuf;
268: {
269: char *pch1;
270: char ch;
271:
272: /* save name */
273: Mylstrcpy((LPSTR)pchBuf, (LPSTR)pchName);
274:
275: /* get to end */
276: pch1 = pchBuf + Mylstrlen((LPSTR)pchBuf);
277:
278: /* scan backwards for beginning or end of filename */
279: while ((ch = *pch1) != '.' && ch != '\\' && ch != ':' && pch1 > pchBuf)
280: pch1 = FAR_TO_NEAR( AnsiPrev((LPSTR)pchBuf, (LPSTR)pch1) );
281:
282: /* if no '.', need to tack on extension */
283: if (*pch1 != '.')
284: Mylstrcat((LPSTR)pchBuf, (LPSTR)".CRD");
285:
286: /* what the heck, upper case it */
287: AnsiUpper((LPSTR)pchBuf);
288: }
289:
290: /*********************************************************************/
291: /* WriteCardFile - */
292: /* This routine writes out a cardfile */
293: /* */
294: /* Same for PM and Windows */
295: /*********************************************************************/
296:
297: BOOL FAR WriteCardFile(pchName)
298: PSTR pchName;
299: {
300: LPCARDHEADER lpTCards = NULL; /* so cleaning works */
301: char bakName[PATHMAX];
302: unsigned i;
303: int fhBak;
304: int fhDollar;
305: int fhOld;
306: int fh;
307: unsigned long lCurLoc;
308: unsigned long lCardData;
309: unsigned bmSize;
310: HANDLE hText;
311: LPSTR lpText;
312: char buf[PATHMAX];
313: unsigned tSize;
314: int fSameFile;
315: char *pchFileName;
316: int result = FALSE;
317: CARDHEADER CardHeader;
318: LPCARDHEADER lpCards;
319: OFSTRUCT bakofStruct;
320:
321: /* if no extension, append the default one */
322: AppendExtension(pchName, buf);
323:
324: /* if saving to same file, need to save out to temporary one */
325: if (fSameFile = !Mylstrcmp(buf, CurIFile))
326: {
327: /* get a tempfile name */
328: if(!GetTempFileName(CurIFile[0] | TF_FORCEDRIVE, (LPSTR)"CRD", 0,
329: (LPSTR)bakName))
330: goto SaveTempProblem;
331: }
332: else
333: /* otherwise, just save to specified file */
334: Mylstrcpy((LPSTR)bakName, (LPSTR)buf);
335:
336: /* open the new file */
337: fhBak = OpenFile((LPSTR)bakName, (LPOFSTRUCT)&bakofStruct, OF_CREATE);
338: /* open files */
339: if (CurIFile[0])
340: pchFileName = CurIFile;
341: else
342: pchFileName = rgchCardData;
343: /* open temporary file */
344: if (fReadOnly)
345: goto SaveTempProblem;
346:
347: fhDollar = OpenFile((LPSTR)pchFileName, (LPOFSTRUCT)&tmpreopen,
348: OF_PROMPT | OF_REOPEN | 2);
349: if (fhDollar == -1)
350: {
351: SaveTempProblem:
352: CardfileOkError(IDS_EDISKFULLFILE);
353: return(FALSE);
354: }
355: if (fhBak < 0)
356: {
357: goto CantMakeFile;
358: }
359: /* if curifile is null, then won't use fhOld */
360: if (CurIFile[0])
361: fhOld = OpenFile((LPSTR)CurIFile, (LPOFSTRUCT)&mainreopen,
362: OF_PROMPT | OF_REOPEN);
363:
364: if (MyLseek(fhBak, 0L, 0) == -1)
365: {
366: if (CurIFile[0])
367: MyClose(fhOld);
368: CantMakeFile:
369: MyClose(fhDollar);
370: CardfileOkError(IDS_ECANTMAKEFILE);
371: return(FALSE);
372: }
373: /* truncate file */
374: mywrite(fhBak, (PSTR)"", 0);
375:
376: /* write out cardfile magic bytes */
377: mywrite(fhBak, (PSTR)"MGC", 3);
378:
379: /* write the number of cards in the file */
380: mywrite(fhBak, (PSTR)&cCards, sizeof(int));
381: lCardData = MyLseek(fhBak, 0L, 1) + (cCards * sizeof(CARDHEADER));
382:
383: /* allocate buf for card text */
384: hText = GlobalAlloc(GHND, (long)CARDTEXTSIZE);
385: if (!hText)
386: {
387: MyClose(fhBak);
388: MyClose(fhOld);
389: MyClose(fhDollar);
390: Fdelete(bakName);
391: CardfileOkError(IDS_EINSMEMORY);
392: goto WriteFileClean;
393: }
394:
395: lpText = (LPSTR)GlobalLock(hText);
396:
397: /* lock down the card headers */
398: lpCards = lpTCards = (LPCARDHEADER) GlobalLock(hCards);
399:
400: /* for each card in file */
401: for(i = 0; i < cCards; ++i)
402: {
403: /* see where the card's data is */
404: if (lpTCards->flags & FTMPFILE)
405: fh = fhDollar;
406: else
407: fh = fhOld;
408: /* seek to data */
409: MyLseek(fh, lpTCards->lfData, 0);
410: /* get header */
411: CardHeader = *lpTCards++;
412: /* clear out tmpfile bit */
413: CardHeader.flags &= (!FTMPFILE);
414: CardHeader.lfData = lCardData;
415: /* write header */
416: if (mylwrite(fhBak, (LPSTR)&CardHeader, sizeof(CARDHEADER))
417: < sizeof(CARDHEADER))
418: goto WFDiskFull;
419: lCurLoc = MyLseek(fhBak, 0L, 1);
420: /* seek to data spot in new file */
421: MyLseek(fhBak, lCardData, 0);
422: myread(fh, (PSTR)&bmSize, sizeof(int));
423: mywrite(fhBak, (PSTR)&bmSize, sizeof(int));
424:
425: /* save text */
426: myread(fh, (PSTR)&tSize, sizeof(int));
427: if (mywrite(fhBak, (PSTR)&tSize, sizeof(int)) < sizeof(int))
428: goto WFDiskFull;
429: mylread(fh, (LPSTR)lpText, tSize);
430: if (mylwrite(fhBak, (LPSTR)lpText, tSize) < tSize)
431: {
432: WFDiskFull:
433: MyClose(fhBak);
434: MyClose(fhOld);
435: MyClose(fhDollar);
436: Fdelete(bakName);
437: CardfileOkError(IDS_EDISKFULLFILE);
438: goto WriteFileClean;
439: }
440:
441: lCardData = MyLseek(fhBak, 0L, 1);
442: MyLseek(fhBak, lCurLoc, 0);
443: }
444: MyClose(fhBak);
445: if (CurIFile[0])
446: MyClose(fhOld);
447: MyLseek(fhDollar, 0L, 0);
448: mywrite(fhDollar, (PSTR)"", 0);
449: MyClose(fhDollar);
450: if (fSameFile)
451: {
452: Fdelete(buf);
453: Frename(bakName, buf);
454: fhOld = OpenFile((LPSTR)buf, (LPOFSTRUCT)&mainreopen, 2);
455: }
456: else
457: {
458: AnsiUpper((LPSTR)CurIFile);
459: fhOld = OpenFile((LPSTR)bakName, (LPOFSTRUCT)&mainreopen, 2);
460: }
461:
462: Mylstrcpy((LPSTR)CurIFile, (LPSTR)mainreopen.szPathName);
463:
464: MyLseek(fhOld, 5L, 0);
465: lpTCards = lpCards;
466: for(i = 0; i < cCards; ++i)
467: {
468: myread(fhOld, (PSTR)&CardHeader, sizeof(CARDHEADER));
469: *lpTCards++ = CardHeader;
470: }
471: MyClose(fhOld);
472: fFileDirty = FALSE;
473: result = TRUE;
474: WriteFileClean:
475: if (hText)
476: {
477: GlobalUnlock(hText);
478: GlobalFree(hText);
479: }
480: if (lpTCards)
481: GlobalUnlock(hCards);
482: return(result);
483: }
484:
485: /*********************************************************************/
486: /* WriteCurCard - */
487: /* Write out the data for the current card */
488: /* */
489: /* Same for PM and Windows */
490: /*********************************************************************/
491:
492: BOOL FAR WriteCurCard(pCardHead, pCard, lpText)
493: PCARDHEADER pCardHead;
494: PCARD pCard;
495: LPSTR lpText;
496: {
497: int fh;
498: unsigned long lEnd;
499: int zero = 0;
500: unsigned tSize;
501: char *pchFileName;
502: unsigned cchWritten;
503:
504: /* get right string in case of error */
505: if (CurIFile[0])
506: pchFileName = CurIFile;
507: else
508: pchFileName = rgchCardData;
509:
510: /* open temp file, if necessary asking for it */
511:
512: fh = OpenFile((LPSTR)pchFileName, (LPOFSTRUCT)&tmpreopen,
513: OF_CANCEL | OF_PROMPT | OF_REOPEN | 2);
514: if (fh == -1)
515: {
516: CardfileOkError(IDS_EOPENTEMPSAVE);
517: return(FALSE);
518: }
519:
520: /* seek to end of temp file */
521: lEnd = MyLseek(fh, 0L, 2);
522:
523: mywrite(fh, (PSTR)&zero, sizeof(int));
524:
525: /* save text */
526: tSize = Mylstrlen((LPSTR)lpText);
527: if (tSize >= CARDTEXTSIZE)
528: tSize = CARDTEXTSIZE-1;
529: if (mywrite(fh, (PSTR)&tSize, sizeof(int)) < sizeof(int))
530: goto WCDiskFull;
531: cchWritten = mylwrite(fh, (LPSTR)lpText, tSize);
532: MyClose(fh);
533: if (cchWritten < tSize)
534: {
535: WCDiskFull:
536: CardfileOkError(IDS_EDISKFULLSAVE);
537: return(FALSE);
538: }
539: pCardHead->flags |= FTMPFILE;
540: pCardHead->lfData = lEnd;
541: return(TRUE);
542: }
543:
544: /*********************************************************************/
545: /* ReadCurData - */
546: /* Read current card's data */
547: /* */
548: /* Same for PM and Windows */
549: /*********************************************************************/
550:
551: BOOL FAR ReadCurCardData(pCardHead, pCard, lpText)
552: PCARDHEADER pCardHead;
553: PCARD pCard;
554: LPSTR lpText;
555: {
556: int fh;
557: unsigned tSize;
558: char *pchFileName;
559: int result = TRUE;
560:
561: /* assume no bitmap */
562: pCard->hBitmap = 0;
563:
564: /* if a new card, then can't get it out of any file */
565: if (pCardHead->flags & FNEW)
566: {
567: /* no text */
568: lpText = (LPSTR)"";
569: return(result);
570: }
571:
572: /* if data is in temp file, get the right file handle */
573: if (pCardHead->flags & FTMPFILE)
574: {
575: if (CurIFile[0])
576: pchFileName = CurIFile;
577: else
578: pchFileName = rgchCardData;
579: fh = OpenFile((LPSTR)pchFileName, (LPOFSTRUCT)&tmpreopen,
580: OF_PROMPT | OF_REOPEN | 2);
581: }
582: else
583: fh = OpenFile((LPSTR)CurIFile, (LPOFSTRUCT)&mainreopen,
584: OF_PROMPT | OF_REOPEN);
585:
586: /* seek to data */
587: MyLseek(fh, pCardHead->lfData, 0);
588:
589: /* This must be 0 */
590: myread(fh, (PSTR)&(pCard->bmSize), sizeof(int));
591:
592: /* read text */
593: myread(fh, (PSTR)&tSize, sizeof(int));
594: if (tSize >= CARDTEXTSIZE)
595: tSize = CARDTEXTSIZE-1;
596: mylread(fh, (LPSTR)lpText, tSize);
597: *(lpText+tSize) = 0;
598: MyClose(fh);
599: return (result);
600: }
601:
602: /*********************************************************************/
603: /* MakeTmpFile - */
604: /* Create a temporary file, with a random name provided by system */
605: /* */
606: /* Same for PM and Windows */
607: /*********************************************************************/
608:
609: void FAR MakeTmpFile()
610: {
611: int fh;
612:
613: if(GetTempFileName(CurIFile[0], (LPSTR)"CRD", 0, (LPSTR)TmpFile))
614: {
615: if ((fh = OpenFile((LPSTR)TmpFile, (LPOFSTRUCT)&tmpreopen,
616: OF_CREATE)) < 0)
617: goto CantMakeTmp;
618: else
619: MyClose(fh);
620: }
621: else
622: {
623: /* if can't make temp file, mark "read only", although I'm sure */
624: /* this readonly stuff doesn't work well. Should rarely happen. */
625: CantMakeTmp:
626: CardfileOkError(IDS_ECANTMAKETEMP);
627: fReadOnly = TRUE;
628: }
629: }
630:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.