home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: InfoMgt / InfoMgt.zip / code25.zip / fsptodo.c < prev    next >
C/C++ Source or Header  |  1995-10-13  |  88KB  |  2,525 lines
  1.  
  2. #define INCL_GPIPATHS
  3.  
  4. #define VAR_SCOPE extern
  5.  
  6. #include "fsp.h"
  7.  
  8. //*** Prototypes ************************************************************ */
  9.  
  10. BOOL             pfnToDoStat     ( PUSEREC );
  11. VOID             pfnToDoCont     ( HWND, PUSEREC );
  12. VOID             pfnToDoMenu     ( PUSEREC, HWND, SHORT );
  13. VOID             pfnToDoNewPage  ( BOOL );
  14. VOID             pfnToDoPrintInit( VOID );
  15. SHORT   APIENTRY pfnToDoSort     ( PRECORDCORE, PRECORDCORE, PVOID );
  16. VOID             pfnToDoPrtThd   ( PVOID );
  17.  
  18. VOID             pfnDrawCheckMark( HPS, PRECTL, PFONTMETRICS );
  19.  
  20. /***************************************************************************/
  21. /* To-Do Window Proc                                                       */
  22. /***************************************************************************/
  23. MRESULT EXPENTRY pfnwpToDoWin ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  24. {
  25.    PUSEREC     pRecScn = WinQueryWindowPtr ( hwnd, 0 );
  26.     
  27.    switch ( msg ) 
  28.    {
  29.       case WM_CREATE:
  30.           
  31.       break;
  32.        
  33.       case WM_ACTIVATE:
  34.           
  35.          if ( SHORT1FROMMP ( mp1 ) ) 
  36.          {
  37.             hwndFoc = HWNDFROMMP ( mp2 );
  38.              
  39.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  40.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  41.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  42.          }
  43.          else 
  44.          {
  45.             hwndFoc = HWNDFROMMP ( mp2 );
  46.              
  47.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  48.                          NULL, NULL );
  49.          }
  50.           
  51.       break;
  52.        
  53.       case WM_DRAWITEM:
  54.       {
  55.          POWNERITEM        poi;
  56.          PCNRDRAWITEMINFO  pcdi;
  57.          PTODOREC          pToDoFoc;
  58.  
  59.          poi = PVOIDFROMMP ( mp2 );
  60.           
  61.          if ( ! poi->hItem )
  62.             break;
  63.           
  64.          pcdi     = (PCNRDRAWITEMINFO) poi->hItem;
  65.          pToDoFoc = (PTODOREC)         pcdi->pRecord;
  66.           
  67.          if ( ! pToDoFoc )
  68.             break;
  69.           
  70.          if ( ulToDoOpts & SCB_PRICOLR ) 
  71.          {
  72.             if ( pcdi->pFieldInfo->offStruct == FIELDOFFSET ( TODOREC, pszPr ) ) 
  73.             {
  74.                switch ( pToDoFoc->ulPri ) 
  75.                {
  76.                   case SCB_TODO_PRI5:
  77.                       
  78.                      WinFillRect ( poi->hps, &poi->rclItem, 0x00FF0000 );//CLR_RED );
  79.                       
  80.                   break;
  81.                    
  82.                   case SCB_TODO_PRI4:
  83.                       
  84.                      WinFillRect ( poi->hps, &poi->rclItem, 0x00FFFF00 );//CLR_PINK ); Yellow
  85.                       
  86.                   break;
  87.                    
  88.                   case SCB_TODO_PRI3:
  89.                       
  90.                      WinFillRect ( poi->hps, &poi->rclItem, 0x000000FF );//CLR_BLUE );
  91.                       
  92.                   break;
  93.                    
  94.                   case SCB_TODO_PRI2:
  95.                       
  96.                      WinFillRect ( poi->hps, &poi->rclItem, 0x0000FFFF );//CLR_CYAN );
  97.                       
  98.                   break;
  99.                    
  100.                   case SCB_TODO_PRI1:
  101.                       
  102.                      WinFillRect ( poi->hps, &poi->rclItem, 0x00FFFFFF );//CLR_WHITE );
  103.                       
  104.                   break;
  105.                }
  106.                return ( MRESULT ) TRUE;
  107.             }
  108.          }
  109.  
  110.          if ( pcdi->pFieldInfo->offStruct == FIELDOFFSET ( TODOREC, pszFn ) )
  111.          {
  112.             if ( pToDoFoc->ulOpt & SCB_TODO_DONE )
  113.             {
  114.                poi->rclItem.xLeft += pRecScn->pdr->fat.lAveCharWidth;
  115.  
  116.                pfnDrawCheckMark ( poi->hps, &poi->rclItem, NULL );
  117.             }
  118.             else
  119.                WinFillRect ( poi->hps, &poi->rclItem, 0x00FFFFFF );//CLR_WHITE );
  120.  
  121.             return ( MRESULT ) TRUE;
  122.          }
  123.       }
  124.       break;
  125.        
  126.       case WM_SIZE:
  127.           
  128.          if ( pRecScn )
  129.             WinSetWindowPos ( pRecScn->pdr->hwndE, 0, 0, 0,
  130.                               SHORT1FROMMP ( mp2 ),
  131.                               SHORT2FROMMP ( mp2 ),
  132.                               SWP_SHOW | SWP_SIZE | SWP_MOVE );
  133.       break;
  134.        
  135.       case UWM_SETRECPTR: //*** Store Data Pointer **************************
  136.       {
  137.          pRecScn = PVOIDFROMMP ( mp1 );
  138.           
  139.          WinSetWindowPtr ( hwnd, 0, pRecScn );
  140.       }
  141.       break;
  142.  
  143.       case UWM_PARAMS:
  144.       {
  145.          PDATREC        pdr;
  146.          ULONG          ulOff;
  147.          PBYTE          pbDat;
  148.          ULONG          ulLen;
  149.          PTODOREC       pToDoNew;
  150.          RECORDINSERT   recins;
  151.          HWND           hwndMenu;
  152.  
  153.          //*** Store Data Pointer *******************************************
  154.           
  155.          pRecScn = PVOIDFROMMP ( mp1 );
  156.           
  157.          WinSetWindowPtr ( hwnd, 0, pRecScn );
  158.           
  159.          pdr = pRecScn->pdr;
  160.           
  161.          //*** Frame ********************************************************
  162.           
  163.          pfnSetWinPos ( hwnd, pdr );
  164.           
  165.          pdr->hwndM = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU );
  166.           
  167.          pdr->pszStat = malloc ( 80 );
  168.           
  169.          if ( ( ulRelRev % 5000 ) < 110 || ! pdr->ulDEnt )
  170.             pRecScn->pdr->ulStyl = TODO_STY_SHOWENTR | TODO_STY_SHOWTARG |
  171.                                    TODO_STY_SHOWDONE | TODO_STY_SHOWPRIO |
  172.                                    TODO_STY_SHOWCHEK | TODO_STY_SHOWTASK;
  173.  
  174.          pfnToDoCont ( hwnd, pRecScn );
  175.  
  176.          hwndMenu = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU);
  177.  
  178.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWENTR )
  179.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWENTR, TRUE );
  180.  
  181.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWTARG )
  182.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWTARG, TRUE );
  183.  
  184.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWDONE )
  185.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWDONE, TRUE );
  186.  
  187.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWPRIO )
  188.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWPRIO, TRUE );
  189.  
  190.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWCHEK )
  191.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWCHEK, TRUE );
  192.  
  193.          if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWTASK )
  194.             WinCheckMenuItem ( hwndMenu, MID_TODO_SHOWTASK, TRUE );
  195.  
  196.          //*** Insert Data **************************************************
  197.           
  198.          pbDat = pdr->pvDat;
  199.  
  200.          /* pdr->colInfo[TODO_ENTR].ulPels = 10;
  201.             pdr->colInfo[TODO_TARG].ulPels = 10;
  202.             pdr->colInfo[TODO_DONE].ulPels = 10;
  203.             pdr->colInfo[TODO_PRIO].ulPels =  5;
  204.             pdr->colInfo[TODO_CHEK].ulPels =  5;
  205.             pdr->colInfo[TODO_TASK].ulPels = 60;*/
  206.  
  207.          if ( pdr->ulDEnt && pdr->ulRelRev >= 114 )
  208.             for ( ulOff = 0; ulOff < TODO_COLS; ++ulOff )
  209.             {
  210.                memcpy ( &pdr->colInfo[ulOff].ulPels, pbDat, sizeof ( ULONG ) );
  211.                pbDat += sizeof ( ULONG );
  212.             }
  213.  
  214.          pdr->ulCntr = 0;
  215.           
  216.          for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) 
  217.          {
  218.             pToDoNew = WinSendMsg ( pdr->hwndE, CM_ALLOCRECORD,
  219.                                     MPFROMLONG (sizeof(TODOREC)-sizeof(RECORDCORE)),
  220.                                     MPFROMSHORT( 1 ) );
  221.              
  222.             //*** Init Record ***********************************************
  223.              
  224.             memcpy ( &pToDoNew->cdEnt, pbDat, sizeof ( CDATE ) );
  225.             pbDat += sizeof ( CDATE );
  226.              
  227.             memcpy ( &pToDoNew->cdFin, pbDat, sizeof ( CDATE ) );
  228.             pbDat += sizeof ( CDATE );
  229.              
  230.             memcpy ( &pToDoNew->cdTrg, pbDat, sizeof ( CDATE ) );
  231.             pbDat += sizeof ( CDATE );
  232.              
  233.             memcpy ( &pToDoNew->ulOpt, pbDat, sizeof ( ULONG ) );
  234.             pbDat += sizeof ( ULONG );
  235.              
  236.             pToDoNew->pszPr = malloc ( 2 );
  237.              
  238.             if ( ( ulRelRev % 5000 ) < 110 ) 
  239.             {
  240.                if ( pToDoNew->ulOpt ) 
  241.                {
  242.                   pToDoNew->ulOpt = SCB_TODO_DONE;
  243.                   pToDoNew->ulPri = 0;
  244.                    
  245.                   strcpy ( pToDoNew->pszPr, "5" );
  246.                }
  247.             }
  248.             else 
  249.             {
  250.                pToDoNew->ulPri = pToDoNew->ulOpt & 0x0000000F;
  251.                 
  252.                switch ( pToDoNew->ulPri ) 
  253.                {
  254.                   case SCB_TODO_PRI5:
  255.                       
  256.                      strcpy ( pToDoNew->pszPr, "1" );
  257.                       
  258.                   break;
  259.                    
  260.                   case SCB_TODO_PRI4:
  261.                       
  262.                      strcpy ( pToDoNew->pszPr, "2" );
  263.                       
  264.                   break;
  265.                    
  266.                   case SCB_TODO_PRI3:
  267.                       
  268.                      strcpy ( pToDoNew->pszPr, "3" );
  269.                       
  270.                   break;
  271.                    
  272.                   case SCB_TODO_PRI2:
  273.                       
  274.                      strcpy ( pToDoNew->pszPr, "4" );
  275.                       
  276.                   break;
  277.                    
  278.                   case SCB_TODO_PRI1:
  279.                       
  280.                      strcpy ( pToDoNew->pszPr, "5" );
  281.                       
  282.                   break;
  283.                    
  284.                }
  285.                 
  286.             }
  287.              
  288.             ulLen = strlen ( pbDat ) + 1;
  289.             pToDoNew->pszDo = malloc ( ulLen );
  290.             strcpy ( pToDoNew->pszDo, pbDat );
  291.             pbDat += ulLen;
  292.              
  293.             pToDoNew->pszFn = malloc ( 2 );
  294.              
  295.             if ( pToDoNew->ulOpt & SCB_TODO_DONE ) 
  296.             {
  297.                //sprintf ( pToDoNew->pszFn, "%c", 251 );
  298.                strcpy ( pToDoNew->pszFn, "X" );
  299.                 
  300.                ++pRecScn->pdr->ulCntr;
  301.             }
  302.             else
  303.                strcpy ( pToDoNew->pszFn, " " );
  304.              
  305.             //*** Insert ****************************************************
  306.              
  307.             recins.cb                = sizeof ( RECORDINSERT );
  308.             recins.pRecordParent     = (PRECORDCORE) NULL;
  309.             recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  310.             recins.zOrder            = CMA_TOP;
  311.             recins.cRecordsInsert    = 1;
  312.             recins.fInvalidateRecord = TRUE;
  313.              
  314.             WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  315.                          MPFROMP( pToDoNew ), MPFROMP ( &recins ) );
  316.          }
  317.           
  318.          //*** Create & Date Edit *******************************************
  319.           
  320.          pdr->pdDate = malloc ( sizeof ( DATEREC ) );
  321.           
  322.          memset ( pdr->pdDate, 0, sizeof ( DATEREC ) );
  323.           
  324.          pdr->pdDate->pszTtl = malloc ( 80 );
  325.           
  326.          pdr->ulOpts |= SCB_OPENED;
  327.           
  328.          pdr->fbModified = FALSE;
  329.           
  330.          pfnToDoStat ( pRecScn );
  331.  
  332.          //*** Create & Init Search *****************************************
  333.           
  334.          pRecScn->pdr->psSrch = malloc ( sizeof ( SRCHREC ) );
  335.           
  336.          memset ( pRecScn->pdr->psSrch, 0, sizeof ( SRCHREC ) );
  337.           
  338.          pRecScn->pdr->psSrch->hwndE = hwnd;
  339.           
  340.          pRecScn->pdr->psSrch->fbIsCn = TRUE;
  341.           
  342.          pRecScn->pdr->psSrch->pszFnd = malloc ( 1 );
  343.  
  344.          *pRecScn->pdr->psSrch->pszFnd = 0;
  345.       }
  346.       break;
  347.        
  348.       case WM_INITMENU:
  349.       {
  350.          HWND    hwndMenu;
  351.  
  352.          WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  353.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  354.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  355.           
  356.          hwndMenu = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU);
  357.  
  358.          pfnToDoMenu ( pRecScn, hwndMenu, SHORT1FROMMP ( mp1 ) );
  359.       }
  360.       break;
  361.        
  362.       case WM_HELP:
  363.       {
  364.          SHORT   sId;
  365.  
  366.          sId = WinQueryWindowUShort ( hwnd, QWS_ID );
  367.  
  368.          WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  369.                       MPFROM2SHORT ( sId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  370.       }
  371.       break;
  372.        
  373.       case WM_COMMAND:
  374.           
  375.          if ( SHORT1FROMMP(mp1) != MID_TODO_TASK && pRecScn->pdr->fbEditing )
  376.             WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  377.           
  378.          switch ( SHORT1FROMMP ( mp1 ) ) 
  379.          {
  380.             case MID_TODO_SAVE:
  381.                 
  382.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  383.                 
  384.             break;
  385.              
  386.             case MID_TODO_EXIT:
  387.  
  388.                WinPostMsg ( WinQueryWindow(hwnd,QW_PARENT), WM_SYSCOMMAND, MPFROM2SHORT ( SC_CLOSE, 0 ), NULL );
  389.  
  390.             break;
  391.              
  392.             case MID_TODO_SAVE_EXIT:
  393.  
  394.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  395.                WinPostMsg ( WinQueryWindow(hwnd,QW_PARENT), WM_SYSCOMMAND, MPFROM2SHORT ( SC_CLOSE, 0 ), NULL );
  396.  
  397.             break;
  398.              
  399.             case MID_TODO_FIND:
  400.                 
  401.                WinLoadDlg ( HWND_DESKTOP, hwnd, pfndpSearch, 0L, DLG_SEARCH, 
  402.                             pRecScn->pdr->psSrch );
  403.                 
  404.             break;
  405.              
  406.             case MID_TODO_FNDNXT:
  407.                 
  408.                WinPostMsg ( hwnd, UWM_SEARCH, NULL, NULL );
  409.                 
  410.             break;
  411.              
  412.             case MID_TODO_COPY: case MID_TODO_CUT:
  413.             {
  414.                PVOID       pvClip;
  415.                ULONG       ulSize;
  416.                PBYTE       pbScn;
  417.                PTODOREC    pToDoFoc;
  418.  
  419.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  420.                                        MPFROMLONG ( CMA_FIRST ),
  421.                                        MPFROMSHORT( CRA_SELECTED ) );
  422.                 
  423.                //*** Alloc & Init Mem ***************************************
  424.                 
  425.                ulSize  = sizeof ( CDATE );
  426.                ulSize += sizeof ( CDATE );
  427.                ulSize += sizeof ( CDATE );
  428.                ulSize += sizeof ( BOOL );
  429.                ulSize += strlen ( pToDoFoc->pszDo ) + 1;
  430.                 
  431.                DosAllocSharedMem ( &pvClip, NULL, ulSize, PAG_WRITE | PAG_COMMIT | OBJ_GIVEABLE | OBJ_GETTABLE );
  432.                 
  433.                DosGetSharedMem ( pvClip, PAG_WRITE );
  434.                 
  435.                pbScn = pvClip;
  436.                 
  437.                memcpy ( pbScn, &pToDoFoc->cdEnt, sizeof ( CDATE ) );
  438.                pbScn  += sizeof ( CDATE );
  439.                 
  440.                memcpy ( pbScn, &pToDoFoc->cdFin, sizeof ( CDATE ) );
  441.                pbScn  += sizeof ( CDATE );
  442.                 
  443.                memcpy ( pbScn, &pToDoFoc->cdTrg, sizeof ( CDATE ) );
  444.                pbScn  += sizeof ( CDATE );
  445.                 
  446.                memcpy ( pbScn, &pToDoFoc->ulOpt, sizeof ( ULONG ) );
  447.                pbScn  += sizeof ( ULONG );
  448.                 
  449.                strcpy ( pbScn, pToDoFoc->pszDo );
  450.                pbScn  += strlen ( pToDoFoc->pszDo ) + 1;
  451.                 
  452.                //*** Clipboard it *******************************************
  453.                 
  454.                WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  455.                 
  456.                WinSetClipbrdData ( WinQueryAnchorBlock ( hwnd ), (ULONG) pvClip, atomToDo, CFI_POINTER );
  457.                 
  458.                WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  459.                 
  460.                if ( SHORT1FROMMP ( mp1 ) == MID_TODO_CUT )
  461.                   WinSendMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_TODO_DELT, 0 ), NULL );
  462.             }
  463.             break;
  464.              
  465.             case MID_TODO_PASTE:
  466.             {
  467.                PVOID          pvClip;
  468.                PBYTE          pbScn;
  469.                PTODOREC       pToDoNew;
  470.                PTODOREC       pToDoFoc;
  471.                RECORDINSERT   recins;
  472.  
  473.                if ( pfnIsMyClip ( hwnd, atomToDo ) ) 
  474.                {
  475.                   WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  476.                    
  477.                   pvClip = (PVOID)WinQueryClipbrdData ( WinQueryAnchorBlock ( hwnd ), atomToDo );
  478.                    
  479.                   pbScn = pvClip;
  480.                    
  481.                   //*** Allocate & Init Rec *********************************
  482.                    
  483.                   pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  484.                                           MPFROMLONG ( CMA_FIRST ),
  485.                                           MPFROMSHORT( CRA_SELECTED ) );
  486.                    
  487.                   pToDoNew = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  488.                                           MPFROMLONG (sizeof(TODOREC)-sizeof(RECORDCORE)),
  489.                                           MPFROMSHORT( 1 ) );
  490.                    
  491.                   //*** Init Record *****************************************
  492.                    
  493.                   memcpy ( &pToDoNew->cdEnt, pbScn, sizeof ( CDATE ) );
  494.                   pbScn  += sizeof ( CDATE );
  495.                    
  496.                   memcpy ( &pToDoNew->cdFin, pbScn, sizeof ( CDATE ) );
  497.                   pbScn  += sizeof ( CDATE );
  498.                    
  499.                   memcpy ( &pToDoNew->cdTrg, pbScn, sizeof ( CDATE ) );
  500.                   pbScn  += sizeof ( CDATE );
  501.                    
  502.                   memcpy ( &pToDoNew->ulOpt, pbScn, sizeof ( ULONG ) );
  503.                   pbScn  += sizeof ( ULONG );
  504.                    
  505.                   pToDoNew->pszDo = malloc ( strlen ( pbScn ) + 1 );
  506.                   strcpy ( pToDoNew->pszDo, pbScn );
  507.                   pbScn  += strlen ( pToDoNew->pszDo ) + 1;
  508.                    
  509.                   pToDoNew->pszFn = malloc ( 2 );
  510.                    
  511.                   if ( pToDoNew->ulOpt & SCB_TODO_DONE ) 
  512.                   {
  513.                      //sprintf ( pToDoNew->pszFn, "%c", 251 );
  514.                      strcpy ( pToDoNew->pszFn, "X" );
  515.                       
  516.                      ++pRecScn->pdr->ulCntr;
  517.                   }
  518.                   else
  519.                      strcpy ( pToDoNew->pszFn, " " );
  520.                    
  521.                   pToDoNew->ulPri = pToDoNew->ulOpt & 0x0000000F;
  522.                    
  523.                   pToDoNew->pszPr = malloc ( 2 );
  524.                    
  525.                   switch ( pToDoNew->ulPri ) 
  526.                   {
  527.                      case SCB_TODO_PRI5:
  528.                          
  529.                         strcpy ( pToDoNew->pszPr, "1" );
  530.                          
  531.                      break;
  532.                       
  533.                      case SCB_TODO_PRI4:
  534.                          
  535.                         strcpy ( pToDoNew->pszPr, "2" );
  536.                          
  537.                      break;
  538.                       
  539.                      case SCB_TODO_PRI3:
  540.                          
  541.                         strcpy ( pToDoNew->pszPr, "3" );
  542.                          
  543.                      break;
  544.                       
  545.                      case SCB_TODO_PRI2:
  546.                          
  547.                         strcpy ( pToDoNew->pszPr, "4" );
  548.                          
  549.                      break;
  550.                       
  551.                      case SCB_TODO_PRI1:
  552.                          
  553.                         strcpy ( pToDoNew->pszPr, "5" );
  554.                          
  555.                      break;
  556.                       
  557.                   }
  558.                    
  559.                   //*** Insert **********************************************
  560.                    
  561.                   recins.cb                = sizeof ( RECORDINSERT );
  562.                   recins.pRecordParent     = NULL;
  563.                    
  564.                   if ( pToDoFoc )
  565.                      recins.pRecordOrder = (PRECORDCORE) pToDoFoc;
  566.                   else 
  567.                      recins.pRecordOrder = (PRECORDCORE) CMA_END;
  568.                    
  569.                   recins.zOrder            = CMA_TOP;
  570.                   recins.cRecordsInsert    = 1;
  571.                   recins.fInvalidateRecord = TRUE;
  572.                    
  573.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  574.                                MPFROMP( pToDoNew ), MPFROMP ( &recins ) );
  575.                    
  576.                   pRecScn->pdr->fbModified = TRUE;
  577.                   //fbModified = TRUE;
  578.                    
  579.                   ++pRecScn->pdr->ulDEnt;
  580.                    
  581.                   pfnToDoStat ( pRecScn );
  582.                    
  583.                   WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  584.                }
  585.             }
  586.             break;
  587.              
  588.             case MID_TODO_ADD:
  589.             {
  590.                PTODOREC       pToDoNew;
  591.                PTODOREC       pToDoFoc;
  592.                RECORDINSERT   recins;
  593.  
  594.                //*** Allocate & Init Rec ************************************
  595.                 
  596.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  597.                                        MPFROMLONG ( CMA_FIRST ),
  598.                                        MPFROMSHORT( CRA_SELECTED ) );
  599.                 
  600.                pToDoNew = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  601.                                        MPFROMLONG (sizeof(TODOREC)-sizeof(RECORDCORE)),
  602.                                        MPFROMSHORT( 1 ) );
  603.                 
  604.                //*** Init Record ********************************************
  605.                 
  606.                pToDoNew->pszDo = malloc ( 1 );
  607.                 
  608.                *pToDoNew->pszDo = 0;
  609.                 
  610.                pfnSetWhen ( &pToDoNew->cdEnt, NULL );
  611.                 
  612.                memset ( &pToDoNew->cdFin, 0, sizeof ( CDATE ) );
  613.                memset ( &pToDoNew->cdTrg, 0, sizeof ( CDATE ) );
  614.                 
  615.                pToDoNew->ulOpt = 0;
  616.                 
  617.                pToDoNew->pszFn = malloc ( 2 );
  618.                 
  619.                strcpy ( pToDoNew->pszFn, " " );
  620.                 
  621.                pToDoNew->pszPr = malloc ( 2 );
  622.  
  623.                pToDoNew->ulOpt |= SCB_TODO_PRI5;
  624.                 
  625.                pToDoNew->ulPri = SCB_TODO_PRI5;
  626.                 
  627.                strcpy ( pToDoNew->pszPr, "1" );
  628.                 
  629.                //*** Insert *************************************************
  630.                 
  631.                recins.cb                = sizeof ( RECORDINSERT );
  632.                recins.pRecordParent     = NULL;
  633.                 
  634.                if ( pToDoFoc )
  635.                   recins.pRecordOrder = (PRECORDCORE) pToDoFoc;
  636.                else
  637.                   recins.pRecordOrder = (PRECORDCORE) CMA_END;
  638.                 
  639.                recins.zOrder            = CMA_TOP;
  640.                recins.cRecordsInsert    = 1;
  641.                recins.fInvalidateRecord = TRUE;
  642.                 
  643.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  644.                             MPFROMP( pToDoNew ), MPFROMP ( &recins ) );
  645.                 
  646.                pRecScn->pdr->fbModified = TRUE;
  647.                //fbModified = TRUE;
  648.                 
  649.                ++pRecScn->pdr->ulDEnt;
  650.                 
  651.                pfnToDoStat ( pRecScn );
  652.                 
  653.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  654.                             MPFROMP ( pToDoNew ),
  655.                             MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  656.                 
  657.                WinPostMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_TODO_TASK, 0 ), NULL );
  658.             }
  659.             break;
  660.              
  661.             case MID_TODO_DELT:
  662.             {
  663.                PTODOREC   pToDoFoc;
  664.  
  665.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  666.                                        MPFROMLONG ( CMA_FIRST ),
  667.                                        MPFROMSHORT( CRA_SELECTED ) );
  668.                 
  669.                if ( pToDoFoc->ulOpt & SCB_TODO_DONE )
  670.                   --pRecScn->pdr->ulCntr;
  671.                 
  672.                WinSendMsg ( pRecScn->pdr->hwndE, CM_REMOVERECORD,
  673.                             MPFROMP ( &pToDoFoc ),
  674.                             MPFROM2SHORT( 1, CMA_FREE | CMA_INVALIDATE ) );
  675.                 
  676.                pRecScn->pdr->fbModified = TRUE;
  677.                //fbModified = TRUE;
  678.                 
  679.                --pRecScn->pdr->ulDEnt;
  680.                 
  681.                pfnToDoStat ( pRecScn );
  682.             }
  683.             break;
  684.              
  685.             case MID_TODO_FONT:
  686.             {
  687.                PDATREC   pdr = pRecScn->pdr;
  688.                HPS       hps = WinGetPS ( pdr->hwndE );
  689.  
  690.                if ( pfnGetFont ( hwnd, hps, NULLHANDLE, &pdr->fxPtSz, &pdr->fat ) )
  691.                {
  692.                   pfnSetPPFont ( pdr->hwndE, pdr->fxPtSz, &pdr->fat );
  693.                }
  694.  
  695.                WinReleasePS ( hps );
  696.             }
  697.             break;
  698.              
  699.             case MID_TODO_COLOR:
  700.             {
  701.                PDATREC   pdr;
  702.  
  703.                pdr = pRecScn->pdr;
  704.                 
  705.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpColors, 0L, DLG_COLORS, &pdr->hwndE );
  706.             }
  707.             break;
  708.              
  709.             case MID_TODO_TITLE:
  710.             {
  711.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpSetTitle, 0L, DLG_SET_TITLE, pRecScn );
  712.             }
  713.             break;
  714.              
  715.             case MID_TODO_PRINT:
  716.             {
  717.                pRecPrt = pRecScn;
  718.  
  719.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpPrint,  0L,
  720.                            DLG_PRINT, (PVOID) pfnToDoPrtThd );
  721.             }
  722.             break;
  723.              
  724.             case MID_TODO_SORT_ED: case MID_TODO_SORT_TD: case MID_TODO_SORT_FD:
  725.             case MID_TODO_SORT_TA: case MID_TODO_SORT_PR: case MID_TODO_SORT_DN:
  726.             {
  727.                ULONG    ulOff;
  728.  
  729.                ulOff = SHORT1FROMMP ( mp1 );
  730.                 
  731.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SORTRECORD,
  732.                             MPFROMP ( pfnToDoSort ),
  733.                             MPFROMP ( &ulOff ) );
  734.                 
  735.                pRecScn->pdr->fbModified = TRUE;
  736.                //fbModified = TRUE;
  737.             }
  738.             break;
  739.              
  740.             case MID_TODO_ENTD: case MID_TODO_TRGD: case MID_TODO_DUND:
  741.             {
  742.                PTODOREC  pToDoFoc;
  743.                PDATREC   pdr;
  744.  
  745.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  746.                                        MPFROMLONG ( CMA_FIRST ),
  747.                                        MPFROMSHORT( CRA_SELECTED ) );
  748.                 
  749.                pdr = pRecScn->pdr;
  750.                 
  751.                switch ( SHORT1FROMMP ( mp1 ) ) 
  752.                {
  753.                   case MID_TODO_ENTD:
  754.                       
  755.                      pdr->pdDate->pcdate = &pToDoFoc->cdEnt;
  756.                       
  757.                      strcpy ( pdr->pdDate->pszTtl, "Entry Date" );
  758.                       
  759.                   break;
  760.                    
  761.                   case MID_TODO_TRGD:
  762.                       
  763.                      pdr->pdDate->pcdate = &pToDoFoc->cdTrg;
  764.                       
  765.                      strcpy ( pdr->pdDate->pszTtl, "Target Date" );
  766.                       
  767.                   break;
  768.                    
  769.                   case MID_TODO_DUND:
  770.                       
  771.                      pdr->pdDate->pcdate = &pToDoFoc->cdFin;
  772.                       
  773.                      strcpy ( pdr->pdDate->pszTtl, "Completion Date" );
  774.                       
  775.                   break;
  776.                    
  777.                }
  778.                 
  779.                if ( WinDlgBox ( HWND_DESKTOP, hwnd, pfndpEditDate, 0L, DLG_DATE, pdr->pdDate ) ) 
  780.                {
  781.                   WinSendMsg ( pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  782.                    
  783.                   pdr->fbModified = TRUE;
  784.                   //fbModified = TRUE;
  785.                }
  786.             }
  787.             break;
  788.              
  789.             case MID_TODO_TASK:
  790.             {
  791.                PTODOREC       pToDoFoc;
  792.                CNREDITDATA    cnrEdt;
  793.  
  794.                if ( pRecScn->pdr->fbEditing ) 
  795.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  796.                else 
  797.                {
  798.                   pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  799.                                           MPFROMLONG ( CMA_FIRST ),
  800.                                           MPFROMSHORT( CRA_SELECTED ) );
  801.                    
  802.                   cnrEdt.cb         = sizeof ( CNREDITDATA );
  803.                   cnrEdt.hwndCnr    = pRecScn->pdr->hwndE;
  804.                   cnrEdt.pRecord    = (PRECORDCORE) pToDoFoc;
  805.                   cnrEdt.pFieldInfo = pRecScn->pdr->colInfo[TODO_TASK].pfinf;
  806.                   cnrEdt.ppszText   = NULL;
  807.                   cnrEdt.cbText     = 0;
  808.                   cnrEdt.id         = CID_RIGHTDVWND;
  809.                    
  810.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_OPENEDIT,
  811.                                MPFROMP ( &cnrEdt ), NULL );
  812.                }
  813.             }
  814.             break;
  815.              
  816.             case MID_TODO_PRI5:
  817.             {
  818.                PTODOREC   pToDoFoc;
  819.  
  820.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  821.                                        MPFROMLONG ( CMA_FIRST ),
  822.                                        MPFROMSHORT( CRA_SELECTED ) );
  823.                 
  824.                if ( ! pToDoFoc )
  825.                   break;
  826.                 
  827.                pToDoFoc->ulOpt &= 0xFFFFFFF0;
  828.                 
  829.                pToDoFoc->ulOpt |= SCB_TODO_PRI5;
  830.                 
  831.                pToDoFoc->ulPri = SCB_TODO_PRI5;
  832.                 
  833.                strcpy ( pToDoFoc->pszPr, "1" );
  834.                 
  835.                pRecScn->pdr->fbModified = TRUE;
  836.                //fbModified = TRUE;
  837.                 
  838.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  839.             }
  840.             break;
  841.             case MID_TODO_PRI4:
  842.             {
  843.                PTODOREC   pToDoFoc;
  844.  
  845.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  846.                                        MPFROMLONG ( CMA_FIRST ),
  847.                                        MPFROMSHORT( CRA_SELECTED ) );
  848.                 
  849.                if ( ! pToDoFoc )
  850.                   break;
  851.                 
  852.                pToDoFoc->ulOpt &= 0xFFFFFFF0;
  853.                 
  854.                pToDoFoc->ulOpt |= SCB_TODO_PRI4;
  855.                 
  856.                pToDoFoc->ulPri = SCB_TODO_PRI4;
  857.                 
  858.                strcpy ( pToDoFoc->pszPr, "2" );
  859.                 
  860.                pRecScn->pdr->fbModified = TRUE;
  861.                //fbModified = TRUE;
  862.                 
  863.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  864.             }
  865.             break;
  866.             case MID_TODO_PRI3:
  867.             {
  868.                PTODOREC   pToDoFoc;
  869.  
  870.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  871.                                        MPFROMLONG ( CMA_FIRST ),
  872.                                        MPFROMSHORT( CRA_SELECTED ) );
  873.                 
  874.                if ( ! pToDoFoc )
  875.                   break;
  876.                 
  877.                pToDoFoc->ulOpt &= 0xFFFFFFF0;
  878.                 
  879.                pToDoFoc->ulOpt |= SCB_TODO_PRI3;
  880.                 
  881.                pToDoFoc->ulPri = SCB_TODO_PRI3;
  882.                 
  883.                strcpy ( pToDoFoc->pszPr, "3" );
  884.                 
  885.                pRecScn->pdr->fbModified = TRUE;
  886.                //fbModified = TRUE;
  887.                 
  888.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  889.             }
  890.             break;
  891.             case MID_TODO_PRI2:
  892.             {
  893.                PTODOREC   pToDoFoc;
  894.  
  895.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  896.                                        MPFROMLONG ( CMA_FIRST ),
  897.                                        MPFROMSHORT( CRA_SELECTED ) );
  898.                 
  899.                if ( ! pToDoFoc )
  900.                   break;
  901.                 
  902.                pToDoFoc->ulOpt &= 0xFFFFFFF0;
  903.                 
  904.                pToDoFoc->ulOpt |= SCB_TODO_PRI2;
  905.                 
  906.                pToDoFoc->ulPri = SCB_TODO_PRI2;
  907.                 
  908.                strcpy ( pToDoFoc->pszPr, "4" );
  909.                 
  910.                pRecScn->pdr->fbModified = TRUE;
  911.                //fbModified = TRUE;
  912.                 
  913.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  914.             }
  915.             break;
  916.             case MID_TODO_PRI1:
  917.             {
  918.                PTODOREC   pToDoFoc;
  919.  
  920.                pToDoFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  921.                                        MPFROMLONG ( CMA_FIRST ),
  922.                                        MPFROMSHORT( CRA_SELECTED ) );
  923.                 
  924.                if ( ! pToDoFoc )
  925.                   break;
  926.                 
  927.                pToDoFoc->ulOpt &= 0xFFFFFFF0;
  928.                 
  929.                pToDoFoc->ulOpt |= SCB_TODO_PRI1;
  930.                 
  931.                pToDoFoc->ulPri = SCB_TODO_PRI1;
  932.                 
  933.                strcpy ( pToDoFoc->pszPr, "5" );
  934.                 
  935.                pRecScn->pdr->fbModified = TRUE;
  936.                //fbModified = TRUE;
  937.                 
  938.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  939.             }
  940.             break;
  941.              
  942.             case MID_TODO_SHOWENTR:
  943.                 
  944.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWENTR )
  945.                {
  946.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  947.                                      SHORT1FROMMP ( mp1 ), FALSE );
  948.  
  949.                   pfnFixCnrCols ( pRecScn, TODO_ENTR, FALSE );
  950.                }
  951.                else
  952.                {
  953.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  954.                                      SHORT1FROMMP ( mp1 ), TRUE );
  955.  
  956.                   pfnFixCnrCols ( pRecScn, TODO_ENTR, TRUE );
  957.                }
  958.                pRecScn->pdr->fbModified = TRUE;
  959.             break;
  960.             case MID_TODO_SHOWTARG:
  961.                 
  962.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWTARG )
  963.                {
  964.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  965.                                      SHORT1FROMMP ( mp1 ), FALSE );
  966.  
  967.                   pfnFixCnrCols ( pRecScn, TODO_TARG, FALSE );
  968.                }
  969.                else
  970.                {
  971.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  972.                                      SHORT1FROMMP ( mp1 ), TRUE );
  973.  
  974.                   pfnFixCnrCols ( pRecScn, TODO_TARG, TRUE );
  975.                }
  976.                pRecScn->pdr->fbModified = TRUE;
  977.             break;
  978.             case MID_TODO_SHOWDONE:
  979.                 
  980.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWDONE )
  981.                {
  982.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  983.                                      SHORT1FROMMP ( mp1 ), FALSE );
  984.  
  985.                   pfnFixCnrCols ( pRecScn, TODO_DONE, FALSE );
  986.                }
  987.                else
  988.                {
  989.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  990.                                      SHORT1FROMMP ( mp1 ), TRUE );
  991.  
  992.                   pfnFixCnrCols ( pRecScn, TODO_DONE, TRUE );
  993.                }
  994.                pRecScn->pdr->fbModified = TRUE;
  995.             break;
  996.             case MID_TODO_SHOWPRIO:
  997.                 
  998.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWPRIO )
  999.                {
  1000.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1001.                                      SHORT1FROMMP ( mp1 ), FALSE );
  1002.  
  1003.                   pfnFixCnrCols ( pRecScn, TODO_PRIO, FALSE );
  1004.                }
  1005.                else
  1006.                {
  1007.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1008.                                      SHORT1FROMMP ( mp1 ), TRUE );
  1009.  
  1010.                   pfnFixCnrCols ( pRecScn, TODO_PRIO, TRUE );
  1011.                }
  1012.                pRecScn->pdr->fbModified = TRUE;
  1013.             break;
  1014.             case MID_TODO_SHOWCHEK:
  1015.                 
  1016.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWCHEK )
  1017.                {
  1018.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1019.                                      SHORT1FROMMP ( mp1 ), FALSE );
  1020.  
  1021.                   pfnFixCnrCols ( pRecScn, TODO_CHEK, FALSE );
  1022.                }
  1023.                else
  1024.                {
  1025.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1026.                                      SHORT1FROMMP ( mp1 ), TRUE );
  1027.  
  1028.                   pfnFixCnrCols ( pRecScn, TODO_CHEK, TRUE );
  1029.                }
  1030.                pRecScn->pdr->fbModified = TRUE;
  1031.             break;
  1032.             case MID_TODO_SHOWTASK:
  1033.                 
  1034.                if ( pRecScn->pdr->ulStyl & TODO_STY_SHOWTASK )
  1035.                {
  1036.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1037.                                      SHORT1FROMMP ( mp1 ), FALSE );
  1038.  
  1039.                   pfnFixCnrCols ( pRecScn, TODO_TASK, FALSE );
  1040.                }
  1041.                else
  1042.                {
  1043.                   WinCheckMenuItem ( WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU ),
  1044.                                      SHORT1FROMMP ( mp1 ), TRUE );
  1045.  
  1046.                   pfnFixCnrCols ( pRecScn, TODO_TASK, TRUE );
  1047.                }
  1048.                pRecScn->pdr->fbModified = TRUE;
  1049.             break;
  1050.  
  1051.             default:
  1052.                WinPostMsg ( hwndM, msg, mp1, mp2 );
  1053.          }
  1054.           
  1055.       break;
  1056.        
  1057.       case WM_CONTROL:
  1058.           
  1059.          if ( SHORT1FROMMP ( mp1 ) == WID_CONT )
  1060.          {
  1061.             //case WID_CONT:
  1062.             switch ( SHORT2FROMMP ( mp1 ) ) 
  1063.             {
  1064.                case CN_BEGINEDIT:
  1065.                    
  1066.                   pRecScn->pdr->fbEditing = TRUE;
  1067.                    
  1068.                return ( MRESULT ) TRUE;
  1069.                 
  1070.                case CN_ENDEDIT:
  1071.                    
  1072.                   pRecScn->pdr->fbEditing = FALSE;
  1073.                    
  1074.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  1075.  
  1076.                return ( MRESULT ) TRUE;
  1077.                 
  1078.                case CN_CONTEXTMENU:
  1079.                {
  1080.                   HWND       hwndMenu;
  1081.                   POINTL     ptl;
  1082.                   PTODOREC   pToDoNew;
  1083.  
  1084.                   pToDoNew = PVOIDFROMMP ( mp2 );
  1085.                    
  1086.                   hwndMenu = WinLoadMenu ( hwnd, 0, WID_TODO );
  1087.                    
  1088.                   if ( ! pToDoNew )
  1089.                      WinEnableMenuItem ( hwndMenu, MID_TODO_DELT, FALSE );
  1090.                   else 
  1091.                   {
  1092.                      WinEnableMenuItem ( hwndMenu, MID_TODO_DELT, TRUE );
  1093.                       
  1094.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  1095.                                   MPFROMP ( pToDoNew ),
  1096.                                   MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  1097.                   }
  1098.  
  1099.                   pfnToDoMenu ( pRecScn, hwndMenu, MID_TODO_EDIT );
  1100.  
  1101.                   WinQueryPointerPos ( HWND_DESKTOP, &ptl );
  1102.                    
  1103.                   WinMapWindowPoints ( HWND_DESKTOP, hwnd, &ptl, 1 );
  1104.                    
  1105.                   WinPopupMenu ( pRecScn->pdr->hwndE, hwnd, hwndMenu,
  1106.                                  (SHORT)ptl.x, (SHORT)ptl.y,
  1107.                                  MID_TODO_EDIT,
  1108.                                  PU_POSITIONONITEM | //PU_HCONSTRAIN | PU_VCONSTRAIN |
  1109.                                  PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 | PU_KEYBOARD );
  1110.                }
  1111.                return ( MRESULT ) TRUE;
  1112.                 
  1113.                case CN_REALLOCPSZ:
  1114.                {
  1115.                   PTODOREC       pToDoNew;
  1116.                   PCNREDITDATA   pcnrEdt;
  1117.  
  1118.                   pcnrEdt = PVOIDFROMMP ( mp2 );
  1119.                    
  1120.                   pToDoNew = (PTODOREC) pcnrEdt->pRecord;
  1121.                    
  1122.                   pToDoNew->pszDo = realloc ( pToDoNew->pszDo, pcnrEdt->cbText );
  1123.                    
  1124.                   pRecScn->pdr->fbModified = TRUE;
  1125.                   //fbModified = TRUE;
  1126.                    
  1127.                   pfnSetWhen ( &pToDoNew->cdEnt, NULL );
  1128.                }
  1129.                return ( MRESULT ) TRUE;
  1130.                 
  1131.                case CN_ENTER:
  1132.                {
  1133.                   PTODOREC              pToDoNew;
  1134.                   PNOTIFYRECORDENTER    pcnrEnt;
  1135.  
  1136.                   pcnrEnt = PVOIDFROMMP ( mp2 );
  1137.                    
  1138.                   pToDoNew = (PTODOREC) pcnrEnt->pRecord;
  1139.                    
  1140.                   if ( pToDoNew ) 
  1141.                   {
  1142.                      if ( pToDoNew->ulOpt & SCB_TODO_DONE ) 
  1143.                      {
  1144.                         pToDoNew->ulOpt &= ~SCB_TODO_DONE;
  1145.                          
  1146.                         --pRecScn->pdr->ulCntr;
  1147.                          
  1148.                         strcpy ( pToDoNew->pszFn, " " );
  1149.                      }
  1150.                      else 
  1151.                      {
  1152.                         pToDoNew->ulOpt |= SCB_TODO_DONE;
  1153.                          
  1154.                         //sprintf ( pToDoNew->pszFn, "%c", 251 );
  1155.                         strcpy ( pToDoNew->pszFn, "X" );
  1156.                          
  1157.                         ++pRecScn->pdr->ulCntr;
  1158.                          
  1159.                         pRecScn->pdr->fbModified = TRUE;
  1160.                         pfnSetWhen ( &pToDoNew->cdFin, NULL );
  1161.                      }
  1162.                       
  1163.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  1164.  
  1165.                      pfnToDoStat ( pRecScn );
  1166.                   }
  1167.                }
  1168.                return ( MRESULT ) TRUE;
  1169.                 
  1170.                case CN_INITDRAG:
  1171.                {
  1172.                   PTODOREC      pRecDrg;
  1173.                   PCNRDRAGINIT  pcnrDrg;
  1174.                   PDRAGINFO     pdinfo;
  1175.                   DRAGITEM      ditem;
  1176.                   DRAGIMAGE     dimage;
  1177.       
  1178.                   pcnrDrg = PVOIDFROMMP ( mp2 );
  1179.                    
  1180.                   pRecDrg = (PTODOREC) pcnrDrg->pRecord;
  1181.                    
  1182.                   if ( ! pRecDrg )
  1183.                      break;
  1184.                    
  1185.                   //*** Drag It ******************************************
  1186.                    
  1187.                   pdinfo = DrgAllocDraginfo ( 1 );
  1188.                    
  1189.                   ditem.hwndItem       = hwnd;
  1190.                   ditem.ulItemID       = (ULONG)pRecDrg;
  1191.                   ditem.hstrType       = DrgAddStrHandle ( DRT_TREE );
  1192.                   ditem.hstrRMF        = DrgAddStrHandle ( DRM_TODO );
  1193.                   ditem.fsControl      = 0;
  1194.                   ditem.fsSupportedOps = DO_COPYABLE | DO_MOVEABLE;
  1195.                    
  1196.                   DrgSetDragitem ( pdinfo, &ditem, sizeof(ditem), 0 );
  1197.                    
  1198.                   dimage.cb       = sizeof(DRAGIMAGE);
  1199.                   dimage.cptl     = 0;
  1200.                   dimage.hImage   = hptrToDo;
  1201.                   dimage.fl       = DRG_ICON;
  1202.                   dimage.cxOffset = 0;
  1203.                   dimage.cyOffset = 0;
  1204.                    
  1205.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  1206.                                MPFROMP ( pRecDrg ),
  1207.                                MPFROM2SHORT ( TRUE, 0x00004000 ) );//CRA_CURSORED ) );
  1208.                    
  1209.                   DrgDrag ( hwnd, pdinfo, &dimage, 1, VK_ENDDRAG, NULL );
  1210.                    
  1211.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  1212.                                MPFROMP ( pRecDrg ),
  1213.                                MPFROM2SHORT ( FALSE, 0x00004000 ) );//CRA_CURSORED ) );
  1214.                    
  1215.                   DrgFreeDraginfo ( pdinfo );
  1216.                }
  1217.                break;
  1218.                 
  1219.                case CN_DRAGAFTER:
  1220.                {
  1221.                   PCNRDRAGINFO  pcnrDri;
  1222.                   PDRAGINFO     pdinfo;
  1223.                   PDRAGITEM     pditem;
  1224.       
  1225.                   pcnrDri = PVOIDFROMMP ( mp2 );
  1226.                    
  1227.                   pdinfo = pcnrDri->pDragInfo;
  1228.                    
  1229.                   DrgAccessDraginfo ( pdinfo );
  1230.                    
  1231.                   pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  1232.                    
  1233.                   if ( pditem->hwndItem != hwnd )
  1234.                   {
  1235.                      DrgFreeDraginfo ( pdinfo );
  1236.  
  1237.                      return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  1238.                   }
  1239.                   else if ( DrgVerifyRMF ( pditem, "DRM_PMSCRAPBOOK", "DRF_TODO" ) )
  1240.                   { 
  1241.                      DrgFreeDraginfo ( pdinfo );
  1242.                       
  1243.                      return ( MRFROM2SHORT ( DOR_DROP, DO_MOVE ) );
  1244.                       
  1245.                   }
  1246.                   else 
  1247.                   {
  1248.                      DrgFreeDraginfo ( pdinfo );
  1249.                       
  1250.                      return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  1251.                   }
  1252.                }
  1253.                 
  1254.                case CN_DROP:
  1255.                {
  1256.                   PCNRDRAGINFO  pcnrDri;
  1257.                   PDRAGINFO     pdinfo;
  1258.                   PDRAGITEM     pditem;
  1259.                   PTODOREC      pRecDrp;
  1260.                   PTODOREC      pRecAft;
  1261.                   RECORDINSERT  recins;
  1262.       
  1263.                   pcnrDri = PVOIDFROMMP ( mp2 );
  1264.                    
  1265.                   pdinfo = pcnrDri->pDragInfo;
  1266.                    
  1267.                   DrgAccessDraginfo ( pdinfo );
  1268.                    
  1269.                   pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  1270.                    
  1271.                   pRecDrp = (PTODOREC) pditem->ulItemID;
  1272.                   pRecAft = (PTODOREC) pcnrDri->pRecord;
  1273.                    
  1274.                   if ( ! pRecAft || pRecDrp == pRecAft )
  1275.                   {
  1276.                      DrgFreeDraginfo ( pdinfo );
  1277.                      break;
  1278.                   }
  1279.                    
  1280.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_REMOVERECORD,
  1281.                                MPFROMP ( &pRecDrp ),
  1282.                                MPFROM2SHORT( 1, 0 ) );//CMA_INVALIDATE ) );
  1283.                    
  1284.                   //*** Insert *************************************************
  1285.                    
  1286.                   recins.cb                = sizeof ( RECORDINSERT );
  1287.                   recins.pRecordParent     = NULL;
  1288.                   recins.pRecordOrder      = (PRECORDCORE) pRecAft;
  1289.                   recins.zOrder            = CMA_TOP;
  1290.                   recins.cRecordsInsert    = 1;
  1291.                   recins.fInvalidateRecord = TRUE;
  1292.                    
  1293.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  1294.                                MPFROMP( pRecDrp ), MPFROMP ( &recins ) );
  1295.                    
  1296.                   pRecScn->pdr->fbModified = TRUE;
  1297.                   //fbModified = TRUE;
  1298.                }
  1299.                break;
  1300.                 
  1301.                case CN_HELP:
  1302.                    
  1303.                   WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  1304.                                MPFROMSHORT ( HID_TODO ), MPFROMSHORT ( HM_RESOURCEID ) );
  1305.                    
  1306.                break;
  1307.                 
  1308.             }
  1309.             //break;
  1310.          }
  1311.           
  1312.       break;
  1313.        
  1314.       case UWM_SAVE:
  1315.       {
  1316.          CNRINFO   cnrinf;
  1317.          PDATREC   pdr;
  1318.  
  1319.          pdr = pRecScn->pdr;
  1320.           
  1321.          pdr->ulRelRev = REL_REV;
  1322.  
  1323.          pdr->ulDLen = pfnNodeScan  ( pdr->hwndE, SCB_SIZE, WID_TODO, pdr->pvDat );
  1324.           
  1325.          pdr->pvDat = realloc ( pdr->pvDat, pdr->ulDLen );
  1326.           
  1327.          pdr->ulDEnt = pfnNodeScan  ( pdr->hwndE, SCB_WRITE, WID_TODO, pdr->pvDat );
  1328.           
  1329.          pdr->fbModified = FALSE;
  1330.           
  1331.          //*** Set Completion States ****************************************
  1332.           
  1333.          pfnSetWhen ( &pRecScn->cdWri, &pRecScn->ctWri );
  1334.           
  1335.          pfnGetWinPos ( hwnd, pdr );
  1336.           
  1337.          //pdr->sPtSize = pfnFmToFat ( pdr->hwndE, &pdr->fat );
  1338.          //pfnGetDefFattrs ( pdr->hwndE, NULLHANDLE, &pdr->fat, &pdr->fxPtSz );
  1339.           
  1340.          pfnGetPresColors ( pdr->hwndE, &pdr->ulNBClr, &pdr->ulNFClr, &pdr->ulHBClr, &pdr->ulHFClr );
  1341.           
  1342.          WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  1343.                       MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  1344.           
  1345.          pdr->ulXVS = cnrinf.xVertSplitbar;
  1346.           
  1347.          fbModified = TRUE;
  1348.       }
  1349.       break;
  1350.        
  1351.       case UWM_SEARCH:
  1352.       {
  1353.          PTODOREC         pFoc;
  1354.          PDATREC          pdr;
  1355.          SEARCHSTRING     cnrsd;
  1356.  
  1357.          pdr = pRecScn->pdr;
  1358.           
  1359.          cnrsd.cb              = sizeof ( SEARCHSTRING );
  1360.          cnrsd.pszSearch       = pdr->psSrch->pszFnd;
  1361.          cnrsd.fsPrefix        = FALSE;
  1362.          cnrsd.fsCaseSensitive = ( pdr->psSrch->fbCase ) ? TRUE : FALSE;
  1363.          cnrsd.usView          = CV_DETAIL;
  1364.  
  1365.          pFoc = WinSendMsg ( pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  1366.                              MPFROMLONG ( CMA_FIRST ),
  1367.                              MPFROMSHORT( CRA_SELECTED ) );
  1368.           
  1369.          if ( ! pFoc )
  1370.          {
  1371.             pfnMsgOK ( hwnd, APP_TITLE, "Text not found." );
  1372.             break;
  1373.          }
  1374.  
  1375.          if ( pdr->psSrch->fbFirst )
  1376.          {
  1377.             if ( pFoc == pfnGetCnrRec ( pdr->hwndE, NULL ) )
  1378.                pFoc = (PTODOREC) CMA_FIRST;
  1379.             
  1380.             pdr->psSrch->fbFirst = FALSE;
  1381.          }
  1382.          
  1383.          pFoc = WinSendMsg ( pdr->hwndE, CM_SEARCHSTRING,
  1384.                              MPFROMP ( &cnrsd ), MPFROMP ( pFoc ) );
  1385.  
  1386.          if ( pFoc )
  1387.          {
  1388.             pfnCnrShowRec ( pdr->hwndE, pFoc, TRUE );
  1389.  
  1390.             if ( pFoc != pfnGetCnrRec ( pdr->hwndE, NULL ) )
  1391.                pdr->psSrch->fbFirst = TRUE;
  1392.          }
  1393.          else
  1394.          {
  1395.             pdr->psSrch->fbFirst = TRUE;
  1396.             pfnMsgOK ( hwnd, APP_TITLE, "Text not found." );
  1397.          }
  1398.       }
  1399.       break;
  1400.        
  1401.       case WM_CLOSE:
  1402.       {
  1403.          PDATREC   pdr;
  1404.  
  1405.          pdr = pRecScn->pdr;
  1406.           
  1407.          if ( pdr->fbModified ) 
  1408.          {
  1409.             if ( pfnMsgYesNo ( hwnd, APP_TITLE,
  1410.                                "This entry has been modified. Save changes ?" ) )
  1411.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  1412.          }
  1413.           
  1414.          pdr->ulOpts &= ~SCB_OPENED;
  1415.           
  1416.          pdr->hwndD   = 0;
  1417.          pfnHaveAKid ( pRecScn, FALSE );
  1418.           
  1419.          WinEnableWindowUpdate ( pdr->hwndE, FALSE );
  1420.  
  1421.          pfnNodeScan  ( pdr->hwndE, SCB_FREE, 
  1422.                         pRecScn->ulType, pRecScn->pdr->pvDat );
  1423.  
  1424.          free ( pdr->pdDate->pszTtl );
  1425.          free ( pdr->pdDate );
  1426.          free ( pdr->psSrch->pszFnd );
  1427.          free ( pdr->psSrch );
  1428.          free ( pdr->pszStat );
  1429.           
  1430.          WinSendMsg ( hwndC, CM_SETRECORDEMPHASIS,
  1431.                       MPFROMP ( pRecScn ),
  1432.                       MPFROM2SHORT ( FALSE, CRA_INUSE ) );
  1433.           
  1434.          WinDestroyWindow ( WinQueryWindow ( hwnd, QW_PARENT ) );
  1435.       }
  1436.       break;
  1437.        
  1438.       case WM_PRESPARAMCHANGED:
  1439.           
  1440.          pRecScn->pdr->fbModified = TRUE;
  1441.          //fbModified = TRUE;
  1442.           
  1443.       break;
  1444.        
  1445.       case WM_ERASEBACKGROUND:
  1446.           
  1447.       return ( MRESULT ) ( TRUE );
  1448.        
  1449.       default:
  1450.       return WinDefWindowProc ( hwnd, msg, mp1, mp2 );
  1451.        
  1452.    }
  1453.     
  1454.    return ( MRESULT ) FALSE;
  1455. }
  1456.  
  1457. /***************************************************************************/
  1458. /* To-Do Sort                                                              */
  1459. /***************************************************************************/
  1460. SHORT   APIENTRY pfnToDoSort  ( PRECORDCORE pRec1, PRECORDCORE pRec2, PVOID pv ) 
  1461. {
  1462.    PULONG    pulTyp;
  1463.    SHORT     sRet;
  1464.     
  1465.    PTODOREC  pToDo1;
  1466.    PTODOREC  pToDo2;
  1467.    PCDATE    pcdate1;
  1468.    PCDATE    pcdate2;
  1469.     
  1470.    pToDo1 = (PTODOREC) pRec1;
  1471.    pToDo2 = (PTODOREC) pRec2;
  1472.     
  1473.    pulTyp = (PULONG) pv;
  1474.     
  1475.    switch ( *pulTyp ) 
  1476.    {
  1477.       case MID_TODO_SORT_ED:
  1478.           
  1479.          pcdate1 = &pToDo1->cdEnt;
  1480.          pcdate2 = &pToDo2->cdEnt;
  1481.           
  1482.       break;
  1483.        
  1484.       case MID_TODO_SORT_TD:
  1485.           
  1486.          pcdate1 = &pToDo1->cdTrg;
  1487.          pcdate2 = &pToDo2->cdTrg;
  1488.           
  1489.       break;
  1490.        
  1491.       case MID_TODO_SORT_FD:
  1492.           
  1493.          pcdate1 = &pToDo1->cdFin;
  1494.          pcdate2 = &pToDo2->cdFin;
  1495.           
  1496.       break;
  1497.        
  1498.       case MID_TODO_SORT_TA:
  1499.           
  1500.          sRet = stricmp ( pToDo1->pszDo, pToDo2->pszDo );
  1501.           
  1502.          if ( sRet )
  1503.             return sRet;
  1504.           
  1505.          sRet = stricmp ( pToDo1->pszPr, pToDo2->pszPr );
  1506.           
  1507.          if ( sRet )
  1508.             return sRet;
  1509.           
  1510.          sRet = stricmp ( pToDo1->pszFn, pToDo2->pszFn );
  1511.           
  1512.          sRet *= (-1);
  1513.           
  1514.       return sRet;
  1515.        
  1516.       case MID_TODO_SORT_PR:
  1517.           
  1518.          sRet = stricmp ( pToDo1->pszPr, pToDo2->pszPr );
  1519.           
  1520.          if ( sRet )
  1521.             return sRet;
  1522.           
  1523.          sRet = stricmp ( pToDo1->pszFn, pToDo2->pszFn );
  1524.           
  1525.          if ( sRet )
  1526.             return ( sRet * (-1) );
  1527.           
  1528.          sRet = stricmp ( pToDo1->pszDo, pToDo2->pszDo );
  1529.           
  1530.          if ( sRet )
  1531.             return sRet;
  1532.           
  1533.       return sRet;
  1534.        
  1535.       case MID_TODO_SORT_DN:
  1536.           
  1537.          sRet = stricmp ( pToDo1->pszFn, pToDo2->pszFn );
  1538.           
  1539.          if ( sRet )
  1540.             return ( sRet * (-1) );
  1541.           
  1542.          sRet = stricmp ( pToDo1->pszPr, pToDo2->pszPr );
  1543.           
  1544.          if ( sRet )
  1545.             return sRet;
  1546.           
  1547.          sRet = stricmp ( pToDo1->pszDo, pToDo2->pszDo );
  1548.           
  1549.          if ( sRet )
  1550.             return sRet;
  1551.           
  1552.       return sRet;
  1553.        
  1554.    }
  1555.     
  1556.    if ( pcdate1->year < pcdate2->year )
  1557.       sRet = -1;
  1558.    else if ( pcdate1->year > pcdate2->year )
  1559.       sRet = 1;
  1560.    else if ( pcdate1->month < pcdate2->month )
  1561.       sRet = -1;
  1562.    else if ( pcdate1->month > pcdate2->month )
  1563.       sRet = 1;
  1564.    else if ( pcdate1->day < pcdate2->day )
  1565.       sRet = -1;
  1566.    else if ( pcdate1->day > pcdate2->day )
  1567.       sRet = 1;
  1568.    else 
  1569.       sRet = 0;
  1570.     
  1571.    return sRet;
  1572. }
  1573.  
  1574. /***************************************************************************/
  1575. /* To-Do Stat                                                              */
  1576. /***************************************************************************/
  1577. BOOL             pfnToDoStat  ( PUSEREC pRecScn ) 
  1578. {
  1579.    //CNRINFO               cnrinf;
  1580.     
  1581.    if ( pRecScn->pdr->ulDEnt ) 
  1582.       sprintf ( pRecScn->pdr->pszStat, "%d entries - %d (%d%%) complete",
  1583.                 pRecScn->pdr->ulDEnt,
  1584.                 pRecScn->pdr->ulCntr,
  1585.                 pRecScn->pdr->ulCntr * 100 / pRecScn->pdr->ulDEnt );
  1586.    else
  1587.       sprintf ( pRecScn->pdr->pszStat, "%d entries - %d (%d%%) complete",
  1588.                 pRecScn->pdr->ulDEnt,
  1589.                 pRecScn->pdr->ulCntr,
  1590.                 0 );
  1591.     
  1592.    pfnCnrTitle ( pRecScn->pdr->hwndE, pRecScn->pdr->pszStat );
  1593.  
  1594.    //cnrinf.pszCnrTitle  = pRecScn->pdr->pszStat;
  1595.     
  1596.    //WinSendMsg ( pRecScn->pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  1597.      //           MPFROMLONG ( CMA_CNRTITLE ) );
  1598.     
  1599.    return TRUE;
  1600. }
  1601.  
  1602. /***************************************************************************/
  1603. /* Create To-Do Container                                                  */
  1604. /***************************************************************************/
  1605. VOID             pfnToDoCont  ( HWND hwnd, PUSEREC pRecScn )
  1606. {
  1607.    PDATREC           pdr;
  1608.    CNRINFO           cnrinf;
  1609.    MRESULT           mr;
  1610.    SWP               swp;
  1611.     
  1612.    pdr = pRecScn->pdr;
  1613.  
  1614.    pdr->hwndE = WinCreateWindow ( hwnd, WC_CONTAINER, NULL,
  1615.                                   CCS_SINGLESEL,
  1616.                                   0,0,0,0, hwnd, HWND_TOP,
  1617.                                   WID_CONT, NULL, NULL );
  1618.     
  1619.    WinSetWindowPtr ( pdr->hwndE, 0, pRecScn );
  1620.     
  1621.    cnrinf.pszCnrTitle  = pdr->pszStat;
  1622.    //cnrinf.flWindowAttr = CV_DETAIL | CA_DETAILSVIEWTITLES | CA_OWNERDRAW | CA_ORDEREDTARGETEMPH;
  1623.    cnrinf.flWindowAttr = CV_DETAIL | CA_DETAILSVIEWTITLES | CA_ORDEREDTARGETEMPH;
  1624.     
  1625.    if ( ulToDoOpts & SCB_STATED )
  1626.       cnrinf.flWindowAttr |= CA_CONTAINERTITLE | CA_TITLESEPARATOR | CA_TITLEREADONLY;
  1627.     
  1628.    WinSendMsg ( pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  1629.                 MPFROMLONG ( CMA_FLWINDOWATTR ) );
  1630.     
  1631.    pfnSetPPFont ( pdr->hwndE, pdr->fxPtSz, &pdr->fat );
  1632.     
  1633.    pfnSetPresColors ( pdr->hwndE, pdr->ulNBClr, pdr->ulNFClr, pdr->ulHBClr, pdr->ulHFClr );
  1634.     
  1635.    WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  1636.                 MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  1637.     
  1638.    //*** Allocate & Init Field Info ***********************************
  1639.     
  1640.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoEntr, CFA_CENTER | CFA_FITITLEREADONLY,
  1641.                        CFA_DATE | CFA_TOP | CFA_RIGHT |
  1642.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1643.                        FIELDOFFSET ( TODOREC, cdEnt ) );
  1644.          
  1645.    pdr->colInfo[TODO_ENTR].pfinf            = PVOIDFROMMR ( mr );
  1646.    pdr->colInfo[TODO_ENTR].fbVisible        = TRUE;
  1647.    pdr->colInfo[TODO_ENTR].ulShowMask       = TODO_STY_SHOWENTR;
  1648.    pdr->colInfo[TODO_ENTR].pfinf->pUserData = &usLeftDvWnd;
  1649.  
  1650.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoTarg, CFA_CENTER | CFA_FITITLEREADONLY,
  1651.                        CFA_DATE | CFA_TOP | CFA_RIGHT |
  1652.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1653.                        FIELDOFFSET ( TODOREC, cdTrg ) );
  1654.          
  1655.    pdr->colInfo[TODO_TARG].pfinf            = PVOIDFROMMR ( mr );
  1656.    pdr->colInfo[TODO_TARG].fbVisible        = TRUE;
  1657.    pdr->colInfo[TODO_TARG].ulShowMask       = TODO_STY_SHOWTARG;
  1658.    pdr->colInfo[TODO_TARG].pfinf->pUserData = &usLeftDvWnd;
  1659.  
  1660.     
  1661.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoDone, CFA_CENTER | CFA_FITITLEREADONLY,
  1662.                        CFA_DATE | CFA_TOP | CFA_RIGHT |
  1663.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1664.                        FIELDOFFSET ( TODOREC, cdFin ) );
  1665.          
  1666.    pdr->colInfo[TODO_DONE].pfinf            = PVOIDFROMMR ( mr );
  1667.    pdr->colInfo[TODO_DONE].fbVisible        = TRUE;
  1668.    pdr->colInfo[TODO_DONE].ulShowMask       = TODO_STY_SHOWDONE;
  1669.    pdr->colInfo[TODO_DONE].pfinf->pUserData = &usLeftDvWnd;
  1670.  
  1671.     
  1672.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoPrio, CFA_CENTER | CFA_FITITLEREADONLY,
  1673.                        CFA_STRING | CFA_TOP | CFA_CENTER |
  1674.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1675.                        FIELDOFFSET ( TODOREC, pszPr ) );
  1676.          
  1677.    pdr->colInfo[TODO_PRIO].pfinf            = PVOIDFROMMR ( mr );
  1678.    pdr->colInfo[TODO_PRIO].fbVisible        = TRUE;
  1679.    pdr->colInfo[TODO_PRIO].ulShowMask       = TODO_STY_SHOWPRIO;
  1680.    pdr->colInfo[TODO_PRIO].pfinf->pUserData = &usRightDvWnd;
  1681.  
  1682.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoIDid, CFA_CENTER | CFA_FITITLEREADONLY,
  1683.                        CFA_STRING | CFA_TOP | CFA_CENTER |
  1684.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1685.                        FIELDOFFSET ( TODOREC, pszFn ) );
  1686.          
  1687.    pdr->colInfo[TODO_CHEK].pfinf            = PVOIDFROMMR ( mr );
  1688.    pdr->colInfo[TODO_CHEK].fbVisible        = TRUE;
  1689.    pdr->colInfo[TODO_CHEK].ulShowMask       = TODO_STY_SHOWCHEK;
  1690.    pdr->colInfo[TODO_CHEK].pfinf->pUserData = &usRightDvWnd;
  1691.  
  1692.     
  1693.    mr = pfnAddCnrCol ( pdr->hwndE, colStrs.pszToDoTask, CFA_CENTER | CFA_FITITLEREADONLY,
  1694.                        CFA_STRING | CFA_TOP | CFA_LEFT |
  1695.                        CFA_SEPARATOR | CFA_HORZSEPARATOR,
  1696.                        FIELDOFFSET ( TODOREC, pszDo ) );
  1697.          
  1698.    pdr->colInfo[TODO_TASK].pfinf            = PVOIDFROMMR ( mr );
  1699.    pdr->colInfo[TODO_TASK].fbVisible        = TRUE;
  1700.    pdr->colInfo[TODO_TASK].ulShowMask       = TODO_STY_SHOWTASK;
  1701.    pdr->colInfo[TODO_TASK].pfinf->pUserData = &usRightDvWnd;
  1702.  
  1703.    //*** Hide Hidden Columns ******************************************
  1704.  
  1705.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWENTR ) )
  1706.    {
  1707.       pdr->colInfo[TODO_ENTR].fbVisible = FALSE;
  1708.  
  1709.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1710.                    MPFROMP ( &pdr->colInfo[TODO_ENTR].pfinf ),
  1711.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1712.    }
  1713.  
  1714.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWTARG ) )
  1715.    {
  1716.       pdr->colInfo[TODO_TARG].fbVisible = FALSE;
  1717.  
  1718.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1719.                    MPFROMP ( &pdr->colInfo[TODO_TARG].pfinf ),
  1720.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1721.    }
  1722.  
  1723.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWDONE ) )
  1724.    {
  1725.       pdr->colInfo[TODO_DONE].fbVisible = FALSE;
  1726.  
  1727.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1728.                    MPFROMP ( &pdr->colInfo[TODO_DONE].pfinf ),
  1729.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1730.    }
  1731.  
  1732.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWPRIO ) )
  1733.    {
  1734.       pdr->colInfo[TODO_PRIO].fbVisible = FALSE;
  1735.  
  1736.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1737.                    MPFROMP ( &pdr->colInfo[TODO_PRIO].pfinf ),
  1738.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1739.    }
  1740.  
  1741.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWCHEK ) )
  1742.    {
  1743.       pdr->colInfo[TODO_CHEK].fbVisible = FALSE;
  1744.  
  1745.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1746.                    MPFROMP ( &pdr->colInfo[TODO_CHEK].pfinf ),
  1747.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1748.    }
  1749.  
  1750.    if ( ! ( pdr->ulStyl & TODO_STY_SHOWTASK ) )
  1751.    {
  1752.       pdr->colInfo[TODO_TASK].fbVisible = FALSE;
  1753.  
  1754.       WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1755.                    MPFROMP ( &pdr->colInfo[TODO_TASK].pfinf ),
  1756.                    MPFROM2SHORT ( 1, 0 ) );//CMA_INVALIDATE ) );
  1757.    }
  1758.  
  1759.    //*** Position Container *******************************************
  1760.     
  1761.    WinQueryWindowPos ( hwnd, &swp );
  1762.     
  1763.    WinSetWindowPos ( pdr->hwndE, HWND_TOP,
  1764.                      0, 0,
  1765.                      swp.cx,
  1766.                      swp.cy,
  1767.                      SWP_SIZE | SWP_MOVE | SWP_SHOW );
  1768.     
  1769.    WinSetFocus ( HWND_DESKTOP, pdr->hwndE );
  1770.     
  1771.    //*** Set up Splitbar **********************************************
  1772.     
  1773.    if ( ! pdr->ulDLen ) 
  1774.       pdr->ulXVS = swp.cx / 4 * 3;
  1775.     
  1776.    pfnCnrSplit ( pdr->hwndE,
  1777.                  pdr->colInfo[TODO_DONE].pfinf,
  1778.                  pdr->ulXVS );
  1779. }
  1780.  
  1781. //****************************************************************************
  1782. // Init Menu
  1783. //****************************************************************************
  1784. VOID             pfnToDoMenu  ( PUSEREC pRecScn, HWND hwndMenu, SHORT sMID )
  1785. {
  1786.    PTODOREC   pFoc;
  1787.  
  1788.    switch ( sMID )
  1789.    {
  1790.       case MID_TODO_FILE:
  1791.          if ( pqi.pDriverData )
  1792.             WinEnableMenuItem ( hwndMenu, MID_TODO_PRINT, TRUE  );
  1793.          else
  1794.             WinEnableMenuItem ( hwndMenu, MID_TODO_PRINT, FALSE );
  1795.       break;
  1796.           
  1797.       case MID_TODO_EDIT:
  1798.           
  1799.          if (  pfnIsMyClip ( hwndMenu, atomToDo ) )
  1800.             WinEnableMenuItem ( hwndMenu, MID_TODO_PASTE, TRUE );
  1801.          else
  1802.             WinEnableMenuItem ( hwndMenu, MID_TODO_PASTE, FALSE );
  1803.           
  1804.          pFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  1805.                              MPFROMLONG ( CMA_FIRST ),
  1806.                              MPFROMSHORT( CRA_SELECTED ) );
  1807.           
  1808.          if (  pFoc ) 
  1809.          {
  1810.             WinEnableMenuItem ( hwndMenu, MID_TODO_CUT,  TRUE );
  1811.             WinEnableMenuItem ( hwndMenu, MID_TODO_COPY, TRUE );
  1812.             WinEnableMenuItem ( hwndMenu, MID_TODO_DELT, TRUE );
  1813.             WinEnableMenuItem ( hwndMenu, MID_TODO_ENTD, TRUE );
  1814.             WinEnableMenuItem ( hwndMenu, MID_TODO_TRGD, TRUE );
  1815.             WinEnableMenuItem ( hwndMenu, MID_TODO_DUND, TRUE );
  1816.             WinEnableMenuItem ( hwndMenu, MID_TODO_TASK, TRUE );
  1817.             WinEnableMenuItem ( hwndMenu, MID_TODO_PRIO, TRUE );
  1818.          }
  1819.          else 
  1820.          {
  1821.             WinEnableMenuItem ( hwndMenu, MID_TODO_CUT,  FALSE );
  1822.             WinEnableMenuItem ( hwndMenu, MID_TODO_COPY, FALSE );
  1823.             WinEnableMenuItem ( hwndMenu, MID_TODO_DELT, FALSE );
  1824.             WinEnableMenuItem ( hwndMenu, MID_TODO_ENTD, FALSE );
  1825.             WinEnableMenuItem ( hwndMenu, MID_TODO_TRGD, FALSE );
  1826.             WinEnableMenuItem ( hwndMenu, MID_TODO_DUND, FALSE );
  1827.             WinEnableMenuItem ( hwndMenu, MID_TODO_TASK, FALSE );
  1828.             WinEnableMenuItem ( hwndMenu, MID_TODO_PRIO, FALSE );
  1829.          }
  1830.           
  1831.          if ( pRecScn->pdr->psSrch->hwndS  || ! pFoc )
  1832.             WinEnableMenuItem ( hwndMenu, MID_TODO_FIND, FALSE );
  1833.          else 
  1834.             WinEnableMenuItem ( hwndMenu, MID_TODO_FIND, TRUE  );
  1835.           
  1836.          if ( *pRecScn->pdr->psSrch->pszFnd && pFoc )
  1837.             WinEnableMenuItem ( hwndMenu, MID_TODO_FNDNXT, TRUE );
  1838.          else 
  1839.             WinEnableMenuItem ( hwndMenu, MID_TODO_FNDNXT, FALSE );
  1840.       break;
  1841.    }
  1842. }
  1843.  
  1844. //****************************************************************************
  1845. // Print Thread
  1846. //****************************************************************************
  1847. VOID             pfnToDoPrtThd       ( PVOID pv )
  1848. {
  1849.    HMQ         hmq;
  1850.    PDATREC     pdr;
  1851.    PTODOREC    pPrt;
  1852.    ULONG       ulPrinted = 0;
  1853.    LONG        lCharsOut;
  1854.    LONG        lCharsLeft = 1;
  1855.    LONG        lNewBottom;
  1856.    LONG        lLowBottom;
  1857.    BOOL        fbCausePage = FALSE;
  1858.    FONTMETRICS fm;
  1859.    RECTL       rclText;
  1860.    POINTL      pt;
  1861.    SHORT       sColsDone;
  1862.    SHORT       sCurCol;
  1863.    SHORT       sX;
  1864.    CHAR        ach32[32];
  1865.  
  1866.    hmq = WinCreateMsgQueue ( WinQueryAnchorBlock ( hwndM ), 0 );
  1867.  
  1868.    pdr = pprtCtl->pPrtRec->pdr;
  1869.  
  1870.    ++pprtCtl->ulPrtPage;
  1871.  
  1872.    pdr->ulPrtPage = pprtCtl->ulPrtPage;
  1873.  
  1874.    pfnToDoPrintInit ();
  1875.  
  1876.    fm = pprtCtl->fmAll;
  1877.  
  1878.    //*** Print Entry ********************************************************
  1879.  
  1880.    rclText.yBottom = pprtCtl->rclBody.yBottom;
  1881.    rclText.yTop    = rclText.yBottom;
  1882.  
  1883.    sColsDone = pprtCtl->sVisCols;
  1884.  
  1885.    for ( sX = 0; sX < pprtCtl->sVisCols; ++sX )
  1886.    {
  1887.       pprtCtl->abfinf[sX]   = TRUE;
  1888.       pprtCtl->apszfinf[sX] = NULL;
  1889.    }
  1890.  
  1891.    pPrt = pfnGetCnrRec ( pdr->hwndE, NULL );
  1892.     
  1893.    while ( pPrt && fbPrinting )
  1894.    {
  1895.       if ( rclText.yTop - fm.lMaxBaselineExt < rclText.yBottom )
  1896.       {
  1897.          pfnToDoNewPage ( fbCausePage );
  1898.  
  1899.          fbCausePage = TRUE;
  1900.          rclText.yTop = pprtCtl->arclfinf[0].yBottom - fm.lMaxDescender;
  1901.          lLowBottom   = rclText.yTop;
  1902.          lNewBottom   = lLowBottom;
  1903.       }
  1904.  
  1905.       sCurCol = 0;
  1906.  
  1907.       //*** Print Entry Date ************************************************
  1908.  
  1909.       if ( pdr->ulStyl & TODO_STY_SHOWENTR )
  1910.       {
  1911.          if ( pprtCtl->abfinf[sCurCol] )
  1912.          {
  1913.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  1914.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  1915.  
  1916.             pfnNLSDate ( &ci, ach32,
  1917.                          pPrt->cdEnt.year,
  1918.                          pPrt->cdEnt.month, pPrt->cdEnt.day );
  1919.  
  1920.             pfnPaintText ( pprtCtl->hpsPrinter, ach32, 
  1921.                            &rclText, &pprtCtl->fmAll,
  1922.                            DT_RIGHT | DT_TOP, TRUE, FALSE );
  1923.  
  1924.             --sColsDone;
  1925.             pprtCtl->abfinf[sCurCol] = FALSE;
  1926.  
  1927.             if ( lNewBottom && lLowBottom > lNewBottom )
  1928.                lLowBottom = lNewBottom;
  1929.          }
  1930.  
  1931.          ++sCurCol;
  1932.       }
  1933.       //*** Print Target Date ***********************************************
  1934.  
  1935.       if ( pdr->ulStyl & TODO_STY_SHOWTARG )
  1936.       {
  1937.          if ( pprtCtl->abfinf[sCurCol] )
  1938.          {
  1939.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  1940.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  1941.  
  1942.             pfnNLSDate ( &ci, ach32,
  1943.                          pPrt->cdTrg.year,
  1944.                          pPrt->cdTrg.month, pPrt->cdTrg.day );
  1945.  
  1946.             pfnPaintText ( pprtCtl->hpsPrinter, ach32, 
  1947.                            &rclText, &pprtCtl->fmAll,
  1948.                            DT_RIGHT | DT_TOP, TRUE, FALSE );
  1949.  
  1950.             --sColsDone;
  1951.             pprtCtl->abfinf[sCurCol] = FALSE;
  1952.  
  1953.             if ( lLowBottom > lNewBottom )
  1954.                lLowBottom = lNewBottom;
  1955.          }
  1956.  
  1957.          ++sCurCol;
  1958.       }
  1959.       //*** Print Completion Date *******************************************
  1960.  
  1961.       if ( pdr->ulStyl & TODO_STY_SHOWDONE )
  1962.       {
  1963.          if ( pprtCtl->abfinf[sCurCol] )
  1964.          {
  1965.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  1966.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  1967.  
  1968.             pfnNLSDate ( &ci, ach32,
  1969.                          pPrt->cdFin.year,
  1970.                          pPrt->cdFin.month, pPrt->cdFin.day );
  1971.  
  1972.             pfnPaintText ( pprtCtl->hpsPrinter, ach32, 
  1973.                            &rclText, &pprtCtl->fmAll,
  1974.                            DT_RIGHT | DT_TOP, TRUE, FALSE );
  1975.  
  1976.             --sColsDone;
  1977.             pprtCtl->abfinf[sCurCol] = FALSE;
  1978.  
  1979.             if ( lLowBottom > lNewBottom )
  1980.                lLowBottom = lNewBottom;
  1981.          }
  1982.  
  1983.          ++sCurCol;
  1984.       }
  1985.       //*** Print Priority **************************************************
  1986.  
  1987.       if ( pdr->ulStyl & TODO_STY_SHOWPRIO )
  1988.       {
  1989.          if ( pprtCtl->abfinf[sCurCol] )
  1990.          {
  1991.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  1992.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  1993.  
  1994.             if ( ! pprtCtl->apszfinf[sCurCol] )
  1995.                pprtCtl->apszfinf[sCurCol] = pPrt->pszPr;
  1996.  
  1997.             pfnPaintText ( pprtCtl->hpsPrinter, pprtCtl->apszfinf[sCurCol], 
  1998.                            &rclText, &pprtCtl->fmAll,
  1999.                            DT_CENTER | DT_TOP, TRUE, FALSE );
  2000.  
  2001.             /*lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter,
  2002.                                            pprtCtl->apszfinf[sCurCol],
  2003.                                            &rclText, &pprtCtl->fmAll,
  2004.                                            &lNewBottom, &lCharsLeft, 
  2005.                                            DT_CENTER | DT_VCENTER,
  2006.                                            TRUE, FALSE, FALSE );
  2007.       
  2008.             if ( lCharsLeft )
  2009.                pprtCtl->apszfinf[sCurCol] += lCharsOut;
  2010.             else*/
  2011.             {
  2012.                --sColsDone;
  2013.                pprtCtl->abfinf[sCurCol] = FALSE;
  2014.             }
  2015.  
  2016.             if ( lLowBottom > lNewBottom )
  2017.                lLowBottom = lNewBottom;
  2018.          }
  2019.  
  2020.          ++sCurCol;
  2021.       }
  2022.       //*** Print Completion Flag *******************************************
  2023.  
  2024.       if ( pdr->ulStyl & TODO_STY_SHOWCHEK )
  2025.       {
  2026.          if ( pprtCtl->abfinf[sCurCol] )
  2027.          {
  2028.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  2029.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  2030.  
  2031.             if ( ! pprtCtl->apszfinf[sCurCol] )
  2032.                pprtCtl->apszfinf[sCurCol] = pPrt->pszFn;
  2033.  
  2034.             pfnPaintText ( pprtCtl->hpsPrinter, pprtCtl->apszfinf[sCurCol], 
  2035.                            &rclText, &pprtCtl->fmAll,
  2036.                            DT_CENTER | DT_TOP, TRUE, FALSE );
  2037.  
  2038.             /*lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter,
  2039.                                            pprtCtl->apszfinf[sCurCol],
  2040.                                            &rclText, &pprtCtl->fmAll,
  2041.                                            &lNewBottom, &lCharsLeft, 
  2042.                                            DT_CENTER | DT_VCENTER,
  2043.                                            TRUE, FALSE, FALSE );
  2044.       
  2045.             if ( lCharsLeft )
  2046.                pprtCtl->apszfinf[sCurCol] += lCharsOut;
  2047.             else*/
  2048.             {
  2049.                --sColsDone;
  2050.                pprtCtl->abfinf[sCurCol] = FALSE;
  2051.             }
  2052.  
  2053.             if ( lLowBottom > lNewBottom )
  2054.                lLowBottom = lNewBottom;
  2055.          }
  2056.  
  2057.          ++sCurCol;
  2058.       }
  2059.       //*** Print Task ******************************************************
  2060.  
  2061.       if ( pdr->ulStyl & TODO_STY_SHOWTASK )
  2062.       {
  2063.          if ( pprtCtl->abfinf[sCurCol] )
  2064.          {
  2065.             rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  2066.             rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  2067.  
  2068.             if ( ! pprtCtl->apszfinf[sCurCol] )
  2069.                pprtCtl->apszfinf[sCurCol] = pPrt->pszDo;
  2070.  
  2071.             lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter,
  2072.                                            pprtCtl->apszfinf[sCurCol],
  2073.                                            &rclText, &pprtCtl->fmAll,
  2074.                                            &lNewBottom, &lCharsLeft, 
  2075.                                            DT_LEFT | DT_VCENTER,
  2076.                                            TRUE, FALSE, TRUE );
  2077.       
  2078.             if ( lCharsLeft && lCharsOut )
  2079.                pprtCtl->apszfinf[sCurCol] += lCharsOut;
  2080.             else
  2081.             {
  2082.                --sColsDone;
  2083.                pprtCtl->abfinf[sCurCol] = FALSE;
  2084.             }
  2085.  
  2086.             if ( lLowBottom > lNewBottom )
  2087.                lLowBottom = lNewBottom;
  2088.          }
  2089.  
  2090.          ++sCurCol;
  2091.       }
  2092.  
  2093.       //*** End of Record Processing ****************************************
  2094.  
  2095.       rclText.yTop  = lLowBottom;
  2096.       rclText.yTop -= fm.lMaxDescender;
  2097.  
  2098.       if ( ! sColsDone )
  2099.       {
  2100.          if ( rclText.yTop - ( fm.lMaxBaselineExt + fm.lMaxDescender ) > 
  2101.               rclText.yBottom )
  2102.          {
  2103.             pt.y = rclText.yTop;
  2104.             pt.x = pprtCtl->rclPage.xLeft;
  2105.    
  2106.             GpiMove ( pprtCtl->hpsPrinter, &pt );
  2107.    
  2108.             pt.x = pprtCtl->rclPage.xRight;
  2109.    
  2110.             GpiLine ( pprtCtl->hpsPrinter, &pt );
  2111.          }
  2112.  
  2113.          rclText.yTop -= fm.lMaxDescender;
  2114.  
  2115.          sColsDone = pprtCtl->sVisCols;
  2116.       
  2117.          for ( sX = 0; sX < pprtCtl->sVisCols; ++sX )
  2118.          {
  2119.             pprtCtl->abfinf[sX]   = TRUE;
  2120.             pprtCtl->apszfinf[sX] = NULL;
  2121.          }
  2122.       
  2123.          WinPostMsg ( pprtCtl->hwndPrtDlg, UWM_STAT, 
  2124.                       MPFROMLONG ( ++ulPrinted ),
  2125.                       MPFROMLONG ( pdr->ulDEnt ) );
  2126.  
  2127.          pPrt = pfnGetCnrRec ( pdr->hwndE, pPrt );
  2128.       }
  2129.    }
  2130.    //*** Clear Out **********************************************************
  2131.  
  2132.    /*if ( pbBuf )
  2133.       free ( pbBuf );*/
  2134.  
  2135.    if ( fbPrinting )
  2136.       WinPostMsg ( pprtCtl->hwndPrtDlg, UWM_DONE, NULL, NULL );
  2137.  
  2138.    WinDestroyMsgQueue ( hmq );
  2139.  
  2140.    DosPostEventSem ( evtThdDone );
  2141.  
  2142.    //DosExit ( EXIT_THREAD, 0 );
  2143.    _endthread();
  2144. }
  2145.  
  2146. //****************************************************************************
  2147. // Print New Page
  2148. //****************************************************************************
  2149. VOID             pfnToDoNewPage      ( BOOL fbCausePage )
  2150. {
  2151.    PDATREC     pdr;
  2152.    LONG        lCharsOut;
  2153.    LONG        lCharsLeft;
  2154.    LONG        lNewBottom;
  2155.    SHORT       sX;
  2156.    CHAR        ach32[32];
  2157.    POINTL      pt;
  2158.  
  2159.    pdr = pprtCtl->pPrtRec->pdr;
  2160.  
  2161.    lNewBottom = pprtCtl->rclPage.yTop;
  2162.  
  2163.    //*** Print Heading ***************************************************
  2164.  
  2165.    if ( fbCausePage )
  2166.    {
  2167.       pfnPrintPageEject ( pdr->hwndD, pprtCtl->hpsPrinter );
  2168.  
  2169.       ++pprtCtl->ulPrtPage;
  2170.    }
  2171.  
  2172.    else if ( ulTreeOpts & SCB_PRTHEAD )
  2173.    {
  2174.       pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  2175.                         &pprtCtl->defPrtHed.fat, FONTID_HED );
  2176.  
  2177.       lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter, 
  2178.                                      pprtCtl->pPrtRec->crecCore.pszTree,
  2179.                                      &pprtCtl->rclPage, &pprtCtl->fmHed,
  2180.                                      &lNewBottom, &lCharsLeft, 
  2181.                                      DT_LEFT | DT_VCENTER,
  2182.                                      FALSE, FALSE, FALSE );
  2183.    
  2184.    }
  2185.  
  2186.    //*** Adjust to Printed Heading Height First Time Through *************
  2187.  
  2188.    if ( ! fbCausePage )
  2189.    {
  2190.       pprtCtl->rclBody.yTop = lNewBottom - pprtCtl->fmAll.lMaxBaselineExt;
  2191.  
  2192.       for ( sX = 0; sX < pprtCtl->sVisCols; ++sX )
  2193.       {
  2194.          pprtCtl->arclfinf[sX].yTop    = pprtCtl->rclBody.yTop;
  2195.          pprtCtl->arclfinf[sX].yBottom = pprtCtl->rclBody.yTop -
  2196.                                         ( pprtCtl->fmAll.lMaxBaselineExt * pprtCtl->lHedLines );
  2197.       }
  2198.    }
  2199.  
  2200.    //*** Print Page Number ***********************************************
  2201.  
  2202.    if ( ulTreeOpts & SCB_PRTPAGE )
  2203.    {
  2204.       pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  2205.                         &pprtCtl->defPrtCnt.fat, FONTID_CNT );
  2206.  
  2207.  
  2208.       sprintf ( ach32, "-  %d  -", pprtCtl->ulPrtPage );
  2209.    
  2210.       pfnPaintText ( pprtCtl->hpsPrinter, ach32, 
  2211.                      &pprtCtl->rclFoot, &pprtCtl->fmCnt,
  2212.                      DT_CENTER | DT_BOTTOM, FALSE, FALSE );
  2213.    }
  2214.  
  2215.    //*** Print Column Headings *******************************************
  2216.  
  2217.    pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  2218.                      &pprtCtl->defPrtAll.fat, FONTID_ALL );
  2219.  
  2220.    pfnPaintBox ( pprtCtl->hpsPrinter, &pprtCtl->rclBody );
  2221.  
  2222.    lCharsOut = pprtCtl->fmAll.lMaxBaselineExt / 2;
  2223.  
  2224.    for ( sX = 0; sX < pprtCtl->sVisCols; ++sX )
  2225.    {
  2226.       pprtCtl->arclfinf[sX].yTop -= lCharsOut;
  2227.  
  2228.       pfnPaintTextRect ( pprtCtl->hpsPrinter,
  2229.                          (PSZ)pdr->colInfo[pprtCtl->alIds[sX]].pfinf->pTitleData,
  2230.                          &pprtCtl->arclfinf[sX], 
  2231.                          &pprtCtl->fmAll,
  2232.                          &lNewBottom, &lCharsLeft, 
  2233.                          DT_CENTER | DT_VCENTER,
  2234.                          FALSE, FALSE, FALSE );
  2235.  
  2236.       pprtCtl->arclfinf[sX].yTop += lCharsOut;
  2237.  
  2238.       pt.x = pprtCtl->arclfinf[sX].xLeft;
  2239.       pt.y = pprtCtl->rclBody.yTop;
  2240.  
  2241.       GpiMove ( pprtCtl->hpsPrinter, &pt );
  2242.  
  2243.       pt.y = pprtCtl->rclBody.yBottom;
  2244.  
  2245.       GpiLine ( pprtCtl->hpsPrinter, &pt );
  2246.    }
  2247.  
  2248.    pt.x = pprtCtl->rclPage.xLeft;
  2249.    pt.y = pprtCtl->arclfinf[0].yBottom;
  2250.  
  2251.    GpiMove ( pprtCtl->hpsPrinter, &pt );
  2252.  
  2253.    pt.x = pprtCtl->rclPage.xRight;
  2254.  
  2255.    GpiLine ( pprtCtl->hpsPrinter, &pt );
  2256.  
  2257. }
  2258.  
  2259. //****************************************************************************
  2260. // Print Initialization
  2261. //****************************************************************************
  2262. VOID             pfnToDoPrintInit    (  )
  2263. {
  2264.    PDATREC     pdr;
  2265.    SHORT       sVisCols;
  2266.    LONG        lLeft;
  2267.    SHORT       sX;
  2268.    LONG        lDateLen;
  2269.    LONG        lCharLen;
  2270.    LONG        lUsedPels;
  2271.    LONG        colLines;
  2272.    PSZ         psz;
  2273.  
  2274.    pdr = pprtCtl->pPrtRec->pdr;
  2275.  
  2276.    //*** Set Entry Font *****************************************************
  2277.  
  2278.    if ( pprtCtl->fbNewFont )
  2279.    {
  2280.       pdr->fxPtSzPrt = pprtCtl->defPrtAll.fxPtSz;
  2281.       pdr->fatPrt    = pprtCtl->defPrtAll.fat;
  2282.    }
  2283.  
  2284.    if ( pdr->fxPtSzPrt )
  2285.    {
  2286.       pprtCtl->defPrtAll.fxPtSz = pdr->fxPtSzPrt;
  2287.       pprtCtl->defPrtAll.fat    = pdr->fatPrt;
  2288.    }
  2289.  
  2290.    pfnCvtVecFont     ( pprtCtl->hpsPrinter, 
  2291.                        pprtCtl->defPrtAll.fxPtSz,
  2292.                        &pprtCtl->defPrtAll.fat );
  2293.  
  2294.    pfnSetPaintFont   ( pdr->hwndD, pprtCtl->hpsPrinter, 
  2295.                        &pprtCtl->defPrtAll.fat, FONTID_ALL );
  2296.  
  2297.    GpiQueryFontMetrics ( pprtCtl->hpsPrinter, sizeof ( FONTMETRICS ), 
  2298.                          &pprtCtl->fmAll );
  2299.  
  2300.    //*** Column Setup *******************************************************
  2301.  
  2302.    lDateLen  = pfnStrPelLen ( pprtCtl->hpsPrinter, "55-55-5555" );
  2303.    lDateLen += ( pprtCtl->fmAll.lAveCharWidth * 2 );
  2304.  
  2305.    lCharLen  = pfnStrPelLen ( pprtCtl->hpsPrinter, "X" );
  2306.    lCharLen += ( pprtCtl->fmAll.lAveCharWidth * 2 );
  2307.  
  2308.    lUsedPels = 0;
  2309.  
  2310.    sVisCols = 0;
  2311.  
  2312.    if ( pdr->hwndD )
  2313.    {
  2314.       if ( pdr->ulStyl & TODO_STY_SHOWENTR )
  2315.       {
  2316.          pprtCtl->alfinf[sVisCols] = lDateLen; /*pfnCnrColPels ( pdr->hwndE,
  2317.                                                      pdr->colInfo[TODO_ENTR].pfinf );
  2318.    
  2319.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2320.    
  2321.          lUsedPels += pprtCtl->alfinf[sVisCols];
  2322.  
  2323.          pprtCtl->alIds[sVisCols]   = TODO_ENTR;
  2324.    
  2325.          ++sVisCols;
  2326.       }
  2327.       if ( pdr->ulStyl & TODO_STY_SHOWTARG )
  2328.       {
  2329.          pprtCtl->alfinf[sVisCols] = lDateLen; /*pfnCnrColPels ( pdr->hwndE,
  2330.                                                      pdr->colInfo[TODO_TARG].pfinf );
  2331.    
  2332.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2333.    
  2334.          lUsedPels += pprtCtl->alfinf[sVisCols];
  2335.  
  2336.          pprtCtl->alIds[sVisCols]   = TODO_TARG;
  2337.    
  2338.          ++sVisCols;
  2339.       }
  2340.       if ( pdr->ulStyl & TODO_STY_SHOWDONE )
  2341.       {
  2342.          pprtCtl->alfinf[sVisCols] = lDateLen; /*pfnCnrColPels ( pdr->hwndE,
  2343.                                                      pdr->colInfo[TODO_DONE].pfinf );
  2344.    
  2345.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2346.    
  2347.          lUsedPels += pprtCtl->alfinf[sVisCols];
  2348.  
  2349.          pprtCtl->alIds[sVisCols]   = TODO_DONE;
  2350.    
  2351.          ++sVisCols;
  2352.       }
  2353.       if ( pdr->ulStyl & TODO_STY_SHOWPRIO )
  2354.       {
  2355.          pprtCtl->alfinf[sVisCols] = lCharLen; /*pfnCnrColPels ( pdr->hwndE,
  2356.                                                      pdr->colInfo[TODO_PRIO].pfinf );
  2357.    
  2358.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2359.    
  2360.          lUsedPels += pprtCtl->alfinf[sVisCols];
  2361.  
  2362.          pprtCtl->alIds[sVisCols]   = TODO_PRIO;
  2363.    
  2364.          ++sVisCols;
  2365.       }
  2366.       if ( pdr->ulStyl & TODO_STY_SHOWCHEK )
  2367.       {
  2368.          pprtCtl->alfinf[sVisCols] = lCharLen; /*pfnCnrColPels ( pdr->hwndE,
  2369.                                                      pdr->colInfo[TODO_CHEK].pfinf );
  2370.    
  2371.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2372.    
  2373.          lUsedPels += pprtCtl->alfinf[sVisCols];
  2374.  
  2375.          pprtCtl->alIds[sVisCols]   = TODO_CHEK;
  2376.    
  2377.          ++sVisCols;
  2378.       }
  2379.       if ( pdr->ulStyl & TODO_STY_SHOWTASK )
  2380.       {
  2381.          pprtCtl->alfinf[sVisCols] = pprtCtl->rclPage.xRight - pprtCtl->rclPage.xLeft - lUsedPels;
  2382.          /*pfnCnrColPels ( pdr->hwndE,
  2383.                                                      pdr->colInfo[TODO_TASK].pfinf );
  2384.    
  2385.          pprtCtl->alfinf[sVisCols] += ( pprtCtl->fmAll.lAveCharWidth * 2 );*/
  2386.    
  2387.          pprtCtl->alIds[sVisCols]   = TODO_TASK;
  2388.    
  2389.          ++sVisCols;
  2390.       }
  2391.    }
  2392.  
  2393.    pprtCtl->sVisCols = sVisCols;
  2394.  
  2395. /*   pprtCtl->rclPage.xRight = pfnPrintALScale ( pprtCtl->rclPage.xRight -
  2396.                                                pprtCtl->rclPage.xLeft,
  2397.                                                sVisCols, 
  2398.                                                pprtCtl->alfinf );*/
  2399.  
  2400.    pprtCtl->rclBody.xRight = pprtCtl->rclPage.xRight;
  2401.    pprtCtl->rclFoot.xRight = pprtCtl->rclPage.xRight;
  2402.  
  2403.    //*** Column Headings Setup ********************************************** */
  2404.  
  2405.    lLeft = pprtCtl->rclPage.xLeft;
  2406.  
  2407.    for ( sX = 0; sX < sVisCols; ++sX )
  2408.    {
  2409.       pprtCtl->arclfinf[sX].xLeft  = lLeft;
  2410.       pprtCtl->arclfinf[sX].xRight = lLeft + pprtCtl->alfinf[sX];
  2411.  
  2412.       lLeft = pprtCtl->arclfinf[sX].xRight;
  2413.    }
  2414.  
  2415.    pprtCtl->arclfinf[sVisCols-1].xRight = pprtCtl->rclPage.xRight;
  2416.  
  2417.    pprtCtl->lHedLines = 1;
  2418.  
  2419.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoEntr; sX < strlen ( psz ); ++sX )
  2420.       if ( psz[sX] == '\n' )
  2421.          ++colLines;
  2422.    if ( colLines > pprtCtl->lHedLines )
  2423.       pprtCtl->lHedLines = colLines;
  2424.  
  2425.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoTarg; sX < strlen ( psz ); ++sX )
  2426.       if ( psz[sX] == '\n' )
  2427.          ++colLines;
  2428.    if ( colLines > pprtCtl->lHedLines )
  2429.       pprtCtl->lHedLines = colLines;
  2430.  
  2431.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoDone; sX < strlen ( psz ); ++sX )
  2432.       if ( psz[sX] == '\n' )
  2433.          ++colLines;
  2434.    if ( colLines > pprtCtl->lHedLines )
  2435.       pprtCtl->lHedLines = colLines;
  2436.  
  2437.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoPrio; sX < strlen ( psz ); ++sX )
  2438.       if ( psz[sX] == '\n' )
  2439.          ++colLines;
  2440.    if ( colLines > pprtCtl->lHedLines )
  2441.       pprtCtl->lHedLines = colLines;
  2442.  
  2443.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoIDid; sX < strlen ( psz ); ++sX )
  2444.       if ( psz[sX] == '\n' )
  2445.          ++colLines;
  2446.    if ( colLines > pprtCtl->lHedLines )
  2447.       pprtCtl->lHedLines = colLines;
  2448.  
  2449.    for ( sX = 0, colLines = 1, psz = colStrs.pszToDoTask; sX < strlen ( psz ); ++sX )
  2450.       if ( psz[sX] == '\n' )
  2451.          ++colLines;
  2452.    if ( colLines > pprtCtl->lHedLines )
  2453.       pprtCtl->lHedLines = colLines;
  2454.  
  2455.    ++pprtCtl->lHedLines;
  2456. }
  2457.  
  2458. //****************************************************************************
  2459. // Draw a Check Mark
  2460. //****************************************************************************
  2461. VOID             pfnDrawCheckMark    ( HPS hps, PRECTL pRecIn, PFONTMETRICS pfm )
  2462. {
  2463.    RECTL  rclChk;
  2464.    POINTL aptl[6];
  2465.  
  2466.    LONG   xWork,
  2467.           x3rd,
  2468.           y3rd;
  2469.  
  2470.    BOOL   pfmLocal = FALSE;
  2471.  
  2472.    if ( ! pfm )
  2473.    {
  2474.       pfm = (PFONTMETRICS) malloc ( sizeof ( FONTMETRICS ) );
  2475.  
  2476.       GpiQueryFontMetrics ( hps, sizeof ( FONTMETRICS ), pfm );
  2477.  
  2478.       pfmLocal = TRUE;
  2479.    }
  2480.    rclChk.yBottom = pRecIn->yTop - pfm->lMaxAscender;
  2481.    rclChk.yTop    = rclChk.yBottom + pfm->lLowerCaseAscent;
  2482.  
  2483.    xWork = pfm->lMaxCharInc - 6;
  2484.  
  2485.    rclChk.xLeft   = pRecIn->xLeft + 3;
  2486.    rclChk.xRight  = rclChk.xLeft + xWork;
  2487.  
  2488.    x3rd = xWork / 3;
  2489.    y3rd = ( rclChk.yTop - rclChk.yBottom ) / 3;
  2490.  
  2491.    aptl[0].x = rclChk.xLeft;
  2492.    aptl[0].y = rclChk.yBottom + y3rd;
  2493.  
  2494.    aptl[1].x = rclChk.xLeft + x3rd;
  2495.    aptl[1].y = rclChk.yBottom;
  2496.  
  2497.    aptl[2].x = rclChk.xLeft + x3rd + 3;
  2498.    aptl[2].y = rclChk.yBottom;
  2499.  
  2500.    aptl[3].x = rclChk.xRight;
  2501.    aptl[3].y = rclChk.yTop;
  2502.  
  2503.    aptl[4].x = rclChk.xLeft   + x3rd + 1;
  2504.    aptl[4].y = rclChk.yBottom + y3rd - 1;
  2505.  
  2506.    aptl[5] = aptl[0];
  2507.  
  2508.    GpiSetColor ( hps, CLR_DEFAULT ) ;
  2509.  
  2510.    GpiBeginPath ( hps, 1 );
  2511.  
  2512.    GpiMove ( hps, &aptl[0] ) ;
  2513.  
  2514.    GpiPolyLine ( hps, 6, aptl );
  2515.  
  2516.    GpiEndPath ( hps );
  2517.  
  2518.    GpiFillPath ( hps, 1, FPATH_ALTERNATE );
  2519.  
  2520.    if ( pfmLocal )
  2521.    {
  2522.       free ( pfm );
  2523.    }
  2524. }
  2525.