home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: InfoMgt / InfoMgt.zip / code25.zip / fspmini.c < prev    next >
C/C++ Source or Header  |  1995-10-13  |  127KB  |  3,688 lines
  1.  
  2. #define VAR_SCOPE extern
  3.  
  4. #include "fsp.h"
  5.  
  6. //*** #define's ************************************************************* */
  7.  
  8. #define UWM_SHOW    WM_USER+1
  9.  
  10. #define MINI_ATTR   1
  11. #define MINI_SHOW   2
  12.  
  13. //*** typedef's ************************************************************* */
  14.  
  15. typedef struct _MAINTREC 
  16. {
  17.    MINIRECORDCORE  crecCore;
  18.    //ULONG           ulX;
  19.    PMCOLREC    pcol;
  20.  
  21. }  MAINTREC, *PMAINTREC;
  22.  
  23. //*** Prototypes ************************************************************ */
  24.  
  25. MRESULT EXPENTRY pfndpColMaint   ( HWND, ULONG, MPARAM, MPARAM );
  26.  
  27. BOOL             pfnSetSplit     ( HWND, PDATREC, BOOL );
  28. USHORT           pfnWhichSplit   ( HWND, PDATREC, SHORT, PMCTLREC );
  29. PFIELDINFO       pfnCol2FInfo    ( HWND, PMCOLREC, PFIELDINFO, PFIELDINFO );
  30. ULONG            pfnMiniRecMem   ( HWND, PMINIREC, ULONG, PBYTE );
  31.  
  32. BOOL             pfnMiniStat     ( PUSEREC );
  33. PBYTE            pfnMiniCont     ( HWND, PUSEREC );
  34. VOID             pfnMiniMenu     ( PUSEREC, HWND, SHORT );
  35. VOID             pfnInitStrings  ( PMINIREC );
  36.  
  37. VOID             pfnMiniNewPage  ( BOOL );
  38. VOID             pfnMiniPrintInit( VOID );
  39.  
  40. SHORT   APIENTRY pfnMiniSort     ( PRECORDCORE, PRECORDCORE, PVOID );
  41. VOID             pfnMiniPrtThd   ( PVOID );
  42.  
  43. /***************************************************************************/
  44. /* Mini Window Proc                                                        */
  45. /***************************************************************************/
  46. MRESULT EXPENTRY pfnwpMiniWin ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  47. {
  48.    PUSEREC    pRecScn = WinQueryWindowPtr ( hwnd, 0 );
  49.     
  50.    switch ( msg ) 
  51.    {
  52.       case WM_CREATE:
  53.           
  54.       break;
  55.        
  56.       case WM_ACTIVATE:
  57.           
  58.          if ( SHORT1FROMMP ( mp1 ) ) 
  59.          {
  60.             hwndFoc = HWNDFROMMP ( mp2 );
  61.              
  62.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  63.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  64.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  65.          }
  66.          else 
  67.          {
  68.             hwndFoc = HWNDFROMMP ( mp2 );
  69.              
  70.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  71.                          NULL, NULL );
  72.          }
  73.           
  74.       break;
  75.        
  76.       case WM_SIZE:
  77.           
  78.          if ( pRecScn )
  79.             WinSetWindowPos ( pRecScn->pdr->hwndE, 0, 0, 0,
  80.                               SHORT1FROMMP ( mp2 ),
  81.                               SHORT2FROMMP ( mp2 ),
  82.                               SWP_SHOW | SWP_SIZE | SWP_MOVE );
  83.           
  84.       break;
  85.        
  86.       case UWM_SETRECPTR: //*** Store Data Pointer **************************
  87.       {
  88.          pRecScn = PVOIDFROMMP ( mp1 );
  89.           
  90.          WinSetWindowPtr ( hwnd, 0, pRecScn );
  91.       }
  92.       break;
  93.  
  94.       case UWM_PARAMS:                  
  95.       {
  96.          ULONG             ulX;
  97.          PBYTE             pbDat;
  98.          ULONG             ulLen;
  99.          PMINIREC          pNew;
  100.          RECORDINSERT      recins;
  101.          PDATREC           pdr;
  102.  
  103.          //*** Store Data Pointer *******************************************
  104.           
  105.          pRecScn = PVOIDFROMMP ( mp1 );
  106.           
  107.          WinSetWindowPtr ( hwnd, 0, pRecScn );
  108.           
  109.          pdr = pRecScn->pdr;
  110.           
  111.          pdr->pvWork = malloc ( sizeof ( MCTLREC ) );
  112.           
  113.          memset ( pdr->pvWork, 0, sizeof ( MCTLREC ) );
  114.           
  115.          //*** Frame ********************************************************
  116.           
  117.          pfnSetWinPos ( hwnd, pdr );
  118.           
  119.          pdr->hwndM = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU );
  120.           
  121.          pdr->pszStat = malloc ( 80 );
  122.           
  123.          pbDat = pfnMiniCont ( hwnd, pRecScn );
  124.  
  125.          //*** Insert Data **************************************************
  126.           
  127.          for ( ulX = 0; ulX < pdr->ulDEnt; ++ulX )
  128.          {
  129.             pNew = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  130.                                 MPFROMLONG (sizeof(MINIREC)-sizeof(RECORDCORE)),
  131.                                 MPFROMSHORT( 1 ) );
  132.              
  133.             //*** Init Record ***********************************************
  134.              
  135.             ulLen = strlen ( pbDat ) + 1;
  136.             pNew->psz01 = malloc ( ulLen );
  137.             strcpy ( pNew->psz01, pbDat );
  138.             pbDat += ulLen;
  139.              
  140.             ulLen = strlen ( pbDat ) + 1;
  141.             pNew->psz02 = malloc ( ulLen );
  142.             strcpy ( pNew->psz02, pbDat );
  143.             pbDat += ulLen;
  144.              
  145.             ulLen = strlen ( pbDat ) + 1;
  146.             pNew->psz03 = malloc ( ulLen );
  147.             strcpy ( pNew->psz03, pbDat );
  148.             pbDat += ulLen;
  149.              
  150.             ulLen = strlen ( pbDat ) + 1;
  151.             pNew->psz04 = malloc ( ulLen );
  152.             strcpy ( pNew->psz04, pbDat );
  153.             pbDat += ulLen;
  154.              
  155.             ulLen = strlen ( pbDat ) + 1;
  156.             pNew->psz05 = malloc ( ulLen );
  157.             strcpy ( pNew->psz05, pbDat );
  158.             pbDat += ulLen;
  159.              
  160.             ulLen = strlen ( pbDat ) + 1;
  161.             pNew->psz06 = malloc ( ulLen );
  162.             strcpy ( pNew->psz06, pbDat );
  163.             pbDat += ulLen;
  164.              
  165.             ulLen = strlen ( pbDat ) + 1;
  166.             pNew->psz07 = malloc ( ulLen );
  167.             strcpy ( pNew->psz07, pbDat );
  168.             pbDat += ulLen;
  169.              
  170.             ulLen = strlen ( pbDat ) + 1;
  171.             pNew->psz08 = malloc ( ulLen );
  172.             strcpy ( pNew->psz08, pbDat );
  173.             pbDat += ulLen;
  174.              
  175.             ulLen = strlen ( pbDat ) + 1;
  176.             pNew->psz09 = malloc ( ulLen );
  177.             strcpy ( pNew->psz09, pbDat );
  178.             pbDat += ulLen;
  179.              
  180.             ulLen = strlen ( pbDat ) + 1;
  181.             pNew->psz10 = malloc ( ulLen );
  182.             strcpy ( pNew->psz10, pbDat );
  183.             pbDat += ulLen;
  184.              
  185.             ulLen = strlen ( pbDat ) + 1;
  186.             pNew->psz11 = malloc ( ulLen );
  187.             strcpy ( pNew->psz11, pbDat );
  188.             pbDat += ulLen;
  189.              
  190.             ulLen = strlen ( pbDat ) + 1;
  191.             pNew->psz12 = malloc ( ulLen );
  192.             strcpy ( pNew->psz12, pbDat );
  193.             pbDat += ulLen;
  194.              
  195.             ulLen = strlen ( pbDat ) + 1;
  196.             pNew->psz13 = malloc ( ulLen );
  197.             strcpy ( pNew->psz13, pbDat );
  198.             pbDat += ulLen;
  199.              
  200.             ulLen = strlen ( pbDat ) + 1;
  201.             pNew->psz14 = malloc ( ulLen );
  202.             strcpy ( pNew->psz14, pbDat );
  203.             pbDat += ulLen;
  204.              
  205.             ulLen = strlen ( pbDat ) + 1;
  206.             pNew->psz15 = malloc ( ulLen );
  207.             strcpy ( pNew->psz15, pbDat );
  208.             pbDat += ulLen;
  209.              
  210.             ulLen = strlen ( pbDat ) + 1;
  211.             pNew->psz16 = malloc ( ulLen );
  212.             strcpy ( pNew->psz16, pbDat );
  213.             pbDat += ulLen;
  214.              
  215.             memcpy ( &pNew->cdUpd, pbDat, sizeof ( CDATE ) );
  216.             pbDat += sizeof ( CDATE );
  217.              
  218.             memcpy ( &pNew->ulOpt, pbDat, sizeof ( ULONG ) );
  219.             pbDat += sizeof ( ULONG );
  220.  
  221.             //*** Insert ****************************************************
  222.              
  223.             recins.cb                = sizeof ( RECORDINSERT );
  224.             recins.pRecordParent     = (PRECORDCORE) NULL;
  225.             recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  226.             recins.zOrder            = CMA_TOP;
  227.             recins.cRecordsInsert    = 1;
  228.             recins.fInvalidateRecord = TRUE;
  229.              
  230.             WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  231.                          MPFROMP( pNew ), MPFROMP ( &recins ) );
  232.          }
  233.           
  234.          pdr->ulOpts |= SCB_OPENED;
  235.           
  236.          pdr->fbModified = FALSE;
  237.           
  238.          pfnMiniStat ( pRecScn );
  239.  
  240.          //*** Create & Init Search *****************************************
  241.           
  242.          pRecScn->pdr->psSrch = malloc ( sizeof ( SRCHREC ) );
  243.           
  244.          memset ( pRecScn->pdr->psSrch, 0, sizeof ( SRCHREC ) );
  245.           
  246.          pRecScn->pdr->psSrch->hwndE = hwnd;
  247.           
  248.          pRecScn->pdr->psSrch->fbIsCn = TRUE;
  249.           
  250.          pRecScn->pdr->psSrch->pszFnd = malloc ( 1 );
  251.  
  252.          *pRecScn->pdr->psSrch->pszFnd = 0;
  253.       }
  254.       break;
  255.        
  256.       case WM_INITMENU:
  257.       {
  258.          HWND    hwndMenu;
  259.  
  260.          WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  261.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  262.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  263.           
  264.          hwndMenu = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU);
  265.  
  266.          pfnMiniMenu ( pRecScn, hwndMenu, SHORT1FROMMP ( mp1 ) );
  267.       }
  268.       break;
  269.        
  270.       case WM_HELP:
  271.       {
  272.          SHORT   sId;
  273.  
  274.          sId = WinQueryWindowUShort ( hwnd, QWS_ID );
  275.  
  276.          WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  277.                       MPFROM2SHORT ( sId, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  278.       }
  279.       break;
  280.        
  281.       case WM_COMMAND:
  282.           
  283.          if ( SHORT1FROMMP(mp1) != MID_MINI_NEXT &&
  284.               SHORT1FROMMP(mp1) != MID_MINI_PREV &&
  285.               SHORT1FROMMP(mp1) != MID_MINI_STOP &&
  286.               pRecScn->pdr->fbEditing ) {
  287.              
  288.             WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  289.              
  290.          }
  291.           
  292.          switch ( SHORT1FROMMP ( mp1 ) ) 
  293.          {
  294.             case MID_MINI_SAVE:
  295.                 
  296.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  297.                 
  298.             break;
  299.              
  300.             case MID_MINI_EXIT:
  301.  
  302.                WinPostMsg ( WinQueryWindow(hwnd,QW_PARENT), WM_SYSCOMMAND, MPFROM2SHORT ( SC_CLOSE, 0 ), NULL );
  303.  
  304.             break;
  305.              
  306.             case MID_MINI_SAVE_EXIT:
  307.  
  308.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  309.                WinPostMsg ( WinQueryWindow(hwnd,QW_PARENT), WM_SYSCOMMAND, MPFROM2SHORT ( SC_CLOSE, 0 ), NULL );
  310.  
  311.             break;
  312.              
  313.             case MID_MINI_SETTINGS:
  314.                 
  315.                if ( WinDlgBox ( HWND_DESKTOP, hwnd, pfndpColMaint,
  316.                                 0L, DLG_COLMAINT, pRecScn ) ) 
  317.                {
  318.                   pRecScn->pdr->fbModified = TRUE;
  319.                   //fbModified = TRUE;
  320.                }
  321.                 
  322.             break;
  323.              
  324.             case MID_MINI_ADD:
  325.             {
  326.                PMINIREC           pNew;
  327.                PMINIREC           pFoc;
  328.                RECORDINSERT       recins;
  329.  
  330.                //*** Allocate & Init Rec ************************************
  331.                 
  332.                pFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  333.                                    MPFROMLONG ( CMA_FIRST ),
  334.                                    MPFROMSHORT( CRA_SELECTED ) );
  335.                 
  336.                pNew = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  337.                                    MPFROMLONG (sizeof(MINIREC)-sizeof(RECORDCORE)),
  338.                                    MPFROMSHORT( 1 ) );
  339.  
  340.                pfnInitStrings ( pNew );
  341.                 
  342.                pfnSetWhen ( &pNew->cdUpd, NULL );
  343.  
  344.                pNew->ulOpt = 0;
  345.  
  346.                //*** Insert *************************************************
  347.                 
  348.                recins.cb                = sizeof ( RECORDINSERT );
  349.                recins.pRecordParent     = NULL;
  350.                 
  351.                if ( pFoc )
  352.                   recins.pRecordOrder = (PRECORDCORE) pFoc;
  353.                else 
  354.                   recins.pRecordOrder = (PRECORDCORE) CMA_END;
  355.                 
  356.                recins.zOrder            = CMA_TOP;
  357.                recins.cRecordsInsert    = 1;
  358.                recins.fInvalidateRecord = TRUE;
  359.                 
  360.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  361.                             MPFROMP( pNew ), MPFROMP ( &recins ) );
  362.                 
  363.                pRecScn->pdr->fbModified = TRUE;
  364.                //fbModified = TRUE;
  365.                 
  366.                ++pRecScn->pdr->ulDEnt;
  367.                 
  368.                pfnMiniStat ( pRecScn );
  369.                 
  370.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  371.                             MPFROMP ( pNew ),
  372.                             MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  373.                 
  374.                WinPostMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_MINI_BEGN, 0 ), NULL );
  375.                 
  376.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  377.             }
  378.             break;
  379.              
  380.             case MID_MINI_DELT:
  381.             {
  382.                PMINIREC           pFoc;
  383.  
  384.                pFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  385.                                    MPFROMLONG ( CMA_FIRST ),
  386.                                    MPFROMSHORT( CRA_SELECTED ) );
  387.                 
  388.                WinSendMsg ( pRecScn->pdr->hwndE, CM_REMOVERECORD,
  389.                             MPFROMP ( &pFoc ),
  390.                             MPFROM2SHORT( 1, CMA_FREE | CMA_INVALIDATE ) );
  391.                 
  392.                pRecScn->pdr->fbModified = TRUE;
  393.                //fbModified = TRUE;
  394.                 
  395.                --pRecScn->pdr->ulDEnt;
  396.                 
  397.                pfnMiniStat ( pRecScn );
  398.             }
  399.             break;
  400.              
  401.             case MID_MINI_SORT:
  402.                 
  403.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SORTRECORD,
  404.                             MPFROMP ( pfnMiniSort ),
  405.                             MPFROMP ( pRecScn->pdr->pvWork ) );
  406.                 
  407.                pRecScn->pdr->fbModified = TRUE;
  408.                //fbModified = TRUE;
  409.                 
  410.             break;
  411.              
  412.             case MID_MINI_FONT:
  413.             {
  414.                PDATREC   pdr = pRecScn->pdr;
  415.                HPS       hps = WinGetPS ( pdr->hwndE );
  416.  
  417.                if ( pfnGetFont ( hwnd, hps, NULLHANDLE, &pdr->fxPtSz, &pdr->fat ) )
  418.                {
  419.                   pfnSetPPFont ( pdr->hwndE, pdr->fxPtSz, &pdr->fat );
  420.                }
  421.  
  422.                WinReleasePS ( hps );
  423.             }
  424.             break;
  425.              
  426.             case MID_MINI_COLOR:
  427.             {
  428.                PDATREC            pdr;
  429.  
  430.                pdr = pRecScn->pdr;
  431.                 
  432.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpColors, 0L, DLG_COLORS, &pdr->hwndE );
  433.             }
  434.             break;
  435.              
  436.             case MID_MINI_TITLE:
  437.             {
  438.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpSetTitle, 0L, DLG_SET_TITLE, pRecScn );
  439.             }
  440.             break;
  441.              
  442.             case MID_MINI_PRINT:
  443.             {
  444.                pRecPrt = pRecScn;
  445.  
  446.                WinDlgBox ( HWND_DESKTOP, hwnd, pfndpPrint,  0L,
  447.                            DLG_PRINT, (PVOID) pfnMiniPrtThd );
  448.             }
  449.             break;
  450.              
  451.             case MID_MINI_FIND:
  452.                 
  453.                WinLoadDlg ( HWND_DESKTOP, hwnd, pfndpSearch, 0L, DLG_SEARCH, 
  454.                             pRecScn->pdr->psSrch );
  455.                 
  456.             break;
  457.              
  458.             case MID_MINI_FNDNXT:
  459.                 
  460.                WinPostMsg ( hwnd, UWM_SEARCH, NULL, NULL );
  461.                 
  462.             break;
  463.              
  464.             case MID_MINI_COPY: case MID_MINI_CUT:
  465.             {
  466.                PBYTE              pbDat;
  467.                ULONG              ulLen;
  468.                PVOID              pvClip;
  469.                PMCTLREC           pctl;
  470.                PMINIREC           pFoc;
  471.                PDATREC            pdr;
  472.  
  473.                pdr = pRecScn->pdr;
  474.                 
  475.                pFoc = WinSendMsg ( pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  476.                                    MPFROMLONG ( CMA_FIRST ),
  477.                                    MPFROMSHORT( CRA_SELECTED ) );
  478.                 
  479.                ulLen = pfnMiniRecMem ( pdr->hwndE, pFoc, 0, NULL );
  480.                 
  481.                ulLen += sizeof (ULONG);
  482.                 
  483.                pvClip = NULL;
  484.                 
  485.                DosAllocSharedMem ( &pvClip, NULL, ulLen, PAG_WRITE | PAG_COMMIT | OBJ_GIVEABLE | OBJ_GETTABLE );
  486.                 
  487.                if ( pvClip ) //&& pbMem )
  488.                {
  489.                   pctl = ( PMCTLREC ) pdr->pvWork;
  490.                    
  491.                   pbDat = pvClip;
  492.                    
  493.                   memcpy ( pbDat, &pctl->ulCols, sizeof (ULONG) );
  494.                    
  495.                   pfnMiniRecMem ( pdr->hwndE, pFoc, ulLen, pbDat + sizeof (ULONG) );
  496.                    
  497.                   WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  498.                    
  499.                   WinSetClipbrdData ( WinQueryAnchorBlock ( hwnd ), (ULONG) pvClip, atomMini, CFI_POINTER );
  500.                    
  501.                   WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  502.                }
  503.                else 
  504.                {
  505.                   pfnMsgOK ( hwnd, APP_TITLE, "Could not get memory for clipboard." );
  506.                   break;
  507.                }
  508.                 
  509.                if ( SHORT1FROMMP ( mp1 ) == MID_MINI_CUT ) 
  510.                {
  511.                   WinSendMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_MINI_DELT, 0 ), NULL );
  512.                    
  513.                   pfnMiniStat ( pRecScn );
  514.                }
  515.             }
  516.             break;
  517.              
  518.             case MID_MINI_PASTE:
  519.             {
  520.                PBYTE              pbDat;
  521.                ULONG              ulCols;
  522.                ULONG              ulLen;
  523.                ULONG              ulX;
  524.                PVOID              pvClip;
  525.                PSZ               *ppsz;
  526.                PMCOLREC           pcol;
  527.                PFIELDINFO         pfinf;
  528.                PMINIREC           pNew;
  529.                PMINIREC           pFoc;
  530.                RECORDINSERT       recins;
  531.                PDATREC            pdr;
  532.  
  533.                if ( pfnIsMyClip ( hwnd, atomMini ) ) 
  534.                {
  535.                   pdr = pRecScn->pdr;
  536.                    
  537.                   WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  538.                    
  539.                   pvClip = (PVOID)WinQueryClipbrdData ( WinQueryAnchorBlock ( hwnd ), atomMini );
  540.                    
  541.                   memcpy ( &ulCols, pvClip, sizeof ( ULONG ) );
  542.                    
  543.                   pbDat = pvClip;
  544.                    
  545.                   pbDat += sizeof (ULONG );
  546.                    
  547.                   //*** Allocate & Init Rec *********************************
  548.                    
  549.                   pFoc = WinSendMsg ( pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  550.                                       MPFROMLONG ( CMA_FIRST ),
  551.                                       MPFROMSHORT( CRA_SELECTED ) );
  552.                    
  553.                   pNew = WinSendMsg ( pdr->hwndE, CM_ALLOCRECORD,
  554.                                       MPFROMLONG (sizeof(MINIREC)-sizeof(RECORDCORE)),
  555.                                       MPFROMSHORT( 1 ) );
  556.                    
  557.                   pfnInitStrings ( pNew );
  558.  
  559.                   //*** Init Record *****************************************
  560.                    
  561.                   pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  562.                                        //MPFROMP ( pfinf ),
  563.                                        NULL, MPFROMSHORT( CMA_FIRST ) );
  564.                    
  565.                   for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  566.                   {
  567.                      pcol = (PMCOLREC) pfinf->pUserData;
  568.                       
  569.                     if ( pcol->ulOpts & SCB_MINI_USED )
  570.                     {
  571.                         ppsz = &pNew->psz01;
  572.                          
  573.                         ppsz += ( pcol->ulX );
  574.                          
  575.                         ulLen = strlen ( pbDat ) + 1;
  576.                          
  577.                         (*ppsz) = realloc ( *ppsz, ulLen );
  578.                          
  579.                         strcpy ( *ppsz, pbDat );
  580.                          
  581.                         pbDat += ulLen;
  582.                      }
  583.                       
  584.                      pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  585.                                           MPFROMP ( pfinf ),
  586.                                           MPFROMSHORT( CMA_NEXT ) );
  587.                   }
  588.                    
  589.                   pfnSetWhen ( &pNew->cdUpd, NULL );
  590.  
  591.                   pbDat += sizeof ( CDATE );
  592.  
  593.                   memcpy ( &pNew->ulOpt, pbDat, sizeof ( ULONG ) );
  594.  
  595.                   //*** Insert **********************************************
  596.                    
  597.                   recins.cb                = sizeof ( RECORDINSERT );
  598.                   recins.pRecordParent     = NULL;
  599.                    
  600.                   if ( pFoc )
  601.                      recins.pRecordOrder = (PRECORDCORE) pFoc;
  602.                   else
  603.                      recins.pRecordOrder = (PRECORDCORE) CMA_END;
  604.                    
  605.                   recins.zOrder            = CMA_TOP;
  606.                   recins.cRecordsInsert    = 1;
  607.                   recins.fInvalidateRecord = TRUE;
  608.                    
  609.                   WinSendMsg ( pdr->hwndE, CM_INSERTRECORD,
  610.                                MPFROMP( pNew ), MPFROMP ( &recins ) );
  611.                    
  612.                   pRecScn->pdr->fbModified = TRUE;
  613.                   //fbModified = TRUE;
  614.                    
  615.                   ++pdr->ulDEnt;
  616.                    
  617.                   pfnMiniStat ( pRecScn );
  618.                    
  619.                   WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  620.                    
  621.                   pfnMiniStat ( pRecScn );
  622.                }
  623.             }
  624.             break;
  625.              
  626.             case MID_MINI_BEGN:
  627.             {
  628.                PMINIREC      pFoc;
  629.                CNREDITDATA   cnrEdt;
  630.  
  631.                pFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  632.                                    MPFROMLONG ( CMA_FIRST ),
  633.                                    MPFROMSHORT( CRA_SELECTED ) );
  634.                 
  635.                if ( ! pFoc || pRecScn->pdr->fbEditing ) {
  636.                    
  637.                   break;//WinSendMsg ( hwndC, CM_CLOSEEDIT, NULL, NULL );
  638.                    
  639.                }
  640.                //else {
  641.                    
  642.                   pRecScn->pdr->pfi =
  643.                           WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  644.                                        MPFROMP ( pRecScn->pdr->pfi ),
  645.                                        MPFROMSHORT( CMA_FIRST ) );
  646.                    
  647.                   cnrEdt.cb         = sizeof ( CNREDITDATA );
  648.                   cnrEdt.hwndCnr    = pRecScn->pdr->hwndE;
  649.                   cnrEdt.pRecord    = (PRECORDCORE) pFoc;
  650.                   cnrEdt.pFieldInfo = pRecScn->pdr->pfi;
  651.                   cnrEdt.ppszText   = NULL;
  652.                   cnrEdt.cbText     = 0;
  653.                   cnrEdt.id         = usLeftDvWnd;
  654.                    
  655.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_OPENEDIT,
  656.                                MPFROMP ( &cnrEdt ), NULL );
  657.                    
  658.                   //pRecScn->pdr->fbEditing = TRUE;
  659.                    
  660.                //}
  661.             }
  662.             break;
  663.              
  664.             case MID_MINI_NEXT: case MID_MINI_PREV:
  665.             {
  666.                PMINIREC           pFoc;
  667.                PMCTLREC           pctl;
  668.                PMCOLREC           pcol;
  669.                CNREDITDATA        cnrEdt;
  670.                PDATREC            pdr;
  671.  
  672.                if ( pRecScn->pdr->fbEditing ) 
  673.                {
  674.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  675.                    
  676.                   pdr = pRecScn->pdr;
  677.                    
  678.                   pctl = ( PMCTLREC ) pdr->pvWork;
  679.                    
  680.                   if ( ! pdr->pfi ) 
  681.                      pdr->pfi = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  682.                                              MPFROMP ( pdr->pfi ),
  683.                                              MPFROMSHORT( CMA_FIRST ) );
  684.                    
  685.                   pFoc = WinSendMsg ( pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  686.                                       MPFROMLONG ( CMA_FIRST ),
  687.                                       MPFROMSHORT( CRA_SELECTED ) );
  688.                    
  689.                   cnrEdt.id = pfnWhichSplit ( pdr->hwndE, pdr, SHORT1FROMMP ( mp1 ), pctl );
  690.                    
  691.                   if ( pdr->pfi ) 
  692.                   {
  693.                      cnrEdt.cb         = sizeof ( CNREDITDATA );
  694.                      cnrEdt.hwndCnr    = pdr->hwndE;
  695.                      cnrEdt.pRecord    = (PRECORDCORE) pFoc;
  696.                      cnrEdt.pFieldInfo = pdr->pfi;
  697.                      cnrEdt.ppszText   = NULL;
  698.                      cnrEdt.cbText     = 0;
  699.                       
  700.                      //pcol = (PMCOLREC) pdr->pfi->pUserData;
  701.                       
  702.                      WinSendMsg ( pdr->hwndE, CM_OPENEDIT,
  703.                                   MPFROMP ( &cnrEdt ), NULL );
  704.                       
  705.                   }
  706.                   else 
  707.                   {
  708.                      WinSendMsg ( pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  709.                   }
  710.                }
  711.             }
  712.             break;
  713.              
  714.             case MID_MINI_STOP:
  715.                 
  716.                WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  717.                 
  718.             break;
  719.  
  720.             default:
  721.                WinPostMsg ( hwndM, msg, mp1, mp2 );
  722.          }
  723.           
  724.       break;
  725.        
  726.       case WM_CONTROL:
  727.           
  728.          switch ( SHORT1FROMMP ( mp1 ) ) 
  729.          {
  730.             case WID_CONT:
  731.                 
  732.                switch ( SHORT2FROMMP ( mp1 ) ) 
  733.                {
  734.                   case CN_BEGINEDIT:
  735.                   {
  736.                      PCNREDITDATA     pcnrEdt;
  737.  
  738.                      pRecScn->pdr->fbEditing = TRUE;
  739.                       
  740.                      pcnrEdt = PVOIDFROMMP ( mp2 );
  741.                       
  742.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  743.                                   MPFROMP ( pcnrEdt->pRecord ),
  744.                                   MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  745.                       
  746.                      pRecScn->pdr->pfi = pcnrEdt->pFieldInfo;
  747.                   }
  748.                   return ( MRESULT ) TRUE;
  749.                    
  750.                   case CN_ENDEDIT:
  751.                       
  752.                      pRecScn->pdr->fbEditing = FALSE;
  753.                       
  754.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_INVALIDATEDETAILFIELDINFO, NULL, NULL );
  755.    
  756.                   return ( MRESULT ) TRUE;
  757.                    
  758.                   case CN_CONTEXTMENU:
  759.                   {
  760.                      HWND          hwndMenu;
  761.                      POINTL        ptl;
  762.                      PMINIREC      pNew;
  763.  
  764.                      pNew = PVOIDFROMMP ( mp2 );
  765.                       
  766.                      hwndMenu = WinLoadMenu ( hwnd, 0, WID_MINI );
  767.                       
  768.                      if ( ! pNew )
  769.                         WinEnableMenuItem ( hwndMenu, MID_MINI_DELT, FALSE );
  770.                      else 
  771.                      {
  772.                         WinEnableMenuItem ( hwndMenu, MID_MINI_DELT, TRUE );
  773.                          
  774.                         WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  775.                                      MPFROMP ( pNew ),
  776.                                      MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  777.                      }
  778.  
  779.                      pfnMiniMenu ( pRecScn, hwndMenu, MID_MINI_EDIT );
  780.  
  781.                      WinQueryPointerPos ( HWND_DESKTOP, &ptl );
  782.                       
  783.                      WinMapWindowPoints ( HWND_DESKTOP, hwnd, &ptl, 1 );
  784.                       
  785.                      WinPopupMenu ( pRecScn->pdr->hwndE, hwnd, hwndMenu,
  786.                                     (SHORT)ptl.x, (SHORT)ptl.y,
  787.                                     MID_MINI_EDIT,
  788.                                     PU_POSITIONONITEM | //PU_HCONSTRAIN | PU_VCONSTRAIN |
  789.                                     PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 | PU_KEYBOARD );
  790.                   }
  791.                   return ( MRESULT ) TRUE;
  792.                    
  793.                   case CN_REALLOCPSZ:
  794.                   {
  795.                      //ULONG            ulOff;
  796.                      PSZ             *ppsz;
  797.                      PMCOLREC         pcol;
  798.                      PFIELDINFO       pfinf;
  799.                      PMINIREC         pNew;
  800.                      PCNREDITDATA     pcnrEdt;
  801.  
  802.                      pcnrEdt = PVOIDFROMMP ( mp2 );
  803.                       
  804.                      pNew = (PMINIREC) pcnrEdt->pRecord;
  805.                       
  806.                      //ulOff = pcnrEdt->pFieldInfo->offStruct;
  807.                       
  808.                      pfinf = pcnrEdt->pFieldInfo;
  809.                       
  810.                      pcol = (PMCOLREC) pfinf->pUserData;
  811.                       
  812.                      if ( ! pNew )
  813.                         return (MRESULT) FALSE;
  814.                       
  815.                      ppsz = &pNew->psz01;
  816.                       
  817.                      ppsz += pcol->ulX;
  818.                       
  819.                      (*ppsz) = realloc ( *ppsz, pcnrEdt->cbText );
  820.                       
  821.                      pRecScn->pdr->fbModified = TRUE;
  822.                      //fbModified = TRUE;
  823.                       
  824.                      pfnSetWhen ( &pNew->cdUpd, NULL );
  825.                   }
  826.                   return ( MRESULT ) TRUE;
  827.                    
  828.                   case CN_INITDRAG:
  829.                   {
  830.                      PMINIREC      pRecDrg;
  831.                      PCNRDRAGINIT  pcnrDrg;
  832.                      PDRAGINFO     pdinfo;
  833.                      DRAGITEM      ditem;
  834.                      DRAGIMAGE     dimage;
  835.          
  836.                      pcnrDrg = PVOIDFROMMP ( mp2 );
  837.                       
  838.                      pRecDrg = (PMINIREC) pcnrDrg->pRecord;
  839.                       
  840.                      if ( ! pRecDrg )
  841.                         break;
  842.                       
  843.                      //*** Drag It ******************************************
  844.                       
  845.                      pdinfo = DrgAllocDraginfo ( 1 );
  846.                       
  847.                      ditem.hwndItem       = hwnd;
  848.                      ditem.ulItemID       = (ULONG)pRecDrg;
  849.                      ditem.hstrType       = DrgAddStrHandle ( DRT_TREE );
  850.                      ditem.hstrRMF        = DrgAddStrHandle ( DRM_MINI );
  851.                      ditem.fsControl      = 0;
  852.                      ditem.fsSupportedOps = DO_COPYABLE | DO_MOVEABLE;
  853.                       
  854.                      DrgSetDragitem ( pdinfo, &ditem, sizeof(ditem), 0 );
  855.                       
  856.                      dimage.cb       = sizeof(DRAGIMAGE);
  857.                      dimage.cptl     = 0;
  858.                      dimage.hImage   = hptrMini;
  859.                      dimage.fl       = DRG_ICON;
  860.                      dimage.cxOffset = 0;
  861.                      dimage.cyOffset = 0;
  862.                       
  863.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  864.                                   MPFROMP ( pRecDrg ),
  865.                                   MPFROM2SHORT ( TRUE, 0x00004000 ) );//CRA_CURSORED ) );
  866.                       
  867.                      DrgDrag ( hwnd, pdinfo, &dimage, 1, VK_ENDDRAG, NULL );
  868.                       
  869.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  870.                                   MPFROMP ( pRecDrg ),
  871.                                   MPFROM2SHORT ( FALSE, 0x00004000 ) );//CRA_CURSORED ) );
  872.                       
  873.                      DrgFreeDraginfo ( pdinfo );
  874.                   }
  875.                   break;
  876.                    
  877.                   case CN_DRAGAFTER:
  878.                   {
  879.                      PCNRDRAGINFO  pcnrDri;
  880.                      PDRAGINFO     pdinfo;
  881.                      PDRAGITEM     pditem;
  882.          
  883.                      pcnrDri = PVOIDFROMMP ( mp2 );
  884.                       
  885.                      pdinfo = pcnrDri->pDragInfo;
  886.                       
  887.                      DrgAccessDraginfo ( pdinfo );
  888.                       
  889.                      pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  890.                       
  891.                      if ( pditem->hwndItem != hwnd )
  892.                      {
  893.                         DrgFreeDraginfo ( pdinfo );
  894.    
  895.                         return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  896.                      }
  897.                      else if ( DrgVerifyRMF ( pditem, "DRM_PMSCRAPBOOK", "DRF_MINI" ) )
  898.                      { 
  899.                         DrgFreeDraginfo ( pdinfo );
  900.                          
  901.                         return ( MRFROM2SHORT ( DOR_DROP, DO_MOVE ) );
  902.                          
  903.                      }
  904.                      else 
  905.                      {
  906.                         DrgFreeDraginfo ( pdinfo );
  907.                          
  908.                         return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  909.                      }
  910.                   }
  911.                    
  912.                   case CN_DROP:
  913.                   {
  914.                      PCNRDRAGINFO  pcnrDri;
  915.                      PDRAGINFO     pdinfo;
  916.                      PDRAGITEM     pditem;
  917.                      PMINIREC      pRecDrp;
  918.                      PMINIREC      pRecAft;
  919.                      RECORDINSERT  recins;
  920.          
  921.                      pcnrDri = PVOIDFROMMP ( mp2 );
  922.                       
  923.                      pdinfo = pcnrDri->pDragInfo;
  924.                       
  925.                      DrgAccessDraginfo ( pdinfo );
  926.                       
  927.                      pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  928.                       
  929.                      pRecDrp = (PMINIREC) pditem->ulItemID;
  930.                      pRecAft = (PMINIREC) pcnrDri->pRecord;
  931.                       
  932.                      if ( ! pRecAft || pRecDrp == pRecAft )
  933.                      {
  934.                         DrgFreeDraginfo ( pdinfo );
  935.                         break;
  936.                      }
  937.                       
  938.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_REMOVERECORD,
  939.                                   MPFROMP ( &pRecDrp ),
  940.                                   MPFROM2SHORT( 1, 0 ) );//CMA_INVALIDATE ) );
  941.                       
  942.                      //*** Insert *************************************************
  943.                       
  944.                      recins.cb                = sizeof ( RECORDINSERT );
  945.                      recins.pRecordParent     = NULL;
  946.                      recins.pRecordOrder      = (PRECORDCORE) pRecAft;
  947.                      recins.zOrder            = CMA_TOP;
  948.                      recins.cRecordsInsert    = 1;
  949.                      recins.fInvalidateRecord = TRUE;
  950.                       
  951.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  952.                                   MPFROMP( pRecDrp ), MPFROMP ( &recins ) );
  953.                       
  954.                      pRecScn->pdr->fbModified = TRUE;
  955.                      //fbModified = TRUE;
  956.                   }
  957.                   break;
  958.                    
  959.                   case CN_HELP:
  960.                       
  961.                      WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  962.                                   MPFROMSHORT ( HID_MINI ), MPFROMSHORT ( HM_RESOURCEID ) );
  963.                       
  964.                   break;
  965.                    
  966.                }
  967.                 
  968.             break;
  969.              
  970.          }
  971.           
  972.       break;
  973.        
  974.       case UWM_SAVE:
  975.       {
  976.          ULONG              ulOff;
  977.          ULONG              ulLen;
  978.          ULONG              ulX;
  979.          ULONG              ulAdd;
  980.          PBYTE              pbScn;
  981.          PMCTLREC           pctl;
  982.          PMCOLREC           pcol;
  983.          CNRINFO            cnrinf;
  984.          PFIELDINFO         pfinf;
  985.          PDATREC            pdr;
  986.  
  987.          pdr = pRecScn->pdr;
  988.           
  989.          pdr->ulRelRev = REL_REV;
  990.  
  991.          pctl = (PMCTLREC ) pdr->pvWork;
  992.           
  993.          pdr->ulDLen = pfnNodeScan  ( pdr->hwndE, SCB_SIZE, WID_MINI, pdr->pvDat );
  994.           
  995.          pdr->ulDLen += ( sizeof ( ULONG ) * 2 );
  996.           
  997.          pdr->ulDLen += ( sizeof ( BYTE ) * MINI_SORTS );
  998.           
  999.          pdr->ulDLen += ( sizeof ( BYTE ) * MINI_SORTS );
  1000.           
  1001.          pdr->ulDLen += ( sizeof ( MCOLREC ) * MINI_COLS );
  1002.           
  1003.          for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1004.             pdr->ulDLen += ( strlen ( pctl->mcols[ulX].pszTitl ) + 1 );
  1005.           
  1006.          pdr->pvDat = realloc ( pdr->pvDat, pdr->ulDLen );
  1007.           
  1008.          //*** Write Control Header *****************************************
  1009.           
  1010.          pbScn = pdr->pvDat;
  1011.           
  1012.          //*** # Cols *******************************************************
  1013.           
  1014.          memcpy ( pbScn, &pctl->ulCols, sizeof ( ULONG ) );
  1015.           
  1016.          pbScn += sizeof ( ULONG );
  1017.           
  1018.          //*** Split ********************************************************
  1019.           
  1020.          if ( pctl->ulSplit ) 
  1021.          {
  1022.             pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1023.                                  NULL, MPFROMSHORT( CMA_FIRST ) );
  1024.              
  1025.             for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1026.             {
  1027.                pcol = (PMCOLREC) pfinf->pUserData;
  1028.                 
  1029.                if ( pcol->ulOpts & SCB_MINI_SPLT )
  1030.                //if ( pcol->ulX == ( pctl->ulSplit - 1 ) )
  1031.                {
  1032.                   ulOff = ulX + 1;
  1033.                    
  1034.                   break;
  1035.                }
  1036.                 
  1037.                pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1038.                                     MPFROMP ( pfinf ),
  1039.                                     MPFROMSHORT( CMA_NEXT ) );
  1040.             }
  1041.              
  1042.          }
  1043.          else 
  1044.          {
  1045.             ulOff = 0;
  1046.          }
  1047.           
  1048.          memcpy ( pbScn, &ulOff, sizeof ( ULONG ) );
  1049.           
  1050.          pbScn += sizeof ( ULONG );
  1051.           
  1052.          //*** Sort *********************************************************
  1053.           
  1054.          memcpy ( pbScn, pctl->abSort, sizeof ( BYTE ) * MINI_SORTS );
  1055.           
  1056.          pbScn += ( sizeof ( BYTE ) * MINI_SORTS );
  1057.           
  1058.          memcpy ( pbScn, pctl->abSOpt, sizeof ( BYTE ) * MINI_SORTS );
  1059.           
  1060.          pbScn += ( sizeof ( BYTE ) * MINI_SORTS );
  1061.           
  1062.          //*** Col Data *****************************************************
  1063.           
  1064.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1065.                               NULL,
  1066.                               MPFROMSHORT( CMA_FIRST ) );
  1067.           
  1068.          for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1069.          {
  1070.             pcol = (PMCOLREC) pfinf->pUserData;
  1071.              
  1072.             pcol->ulChrs = pfnCnrColPels ( pdr->hwndE, pfinf );
  1073.  
  1074.             memcpy ( pbScn, pcol, sizeof ( MCOLREC ) );
  1075.              
  1076.             pbScn += sizeof ( MCOLREC );
  1077.              
  1078.             pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1079.                                  MPFROMP ( pfinf ),
  1080.                                  MPFROMSHORT( CMA_NEXT ) );
  1081.          }
  1082.           
  1083.          //*** Titles *******************************************************
  1084.           
  1085.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1086.                               MPFROMP ( pfinf ),
  1087.                               MPFROMSHORT( CMA_FIRST ) );
  1088.           
  1089.          ulAdd = 0;
  1090.  
  1091.          for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1092.          {
  1093.             pcol = (PMCOLREC) pfinf->pUserData;
  1094.              
  1095.          /*  if ( pcol->ulOpts & SCB_MINI_USED )
  1096.            {*/
  1097.                ulLen = strlen ( pcol->pszTitl ) + 1;
  1098.              
  1099.                memcpy ( pbScn, pcol->pszTitl, ulLen );
  1100.              
  1101.                pbScn += ulLen;
  1102.             /*}
  1103.             else
  1104.                ++ulAdd;*/
  1105.              
  1106.             pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1107.                                  MPFROMP ( pfinf ),
  1108.                                  MPFROMSHORT( CMA_NEXT ) );
  1109.          }
  1110.  
  1111.          pdr->ulDEnt = pfnNodeScan  ( pdr->hwndE, SCB_WRITE, WID_MINI, pbScn );
  1112.           
  1113.          //*** Set Completion States ****************************************
  1114.           
  1115.          pdr->fbModified = FALSE;
  1116.           
  1117.          pfnSetWhen ( &pRecScn->cdWri, &pRecScn->ctWri );
  1118.           
  1119.          pfnGetWinPos ( hwnd, pdr );
  1120.           
  1121.          //pfnGetDefFattrs ( pdr->hwndE, NULLHANDLE, &pdr->fat, &pdr->fxPtSz );
  1122.           
  1123.          pfnGetPresColors ( pdr->hwndE, &pdr->ulNBClr, &pdr->ulNFClr, &pdr->ulHBClr, &pdr->ulHFClr );
  1124.           
  1125.          WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  1126.                       MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  1127.           
  1128.          pdr->ulXVS = cnrinf.xVertSplitbar;
  1129.           
  1130.          fbModified = TRUE;
  1131.       }
  1132.       break;
  1133.        
  1134.       case UWM_SEARCH:
  1135.       {
  1136.          PMINIREC         pFoc;
  1137.          PDATREC          pdr;
  1138.          SEARCHSTRING     cnrsd;
  1139.  
  1140.          pdr = pRecScn->pdr;
  1141.           
  1142.          cnrsd.cb              = sizeof ( SEARCHSTRING );
  1143.          cnrsd.pszSearch       = pdr->psSrch->pszFnd;
  1144.          cnrsd.fsPrefix        = FALSE;
  1145.          cnrsd.fsCaseSensitive = ( pdr->psSrch->fbCase ) ? TRUE : FALSE;
  1146.          cnrsd.usView          = CV_DETAIL;
  1147.  
  1148.          pFoc = WinSendMsg ( pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  1149.                              MPFROMLONG ( CMA_FIRST ),
  1150.                              MPFROMSHORT( CRA_SELECTED ) );
  1151.           
  1152.          if ( ! pFoc )
  1153.          {
  1154.             pfnMsgOK ( hwnd, APP_TITLE, "Text not found." );
  1155.             break;
  1156.          }
  1157.  
  1158.          if ( pdr->psSrch->fbFirst )
  1159.          {
  1160.             if ( pFoc == pfnGetCnrRec ( pdr->hwndE, NULL ) )
  1161.                pFoc = (PMINIREC) CMA_FIRST;
  1162.             
  1163.             pdr->psSrch->fbFirst = FALSE;
  1164.          }
  1165.          
  1166.          pFoc = WinSendMsg ( pdr->hwndE, CM_SEARCHSTRING,
  1167.                              MPFROMP ( &cnrsd ), MPFROMP ( pFoc ) );
  1168.  
  1169.          if ( pFoc )
  1170.          {
  1171.             pfnCnrShowRec ( pdr->hwndE, pFoc, TRUE );
  1172.  
  1173.             if ( pFoc != pfnGetCnrRec ( pdr->hwndE, NULL ) )
  1174.                pdr->psSrch->fbFirst = TRUE;
  1175.          }
  1176.          else
  1177.          {
  1178.             pdr->psSrch->fbFirst = TRUE;
  1179.             pfnMsgOK ( hwnd, APP_TITLE, "Text not found." );
  1180.          }
  1181.       }
  1182.       break;
  1183.        
  1184.       case WM_CLOSE:
  1185.       {
  1186.          PDATREC            pdr;
  1187.  
  1188.          pdr = pRecScn->pdr;
  1189.           
  1190.          if ( pdr->fbModified ) 
  1191.          {
  1192.             if ( pfnMsgYesNo ( hwnd, APP_TITLE,
  1193.                                "This entry has been modified. Save changes ?" ) )
  1194.  
  1195.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  1196.          }
  1197.           
  1198.          pdr->ulOpts &= ~SCB_OPENED;
  1199.           
  1200.          pdr->hwndD   = 0;
  1201.          pfnHaveAKid ( pRecScn, FALSE );
  1202.           
  1203.          WinEnableWindowUpdate ( pdr->hwndE, FALSE );
  1204.  
  1205.          pfnNodeScan  ( pdr->hwndE, SCB_FREE, 
  1206.                         pRecScn->ulType, pRecScn->pdr->pvDat );
  1207.  
  1208.          free ( pdr->psSrch->pszFnd );
  1209.          free ( pdr->psSrch );
  1210.          free ( pdr->pszStat );
  1211.           
  1212.          WinSendMsg ( hwndC, CM_SETRECORDEMPHASIS,
  1213.                       MPFROMP ( pRecScn ),
  1214.                       MPFROM2SHORT ( FALSE, CRA_INUSE ) );
  1215.           
  1216.          WinDestroyWindow ( WinQueryWindow ( hwnd, QW_PARENT ) );
  1217.       }
  1218.       break;
  1219.        
  1220.       case WM_PRESPARAMCHANGED:
  1221.           
  1222.          pRecScn->pdr->fbModified = TRUE;
  1223.          //fbModified = TRUE;
  1224.           
  1225.       break;
  1226.        
  1227.       case WM_ERASEBACKGROUND:
  1228.           
  1229.       return ( MRESULT ) ( TRUE );
  1230.        
  1231.       default:
  1232.       return WinDefWindowProc ( hwnd, msg, mp1, mp2 );
  1233.        
  1234.    }
  1235.     
  1236.    return ( MRESULT ) FALSE;
  1237.     
  1238. }
  1239.  
  1240. /***************************************************************************/
  1241. /* Mini Columns Maintenance Window Proc                                    */
  1242. /***************************************************************************/
  1243. MRESULT EXPENTRY pfndpColMaint( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) 
  1244. {
  1245.    PUSEREC    pRecScn = (PUSEREC) WinQueryWindowULong ( hwnd, QWL_USER );
  1246.     
  1247.    switch ( msg ) 
  1248.    {
  1249.       case WM_INITDLG:
  1250.       {
  1251.          CNRINFO      cnrinf;
  1252.          HWND         hwndP;
  1253.          ULONG        ulX;
  1254.          PDATREC      pdr;
  1255.          PMAINTREC    prec;
  1256.          PFIELDINFO   pfiBfr;
  1257.          PMCTLREC     pctl;
  1258.          PMCOLREC     pcol;
  1259.          RECORDINSERT recins;
  1260.  
  1261.          pRecScn = (PUSEREC) PVOIDFROMMP ( mp2 );
  1262.           
  1263.          pdr = pRecScn->pdr;
  1264.           
  1265.          pctl = ( PMCTLREC ) pdr->pvWork;
  1266.           
  1267.          WinSetWindowULong ( hwnd, QWL_USER, (ULONG) pRecScn );
  1268.           
  1269.          //*** Set Container Attrs ******************************************
  1270.           
  1271.          hwndP = WinWindowFromID ( hwnd, DIT_COLLIST );
  1272.           
  1273.          cnrinf.flWindowAttr = CV_TEXT | CA_ORDEREDTARGETEMPH;
  1274.           
  1275.          WinSendMsg ( hwndP, CM_SETCNRINFO, &cnrinf,
  1276.                       MPFROMLONG ( CMA_FLWINDOWATTR ) );
  1277.           
  1278.          //*** Fill Container ***********************************************
  1279.           
  1280.          pfiBfr = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1281.                                MPFROMP ( pRecScn->pdr->pfi ),
  1282.                                MPFROMSHORT( CMA_FIRST ) );
  1283.           
  1284.          for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1285.          {
  1286.             pcol = (PMCOLREC) pfiBfr->pUserData;
  1287.              
  1288.             if ( pcol->ulOpts & SCB_MINI_USED )
  1289.             {
  1290.                //*** Allocate **************************************************
  1291.                 
  1292.                prec = WinSendMsg ( hwndP, CM_ALLOCRECORD,
  1293.                                    MPFROMLONG (sizeof(MAINTREC)-sizeof(MINIRECORDCORE)),
  1294.                                    MPFROMSHORT( 1 ) );
  1295.                 
  1296.                prec->crecCore.pszIcon = strdup ( pcol->pszTitl );
  1297.                 
  1298.                //prec->ulX = pcol->ulX;
  1299.                prec->pcol = pcol;
  1300.                 
  1301.                //*** Insert ****************************************************
  1302.                 
  1303.                recins.cb                = sizeof ( RECORDINSERT );
  1304.                recins.pRecordParent     = NULL;
  1305.                recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  1306.                recins.zOrder            = CMA_TOP;
  1307.                recins.cRecordsInsert    = 1;
  1308.                recins.fInvalidateRecord = TRUE;
  1309.                 
  1310.                WinSendMsg ( hwndP, CM_INSERTRECORD,
  1311.                             MPFROMP( prec ), MPFROMP ( &recins ) );
  1312.             }
  1313.              
  1314.             pfiBfr = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1315.                                   MPFROMP ( pfiBfr ),
  1316.                                   MPFROMSHORT( CMA_NEXT ) );
  1317.          }
  1318.           
  1319.          prec = WinSendMsg ( hwndP, CM_QUERYRECORD,
  1320.                              MPFROMP ( NULL ),
  1321.                              MPFROM2SHORT ( CMA_FIRST, CMA_ITEMORDER ) );
  1322.           
  1323.          WinSendMsg ( hwnd, UWM_SHOW, MPFROMP ( prec ), NULL );
  1324.           
  1325.          WinSendMsg ( hwndP, CM_SETRECORDEMPHASIS,
  1326.                       MPFROMP ( prec ),
  1327.                       MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  1328.       }
  1329.       break;
  1330.        
  1331.       case UWM_SHOW:
  1332.       {
  1333.          HWND         hwndP;
  1334.          PDATREC      pdr;
  1335.          PMAINTREC    precTmp;
  1336.          PMAINTREC    prec;
  1337.          PMCTLREC     pctl;
  1338.          PMCOLREC     pcol;
  1339.           
  1340.          prec = (PMAINTREC) PVOIDFROMMP ( mp1 );
  1341.           
  1342.          if ( ! prec )
  1343.             break;
  1344.           
  1345.          pdr = pRecScn->pdr;
  1346.           
  1347.          pctl = ( PMCTLREC ) pdr->pvWork;
  1348.           
  1349.          //pcol = &pctl->mcols[prec->ulX];
  1350.          pcol = prec->pcol;
  1351.           
  1352.          hwndP = WinWindowFromID ( hwnd, DIT_COLLIST );
  1353.           
  1354.          //*** ADDs, DELETEs and SPLITs *************************************
  1355.           
  1356.          if ( pcol->ulOpts & SCB_MINI_MLE )
  1357.             WinCheckButton ( hwnd, DIT_COLMLE, TRUE );
  1358.          else 
  1359.             WinCheckButton ( hwnd, DIT_COLMLE, FALSE );
  1360.           
  1361.          if ( pctl->ulCols <= 1 )
  1362.             WinCheckButton ( hwnd, DIT_COLDELT, FALSE );
  1363.          else
  1364.             WinCheckButton ( hwnd, DIT_COLDELT, TRUE );
  1365.           
  1366.          if ( pctl->ulCols == MINI_COLS )
  1367.             WinCheckButton ( hwnd, DIT_COLADD, FALSE );
  1368.          else
  1369.             WinCheckButton ( hwnd, DIT_COLADD, TRUE );
  1370.           
  1371.          //if ( pcol->ulX == ( pctl->ulSplit - 1 ) )
  1372.          if ( pcol->ulOpts & SCB_MINI_SPLT )
  1373.             WinCheckButton ( hwnd, DIT_COLSPLITCOL, TRUE );
  1374.          else
  1375.             WinCheckButton ( hwnd, DIT_COLSPLITCOL, FALSE );
  1376.           
  1377.          //*** Alignment ****************************************************
  1378.           
  1379.          if ( pcol->ulCHOpts & CFA_LEFT )
  1380.             WinCheckButton ( hwnd, DIT_COLLEFT, TRUE );
  1381.          else if ( pcol->ulCHOpts & CFA_RIGHT )
  1382.             WinCheckButton ( hwnd, DIT_COLRIGHT, TRUE );
  1383.          else
  1384.             WinCheckButton ( hwnd, DIT_COLCENTER, TRUE );
  1385.           
  1386.          if ( pcol->ulCHOpts & CFA_TOP )
  1387.             WinCheckButton ( hwnd, DIT_COLTOP, TRUE );
  1388.          else if ( pcol->ulCHOpts & CFA_BOTTOM )
  1389.             WinCheckButton ( hwnd, DIT_COLBOTTOM, TRUE );
  1390.          else
  1391.             WinCheckButton ( hwnd, DIT_COLVCENTER, TRUE );
  1392.           
  1393.          if ( pcol->ulCDOpts & CFA_LEFT )
  1394.             WinCheckButton ( hwnd, DIT_DATLEFT, TRUE );
  1395.          else if ( pcol->ulCDOpts & CFA_RIGHT )
  1396.             WinCheckButton ( hwnd, DIT_DATRIGHT, TRUE );
  1397.          else
  1398.             WinCheckButton ( hwnd, DIT_DATCENTER, TRUE );
  1399.           
  1400.          if ( pcol->ulCDOpts & CFA_TOP )
  1401.             WinCheckButton ( hwnd, DIT_DATTOP, TRUE );
  1402.          else if ( pcol->ulCDOpts & CFA_BOTTOM )
  1403.             WinCheckButton ( hwnd, DIT_DATBOTTOM, TRUE );
  1404.          else
  1405.             WinCheckButton ( hwnd, DIT_DATVCENTER, TRUE );
  1406.           
  1407.          //*** Position *****************************************************
  1408.           
  1409.          precTmp = WinSendMsg ( hwndP, CM_QUERYRECORD,
  1410.                                 MPFROMP ( prec ),
  1411.                                 MPFROM2SHORT ( CMA_NEXT, CMA_ITEMORDER ) );
  1412.           
  1413.          if ( ! precTmp ) 
  1414.          {
  1415.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_DOWN ), FALSE );
  1416.              
  1417.             //WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSPLITCOL ), FALSE );
  1418.          }
  1419.          else 
  1420.          {
  1421.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_DOWN ), TRUE );
  1422.              
  1423.             //WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSPLITCOL ), TRUE );
  1424.          }
  1425.           
  1426.          precTmp = WinSendMsg ( hwndP, CM_QUERYRECORD,
  1427.                                 MPFROMP ( prec ),
  1428.                                 MPFROM2SHORT ( CMA_PREV, CMA_ITEMORDER ) );
  1429.           
  1430.          if ( ! precTmp ) 
  1431.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_UP ), FALSE );
  1432.          else
  1433.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_UP ), TRUE );
  1434.           
  1435.          //*** Sorts ********************************************************
  1436.           
  1437.          WinCheckButton ( hwnd, DIT_COLSORT1, FALSE );
  1438.          WinCheckButton ( hwnd, DIT_COLSORT2, FALSE );
  1439.          WinCheckButton ( hwnd, DIT_COLSORT3, FALSE );
  1440.          WinCheckButton ( hwnd, DIT_COLSORT4, FALSE );
  1441.           
  1442.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT1_DEC ), FALSE );
  1443.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT2_DEC ), FALSE );
  1444.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT3_DEC ), FALSE );
  1445.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT4_DEC ), FALSE );
  1446.           
  1447.          if ( pcol->ulX == ( pctl->abSort[0] - 1 ) ) 
  1448.          {
  1449.             WinCheckButton ( hwnd, DIT_COLSORT1, TRUE );
  1450.              
  1451.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT1_DEC ), TRUE );
  1452.          }
  1453.          else if ( pcol->ulX == ( pctl->abSort[1] - 1 ) ) 
  1454.          {
  1455.             WinCheckButton ( hwnd, DIT_COLSORT2, TRUE );
  1456.              
  1457.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT2_DEC ), TRUE );
  1458.          }
  1459.          else if ( pcol->ulX == ( pctl->abSort[2] - 1 ) ) 
  1460.          {
  1461.             WinCheckButton ( hwnd, DIT_COLSORT3, TRUE );
  1462.              
  1463.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT3_DEC ), TRUE );
  1464.          }
  1465.          else if ( pcol->ulX == ( pctl->abSort[3] - 1 ) ) 
  1466.          {
  1467.             WinCheckButton ( hwnd, DIT_COLSORT4, TRUE );
  1468.              
  1469.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT4_DEC ), TRUE );
  1470.          }
  1471.           
  1472.          WinCheckButton ( hwnd, DIT_COLSORT1_DEC, FALSE );
  1473.          WinCheckButton ( hwnd, DIT_COLSORT2_DEC, FALSE );
  1474.          WinCheckButton ( hwnd, DIT_COLSORT3_DEC, FALSE );
  1475.          WinCheckButton ( hwnd, DIT_COLSORT4_DEC, FALSE );
  1476.           
  1477.          if ( pcol->ulX == ( pctl->abSort[0] - 1 ) ) 
  1478.          {
  1479.             if ( pctl->abSOpt[0] & SCB_MINI_DESC )
  1480.                WinCheckButton ( hwnd, DIT_COLSORT1_DEC, TRUE );
  1481.          }
  1482.          else if ( pcol->ulX == ( pctl->abSort[1] - 1 ) ) 
  1483.          {
  1484.             if ( pctl->abSOpt[1] & SCB_MINI_DESC )
  1485.                WinCheckButton ( hwnd, DIT_COLSORT2_DEC, TRUE );
  1486.          }
  1487.          else if ( pcol->ulX == ( pctl->abSort[2] - 1 ) ) 
  1488.          {
  1489.             if ( pctl->abSOpt[2] & SCB_MINI_DESC )
  1490.                WinCheckButton ( hwnd, DIT_COLSORT3_DEC, TRUE );
  1491.          }
  1492.          else if ( pcol->ulX == ( pctl->abSort[3] - 1 ) ) 
  1493.          {
  1494.             if ( pctl->abSOpt[3] & SCB_MINI_DESC )
  1495.                WinCheckButton ( hwnd, DIT_COLSORT4_DEC, TRUE );
  1496.          }
  1497.           
  1498.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT2 ), TRUE );
  1499.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT3 ), TRUE );
  1500.          WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT4 ), TRUE );
  1501.           
  1502.          if ( pctl->ulCols < 2 ) 
  1503.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT2 ), FALSE );
  1504.           
  1505.          if ( pctl->ulCols < 3 ) 
  1506.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT3 ), FALSE );
  1507.           
  1508.          if ( pctl->ulCols < 4 ) 
  1509.             WinEnableWindow ( WinWindowFromID ( hwnd, DIT_COLSORT4 ), FALSE );
  1510.           
  1511.       }
  1512.       break;
  1513.        
  1514.       /*case WM_CLOSE:
  1515.       {
  1516.          pRecScn->pdr->fbModified = TRUE;
  1517.       }
  1518.       break;*/
  1519.        
  1520.       case WM_COMMAND:
  1521.       {
  1522.          HWND         hwndP;
  1523.          PDATREC      pdr;
  1524.          PMAINTREC    precTmp;
  1525.          PFIELDINFO   pfiBfr;
  1526.          PFIELDINFO   pfiAft;
  1527.          PMAINTREC    prec;
  1528.          PMCTLREC     pctl;
  1529.          PMCOLREC     pcol;
  1530.          RECORDINSERT recins;
  1531.  
  1532.          hwndP = WinWindowFromID ( hwnd, DIT_COLLIST );
  1533.           
  1534.          if ( pRecScn->pdr->fbEditing && SHORT1FROMMP ( mp1 ) == DIT_COLNAME )
  1535.          {
  1536.             WinSendMsg ( hwndP, CM_CLOSEEDIT, NULL, NULL );
  1537.             break;
  1538.          }
  1539.          else if ( pRecScn->pdr->fbEditing )
  1540.             WinSendMsg ( hwndP, CM_CLOSEEDIT, NULL, NULL );
  1541.           
  1542.          prec = WinSendMsg ( hwndP, CM_QUERYRECORDEMPHASIS,
  1543.                              MPFROMLONG ( CMA_FIRST ), MPFROMSHORT( CRA_SELECTED ) );
  1544.           
  1545.          if ( ! prec ) 
  1546.          {
  1547.             WinAlarm ( HWND_DESKTOP, WA_NOTE );
  1548.              
  1549.             break;
  1550.          }
  1551.           
  1552.          pdr = pRecScn->pdr;
  1553.           
  1554.          pctl = ( PMCTLREC ) pdr->pvWork;
  1555.           
  1556.          pcol = prec->pcol;//&pctl->mcols[prec->ulX];
  1557.           
  1558.          switch ( SHORT1FROMMP ( mp1 ) ) 
  1559.          {
  1560.             case DIT_OK:
  1561.                 
  1562.                WinDismissDlg ( hwnd, TRUE );
  1563.                 
  1564.             break;
  1565.              
  1566.             case DIT_HELP:
  1567.             {
  1568.                WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  1569.                             MPFROM2SHORT ( DLG_COLMAINT, 0 ), MPFROMSHORT ( HM_RESOURCEID ) );
  1570.             }
  1571.             break;
  1572.              
  1573.             case DIT_COLNAME:
  1574.             {
  1575.                CNREDITDATA    cnrEdt;
  1576.  
  1577.                cnrEdt.cb         = sizeof ( CNREDITDATA );
  1578.                cnrEdt.hwndCnr    = hwndP;
  1579.                cnrEdt.pRecord    = (PRECORDCORE) prec;
  1580.                cnrEdt.pFieldInfo = NULL;
  1581.                cnrEdt.ppszText   = &prec->crecCore.pszIcon;
  1582.                cnrEdt.cbText     = strlen ( prec->crecCore.pszIcon ) + 1;
  1583.                cnrEdt.id         = DIT_COLLIST;//CID_LEFTDVWND;//0;
  1584.                 
  1585.                WinSendMsg ( hwndP, CM_OPENEDIT, MPFROMP ( &cnrEdt ), NULL );
  1586.             }
  1587.             break;
  1588.              
  1589.             case DIT_COLDELT:
  1590.             {
  1591.                PMINIREC  pRecTmp;
  1592.                PSZ      *ppsz;
  1593.  
  1594.                --pctl->ulCols;
  1595.                 
  1596.                pcol->ulOpts &= ~SCB_MINI_USED;
  1597.                 
  1598.                pfnSetSplit ( pdr->hwndE, pdr, FALSE );
  1599.                 
  1600.                //*** Free Strings *******************************************
  1601.                 
  1602.                free ( prec->crecCore.pszIcon );
  1603.                 
  1604.                pRecTmp = WinSendMsg ( pdr->hwndE, CM_QUERYRECORD,
  1605.                                       MPFROMP ( NULL ),
  1606.                                       MPFROM2SHORT ( CMA_FIRST, CMA_ITEMORDER ) );
  1607.                 
  1608.                while ( pRecTmp ) 
  1609.                {
  1610.                   ppsz = &pRecTmp->psz01;
  1611.                    
  1612.                   ppsz += pcol->ulX;
  1613.                    
  1614.                   (*ppsz) = realloc ( *ppsz, 1 );
  1615.                    
  1616.                   //*ppsz = 0;
  1617.                   strcpy ( *ppsz, "" );
  1618.  
  1619.                   pRecTmp = WinSendMsg ( pdr->hwndE, CM_QUERYRECORD,
  1620.                                          MPFROMP ( pRecTmp ),
  1621.                                          MPFROM2SHORT ( CMA_NEXT, CMA_ITEMORDER ) );
  1622.                }
  1623.  
  1624.                //*** Remove/Hide Records ************************************
  1625.                 
  1626.                pcol->pfi->flData |= CFA_INVISIBLE;
  1627.  
  1628.                WinSendMsg ( hwndP, CM_REMOVERECORD,
  1629.                             MPFROMP ( &prec ),
  1630.                             MPFROM2SHORT( 1, CMA_INVALIDATE ) );
  1631.                 
  1632.                prec = WinSendMsg ( WinWindowFromID ( hwnd, DIT_COLLIST ), CM_QUERYRECORDEMPHASIS,
  1633.                                    MPFROMLONG ( CMA_FIRST ), MPFROMSHORT( CRA_SELECTED ) );
  1634.                 
  1635.                WinSendMsg ( hwnd, UWM_SHOW, MPFROMP ( prec ), NULL );
  1636.                 
  1637.                pfnSetSplit ( pdr->hwndE, pdr, TRUE );
  1638.             }
  1639.             break;
  1640.              
  1641.             case DIT_COLADD:
  1642.             {
  1643.                ULONG     ulX;
  1644.                PFIELDINFO   pfiBfr;
  1645.  
  1646.                pfiBfr = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1647.                                      NULL,
  1648.                                      MPFROMSHORT( CMA_FIRST ) );
  1649.                 
  1650.                for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  1651.                {
  1652.                   pcol = (PMCOLREC) pfiBfr->pUserData;
  1653.                    
  1654.                   if ( ! ( pcol->ulOpts & SCB_MINI_USED ) )
  1655.                   {
  1656.                      ++pctl->ulCols;
  1657.                       
  1658.                      pfnSetSplit ( pdr->hwndE, pdr, FALSE );
  1659.                       
  1660.                      //*** Add Editor Column ********************************
  1661.                       
  1662.                      pcol->ulOpts |= SCB_MINI_USED;
  1663.                       
  1664.                      pcol->ulCHOpts = CFA_TOP | CFA_CENTER | CFA_FITITLEREADONLY;
  1665.                      pcol->ulCDOpts = CFA_STRING | CFA_TOP | CFA_LEFT | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  1666.                      pcol->ulStyl   = 0;
  1667.                      pcol->pszTitl  = strdup ( "New Column" );
  1668.                       
  1669.                      pcol->pfi = pfnCol2FInfo ( pdr->hwndE, pcol, pcol->pfi, (PFIELDINFO)CMA_END );
  1670.                       
  1671.                      //*** Allocate Settings Record *************************
  1672.                       
  1673.                      prec = WinSendMsg ( hwndP, CM_ALLOCRECORD,
  1674.                                          MPFROMLONG (sizeof(MAINTREC)-sizeof(MINIRECORDCORE)),
  1675.                                          MPFROMSHORT( 1 ) );
  1676.                       
  1677.                      prec->crecCore.pszIcon = strdup ( pcol->pszTitl );
  1678.                       
  1679.                      //prec->ulX = ulX;
  1680.                      prec->pcol = pcol;
  1681.                       
  1682.                      //*** Insert *******************************************
  1683.                       
  1684.                      recins.cb                = sizeof ( RECORDINSERT );
  1685.                      recins.pRecordParent     = NULL;
  1686.                      recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  1687.                      recins.zOrder            = CMA_TOP;
  1688.                      recins.cRecordsInsert    = 1;
  1689.                      recins.fInvalidateRecord = TRUE;
  1690.                       
  1691.                      WinSendMsg ( hwndP, CM_INSERTRECORD,
  1692.                                   MPFROMP( prec ), MPFROMP ( &recins ) );
  1693.                       
  1694.                      pfnSetSplit ( pdr->hwndE, pdr, TRUE );
  1695.                       
  1696.                      WinSendMsg ( hwnd, UWM_SHOW, MPFROMP ( prec ), NULL );
  1697.                       
  1698.                      WinSendMsg ( hwndP, CM_SETRECORDEMPHASIS,
  1699.                                   MPFROMP ( prec ),
  1700.                                   MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  1701.                       
  1702.                      break;
  1703.                   }
  1704.                   pfiBfr = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  1705.                                         MPFROMP ( pfiBfr ),
  1706.                                         MPFROMSHORT( CMA_NEXT ) );
  1707.                }
  1708.             }
  1709.             break;
  1710.              
  1711.          }
  1712.       }
  1713.       break;
  1714.        
  1715.       case WM_CONTROL:
  1716.       {
  1717.          ULONG        ulCmd;
  1718.          HWND         hwndP;
  1719.          PDATREC      pdr;
  1720.          PMAINTREC    prec = NULL;
  1721.          PMAINTREC    precX;
  1722.          PMCTLREC     pctl;
  1723.          PMCOLREC     pcol;
  1724.  
  1725.          ulCmd = 0;
  1726.           
  1727.          if ( SHORT1FROMMP ( mp1 ) == DIT_COLLIST )
  1728.          {
  1729.             hwndP = WinWindowFromID ( hwnd, DIT_COLLIST );
  1730.  
  1731.             switch ( SHORT2FROMMP ( mp1 ) ) 
  1732.             {
  1733.                case CN_EMPHASIS:
  1734.                {
  1735.                   PNOTIFYRECORDEMPHASIS pcnrEmf;
  1736.  
  1737.                   pcnrEmf = PVOIDFROMMP ( mp2 );
  1738.                    
  1739.                   if ( pcnrEmf && pcnrEmf->fEmphasisMask & CRA_SELECTED )
  1740.                      WinSendMsg ( hwnd, UWM_SHOW, MPFROMP ( pcnrEmf->pRecord ), NULL );
  1741.                }
  1742.                break;
  1743.                 
  1744.                case CN_INITDRAG:
  1745.                {
  1746.                   PCNRDRAGINIT  pcnrDrg;
  1747.                   PDRAGINFO     pdinfo;
  1748.                   DRAGITEM      ditem;
  1749.                   DRAGIMAGE     dimage;
  1750.       
  1751.                   pcnrDrg = PVOIDFROMMP ( mp2 );
  1752.                    
  1753.                   prec = (PMAINTREC) pcnrDrg->pRecord;
  1754.                    
  1755.                   if ( ! prec )
  1756.                      break;
  1757.                    
  1758.                   //*** Drag It ******************************************
  1759.                    
  1760.                   pdinfo = DrgAllocDraginfo ( 1 );
  1761.                    
  1762.                   ditem.hwndItem       = hwnd;
  1763.                   ditem.ulItemID       = (ULONG)prec;
  1764.                   ditem.hstrType       = DrgAddStrHandle ( DRT_TREE );
  1765.                   ditem.hstrRMF        = DrgAddStrHandle ( "<PM_SCRAPBOOK,DRF_COLMAINT>" );
  1766.                   ditem.fsControl      = 0;
  1767.                   ditem.fsSupportedOps = DO_COPYABLE | DO_MOVEABLE;
  1768.                    
  1769.                   DrgSetDragitem ( pdinfo, &ditem, sizeof(ditem), 0 );
  1770.                    
  1771.                   dimage.cb       = sizeof(DRAGIMAGE);
  1772.                   dimage.cptl     = 0;
  1773.                   dimage.hImage   = hptrMini;
  1774.                   dimage.fl       = DRG_ICON;
  1775.                   dimage.cxOffset = 0;
  1776.                   dimage.cyOffset = 0;
  1777.                    
  1778.                   WinSendMsg ( hwndP, CM_SETRECORDEMPHASIS,
  1779.                                MPFROMP ( prec ),
  1780.                                MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  1781.                    
  1782.                   DrgDrag ( hwnd, pdinfo, &dimage, 1, VK_ENDDRAG, NULL );
  1783.                    
  1784.                   WinSendMsg ( hwndP, CM_SETRECORDEMPHASIS,
  1785.                                MPFROMP ( prec ),
  1786.                                MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  1787.                    
  1788.                   //WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  1789.                     //           MPFROMP ( pRecDrg ),
  1790.                       //         MPFROM2SHORT ( FALSE, 0x00004000 ) );//CRA_CURSORED ) );
  1791.                    
  1792.                   DrgFreeDraginfo ( pdinfo );
  1793.                }
  1794.                break;
  1795.                 
  1796.                case CN_DRAGAFTER:
  1797.                {
  1798.                   PCNRDRAGINFO  pcnrDri;
  1799.                   PDRAGINFO     pdinfo;
  1800.                   PDRAGITEM     pditem;
  1801.       
  1802.                   pcnrDri = PVOIDFROMMP ( mp2 );
  1803.                    
  1804.                   pdinfo = pcnrDri->pDragInfo;
  1805.                    
  1806.                   DrgAccessDraginfo ( pdinfo );
  1807.                    
  1808.                   pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  1809.                    
  1810.                   if ( pditem->hwndItem != hwnd )
  1811.                   {
  1812.                      DrgFreeDraginfo ( pdinfo );
  1813.  
  1814.                      return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  1815.                   }
  1816.                   else if ( DrgVerifyRMF ( pditem, "PM_SCRAPBOOK", "DRF_COLMAINT" ) )
  1817.                   { 
  1818.                      DrgFreeDraginfo ( pdinfo );
  1819.                       
  1820.                      return ( MRFROM2SHORT ( DOR_DROP, DO_MOVE ) );
  1821.                       
  1822.                   }
  1823.                   else 
  1824.                   {
  1825.                      DrgFreeDraginfo ( pdinfo );
  1826.                       
  1827.                      return ( MRFROM2SHORT ( DOR_NEVERDROP, 0 ) );
  1828.                   }
  1829.                }
  1830.                 
  1831.                case CN_DROP:
  1832.                {
  1833.                   PCNRDRAGINFO  pcnrDri;
  1834.                   PDRAGINFO     pdinfo;
  1835.                   PDRAGITEM     pditem;
  1836.                   PFIELDINFO    pfiAft;
  1837.                   RECORDINSERT  recins;
  1838.       
  1839.                   pcnrDri = PVOIDFROMMP ( mp2 );
  1840.                    
  1841.                   pdinfo = pcnrDri->pDragInfo;
  1842.                    
  1843.                   DrgAccessDraginfo ( pdinfo );
  1844.                    
  1845.                   pditem = DrgQueryDragitemPtr ( pdinfo, 0 );
  1846.                    
  1847.                   prec  = (PMAINTREC) pditem->ulItemID;
  1848.                   precX = (PMAINTREC) pcnrDri->pRecord;
  1849.                    
  1850.                   if ( ! precX || prec == precX )
  1851.                   {
  1852.                      DrgFreeDraginfo ( pdinfo );
  1853.                      break;
  1854.                   }
  1855.                    
  1856.                   WinSendMsg ( hwndP, CM_REMOVERECORD,
  1857.                                MPFROMP ( &prec ),
  1858.                                MPFROM2SHORT( 1, CMA_INVALIDATE ) );
  1859.                    
  1860.                   //*** Insert *************************************************
  1861.                    
  1862.                   recins.cb                = sizeof ( RECORDINSERT );
  1863.                   recins.pRecordParent     = NULL;
  1864.                   recins.pRecordOrder      = (PRECORDCORE) precX;
  1865.                   recins.zOrder            = CMA_TOP;
  1866.                   recins.cRecordsInsert    = 1;
  1867.                   recins.fInvalidateRecord = TRUE;
  1868.                    
  1869.                   WinSendMsg ( hwndP, CM_INSERTRECORD,
  1870.                                MPFROMP( prec ), MPFROMP ( &recins ) );
  1871.  
  1872.                   //*** Editor *************************************************
  1873.                    
  1874.                   pdr = pRecScn->pdr;
  1875.  
  1876.                   pfnSetSplit ( pdr->hwndE, pdr, FALSE );
  1877.  
  1878.                   pctl = ( PMCTLREC ) pdr->pvWork;
  1879.                    
  1880.                   pcol = prec->pcol;//&pctl->mcols[prec->ulX];
  1881.                    
  1882.                   if ( CMA_FIRST == (LONG) precX )
  1883.                      pfiAft = (PFIELDINFO) CMA_FIRST;
  1884.                   else
  1885.                      pfiAft = precX->pcol->pfi;//pctl->mcols[precX->ulX].pfi;
  1886.                    
  1887.                   //*** Remove *************************************************
  1888.  
  1889.                   WinSendMsg ( pdr->hwndE, CM_REMOVEDETAILFIELDINFO,
  1890.                                MPFROMP ( &pcol->pfi ),
  1891.                                MPFROM2SHORT ( 1, CMA_INVALIDATE ) );
  1892.                    
  1893.                   pcol->pfi = pfnCol2FInfo ( pdr->hwndE, pcol, pcol->pfi/*NULL*/, pfiAft );
  1894.                    
  1895.                   pfnSetSplit ( pdr->hwndE, pdr, TRUE );
  1896.                }
  1897.                break;
  1898.                 
  1899.                case CN_BEGINEDIT:
  1900.                {
  1901.                   //PCNREDITDATA   pcnrEdt;
  1902.  
  1903.                   pRecScn->pdr->fbEditing = TRUE;
  1904.                    
  1905.                   WinSetDlgItemText ( hwnd, DIT_COLNAME, "~End Edit" );
  1906.                    
  1907.                   /*pcnrEdt = PVOIDFROMMP ( mp2 );
  1908.                    
  1909.                   WinSendMsg ( WinWindowFromID ( hwnd, DIT_COLLIST ), CM_SETRECORDEMPHASIS,
  1910.                                MPFROMP ( pcnrEdt->pRecord ),
  1911.                                MPFROM2SHORT ( TRUE, CRA_SELECTED ) );*/
  1912.                }
  1913.                break;//return ( MRESULT ) TRUE;
  1914.                 
  1915.                case CN_ENDEDIT:
  1916.                {
  1917.                   PCNREDITDATA     pcnrEdt;
  1918.  
  1919.                   pcnrEdt = PVOIDFROMMP ( mp2 );
  1920.                    
  1921.                   pRecScn->pdr->fbEditing = FALSE;
  1922.                    
  1923.                   WinSetDlgItemText ( hwnd, DIT_COLNAME, "~Edit Name" );
  1924.  
  1925.                   //*** Setup to Process Column Change *************************
  1926.  
  1927.                   ulCmd = MINI_ATTR;
  1928.  
  1929.                   prec = (PMAINTREC) pcnrEdt->pRecord;
  1930.  
  1931.                   pdr = pRecScn->pdr;
  1932.                    
  1933.                   pctl = ( PMCTLREC ) pdr->pvWork;
  1934.                    
  1935.                   pcol = prec->pcol;//&pctl->mcols[prec->ulX];
  1936.  
  1937.                   if ( pcnrEdt->cbText )
  1938.                   {
  1939.                      pcol->pszTitl = realloc ( pcol->pszTitl, pcnrEdt->cbText );
  1940.                      strcpy ( pcol->pszTitl, pcnrEdt->pRecord->pszIcon );
  1941.                   }
  1942.                }
  1943.                break;
  1944.                 
  1945.                case CN_REALLOCPSZ:
  1946.                {
  1947.                   PMAINTREC        pNew;
  1948.                   PCNREDITDATA     pcnrEdt;
  1949.  
  1950.                   pcnrEdt = PVOIDFROMMP ( mp2 );
  1951.                    
  1952.                   prec = (PMAINTREC) pcnrEdt->pRecord;
  1953.  
  1954.                   pdr = pRecScn->pdr;
  1955.                    
  1956.                   pctl = ( PMCTLREC ) pdr->pvWork;
  1957.                    
  1958.                   pcol = prec->pcol;//&pctl->mcols[prec->ulX];
  1959.                    
  1960.                   pcol->pszTitl = realloc ( pcol->pszTitl, pcnrEdt->cbText );
  1961.                   strcpy ( pcol->pszTitl, pcnrEdt->pRecord->pszIcon );
  1962.                    
  1963.                   pRecScn->pdr->fbModified = TRUE;
  1964.                   //fbModified = TRUE;
  1965.                    
  1966.                   //ulCmd = MINI_ATTR;
  1967.                    
  1968.                   pcnrEdt->pRecord->pszIcon = realloc ( pcnrEdt->pRecord->pszIcon, pcnrEdt->cbText );
  1969.                }
  1970.                return ( MRESULT ) TRUE;
  1971.                 
  1972.             }
  1973.             //break;
  1974.          }
  1975.          else
  1976.          {
  1977.             //if ( ! pRecScn->pdr->fbEditing )
  1978.                 
  1979.             prec = WinSendMsg ( WinWindowFromID ( hwnd, DIT_COLLIST ), CM_QUERYRECORDEMPHASIS,
  1980.                                 MPFROMLONG ( CMA_FIRST ), MPFROMSHORT( CRA_SELECTED ) );
  1981.              
  1982.             if ( ! prec ) 
  1983.             {
  1984.                WinAlarm ( HWND_DESKTOP, WA_NOTE );
  1985.                 
  1986.                break;
  1987.             }
  1988.              
  1989.             pdr = pRecScn->pdr;
  1990.              
  1991.             pctl = ( PMCTLREC ) pdr->pvWork;
  1992.              
  1993.             pcol = prec->pcol;//&pctl->mcols[prec->ulX];
  1994.              
  1995.             switch ( SHORT1FROMMP ( mp1 ) ) 
  1996.             {
  1997.                case DIT_COLSPLITCOL:
  1998.                {
  1999.                   ULONG ulX;
  2000.  
  2001.                   for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  2002.                   {
  2003.                      pctl->mcols[ulX].ulOpts &= ~SCB_MINI_SPLT;
  2004.                      pctl->mcols[ulX].ulOpts &= ~SCB_MINI_LEFT;
  2005.                   }
  2006.  
  2007.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSPLITCOL ) )
  2008.                   {
  2009.                      pctl->ulSplit = prec->pcol->ulX + 1;
  2010.                      pcol->ulOpts |= SCB_MINI_SPLT;
  2011.                   }
  2012.                   else
  2013.                   {
  2014.                      pctl->ulSplit = 0;
  2015.                   }
  2016.                   /*   pctl->ulSplit = prec->pcol->ulX + 1;
  2017.                   else
  2018.                      pctl->ulSplit = 0;*/
  2019.                    
  2020.                   pfnSetSplit ( pdr->hwndE, pdr, TRUE );
  2021.                }
  2022.                break;
  2023.                 
  2024.                //*** Sort Fields ***********************************************
  2025.                 
  2026.                case DIT_COLSORT1:
  2027.                {
  2028.                   ULONG     ulX;
  2029.    
  2030.                   ulCmd = MINI_SHOW;
  2031.                    
  2032.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT1 ) ) 
  2033.                   {
  2034.                      for ( ulX = 0; ulX < MINI_SORTS; ++ulX ) 
  2035.                      {
  2036.                         if ( ( pctl->abSort[ulX] - 1 ) == pcol->ulX )
  2037.                            pctl->abSort[ulX] = 0;
  2038.                      }
  2039.                       
  2040.                      pctl->abSort[0] = pcol->ulX + 1;
  2041.                       
  2042.                   }
  2043.                   else 
  2044.                      pctl->abSort[0] = 0;
  2045.                }
  2046.                break;
  2047.                 
  2048.                case DIT_COLSORT2:
  2049.                {
  2050.                   ULONG     ulX;
  2051.    
  2052.                   ulCmd = MINI_SHOW;
  2053.                    
  2054.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT2 ) ) 
  2055.                   {
  2056.                      for ( ulX = 0; ulX < MINI_SORTS; ++ulX ) 
  2057.                      {
  2058.                         if ( ( pctl->abSort[ulX] - 1 ) == pcol->ulX ) 
  2059.                            pctl->abSort[ulX] = 0;
  2060.                      }
  2061.                       
  2062.                      pctl->abSort[1] = pcol->ulX + 1;
  2063.                   }
  2064.                   else 
  2065.                      pctl->abSort[1] = 0;
  2066.                }
  2067.                break;
  2068.                 
  2069.                case DIT_COLSORT3:
  2070.                {
  2071.                   ULONG     ulX;
  2072.    
  2073.                   ulCmd = MINI_SHOW;
  2074.                    
  2075.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT3 ) ) 
  2076.                   {
  2077.                      for ( ulX = 0; ulX < MINI_SORTS; ++ulX ) 
  2078.                      {
  2079.                         if ( ( pctl->abSort[ulX] - 1 ) == pcol->ulX ) 
  2080.                            pctl->abSort[ulX] = 0;
  2081.                      }
  2082.                       
  2083.                      pctl->abSort[2] = pcol->ulX + 1;
  2084.                   }
  2085.                   else
  2086.                      pctl->abSort[2] = 0;
  2087.                }
  2088.                break;
  2089.                 
  2090.                case DIT_COLSORT4:
  2091.                {
  2092.                   ULONG     ulX;
  2093.    
  2094.                   ulCmd = MINI_SHOW;
  2095.                    
  2096.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT4 ) ) 
  2097.                   {
  2098.                      for ( ulX = 0; ulX < MINI_SORTS; ++ulX ) 
  2099.                      {
  2100.                         if ( ( pctl->abSort[ulX] - 1 ) == pcol->ulX ) 
  2101.                            pctl->abSort[ulX] = 0;
  2102.                      }
  2103.                       
  2104.                      pctl->abSort[3] = pcol->ulX + 1;
  2105.                   }
  2106.                   else
  2107.                      pctl->abSort[3] = 0;
  2108.                }
  2109.                break;
  2110.                 
  2111.                case DIT_COLSORT1_DEC:
  2112.                    
  2113.                   ulCmd = MINI_SHOW;
  2114.                    
  2115.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT1_DEC ) )
  2116.                      pctl->abSOpt[0] |= SCB_MINI_DESC;
  2117.                   else
  2118.                      pctl->abSOpt[0] &= ~SCB_MINI_DESC;
  2119.                    
  2120.                break;
  2121.                 
  2122.                case DIT_COLSORT2_DEC:
  2123.                    
  2124.                   ulCmd = MINI_SHOW;
  2125.                    
  2126.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT2_DEC ) )
  2127.                      pctl->abSOpt[1] |= SCB_MINI_DESC;
  2128.                   else
  2129.                      pctl->abSOpt[1] &= ~SCB_MINI_DESC;
  2130.                    
  2131.                break;
  2132.                 
  2133.                case DIT_COLSORT3_DEC:
  2134.                    
  2135.                   ulCmd = MINI_SHOW;
  2136.                    
  2137.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT3_DEC ) )
  2138.                      pctl->abSOpt[2] |= SCB_MINI_DESC;
  2139.                   else
  2140.                      pctl->abSOpt[2] &= ~SCB_MINI_DESC;
  2141.                    
  2142.                break;
  2143.                 
  2144.                case DIT_COLSORT4_DEC:
  2145.                    
  2146.                   ulCmd = MINI_SHOW;
  2147.                    
  2148.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLSORT4_DEC ) )
  2149.                      pctl->abSOpt[3] |= SCB_MINI_DESC;
  2150.                   else
  2151.                      pctl->abSOpt[3] &= ~SCB_MINI_DESC;
  2152.                    
  2153.                break;
  2154.                 
  2155.                 
  2156.                //*** Alignment Attrs *******************************************
  2157.                 
  2158.                case DIT_COLLEFT:
  2159.                    
  2160.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLLEFT ) ) 
  2161.                   {
  2162.                      ulCmd = MINI_ATTR;
  2163.                       
  2164.                      pcol->ulCHOpts &= ~CFA_RIGHT;
  2165.                      pcol->ulCHOpts &= ~CFA_CENTER;
  2166.                       
  2167.                      pcol->ulCHOpts |= CFA_LEFT;
  2168.                   }
  2169.                    
  2170.                break;
  2171.                 
  2172.                case DIT_COLRIGHT:
  2173.                    
  2174.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLRIGHT ) ) 
  2175.                   {
  2176.                      ulCmd = MINI_ATTR;
  2177.                       
  2178.                      pcol->ulCHOpts &= ~CFA_LEFT;
  2179.                      pcol->ulCHOpts &= ~CFA_CENTER;
  2180.                       
  2181.                      pcol->ulCHOpts |= CFA_RIGHT;
  2182.                   }
  2183.                    
  2184.                break;
  2185.                 
  2186.                case DIT_COLCENTER:
  2187.                    
  2188.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLCENTER ) ) 
  2189.                   {
  2190.                      ulCmd = MINI_ATTR;
  2191.                       
  2192.                      pcol->ulCHOpts &= ~CFA_LEFT;
  2193.                      pcol->ulCHOpts &= ~CFA_RIGHT;
  2194.                       
  2195.                      pcol->ulCHOpts |= CFA_CENTER;
  2196.                   }
  2197.                    
  2198.                break;
  2199.                 
  2200.                case DIT_COLTOP:
  2201.                    
  2202.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLTOP ) ) 
  2203.                   {
  2204.                      ulCmd = MINI_ATTR;
  2205.                       
  2206.                      pcol->ulCHOpts &= ~CFA_BOTTOM;
  2207.                      pcol->ulCHOpts &= ~CFA_VCENTER;
  2208.                       
  2209.                      pcol->ulCHOpts |= CFA_TOP;
  2210.                   }
  2211.                    
  2212.                break;
  2213.                 
  2214.                case DIT_COLBOTTOM:
  2215.                    
  2216.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLBOTTOM ) ) 
  2217.                   {
  2218.                      ulCmd = MINI_ATTR;
  2219.                       
  2220.                      pcol->ulCHOpts &= ~CFA_TOP;
  2221.                      pcol->ulCHOpts &= ~CFA_VCENTER;
  2222.                       
  2223.                      pcol->ulCHOpts |= CFA_BOTTOM;
  2224.                   }
  2225.                    
  2226.                break;
  2227.                 
  2228.                case DIT_COLVCENTER:
  2229.                    
  2230.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_COLVCENTER ) ) 
  2231.                   {
  2232.                      ulCmd = MINI_ATTR;
  2233.                       
  2234.                      pcol->ulCHOpts &= ~CFA_TOP;
  2235.                      pcol->ulCHOpts &= ~CFA_BOTTOM;
  2236.                       
  2237.                      pcol->ulCHOpts |= CFA_VCENTER;
  2238.                   }
  2239.                    
  2240.                break;
  2241.                 
  2242.                case DIT_DATLEFT:
  2243.                    
  2244.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATLEFT ) ) 
  2245.                   {
  2246.                      ulCmd = MINI_ATTR;
  2247.                       
  2248.                      pcol->ulCDOpts &= ~CFA_RIGHT;
  2249.                      pcol->ulCDOpts &= ~CFA_CENTER;
  2250.                       
  2251.                      pcol->ulCDOpts |= CFA_LEFT;
  2252.                   }
  2253.                    
  2254.                break;
  2255.                 
  2256.                case DIT_DATRIGHT:
  2257.                    
  2258.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATRIGHT ) ) 
  2259.                   {
  2260.                      ulCmd = MINI_ATTR;
  2261.                       
  2262.                      pcol->ulCDOpts &= ~CFA_LEFT;
  2263.                      pcol->ulCDOpts &= ~CFA_CENTER;
  2264.                       
  2265.                      pcol->ulCDOpts |= CFA_RIGHT;
  2266.                   }
  2267.                    
  2268.                break;
  2269.                 
  2270.                case DIT_DATCENTER:
  2271.                    
  2272.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATCENTER ) ) 
  2273.                   {
  2274.                      ulCmd = MINI_ATTR;
  2275.                       
  2276.                      pcol->ulCDOpts &= ~CFA_LEFT;
  2277.                      pcol->ulCDOpts &= ~CFA_RIGHT;
  2278.                       
  2279.                      pcol->ulCDOpts |= CFA_CENTER;
  2280.                   }
  2281.                    
  2282.                break;
  2283.                 
  2284.                case DIT_DATTOP:
  2285.                    
  2286.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATTOP ) ) 
  2287.                   {
  2288.                      ulCmd = MINI_ATTR;
  2289.                       
  2290.                      pcol->ulCDOpts &= ~CFA_BOTTOM;
  2291.                      pcol->ulCDOpts &= ~CFA_VCENTER;
  2292.                       
  2293.                      pcol->ulCDOpts |= CFA_TOP;
  2294.                   }
  2295.                    
  2296.                break;
  2297.                 
  2298.                case DIT_DATBOTTOM:
  2299.                    
  2300.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATBOTTOM ) ) 
  2301.                   {
  2302.                      ulCmd = MINI_ATTR;
  2303.                       
  2304.                      pcol->ulCDOpts &= ~CFA_TOP;
  2305.                      pcol->ulCDOpts &= ~CFA_VCENTER;
  2306.                       
  2307.                      pcol->ulCDOpts |= CFA_BOTTOM;
  2308.                   }
  2309.                    
  2310.                break;
  2311.                 
  2312.                case DIT_DATVCENTER:
  2313.                    
  2314.                   if ( prec && WinQueryButtonCheckstate ( hwnd, DIT_DATVCENTER ) ) 
  2315.                   {
  2316.                      ulCmd = MINI_ATTR;
  2317.                       
  2318.                      pcol->ulCDOpts &= ~CFA_TOP;
  2319.                      pcol->ulCDOpts &= ~CFA_BOTTOM;
  2320.                       
  2321.                      pcol->ulCDOpts |= CFA_VCENTER;
  2322.                   }
  2323.                    
  2324.                break;
  2325.                 
  2326.             }
  2327.          }
  2328.          switch ( ulCmd ) 
  2329.          {
  2330.             case MINI_ATTR:
  2331.                 
  2332.                pfnSetSplit ( pdr->hwndE, pdr, FALSE );
  2333.                 
  2334.                hwndP = pdr->hwndE;//WinWindowFromID ( hwnd, DIT_COLLIST );
  2335.                 
  2336.                pdr->pfi = WinSendMsg ( hwndP, CM_QUERYDETAILFIELDINFO,
  2337.                                        MPFROMP ( pcol->pfi ),
  2338.                                        MPFROMSHORT( CMA_PREV ) );
  2339.                 
  2340.                if ( ! pdr->pfi )
  2341.                   pdr->pfi = (PFIELDINFO)CMA_FIRST;
  2342.                 
  2343.                //*** Remove *************************************************
  2344.                 
  2345.                /*WinSendMsg ( hwndP, CM_REMOVEDETAILFIELDINFO,
  2346.                             MPFROMP ( &pcol->pfi ),
  2347.                             MPFROM2SHORT ( 1, CMA_INVALIDATE ) );*/
  2348.                 
  2349.                pcol->pfi = pfnCol2FInfo ( hwndP, pcol, pcol->pfi/*NULL*/, pdr->pfi );
  2350.                 
  2351.                pfnSetSplit ( pdr->hwndE, pdr, TRUE );
  2352.                 
  2353.             break;
  2354.              
  2355.             case MINI_SHOW:
  2356.                 
  2357.                WinSendMsg ( hwnd, UWM_SHOW, MPFROMP ( prec ), NULL );
  2358.                 
  2359.             break;
  2360.              
  2361.          }
  2362.       }
  2363.       break;
  2364.        
  2365.       default:
  2366.       return WinDefDlgProc ( hwnd, msg, mp1, mp2 );
  2367.        
  2368.    }
  2369.     
  2370.      return ( MRESULT ) FALSE;
  2371. }
  2372.  
  2373. /***************************************************************************/
  2374. /* Set the Split Bar                                                       */
  2375. /***************************************************************************/
  2376. BOOL             pfnSetSplit  ( HWND hwndP, PDATREC pdr, BOOL fbSplit ) 
  2377. {
  2378.    ULONG        ulX;
  2379.    PMCTLREC     pctl;
  2380.    PFIELDINFO   pfinf;
  2381.    PMCOLREC     pcol;
  2382.    CNRINFO      cnrinf;
  2383.    ULONG        ulSide;
  2384.     
  2385.    pctl = (PMCTLREC) pdr->pvWork;
  2386.     
  2387.    cnrinf.pFieldInfoLast = NULL;
  2388.     
  2389.    cnrinf.xVertSplitbar = -1;
  2390.     
  2391.    ulSide = SCB_MINI_LEFT;
  2392.  
  2393.    if ( fbSplit ) 
  2394.    {
  2395.       pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2396.                            NULL, MPFROMSHORT( CMA_FIRST ) );
  2397.        
  2398.       pctl->ulSplit = 0;
  2399.  
  2400.       for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  2401.       {
  2402.          pcol = (PMCOLREC) pfinf->pUserData;
  2403.           
  2404.          pcol->ulOpts |= ulSide;
  2405.  
  2406.          //if ( pcol->ulX == ( pctl->ulSplit - 1 ) )
  2407.          if ( pcol->ulOpts & SCB_MINI_SPLT )
  2408.          {
  2409.             if ( pcol->ulOpts & SCB_MINI_USED )
  2410.             {
  2411.                cnrinf.pFieldInfoLast = pcol->pfi;
  2412.                 
  2413.                cnrinf.xVertSplitbar = pdr->ulXVS;
  2414.  
  2415.                pctl->ulSplit = pcol->ulX + 1;
  2416.          
  2417.                ulSide = 0;
  2418.             }
  2419.             /*else
  2420.                pctl->ulSplit = 0;*/
  2421.              
  2422.             break;
  2423.          }
  2424.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2425.                               MPFROMP ( pfinf ),
  2426.                               MPFROMSHORT( CMA_NEXT ) );
  2427.       }
  2428.    }
  2429.    else 
  2430.    {
  2431.       WinSendMsg ( hwndP, CM_QUERYCNRINFO,
  2432.                    MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  2433.        
  2434.       pdr->ulXVS = cnrinf.xVertSplitbar;
  2435.    }
  2436.     
  2437.    WinSendMsg ( hwndP, CM_SETCNRINFO,
  2438.                 MPFROMP ( &cnrinf ),
  2439.                 MPFROMLONG ( CMA_PFIELDINFOLAST | CMA_XVERTSPLITBAR ) );
  2440.     
  2441.    return TRUE;
  2442. }
  2443.  
  2444. /***************************************************************************/
  2445. /* See Which Side of Split Bar We're On                                    */
  2446. /***************************************************************************/
  2447. USHORT           pfnWhichSplit( HWND hwndP, PDATREC pdr, SHORT cmd, PMCTLREC pctl )
  2448. {
  2449.    ULONG        ulX;
  2450.    USHORT       usWhich;
  2451.    PMCOLREC     pcolScn;
  2452.    CNRINFO      cnrinf;
  2453.    PFIELDINFO   pfinf;
  2454.    BOOL         foundIt = FALSE;
  2455.     
  2456.    WinSendMsg ( hwndP, CM_QUERYCNRINFO,
  2457.                 MPFROMP( &cnrinf ), MPFROMSHORT ( 16 ) );
  2458.  
  2459.    usWhich = usLeftDvWnd;
  2460.     
  2461.    //*** Find Next/Previous Visible Column *************************************
  2462.  
  2463.    if ( cmd == MID_MINI_NEXT )
  2464.       pdr->pfi = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2465.                               MPFROMP ( pdr->pfi ),
  2466.                               MPFROMSHORT( CMA_NEXT ) );
  2467.    else
  2468.       pdr->pfi = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2469.                               MPFROMP ( pdr->pfi ),
  2470.                               MPFROMSHORT( CMA_PREV ) );
  2471.     
  2472.    for ( ulX = 0; ulX < MINI_COLS && pdr->pfi; ++ulX )
  2473.    {
  2474.       pcolScn = (PMCOLREC) pdr->pfi->pUserData;
  2475.        
  2476.       if ( pcolScn->ulOpts & SCB_MINI_USED )
  2477.       {
  2478.          if ( pcolScn->ulOpts & SCB_MINI_LEFT )
  2479.             return usLeftDvWnd;
  2480.          else
  2481.             return usRightDvWnd;
  2482.          /*if ( ! pctl->ulSplit )
  2483.          {
  2484.             usWhich = usLeftDvWnd;
  2485.       
  2486.             return usWhich;
  2487.          }
  2488.           
  2489.          if ( foundIt )
  2490.          {
  2491.             usWhich = usRightDvWnd;
  2492.             break;
  2493.          }
  2494.           
  2495.          if ( cnrinf.pFieldInfoLast == pdr->pfi )
  2496.          {
  2497.             usWhich = usLeftDvWnd;
  2498.             foundIt = TRUE;
  2499.          } */
  2500.       }
  2501.        
  2502.       if ( cmd == MID_MINI_NEXT )
  2503.          pdr->pfi = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2504.                                  MPFROMP ( pdr->pfi ),
  2505.                                  MPFROMSHORT( CMA_NEXT ) );
  2506.       else
  2507.          pdr->pfi = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  2508.                                  MPFROMP ( pdr->pfi ),
  2509.                                  MPFROMSHORT( CMA_PREV ) );
  2510.    }
  2511.     
  2512.    return usWhich;
  2513. }
  2514.  
  2515. /***************************************************************************/
  2516. /* Convert Column to Field Info Structure                                  */
  2517. /***************************************************************************/
  2518. PFIELDINFO       pfnCol2FInfo ( HWND hwndP, PMCOLREC pcol, 
  2519.                                 PFIELDINFO pfiTo, PFIELDINFO pfiAft )
  2520. {
  2521.    FIELDINFOINSERT       fInfIns;
  2522.     
  2523.    if ( ! pfiTo )
  2524.       pfiTo = WinSendMsg ( hwndP, CM_ALLOCDETAILFIELDINFO, 
  2525.                            MPFROMLONG ( 1 ), NULL);
  2526.  
  2527.    WinSendMsg ( hwndP, CM_REMOVEDETAILFIELDINFO,
  2528.                 MPFROMP ( &pfiTo ),
  2529.                 MPFROM2SHORT ( 1, CMA_INVALIDATE ) );
  2530.     
  2531.    pfiTo->cb         = sizeof ( FIELDINFO );
  2532.    pfiTo->flData     = pcol->ulCDOpts;
  2533.    pfiTo->flTitle    = pcol->ulCHOpts;
  2534.    pfiTo->pTitleData = pcol->pszTitl;
  2535.    pfiTo->offStruct  = pcol->ulOffset;
  2536.    pfiTo->pUserData  = pcol;
  2537.     
  2538.    //*** Insert ? ************************************************
  2539.     
  2540.    if ( pfiAft ) 
  2541.    {
  2542.       fInfIns.cb                   = sizeof ( FIELDINFOINSERT );
  2543.       fInfIns.pFieldInfoOrder      = pfiAft;
  2544.       fInfIns.cFieldInfoInsert     = 1;
  2545.       fInfIns.fInvalidateFieldInfo = TRUE;
  2546.        
  2547.       WinSendMsg ( hwndP, CM_INSERTDETAILFIELDINFO,
  2548.                    MPFROMP ( pfiTo ),
  2549.                    MPFROMP ( &fInfIns ) );
  2550.    }
  2551.     
  2552.    return pfiTo;
  2553.     
  2554. }
  2555.  
  2556. /***************************************************************************/
  2557. /* Copy Data to Memory                                                     */
  2558. /***************************************************************************/
  2559. ULONG            pfnMiniRecMem( HWND hwnd, PMINIREC pRecIn, ULONG ulSize, PBYTE pbDat ) 
  2560. {
  2561.    PSZ         *ppszX;
  2562.    ULONG        ulX;
  2563.    PFIELDINFO   pfi;
  2564.    PMCOLREC     pcol;
  2565.     
  2566.    ULONG        ulLen;
  2567.     
  2568.    if ( ! ulSize ) 
  2569.    {
  2570.       pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  2571.                          MPFROMP ( NULL ),
  2572.                          MPFROMSHORT( CMA_FIRST ) );
  2573.        
  2574.       for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  2575.       {
  2576.          pcol = (PMCOLREC) pfi->pUserData;
  2577.           
  2578.          if ( pcol->ulOpts & SCB_MINI_USED )
  2579.          {
  2580.             ppszX = &pRecIn->psz01;
  2581.              
  2582.             ppszX += ( pcol->ulX );
  2583.  
  2584.             ulSize += strlen ( *ppszX ) + 1;
  2585.          }
  2586.           
  2587.          pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  2588.                             MPFROMP ( pfi ),
  2589.                             MPFROMSHORT( CMA_NEXT ) );
  2590.       }
  2591.  
  2592.       ulSize += sizeof ( CDATE );
  2593.       ulSize += sizeof ( ULONG );
  2594.    }
  2595.    else 
  2596.    {
  2597.       ulSize = 0;
  2598.        
  2599.       pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  2600.                          MPFROMP ( NULL ),
  2601.                          MPFROMSHORT( CMA_FIRST ) );
  2602.        
  2603.       for ( ulX = 0; pfi && ulX < MINI_COLS; ++ulX ) 
  2604.       {
  2605.          pcol = (PMCOLREC) pfi->pUserData;
  2606.           
  2607.          if ( pcol->ulOpts & SCB_MINI_USED )
  2608.          {
  2609.             ppszX = &pRecIn->psz01;
  2610.              
  2611.             ppszX += ( pcol->ulX );
  2612.  
  2613.             ulLen = strlen ( *ppszX ) + 1;
  2614.             memcpy ( pbDat, *ppszX, ulLen );
  2615.             pbDat += ulLen;
  2616.              
  2617.             ulSize += ulLen;
  2618.          }
  2619.           
  2620.          pfi = WinSendMsg ( hwnd, CM_QUERYDETAILFIELDINFO,
  2621.                             MPFROMP ( pfi ),
  2622.                             MPFROMSHORT( CMA_NEXT ) );
  2623.       }
  2624.  
  2625.       memcpy ( pbDat, &pRecIn->cdUpd, sizeof ( CDATE ) );
  2626.       pbDat += sizeof ( CDATE );
  2627.  
  2628.       memcpy ( pbDat, &pRecIn->ulOpt, sizeof ( ULONG ) );
  2629.       pbDat += sizeof ( ULONG );
  2630.    }
  2631.     
  2632.    return ulSize;
  2633.     
  2634. }
  2635.  
  2636. /***************************************************************************/
  2637. /* Mini  Sort                                                              */
  2638. /***************************************************************************/
  2639. SHORT   APIENTRY pfnMiniSort  ( PRECORDCORE pRec1, PRECORDCORE pRec2, PVOID pv ) 
  2640. {
  2641.    PMINIREC  p1;
  2642.    PMINIREC  p2;
  2643.     
  2644.    PMCTLREC  pctl;
  2645.     
  2646.    SHORT     sRC;
  2647.    SHORT     sX;
  2648.     
  2649.    PSZ       *ppsz1;
  2650.    PSZ       *ppsz2;
  2651.    PSZ       psz1;
  2652.    PSZ       psz2;
  2653.     
  2654.    p1 = (PMINIREC) pRec1;
  2655.    p2 = (PMINIREC) pRec2;
  2656.     
  2657.    pctl = ( PMCTLREC) pv;
  2658.     
  2659.    sRC = 0;
  2660.     
  2661.    ppsz1 = &p1->psz01;
  2662.    ppsz2 = &p2->psz01;
  2663.     
  2664.    for ( sX = 0; sX < MINI_SORTS && sX < pctl->ulCols; ++sX ) 
  2665.    {
  2666.       if ( ( ! sRC ) && pctl->abSort[sX] ) 
  2667.       {
  2668.          psz1 = ppsz1[pctl->abSort[sX]-1];
  2669.          psz2 = ppsz2[pctl->abSort[sX]-1];
  2670.           
  2671.          sRC = stricmp ( psz1, psz2 );
  2672.           
  2673.          if ( pctl->abSOpt[sX] & SCB_MINI_DESC ) 
  2674.          {
  2675.             sRC *= (-1);
  2676.          }
  2677.       }
  2678.    }
  2679.     
  2680.    return sRC;
  2681.     
  2682. }
  2683.  
  2684. /***************************************************************************/
  2685. /* Mini  Stat                                                              */
  2686. /***************************************************************************/
  2687. BOOL             pfnMiniStat  ( PUSEREC pRecScn ) 
  2688. {
  2689.    //CNRINFO               cnrinf;
  2690.     
  2691.    sprintf ( pRecScn->pdr->pszStat, "%d entries", pRecScn->pdr->ulDEnt );
  2692.     
  2693.    pfnCnrTitle ( pRecScn->pdr->hwndE, pRecScn->pdr->pszStat );
  2694.  
  2695.    //cnrinf.pszCnrTitle  = pRecScn->pdr->pszStat;
  2696.     
  2697.    //WinSendMsg ( pRecScn->pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  2698.      //           MPFROMLONG ( CMA_CNRTITLE ) );
  2699.     
  2700.    return TRUE;
  2701. }
  2702.  
  2703. /***************************************************************************/
  2704. /* Create Mini Container                                                   */
  2705. /***************************************************************************/
  2706. PBYTE            pfnMiniCont  ( HWND hwnd, PUSEREC pRecScn )
  2707. {
  2708.    PDATREC           pdr;
  2709.    PMCTLREC          pctl;
  2710.    CNRINFO           cnrinf;
  2711.    PFIELDINFO        pfinf;
  2712.    PFIELDINFO        pfinfScn;
  2713.    FIELDINFOINSERT   fInfIns;
  2714.    SWP               swp;
  2715.    ULONG             ulX;
  2716.    ULONG             ulLen;
  2717.    PBYTE             pbDat;
  2718.    PCHAR             pchDat;
  2719.    ULONG             ulSide;
  2720.     
  2721.    pdr = pRecScn->pdr;
  2722.  
  2723.    pdr->hwndE = WinCreateWindow ( hwnd, WC_CONTAINER, NULL,
  2724.                                   CCS_SINGLESEL,
  2725.                                   0,0,0,0, hwnd, HWND_TOP,
  2726.                                   WID_CONT, NULL, NULL );
  2727.     
  2728.    WinSetWindowPtr ( pdr->hwndE, 0, pRecScn );
  2729.     
  2730.    cnrinf.pszCnrTitle  = pdr->pszStat;
  2731.    cnrinf.flWindowAttr = CV_DETAIL | CA_DETAILSVIEWTITLES | CA_ORDEREDTARGETEMPH;
  2732.     
  2733.    if ( ulMiniOpts & SCB_STATED )
  2734.       cnrinf.flWindowAttr |= CA_CONTAINERTITLE | CA_TITLESEPARATOR | CA_TITLEREADONLY;
  2735.     
  2736.    WinSendMsg ( pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  2737.                 MPFROMLONG ( CMA_FLWINDOWATTR ) );
  2738.     
  2739.    pfnSetPPFont ( pdr->hwndE, pdr->fxPtSz, &pdr->fat );
  2740.     
  2741.    pfnSetPresColors ( pdr->hwndE, pdr->ulNBClr, pdr->ulNFClr, pdr->ulHBClr, pdr->ulHFClr );
  2742.     
  2743.    WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  2744.                 MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  2745.     
  2746.    //*** Allocate & Init Field Info ***********************************
  2747.     
  2748.    pctl = ( PMCTLREC ) pdr->pvWork;
  2749.     
  2750.    pbDat = pdr->pvDat;
  2751.  
  2752.    for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  2753.    {
  2754.       memset ( &pctl->mcols[ulX], 0, sizeof ( MCOLREC ) );
  2755.  
  2756.       pctl->mcols[ulX].ulX = ulX;
  2757.    }
  2758.     
  2759.    pfinf = WinSendMsg ( pdr->hwndE, CM_ALLOCDETAILFIELDINFO,
  2760.                         MPFROMLONG ( MINI_COLS ), NULL);
  2761.    pfinfScn = pfinf;
  2762.     
  2763.    if ( ! pdr->ulDLen ) 
  2764.    {
  2765.       pctl->ulCols  = ulMDefCols;
  2766.       pctl->ulSplit = 2;
  2767.        
  2768.       pctl->abSort[0] = 1;
  2769.       pctl->abSort[1] = 2;
  2770.       pctl->abSort[2] = 3;
  2771.       pctl->abSort[3] = 0;
  2772.        
  2773.       pctl->abSOpt[0] = 0;
  2774.       pctl->abSOpt[1] = 0;
  2775.       pctl->abSOpt[2] = 0;
  2776.       pctl->abSOpt[3] = 0;
  2777.        
  2778.       for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  2779.       {
  2780.          pctl->mcols[ulX].ulCHOpts = CFA_TOP | CFA_CENTER | CFA_FITITLEREADONLY;
  2781.          pctl->mcols[ulX].ulCDOpts = CFA_STRING | CFA_TOP | CFA_LEFT | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  2782.          pctl->mcols[ulX].ulOffset = ( ( FIELDOFFSET ( MINIREC, psz01 ) ) + ( ulX * sizeof ( PSZ) ) );
  2783.          pctl->mcols[ulX].ulOpts   = 0;
  2784.          pctl->mcols[ulX].ulStyl   = 0;
  2785.          pctl->mcols[ulX].ulChrs   = 0;
  2786.          pctl->mcols[ulX].ulX      = ulX;
  2787.          pctl->mcols[ulX].pszTitl  = strdup ( "Title" );
  2788.          pctl->mcols[ulX].pfi      = 0;
  2789.           
  2790.          pfinfScn->cb         = sizeof ( FIELDINFO );
  2791.          pfinfScn->flData     = pctl->mcols[ulX].ulCDOpts;
  2792.          pfinfScn->flTitle    = pctl->mcols[ulX].ulCHOpts;
  2793.          pfinfScn->pTitleData = strdup ( pctl->mcols[ulX].pszTitl );
  2794.          pfinfScn->offStruct  = pctl->mcols[ulX].ulOffset;
  2795.          pfinfScn->pUserData  = &pctl->mcols[ulX];
  2796.           
  2797.          if ( ulX < pctl->ulCols )
  2798.          {
  2799.             pctl->mcols[ulX].ulOpts   = SCB_MINI_USED;
  2800.  
  2801.             if ( ulX <= ( pctl->ulSplit - 1 ) )
  2802.                pctl->mcols[ulX].ulOpts  |= SCB_MINI_LEFT;
  2803.  
  2804.             if ( ulX == ( pctl->ulSplit - 1 ) )
  2805.             {
  2806.                cnrinf.pFieldInfoLast = pfinfScn;
  2807.                pctl->mcols[ulX].ulOpts  |= SCB_MINI_SPLT;
  2808.             }
  2809.          }
  2810.          else
  2811.          {
  2812.             pfinfScn->flData        |= CFA_INVISIBLE;
  2813.          }
  2814.  
  2815.          pctl->mcols[ulX].pfi      = pfinfScn;
  2816.           
  2817.          pfinfScn             = pfinfScn->pNextFieldInfo;
  2818.       }
  2819.        
  2820.       //*** Insert ****************************************************
  2821.        
  2822.       fInfIns.cb                   = sizeof ( FIELDINFOINSERT );
  2823.       fInfIns.pFieldInfoOrder      = (PFIELDINFO)CMA_FIRST;
  2824.       fInfIns.cFieldInfoInsert     = MINI_COLS;
  2825.       fInfIns.fInvalidateFieldInfo = TRUE;
  2826.        
  2827.       WinSendMsg ( pdr->hwndE, CM_INSERTDETAILFIELDINFO,
  2828.                    MPFROMP ( pfinf ),
  2829.                    MPFROMP ( &fInfIns ) );
  2830.    }
  2831.    else 
  2832.    {
  2833.        
  2834.       memcpy ( &pctl->ulCols, pbDat, sizeof ( ULONG ) );
  2835.        
  2836.       pbDat += sizeof ( ULONG );
  2837.        
  2838.       memcpy ( &pctl->ulSplit, pbDat, sizeof ( ULONG ) );
  2839.        
  2840.       pbDat += sizeof ( ULONG );
  2841.        
  2842.       memcpy ( &pctl->abSort, pbDat, sizeof ( BYTE ) * MINI_SORTS );
  2843.        
  2844.       pbDat += ( sizeof ( BYTE ) * MINI_SORTS );
  2845.        
  2846.       memcpy ( &pctl->abSOpt, pbDat, sizeof ( BYTE ) * MINI_SORTS );
  2847.        
  2848.       pbDat += ( sizeof ( BYTE ) * MINI_SORTS );
  2849.        
  2850.       for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  2851.       {
  2852.          memcpy ( &pctl->mcols[ulX], pbDat, sizeof ( MCOLREC ) );
  2853.           
  2854.          pbDat += sizeof ( MCOLREC );
  2855.       }
  2856.  
  2857.       ulSide = SCB_MINI_LEFT;
  2858.  
  2859.       for ( ulX = 0; ulX < MINI_COLS; ++ulX )
  2860.       {
  2861.          pchDat = (PCHAR) pbDat;
  2862.  
  2863.          pctl->mcols[ulX].pfi = pfinf;
  2864.           
  2865.          //*** Get Title **********************************************
  2866.           
  2867.          ulLen = strlen ( pchDat ) + 1;
  2868.           
  2869.          pctl->mcols[ulX].pszTitl = malloc ( ulLen );
  2870.           
  2871.          memcpy ( pctl->mcols[ulX].pszTitl, pchDat, ulLen );
  2872.           
  2873.          pbDat += ulLen;
  2874.           
  2875.          //*** Init Field Info ****************************************
  2876.           
  2877.          pfinfScn->cb         = sizeof ( FIELDINFO );
  2878.          pfinfScn->flData     = pctl->mcols[ulX].ulCDOpts;
  2879.          pfinfScn->flTitle    = pctl->mcols[ulX].ulCHOpts;
  2880.          pfinfScn->pTitleData = pctl->mcols[ulX].pszTitl;
  2881.          pfinfScn->pUserData  = &pctl->mcols[ulX];
  2882.           
  2883.          pfinfScn->offStruct  = pctl->mcols[ulX].ulOffset;
  2884.           
  2885.          if ( ! ( pctl->mcols[ulX].ulOpts & SCB_MINI_USED ) )
  2886.             pfinfScn->flData |= CFA_INVISIBLE;
  2887.          else
  2888.          {
  2889.             pctl->mcols[ulX].ulOpts |= ulSide;
  2890.  
  2891.             if ( pctl->mcols[ulX].ulOpts & SCB_MINI_SPLT )
  2892.             {
  2893.                cnrinf.pFieldInfoLast = pfinfScn;
  2894.                ulSide = 0;
  2895.             }
  2896.          }
  2897.  
  2898.          pctl->mcols[ulX].pfi = pfinfScn;
  2899.           
  2900.          pfinfScn = pfinfScn->pNextFieldInfo;
  2901.       }
  2902.        
  2903.       //*** Insert ****************************************************
  2904.        
  2905.       fInfIns.cb                   = sizeof ( FIELDINFOINSERT );
  2906.       fInfIns.pFieldInfoOrder      = (PFIELDINFO)CMA_FIRST;
  2907.       fInfIns.cFieldInfoInsert     = MINI_COLS;
  2908.       fInfIns.fInvalidateFieldInfo = TRUE;
  2909.        
  2910.       WinSendMsg ( pdr->hwndE, CM_INSERTDETAILFIELDINFO,
  2911.                    MPFROMP ( pfinf ),
  2912.                    MPFROMP ( &fInfIns ) );
  2913.        
  2914.       //if ( pctl->ulSplit )
  2915.         // cnrinf.pFieldInfoLast = pctl->mcols[pctl->ulSplit-1].pfi;
  2916.    }
  2917.     
  2918.    //*** Position Container *******************************************
  2919.     
  2920.    if ( pctl->ulSplit )
  2921.       WinSendMsg ( pdr->hwndE, CM_SETCNRINFO,
  2922.                    MPFROMP ( &cnrinf ),
  2923.                    MPFROMLONG ( CMA_PFIELDINFOLAST ) );
  2924.     
  2925.    WinQueryWindowPos ( hwnd, &swp );
  2926.     
  2927.    WinSetWindowPos ( pdr->hwndE, HWND_TOP,
  2928.                      0, 0,
  2929.                      swp.cx,
  2930.                      swp.cy,
  2931.                      SWP_SIZE | SWP_MOVE | SWP_SHOW );
  2932.     
  2933.    WinSetFocus ( HWND_DESKTOP, pdr->hwndE );
  2934.     
  2935.    //*** Set up Splitbar **********************************************
  2936.     
  2937.    if ( (LONG) pdr->ulXVS <= 0 )
  2938.       pdr->ulXVS = swp.cx / 4 * 3;
  2939.     
  2940.    if ( pctl->ulSplit ) 
  2941.    {
  2942.       cnrinf.xVertSplitbar = pdr->ulXVS;
  2943.        
  2944.       WinSendMsg ( pdr->hwndE, CM_SETCNRINFO,
  2945.                    MPFROMP ( &cnrinf ),
  2946.                    MPFROMLONG ( CMA_XVERTSPLITBAR ) );
  2947.    }
  2948.  
  2949.    return pbDat;
  2950. }
  2951.  
  2952. //****************************************************************************
  2953. // Init Menu
  2954. //****************************************************************************
  2955. VOID             pfnMiniMenu  ( PUSEREC pRecScn, HWND hwndMenu, SHORT sMID )
  2956. {
  2957.    PMINIREC   pFoc;
  2958.  
  2959.    switch ( sMID )
  2960.    {
  2961.       case MID_MINI_FILE:
  2962.          if ( pqi.pDriverData )
  2963.             WinEnableMenuItem ( hwndMenu, MID_MINI_PRINT, TRUE  );
  2964.          else
  2965.             WinEnableMenuItem ( hwndMenu, MID_MINI_PRINT, FALSE );
  2966.       break;
  2967.           
  2968.       case MID_MINI_EDIT:
  2969.           
  2970.          if (  pfnIsMyClip ( hwndMenu, atomMini ) )
  2971.             WinEnableMenuItem ( hwndMenu, MID_MINI_PASTE, TRUE );
  2972.          else
  2973.             WinEnableMenuItem ( hwndMenu, MID_MINI_PASTE, FALSE );
  2974.           
  2975.          pFoc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  2976.                              MPFROMLONG ( CMA_FIRST ),
  2977.                              MPFROMSHORT( CRA_SELECTED ) );
  2978.           
  2979.          if (  pFoc ) 
  2980.          {
  2981.             WinEnableMenuItem ( hwndMenu, MID_MINI_CUT,  TRUE );
  2982.             WinEnableMenuItem ( hwndMenu, MID_MINI_COPY, TRUE );
  2983.             WinEnableMenuItem ( hwndMenu, MID_MINI_DELT, TRUE );
  2984.          }
  2985.          else 
  2986.          {
  2987.             WinEnableMenuItem ( hwndMenu, MID_MINI_CUT,  FALSE );
  2988.             WinEnableMenuItem ( hwndMenu, MID_MINI_COPY, FALSE );
  2989.             WinEnableMenuItem ( hwndMenu, MID_MINI_DELT, FALSE );
  2990.          }
  2991.           
  2992.          if ( pRecScn->pdr->psSrch->hwndS  || ! pFoc )
  2993.             WinEnableMenuItem ( hwndMenu, MID_MINI_FIND, FALSE );
  2994.          else 
  2995.             WinEnableMenuItem ( hwndMenu, MID_MINI_FIND, TRUE  );
  2996.           
  2997.          if ( *pRecScn->pdr->psSrch->pszFnd && pFoc )
  2998.             WinEnableMenuItem ( hwndMenu, MID_MINI_FNDNXT, TRUE );
  2999.          else 
  3000.             WinEnableMenuItem ( hwndMenu, MID_MINI_FNDNXT, FALSE );
  3001.       break;
  3002.    }
  3003. }
  3004.  
  3005. //****************************************************************************
  3006. // Init Mini Strings
  3007. //****************************************************************************
  3008. VOID             pfnInitStrings( PMINIREC pNew )
  3009. {
  3010.    pNew->psz01 = malloc ( 1 );
  3011.    pNew->psz02 = malloc ( 1 );
  3012.    pNew->psz03 = malloc ( 1 );
  3013.    pNew->psz04 = malloc ( 1 );
  3014.    pNew->psz05 = malloc ( 1 );
  3015.    pNew->psz06 = malloc ( 1 );
  3016.    pNew->psz07 = malloc ( 1 );
  3017.    pNew->psz08 = malloc ( 1 );
  3018.    pNew->psz09 = malloc ( 1 );
  3019.    pNew->psz10 = malloc ( 1 );
  3020.    pNew->psz11 = malloc ( 1 );
  3021.    pNew->psz12 = malloc ( 1 );
  3022.    pNew->psz13 = malloc ( 1 );
  3023.    pNew->psz14 = malloc ( 1 );
  3024.    pNew->psz15 = malloc ( 1 );
  3025.    pNew->psz16 = malloc ( 1 );
  3026.     
  3027.    *pNew->psz01 = 0;
  3028.    *pNew->psz02 = 0;
  3029.    *pNew->psz03 = 0;
  3030.    *pNew->psz04 = 0;
  3031.    *pNew->psz05 = 0;
  3032.    *pNew->psz06 = 0;
  3033.    *pNew->psz07 = 0;
  3034.    *pNew->psz08 = 0;
  3035.    *pNew->psz09 = 0;
  3036.    *pNew->psz10 = 0;
  3037.    *pNew->psz11 = 0;
  3038.    *pNew->psz12 = 0;
  3039.    *pNew->psz13 = 0;
  3040.    *pNew->psz14 = 0;
  3041.    *pNew->psz15 = 0;
  3042.    *pNew->psz16 = 0;
  3043. }
  3044.  
  3045. //****************************************************************************
  3046. // Print Thread
  3047. //****************************************************************************
  3048. VOID             pfnMiniPrtThd       ( PVOID pv )
  3049. {
  3050.    HMQ         hmq;
  3051.    PDATREC     pdr;
  3052.    PMINIREC    pPrt;
  3053.    ULONG       ulPrinted = 0;
  3054.    LONG        lCharsOut;
  3055.    LONG        lCharsLeft = 1;
  3056.    LONG        lNewBottom;
  3057.    LONG        lLowBottom;
  3058.    BOOL        fbCausePage = FALSE;
  3059.    FONTMETRICS fm;
  3060.    RECTL       rclText;
  3061.    POINTL      pt;
  3062.    SHORT       sColsDone;
  3063.    SHORT       sCurCol;
  3064.    SHORT       sX;
  3065.    //CHAR        ach32[32];
  3066.    PSZ        *ppszX;
  3067.    PFIELDINFO  pfinf;
  3068.    PMCOLREC    pcol;
  3069.  
  3070.    hmq = WinCreateMsgQueue ( WinQueryAnchorBlock ( hwndM ), 0 );
  3071.  
  3072.    pdr = pprtCtl->pPrtRec->pdr;
  3073.  
  3074.    ++pprtCtl->ulPrtPage;
  3075.  
  3076.    pdr->ulPrtPage = pprtCtl->ulPrtPage;
  3077.  
  3078.    pfnMiniPrintInit ();
  3079.  
  3080.    fm = pprtCtl->fmAll;
  3081.  
  3082.    //*** Print Entry ********************************************************
  3083.  
  3084.    rclText.yBottom = pprtCtl->rclBody.yBottom;
  3085.    rclText.yTop    = rclText.yBottom;
  3086.  
  3087.    sColsDone = pprtCtl->sVisCols;
  3088.  
  3089.    for ( sX = 0; sX < MINI_COLS; ++sX )
  3090.    {
  3091.       pprtCtl->abfinf[sX]   = TRUE;
  3092.       pprtCtl->apszfinf[sX] = NULL;
  3093.    }
  3094.  
  3095.    pPrt = pfnGetCnrRec ( pdr->hwndE, NULL );
  3096.     
  3097.    while ( pPrt && fbPrinting )
  3098.    {
  3099.       if ( rclText.yTop - fm.lMaxBaselineExt < rclText.yBottom )
  3100.       {
  3101.          pfnMiniNewPage ( fbCausePage );
  3102.  
  3103.          fbCausePage = TRUE;
  3104.          rclText.yTop = pprtCtl->arclfinf[0].yBottom - fm.lMaxDescender;
  3105.          lLowBottom   = rclText.yTop;
  3106.          lNewBottom   = lLowBottom;
  3107.       }
  3108.  
  3109.       sCurCol = 0;
  3110.  
  3111.       //*** Print Columns ***************************************************
  3112.  
  3113.       pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3114.                            MPFROMP ( NULL ),
  3115.                            MPFROMSHORT( CMA_FIRST ) );
  3116.        
  3117.       for ( sX = 0; sX < MINI_COLS; ++sX )
  3118.       {
  3119.          pcol = (PMCOLREC) pfinf->pUserData;
  3120.           
  3121.          if ( pcol->ulOpts & SCB_MINI_USED )
  3122.          {
  3123.             if ( pprtCtl->abfinf[sCurCol] )
  3124.             {
  3125.                rclText.xLeft  = pprtCtl->arclfinf[sCurCol].xLeft;
  3126.                rclText.xRight = pprtCtl->arclfinf[sCurCol].xRight;
  3127.    
  3128.                if ( ! pprtCtl->apszfinf[sCurCol] )
  3129.                {
  3130.                   ppszX = &pPrt->psz01;
  3131.    
  3132.                   ppszX += ( pcol->ulX /*- 1*/ );
  3133.    
  3134.                   pprtCtl->apszfinf[sCurCol] = *ppszX;
  3135.                }
  3136.    
  3137.                lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter,
  3138.                                               pprtCtl->apszfinf[sCurCol],
  3139.                                               &rclText, &pprtCtl->fmAll,
  3140.                                               &lNewBottom, &lCharsLeft, 
  3141.                                               pprtCtl->alFmt[sCurCol],//DT_LEFT | DT_VCENTER,
  3142.                                               TRUE, FALSE, TRUE );
  3143.          
  3144.                if ( lCharsLeft && lCharsOut )
  3145.                   pprtCtl->apszfinf[sCurCol] += lCharsOut;
  3146.                else
  3147.                {
  3148.                   --sColsDone;
  3149.                   pprtCtl->abfinf[sCurCol] = FALSE;
  3150.                }
  3151.    
  3152.                if ( lNewBottom && lLowBottom > lNewBottom )
  3153.                   lLowBottom = lNewBottom;
  3154.             }
  3155.          }
  3156.  
  3157.          ++sCurCol;
  3158.  
  3159.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3160.                               MPFROMP ( pfinf ),
  3161.                               MPFROMSHORT( CMA_NEXT ) );
  3162.           
  3163.       }
  3164.  
  3165.       //*** End of Record Processing ****************************************
  3166.  
  3167.       rclText.yTop  = lLowBottom;
  3168.       rclText.yTop -= fm.lMaxDescender;
  3169.  
  3170.       if ( ! sColsDone )
  3171.       {
  3172.          if ( rclText.yTop - ( fm.lMaxBaselineExt + fm.lMaxDescender ) > 
  3173.               rclText.yBottom )
  3174.          {
  3175.             pt.y = rclText.yTop;
  3176.             pt.x = pprtCtl->rclPage.xLeft;
  3177.    
  3178.             GpiMove ( pprtCtl->hpsPrinter, &pt );
  3179.    
  3180.             pt.x = pprtCtl->rclPage.xRight;
  3181.    
  3182.             GpiLine ( pprtCtl->hpsPrinter, &pt );
  3183.          }
  3184.  
  3185.          rclText.yTop -= fm.lMaxDescender;
  3186.  
  3187.          sColsDone = pprtCtl->sVisCols;
  3188.       
  3189.          for ( sX = 0; sX < MINI_COLS; ++sX )
  3190.          {
  3191.             pprtCtl->abfinf[sX]   = TRUE;
  3192.             pprtCtl->apszfinf[sX] = NULL;
  3193.          }
  3194.       
  3195.          WinPostMsg ( pprtCtl->hwndPrtDlg, UWM_STAT, 
  3196.                       MPFROMLONG ( ++ulPrinted ),
  3197.                       MPFROMLONG ( pdr->ulDEnt ) );
  3198.  
  3199.          pPrt = pfnGetCnrRec ( pdr->hwndE, pPrt );
  3200.       }
  3201.    }
  3202.    //*** Clear Out **********************************************************
  3203.  
  3204.    /*if ( pbBuf )
  3205.       free ( pbBuf );*/
  3206.  
  3207.    if ( fbPrinting )
  3208.       WinPostMsg ( pprtCtl->hwndPrtDlg, UWM_DONE, NULL, NULL );
  3209.  
  3210.    WinDestroyMsgQueue ( hmq );
  3211.  
  3212.    DosPostEventSem ( evtThdDone );
  3213.  
  3214.    //DosExit ( EXIT_THREAD, 0 );
  3215.    _endthread();
  3216. }
  3217.  
  3218. //****************************************************************************
  3219. // Print New Page
  3220. //****************************************************************************
  3221. VOID             pfnMiniNewPage      ( BOOL fbCausePage )
  3222. {
  3223.    PDATREC     pdr;
  3224.    LONG        lCharsOut;
  3225.    LONG        lCharsLeft;
  3226.    LONG        lNewBottom;
  3227.    SHORT       sX;
  3228.    CHAR        ach32[32];
  3229.    POINTL      pt;
  3230.    PFIELDINFO  pfinf;
  3231.    PMCOLREC    pcol;
  3232.  
  3233.    pdr = pprtCtl->pPrtRec->pdr;
  3234.  
  3235.    lNewBottom = pprtCtl->rclPage.yTop;
  3236.  
  3237.    //*** Print Heading ***************************************************
  3238.  
  3239.    if ( fbCausePage )
  3240.    {
  3241.       pfnPrintPageEject ( pdr->hwndD, pprtCtl->hpsPrinter );
  3242.  
  3243.       ++pprtCtl->ulPrtPage;
  3244.    }
  3245.  
  3246.    else if ( ulTreeOpts & SCB_PRTHEAD )
  3247.    {
  3248.       pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  3249.                         &pprtCtl->defPrtHed.fat, FONTID_HED );
  3250.  
  3251.       lCharsOut = pfnPaintTextRect ( pprtCtl->hpsPrinter, 
  3252.                                      pprtCtl->pPrtRec->crecCore.pszTree,
  3253.                                      &pprtCtl->rclPage, &pprtCtl->fmHed,
  3254.                                      &lNewBottom, &lCharsLeft, 
  3255.                                      DT_LEFT | DT_VCENTER,
  3256.                                      FALSE, FALSE, FALSE );
  3257.    
  3258.    }
  3259.  
  3260.    //*** Adjust to Printed Heading Height First Time Through *************
  3261.  
  3262.    if ( ! fbCausePage )
  3263.    {
  3264.       pprtCtl->rclBody.yTop = lNewBottom - pprtCtl->fmAll.lMaxBaselineExt;
  3265.  
  3266.       for ( sX = 0; sX < MINI_COLS; ++sX )
  3267.       {
  3268.          pprtCtl->arclfinf[sX].yTop    = pprtCtl->rclBody.yTop;
  3269.          pprtCtl->arclfinf[sX].yBottom = pprtCtl->rclBody.yTop -
  3270.                                          ( pprtCtl->fmAll.lMaxBaselineExt * 
  3271.                                            pprtCtl->lHedLines );
  3272.       }
  3273.    }
  3274.  
  3275.    //*** Print Page Number ***********************************************
  3276.  
  3277.    if ( ulTreeOpts & SCB_PRTPAGE )
  3278.    {
  3279.       pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  3280.                         &pprtCtl->defPrtCnt.fat, FONTID_CNT );
  3281.  
  3282.  
  3283.       sprintf ( ach32, "-  %d  -", pprtCtl->ulPrtPage );
  3284.    
  3285.       pfnPaintText ( pprtCtl->hpsPrinter, ach32, 
  3286.                      &pprtCtl->rclFoot, &pprtCtl->fmCnt,
  3287.                      DT_CENTER | DT_BOTTOM, FALSE, FALSE );
  3288.    }
  3289.  
  3290.    //*** Print Column Headings *******************************************
  3291.  
  3292.    pfnSelPaintFont ( hwndM, pprtCtl->hpsPrinter, 
  3293.                      &pprtCtl->defPrtAll.fat, FONTID_ALL );
  3294.  
  3295.    pfnPaintBox ( pprtCtl->hpsPrinter, &pprtCtl->rclBody );
  3296.  
  3297.    lCharsOut = pprtCtl->fmAll.lMaxBaselineExt / 2;
  3298.  
  3299.    pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3300.                         MPFROMP ( NULL ),
  3301.                         MPFROMSHORT( CMA_FIRST ) );
  3302.     
  3303.    for ( sX = 0; sX < MINI_COLS; ++sX )
  3304.    {
  3305.       pcol = (PMCOLREC) pfinf->pUserData;
  3306.        
  3307.       if ( pcol->ulOpts & SCB_MINI_USED )
  3308.       {
  3309.          pprtCtl->arclfinf[sX].yTop -= lCharsOut;
  3310.    
  3311.          pfnPaintTextRect ( pprtCtl->hpsPrinter,
  3312.                             (PSZ)pfinf->pTitleData,
  3313.                             &pprtCtl->arclfinf[sX], 
  3314.                             &pprtCtl->fmAll,
  3315.                             &lNewBottom, &lCharsLeft, 
  3316.                             DT_CENTER | DT_VCENTER,
  3317.                             FALSE, FALSE, FALSE );
  3318.    
  3319.          pprtCtl->arclfinf[sX].yTop += lCharsOut;
  3320.    
  3321.          pt.x = pprtCtl->arclfinf[sX].xLeft;
  3322.          pt.y = pprtCtl->rclBody.yTop;
  3323.    
  3324.          GpiMove ( pprtCtl->hpsPrinter, &pt );
  3325.    
  3326.          pt.y = pprtCtl->rclBody.yBottom;
  3327.    
  3328.          GpiLine ( pprtCtl->hpsPrinter, &pt );
  3329.       }
  3330.  
  3331.       pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3332.                            MPFROMP ( pfinf ),
  3333.                            MPFROMSHORT( CMA_NEXT ) );
  3334.    }
  3335.  
  3336.    pt.x = pprtCtl->rclPage.xLeft;
  3337.    pt.y = pprtCtl->arclfinf[0].yBottom;
  3338.  
  3339.    GpiMove ( pprtCtl->hpsPrinter, &pt );
  3340.  
  3341.    pt.x = pprtCtl->rclPage.xRight;
  3342.  
  3343.    GpiLine ( pprtCtl->hpsPrinter, &pt );
  3344.  
  3345. }
  3346.  
  3347. //****************************************************************************
  3348. // Print Initialization
  3349. //****************************************************************************
  3350. VOID             pfnMiniPrintInit    (  )
  3351. {
  3352.    PDATREC     pdr;
  3353.    PMCTLREC    pctl;
  3354.    PMCOLREC    pcol;
  3355.    LONG        lLeft;
  3356.    SHORT       sX;
  3357.    RECTL       rclCalc;
  3358.    LONG        lNumLines;
  3359.    PFIELDINFO  pfinf;
  3360.    PFIELDINFO  pfinfLast;
  3361.    SHORT       sXLast;
  3362.  
  3363.    pdr = pprtCtl->pPrtRec->pdr;
  3364.  
  3365.    pctl = ( PMCTLREC ) pdr->pvWork;
  3366.  
  3367.    //*** Set Entry Font *****************************************************
  3368.  
  3369.    if ( pprtCtl->fbNewFont )
  3370.    {
  3371.       pdr->fxPtSzPrt = pprtCtl->defPrtAll.fxPtSz;
  3372.       pdr->fatPrt    = pprtCtl->defPrtAll.fat;
  3373.    }
  3374.  
  3375.    if ( pdr->fxPtSzPrt )
  3376.    {
  3377.       pprtCtl->defPrtAll.fxPtSz = pdr->fxPtSzPrt;
  3378.       pprtCtl->defPrtAll.fat    = pdr->fatPrt;
  3379.    }
  3380.  
  3381.    pfnCvtVecFont     ( pprtCtl->hpsPrinter, 
  3382.                        pprtCtl->defPrtAll.fxPtSz,
  3383.                        &pprtCtl->defPrtAll.fat );
  3384.  
  3385.    pfnSetPaintFont   ( pdr->hwndD, pprtCtl->hpsPrinter, 
  3386.                        &pprtCtl->defPrtAll.fat, FONTID_ALL );
  3387.  
  3388.    GpiQueryFontMetrics ( pprtCtl->hpsPrinter, sizeof ( FONTMETRICS ), 
  3389.                          &pprtCtl->fmAll );
  3390.  
  3391.    //*** Column Setup ******************************************************* */
  3392.  
  3393.    pprtCtl->sVisCols = 0;
  3394.  
  3395.    if ( pdr->hwndD )
  3396.    {
  3397.       pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3398.                            MPFROMP ( NULL ),
  3399.                            MPFROMSHORT( CMA_FIRST ) );
  3400.        
  3401.       for ( sX = 0; sX < MINI_COLS; ++sX )
  3402.       {
  3403.          pcol = (PMCOLREC) pfinf->pUserData;
  3404.           
  3405.          if ( pcol->ulOpts & SCB_MINI_USED )
  3406.          {
  3407.             ++pprtCtl->sVisCols;
  3408.  
  3409.             //pdr->colInfo[sX].pfinf = pfinf; ???
  3410.    
  3411.             pprtCtl->alfinf[sX] = pfnCnrColPels ( pdr->hwndE, pfinf );
  3412.       
  3413.             pprtCtl->alfinf[sX] += ( pprtCtl->fmAll.lAveCharWidth * 2 );
  3414.       
  3415.             pprtCtl->alIds[sX]   = pcol->ulX + 1;
  3416.              
  3417.             if ( pcol->ulCDOpts & CFA_LEFT )
  3418.                pprtCtl->alFmt[sX] = DT_LEFT | DT_TOP;
  3419.             else if ( pcol->ulCDOpts & CFA_CENTER )
  3420.                pprtCtl->alFmt[sX] = DT_CENTER | DT_TOP;
  3421.             else
  3422.                pprtCtl->alFmt[sX] = DT_RIGHT | DT_TOP;
  3423.          }
  3424.          else
  3425.          {
  3426.             pprtCtl->alfinf[sX] = 0;
  3427.          }
  3428.           
  3429.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3430.                               MPFROMP ( pfinf ),
  3431.                               MPFROMSHORT( CMA_NEXT ) );
  3432.       }
  3433.        
  3434.    }
  3435.  
  3436.    /*pprtCtl->rclPage.xRight = */pfnPrintALScale ( pprtCtl->rclPage.xRight -
  3437.                                                pprtCtl->rclPage.xLeft,
  3438.                                                MINI_COLS,//pctl->ulCols,
  3439.                                                pprtCtl->alfinf );
  3440.  
  3441.    pprtCtl->rclBody.xRight = pprtCtl->rclPage.xRight;
  3442.    pprtCtl->rclFoot.xRight = pprtCtl->rclPage.xRight;
  3443.  
  3444.    //*** Column Headings Setup ********************************************** */
  3445.  
  3446.    lLeft = pprtCtl->rclPage.xLeft;
  3447.  
  3448.    pprtCtl->lHedLines = 0;
  3449.  
  3450.    pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3451.                         MPFROMP ( NULL ),
  3452.                         MPFROMSHORT( CMA_FIRST ) );
  3453.     
  3454.    for ( sX = 0; sX < MINI_COLS; ++sX )
  3455.    {
  3456.       pcol = (PMCOLREC) pfinf->pUserData;
  3457.        
  3458.       if ( pcol->ulOpts & SCB_MINI_USED )
  3459.       {
  3460.          pprtCtl->arclfinf[sX].yBottom = pprtCtl->rclPage.yBottom;
  3461.          pprtCtl->arclfinf[sX].yTop    = pprtCtl->rclPage.yTop;
  3462.    
  3463.          pprtCtl->arclfinf[sX].xLeft  = lLeft;
  3464.          pprtCtl->arclfinf[sX].xRight = lLeft + pprtCtl->alfinf[sX];
  3465.    
  3466.          lLeft = pprtCtl->arclfinf[sX].xRight;
  3467.    
  3468.          //*** Calc Deepest Column *********************************************
  3469.    
  3470.          pfnPaintCalcRect ( pprtCtl->hpsPrinter,
  3471.                             (PSZ)pfinf->pTitleData,
  3472.                             &pprtCtl->arclfinf[sX], 
  3473.                             &pprtCtl->fmAll,
  3474.                             &rclCalc,
  3475.                             &lNumLines,
  3476.                             DT_CENTER | DT_VCENTER,
  3477.                             FALSE, FALSE );
  3478.    
  3479.          if ( lNumLines > pprtCtl->lHedLines )
  3480.             pprtCtl->lHedLines = lNumLines;
  3481.    
  3482.          pfinfLast = pfinf;
  3483.          sXLast    = sX;
  3484.       }
  3485.  
  3486.       pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  3487.                            MPFROMP ( pfinf ),
  3488.                            MPFROMSHORT( CMA_NEXT ) );
  3489.    }
  3490.  
  3491.    pprtCtl->arclfinf[sXLast].xRight = pprtCtl->rclPage.xRight;
  3492.  
  3493.    pfnPaintCalcRect ( pprtCtl->hpsPrinter,
  3494.                       (PSZ)pfinfLast->pTitleData,
  3495.                       &pprtCtl->arclfinf[sXLast],
  3496.                       &pprtCtl->fmAll,
  3497.                       &rclCalc,
  3498.                       &lNumLines,
  3499.                       DT_CENTER | DT_VCENTER,
  3500.                       FALSE, FALSE );
  3501.  
  3502.    if ( lNumLines > pprtCtl->lHedLines )
  3503.       pprtCtl->lHedLines = lNumLines;
  3504.  
  3505.    ++pprtCtl->lHedLines;
  3506. }
  3507.  
  3508. //****************************************************************************
  3509. // Convert Old 2-Column Lists to MiniBases
  3510. //****************************************************************************
  3511. BOOL             pfnLst2MiniBase     ( PUSEREC pRecIn )
  3512. {
  3513.    PDATREC    pdr;
  3514.    PBYTE      pbDat;
  3515.    ULONG      ulLen;
  3516.    ULONG      ulTmp;
  3517.    ULONG      ulOff;
  3518.    ULONG      ulX;
  3519.  
  3520.    ULONG      ulNewSize;
  3521.    PVOID      pvDat;
  3522.    PBYTE      pbDatNew;
  3523.  
  3524.    PMCTLREC   pctl;
  3525.    //PMCOLREC   pcol;
  3526.  
  3527.    pdr = pRecIn->pdr;
  3528.  
  3529.    //*** Get Data Record Size ***********************************************
  3530.  
  3531.    ulLen = 0;
  3532.  
  3533.    pbDat = pdr->pvDat;
  3534.  
  3535.    //*** Title Lengths *********************************************************
  3536.  
  3537.    ulTmp  = strlen ( pbDat ) + 1;
  3538.    pbDat += ulTmp;
  3539.    ulLen += ulTmp;
  3540.        
  3541.    ulTmp  = strlen ( pbDat ) + 1;
  3542.    pbDat += ulTmp;
  3543.    ulLen += ulTmp;
  3544.        
  3545.    ulLen += ( ( MINI_COLS - 2 ) * 5 );
  3546.  
  3547.    //*** Data Lengths **********************************************************
  3548.  
  3549.    for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) 
  3550.    {
  3551.       ulTmp  = strlen ( pbDat ) + 1;
  3552.       pbDat += ulTmp;
  3553.       ulLen += ulTmp;
  3554.           
  3555.       ulTmp  = strlen ( pbDat ) + 1;
  3556.       pbDat += ulTmp;
  3557.       ulLen += ulTmp;
  3558.           
  3559.       ulTmp  = sizeof ( CDATE );
  3560.       pbDat += ulTmp;
  3561.       ulLen += ulTmp;
  3562.  
  3563.       ulLen  = sizeof ( ULONG );   // New Empty Options
  3564.       ulLen += ( MINI_COLS - 2 );  // New empty columns
  3565.    }
  3566.  
  3567.    //*** Calc MiniBase Size *************************************************
  3568.  
  3569.    ulNewSize  = sizeof ( ULONG ) * 4;
  3570.    ulNewSize += ( sizeof ( MCOLREC ) * MINI_COLS );
  3571.    ulNewSize += ulLen;
  3572.    //ulNewSize += ( pdr->ulDEnt * ( sizeof ( ULONG ) + 14 ) );
  3573.  
  3574.    //*** Convert Data *******************************************************
  3575.  
  3576.    pvDat = malloc ( ulNewSize );
  3577.  
  3578.    if ( ! pvDat )
  3579.       return FALSE;
  3580.  
  3581.    pbDatNew = (PBYTE) pvDat;
  3582.    pctl     = (PMCTLREC) pvDat;
  3583.  
  3584.    pctl->ulCols    = 2;
  3585.    pctl->ulSplit   = 1;
  3586.    pctl->abSort[0] = 1;
  3587.    pctl->abSort[1] = 2;
  3588.    pctl->abSort[2] = 3;
  3589.    pctl->abSort[3] = 0;
  3590.     
  3591.    pctl->abSOpt[0] = 0;
  3592.    pctl->abSOpt[1] = 0;
  3593.    pctl->abSOpt[2] = 0;
  3594.    pctl->abSOpt[3] = 0;
  3595.     
  3596.    for ( ulX = 0; ulX < MINI_COLS; ++ulX ) 
  3597.    {
  3598.       memset ( &pctl->mcols[ulX], 0, sizeof ( MCOLREC ) );
  3599.  
  3600.       pctl->mcols[ulX].ulCHOpts = CFA_TOP | CFA_CENTER | CFA_FITITLEREADONLY; 
  3601.       pctl->mcols[ulX].ulCDOpts = CFA_STRING | CFA_TOP | CFA_LEFT | CFA_HORZSEPARATOR | CFA_SEPARATOR; 
  3602.       pctl->mcols[ulX].ulOpts   = (ulX < 2 ) ? SCB_MINI_USED : 0;
  3603.       pctl->mcols[ulX].ulStyl   = 0;
  3604.       pctl->mcols[ulX].ulOffset = ( ( FIELDOFFSET ( MINIREC, psz01 ) ) + ( ulX * sizeof ( PSZ) ) );
  3605.       pctl->mcols[ulX].ulChrs   = 0;
  3606.       pctl->mcols[ulX].pfi      = NULL;
  3607.       pctl->mcols[ulX].pszTitl  = NULL;
  3608.       pctl->mcols[ulX].ulX      = ulX;
  3609.    }
  3610.     
  3611.    pctl->mcols[0].ulOpts |= ( SCB_MINI_LEFT | SCB_MINI_SPLT );
  3612.  
  3613.    pbDatNew  = (PBYTE) pvDat;
  3614.    pbDatNew += 16;//( sizeof ( MCTLREC ) - sizeof ( PVOID ) );
  3615.    pbDatNew += ( sizeof ( MCOLREC ) * MINI_COLS );
  3616.        
  3617.    pbDat = pdr->pvDat;
  3618.  
  3619.    ulLen = strlen ( pbDat ) + 1;
  3620.    strcpy ( pbDatNew, pbDat );
  3621.    pbDat    += ulLen;
  3622.    pbDatNew += ulLen;
  3623.     
  3624.    ulLen = strlen ( pbDat ) + 1;
  3625.    strcpy ( pbDatNew, pbDat );
  3626.    pbDat    += ulLen;
  3627.    pbDatNew += ulLen;
  3628.     
  3629.    for ( ulOff = 0; ulOff < MINI_COLS - 2; ++ulOff )
  3630.    {
  3631.       ulLen = strlen ( "Name" ) + 1;
  3632.       strcpy ( pbDatNew, "Name" );
  3633.       pbDatNew += ulLen;
  3634.    }
  3635.     
  3636.    for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) 
  3637.    {
  3638.       ulLen = strlen ( pbDat ) + 1;
  3639.       strcpy ( pbDatNew, pbDat );
  3640.       pbDat    += ulLen;
  3641.       pbDatNew += ulLen;
  3642.  
  3643.       ulLen = strlen ( pbDat ) + 1;
  3644.       strcpy ( pbDatNew, pbDat );
  3645.       pbDat    += ulLen;
  3646.       pbDatNew += ulLen;
  3647.  
  3648.       memset ( pbDatNew, 0, 14 );
  3649.       pbDatNew += 14;
  3650.  
  3651.       ulLen  = sizeof ( CDATE );
  3652.       memcpy ( pbDatNew, pbDat, ulLen );
  3653.       pbDat    += ulLen;
  3654.       pbDatNew += ulLen;
  3655.  
  3656.       memset ( pbDatNew, 0, 4 );
  3657.       pbDatNew += 4;
  3658.    }
  3659.  
  3660.    //*** Replace Data Pointer ***********************************************
  3661.  
  3662.    free ( pdr->pvDat );
  3663.  
  3664.    pdr->pvDat = pvDat;
  3665.  
  3666.    pRecIn->ulType = WID_MINI;
  3667.    pRecIn->ulReal = WID_MINI;
  3668.  
  3669.    fbModified = TRUE;
  3670.  
  3671.    return TRUE;
  3672. }
  3673.  
  3674. //****************************************************************************
  3675. /* Record Layout:
  3676.  
  3677.    ulCols
  3678.    ulSplit
  3679.    abSort
  3680.    abSOpt
  3681.    MCOLREC[MINI_COLS]
  3682.    pszTitle ( * MINICOLS )
  3683.    entries:
  3684.       psz01 to psz16
  3685.       CDATE
  3686.       ULONG
  3687. */
  3688.