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