home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: InfoMgt / InfoMgt.zip / code25.zip / fspmain.c < prev    next >
C/C++ Source or Header  |  1995-10-04  |  109KB  |  3,022 lines
  1.  
  2. #define VAR_SCOPE
  3.  
  4. #include "fsp.h"
  5.  
  6. //*** Prototypes ************************************************************ */
  7.  
  8. BOOL             pfnDefTree   ( PUSEREC );
  9. BOOL             pfnLoadOpts  ( VOID );
  10. MRESULT EXPENTRY pfndpNotebook( HWND, ULONG, MPARAM, MPARAM );
  11.  
  12. /***************************************************************************/
  13. /* Main Entry Point                                                        */
  14. /***************************************************************************/
  15. INT              main         ( USHORT usArgc, PSZ psz[] ) 
  16. {
  17.    HAB      habMain;
  18.    HMQ      hmqMain;
  19.    QMSG     qmsg;
  20.     
  21.    HELPINIT help;
  22.     
  23.    ULONG    flCreate;
  24.     
  25.    SWP      swp;
  26.    ULONG    ulWid;
  27.     
  28.    HATOMTBL hatSysAtom;
  29.     
  30.    BOOL     fbDoSettings = FALSE;
  31.  
  32.    //*** PM *****************************************************************
  33.     
  34.    habMain = WinInitialize ( ( USHORT ) NULL );
  35.     
  36.    hmqMain = WinCreateMsgQueue ( habMain, 0 );
  37.     
  38.    //*** Suicide Run ? ******************************************************
  39.  
  40.    if ( usArgc == 2 ) 
  41.    {
  42.       if ( ! stricmp ( psz[1], "REMOVE_PMSB_NOW" ) )
  43.       {
  44.          if ( pfnMsgYesNo ( HWND_DESKTOP, APP_TITLE,
  45.                             "Remove PM Scrapbook Settings ?" ) )
  46.          {
  47.             PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, NULL, NULL, 0 );
  48.              
  49.             DosExit ( EXIT_PROCESS, 0 );
  50.          }
  51.       }
  52.    }
  53.  
  54.    //*** INI ****************************************************************
  55.     
  56.    pszQueueName  = malloc ( QNAME_LEN );
  57.    *pszQueueName = 0;
  58.  
  59.    fbUnregistered = UNREGSTRD;
  60.  
  61.    if ( ! pfnLoadOpts () )
  62.       fbDoSettings = TRUE;
  63.     
  64.    if ( fbUnregistered || fbDoSettings )
  65.       WinDlgBox ( HWND_DESKTOP, HWND_DESKTOP, pfndpAbout,
  66.                   0L, DLG_ABOUT, NULL );
  67.     
  68.    //*** Main Window ********************************************************
  69.     
  70.    WinRegisterClass ( habMain, "PMScrapBook", pfnwpMainWin, 0L, 4 );
  71.     
  72.    flCreate = FCF_SYSMENU | FCF_TITLEBAR | FCF_ACCELTABLE | FCF_MINMAX | FCF_ICON | FCF_MENU |
  73.               FCF_TASKLIST | FCF_SIZEBORDER | FCF_NOBYTEALIGN | FCF_SHELLPOSITION;
  74.     
  75.    hwndFrame = WinCreateStdWindow ( HWND_DESKTOP, 0L, &flCreate,
  76.                                     "PMScrapBook",
  77.                                     "PM Scrapbook",
  78.                                     0L, 0L, (ULONG)WID_MAIN, &hwndM );
  79.     
  80.    hwndTreeMenu = WinWindowFromID ( hwndFrame, FID_MENU );
  81.  
  82.    if ( ! ( ulTreeOpts & SCB_MENUED ) )
  83.    {
  84.       WinSetParent ( hwndTreeMenu, HWND_OBJECT, FALSE );
  85.        
  86.       WinSendMsg ( hwndFrame, WM_UPDATEFRAME, (MPARAM) FCF_MENU, 0 );
  87.    }
  88.  
  89.    //*** Help Init **********************************************************
  90.     
  91.    help.cb                       = sizeof (HELPINIT);
  92.    help.ulReturnCode             = 0;
  93.    help.pszTutorialName          = NULL;
  94.    help.phtHelpTable             = (PHELPTABLE) ( 0xFFFF0000 | WID_HELP );
  95.    help.hmodHelpTableModule      = 0;
  96.    help.hmodAccelActionBarModule = 0;
  97.    help.idAccelTable             = 0;
  98.    help.idActionBar              = 0;
  99.    help.fShowPanelId             = CMIC_HIDE_PANEL_ID;
  100.    help.pszHelpWindowTitle       = "PM Scrapbook Help";
  101.    help.pszHelpLibraryName       = "PMScrpBk.hlp";
  102.     
  103.    hwndH = WinCreateHelpInstance ( habMain, &help );
  104.     
  105.    if ( hwndH ) 
  106.       WinAssociateHelpInstance ( hwndH, hwndFrame );
  107.    else 
  108.    {
  109.       help.pszHelpLibraryName = "PMScrpBk.hlp";
  110.        
  111.       hwndH = WinCreateHelpInstance ( habMain, &help );
  112.        
  113.       if ( hwndH )
  114.          WinAssociateHelpInstance ( hwndH, hwndFrame );
  115.       else 
  116.       {
  117.          WinAlarm ( HWND_DESKTOP, WA_NOTE );
  118.          /*WinMessageBox ( HWND_DESKTOP, hwndFrame,
  119.                         "Could not open help file.",
  120.                         "PM Scrapbook ERROR", 0, MB_OK | MB_ICONEXCLAMATION );*/
  121.       }
  122.    }
  123.     
  124.    //*** Window Sizes & Positions *******************************************
  125.     
  126.    WinQueryTaskSizePos ( habMain, 0, &swp );
  127.     
  128.    WinSetWindowPos ( hwndFrame, HWND_TOP, swp.x, swp.y, swp.cx, swp.cy, SWP_MOVE | SWP_SIZE | SWP_SHOW );
  129.     
  130.    WinQueryWindowPos ( hwndM, &swp );
  131.     
  132.    /*WinSetWindowPos ( WinQueryWindow ( hwndT, QW_PARENT ), HWND_TOP,
  133.                      0,
  134.                      swp.cy / 4,
  135.                      swp.cx / 2,
  136.                      swp.cy / 4 * 3,
  137.                      SWP_SIZE | SWP_MOVE | SWP_SHOW );*/
  138.    ulWid = swp.cx;
  139.     
  140.    WinQueryWindowPos ( hwndS, &swp );
  141.     
  142.    WinSetWindowPos ( hwndS, HWND_TOP,
  143.                      ulWid - swp.cx, 0, 0, 0,
  144.                      SWP_MOVE );
  145.     
  146.    //*** Window Classes *****************************************************
  147.     
  148.    WinRegisterClass ( habMain, "PMScbText", pfnwpTextWin, 0L, 4 );
  149.    WinRegisterClass ( habMain, "PMScbAddr", pfnwpAddrWin, 0L, 4 );
  150.    WinRegisterClass ( habMain, "PMScbToDo", pfnwpToDoWin, 0L, 4 );
  151. //   WinRegisterClass ( habMain, "PMScbLst2", pfnwpLst2Win, 0L, 4 );
  152.    WinRegisterClass ( habMain, "PMScbMini", pfnwpMiniWin, 0L, 4 );
  153.     
  154.     
  155.    //*** Clipboard Formats **************************************************
  156.     
  157.    hatSysAtom = WinQuerySystemAtomTable ();
  158.     
  159.    atomTree = WinAddAtom ( hatSysAtom, "Get Organized ! Tree" );
  160.    atomAddr = WinAddAtom ( hatSysAtom, "Get Organized ! Addr" );
  161.    atomToDo = WinAddAtom ( hatSysAtom, "Get Organized ! ToDo" );
  162. //   atomLst2 = WinAddAtom ( hatSysAtom, "Get Organized ! Lst2" );
  163.    atomMini = WinAddAtom ( hatSysAtom, "Get Organized ! Mini" );
  164.     
  165.    //*** Misc Inits *********************************************************
  166.     
  167.    //pRecAll = malloc ( sizeof ( USEREC ) );
  168.     
  169.    //pRecAll->pdr = malloc ( sizeof ( DATREC ) );
  170.     
  171.    pszSearch = malloc ( 32 );
  172.    *pszSearch = 0;
  173.     
  174.    DosCreateEventSem ( NULL, &evtThdDone, 0, FALSE );
  175.  
  176.    pszCurrFile = pfnFileNameBuf ( NULL );
  177.  
  178.    usLeftDvWnd  = CID_LEFTDVWND;
  179.    usRightDvWnd = CID_RIGHTDVWND;
  180.     
  181.    WinSetFocus ( HWND_DESKTOP, hwndC );
  182.     
  183.    fbGotModem = FALSE;
  184.  
  185.    /*hfilModem = pfnDialOpen ( achComX );
  186.  
  187.    if ( hfilModem )
  188.    {
  189.       if ( pfnDialTest ( hfilModem ) )
  190.          fbGotModem = TRUE;
  191.  
  192.       DosClose ( hfilModem );
  193.    } */
  194.  
  195.    hfilModem = NULLHANDLE;
  196.  
  197.    ctrycode.country  = 0;
  198.    ctrycode.codepage = 0;
  199.     
  200.    DosQueryCtryInfo ( sizeof(COUNTRYINFO), &ctrycode, &ci, &flCreate );
  201.  
  202.    //*** Parse Arg Line *****************************************************
  203.     
  204.    pRec = 0;
  205.  
  206.    if ( usArgc == 2 ) 
  207.       pfnReadFile ( hwndM, psz[1] );
  208.    else
  209.       WinPostMsg ( hwndM, WM_COMMAND, MPFROM2SHORT ( MID_MAIN_NEW, 0 ), NULL );
  210.     
  211.    if ( fbDoSettings )
  212.       WinPostMsg ( hwndM, WM_COMMAND, MPFROM2SHORT ( MID_MAIN_SETTINGS, 0 ), NULL );
  213.  
  214.    while ( WinGetMsg ( habMain, &qmsg, 0L, 0L, 0L ) )
  215.            WinDispatchMsg ( habMain, ( PQMSG ) &qmsg );
  216.     
  217.    //*** Clean Up ***********************************************************
  218.     
  219.    free ( pszSearch );
  220.    free ( pszCurrFile );
  221.    free ( pszQueueName );
  222.     
  223.    free ( pRecAll->pdr );
  224.     
  225.    free ( pRecAll );
  226.     
  227.    WinDestroyHelpInstance ( hwndH );
  228.     
  229.    WinDeleteAtom ( hatSysAtom, atomTree );
  230.    WinDeleteAtom ( hatSysAtom, atomAddr );
  231.    WinDeleteAtom ( hatSysAtom, atomToDo );
  232.    WinDeleteAtom ( hatSysAtom, atomLst2 );
  233.    WinDeleteAtom ( hatSysAtom, atomMini );
  234.     
  235.    WinDestroyWindow ( hwndFrame );
  236.     
  237.    WinDestroyMsgQueue ( hmqMain );
  238.     
  239.    WinTerminate ( habMain );
  240.     
  241.    DosExit ( EXIT_PROCESS, 0 );
  242.     
  243.    return 0;
  244. }
  245.  
  246. /***************************************************************************/
  247. /* Initialize New Scrapbook                                                */
  248. /***************************************************************************/
  249. BOOL             pfnNewBook   ( HWND hwnd, PSZ pszInFile )
  250. {
  251.    PDATREC    pdr;
  252.    PSZ        pszTmp;
  253.     
  254.    //*** Reset Set Tree State, Fonts & Colors *******************************
  255.     
  256.    pfnDefTree ( pRecAll );
  257.     
  258.    pdr = pRecAll->pdr;
  259.     
  260.    pdr->ulDEnt = 1; // 112
  261.     
  262.    //pfnSetPresFont ( hwndC, pdr->sPtSize, pdr->fat.szFacename );
  263.    pfnSetPPFont ( hwndC, pdr->fxPtSz, &pdr->fat );
  264.     
  265.    pfnSetPresColors ( hwndC, pdr->ulNBClr, pdr->ulNFClr, pdr->ulHBClr, pdr->ulHFClr );
  266.     
  267.    //*** Allocate & Init Root Rec *******************************************
  268.     
  269.    pRec = pfnAllocRec ( NULL, WID_TREE, 0, TRUE, TRUE );
  270.     
  271.    pRecFoc = pRec;
  272.     
  273.    pRec->pdr->hwndE = hwndC;
  274.  
  275.    if ( pRec->pdr->pszStat )
  276.       free ( pRec->pdr->pszStat );
  277.     
  278.    pRec->pdr->pszStat = malloc ( 256 );
  279.     
  280.    //*** Set Globals ********************************************************
  281.     
  282.    fbModified = FALSE;
  283.    fbEditing  = FALSE;
  284.    fbSaving   = FALSE;
  285.    fbDialing  = FALSE;
  286.    fbReading  = FALSE;
  287.     
  288.    ulRelRev = REL_REV;
  289.     
  290.    if ( pszInFile )
  291.    {
  292.       strcpy ( pszCurrFile, pszInFile );
  293.        
  294.       pszTmp = strrchr ( pszInFile, '\\' );
  295.        
  296.       if ( pszTmp )
  297.          ++pszTmp;
  298.       else 
  299.          pszTmp = pszInFile;
  300.        
  301.       pfnFrameTitle ( WinQueryWindow ( hwnd, QW_PARENT ), "PM Scrapbook", pszTmp );
  302.    }
  303.    else 
  304.    {
  305.       *pszCurrFile = 0;
  306.        
  307.       pfnFrameTitle ( WinQueryWindow ( hwnd, QW_PARENT ), "PM Scrapbook", "?" );
  308.    }
  309.     
  310.    return TRUE;
  311. }
  312.  
  313. /***************************************************************************/
  314. /* See if Scrapbook has changed                                            */
  315. /***************************************************************************/
  316. USHORT           pfnMaybeSave (  ) 
  317. {
  318.    USHORT  usResp = MBID_YES;
  319.     
  320.    ulEntryUpdates = 0;
  321.  
  322.    if ( pRec )
  323.       pfnTreeScan ( pRec, SCB_TREE, SCB_UPDATED, 0 );
  324.  
  325.    if ( fbModified || ulEntryUpdates )
  326.    {
  327.       usResp = pfnMsgYesNoCan ( hwndM, APP_TITLE,
  328.                                "This scrapbook has been modified. Save changes ?" );
  329.        
  330.       if ( usResp == MBID_YES ) 
  331.          WinSendMsg ( hwndM, WM_COMMAND, MPFROM2SHORT ( MID_MAIN_SAVE, 0 ), NULL );
  332.       else if ( usResp != MBID_CANCEL ) 
  333.          fbModified = FALSE;
  334.    }
  335.     
  336.    /* Free Containers */
  337.     
  338.    if ( pRec ) 
  339.    {
  340.       if ( usResp != MBID_CANCEL ) 
  341.       {
  342.          WinEnableWindowUpdate ( hwndC, FALSE );
  343.           
  344.          pfnTreeScan ( pRec, SCB_TREE, SCB_FREE, 0 );
  345.           
  346.          WinEnableWindowUpdate ( hwndC, TRUE );
  347.       }
  348.    }
  349.     
  350.    return usResp;
  351. }
  352.  
  353. /***************************************************************************/
  354. /* Save Scrapbook to Disk                                                  */
  355. /***************************************************************************/
  356. BOOL             pfnSaveFile  ( HWND hwnd, PSZ pszToFile )
  357. {
  358.    HFILE   hfil;
  359.    ULONG   ulBytesWrit;
  360.     
  361.    DATREC  dr;
  362.    PDATREC pdr;
  363.     
  364.    APIRET  apiret;
  365.    PSZ     pszTmp;
  366.     
  367.    //*** Open File **********************************************************
  368.     
  369.    ulBytesWrit = 0;
  370.     
  371.    apiret = DosOpen ( pszToFile, &hfil, &ulBytesWrit, 0L, 0L,
  372.                       OPEN_ACTION_REPLACE_IF_EXISTS | OPEN_ACTION_CREATE_IF_NEW,
  373.                       OPEN_SHARE_DENYREADWRITE|OPEN_ACCESS_WRITEONLY, 0L );
  374.     
  375.    if ( apiret ) 
  376.    {
  377.       pfnMsgOK ( hwnd, APP_TITLE, "Could not open file." );
  378.  
  379.       return FALSE;
  380.    }
  381.        
  382.    //*** Set Main Title *****************************************************
  383.     
  384.    strcpy ( pszCurrFile, pszToFile );
  385.     
  386.    pszTmp = strrchr ( pszToFile, '\\' );
  387.     
  388.    if ( pszTmp )
  389.       ++pszTmp;
  390.    else
  391.       pszTmp = pszToFile;
  392.     
  393.    //pfnFrameTitle ( WinQueryWindow ( hwndM, QW_PARENT ), "PM Scrapbook", pszTmp );
  394.     
  395.    //*** Save All Entries ***************************************************
  396.     
  397.    pfnTreeScan ( pRec, SCB_TREE, SCB_SAVE, 0 );
  398.  
  399.    //*** Write Header *******************************************************
  400.     
  401.    DosWrite ( hfil, "PMSCB", 5, &ulBytesWrit );
  402.     
  403.    ulRelRev = REL_REV;
  404.     
  405.    DosWrite ( hfil, &ulRelRev, sizeof ( ULONG ), &ulBytesWrit );
  406.     
  407.    dr.hwndD = WinQueryWindow ( hwndM, QW_PARENT );
  408.     
  409.    dr.ulDLen = 1;
  410.     
  411.    pfnGetWinPos ( dr.hwndD, &dr );
  412.     
  413.    DosWrite ( hfil, &dr.swp, sizeof ( SWP ), &ulBytesWrit );
  414.     
  415.    //dr.hwndD = hwndT;
  416.    dr.hwndD = WinQueryWindow ( hwndM, QW_PARENT );
  417.     
  418.    dr.ulDLen = 1;
  419.     
  420.    pfnGetWinPos ( dr.hwndD, &dr );
  421.     
  422.    pdr = pRecAll->pdr;
  423.     
  424.    //pdr->sPtSize = pfnFmToFat ( hwndC, &pdr->fat );
  425.  
  426.    //pfnGetDefFattrs ( hwndC, NULLHANDLE, &pdr->fat, &pdr->fxPtSz );
  427.     
  428.    pfnGetPresColors ( hwndC, &pdr->ulNBClr, &pdr->ulNFClr, &pdr->ulHBClr, &pdr->ulHFClr );
  429.     
  430.    DosWrite ( hfil, &dr.swp,                 sizeof ( SWP ),    &ulBytesWrit );
  431.    DosWrite ( hfil, &pRecAll->pdr->fat,      sizeof ( FATTRS ), &ulBytesWrit );
  432. //   DosWrite ( hfil, &pRecAll->pdr->sPtSize, sizeof ( SHORT ),  &ulBytesWrit );
  433.    DosWrite ( hfil, &pRecAll->pdr->fxPtSz,   sizeof ( FIXED ),  &ulBytesWrit );
  434.    DosWrite ( hfil, &pRecAll->pdr->ulDLen,   sizeof ( ULONG ),  &ulBytesWrit );
  435.    DosWrite ( hfil, &pRecAll->pdr->ulDEnt,   sizeof ( ULONG ),  &ulBytesWrit );
  436.    DosWrite ( hfil, &pRecAll->pdr->ulOpts,   sizeof ( ULONG ),  &ulBytesWrit );
  437.    DosWrite ( hfil, &pRecAll->pdr->ulStyl,   sizeof ( ULONG ),  &ulBytesWrit );
  438.    DosWrite ( hfil, &pRecAll->pdr->ulNBClr,  sizeof ( ULONG ),  &ulBytesWrit );
  439.    DosWrite ( hfil, &pRecAll->pdr->ulNFClr,  sizeof ( ULONG ),  &ulBytesWrit );
  440.    DosWrite ( hfil, &pRecAll->pdr->ulHBClr,  sizeof ( ULONG ),  &ulBytesWrit );
  441.    DosWrite ( hfil, &pRecAll->pdr->ulHFClr,  sizeof ( ULONG ),  &ulBytesWrit );
  442.     
  443.    DosWrite ( hfil, &pRecAll->pdr->fatPrt,   sizeof ( FATTRS ), &ulBytesWrit );
  444.    DosWrite ( hfil, &pRecAll->pdr->fxPtSzPrt,sizeof ( FIXED ),  &ulBytesWrit );
  445.  
  446.    pfnTreeScan ( pRec, SCB_TREE, SCB_WRITE, MPFROMLONG ( hfil ) );
  447.     
  448.    //*** Close File & Clean Up **********************************************
  449.     
  450.    DosClose ( hfil );
  451.     
  452.    return TRUE;
  453. }
  454.  
  455. /***************************************************************************/
  456. /* Read Scrapbook from Disk                                                */
  457. /***************************************************************************/
  458. BOOL             pfnReadFile  ( HWND hwnd, PSZ pszOfFile )
  459. {
  460.    HFILE   hfil;
  461.    ULONG   ulBytesRead;
  462.    ULONG   ul;
  463.    LONG    lRLvl;
  464.    LONG    lExpnd;
  465.    LONG    lX;
  466.    ULONG   ulOpts;
  467.    ULONG   ulReal;
  468.     
  469.    APIRET  apiret;
  470.     
  471.    CHAR    ach[CCHMAXPATH+80];
  472.     
  473.    //PSZ     pszTtl;
  474.    PSZ     pszTmp;
  475.    SHORT   sPtSz;
  476.  
  477.    DATREC  dr;
  478.     
  479.    /* Container Stuff */
  480.     
  481.    PUSEREC      pRecTmp;
  482.    PUSEREC      pRecPar;
  483.    PDATREC      pdr;
  484.    PUSEREC     *pParStack;
  485.    PUSEREC     *pParExpnd;
  486.    //CNRINFO      cnrinf;
  487.    RECORDINSERT recins;
  488.     
  489.    if ( ! pfnFileExists ( pszOfFile ) )
  490.    {
  491.       pfnNewBook ( hwnd, pszOfFile );
  492.        
  493.       return TRUE;
  494.    }
  495.     
  496.    //*** Open File **********************************************************
  497.     
  498.    ulBytesRead = 0;
  499.     
  500.    apiret = DosOpen ( pszOfFile, &hfil, &ulBytesRead, 0L, 0L,
  501.                       OPEN_ACTION_FAIL_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
  502.    //                   OPEN_ACTION_CREATE_IF_NEW | OPEN_ACTION_OPEN_IF_EXISTS,
  503.                       OPEN_SHARE_DENYNONE|OPEN_ACCESS_READONLY, 0L );
  504.     
  505.    if ( apiret ) 
  506.    {
  507.       pszTmp = malloc ( 80 );
  508.        
  509.       sprintf ( pszTmp, "Open Fail RC = %d", apiret );
  510.        
  511.       pfnMsgOK ( hwnd, APP_TITLE, pszTmp );
  512.        
  513.       free ( pszTmp );
  514.        
  515.       pfnNewBook ( hwnd, NULL );
  516.        
  517.       //if ( apiret != ERROR_FILE_NOT_FOUND ) {
  518.           
  519.          return FALSE;
  520.           
  521.       //}
  522.    }
  523.     
  524.    //*** Init ***************************************************************
  525.     
  526.    pfnNewBook ( hwnd, pszOfFile );
  527.     
  528.    WinSendMsg ( hwndC, CM_REMOVERECORD,
  529.                 MPFROMP ( &pRec ),
  530.                 MPFROM2SHORT( 1, CMA_FREE | CMA_INVALIDATE ) );
  531.     
  532.    pRec = NULL;    // Free HERE
  533.     
  534.    pfnDefTree ( pRecAll );
  535.     
  536.    //WinEnableWindowUpdate ( hwndC, FALSE );
  537.     
  538.    //*** Read Header ********************************************************
  539.     
  540.    DosRead ( hfil, ach, 5, &ulBytesRead );
  541.     
  542.    if ( strncmp ( ach, "PMSCB", 5 ) ) 
  543.    {
  544.       pfnMsgOK ( hwnd, APP_TITLE, "Not a PM Scrapbook file." );
  545.        
  546.       DosClose ( hfil );
  547.        
  548.       pfnNewBook ( hwnd, NULL );
  549.        
  550.       return FALSE;
  551.        
  552.    }
  553.     
  554.    DosRead ( hfil, &ulRelRev, sizeof ( ULONG ), &ulBytesRead );
  555.    DosRead ( hfil, &dr.swp,   sizeof ( SWP ),   &ulBytesRead );
  556.     
  557.    //dr.hwndD = hwndM;
  558.    dr.hwndD = WinQueryWindow ( hwndM, QW_PARENT );
  559.     
  560.    dr.ulDLen = 1;
  561.     
  562.    pfnSetWinPos ( dr.hwndD, &dr );
  563.     
  564.    DosRead ( hfil, &dr.swp,                sizeof ( SWP ),    &ulBytesRead );
  565.    DosRead ( hfil, &pRecAll->pdr->fat,     sizeof ( FATTRS ), &ulBytesRead );
  566.  
  567.    if ( ( ulRelRev % 5000 ) <= 112 )
  568.    {
  569.       DosRead ( hfil, &sPtSz, sizeof ( SHORT ),  &ulBytesRead );
  570.       pRecAll->pdr->fxPtSz = MAKEFIXED ( sPtSz, 0 );
  571.    }
  572.    else
  573.       DosRead ( hfil, &pRecAll->pdr->fxPtSz, sizeof ( FIXED ),  &ulBytesRead );
  574.     
  575.    if ( ( ulRelRev % 5000 ) > 111 ) 
  576.    {
  577.       DosRead ( hfil, &pRecAll->pdr->ulDLen,  sizeof ( ULONG ), &ulBytesRead );
  578.       DosRead ( hfil, &pRecAll->pdr->ulDEnt,  sizeof ( ULONG ), &ulBytesRead );
  579.       DosRead ( hfil, &pRecAll->pdr->ulOpts,  sizeof ( ULONG ), &ulBytesRead );
  580.       DosRead ( hfil, &pRecAll->pdr->ulStyl,  sizeof ( ULONG ), &ulBytesRead );
  581.       DosRead ( hfil, &pRecAll->pdr->ulNBClr, sizeof ( ULONG ), &ulBytesRead );
  582.       DosRead ( hfil, &pRecAll->pdr->ulNFClr, sizeof ( ULONG ), &ulBytesRead );
  583.       DosRead ( hfil, &pRecAll->pdr->ulHBClr, sizeof ( ULONG ), &ulBytesRead );
  584.       DosRead ( hfil, &pRecAll->pdr->ulHFClr, sizeof ( ULONG ), &ulBytesRead );
  585.    }
  586.     
  587.    if ( ( ulRelRev % 5000 ) > 112 )
  588.    {
  589.       DosRead ( hfil, &pRecAll->pdr->fatPrt,   sizeof ( FATTRS ), &ulBytesRead );
  590.       DosRead ( hfil, &pRecAll->pdr->fxPtSzPrt,sizeof ( FIXED ),  &ulBytesRead );
  591.    }
  592.  
  593.    //*** Set Tree Fonts & Colors ********************************************
  594.     
  595.    pdr = pRecAll->pdr;
  596.     
  597.    pfnSetPPFont ( hwndC, pdr->fxPtSz, &pdr->fat );
  598.     
  599.    pfnSetPresColors ( hwndC, pdr->ulNBClr, pdr->ulNFClr, pdr->ulHBClr, pdr->ulHFClr );
  600.     
  601.    //*** Read  Data *********************************************************
  602.     
  603.    DosRead ( hfil, &lRLvl, sizeof ( lRLvl ), &ulBytesRead );
  604.     
  605.    while ( ulBytesRead ) 
  606.    {
  607.       //*** Alloc Record & Read *********************************************
  608.        
  609.       DosRead ( hfil, &ul,     sizeof ( ULONG ), &ulBytesRead );
  610.       DosRead ( hfil, &ulOpts, sizeof ( ULONG ), &ulBytesRead );
  611.       DosRead ( hfil, &ulReal, sizeof ( ULONG ), &ulBytesRead );
  612.        
  613.       pRecTmp = pfnAllocRec ( pRec, ul, ulReal, FALSE, TRUE );
  614.        
  615.       pRecTmp->ulOpts = ulOpts;
  616.        
  617.       //pRecTmp->ulReal = ulReal;
  618.        
  619.       //*** Dates ***********************************************************
  620.        
  621.       DosRead ( hfil, &pRecTmp->cdCre, sizeof ( CDATE ), &ulBytesRead );
  622.       DosRead ( hfil, &pRecTmp->ctCre, sizeof ( CTIME ), &ulBytesRead );
  623.       DosRead ( hfil, &pRecTmp->cdWri, sizeof ( CDATE ), &ulBytesRead );
  624.       DosRead ( hfil, &pRecTmp->ctWri, sizeof ( CTIME ), &ulBytesRead );
  625.       DosRead ( hfil, &pRecTmp->cdAcc, sizeof ( CDATE ), &ulBytesRead );
  626.       DosRead ( hfil, &pRecTmp->ctAcc, sizeof ( CTIME ), &ulBytesRead );
  627.        
  628.       //*** Entry Name ******************************************************
  629.        
  630.       DosRead ( hfil, &ul, sizeof ( ul ), &ulBytesRead );
  631.        
  632.       pRecTmp->crecCore.pszTree  = malloc ( ul );
  633.        
  634.       DosRead ( hfil, pRecTmp->crecCore.pszTree, ul, &ulBytesRead );
  635.        
  636.       //*** Detail **********************************************************
  637.        
  638.       pdr = pRecTmp->pdr;
  639.        
  640.       DosRead ( hfil, &pdr->ulDLen, sizeof ( ULONG ), &ulBytesRead );
  641.        
  642.       if ( pdr->ulDLen ) 
  643.       {
  644.          pdr->pvDat = malloc ( pdr->ulDLen );
  645.           
  646.          DosRead ( hfil, &pdr->ulDEnt,  sizeof ( ULONG ),  &ulBytesRead );
  647.  
  648.          if ( ( ulRelRev % 5000 ) < 114 )
  649.          {
  650.             pdr->ulRelRev = ( ulRelRev % 5000 );
  651.          }
  652.          else
  653.             DosRead ( hfil, &pdr->ulRelRev, sizeof ( ULONG ),  &ulBytesRead );
  654.  
  655.          DosRead ( hfil, pdr->pvDat,    pdr->ulDLen,       &ulBytesRead );
  656.          DosRead ( hfil, &pdr->ulOpts,  sizeof ( ULONG ),  &ulBytesRead );
  657.          DosRead ( hfil, &pdr->ulStyl,  sizeof ( ULONG ),  &ulBytesRead );
  658.          DosRead ( hfil, &pdr->swp,     sizeof ( SWP ),    &ulBytesRead );
  659.          DosRead ( hfil, &pdr->fat,     sizeof ( FATTRS ), &ulBytesRead );
  660.       
  661.          //DosRead ( hfil, &pdr->sPtSize, sizeof ( SHORT ),  &ulBytesRead );
  662.          if ( ( ulRelRev % 5000 ) <= 112 )
  663.          {
  664.             DosRead ( hfil, &sPtSz, sizeof ( SHORT ),  &ulBytesRead );
  665.             pdr->fxPtSz = MAKEFIXED ( sPtSz, 0 );
  666.          }
  667.          else
  668.             DosRead ( hfil, &pdr->fxPtSz, sizeof ( FIXED ),  &ulBytesRead );
  669.           
  670.          DosRead ( hfil, &pdr->ulXVS,   sizeof ( ULONG ),  &ulBytesRead );
  671.           
  672.          if ( ( ulRelRev % 5000 ) > 111 ) 
  673.          {
  674.             DosRead ( hfil, &pdr->ulNBClr, sizeof ( ULONG ), &ulBytesRead );
  675.             DosRead ( hfil, &pdr->ulNFClr, sizeof ( ULONG ), &ulBytesRead );
  676.             DosRead ( hfil, &pdr->ulHBClr, sizeof ( ULONG ), &ulBytesRead );
  677.             DosRead ( hfil, &pdr->ulHFClr, sizeof ( ULONG ), &ulBytesRead );
  678.          }
  679.  
  680.          if ( ( ulRelRev % 5000 ) > 112 )
  681.          {
  682.             DosRead ( hfil, &pdr->fatPrt,   sizeof ( FATTRS ), &ulBytesRead );
  683.             DosRead ( hfil, &pdr->fxPtSzPrt,sizeof ( FIXED ),  &ulBytesRead );
  684.          }
  685.  
  686.          //*** Convert Lst2's ***********************************************
  687.  
  688.          if ( pRecTmp->ulType == WID_LIST )
  689.             pfnLst2MiniBase ( pRecTmp );
  690.  
  691.          //*** Load Reference Icons ? ***************************************
  692.  
  693.          if ( pRecTmp->ulType == WID_REFR )
  694.             if ( ! pfnRefrIcon ( pRecTmp ) )
  695.                pfnMsgOK ( hwnd, APP_TITLE, "Error loading icon file." );
  696.             else
  697.                WinSendMsg ( hwndC, CM_INVALIDATERECORD,
  698.                             MPFROMP ( &pRecTmp ), MPFROM2SHORT ( 1, CMA_NOREPOSITION ) );
  699.  
  700.       }
  701.        
  702.       //*** Root ? **********************************************************
  703.        
  704.       if ( ! pRec ) 
  705.       {
  706.          pRec = pRecTmp;
  707.           
  708.          pRecFoc = pRec;
  709.           
  710.          pParStack = malloc ( sizeof ( PUSEREC ) );
  711.          pParExpnd = malloc ( sizeof ( PUSEREC ) );
  712.           
  713.          lExpnd = 0;
  714.           
  715.          pRec->pdr->hwndE = hwndC;   // Tree shift problem ???
  716.  
  717.          if ( ( ulRelRev % 5000 ) < 112 ) 
  718.          {
  719.             pRecAll->pdr->ulDEnt = pRec->pdr->ulDEnt;
  720.              
  721.             pRec->pdr->ulDEnt = 1;
  722.          }
  723.  
  724.          pfnFrameTitle ( WinQueryWindow ( hwndM, QW_PARENT ), 
  725.                          "PM Scrapbook", pRec->crecCore.pszTree );
  726.       }
  727.        
  728.       //*** Parent ? ********************************************************
  729.        
  730.       if ( pRecTmp->ulOpts & SCB_PARENT ) 
  731.       {
  732.          pParStack = realloc ( pParStack, (lRLvl+1) * sizeof(PUSEREC) );
  733.           
  734.          pParStack[lRLvl] = pRecTmp;
  735.       }
  736.        
  737.       //*** Child ? *********************************************************
  738.        
  739.       pRecPar = ( lRLvl ) ? pParStack[+lRLvl-1] : NULL;
  740.        
  741.       //*** Insert **********************************************************
  742.        
  743.       recins.cb                = sizeof ( RECORDINSERT );
  744.       recins.pRecordParent     = (PRECORDCORE) pRecPar;
  745.       recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  746.       recins.zOrder            = CMA_TOP;
  747.       recins.cRecordsInsert    = 1;
  748.       recins.fInvalidateRecord = TRUE; //FALSE;
  749.        
  750.       WinSendMsg ( hwndC, CM_INSERTRECORD,
  751.                    MPFROMP( pRecTmp ), MPFROMP ( &recins ) );
  752.        
  753.       //*** Expand ? ********************************************************
  754.        
  755.       if ( pRecTmp->ulOpts & SCB_EXPAND ) 
  756.       {
  757.          //WinSendMsg ( hwndC, CM_EXPANDTREE, MPFROMP( pRecTmp ), NULL );
  758.           
  759.          if ( pRecPar ) 
  760.          {
  761.             if ( pRecPar->ulOpts & SCB_EXPAND ) 
  762.             {
  763.                pParExpnd = realloc ( pParExpnd, (lExpnd+1) * sizeof(PUSEREC) );
  764.                 
  765.                pParExpnd[lExpnd] = pRecTmp;
  766.                 
  767.                ++lExpnd;
  768.             }
  769.          }
  770.          else if ( pRecTmp == pRec ) 
  771.          {
  772.             if ( pRecTmp->ulOpts & SCB_EXPAND ) 
  773.             {
  774.                pParExpnd = realloc ( pParExpnd, (lExpnd+1) * sizeof(PUSEREC) );
  775.                 
  776.                pParExpnd[lExpnd] = pRecTmp;
  777.                 
  778.                ++lExpnd;
  779.             }
  780.          }
  781.       }
  782.        
  783.       //*** Open ? **********************************************************
  784.        
  785.       if ( pRecTmp->pdr->ulOpts & SCB_OPENED ) 
  786.       {
  787.          WinSendMsg ( hwndM, UWM_DETWIN, MPFROMP( pRecTmp ), NULL );
  788.       }
  789.        
  790.       //*** Count ***********************************************************
  791.        
  792.       ++pRecAll->pdr->ulDEnt;
  793.        
  794.       //*** Next ************************************************************
  795.        
  796.       DosRead ( hfil, &lRLvl, sizeof ( lRLvl ), &ulBytesRead );
  797.    }
  798.     
  799.    //pfnTreeScan ( pRec, SCB_TREE, SCB_REFRESH, 0 );
  800.     
  801.    //cnrinf.flWindowAttr = CV_TREE | CV_ICON | CA_TREELINE;
  802.     
  803.    /*WinSendMsg ( hwndC, CM_SETCNRINFO, &cnrinf,
  804.                 MPFROMLONG ( CMA_FLWINDOWATTR | CMA_CNRTITLE ) );*/
  805.     
  806.    //WinSendMsg ( hwndC, CM_EXPANDTREE, MPFROMP( pRec ), NULL );
  807.     
  808.    //*** Expand Saved Entries ***********************************************
  809.  
  810.    for ( lX = 0; lX < lExpnd; ++lX ) 
  811.    {
  812.       WinSendMsg ( hwndC, CM_EXPANDTREE, MPFROMP( pParExpnd[lX] ), NULL );
  813.    }
  814.     
  815.    //*** Close File & Clean Up **********************************************
  816.     
  817.    DosClose ( hfil );
  818.     
  819.    free ( pParStack );
  820.    free ( pParExpnd );
  821.     
  822.    //WinEnableWindowUpdate ( hwndC, TRUE );
  823.     
  824.    return TRUE;
  825. }
  826.  
  827. /***************************************************************************/
  828. /* Entry Scan Functions                                                    */
  829. /***************************************************************************/
  830. ULONG            pfnNodeScan  ( HWND hwnd, LONG lFunc, LONG lType, PBYTE pbDat ) 
  831. {
  832.    ULONG    ulSize;
  833.    ULONG    ulLen;
  834.    ULONG    ulX;
  835.    PSZ      *ppszX;
  836.     
  837.    PUSEREC  pRecTmp;
  838.    PUSEREC  pRecScn;
  839.    PADDRREC pAddr;
  840.    PTODOREC pToDo;
  841.    PLST2REC pLst2;
  842.    PMINIREC pMini;
  843.     
  844.    PDATREC  pdr;
  845.    PMCTLREC pctl;
  846.    PMCOLREC pcol;
  847.     
  848.    PFIELDINFO pfi;
  849.     
  850.    ulSize = 0;
  851.     
  852.    //*** Write Column Widths ************************************************
  853.  
  854.    if ( ( lType == WID_ADDR || lType == WID_TODO ) && lFunc == SCB_WRITE )
  855.    {
  856.       pRecScn = WinQueryWindowPtr ( hwnd, 0 );
  857.        
  858.       pdr = pRecScn->pdr;
  859.  
  860.       ulSize = ( lType == WID_ADDR ) ? ADDR_COLS : TODO_COLS;
  861.  
  862.       for ( ulX = 0; ulX < ulSize; ++ulX )
  863.       {
  864.          if ( pdr->colInfo[ulX].fbVisible )
  865.             pdr->colInfo[ulX].ulPels = pfnCnrColPels( pdr->hwndE,
  866.                                                       pdr->colInfo[ulX].pfinf );
  867.          else
  868.             pdr->colInfo[ulX].ulPels = 0;
  869.  
  870.          memcpy ( pbDat, &pdr->colInfo[ulX].ulPels, sizeof ( ULONG ) );
  871.          pbDat += sizeof ( ULONG );
  872.       }
  873.    }
  874.  
  875.    if ( ( lType == WID_ADDR || lType == WID_TODO ) && lFunc == SCB_SIZE )
  876.    {
  877.       if ( lType == WID_ADDR ) 
  878.          ulSize = ADDR_COLS * sizeof ( ULONG );
  879.       else
  880.          ulSize = TODO_COLS * sizeof ( ULONG );
  881.    }
  882.    else
  883.       ulSize = 0;
  884.  
  885.    //*** Scan Entry Entries *************************************************
  886.  
  887.    pRecTmp = WinSendMsg ( hwnd, CM_QUERYRECORD,
  888.                           MPFROMP ( NULL ),
  889.                           MPFROM2SHORT ( CMA_FIRST, CMA_ITEMORDER ) );
  890.     
  891.    while ( pRecTmp ) 
  892.    {
  893.       switch ( lFunc ) 
  894.       {
  895.          case SCB_SIZE:
  896.  
  897.             switch ( lType ) 
  898.             {
  899.                case WID_ADDR:
  900.                    
  901.                   pAddr = (PADDRREC) pRecTmp;
  902.                    
  903.                   ulSize += strlen ( pAddr->pszFN ) + 1;
  904.                   ulSize += strlen ( pAddr->pszAC ) + 1;
  905.                   ulSize += strlen ( pAddr->pszPN ) + 1;
  906.                   ulSize += strlen ( pAddr->pszEx ) + 1;
  907.                   ulSize += strlen ( pAddr->pszAd ) + 1;
  908.                   ulSize += strlen ( pAddr->pszNt ) + 1;
  909.                    
  910.                   ulSize += sizeof ( CDATE );
  911.                   ulSize += sizeof ( ULONG );
  912.  
  913.                   ulSize += ( sizeof ( ULONG ) * ADDR_COLS );
  914.                    
  915.                break;
  916.                 
  917.                case WID_TODO:
  918.                    
  919.                   pToDo = (PTODOREC) pRecTmp;
  920.                    
  921.                   ulSize += sizeof ( CDATE );
  922.                   ulSize += sizeof ( CDATE );
  923.                   ulSize += sizeof ( CDATE );
  924.                   ulSize += sizeof ( BOOL );
  925.                   ulSize += strlen ( pToDo->pszDo ) + 1;
  926.  
  927.                   ulSize += ( sizeof ( ULONG ) * TODO_COLS );
  928.                    
  929.                break;
  930.                 
  931.                case WID_LIST:
  932.                    
  933.                   pLst2 = (PLST2REC) pRecTmp;
  934.                    
  935.                   ulSize += strlen ( pLst2->psz1 ) + 1;
  936.                   ulSize += strlen ( pLst2->psz2 ) + 1;
  937.                    
  938.                   ulSize += sizeof ( CDATE );
  939.                    
  940.                break;
  941.                 
  942.                case WID_MINI:
  943.                    
  944.                   pMini = (PMINIREC) pRecTmp;
  945.                    
  946.                   ppszX = &pMini->psz01;
  947.                    
  948.                   pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  949.                                      NULL,
  950.                                      MPFROMSHORT( CMA_FIRST ) );
  951.                    
  952.                   for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  953.                   {
  954.                      ulSize += strlen ( *ppszX ) + 1;
  955.                       
  956.                      ++ppszX;
  957.  
  958.                      pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  959.                                         MPFROMP ( pfi ),
  960.                                         MPFROMSHORT( CMA_NEXT ) );
  961.                   }
  962.  
  963.                   ulSize += sizeof ( CDATE );
  964.                   ulSize += sizeof ( ULONG );
  965.  
  966.                break;
  967.                 
  968.             }
  969.              
  970.          break;
  971.           
  972.          case SCB_WRITE:
  973.              
  974.             switch ( lType ) 
  975.             {
  976.                case WID_ADDR:
  977.                    
  978.                   pAddr = (PADDRREC) pRecTmp;
  979.                    
  980.                   ulLen = strlen ( pAddr->pszFN ) + 1;
  981.                   memcpy ( pbDat, pAddr->pszFN, ulLen );
  982.                   pbDat += ulLen;
  983.                    
  984.                   ulLen = strlen ( pAddr->pszAC ) + 1;
  985.                   memcpy ( pbDat, pAddr->pszAC, ulLen );
  986.                   pbDat += ulLen;
  987.                    
  988.                   ulLen = strlen ( pAddr->pszPN ) + 1;
  989.                   memcpy ( pbDat, pAddr->pszPN, ulLen );
  990.                   pbDat += ulLen;
  991.                    
  992.                   ulLen = strlen ( pAddr->pszEx ) + 1;
  993.                   memcpy ( pbDat, pAddr->pszEx, ulLen );
  994.                   pbDat += ulLen;
  995.                    
  996.                   ulLen = strlen ( pAddr->pszAd ) + 1;
  997.                   memcpy ( pbDat, pAddr->pszAd, ulLen );
  998.                   pbDat += ulLen;
  999.                    
  1000.                   ulLen = strlen ( pAddr->pszNt ) + 1;
  1001.                   memcpy ( pbDat, pAddr->pszNt, ulLen );
  1002.                   pbDat += ulLen;
  1003.                    
  1004.                   ulLen = sizeof ( CDATE );
  1005.                   memcpy ( pbDat, &pAddr->cdUpd, ulLen );
  1006.                   pbDat += ulLen;
  1007.                    
  1008.                   ulLen = sizeof ( ULONG );
  1009.                   memcpy ( pbDat, &pAddr->ulOpt, ulLen );
  1010.                   pbDat += ulLen;
  1011.                    
  1012.                   ++ulSize;
  1013.                    
  1014.                break;
  1015.                 
  1016.                case WID_TODO:
  1017.                    
  1018.                   pToDo = (PTODOREC) pRecTmp;
  1019.                    
  1020.                   ulLen = sizeof ( CDATE );
  1021.                   memcpy ( pbDat, &pToDo->cdEnt, ulLen );
  1022.                   pbDat += ulLen;
  1023.                    
  1024.                   ulLen = sizeof ( CDATE );
  1025.                   memcpy ( pbDat, &pToDo->cdFin, ulLen );
  1026.                   pbDat += ulLen;
  1027.                    
  1028.                   ulLen = sizeof ( CDATE );
  1029.                   memcpy ( pbDat, &pToDo->cdTrg, ulLen );
  1030.                   pbDat += ulLen;
  1031.                    
  1032.                   ulLen = sizeof ( ULONG );
  1033.                   memcpy ( pbDat, &pToDo->ulOpt, ulLen );
  1034.                   pbDat += ulLen;
  1035.                    
  1036.                   ulLen = strlen ( pToDo->pszDo ) + 1;
  1037.                   memcpy ( pbDat, pToDo->pszDo, ulLen );
  1038.                   pbDat += ulLen;
  1039.                    
  1040.                   ++ulSize;
  1041.                    
  1042.                break;
  1043.                 
  1044.                case WID_LIST:
  1045.                    
  1046.                   pLst2 = (PLST2REC) pRecTmp;
  1047.                    
  1048.                   ulLen = strlen ( pLst2->psz1 ) + 1;
  1049.                   memcpy ( pbDat, pLst2->psz1, ulLen );
  1050.                   pbDat += ulLen;
  1051.                    
  1052.                   ulLen = strlen ( pLst2->psz2 ) + 1;
  1053.                   memcpy ( pbDat, pLst2->psz2, ulLen );
  1054.                   pbDat += ulLen;
  1055.                    
  1056.                   ulLen = sizeof ( CDATE );
  1057.                   memcpy ( pbDat, &pLst2->cdCur, ulLen );
  1058.                   pbDat += ulLen;
  1059.                    
  1060.                   ++ulSize;
  1061.                    
  1062.                break;
  1063.                 
  1064.                case WID_MINI:
  1065.                    
  1066.                   pMini = (PMINIREC) pRecTmp;
  1067.                    
  1068.                   pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  1069.                                      NULL,
  1070.                                      MPFROMSHORT( CMA_FIRST ) );
  1071.                    
  1072.                   ppszX = &pMini->psz01;
  1073.                    
  1074.                   for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  1075.                   {
  1076.                      ulLen = strlen ( *ppszX ) + 1;
  1077.                      memcpy ( pbDat, *ppszX, ulLen );
  1078.                      pbDat += ulLen;
  1079.                       
  1080.                      ++ppszX;
  1081.  
  1082.                      pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  1083.                                         MPFROMP ( pfi ),
  1084.                                         MPFROMSHORT( CMA_NEXT ) );
  1085.                   }
  1086.  
  1087.                   ulLen = sizeof ( CDATE );
  1088.                   memcpy ( pbDat, &pMini->cdUpd, ulLen );
  1089.                   pbDat += ulLen;
  1090.                    
  1091.                   ulLen = sizeof ( ULONG );
  1092.                   memcpy ( pbDat, &pMini->ulOpt, ulLen );
  1093.                   pbDat += ulLen;
  1094.                    
  1095.                   ++ulSize;
  1096.                    
  1097.                break;
  1098.                 
  1099.             }
  1100.              
  1101.          break;
  1102.           
  1103.          case SCB_FREE:
  1104.              
  1105.             switch ( lType ) 
  1106.             {
  1107.                case WID_ADDR:
  1108.                    
  1109.                   pAddr = (PADDRREC) pRecTmp;
  1110.                    
  1111.                   free ( pAddr->pszFN );
  1112.                   free ( pAddr->pszAC );
  1113.                   free ( pAddr->pszPN );
  1114.                   free ( pAddr->pszEx );
  1115.                   free ( pAddr->pszAd );
  1116.                   free ( pAddr->pszNt );
  1117.                    
  1118.                break;
  1119.                 
  1120.                case WID_TODO:
  1121.                    
  1122.                   pToDo = (PTODOREC) pRecTmp;
  1123.                    
  1124.                   free ( pToDo->pszDo );
  1125.                    
  1126.                break;
  1127.                 
  1128.                case WID_LIST:
  1129.                    
  1130.                   pLst2 = (PLST2REC) pRecTmp;
  1131.                    
  1132.                   free ( pLst2->psz1 );
  1133.                   free ( pLst2->psz2 );
  1134.                    
  1135.                break;
  1136.                 
  1137.                case WID_MINI:
  1138.                    
  1139.                   pMini = (PMINIREC) pRecTmp;
  1140.                    
  1141.                   ppszX = &pMini->psz01;
  1142.                    
  1143.                   for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  1144.                   {
  1145.                      free ( *ppszX );
  1146.                       
  1147.                      ++ppszX;
  1148.                   }
  1149.                    
  1150.                break;
  1151.                 
  1152.             }
  1153.              
  1154.          break;
  1155.           
  1156.       }
  1157.        
  1158.       pRecTmp = WinSendMsg ( hwnd, CM_QUERYRECORD,
  1159.                              MPFROMP ( pRecTmp ),
  1160.                              MPFROM2SHORT ( CMA_NEXT, CMA_ITEMORDER ) );
  1161.    }
  1162.     
  1163.    return ulSize;
  1164.     
  1165. }
  1166.  
  1167. /***************************************************************************/
  1168. /* Entry Utilities                                                         */
  1169. /***************************************************************************/
  1170. ULONG            pfnNodeUtil  ( PUSEREC pRecIn, LONG lFunc, LONG lType, MPARAM mp ) 
  1171. {
  1172.    ULONG          ulSize;
  1173.    ULONG          ulLen;
  1174.    BOOL           fbCase;
  1175.    PBYTE          pbDat;
  1176.    ULONG          ulOff;
  1177.    PDATREC        pdr;
  1178.    HWND           hwndEnt;
  1179.     
  1180.    /* Container Stuff */
  1181.     
  1182.    /*PUSEREC  pRecTmp;
  1183.    PADDRREC pAddr;
  1184.    PTODOREC pToDo;
  1185.    PLST2REC pLst2;*/
  1186.     
  1187.    ulSize = 0;
  1188.     
  1189.    pdr = pRecIn->pdr;
  1190.     
  1191.    pbDat = pdr->pvDat;
  1192.     
  1193.    switch ( lFunc ) 
  1194.    {
  1195.       case SCB_SEARCH:
  1196.       {
  1197.          SEARCHSTRING   cnrsd;
  1198.          MLE_SEARCHDATA mlesd;
  1199.          ULONG          ulSrchHow;
  1200.  
  1201.          mlesd.cb        = sizeof ( MLE_SEARCHDATA );
  1202.          mlesd.pchFind   = pszSearch;
  1203.          mlesd.cchFind   = strlen ( pszSearch );
  1204.          mlesd.iptStart  = 0;
  1205.          mlesd.iptStop   = -1;
  1206.           
  1207.          if ( ulTreeOpts & SCB_CASE )
  1208.             ulSrchHow = MLFSEARCH_CASESENSITIVE;
  1209.          else
  1210.             ulSrchHow = 0;//MLFSEARCH_SELECTMATCH;
  1211.           
  1212.          cnrsd.cb              = sizeof ( SEARCHSTRING );
  1213.          cnrsd.pszSearch       = pszSearch;
  1214.          cnrsd.fsPrefix        = FALSE;
  1215.          cnrsd.fsCaseSensitive = ( ulTreeOpts & SCB_CASE ) ? TRUE : FALSE;
  1216.          cnrsd.usView          = CV_DETAIL;
  1217.  
  1218.          switch ( pRecIn->ulType ) 
  1219.          {
  1220.             case WID_REFR:
  1221.             {
  1222.                PSZ   psz;
  1223.  
  1224.                if ( hwndEnt = pfnEntryOpen ( pRecIn, 0 ) )
  1225.                {
  1226.                   //*** Search EA's *****************************************************
  1227.                   ulLen = 0;
  1228.                   psz = 0;
  1229.                   pfnExportFromEF ( pRecIn->pdr->hwndE, DIT_REFR_SUBJECT, &psz, &ulLen, TRUE );
  1230.  
  1231.                   if ( pfnStrSearch ( psz, ulLen, pszSearch, 0, fbCase ) )
  1232.                      ulSize = 1L;
  1233.  
  1234.                   else if ( WinSendDlgItemMsg ( pRecIn->pdr->hwndE, DIT_REFR_KEYWRDS, MLM_SEARCH,
  1235.                                     MPFROMLONG ( ulSrchHow ), 
  1236.                                     MPFROMP ( &mlesd ) ) )
  1237.                      ulSize = 1L;
  1238.  
  1239.                   else if ( WinSendDlgItemMsg ( pRecIn->pdr->hwndE, DIT_REFR_COMMNTS, MLM_SEARCH,
  1240.                                     MPFROMLONG ( ulSrchHow ), 
  1241.                                     MPFROMP ( &mlesd ) ) )
  1242.                      ulSize = 1L;
  1243.                }
  1244.                else
  1245.                {
  1246.                   PREFRREC prr;
  1247.  
  1248.                   prr = pfnRefrLoadEntry ( pRecIn );
  1249.  
  1250.                   if ( ! prr )
  1251.                      ulSize = 0;
  1252.                   else
  1253.                   {
  1254.                      if ( pfnStrSearch ( prr->pszSub, 0, pszSearch, 0, fbCase ) )
  1255.                         ulSize = 1L;
  1256.  
  1257.                      else if ( pfnStrSearch ( prr->pszKey, 0, pszSearch, 0, fbCase ) )
  1258.                         ulSize = 1L;
  1259.  
  1260.                      else if ( pfnStrSearch ( prr->pszCom, 0, pszSearch, 0, fbCase ) )
  1261.                         ulSize = 1L;
  1262.  
  1263.                      pfnRefrFreeEntry ( prr );
  1264.                   }
  1265.                }
  1266.             }
  1267.             break;
  1268.  
  1269.             case WID_ADDR:
  1270.                 
  1271.                if ( hwndEnt = pfnEntryOpen ( pRecIn, 0 ) )
  1272.                {
  1273.                   if ( WinSendMsg ( pRecIn->pdr->hwndE, CM_SEARCHSTRING,
  1274.                                     MPFROMP ( &cnrsd ), 
  1275.                                     MPFROMLONG ( CMA_FIRST ) ) )
  1276.                      return 1L;
  1277.                   else
  1278.                      return 0;
  1279.                }
  1280.  
  1281.                //pAddr = (PADDRREC) pRecIn;
  1282.                 
  1283.                fbCase = ( ulTreeOpts & SCB_CASE ) ? TRUE : FALSE;
  1284.                 
  1285.                pdr = pRecIn->pdr;
  1286.                 
  1287.                pbDat = pdr->pvDat;
  1288.                 
  1289.                if ( ! pdr->ulDEnt )
  1290.                   break;
  1291.                 
  1292.                for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) 
  1293.                {
  1294.                   //*** pszFN ***********************************************
  1295.                    
  1296.                   ulLen = strlen ( pbDat ) + 1;     // pszFN
  1297.                    
  1298.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1299.                      return 1L;
  1300.                    
  1301.                   pbDat += ulLen;
  1302.                    
  1303.                   //*** pszAC ***********************************************
  1304.                    
  1305.                   ulLen = strlen ( pbDat ) + 1;     // pszAC
  1306.                    
  1307.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1308.                      return 1L;
  1309.                    
  1310.                   pbDat += ulLen;
  1311.                    
  1312.                   //*** pszPN ***********************************************
  1313.                    
  1314.                   ulLen = strlen ( pbDat ) + 1;     // pszPN
  1315.                    
  1316.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1317.                      return 1L;
  1318.                    
  1319.                   pbDat += ulLen;
  1320.                    
  1321.                   //*** pszEx ***********************************************
  1322.                    
  1323.                   ulLen = strlen ( pbDat ) + 1;     // pszEx
  1324.                    
  1325.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1326.                      return 1L;
  1327.                    
  1328.                   pbDat += ulLen;
  1329.                    
  1330.                   //*** pszAd ***********************************************
  1331.                    
  1332.                   ulLen = strlen ( pbDat ) + 1;     // pszAd
  1333.                    
  1334.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1335.                      return 1L;
  1336.                    
  1337.                   pbDat += ulLen;
  1338.                    
  1339.                   //*** pszNt ***********************************************
  1340.                    
  1341.                   ulLen = strlen ( pbDat ) + 1;     // pszNt
  1342.                    
  1343.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1344.                      return 1L;
  1345.                    
  1346.                   pbDat += ulLen;
  1347.                    
  1348.                   //*** cdUpd ***********************************************
  1349.                    
  1350.                   pbDat += sizeof ( CDATE );
  1351.                }
  1352.                 
  1353.             break;
  1354.              
  1355.             case WID_TODO:
  1356.                 
  1357.                //pAddr = (PADDRREC) pRecIn;
  1358.                 
  1359.                if ( hwndEnt = pfnEntryOpen ( pRecIn, 0 ) )
  1360.                {
  1361.                   if ( WinSendMsg ( pRecIn->pdr->hwndE, CM_SEARCHSTRING,
  1362.                                     MPFROMP ( &cnrsd ), 
  1363.                                     MPFROMLONG ( CMA_FIRST ) ) )
  1364.                      return 1L;
  1365.                   else
  1366.                      return 0;
  1367.                }
  1368.  
  1369.                fbCase = ( ulTreeOpts & SCB_CASE ) ? TRUE : FALSE;
  1370.                 
  1371.                pdr = pRecIn->pdr;
  1372.                 
  1373.                pbDat = pdr->pvDat;
  1374.                 
  1375.                if ( ! pdr->ulDEnt )
  1376.                   break;
  1377.                 
  1378.                for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) 
  1379.                {
  1380.                   //*** cdEnt ***********************************************
  1381.                    
  1382.                   pbDat += sizeof ( CDATE );
  1383.                    
  1384.                   //*** cdFin ***********************************************
  1385.                    
  1386.                   pbDat += sizeof ( CDATE );
  1387.                    
  1388.                   //*** cdTrg ***********************************************
  1389.                    
  1390.                   pbDat += sizeof ( CDATE );
  1391.                    
  1392.                   //*** pszDo ***********************************************
  1393.                    
  1394.                   ulLen = strlen ( pbDat ) + 1;
  1395.                    
  1396.                   if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) ) 
  1397.                      return 1L;
  1398.                    
  1399.                   pbDat += ulLen;
  1400.                }
  1401.                 
  1402.             break;
  1403.              
  1404.             case WID_MINI:
  1405.             {
  1406.                ULONG   ulCols;
  1407.                ULONG   ulX;
  1408.                ULONG   ulY;
  1409.                //ULONG   ulLen;
  1410.  
  1411.                //pAddr = (PADDRREC) pRecIn;
  1412.                 
  1413.                if ( hwndEnt = pfnEntryOpen ( pRecIn, 0 ) )
  1414.                {
  1415.                   if ( WinSendMsg ( pRecIn->pdr->hwndE, CM_SEARCHSTRING,
  1416.                                     MPFROMP ( &cnrsd ), 
  1417.                                     MPFROMLONG ( CMA_FIRST ) ) )
  1418.                      return 1L;
  1419.                   else
  1420.                      return 0;
  1421.                }
  1422.  
  1423.                fbCase = ( ulTreeOpts & SCB_CASE ) ? TRUE : FALSE;
  1424.                 
  1425.                pdr = pRecIn->pdr;
  1426.                 
  1427.                pbDat = pdr->pvDat;
  1428.                 
  1429.                if ( ! pdr->ulDEnt )
  1430.                   break;
  1431.                 
  1432.                memcpy ( &ulCols, pbDat, sizeof ( ULONG ) );
  1433.                 
  1434.                pbDat += sizeof ( ULONG );                 //*** ulCols
  1435.                pbDat += sizeof ( ULONG );                 //*** ulSplit
  1436.                pbDat += ( sizeof ( BYTE ) * MINI_SORTS ); //*** Sorts
  1437.                pbDat += ( sizeof ( BYTE ) * MINI_SORTS ); //*** Sort Opts
  1438.                 
  1439.                for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1440.                   pbDat += sizeof ( MCOLREC );            //*** Col Recs
  1441.                 
  1442.                for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1443.                   pbDat += strlen ( pbDat ) + 1;          //*** Col Titles
  1444.             
  1445.                for ( ulX = 0; ulX < pdr->ulDEnt; ++ulX )
  1446.                {
  1447.                   for ( ulY = 0; ulY < MINI_COLS; ++ulY )
  1448.                   {
  1449.                      ulLen = strlen ( pbDat ) + 1;
  1450.                       
  1451.                      if ( pfnStrSearch ( pbDat, ulLen, pszSearch, 0, fbCase ) )
  1452.                         return 1L;
  1453.                       
  1454.                      pbDat += ulLen;
  1455.                   }
  1456.                }
  1457.             }
  1458.             break;
  1459.              
  1460.             default:
  1461.                 
  1462.                //pAddr = (PADDRREC) pRecIn;
  1463.                 
  1464.                if ( hwndEnt = pfnEntryOpen ( pRecIn, 0  ) )
  1465.                {
  1466.                   if ( WinSendMsg ( pRecIn->pdr->hwndE, MLM_SEARCH,
  1467.                                     MPFROMLONG ( ulSrchHow ), 
  1468.                                     MPFROMP ( &mlesd ) ) )
  1469.                      return 1L;
  1470.                   else
  1471.                      return 0;
  1472.                }
  1473.  
  1474.                fbCase = ( ulTreeOpts & SCB_CASE ) ? TRUE : FALSE;
  1475.                 
  1476.                pdr = pRecIn->pdr;
  1477.                 
  1478.                pbDat = pdr->pvDat;
  1479.                 
  1480.                if ( ! pdr->ulDLen )
  1481.                   break;
  1482.                 
  1483.                if ( pfnStrSearch ( pbDat, pdr->ulDLen, pszSearch, 0, fbCase ) )
  1484.                   return 1L;
  1485.                 
  1486.             break;
  1487.          }
  1488.       }
  1489.       break;
  1490.        
  1491.    }
  1492.     
  1493.    return ulSize;
  1494. }
  1495.  
  1496. /***************************************************************************/
  1497. /* Set Default Tree Attributes                                             */
  1498. /***************************************************************************/
  1499. BOOL             pfnDefTree   ( PUSEREC pRecIn ) 
  1500. {
  1501.    PDATREC     pdr;
  1502.    ULONG       ulSize;
  1503.    DEFAULTREC  defRec;
  1504.    BOOL        fb;
  1505.     
  1506.    pdr = pRecIn->pdr;
  1507.     
  1508.    pdr->ulDLen  = 0;
  1509.    pdr->ulDEnt  = 0;
  1510.    pdr->ulOpts  = 0;
  1511.    pdr->ulStyl  = 0;
  1512.     
  1513.    ulSize = sizeof ( DEFAULTREC );
  1514.     
  1515.    fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, TREE_KEY,
  1516.                               &defRec, &ulSize );
  1517.  
  1518.    if ( fb )
  1519.    {
  1520.       pdr->fat    = defRec.fat;
  1521.       pdr->fxPtSz = defRec.fxPtSz;
  1522.        
  1523.       pdr->ulNBClr = defRec.ulNBClr;
  1524.       pdr->ulNFClr = defRec.ulNFClr;
  1525.       pdr->ulHBClr = defRec.ulHBClr;
  1526.       pdr->ulHFClr = defRec.ulHFClr;
  1527.    }
  1528.    else
  1529.    {
  1530.       pdr->ulNBClr = CLR_BACKGROUND;
  1531.       pdr->ulNFClr = CLR_NEUTRAL;
  1532.       pdr->ulHBClr = CLR_DARKGRAY;
  1533.       pdr->ulHFClr = CLR_BACKGROUND;
  1534.        
  1535.       pfnGetDefFattrs ( WinQueryWindow ( hwndM, QW_PARENT ), 
  1536.                         NULLHANDLE, &pdr->fat, &pdr->fxPtSz );
  1537.        
  1538.    }
  1539.    return TRUE;
  1540. }
  1541.  
  1542. /***************************************************************************/
  1543. /* Load Options from OS2.INI                                               */
  1544. /***************************************************************************/
  1545. BOOL             pfnLoadOpts  ( ) 
  1546. {
  1547.    ULONG    ulSize;
  1548.    BOOL     fb;
  1549.    ULONG    aulOpts[12];
  1550.    PBYTE    pBuf;
  1551.     
  1552.    ulSize = 12 * sizeof ( ULONG );
  1553.     
  1554.    fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, OPTS_KEY,
  1555.                               aulOpts, &ulSize );
  1556.    ulMDefCols = 3;
  1557.     
  1558.    if ( ! fb ) 
  1559.    {
  1560.       fb = FALSE;
  1561.        
  1562.       ulTreeOpts = SCB_ICONED  | SCB_TREELIN | SCB_MENUED |
  1563.                    SCB_PRTCONT | SCB_PRTHEAD | SCB_PRTPAGE| SCB_WINTASK;
  1564.       ulTextOpts = SCB_MENUED | SCB_TXTWRAP;
  1565.       ulAddrOpts = SCB_MENUED;
  1566.       ulToDoOpts = SCB_MENUED | SCB_STATED;// | SCB_PRICOLR;
  1567.       ulMiniOpts = SCB_MENUED;
  1568.       ulRefrOpts = SCB_REFR_DEFICON;
  1569.    }
  1570.    else 
  1571.    {
  1572.       fb = TRUE;
  1573.        
  1574.       ulTreeOpts = aulOpts[0];
  1575.       ulTextOpts = aulOpts[1];
  1576.       ulAddrOpts = aulOpts[2];
  1577.       ulToDoOpts = aulOpts[3];
  1578.       ulMiniOpts = aulOpts[5];
  1579.       ulRefrOpts = aulOpts[6];
  1580.    }
  1581.     
  1582.    PrfQueryProfileString ( HINI_USERPROFILE, PRG_TITLE, MOD_POR_KEY, "COM1",
  1583.                            achComX, 8 );
  1584.  
  1585.    PrfQueryProfileString ( HINI_USERPROFILE, PRG_TITLE, MOD_SET_KEY, "AT",
  1586.                            achComSet, 80 );
  1587.  
  1588.    PrfQueryProfileString ( HINI_USERPROFILE, PRG_TITLE, PRTQ_KEY, "",
  1589.                            pszQueueName, QNAME_LEN );
  1590.  
  1591.    pfnPrintInfo ( WinQueryWindow ( hwndM, QW_PARENT ), pszQueueName, &pqi );
  1592.     
  1593.    /*fb = */PrfQueryProfileSize ( HINI_USERPROFILE, PRG_TITLE, COL_LISTS, &ulSize );
  1594.  
  1595.    if ( /*! fb || */! ulSize )
  1596.    {
  1597.       colStrs.version = REL_REV;
  1598.       colStrs.regCode = UNREG_CODE;
  1599.  
  1600.       fbUnregistered = TRUE;
  1601.       fb = TRUE;
  1602.  
  1603.       colStrs.pszAddrName = strdup ( ADDR_COLTXT_NAME );
  1604.       colStrs.pszAddrArea = strdup ( ADDR_COLTXT_AREA );
  1605.       colStrs.pszAddrFone = strdup ( ADDR_COLTXT_FONE );
  1606.       colStrs.pszAddrExtn = strdup ( ADDR_COLTXT_EXTN );
  1607.       colStrs.pszAddrAddr = strdup ( ADDR_COLTXT_ADDR );
  1608.       colStrs.pszAddrNote = strdup ( ADDR_COLTXT_NOTE );
  1609.       colStrs.pszAddrDate = strdup ( ADDR_COLTXT_DATE );
  1610.       colStrs.ulAddrName  =          ADDR_COLLEN_NAME;
  1611.       colStrs.ulAddrArea  =          ADDR_COLLEN_AREA;
  1612.       colStrs.ulAddrFone  =          ADDR_COLLEN_FONE;
  1613.       colStrs.ulAddrExtn  =          ADDR_COLLEN_EXTN;
  1614.       colStrs.ulAddrAddr  =          ADDR_COLLEN_ADDR;
  1615.       colStrs.ulAddrNote  =          ADDR_COLLEN_NOTE;
  1616.       colStrs.ulAddrDate  =          ADDR_COLLEN_DATE;
  1617.  
  1618.       colStrs.pszToDoEntr = strdup ( TODO_COLTXT_ENTR );
  1619.       colStrs.pszToDoTarg = strdup ( TODO_COLTXT_TARG );
  1620.       colStrs.pszToDoDone = strdup ( TODO_COLTXT_DONE );
  1621.       colStrs.pszToDoPrio = strdup ( TODO_COLTXT_PRIO );
  1622.       colStrs.pszToDoIDid = strdup ( TODO_COLTXT_IDID );
  1623.       colStrs.pszToDoTask = strdup ( TODO_COLTXT_TASK );
  1624.       colStrs.pszToDoNote = strdup ( TODO_COLTXT_NOTE );
  1625.       colStrs.ulToDoEntr  =          TODO_COLLEN_ENTR;
  1626.       colStrs.ulToDoTarg  =          TODO_COLLEN_TARG;
  1627.       colStrs.ulToDoDone  =          TODO_COLLEN_DONE;
  1628.       colStrs.ulToDoPrio  =          TODO_COLLEN_PRIO;
  1629.       colStrs.ulToDoIDid  =          TODO_COLLEN_IDID;
  1630.       colStrs.ulToDoTask  =          TODO_COLLEN_TASK;
  1631.       colStrs.ulToDoNote  =          TODO_COLLEN_NOTE;
  1632.    }
  1633.    else
  1634.    {
  1635.       PBYTE pScn;
  1636.  
  1637.       pBuf = (PBYTE) malloc ( ulSize );
  1638.  
  1639.       fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, COL_LISTS,
  1640.                                  pBuf, &ulSize );
  1641.    
  1642.       colStrs.version = ((PCOLSTRS)pBuf)->version;
  1643.       colStrs.regCode = ((PCOLSTRS)pBuf)->regCode;
  1644.  
  1645.       if ( colStrs.regCode == UNREG_CODE )
  1646.          fbUnregistered = TRUE;
  1647.       else
  1648.          fbUnregistered = FALSE;
  1649.  
  1650.       pScn = pBuf;
  1651.  
  1652.       pScn += ( sizeof ( ULONG ) * 2 );
  1653.  
  1654.       colStrs.ulAddrName  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1655.       colStrs.ulAddrArea  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1656.       colStrs.ulAddrFone  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1657.       colStrs.ulAddrExtn  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1658.       colStrs.ulAddrAddr  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1659.       colStrs.ulAddrNote  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1660.       colStrs.ulAddrDate  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1661.  
  1662.       colStrs.ulToDoEntr  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1663.       colStrs.ulToDoTarg  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1664.       colStrs.ulToDoDone  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1665.       colStrs.ulToDoPrio  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1666.       colStrs.ulToDoIDid  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1667.       colStrs.ulToDoTask  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1668.       colStrs.ulToDoNote  = *((PULONG)pScn); pScn += sizeof (ULONG);
  1669.  
  1670.       colStrs.pszAddrName = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrName ) + 1 );
  1671.       colStrs.pszAddrArea = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrArea ) + 1 );
  1672.       colStrs.pszAddrFone = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrFone ) + 1 );
  1673.       colStrs.pszAddrExtn = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrExtn ) + 1 );
  1674.       colStrs.pszAddrAddr = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrAddr ) + 1 );
  1675.       colStrs.pszAddrNote = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrNote ) + 1 );
  1676.       colStrs.pszAddrDate = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszAddrDate ) + 1 );
  1677.                                                                                       
  1678.       colStrs.pszToDoEntr = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoEntr ) + 1 );
  1679.       colStrs.pszToDoTarg = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoTarg ) + 1 );
  1680.       colStrs.pszToDoDone = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoDone ) + 1 );
  1681.       colStrs.pszToDoPrio = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoPrio ) + 1 );
  1682.       colStrs.pszToDoIDid = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoIDid ) + 1 );
  1683.       colStrs.pszToDoTask = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoTask ) + 1 );
  1684.       colStrs.pszToDoNote = strdup ( (PSZ)pScn ); pScn += ( strlen ( colStrs.pszToDoNote ) + 1 );
  1685.  
  1686.       free ( pBuf );
  1687.    }
  1688.  
  1689.    return fb;
  1690. }
  1691.  
  1692. /***************************************************************************/
  1693. /* Save Options to OS2.INI                                                 */
  1694. /***************************************************************************/
  1695. BOOL             pfnSaveOpts  ( ) 
  1696. {
  1697.    ULONG    ulSize;
  1698.    ULONG    aulOpts[12];
  1699.    PBYTE    pBuf, pScn;
  1700.     
  1701.    aulOpts[0]  = ulTreeOpts;
  1702.    aulOpts[1]  = ulTextOpts;
  1703.    aulOpts[2]  = ulAddrOpts;
  1704.    aulOpts[3]  = ulToDoOpts;
  1705.    aulOpts[4]  = 0;//ulListOpts;
  1706.    aulOpts[5]  = ulMiniOpts;
  1707.    aulOpts[6]  = ulRefrOpts;
  1708.    aulOpts[7]  = 0;
  1709.    aulOpts[8]  = 0;
  1710.    aulOpts[9]  = 0;
  1711.    aulOpts[10] = 0;
  1712.    aulOpts[11] = 0;
  1713.     
  1714.    ulSize = 12 * sizeof ( ULONG );
  1715.     
  1716.    PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, OPTS_KEY,
  1717.                          aulOpts, ulSize );
  1718.     
  1719.    ulSize = sizeof ( ULONG ) * 16 +
  1720.             strlen ( colStrs.pszAddrName ) + 1 +
  1721.             strlen ( colStrs.pszAddrArea ) + 1 +
  1722.             strlen ( colStrs.pszAddrFone ) + 1 +
  1723.             strlen ( colStrs.pszAddrExtn ) + 1 +
  1724.             strlen ( colStrs.pszAddrAddr ) + 1 +
  1725.             strlen ( colStrs.pszAddrNote ) + 1 +
  1726.             strlen ( colStrs.pszAddrDate ) + 1 +
  1727.                
  1728.             strlen ( colStrs.pszToDoEntr ) + 1 +
  1729.             strlen ( colStrs.pszToDoTarg ) + 1 +
  1730.             strlen ( colStrs.pszToDoDone ) + 1 +
  1731.             strlen ( colStrs.pszToDoPrio ) + 1 +
  1732.             strlen ( colStrs.pszToDoIDid ) + 1 +
  1733.             strlen ( colStrs.pszToDoTask ) + 1 +
  1734.             strlen ( colStrs.pszToDoNote ) + 1;
  1735.  
  1736.    pBuf = (PBYTE) malloc ( ulSize );
  1737.  
  1738.    ((PCOLSTRS)pBuf)->version = REL_REV;
  1739.    ((PCOLSTRS)pBuf)->regCode = colStrs.regCode;
  1740.  
  1741.    if ( colStrs.regCode == UNREG_CODE )
  1742.       fbUnregistered = TRUE;
  1743.    else
  1744.       fbUnregistered = FALSE;
  1745.  
  1746.    pScn = pBuf;
  1747.  
  1748.    pScn += ( sizeof ( ULONG ) * 2 );
  1749.  
  1750.    *((PULONG)pScn) = colStrs.ulAddrName;  pScn += sizeof (ULONG);
  1751.    *((PULONG)pScn) = colStrs.ulAddrArea;  pScn += sizeof (ULONG);
  1752.    *((PULONG)pScn) = colStrs.ulAddrFone;  pScn += sizeof (ULONG);
  1753.    *((PULONG)pScn) = colStrs.ulAddrExtn;  pScn += sizeof (ULONG);
  1754.    *((PULONG)pScn) = colStrs.ulAddrAddr;  pScn += sizeof (ULONG);
  1755.    *((PULONG)pScn) = colStrs.ulAddrNote;  pScn += sizeof (ULONG);
  1756.    *((PULONG)pScn) = colStrs.ulAddrDate;  pScn += sizeof (ULONG);
  1757.                                         
  1758.    *((PULONG)pScn) = colStrs.ulToDoEntr;  pScn += sizeof (ULONG);
  1759.    *((PULONG)pScn) = colStrs.ulToDoTarg;  pScn += sizeof (ULONG);
  1760.    *((PULONG)pScn) = colStrs.ulToDoDone;  pScn += sizeof (ULONG);
  1761.    *((PULONG)pScn) = colStrs.ulToDoPrio;  pScn += sizeof (ULONG);
  1762.    *((PULONG)pScn) = colStrs.ulToDoIDid;  pScn += sizeof (ULONG);
  1763.    *((PULONG)pScn) = colStrs.ulToDoTask;  pScn += sizeof (ULONG);
  1764.    *((PULONG)pScn) = colStrs.ulToDoNote;  pScn += sizeof (ULONG);
  1765.  
  1766.    strcpy ( (PSZ)pScn, colStrs.pszAddrName ); pScn += ( strlen ( colStrs.pszAddrName ) + 1 );
  1767.    strcpy ( (PSZ)pScn, colStrs.pszAddrArea ); pScn += ( strlen ( colStrs.pszAddrArea ) + 1 );
  1768.    strcpy ( (PSZ)pScn, colStrs.pszAddrFone ); pScn += ( strlen ( colStrs.pszAddrFone ) + 1 );
  1769.    strcpy ( (PSZ)pScn, colStrs.pszAddrExtn ); pScn += ( strlen ( colStrs.pszAddrExtn ) + 1 );
  1770.    strcpy ( (PSZ)pScn, colStrs.pszAddrAddr ); pScn += ( strlen ( colStrs.pszAddrAddr ) + 1 );
  1771.    strcpy ( (PSZ)pScn, colStrs.pszAddrNote ); pScn += ( strlen ( colStrs.pszAddrNote ) + 1 );
  1772.    strcpy ( (PSZ)pScn, colStrs.pszAddrDate ); pScn += ( strlen ( colStrs.pszAddrDate ) + 1 );
  1773.                                                                                     
  1774.    strcpy ( (PSZ)pScn, colStrs.pszToDoEntr ); pScn += ( strlen ( colStrs.pszToDoEntr ) + 1 );
  1775.    strcpy ( (PSZ)pScn, colStrs.pszToDoTarg ); pScn += ( strlen ( colStrs.pszToDoTarg ) + 1 );
  1776.    strcpy ( (PSZ)pScn, colStrs.pszToDoDone ); pScn += ( strlen ( colStrs.pszToDoDone ) + 1 );
  1777.    strcpy ( (PSZ)pScn, colStrs.pszToDoPrio ); pScn += ( strlen ( colStrs.pszToDoPrio ) + 1 );
  1778.    strcpy ( (PSZ)pScn, colStrs.pszToDoIDid ); pScn += ( strlen ( colStrs.pszToDoIDid ) + 1 );
  1779.    strcpy ( (PSZ)pScn, colStrs.pszToDoTask ); pScn += ( strlen ( colStrs.pszToDoTask ) + 1 );
  1780.    strcpy ( (PSZ)pScn, colStrs.pszToDoNote ); pScn += ( strlen ( colStrs.pszToDoNote ) + 1 );
  1781.  
  1782.    PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, COL_LISTS,
  1783.                          pBuf, ulSize );
  1784.     
  1785.    free ( pBuf );
  1786.  
  1787.    return TRUE;
  1788. }
  1789.  
  1790. /***************************************************************************/
  1791. /* Settings Notebook Setup                                                 */
  1792. /***************************************************************************/
  1793. MRESULT EXPENTRY pfndpSettings( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  1794. {
  1795.    //POINTERINFO  pi;
  1796.     
  1797.    static HWND    hwndNB;
  1798.    static ULONG   ulIdMain;
  1799.    static ULONG   ulIdText;
  1800.    static ULONG   ulIdAddr;
  1801.    static ULONG   ulIdToDo;
  1802.    static ULONG   ulIdMini;
  1803.    static ULONG   ulIdRefr;
  1804.    static ULONG   ulIdPrnt;
  1805.  
  1806.    static ULONG   ulIdAddrCol;
  1807.    static ULONG   ulIdToDoCol;
  1808.     
  1809.    switch ( msg ) 
  1810.    {
  1811.       case WM_INITDLG:
  1812.       {
  1813.          ULONG        ulId;
  1814.          HWND         hwndTmp;
  1815.  
  1816.          hwndNB = WinWindowFromID ( hwnd, DIT_NBK );
  1817.           
  1818.          ulId = WinQueryWindowULong ( hwndNB, QWL_STYLE );
  1819.          ulId |= BKS_SPIRALBIND;
  1820.          WinSetWindowULong ( hwndNB, QWL_STYLE, ulId );
  1821.  
  1822.          WinSendMsg ( hwndNB, BKM_SETNOTEBOOKCOLORS,
  1823.                       MPFROMLONG ( SYSCLR_DIALOGBACKGROUND ),
  1824.                       MPFROMLONG ( BKA_BACKGROUNDPAGECOLOR ) );
  1825.          WinSendMsg ( hwndNB, BKM_SETNOTEBOOKCOLORS,
  1826.                       MPFROMLONG ( SYSCLR_DIALOGBACKGROUND ),
  1827.                       MPFROMLONG ( BKA_BACKGROUNDMAJORCOLOR ) );
  1828.          WinSendMsg ( hwndNB, BKM_SETNOTEBOOKCOLORS,
  1829.                       MPFROMLONG ( SYSCLR_DIALOGBACKGROUND ),
  1830.                       MPFROMLONG ( BKA_BACKGROUNDMINORCOLOR ) );
  1831.           
  1832.          WinSendMsg ( hwndNB, BKM_SETDIMENSIONS,
  1833.                       MPFROM2SHORT ( WinQuerySysValue ( HWND_DESKTOP, SV_CXICON ) +
  1834.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CXICON ) / 4,
  1835.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CYICON ) +
  1836.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CYICON ) / 4 ),
  1837.                       MPFROMSHORT ( BKA_MAJORTAB ) );
  1838.           
  1839.          WinSendMsg ( hwndNB, BKM_SETDIMENSIONS,
  1840.                       MPFROM2SHORT ( WinQuerySysValue ( HWND_DESKTOP, SV_CXICON ) +
  1841.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CXICON ) / 4,
  1842.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CYICON ) +
  1843.                                      WinQuerySysValue ( HWND_DESKTOP, SV_CYICON ) / 4 ),
  1844.                       MPFROMSHORT ( BKA_MINORTAB ) );
  1845.           
  1846.          inSettingsInit = TRUE;
  1847.  
  1848.          //*** Tree Window Page *********************************************
  1849.           
  1850.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1851.                                      NULL,
  1852.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | BKA_STATUSTEXTON,
  1853.                                                     BKA_LAST ) );
  1854.           
  1855.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_MAIN, NULL );
  1856.           
  1857.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1858.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1859.           
  1860.          WinSendMsg ( hwndNB, BKM_SETSTATUSLINETEXT,
  1861.                       MPFROMLONG ( ulId ), MPFROMP ( " " ) );
  1862.           
  1863.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1864.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_MAIN ) );
  1865.           
  1866.          ulIdMain = ulId;
  1867.  
  1868.           
  1869.          /*WinQueryPointerInfo ( hptr, &pi );
  1870.           
  1871.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  1872.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor));//hbmPointer is small
  1873.          */
  1874.           
  1875.          //*** Text Editor Page *********************************************
  1876.           
  1877.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1878.                                      NULL,
  1879.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1880.                                                     BKA_LAST ) );
  1881.           
  1882.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_TEXT, NULL );
  1883.           
  1884.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1885.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1886.           
  1887.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1888.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_TEXT ) );
  1889.           
  1890.          ulIdText = ulId;
  1891.           
  1892.          /*WinQueryPointerInfo ( hptrText, &pi );
  1893.           
  1894.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  1895.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  1896.          */
  1897.           
  1898.          //*** Address Book Page ********************************************
  1899.           
  1900.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1901.                                      NULL,
  1902.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1903.                                                     BKA_LAST ) );
  1904.           
  1905.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_ADDR, NULL );
  1906.           
  1907.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1908.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1909.           
  1910.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1911.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_ADDR ) );
  1912.           
  1913.          ulIdAddr = ulId;
  1914.           
  1915.          /*WinQueryPointerInfo ( hptrAddr, &pi );
  1916.           
  1917.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  1918.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  1919.          */
  1920.           
  1921.           
  1922.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1923.                                      NULL,
  1924.                                      MPFROM2SHORT ( BKA_MINOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1925.                                                     BKA_LAST ) );
  1926.           
  1927.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_ADDR_COL, NULL );
  1928.           
  1929.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1930.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1931.           
  1932.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1933.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_ADDR_COL ) );
  1934.           
  1935.          ulIdAddrCol = ulId;
  1936.           
  1937.           
  1938.          //*** To-Do List Page **********************************************
  1939.           
  1940.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1941.                                      NULL,
  1942.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1943.                                                     BKA_LAST ) );
  1944.           
  1945.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_TODO, NULL );
  1946.           
  1947.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1948.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1949.           
  1950.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1951.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_TODO ) );
  1952.           
  1953.          ulIdToDo = ulId;
  1954.           
  1955.          /*WinQueryPointerInfo ( hptrToDo, &pi );
  1956.           
  1957.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  1958.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  1959.          */
  1960.           
  1961.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1962.                                      NULL,
  1963.                                      MPFROM2SHORT ( BKA_MINOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1964.                                                     BKA_LAST ) );
  1965.           
  1966.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_TODO_COL, NULL );
  1967.           
  1968.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1969.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1970.           
  1971.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1972.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_TODO_COL ) );
  1973.           
  1974.          ulIdToDoCol = ulId;
  1975.           
  1976.           
  1977.          //*** Mini Page ****************************************************
  1978.           
  1979.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  1980.                                      NULL,
  1981.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  1982.                                                     BKA_LAST ) );
  1983.           
  1984.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_MINI, NULL );
  1985.           
  1986.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  1987.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  1988.           
  1989.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  1990.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_MINI ) );
  1991.           
  1992.          ulIdMini = ulId;
  1993.           
  1994.          /*WinQueryPointerInfo ( hptrList, &pi );
  1995.           
  1996.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  1997.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  1998.          */
  1999.  
  2000.          //*** Refr Page ****************************************************
  2001.           
  2002.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  2003.                                      NULL,
  2004.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  2005.                                                     BKA_LAST ) );
  2006.           
  2007.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_REFR, NULL );
  2008.           
  2009.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  2010.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  2011.           
  2012.          WinSendMsg ( hwndNB, BKM_SETPAGEDATA,
  2013.                       MPFROMLONG ( ulId ), MPFROMLONG ( DLG_NBK_REFR ) );
  2014.           
  2015.          ulIdRefr = ulId;
  2016.           
  2017.          /*WinQueryPointerInfo ( hptrList, &pi );
  2018.           
  2019.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  2020.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  2021.          */
  2022.  
  2023.          //*** Print Page ***************************************************
  2024.           
  2025.          ulId = (ULONG) WinSendMsg ( hwndNB, BKM_INSERTPAGE,
  2026.                                      NULL,
  2027.                                      MPFROM2SHORT ( BKA_MAJOR | BKA_AUTOPAGESIZE,// | //BKA_STATUSTEXTON,
  2028.                                                     BKA_LAST ) );
  2029.           
  2030.          hwndTmp = WinLoadDlg ( hwnd, hwnd, pfndpNotebook, 0, DLG_NBK_PRNT, NULL );
  2031.           
  2032.          WinSendMsg ( hwndNB, BKM_SETPAGEWINDOWHWND,
  2033.                       MPFROMLONG ( ulId ), MPFROMLONG ( hwndTmp ) );
  2034.           
  2035.          ulIdPrnt = ulId;
  2036.           
  2037.          /*WinQueryPointerInfo ( hptrList, &pi );
  2038.           
  2039.          WinSendMsg ( hwndNB, BKM_SETTABBITMAP,
  2040.                       MPFROMLONG ( ulId ), MPFROMLONG ( pi.hbmColor ));
  2041.          */
  2042.  
  2043.          inSettingsInit = FALSE;
  2044.  
  2045.       }
  2046.       break;
  2047.        
  2048.       case WM_DRAWITEM:
  2049.       {
  2050.          POWNERITEM   poi;
  2051.  
  2052.          poi = PVOIDFROMMP ( mp2 );
  2053.           
  2054.          WinFillRect ( poi->hps, &poi->rclItem, SYSCLR_BUTTONMIDDLE );//SYSCLR_PAGEBACKGROUND );
  2055.           
  2056.          if ( poi->hItem == ulIdMain )
  2057.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2058.                              hptr, DP_NORMAL );
  2059.          else if ( poi->hItem == ulIdText )
  2060.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2061.                              hptrText, DP_NORMAL );
  2062.          else if ( poi->hItem == ulIdAddr ) 
  2063.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2064.                              hptrAddr, DP_NORMAL );
  2065.          else if ( poi->hItem == ulIdToDo ) 
  2066.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2067.                              hptrToDo, DP_NORMAL );
  2068.          else if ( poi->hItem == ulIdMini )
  2069.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2070.                              hptrMini, DP_NORMAL );
  2071.          else if ( poi->hItem == ulIdRefr )
  2072.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2073.                              hptrRefr, DP_NORMAL );
  2074.          else if ( poi->hItem == ulIdPrnt )
  2075.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2076.                              hptrPrnt, DP_NORMAL );
  2077.          else if ( poi->hItem == ulIdToDoCol || poi->hItem == ulIdAddrCol )
  2078.             WinDrawPointer ( poi->hps, poi->rclItem.xLeft, poi->rclItem.yBottom,
  2079.                              hptrText, DP_NORMAL );
  2080.       }
  2081.       return ( MRESULT ) TRUE;
  2082.        
  2083.       case WM_SIZE:
  2084.           
  2085.          WinSetWindowPos ( hwndNB, 0, 0, 0,
  2086.                            SHORT1FROMMP ( mp2 ),
  2087.                            SHORT2FROMMP ( mp2 ),
  2088.                            SWP_SIZE | SWP_MOVE );
  2089.           
  2090.       break;
  2091.        
  2092.       case WM_SYSCOMMAND:
  2093.           
  2094.          if ( LONGFROMMP ( mp1 ) == SC_CLOSE )
  2095.          {
  2096.             pfnSaveOpts ();
  2097.          }
  2098.           
  2099.       return WinDefDlgProc ( hwnd, msg, mp1, mp2 );
  2100.        
  2101.       case UWM_PARAMS:
  2102.           
  2103.       break;
  2104.        
  2105.       case WM_COMMAND:
  2106.           
  2107.          switch ( SHORT1FROMMP ( mp1 ) ) 
  2108.          {
  2109.             case DID_OK:
  2110.             {
  2111.                WinPostMsg ( hwnd, WM_SYSCOMMAND, MPFROMLONG ( SC_CLOSE ), NULL );
  2112.             }
  2113.             break;
  2114.  
  2115.             case DIT_HELP:
  2116.             {
  2117.                ULONG ulPageId = (ULONG) WinSendMsg ( hwndNB, BKM_QUERYPAGEID,
  2118.                                                      MPFROMLONG ( 0 ), 
  2119.                                                      MPFROM2SHORT ( BKA_TOP, 0 ) );
  2120.  
  2121.                ulPageId = (ULONG) WinSendMsg ( hwndNB, BKM_QUERYPAGEDATA,
  2122.                                                MPFROMLONG ( ulPageId ), MPFROMLONG ( 0 ) );
  2123.       
  2124.                WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2125.                             MPFROM2SHORT ( ulPageId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  2126.             }
  2127.             break;
  2128.          }
  2129.           
  2130.       break;
  2131.        
  2132.       default:
  2133.       return WinDefDlgProc ( hwnd, msg, mp1, mp2 );
  2134.        
  2135.    }
  2136.     
  2137.      return ( MRESULT ) FALSE;
  2138. }
  2139.  
  2140. /***************************************************************************/
  2141. /* Settings Notebook Proc                                                  */
  2142. /***************************************************************************/
  2143.  
  2144. MRESULT EXPENTRY pfndpNotebook( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  2145. {
  2146.     
  2147.    switch ( msg ) 
  2148.    {
  2149.       case WM_INITDLG:
  2150.       {
  2151.          USHORT usDlgID = WinQueryWindowUShort ( hwnd, QWS_ID );
  2152.  
  2153.          
  2154.          switch ( usDlgID ) 
  2155.          {
  2156.          case DLG_NBK_MAIN:
  2157.          WinCheckButton ( hwnd, MID_TREE_ICON,      ( ulTreeOpts & SCB_ICONED  ) ? TRUE : FALSE );
  2158.          WinCheckButton ( hwnd, MID_MAIN_TREELINES, ( ulTreeOpts & SCB_TREELIN ) ? TRUE : FALSE );
  2159.          WinCheckButton ( hwnd, MID_MAIN_STATS,     ( ulTreeOpts & SCB_STATED  ) ? TRUE : FALSE );
  2160.          WinCheckButton ( hwnd, MID_MAIN_MENU,      ( ulTreeOpts & SCB_MENUED  ) ? TRUE : FALSE );
  2161.          WinCheckButton ( hwnd, MID_MAIN_WINOWN,    ( ulTreeOpts & SCB_WINOWN  ) ? TRUE : FALSE );
  2162.          WinCheckButton ( hwnd, MID_TREE_TITFILE,   ( ulTreeOpts & SCB_TITFILE ) ? TRUE : FALSE );
  2163.          WinCheckButton ( hwnd, MID_TREE_WINTASK,   ( ulTreeOpts & SCB_WINTASK ) ? TRUE : FALSE );
  2164.          WinCheckButton ( hwnd, MID_MAIN_DROPREFR,  ( ulTreeOpts & SCB_DROPREFR) ? TRUE : FALSE );
  2165.          break;
  2166.           
  2167.          case DLG_NBK_ADDR:
  2168.          WinCheckButton ( hwnd, MID_ADDR_STATS, ( ulAddrOpts & SCB_STATED )  ? TRUE : FALSE );
  2169.          WinCheckButton ( hwnd, MID_ADDR_MENU,  ( ulAddrOpts & SCB_MENUED )  ? TRUE : FALSE );
  2170.           
  2171.          WinSendDlgItemMsg ( hwnd, DIT_ADDR_COM_PORT,  EM_SETTEXTLIMIT, MPFROMSHORT ( 8 ), NULL );
  2172.          WinSendDlgItemMsg ( hwnd, DIT_ADDR_COM_SETUP, EM_SETTEXTLIMIT, MPFROMSHORT ( 80 ), NULL );
  2173.  
  2174.          WinSetDlgItemText ( hwnd, DIT_ADDR_COM_PORT,  achComX );
  2175.          WinSetDlgItemText ( hwnd, DIT_ADDR_COM_SETUP, achComSet );
  2176.          break;
  2177.  
  2178.          case DLG_NBK_TODO:
  2179.          WinCheckButton ( hwnd, MID_TODO_STATS,  ( ulToDoOpts & SCB_STATED  )  ? TRUE : FALSE );
  2180.          WinCheckButton ( hwnd, MID_TODO_MENU,   ( ulToDoOpts & SCB_MENUED  )  ? TRUE : FALSE );
  2181.          WinCheckButton ( hwnd, MID_TODO_PRICOLR,( ulToDoOpts & SCB_PRICOLR )  ? TRUE : FALSE );
  2182.          break;
  2183.           
  2184.          case DLG_NBK_MINI:
  2185.          WinCheckButton ( hwnd, MID_MINI_STATS, ( ulMiniOpts & SCB_STATED )  ? TRUE : FALSE );
  2186.          WinCheckButton ( hwnd, MID_MINI_MENU,  ( ulMiniOpts & SCB_MENUED )  ? TRUE : FALSE );
  2187.          break;
  2188.           
  2189.          case DLG_NBK_REFR:
  2190.          WinCheckButton ( hwnd, DIT_REFR_DEFICO,( ulRefrOpts & DIT_REFR_DEFICON )  ? TRUE : FALSE );
  2191.          break;
  2192.           
  2193.          case DLG_NBK_PRNT:
  2194.          WinCheckButton ( hwnd, DIT_PRTHEAD,    ( ulTreeOpts & SCB_PRTHEAD )  ? TRUE : FALSE );
  2195.          WinCheckButton ( hwnd, DIT_PRTPAGE,    ( ulTreeOpts & SCB_PRTPAGE )  ? TRUE : FALSE );
  2196.          break;
  2197.           
  2198.          case DLG_NBK_ADDR_COL:
  2199.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_NAME,     colStrs.pszAddrName );
  2200.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_AREA,     colStrs.pszAddrArea );
  2201.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_PHONE,    colStrs.pszAddrFone );
  2202.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_EXT,      colStrs.pszAddrExtn );
  2203.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_ADDRESS,  colStrs.pszAddrAddr );
  2204.          pfnImportToMLE ( hwnd, DIT_ADDR_TXT_NOTES,    colStrs.pszAddrNote );
  2205.          //pfnImportToMLE ( hwnd, DIT_ADDR_TXT_DATE,     colStrs.pszAddrDate );
  2206.          break;
  2207.  
  2208.          case DLG_NBK_TODO_COL:
  2209.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_ENTRY,    colStrs.pszToDoEntr );
  2210.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_TARGET,   colStrs.pszToDoTarg );
  2211.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_DONE,     colStrs.pszToDoDone );
  2212.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_PRIORITY, colStrs.pszToDoPrio );
  2213.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_ISDONE,   colStrs.pszToDoIDid );
  2214.          pfnImportToMLE ( hwnd, DIT_TODO_TXT_TASK,     colStrs.pszToDoTask );
  2215.          break;
  2216.          }
  2217.          //colStrs.pszToDoNote
  2218.       }
  2219.       break;
  2220.        
  2221.       case WM_COMMAND:
  2222.       {
  2223.          switch ( SHORT1FROMMP ( mp1 ) ) 
  2224.          {
  2225.             case DIT_FONTDEF_ALL: case DIT_FONTDEF_HED: case DIT_FONTDEF_CNT:
  2226.             {
  2227.                PSZ         pszKey;
  2228.                HPS         hps;
  2229.                HPS         hpsPrinter;
  2230.                DEFAULTREC  defRec;
  2231.                ULONG       ulSize;
  2232.                BOOL        fb;
  2233.       
  2234.                switch ( SHORT1FROMMP ( mp1 ) )
  2235.                {
  2236.                   case DIT_FONTDEF_ALL:
  2237.                      pszKey = FONT_ALL_KEY;
  2238.                   break;
  2239.                   case DIT_FONTDEF_HED:
  2240.                      pszKey = FONT_HED_KEY;
  2241.                   break;
  2242.                   case DIT_FONTDEF_CNT:
  2243.                      pszKey = FONT_CNT_KEY;
  2244.                   break;
  2245.                }
  2246.          
  2247.                ulSize = sizeof ( DEFAULTREC );
  2248.                 
  2249.                fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2250.                                           &defRec, &ulSize );
  2251.          
  2252.                if ( ! fb )
  2253.                {
  2254.                   pfnGetDefFattrs ( WinQueryWindow ( hwndM, QW_PARENT ), NULLHANDLE,
  2255.                                     &defRec.fat, &defRec.fxPtSz );
  2256.                    
  2257.                   defRec.ulOpts  = 0;
  2258.                   defRec.ulStyl  = 0;
  2259.                    
  2260.                   defRec.ulNBClr = CLR_BACKGROUND;
  2261.                   defRec.ulNFClr = CLR_NEUTRAL;
  2262.                   defRec.ulHBClr = CLR_DARKGRAY;
  2263.                   defRec.ulHFClr = CLR_BACKGROUND;
  2264.                }
  2265.  
  2266.                hps = WinGetPS ( hwnd );
  2267.  
  2268.                hpsPrinter = pfnCreatePS ( hwnd, &pqi );
  2269.  
  2270.                if ( pfnGetFont ( hwnd, hps, hpsPrinter, &defRec.fxPtSz, &defRec.fat ) )
  2271.                {
  2272.                   PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2273.                                         &defRec, sizeof ( DEFAULTREC ) );
  2274.                }
  2275.       
  2276.                WinReleasePS ( hps );
  2277.                pfnDestroyPS ( hpsPrinter );
  2278.             }
  2279.             break;
  2280.              
  2281.             case MID_TREE_FONT: case MID_ADDR_FONT: case MID_TODO_FONT:
  2282.             case MID_MINI_FONT: case MID_TEXT_FONT:
  2283.             {
  2284.                PSZ         pszKey;
  2285.                HPS         hps;
  2286.                DEFAULTREC  defRec;
  2287.                ULONG       ulSize;
  2288.                BOOL        fb;
  2289.       
  2290.                switch ( SHORT1FROMMP ( mp1 ) )
  2291.                {
  2292.                   case MID_TREE_FONT:
  2293.                      pszKey = TREE_KEY;
  2294.                   break;
  2295.                   case MID_ADDR_FONT:
  2296.                      pszKey = ADDR_KEY;
  2297.                   break;
  2298.                   case MID_TODO_FONT:
  2299.                      pszKey = TODO_KEY;
  2300.                   break;
  2301.                   case MID_MINI_FONT:
  2302.                      pszKey = MINI_KEY;
  2303.                   break;
  2304.                   case MID_TEXT_FONT:
  2305.                      pszKey = TEXT_KEY;
  2306.                   break;
  2307.                }
  2308.          
  2309.                ulSize = sizeof ( DEFAULTREC );
  2310.                 
  2311.                fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2312.                                           &defRec, &ulSize );
  2313.          
  2314.                if ( ! fb )
  2315.                {
  2316.                   pfnGetDefFattrs ( WinQueryWindow ( hwndM, QW_PARENT ), NULLHANDLE,
  2317.                                     &defRec.fat, &defRec.fxPtSz );
  2318.                    
  2319.                   defRec.ulOpts  = 0;
  2320.                   defRec.ulStyl  = 0;
  2321.                    
  2322.                   defRec.ulNBClr = CLR_BACKGROUND;
  2323.                   defRec.ulNFClr = CLR_NEUTRAL;
  2324.                   defRec.ulHBClr = CLR_DARKGRAY;
  2325.                   defRec.ulHFClr = CLR_BACKGROUND;
  2326.                }
  2327.  
  2328.                hps = WinGetPS ( hwnd );
  2329.  
  2330.                if ( pfnGetFont ( hwnd, hps, NULLHANDLE, &defRec.fxPtSz, &defRec.fat ) )
  2331.                {
  2332.                   PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2333.                                         &defRec, sizeof ( DEFAULTREC ) );
  2334.                }
  2335.       
  2336.                WinReleasePS ( hps );
  2337.             }
  2338.             break;
  2339.              
  2340.             case MID_TREE_COLOR: case MID_ADDR_COLOR: case MID_TODO_COLOR:
  2341.             case MID_MINI_COLOR: case MID_TEXT_COLOR:
  2342.             {
  2343.                PSZ         pszKey;
  2344.                DEFAULTREC  defRec;
  2345.                ULONG       ulSize;
  2346.                BOOL        fb;
  2347.                HWND        hwndTmp;
  2348.       
  2349.                switch ( SHORT1FROMMP ( mp1 ) )
  2350.                {
  2351.                   case MID_TREE_COLOR:
  2352.                      pszKey = TREE_KEY;
  2353.                   break;
  2354.                   case MID_ADDR_COLOR:
  2355.                      pszKey = ADDR_KEY;
  2356.                   break;
  2357.                   case MID_TODO_COLOR:
  2358.                      pszKey = TODO_KEY;
  2359.                   break;
  2360.                   case MID_MINI_COLOR:
  2361.                      pszKey = MINI_KEY;
  2362.                   break;
  2363.                   case MID_TEXT_COLOR:
  2364.                      pszKey = TEXT_KEY;
  2365.                   break;
  2366.                }
  2367.          
  2368.                ulSize = sizeof ( DEFAULTREC );
  2369.                 
  2370.                fb = PrfQueryProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2371.                                           &defRec, &ulSize );
  2372.          
  2373.                if ( ! fb )
  2374.                {
  2375.                   pfnGetDefFattrs ( WinQueryWindow ( hwndM, QW_PARENT ), NULLHANDLE,
  2376.                                     &defRec.fat, &defRec.fxPtSz );
  2377.                    
  2378.                   defRec.ulOpts  = 0;
  2379.                   defRec.ulStyl  = 0;
  2380.                    
  2381.                   defRec.ulNBClr = CLR_BACKGROUND;
  2382.                   defRec.ulNFClr = CLR_NEUTRAL;
  2383.                   defRec.ulHBClr = CLR_DARKGRAY;
  2384.                   defRec.ulHFClr = CLR_BACKGROUND;
  2385.                }
  2386.  
  2387.                hwndTmp = WinCreateWindow ( hwnd, WC_STATIC, " ",
  2388.                                            SS_TEXT | DT_LEFT,
  2389.                                            0, 0, 0, 0, hwnd, HWND_TOP, 200, NULL, NULL );
  2390.           
  2391.                WinSetPresParam ( hwndTmp, PP_BACKGROUNDCOLORINDEX,       4L, &defRec.ulNBClr );
  2392.                WinSetPresParam ( hwndTmp, PP_FOREGROUNDCOLORINDEX,       4L, &defRec.ulNFClr );
  2393.                WinSetPresParam ( hwndTmp, PP_HILITEBACKGROUNDCOLORINDEX, 4L, &defRec.ulHBClr );
  2394.                WinSetPresParam ( hwndTmp, PP_HILITEFOREGROUNDCOLORINDEX, 4L, &defRec.ulHFClr );
  2395.  
  2396.                if ( WinDlgBox ( HWND_DESKTOP, hwnd, pfndpColors, 0L, 
  2397.                                 DLG_COLORS, &hwndTmp ) )
  2398.                {
  2399.                   WinQueryPresParam ( hwndTmp, PP_BACKGROUNDCOLORINDEX,       0, NULL, 4L, &defRec.ulNBClr, QPF_NOINHERIT );
  2400.                   WinQueryPresParam ( hwndTmp, PP_FOREGROUNDCOLORINDEX,       0, NULL, 4L, &defRec.ulNFClr, QPF_NOINHERIT );
  2401.                   WinQueryPresParam ( hwndTmp, PP_HILITEBACKGROUNDCOLORINDEX, 0, NULL, 4L, &defRec.ulHBClr, QPF_NOINHERIT );
  2402.                   WinQueryPresParam ( hwndTmp, PP_HILITEFOREGROUNDCOLORINDEX, 0, NULL, 4L, &defRec.ulHFClr, QPF_NOINHERIT );
  2403.  
  2404.                   PrfWriteProfileData ( HINI_USERPROFILE, PRG_TITLE, pszKey,
  2405.                                         &defRec, sizeof ( DEFAULTREC ) );
  2406.                }
  2407.  
  2408.                WinDestroyWindow ( hwndTmp );
  2409.             }
  2410.             break;
  2411.          }
  2412.  
  2413.       }
  2414.       break;
  2415.        
  2416.       case WM_HELP:
  2417.       {
  2418.          SHORT   sId;
  2419.  
  2420.          sId = WinQueryWindowUShort ( hwnd, QWS_ID );
  2421.  
  2422.          WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2423.                       MPFROM2SHORT ( sId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  2424.       }
  2425.       break;
  2426.        
  2427.       case WM_CONTROL:
  2428.       {
  2429.          USHORT  usWinType;
  2430.          USHORT  usChecked;
  2431.          ULONG   ulLen;
  2432.          USHORT  usDlgID = WinQueryWindowUShort ( hwnd, QWS_ID );
  2433.  
  2434.          if ( SHORT2FROMMP ( mp1 ) == BKN_HELP )
  2435.          {
  2436.             ULONG ulPageId = LONGFROMMP ( mp2 );
  2437.              
  2438.             WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2439.                          MPFROMSHORT ( ulPageId ), MPFROMSHORT ( HM_RESOURCEID ) );
  2440.          }
  2441.          switch ( SHORT1FROMMP ( mp1 ) ) 
  2442.          {
  2443.             //*** Tree Win **************************************************
  2444.                 
  2445.             case MID_TREE_ICON:    case MID_MAIN_TREELINES:  case MID_MAIN_STATS:
  2446.             case MID_MAIN_MENU:    case MID_MAIN_WINOWN:     case MID_MAIN_1TXTICO:
  2447.             case MID_TREE_TITFILE: case MID_TREE_WINTASK:    case MID_MAIN_DROPREFR:
  2448.             {
  2449.                usWinType = WinQueryWindowUShort ( hwnd, QWS_ID );
  2450.                 
  2451.                usWinType = WID_MAIN;
  2452.             }
  2453.             break;
  2454.              
  2455.             //*** Addr Win **************************************************
  2456.                 
  2457.             case MID_ADDR_STATS: case MID_ADDR_MENU: case DIT_ADDR_ENTER_DIAL:
  2458.             {
  2459.                usWinType = WinQueryWindowUShort ( hwnd, QWS_ID );
  2460.                 
  2461.                usWinType = WID_ADDR;
  2462.             }
  2463.             break;
  2464.              
  2465.             case DIT_ADDR_COM_PORT:
  2466.             {
  2467.                if ( SHORT2FROMMP ( mp1 ) == EN_KILLFOCUS &&
  2468.                     WinSendDlgItemMsg ( hwnd, SHORT1FROMMP ( mp1 ),
  2469.                                         EM_QUERYCHANGED, NULL, NULL ) )
  2470.                {
  2471.                   WinQueryDlgItemText ( hwnd, DIT_ADDR_COM_PORT, 8, achComX );
  2472.       
  2473.                   PrfWriteProfileString ( HINI_USERPROFILE, PRG_TITLE, MOD_POR_KEY,
  2474.                                           achComX );
  2475.                }
  2476.             }
  2477.             break;
  2478.  
  2479.             case DIT_ADDR_COM_SETUP:
  2480.             {
  2481.                if ( SHORT2FROMMP ( mp1 ) == EN_KILLFOCUS &&
  2482.                     WinSendDlgItemMsg ( hwnd, SHORT1FROMMP ( mp1 ),
  2483.                                         EM_QUERYCHANGED, NULL, NULL ) )
  2484.                {
  2485.                   WinQueryDlgItemText ( hwnd, DIT_ADDR_COM_SETUP, 80, achComSet );
  2486.       
  2487.                   PrfWriteProfileString ( HINI_USERPROFILE, PRG_TITLE, MOD_SET_KEY,
  2488.                                           achComSet );
  2489.                }
  2490.             }
  2491.             break;
  2492.  
  2493.             //*** Addr Columns **********************************************
  2494.                 
  2495.             case DIT_ADDR_TXT_NAME:
  2496.             {
  2497.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2498.                {
  2499.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrName, &ulLen, FALSE );
  2500.                }
  2501.             }
  2502.             break;
  2503.             case DIT_ADDR_TXT_AREA:
  2504.             {
  2505.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2506.                {
  2507.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrArea, &ulLen, FALSE  );
  2508.                }
  2509.             }
  2510.             break;
  2511.             case DIT_ADDR_TXT_PHONE:
  2512.             {
  2513.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2514.                {
  2515.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrFone, &ulLen, FALSE  );
  2516.                }
  2517.             }
  2518.             break;
  2519.             case DIT_ADDR_TXT_EXT:
  2520.             {
  2521.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2522.                {
  2523.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrExtn, &ulLen, FALSE  );
  2524.                }
  2525.             }
  2526.             break;
  2527.             case DIT_ADDR_TXT_ADDRESS:
  2528.             {
  2529.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2530.                {
  2531.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrAddr, &ulLen, FALSE  );
  2532.                }
  2533.             }
  2534.             break;
  2535.             case DIT_ADDR_TXT_NOTES:
  2536.             {
  2537.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_ADDR_COL )
  2538.                {
  2539.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszAddrNote, &ulLen, FALSE  );
  2540.                }
  2541.             }
  2542.             break;
  2543.  
  2544.             //*** ToDo Win **************************************************
  2545.                 
  2546.             case MID_TODO_STATS: case MID_TODO_MENU: case MID_TODO_PRICOLR:
  2547.             {
  2548.                usWinType = WinQueryWindowUShort ( hwnd, QWS_ID );
  2549.                 
  2550.                usWinType = WID_TODO;
  2551.             }
  2552.             break;
  2553.              
  2554.             //*** ToDo Columns **********************************************
  2555.                 
  2556.             case DIT_TODO_TXT_ENTRY:
  2557.             {
  2558.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2559.                {
  2560.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoEntr, &ulLen, FALSE  );
  2561.                }
  2562.             }
  2563.             break;
  2564.             case DIT_TODO_TXT_TARGET:
  2565.             {
  2566.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2567.                {
  2568.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoTarg, &ulLen, FALSE  );
  2569.                }
  2570.             }
  2571.             break;
  2572.             case DIT_TODO_TXT_DONE:
  2573.             {
  2574.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2575.                {
  2576.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoDone, &ulLen, FALSE  );
  2577.                }
  2578.             }
  2579.             break;
  2580.             case DIT_TODO_TXT_PRIORITY:
  2581.             {
  2582.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2583.                {
  2584.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoPrio, &ulLen, FALSE  );
  2585.                }
  2586.             }
  2587.             break;
  2588.             case DIT_TODO_TXT_ISDONE:
  2589.             {
  2590.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2591.                {
  2592.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoIDid, &ulLen, FALSE  );
  2593.                }
  2594.             }
  2595.             break;
  2596.             case DIT_TODO_TXT_TASK:
  2597.             {
  2598.                if ( SHORT2FROMMP ( mp1 ) == MLN_KILLFOCUS && ! inSettingsInit && usDlgID == DLG_NBK_TODO_COL )
  2599.                {
  2600.                   pfnExportFromMLE ( hwnd, SHORT1FROMMP(mp1), &colStrs.pszToDoTask, &ulLen, FALSE  );
  2601.                }
  2602.             }
  2603.             break;
  2604.  
  2605.             //*** Mini Win **************************************************
  2606.                 
  2607.             case MID_MINI_STATS: case MID_MINI_MENU:
  2608.             {
  2609.                usWinType = WinQueryWindowUShort ( hwnd, QWS_ID );
  2610.                 
  2611.                usWinType = WID_MINI;
  2612.             }
  2613.             break;
  2614.              
  2615.             //*** Refr Win **************************************************
  2616.                 
  2617.             case DIT_REFR_DEFICO:
  2618.             {
  2619.                usWinType = WinQueryWindowUShort ( hwnd, QWS_ID );
  2620.                 
  2621.                usWinType = WID_REFR;
  2622.             }
  2623.             break;
  2624.              
  2625.             //*** Text Win **************************************************
  2626.                 
  2627.             case MID_TEXT_WRAP:
  2628.             {
  2629.                usWinType = WID_TEXT;
  2630.             }
  2631.             break;
  2632.              
  2633.             case DIT_PRTHEAD: case DIT_PRTPAGE:
  2634.             {
  2635.                usWinType = WID_PRNT;
  2636.             }
  2637.             break;
  2638.  
  2639.          }
  2640.           
  2641.          //******************************************************************
  2642.                 
  2643.          if ( SHORT2FROMMP ( mp1 ) == BN_CLICKED ) 
  2644.          {
  2645.             usChecked = WinQueryButtonCheckstate ( hwnd, SHORT1FROMMP ( mp1 ) );
  2646.              
  2647.             WinSendMsg ( hwndM, UWM_SETTING,
  2648.                          MPFROM2SHORT ( usWinType, SHORT1FROMMP ( mp1 ) ),
  2649.                          MPFROM2SHORT ( usChecked, 0 ) );
  2650.          }
  2651.          else if ( SHORT2FROMMP ( mp1 ) == BKN_HELP )
  2652.          {
  2653.             ULONG ulPageId = LONGFROMMP ( mp2 );
  2654.              
  2655.             WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2656.                          MPFROMSHORT ( ulPageId ), MPFROMSHORT ( HM_RESOURCEID ) );
  2657.          }
  2658.       }
  2659.       break;
  2660.        
  2661.       default:
  2662.       return WinDefDlgProc ( hwnd, msg, mp1, mp2 );
  2663.        
  2664.    }
  2665.     
  2666.      return ( MRESULT ) FALSE;
  2667. }
  2668.  
  2669. //****************************************************************************
  2670. // Print Dialog
  2671. //****************************************************************************
  2672. MRESULT EXPENTRY pfndpPrint     ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 )
  2673. {      
  2674.    HWND        hwndT;
  2675.    SHORT       sX;
  2676.    MRESULT     mr   = MRFROMLONG ( FALSE );
  2677.  
  2678.    PPRQINFO3   ppqiScn;
  2679.  
  2680.    static      PPRQINFO3  ppqiBuf;
  2681.    static      TID        tid;
  2682.    static      PFNTHREAD  pfnThread;
  2683.    //static      ULONG      ulPrinted;
  2684.  
  2685.    switch ( msg )
  2686.    {
  2687.       case WM_INITDLG:
  2688.       {
  2689.          ULONG     ulReturned;
  2690.          ULONG     ulTotal;
  2691.          ULONG     ulBufSize;
  2692.          BOOL      fbDefFound;
  2693.  
  2694.          fbPrinting = FALSE;
  2695.          //ulPrinted = 0;
  2696.  
  2697.          pfnThread = (PFNTHREAD) PVOIDFROMMP ( mp2 );
  2698.  
  2699.          //*** Init Global Print Control Structure **************************
  2700.  
  2701.          pfnNewPrintCtl ( hwnd );
  2702.  
  2703.          //*** Get Queue List ***********************************************
  2704.  
  2705.          SplEnumQueue ( NULL, 3, NULL, 0,
  2706.                         &ulReturned, &ulTotal, &ulBufSize, NULL );
  2707.  
  2708.          ppqiBuf = (PPRQINFO3) malloc ( ulBufSize );
  2709.  
  2710.          SplEnumQueue ( NULL, 3, ppqiBuf, ulBufSize,
  2711.                         &ulReturned, &ulTotal, &ulBufSize, NULL );
  2712.  
  2713.          //*** Set up Queue List ********************************************
  2714.  
  2715.          fbDefFound = FALSE;
  2716.  
  2717.          hwndT = WinWindowFromID ( hwnd, DIT_QUEUES );
  2718.  
  2719.          ppqiScn = ppqiBuf;
  2720.  
  2721.          for ( sX = 0; sX < ulReturned; ++sX )
  2722.          {
  2723.             if ( *ppqiScn->pszComment )
  2724.                mr = WinSendMsg ( hwndT, LM_INSERTITEM, 
  2725.                                  MPFROMLONG ( LIT_SORTASCENDING ),
  2726.                                  MPFROMP ( ppqiScn->pszComment ) );
  2727.             else
  2728.                mr = WinSendMsg ( hwndT, LM_INSERTITEM, 
  2729.                                  MPFROMLONG ( LIT_SORTASCENDING ),
  2730.                                  MPFROMP ( ppqiScn->pszName ) );
  2731.  
  2732.             WinSendMsg ( hwndT, LM_SETITEMHANDLE, mr, MPFROMLONG ( sX ) );
  2733.         
  2734.             if ( ! strcmp ( ppqiScn->pszName,    pszQueueName ) )
  2735.             {
  2736.                //ppqiDef = ppqiScn;
  2737.                fbDefFound = TRUE;
  2738.                WinSendMsg ( hwndT, LM_SELECTITEM,
  2739.                             mr, MPFROMLONG ( TRUE ) );
  2740.             }
  2741.  
  2742.             ++ppqiScn;
  2743.          }
  2744.  
  2745.          //*** Init Dialog Controls *****************************************
  2746.  
  2747.          WinCheckButton ( hwnd, DIT_PRTHEAD, ( ulTreeOpts & SCB_PRTHEAD ) ? TRUE : FALSE );
  2748.          WinCheckButton ( hwnd, DIT_PRTPAGE, ( ulTreeOpts & SCB_PRTPAGE ) ? TRUE : FALSE );
  2749.  
  2750.          if ( ! fbDefFound )
  2751.             WinSendMsg ( hwndT, LM_SELECTITEM,
  2752.                          MPFROMLONG ( 0 ), MPFROMLONG ( TRUE ) );
  2753.  
  2754.          WinSendDlgItemMsg ( hwnd, DIT_SLDR, SLM_SETSLIDERINFO,
  2755.                              MPFROM2SHORT ( SMA_SHAFTPOSITION, 0 ), 
  2756.                              MPFROMSHORT ( 0 ) );
  2757.           
  2758.          mr = MRFROMLONG ( FALSE );//TRUE );
  2759.       }
  2760.       break;
  2761.  
  2762.       case WM_HELP:
  2763.       {
  2764.          SHORT   sId;
  2765.  
  2766.          sId = WinQueryWindowUShort ( hwnd, QWS_ID );
  2767.  
  2768.          WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2769.                       MPFROM2SHORT ( sId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  2770.       }
  2771.       break;
  2772.        
  2773.       case WM_COMMAND:
  2774.       {
  2775.          switch ( SHORT1FROMMP ( mp1 ) )
  2776.          {
  2777.             case DIT_HELP:
  2778.             {
  2779.                SHORT   sId;
  2780.       
  2781.                sId = WinQueryWindowUShort ( hwnd, QWS_ID );
  2782.       
  2783.                WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  2784.                             MPFROM2SHORT ( sId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  2785.             }
  2786.             break;
  2787.              
  2788.             case DIT_FONT_P:
  2789.             {
  2790.                HPS   hps = WinGetPS ( hwnd );
  2791.  
  2792.                pprtCtl->hpsPrinter = pfnCreatePS ( hwnd, &pqi );
  2793.  
  2794.                if ( pfnGetFont ( hwnd, hps, pprtCtl->hpsPrinter,
  2795.                                  &pprtCtl->defPrtAll.fxPtSz, 
  2796.                                  &pprtCtl->defPrtAll.fat ) )
  2797.                {
  2798.                   pprtCtl->fbNewFont = TRUE;
  2799.                }
  2800.  
  2801.                pfnDestroyPS ( pprtCtl->hpsPrinter );
  2802.  
  2803.                WinReleasePS ( hps );
  2804.             }
  2805.             break;
  2806.              
  2807.             case DIT_JOBPROP:
  2808.             {
  2809.                PSZ  pszDriverName;
  2810.                PSZ  pszDeviceName;
  2811.                PSZ  pszTemp;
  2812.  
  2813.                hwndT = WinWindowFromID ( hwnd, DIT_QUEUES );
  2814.       
  2815.                mr = WinSendMsg ( hwndT, LM_QUERYSELECTION, 
  2816.                                  MPFROMLONG ( LIT_FIRST ), NULL );
  2817.                mr = WinSendMsg ( hwndT, LM_QUERYITEMHANDLE, mr, NULL );
  2818.       
  2819.                ppqiScn = ppqiBuf;
  2820.                ppqiScn += (SHORT)mr;
  2821.  
  2822.                pszDriverName = strdup ( ppqiScn->pszDriverName );
  2823.                pszDeviceName = strdup ( ppqiScn->pszDriverName );
  2824.  
  2825.                sX = strcspn ( pszDriverName, "." );
  2826.  
  2827.                if ( sX )
  2828.                {
  2829.                   pszDriverName[sX] = '\0';
  2830.  
  2831.                   strcpy ( pszDeviceName, &pszDriverName[sX + 1] );
  2832.                }
  2833.                else
  2834.                {
  2835.                   *pszDeviceName = '\0';
  2836.                }
  2837.             
  2838.                pszTemp = strchr ( ppqiScn->pszPrinters, ',' );
  2839.  
  2840.                if ( pszTemp )
  2841.                {
  2842.                   *pszTemp = '\0' ;
  2843.                }
  2844.             
  2845.                DevPostDeviceModes ( WinQueryAnchorBlock ( hwnd ),
  2846.                                     ppqiScn->pDriverData,
  2847.                                     pszDriverName,
  2848.                                     pszDeviceName,
  2849.                                     ppqiScn->pszPrinters,
  2850.                                     DPDM_POSTJOBPROP );
  2851.             }
  2852.             break;
  2853.  
  2854.             case DID_OK:
  2855.             {
  2856.                ULONG lPelsX;
  2857.                ULONG lPelsY;
  2858.  
  2859.                DosResetEventSem ( evtThdDone, &lPelsY );
  2860.  
  2861.                WinEnableWindow ( WinWindowFromID ( hwnd, DID_OK     ), FALSE );
  2862.                WinEnableWindow ( WinWindowFromID ( hwnd, DIT_FONT_P ), FALSE );
  2863.                WinEnableWindow ( WinWindowFromID ( hwnd, DIT_JOBPROP), FALSE );
  2864. //               WinEnableWindow ( WinWindowFromID ( hwnd, DID_CANCEL ), FALSE );
  2865.  
  2866.                pfnCanCloseWin ( hwnd, TRUE, FALSE );
  2867.  
  2868.                if ( WinQueryButtonCheckstate ( hwnd, DIT_PRTHEAD ) )
  2869.                   ulTreeOpts |= SCB_PRTHEAD;
  2870.                else
  2871.                   ulTreeOpts &= ~SCB_PRTHEAD;
  2872.  
  2873.                if ( WinQueryButtonCheckstate ( hwnd, DIT_PRTPAGE ) )
  2874.                   ulTreeOpts |= SCB_PRTPAGE;
  2875.                else
  2876.                   ulTreeOpts &= ~SCB_PRTPAGE;
  2877.  
  2878.                hwndT = WinWindowFromID ( hwnd, DIT_QUEUES );
  2879.  
  2880.                mr = WinSendMsg ( hwndT, LM_QUERYSELECTION, 
  2881.                                  MPFROMLONG ( LIT_FIRST ), NULL );
  2882.                mr = WinSendMsg ( hwndT, LM_QUERYITEMHANDLE, mr, NULL );
  2883.       
  2884.                ppqiScn = ppqiBuf;
  2885.                ppqiScn += (SHORT)mr;
  2886.  
  2887.                strcpy ( pszQueueName, ppqiScn->pszName );
  2888.  
  2889.                PrfWriteProfileString ( HINI_USERPROFILE, PRG_TITLE, PRTQ_KEY,
  2890.                                        pszQueueName );
  2891.       
  2892.                pfnPrintQFree ( &pqi );
  2893.                pfnPrintQDupe ( &pqi, ppqiScn );
  2894.  
  2895.                free ( ppqiBuf );
  2896.  
  2897.                //*** Initialize Print Variables *****************************
  2898.  
  2899.                pprtCtl->hpsPrinter = pfnPrintStart ( hwnd, &pqi, APP_TITLE );
  2900.             
  2901.                if ( ! pprtCtl->hpsPrinter )
  2902.                {
  2903.                   pfnMsgOK ( hwnd, APP_TITLE, "Error starting print job." );
  2904.  
  2905.                   free ( ppqiBuf );
  2906.                   free ( pprtCtl );
  2907.    
  2908.                   WinDismissDlg ( hwnd, FALSE );
  2909.                }
  2910.             
  2911.                pfnPrintCurrForm  ( hwnd, pprtCtl->hpsPrinter, &pprtCtl->hci, TRUE );
  2912.                pfnPelsPerInch    ( hwnd, pprtCtl->hpsPrinter, &lPelsX, &lPelsY );
  2913.             
  2914.                if ( pprtCtl->hci.xLeftClip < lPelsX )
  2915.                   pprtCtl->hci.xLeftClip = lPelsX;
  2916.             
  2917.                if ( pprtCtl->hci.yTopClip > pprtCtl->hci.yPels - lPelsY )
  2918.                   pprtCtl->hci.yTopClip = pprtCtl->hci.yPels - lPelsY;
  2919.             
  2920.  
  2921.                pfnCvtVecFont     ( pprtCtl->hpsPrinter, 
  2922.                                    pprtCtl->defPrtHed.fxPtSz, 
  2923.                                    &pprtCtl->defPrtHed.fat );
  2924.                pfnSetPaintFont   ( hwnd, pprtCtl->hpsPrinter, 
  2925.                                    &pprtCtl->defPrtHed.fat, FONTID_HED );
  2926.  
  2927.                GpiQueryFontMetrics ( pprtCtl->hpsPrinter, sizeof ( FONTMETRICS ), 
  2928.                                      &pprtCtl->fmHed );
  2929.  
  2930.                pfnCvtVecFont     ( pprtCtl->hpsPrinter, 
  2931.                                    pprtCtl->defPrtCnt.fxPtSz,
  2932.                                    &pprtCtl->defPrtCnt.fat );
  2933.                pfnSetPaintFont   ( hwnd, pprtCtl->hpsPrinter, 
  2934.                                    &pprtCtl->defPrtCnt.fat, FONTID_CNT );
  2935.  
  2936.                GpiQueryFontMetrics ( pprtCtl->hpsPrinter, sizeof ( FONTMETRICS ), 
  2937.                                      &pprtCtl->fmCnt );
  2938.  
  2939.                pfnPrintBounds    ( hwnd );
  2940.  
  2941.                fbPrinting = TRUE;
  2942.  
  2943.                //DosCreateThread ( &tid, (PFNTHREAD)pfnThread, 0L, 0L, 2000000 );
  2944.                tid = _beginthread ( (VOID (*_Optlink)(PVOID))pfnThread,
  2945.                                     NULL, 
  2946.                                     1024000,
  2947.                                     NULL );
  2948.  
  2949.                //WinDismissDlg ( hwnd, TRUE );
  2950.             }
  2951.             break;
  2952.  
  2953.             case DID_CANCEL:
  2954.             {
  2955.                if ( fbPrinting )
  2956.                {
  2957.                   fbPrinting = FALSE;
  2958.  
  2959.                   //DosWaitThread ( &tid, DCWW_WAIT );
  2960.                   DosWaitEventSem ( evtThdDone, 20000 );
  2961.                   //if ( ! DosKillThread ( tid ) )
  2962.                      pfnPrintStop ( hwnd, pprtCtl->hpsPrinter, FALSE );
  2963.                }
  2964.  
  2965.                free ( ppqiBuf );
  2966.                free ( pprtCtl );
  2967.  
  2968.                WinDismissDlg ( hwnd, FALSE );
  2969.             }
  2970.             break;
  2971.          }
  2972.       }
  2973.       break;
  2974.  
  2975.       case UWM_STAT:
  2976.       {
  2977.          ULONG   ulPrinted = LONGFROMMP ( mp1 );
  2978.          ULONG   ulTotal   = LONGFROMMP ( mp2 );
  2979.              
  2980.          WinSendDlgItemMsg ( hwnd, DIT_SLDR, SLM_SETSLIDERINFO,
  2981.                              MPFROM2SHORT ( SMA_SLIDERARMPOSITION, SMA_INCREMENTVALUE ),
  2982.                              MPFROMLONG ( ulPrinted * 100L / ulTotal ) );
  2983.       }
  2984.       break;
  2985.  
  2986.       case UWM_DONE:
  2987.       {
  2988.          WinSendDlgItemMsg ( hwnd, DIT_SLDR, SLM_SETSLIDERINFO,
  2989.                              MPFROM2SHORT ( SMA_SHAFTPOSITION, 0 ), 
  2990.                              MPFROMLONG ( 99 ) );
  2991.           
  2992.          pfnPrintStop ( hwnd, pprtCtl->hpsPrinter, TRUE );
  2993.  
  2994.          free ( ppqiBuf );
  2995.          free ( pprtCtl );
  2996.  
  2997.          DosSleep ( 500 );
  2998.  
  2999.          WinDismissDlg ( hwnd, TRUE );
  3000.       }
  3001.       break;
  3002.        
  3003.       case UWM_ERROR:
  3004.       {
  3005. //         pfnMsgOK ( hwnd, APP_TITLE, "Print job terminated due to error" );
  3006.  
  3007.          free ( pprtCtl );
  3008.  
  3009.          WinDismissDlg ( hwnd, FALSE );
  3010.       }
  3011.       break;
  3012.        
  3013.       default:
  3014.       {
  3015.          mr = WinDefDlgProc ( hwnd, msg, mp1, mp2 );
  3016.       }
  3017.       break;
  3018.    }
  3019.    return mr;
  3020. }
  3021.  
  3022.