home *** CD-ROM | disk | FTP | other *** search
/ linuxmafia.com 2016 / linuxmafia.com.tar / linuxmafia.com / pub / palmos / progect-src-0.20.tar.gz / progect-src-0.20.tar / progect-0.20 / doc.c < prev    next >
C/C++ Source or Header  |  2000-10-26  |  9KB  |  442 lines
  1. /* -*-Mode:C; tab-width:4; indent-tabs-mode:t; c-file-style:"stroustrup";-*- */
  2. // $Id: doc.c,v 1.5 2000/10/22 18:35:27 burgbach Exp $
  3. //
  4. // DOC format read/write access module.
  5. //
  6.  
  7. #include "progect.h"
  8. #include "progectRsc.h"
  9. #include "task.h"
  10. #include "doc.h"
  11.  
  12.  
  13. ExportHeaddings_t ExportHeaddings[EXPORT_NUMLEVELS] =
  14. {
  15.     {
  16.         "\n\n\n\n"
  17.         "=========================\n"
  18.         "", "\n"
  19.         "=========================\n",
  20.         ""
  21.     },
  22.     {
  23.         "\n"
  24.         "", "\n"
  25.         "---------------------",
  26.         ""
  27.     },
  28.     {
  29.         "  * ", "",
  30.         ""
  31.     },
  32.     {
  33.         "   - ", "",
  34.         "     "
  35.     },
  36.     {
  37.         "    >", "",
  38.         "     "
  39.     },
  40.     { "", "", "" },
  41.     { "", "", "" }, { "", "", "" }, { "", "", "" },
  42.     { "", "", "" }, { "", "", "" }, { "", "", "" }
  43. };
  44.  
  45.  
  46. static DmOpenRef docdb;
  47. static DocInfo_t* info;
  48. static char* putp;
  49. static char* docrcd;
  50. static UInt16 docrcdlen;
  51. static UInt8 autonum[EXPORT_NUMLEVELS];
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58. /****************************************************************************
  59.  * Name : compressDocBuffer
  60.  * Desc : compress the DOC buffer (docrcd)
  61.  * Parm : 
  62.  * Out  : 
  63.  * Auth : seagull, 05.10.2000 (import from zDoc)
  64.  ***************************************************************************/
  65. static void compressDocBuffer(void)
  66. {
  67. #if 1
  68.     return ;
  69. #else
  70.     int i, j;
  71.  
  72. #define DISP_BITS 11
  73. #define COUNT_BITS 3
  74.  
  75.     char *pBuffer;
  76.     char *pHit;
  77.     char *pPrevHit;
  78.     char *pTestHead;
  79.     char *pTestTail;
  80.     char *pEnd;
  81.  
  82.     unsigned int dist, compound, k;
  83.  
  84.     char* pTmpBuff;
  85.     int nTmpLen;
  86.     Boolean space = false;
  87.  
  88.     pHit = pPrevHit = pTestHead = pBuffer = docrcd;
  89.     pEnd = docrcd + docrcdlen;
  90.  
  91.     pTmpBuff = MemPtrNew(6000);
  92.     nTmpLen = 0;
  93.  
  94.     for (pTestTail = pTestHead + 1; pTestHead != pEnd; pTestTail++)
  95.     {
  96.         if (pTestHead - pPrevHit > ((1 << DISP_BITS) - 1))
  97.             pPrevHit = pTestHead - ((1 << DISP_BITS) - 1);
  98.  
  99.         pHit = pPrevHit;
  100.         for (i = pTestHead - pPrevHit + 1 ; i > 0; i--, pHit++)
  101.             if (! *pHit == *pTestHead &&
  102.                 MemCmp(pHit, pTestHead, pTestTail - pTestHead))
  103.                 break;
  104.         if (! i
  105.             || pHit == pTestHead
  106.             || pTestTail-pTestHead > (1 << COUNT_BITS) + 2
  107.             || pTestTail == pEnd)
  108.         {
  109.             if (pTestTail-pTestHead < 4)
  110.             {
  111.                 unsigned char ch = pTestHead[0];
  112.                 int iDest = nTmpLen;
  113.                 unsigned char *dest = pTmpBuff;
  114.     
  115.                 if (space)
  116.                 {
  117.                     if (src >= 0x40 && ch <= 0x7f)
  118.                         dest[iDest++] = ch ^ 0x80;
  119.                     else
  120.                     {
  121.                         dest[iDest++] = ' ';
  122.                         if (ch >= 0x80 || (ch != 0 && ch <= 8))
  123.                             dest[iDest++] = 1;
  124.                         dest[iDest++] = ch;
  125.                     }
  126.                     space = false;
  127.                 }
  128.                 else
  129.                 {
  130.                     if (src == ' ')
  131.                         space = true;
  132.                     else
  133.                     {
  134.                         if (ch >= 0x80 || (ch != 0 && ch <= 8))
  135.                             dest[iDest++] = 1;
  136.                         dest[iDest++] = ch;
  137.                     }
  138.                 }
  139.                 nTmpLen = iDest;
  140.  
  141.                 pTestHead++;
  142.             }
  143.             else
  144.             {
  145.                 if (space)
  146.                 {
  147.                     pTmpBuff[nTmpLen++] = ' ';
  148.                     space = false;
  149.                 }
  150.                 dist = pTestHead - pPrevHit;
  151.                 compound = (dist << COUNT_BITS) + pTestTail-pTestHead-4;
  152.                 pTmpBuff[nTmpLen++] = 0x80 + (compound >> 8);
  153.                 pTmpBuff[nTmpLen++] = compound & 0xff;
  154.                 pTestHead = pTestTail - 1;
  155.             }
  156.             pPrevHit = pBuffer;
  157.         }
  158.         else
  159.             pPrevHit = pHit;
  160.  
  161.         if (pTestTail == pEnd) pTestTail--;
  162.     }
  163.     
  164.     if (space) pTmpBuff[nTmpLen++] = ' ';
  165.     
  166.     for (i=k=0; i < b->len; i++, k++)
  167.     {
  168.         pTmpBuff[k] = pTmpBuff[i];
  169.         if (pTmpBuff[k] >= 0x80 && pTmpBuff[k] < 0xc0)
  170.             pTmpBuff[++k] = pTmpBuff[++i];
  171.         else if (pTmpBuff[k] == 1)
  172.         {
  173.             pTmpBuff[k+1] = pTmpBuff[i+1];
  174.             while (i + 2 < nTmpLen && pTmpBuff[i+2] == 1 && pTmpBuff[k] < 8)
  175.             {
  176.                 pTmpBuff[k]++;
  177.                 pTmpBuff[k+b->buf[k]] = pTmpBuff[i+3];
  178.                 i += 2;
  179.             }
  180.             k += pTmpBuff[k];
  181.             i++;
  182.         }
  183.     }
  184.  
  185.     MemMove(docrcd, pTmpBuff, pTmpLen);
  186.     MemPtrFree(pTmpBuff);
  187.     docrcdlen = nTmpBuff;
  188.  
  189.     return k;
  190. #endif
  191. }
  192.  
  193.  
  194.  
  195. /****************************************************************************
  196.  * Name : flushDocBuffer
  197.  * Desc : flush doc cache buffer pointed by docrcd.
  198.  * Parm : 
  199.  * Out  : 
  200.  * Auth : seagull, 03.10.2000
  201.  ***************************************************************************/
  202. static void flushDocBuffer(void)
  203. {
  204.     UInt16 index;
  205.     MemHandle h;
  206.     MemPtr p;
  207.  
  208.     index = dmMaxRecordIndex;
  209.     h = DmNewRecord(docdb, &index, docrcdlen);
  210.  
  211.     if (!h)
  212.         return;
  213.     
  214.     p  = MemHandleLock(h);
  215.  
  216.     compressDocBuffer();
  217.  
  218.     DmWrite(p, 0, docrcd, docrcdlen);
  219.     MemHandleUnlock(h);
  220.     DmReleaseRecord(docdb, index, true);
  221.  
  222.     info->count++;
  223. }
  224.  
  225.  
  226.  
  227.  
  228.  
  229. /****************************************************************************
  230.  * Name : putString
  231.  * Desc : put the string on doc cache buffer
  232.  * Parm : 
  233.  *         -> target string
  234.  *         -> prefix for each lines
  235.  *         -> suffix for each lines
  236.  * Out  : 
  237.  * Auth : seagull, 03.10.2000
  238.  ***************************************************************************/
  239. static void putString(char* str,
  240.                       char* lineprefix, char* linesuffix)
  241. {
  242.     if (lineprefix)
  243.         putString(lineprefix, NULL, NULL);
  244.  
  245.     // skip empty line on document head.
  246.     if (info->uncompsizeoftext == 0)
  247.         while (*str && *str == '\n')
  248.             str++;
  249.  
  250.     while (*str)
  251.     {
  252.         if (docrcdlen >= 4096)
  253.         {
  254.             flushDocBuffer();
  255.  
  256.             putp = docrcd;
  257.             docrcdlen = 0;
  258.         }
  259.         if (str[0] == '\n' && str[1] != '\0')
  260.         {
  261.             if (linesuffix)
  262.                 putString(linesuffix, NULL, NULL);
  263.             *putp++ = *str++;
  264.             if (lineprefix)
  265.                 putString(lineprefix, NULL, NULL);
  266.         }
  267.         else
  268.             *putp++ = *str++;
  269.         docrcdlen++;
  270.         info->uncompsizeoftext++;
  271.     }
  272.     if (linesuffix)
  273.         putString(linesuffix, NULL, NULL);
  274. }
  275.  
  276.  
  277.  
  278.  
  279. /****************************************************************************
  280.  * Name : ExportToDoc
  281.  * Desc : export current project to doc text
  282.  * Parm : 
  283.  *         -> cardNo of doc DB to generate
  284.  *         -> name generate doc DB name
  285.  * Out  : 
  286.  * Auth : seagull, 03.10.2000
  287.  ***************************************************************************/
  288. void ExportToDoc(UInt16 cardNo, char const* name, UInt16 first, UInt16 last)
  289. {
  290.     static char const szNL[] = "\n";
  291.     LocalID docdbID;
  292.     MemPtr rcd;
  293.     Int16 nCurrLevel = -1;
  294.     UInt16 index;
  295.     MemHandle h;
  296.  
  297.     docdbID = DmFindDatabase(cardNo, name);
  298.     if (docdbID)
  299.     {
  300.         MessageBox(StrDocAlreadyExist);
  301.         return ;
  302.     }
  303.  
  304.     //
  305.     // create and open DB
  306.     //
  307.     DmCreateDatabase(cardNo, name, DocCreatorID, DocTypeID, false);
  308.     if (! (docdbID = DmFindDatabase(cardNo, name)) ||
  309.         ! (docdb = DmOpenDatabase(cardNo, docdbID, dmModeReadWrite)) )
  310.     {
  311.         DEBUG1("can't create DB");
  312.         return ;
  313.     }
  314.  
  315.     //
  316.     // Initialize DOC headder
  317.     //
  318.     info = (DocInfo_t*)MemPtrNew(sizeof(DocInfo_t));
  319.     info->version = DOC_UNCOMPRESSED;
  320.     info->crap = 0;
  321.     info->uncompsizeoftext = 0;
  322.     info->count = 0;
  323.     info->uncomplength = 4096;
  324.     info->morecrap = 0;
  325.  
  326.  
  327.  
  328.     //
  329.     // export each records
  330.     //
  331.     putp = docrcd = MemPtrNew(4096);
  332.     docrcdlen = 0;
  333.     last++;
  334.     for (index = first; index < last; index++)
  335.     {
  336.         char tmpbuff[20];
  337.         TaskExtendedRecordType* pTask;
  338.         Char* desc;
  339.  
  340.         h = DmQueryRecord(gdbP, index);
  341.         pTask = MemHandleLock(h);
  342.  
  343.         // ignore done task if it's require
  344.         if (! gMemoExportPrefs.exportDone && 
  345.             (  pTask->fields.task.completed == 10 ||
  346.                pTask->fields.task.completed == ACTION_OK) )
  347.         {
  348.             MemHandleUnlock(h);
  349.             continue;
  350.         }
  351.  
  352.         // calc level.
  353.         if (nCurrLevel < pTask->attr.bits.level - FIRST_LEVEL &&
  354.             pTask->attr.bits.level - FIRST_LEVEL < EXPORT_NUMLEVELS)
  355.             autonum[pTask->attr.bits.level - FIRST_LEVEL] = 0;
  356.         nCurrLevel = pTask->attr.bits.level - FIRST_LEVEL;
  357.  
  358.  
  359.         // calc autonumber
  360.         if (nCurrLevel < EXPORT_NUMLEVELS)
  361.             autonum[nCurrLevel]++;
  362.  
  363.         
  364.         // TODO: put auto number
  365.         putString(ExportHeaddings[nCurrLevel].szDescPrefix, NULL, NULL);
  366.  
  367.         desc = TaskGetDescriptionByTaskPtr(pTask);
  368.         putString(desc, NULL, NULL);
  369.         MemPtrFree(desc);
  370.  
  371.         // put progress
  372.         if (gMemoExportPrefs.exportProgress)
  373.         {
  374.             if (pTask->fields.task.completed > ACTION)
  375.                 putString(
  376.                     ((pTask->fields.task.completed == ACTION_OK)? "[x]": "[ ]"),
  377.                     NULL, NULL);
  378.             else
  379.             {
  380.                 StrIToA(tmpbuff, pTask->fields.task.completed);
  381.                 putString(tmpbuff, "[", "0%]");
  382.             }
  383.         }
  384.  
  385.         // put dueDate
  386.         if (gMemoExportPrefs.exportDueDate && pTask->fields.task.dueDate.month)
  387.         {
  388.             DateToAscii(pTask->fields.task.dueDate.month,
  389.                         pTask->fields.task.dueDate.day,
  390.                         pTask->fields.task.dueDate.year + YEAR_OFFSET,
  391.                         gDateFormat, tmpbuff);
  392.             putString(tmpbuff, "(", ")");
  393.         }
  394.  
  395.  
  396.         // put priority
  397.         if (gMemoExportPrefs.exportPriority &&
  398.             pTask->fields.task.priority > 0 && pTask->fields.task.priority < 7)
  399.         {
  400.             StrIToA(tmpbuff, pTask->fields.task.priority);
  401.             putString(tmpbuff, " <", ">");
  402.         }
  403.  
  404.         putString(ExportHeaddings[nCurrLevel].szDescSuffix, NULL, NULL);
  405.         putString((char*)szNL, NULL, NULL);
  406.  
  407.  
  408.         // put note
  409.         if (gMemoExportPrefs.exportNote &&
  410.             *(&pTask->fields.task.description + StrLen(&pTask->fields.task.description) + 1) != '\0')
  411.         {
  412.             putString(&pTask->fields.task.description + StrLen(&pTask->fields.task.description) + 1,
  413.                       ( (nCurrLevel < EXPORT_NUMLEVELS)?
  414.                         ExportHeaddings[nCurrLevel].szLinePrefix : NULL),
  415.                       NULL);
  416.             putString((char*)szNL, NULL, NULL);
  417.         }
  418.  
  419.  
  420.         MemHandleUnlock(h);
  421.     }
  422.     flushDocBuffer();
  423.     MemPtrFree(docrcd);
  424.  
  425.  
  426.     //
  427.     // Make DOC headder record
  428.     //
  429.     {
  430.         index = 0;
  431.         h = DmNewRecord(docdb, &index, sizeof(DocInfo_t));
  432.         rcd = MemHandleLock(h);
  433.         DmWrite(rcd, 0, info, sizeof(DocInfo_t));
  434.         MemHandleUnlock(h);
  435.         DmReleaseRecord(docdb, index, true);
  436.     }
  437.  
  438.     MemPtrFree(info);
  439. } // void ExportToDoc(UInt16 cardNo, char const* name, UInt16 first, UInt16 last)
  440.  
  441.  
  442.