home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: InfoMgt / InfoMgt.zip / code25.zip / fsplst2.c < prev    next >
Text File  |  1993-12-01  |  32KB  |  932 lines
  1. /* Main #define's & #include's */
  2.  
  3. #define VAR_SCOPE extern
  4.  
  5. #include "fsp.h"
  6.  
  7.  
  8. /* #defines */
  9.  
  10.  
  11.  
  12. /* typedefs */
  13.  
  14.  
  15.  
  16. /* Globals */
  17.  
  18.  
  19.  
  20. /* Prototypes */
  21.  
  22. BOOL             pfnListStat  ( PUSEREC );
  23.  
  24.  
  25.  
  26. MRESULT EXPENTRY pfnwpLst2Win ( HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2 ) {
  27.     
  28.    /* Local Vars */
  29.     
  30.    SWP     swp;
  31.    HWND    hwndMenu;
  32.    POINTL  ptl;
  33.    ULONG   ulOff;
  34.    USHORT  usResp;
  35.    PBYTE   pbDat;
  36.    ULONG   ulLen;
  37.    CHAR    ach24[25];
  38.     
  39.    PVOID   pvClip;
  40.    ULONG   ulSize;
  41.    PBYTE   pbScn;
  42.     
  43.    PSZ     pszCol;
  44.     
  45.    /* Container Stuff */
  46.     
  47.    CNRINFO               cnrinf;
  48.    PFIELDINFO            pfinf;
  49.    PFIELDINFO            pfinfScn;
  50.    FIELDINFOINSERT       fInfIns;
  51.    PUSEREC               pRecScn;
  52.    PLST2REC              pLst2New;
  53.    PLST2REC              pLst2Foc;
  54.    RECORDINSERT          recins;
  55.    PDATREC               pdr;
  56.    PCNREDITDATA          pcnrEdt;
  57.    CNREDITDATA           cnrEdt;
  58.     
  59.     
  60.     
  61.    pRecScn = WinQueryWindowPtr ( hwnd, 0 );
  62.     
  63.    switch ( msg ) {
  64.        
  65.       case WM_CREATE:
  66.           
  67.       break;
  68.        
  69.       case WM_ACTIVATE:
  70.           
  71.          if ( SHORT1FROMMP ( mp1 ) ) {
  72.              
  73.             hwndFoc = HWNDFROMMP ( mp2 );
  74.              
  75.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  76.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  77.                          MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  78.          }
  79.          else {
  80.              
  81.             hwndFoc = HWNDFROMMP ( mp2 );
  82.              
  83.             WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  84.                          NULL, NULL );
  85.          }
  86.           
  87.       break;
  88.        
  89.       case WM_SIZE:
  90.           
  91.          if ( pRecScn ) {
  92.              
  93.             WinSetWindowPos ( pRecScn->pdr->hwndE, 0, 0, 0,
  94.                               SHORT1FROMMP ( mp2 ),
  95.                               SHORT2FROMMP ( mp2 ),
  96.                               SWP_SHOW | SWP_SIZE | SWP_MOVE );
  97.          }
  98.           
  99.       break;
  100.        
  101.       case UWM_PARAMS:
  102.           
  103.          /* Store Data Pointer */
  104.           
  105.          pRecScn = PVOIDFROMMP ( mp1 );
  106.           
  107.          WinSetWindowPtr ( hwnd, 0, pRecScn );
  108.           
  109.          pdr = pRecScn->pdr;
  110.           
  111.           
  112.          /* Frame */
  113.           
  114.          pfnSetWinPos ( hwnd, pdr );
  115.           
  116.          pdr->hwndM = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU );
  117.           
  118.          pdr->pszStat = malloc ( 80 );
  119.           
  120.           
  121.           
  122.          /* Create & Init Container */
  123.           
  124.          pdr->hwndE = WinCreateWindow ( hwnd, WC_CONTAINER, NULL,
  125.                                         CCS_SINGLESEL,
  126.                                         0,0,0,0, hwnd, HWND_TOP,
  127.                                         WID_CONT, NULL, NULL );
  128.           
  129.          cnrinf.pszCnrTitle  = pdr->pszStat;
  130.          cnrinf.flWindowAttr = CV_DETAIL | CA_DETAILSVIEWTITLES;
  131.           
  132.          if ( ulListOpts & SCB_STATED ) {
  133.              
  134.             cnrinf.flWindowAttr |= CA_CONTAINERTITLE | CA_TITLESEPARATOR | CA_TITLEREADONLY;
  135.              
  136.          }
  137.           
  138.          WinSendMsg ( pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  139.                       MPFROMLONG ( CMA_FLWINDOWATTR ) );
  140.           
  141.          sprintf ( ach24, "%d.%s", FIXEDINT(pdr->fxPtSz), pdr->fat.szFacename );
  142.           
  143.          WinSetPresParam ( pdr->hwndE, PP_FONTNAMESIZE,
  144.                            strlen ( ach24 ) + 1, ach24 );
  145.           
  146.          WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  147.                       MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  148.           
  149.           
  150.           
  151.          /* Allocate & Init Field Info */
  152.           
  153.          pbDat = pdr->pvDat;
  154.           
  155.          pfinf = WinSendMsg ( pdr->hwndE, CM_ALLOCDETAILFIELDINFO,
  156.                               MPFROMLONG ( 3 ), NULL);
  157.           
  158.          pfinfScn = pfinf;
  159.           
  160.          cnrinf.pFieldInfoLast = pfinfScn;
  161.           
  162.          pRecScn->pdr->pfi    = pfinfScn;
  163.           
  164.          pfinfScn->cb         = sizeof ( FIELDINFO );
  165.          pfinfScn->flData     = CFA_STRING | CFA_TOP | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  166.          pfinfScn->flTitle    = 0;
  167.          if ( pdr->ulDLen ) {
  168.              
  169.             ulLen = strlen ( pbDat ) + 1;
  170.             pfinfScn->pTitleData = malloc ( ulLen );
  171.             strcpy ( pfinfScn->pTitleData, pbDat );
  172.             pbDat += ulLen;
  173.              
  174.             }
  175.             else {
  176.              
  177.             pfinfScn->pTitleData = malloc ( strlen ( "Your 1st\ncolumn title\nhere\n(Alt+Left Mouse Button)" ) );
  178.              
  179.             strcpy ( pfinfScn->pTitleData, "Your 1st\ncolumn title\nhere\n(Alt+Left Mouse Button)" );
  180.              
  181.          }
  182.          pfinfScn->offStruct  = FIELDOFFSET ( LST2REC, psz1 );
  183.          pfinfScn             = pfinfScn->pNextFieldInfo;
  184.           
  185.          pfinfScn->cb         = sizeof ( FIELDINFO );
  186.          pfinfScn->flData     = CFA_STRING | CFA_TOP | CFA_HORZSEPARATOR | CFA_SEPARATOR;
  187.          pfinfScn->flTitle    = 0;
  188.          if ( pdr->ulDLen ) {
  189.              
  190.             ulLen = strlen ( pbDat ) + 1;
  191.             pfinfScn->pTitleData = malloc ( ulLen );
  192.             strcpy ( pfinfScn->pTitleData, pbDat );
  193.             pbDat += ulLen;
  194.              
  195.             }
  196.             else {
  197.              
  198.             pfinfScn->pTitleData = malloc ( strlen ( "Your 2nd\ncolumn title\nhere\n(Alt+Left Mouse Button)" ) );
  199.              
  200.             strcpy ( pfinfScn->pTitleData, "Your 2nd\ncolumn title\nhere\n(Alt+Left Mouse Button)" );
  201.              
  202.          }
  203.          pfinfScn->offStruct  = FIELDOFFSET ( LST2REC, psz2 );
  204.          pfinfScn             = pfinfScn->pNextFieldInfo;
  205.           
  206.          pfinfScn->cb         = sizeof ( FIELDINFO );
  207.          pfinfScn->flData     = CFA_DATE | CFA_TOP | CFA_HORZSEPARATOR;
  208.          pfinfScn->flTitle    = CFA_FITITLEREADONLY;
  209.          pfinfScn->pTitleData = "Date";
  210.          pfinfScn->offStruct  = FIELDOFFSET ( LST2REC, cdCur );
  211.          pfinfScn             = pfinfScn->pNextFieldInfo;
  212.           
  213.           
  214.          /* Insert */
  215.           
  216.          fInfIns.cb                   = sizeof ( FIELDINFOINSERT );
  217.          fInfIns.pFieldInfoOrder      = (PFIELDINFO)CMA_FIRST;
  218.          fInfIns.cFieldInfoInsert     = 2;
  219.          fInfIns.fInvalidateFieldInfo = TRUE;
  220.           
  221.          WinSendMsg ( pdr->hwndE, CM_INSERTDETAILFIELDINFO,
  222.                       MPFROMP ( pfinf ),
  223.                       MPFROMP ( &fInfIns ) );
  224.           
  225.           
  226.          /* Position Container */
  227.           
  228.          WinSendMsg ( pdr->hwndE, CM_SETCNRINFO,
  229.                       MPFROMP ( &cnrinf ),
  230.                       MPFROMLONG ( CMA_PFIELDINFOLAST ) );
  231.           
  232.          WinQueryWindowPos ( hwnd, &swp );
  233.           
  234.          WinSetWindowPos ( pdr->hwndE, HWND_TOP,
  235.                            0, 0,
  236.                            swp.cx,
  237.                            swp.cy,
  238.                            SWP_SIZE | SWP_MOVE | SWP_SHOW );
  239.           
  240.          WinSetFocus ( HWND_DESKTOP, pdr->hwndE );
  241.           
  242.           
  243.          /* Set up Splitbar */
  244.           
  245.          if ( ! pdr->ulDLen ) {
  246.              
  247.             pdr->ulXVS = swp.cx / 2;
  248.              
  249.          }
  250.           
  251.          cnrinf.xVertSplitbar = pdr->ulXVS;
  252.           
  253.          WinSendMsg ( pdr->hwndE, CM_SETCNRINFO,
  254.                       MPFROMP ( &cnrinf ),
  255.                       MPFROMLONG ( CMA_XVERTSPLITBAR ) );
  256.           
  257.           
  258.          /* Insert Data */
  259.           
  260.          for ( ulOff = 0; ulOff < pdr->ulDEnt; ++ulOff ) {
  261.              
  262.             pLst2New = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  263.                                     MPFROMLONG (sizeof(LST2REC)-sizeof(RECORDCORE)),
  264.                                     MPFROMSHORT( 1 ) );
  265.              
  266.             /* Init Record */
  267.              
  268.             ulLen = strlen ( pbDat ) + 1;
  269.             pLst2New->psz1 = malloc ( ulLen );
  270.             strcpy ( pLst2New->psz1, pbDat );
  271.             pbDat += ulLen;
  272.              
  273.             ulLen = strlen ( pbDat ) + 1;
  274.             pLst2New->psz2 = malloc ( ulLen );
  275.             strcpy ( pLst2New->psz2, pbDat );
  276.             pbDat += ulLen;
  277.              
  278.             memcpy ( &pLst2New->cdCur, pbDat, sizeof ( CDATE ) );
  279.             pbDat += sizeof ( CDATE );
  280.              
  281.              
  282.             /* Insert */
  283.              
  284.             recins.cb                = sizeof ( RECORDINSERT );
  285.             recins.pRecordParent     = (PRECORDCORE) NULL;
  286.             recins.pRecordOrder      = (PRECORDCORE) CMA_END;
  287.             recins.zOrder            = CMA_TOP;
  288.             recins.cRecordsInsert    = 1;
  289.             recins.fInvalidateRecord = TRUE;
  290.              
  291.             WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  292.                          MPFROMP( pLst2New ), MPFROMP ( &recins ) );
  293.              
  294.              
  295.          }
  296.           
  297.           
  298.          pdr->ulOpts |= SCB_OPENED;
  299.           
  300.          pdr->fbModified = FALSE;
  301.           
  302.          pfnListStat ( pRecScn );
  303.           
  304.       break;
  305.        
  306.       case WM_INITMENU:
  307.           
  308.          WinSendMsg ( WinQueryHelpInstance ( hwnd ), HM_SET_ACTIVE_WINDOW,
  309.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ),
  310.                       MPFROMLONG ( WinQueryWindow ( hwnd, QW_PARENT ) ) );
  311.           
  312.          hwndMenu = WinWindowFromID ( WinQueryWindow ( hwnd, QW_PARENT ), FID_MENU);
  313.           
  314.          switch ( SHORT1FROMMP ( mp1 ) ) {
  315.              
  316.             case MID_LIST_EDIT:
  317.                 
  318.                if (  pfnIsMyClip ( hwnd, atomLst2 ) ) {
  319.                    
  320.                   WinEnableMenuItem ( hwndMenu, MID_LIST_PASTE, TRUE );
  321.                    
  322.                   }
  323.                   else {
  324.                    
  325.                   WinEnableMenuItem ( hwndMenu, MID_LIST_PASTE, FALSE );
  326.                    
  327.                }
  328.                 
  329.                pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  330.                                        MPFROMLONG ( CMA_FIRST ),
  331.                                        MPFROMSHORT( CRA_SELECTED ) );
  332.                 
  333.                if (  pLst2Foc ) {
  334.                    
  335.                   WinEnableMenuItem ( hwndMenu, MID_LIST_CUT,  TRUE );
  336.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COPY, TRUE );
  337.                   WinEnableMenuItem ( hwndMenu, MID_LIST_DELT, TRUE );
  338.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COL1, TRUE );
  339.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COL2, TRUE );
  340.                    
  341.                   }
  342.                   else {
  343.                    
  344.                   WinEnableMenuItem ( hwndMenu, MID_LIST_CUT,  FALSE );
  345.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COPY, FALSE );
  346.                   WinEnableMenuItem ( hwndMenu, MID_LIST_DELT, FALSE );
  347.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COL1, FALSE );
  348.                   WinEnableMenuItem ( hwndMenu, MID_LIST_COL2, FALSE );
  349.                    
  350.                }
  351.                 
  352.             break;
  353.              
  354.          }
  355.           
  356.       break;
  357.        
  358.       case WM_COMMAND:
  359.           
  360.          if ( pRecScn->pdr->fbEditing ) {
  361.              
  362.             WinSendMsg ( pRecScn->pdr->hwndE, CM_CLOSEEDIT, NULL, NULL );
  363.              
  364.          }
  365.           
  366.          switch ( SHORT1FROMMP ( mp1 ) ) {
  367.              
  368.             case MID_LIST_SAVE:
  369.                 
  370.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  371.                 
  372.             break;
  373.              
  374.             case MID_LIST_COPY: case MID_LIST_CUT:
  375.                 
  376.                pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  377.                                        MPFROMLONG ( CMA_FIRST ),
  378.                                        MPFROMSHORT( CRA_SELECTED ) );
  379.                 
  380.                /* Alloc & Init Mem */
  381.                 
  382.                ulSize  = strlen ( pLst2Foc->psz1 ) + 1;
  383.                ulSize += strlen ( pLst2Foc->psz2 ) + 1;
  384.                 
  385.                ulSize += sizeof ( CDATE );
  386.                 
  387.                DosAllocSharedMem ( &pvClip, NULL, ulSize, PAG_WRITE | PAG_COMMIT | OBJ_GIVEABLE | OBJ_GETTABLE );
  388.                 
  389.                DosGetSharedMem ( pvClip, PAG_WRITE );
  390.                 
  391.                pbScn = pvClip;
  392.                 
  393.                strcpy ( pbScn, pLst2Foc->psz1 );
  394.                pbScn  += strlen ( pLst2Foc->psz1 ) + 1;
  395.                 
  396.                strcpy ( pbScn, pLst2Foc->psz2 );
  397.                pbScn  += strlen ( pLst2Foc->psz2 ) + 1;
  398.                 
  399.                memcpy ( pbScn, &pLst2Foc->cdCur, sizeof ( CDATE ) );
  400.                pbScn  += sizeof ( CDATE );
  401.                 
  402.                 
  403.                /* Clipboard it */
  404.                 
  405.                WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  406.                 
  407.                WinSetClipbrdData ( WinQueryAnchorBlock ( hwnd ), (ULONG) pvClip, atomLst2, CFI_POINTER );
  408.                 
  409.                WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  410.                 
  411.                 
  412.                 
  413.                if ( SHORT1FROMMP ( mp1 ) == MID_LIST_CUT ) {
  414.                    
  415.                   WinSendMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_LIST_DELT, 0 ), NULL );
  416.                    
  417.                }
  418.                 
  419.             break;
  420.              
  421.             case MID_LIST_PASTE:
  422.                 
  423.                if ( pfnIsMyClip ( hwnd, atomLst2 ) ) {
  424.                    
  425.                   WinOpenClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  426.                    
  427.                   pvClip = (PVOID)WinQueryClipbrdData ( WinQueryAnchorBlock ( hwnd ), atomLst2 );
  428.                    
  429.                   pbScn = pvClip;
  430.                    
  431.                   /* Allocate & Init Rec */
  432.                    
  433.                   pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  434.                                           MPFROMLONG ( CMA_FIRST ),
  435.                                           MPFROMSHORT( CRA_SELECTED ) );
  436.                    
  437.                   pLst2New = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  438.                                           MPFROMLONG (sizeof(LST2REC)-sizeof(RECORDCORE)),
  439.                                           MPFROMSHORT( 1 ) );
  440.                    
  441.                   /* Init Record */
  442.                    
  443.                   pLst2New->psz1 = malloc ( strlen ( pbScn ) + 1 );
  444.                   strcpy ( pLst2New->psz1, pbScn );
  445.                   pbScn  += strlen ( pLst2New->psz1 ) + 1;
  446.                    
  447.                   pLst2New->psz2 = malloc ( strlen ( pbScn ) + 1 );
  448.                   strcpy ( pLst2New->psz2, pbScn );
  449.                   pbScn  += strlen ( pLst2New->psz2 ) + 1;
  450.                    
  451.                   memcpy ( &pLst2New->cdCur, pbScn, sizeof ( CDATE ) );
  452.                   pbScn  += sizeof ( CDATE );
  453.                    
  454.                    
  455.                    
  456.                   /* Insert */
  457.                    
  458.                   recins.cb                = sizeof ( RECORDINSERT );
  459.                   recins.pRecordParent     = NULL;
  460.                    
  461.                   if ( pLst2Foc ) {
  462.                       
  463.                      recins.pRecordOrder = (PRECORDCORE) pLst2Foc;
  464.                       
  465.                      }
  466.                      else {
  467.                       
  468.                      recins.pRecordOrder = (PRECORDCORE) CMA_END;
  469.                       
  470.                   }
  471.                    
  472.                   recins.zOrder            = CMA_TOP;
  473.                   recins.cRecordsInsert    = 1;
  474.                   recins.fInvalidateRecord = TRUE;
  475.                    
  476.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  477.                                MPFROMP( pLst2New ), MPFROMP ( &recins ) );
  478.                    
  479.                   pRecScn->pdr->fbModified = TRUE;
  480.                   fbModified = TRUE;
  481.                    
  482.                   ++pRecScn->pdr->ulDEnt;
  483.                    
  484.                   pfnListStat ( pRecScn );
  485.                    
  486.                    
  487.                    
  488.                    
  489.                   WinCloseClipbrd ( WinQueryAnchorBlock ( hwnd ) );
  490.                    
  491.                }
  492.                 
  493.             break;
  494.              
  495.             case MID_LIST_ADD:
  496.                 
  497.                /* Allocate & Init Rec */
  498.                 
  499.                pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  500.                                        MPFROMLONG ( CMA_FIRST ),
  501.                                        MPFROMSHORT( CRA_SELECTED ) );
  502.                 
  503.                pLst2New = WinSendMsg ( pRecScn->pdr->hwndE, CM_ALLOCRECORD,
  504.                                        MPFROMLONG (sizeof(LST2REC)-sizeof(RECORDCORE)),
  505.                                        MPFROMSHORT( 1 ) );
  506.                 
  507.                /* Init Record */
  508.                 
  509.                pLst2New->psz1 = malloc ( 1 );
  510.                pLst2New->psz2 = malloc ( 1 );
  511.                 
  512.                *pLst2New->psz1 = 0;
  513.                *pLst2New->psz2 = 0;
  514.                 
  515.                pfnSetWhen ( &pLst2New->cdCur, NULL );
  516.                 
  517.                 
  518.                /* Insert */
  519.                 
  520.                recins.cb                = sizeof ( RECORDINSERT );
  521.                recins.pRecordParent     = NULL;
  522.                 
  523.                if ( pLst2Foc ) {
  524.                    
  525.                   recins.pRecordOrder = (PRECORDCORE) pLst2Foc;
  526.                    
  527.                   }
  528.                   else {
  529.                    
  530.                   recins.pRecordOrder = (PRECORDCORE) CMA_END;
  531.                    
  532.                }
  533.                 
  534.                recins.zOrder            = CMA_TOP;
  535.                recins.cRecordsInsert    = 1;
  536.                recins.fInvalidateRecord = TRUE;
  537.                 
  538.                WinSendMsg ( pRecScn->pdr->hwndE, CM_INSERTRECORD,
  539.                             MPFROMP( pLst2New ), MPFROMP ( &recins ) );
  540.                 
  541.                pRecScn->pdr->fbModified = TRUE;
  542.                fbModified = TRUE;
  543.                 
  544.                ++pRecScn->pdr->ulDEnt;
  545.                 
  546.                pfnListStat ( pRecScn );
  547.                 
  548.                 
  549.                 
  550.                 
  551.                 
  552.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  553.                             MPFROMP ( pLst2New ),
  554.                             MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  555.                 
  556.                WinPostMsg ( hwnd, WM_COMMAND, MPFROM2SHORT ( MID_LIST_COL1, 0 ), NULL );
  557.                 
  558.             break;
  559.              
  560.             case MID_LIST_DELT:
  561.                 
  562.                pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  563.                                        MPFROMLONG ( CMA_FIRST ),
  564.                                        MPFROMSHORT( CRA_SELECTED ) );
  565.                 
  566.                WinSendMsg ( pRecScn->pdr->hwndE, CM_REMOVERECORD,
  567.                             MPFROMP ( &pLst2Foc ),
  568.                             MPFROM2SHORT( 1, CMA_FREE | CMA_INVALIDATE ) );
  569.                 
  570.                pRecScn->pdr->fbModified = TRUE;
  571.                 
  572.                fbModified = TRUE;
  573.                 
  574.                --pRecScn->pdr->ulDEnt;
  575.                 
  576.                pfnListStat ( pRecScn );
  577.                 
  578.             break;
  579.              
  580.             case MID_LIST_SORT_C1: case MID_LIST_SORT_C2:
  581.                 
  582.                ulOff = SHORT1FROMMP ( mp1 );
  583.                 
  584.                WinSendMsg ( pRecScn->pdr->hwndE, CM_SORTRECORD,
  585.                             MPFROMP ( pfnLst2Sort ),
  586.                             MPFROMP ( &ulOff ) );
  587.                 
  588.                pRecScn->pdr->fbModified = TRUE;
  589.                fbModified = TRUE;
  590.                 
  591.             break;
  592.              
  593.             case MID_LIST_FONT:
  594.             {
  595.                HPS       hps = WinGetPS ( pRecScn->pdr->hwndE );
  596.                /*PDATREC */  pdr = pRecScn->pdr;
  597.       
  598.                if ( pfnGetFont ( hwnd, hps, NULLHANDLE, &pdr->fxPtSz, &pdr->fat ) )
  599.                {
  600.                   pfnSetPPFont ( pdr->hwndE, pdr->fxPtSz, &pdr->fat );
  601.                }
  602.       
  603.                WinReleasePS ( hps );
  604.             }
  605.             break;
  606.              
  607.             case MID_LIST_COL1: case MID_LIST_COL2:
  608.                 
  609.                if ( ! pRecScn->pdr->fbEditing ) {
  610.                    
  611.                   pLst2Foc = WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYRECORDEMPHASIS,
  612.                                           MPFROMLONG ( CMA_FIRST ),
  613.                                           MPFROMSHORT( CRA_SELECTED ) );
  614.                    
  615.                   cnrEdt.cb         = sizeof ( CNREDITDATA );
  616.                   cnrEdt.hwndCnr    = pRecScn->pdr->hwndE;
  617.                   cnrEdt.pRecord    = (PRECORDCORE) pLst2Foc;
  618.                    
  619.                   if ( SHORT1FROMMP ( mp1 ) == MID_LIST_COL1 ) {
  620.                       
  621.                      cnrEdt.pFieldInfo = pRecScn->pdr->pfi;
  622.                       
  623.                      cnrEdt.id = CID_LEFTDVWND;
  624.                      }
  625.                      else {
  626.                       
  627.                      cnrEdt.pFieldInfo =
  628.                              WinSendMsg ( pRecScn->pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  629.                                           MPFROMP ( pRecScn->pdr->pfi ),
  630.                                           MPFROMSHORT( CMA_NEXT ) );
  631.                       
  632.                      cnrEdt.id = CID_RIGHTDVWND;
  633.                   }
  634.                    
  635.                   cnrEdt.ppszText   = NULL;
  636.                   cnrEdt.cbText     = 0;
  637.                    
  638.                   WinSendMsg ( pRecScn->pdr->hwndE, CM_OPENEDIT,
  639.                                MPFROMP ( &cnrEdt ), NULL );
  640.                    
  641.                }
  642.                 
  643.             break;
  644.              
  645.          }
  646.           
  647.       break;
  648.        
  649.       case WM_CONTROL:
  650.           
  651.          switch ( SHORT1FROMMP ( mp1 ) ) {
  652.              
  653.             case WID_CONT:
  654.                 
  655.                switch ( SHORT2FROMMP ( mp1 ) ) {
  656.                    
  657.                   case CN_BEGINEDIT:
  658.                       
  659.                      pRecScn->pdr->fbEditing = TRUE;
  660.                       
  661.                      pcnrEdt = PVOIDFROMMP ( mp2 );
  662.                       
  663.                      WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  664.                                   MPFROMP ( pcnrEdt->pRecord ),
  665.                                   MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  666.                       
  667.                      //pRecScn->pdr->pfi = pcnrEdt->pFieldInfo;
  668.                       
  669.                   return ( MRESULT ) TRUE;
  670.                    
  671.                   case CN_ENDEDIT:
  672.                       
  673.                      pRecScn->pdr->fbEditing = FALSE;
  674.                       
  675.                   return ( MRESULT ) TRUE;
  676.                    
  677.                   case CN_CONTEXTMENU:
  678.                       
  679.                      pLst2New = PVOIDFROMMP ( mp2 );
  680.                       
  681.                      hwndMenu = WinLoadMenu ( hwnd, 0, WID_LIST );
  682.                       
  683.                      if ( ! pLst2New ) {
  684.                          
  685.                         WinEnableMenuItem ( hwndMenu, MID_LIST_DELT, FALSE );
  686.                          
  687.                      }
  688.                      else {
  689.                          
  690.                         WinEnableMenuItem ( hwndMenu, MID_LIST_DELT, TRUE );
  691.                          
  692.                         WinSendMsg ( pRecScn->pdr->hwndE, CM_SETRECORDEMPHASIS,
  693.                                      MPFROMP ( pLst2New ),
  694.                                      MPFROM2SHORT ( TRUE, CRA_SELECTED ) );
  695.                      }
  696.                       
  697.                      WinQueryPointerPos ( HWND_DESKTOP, &ptl );
  698.                       
  699.                      WinMapWindowPoints ( HWND_DESKTOP, hwnd, &ptl, 1 );
  700.                       
  701.                      WinPopupMenu ( pRecScn->pdr->hwndE, hwnd, hwndMenu,
  702.                                     (SHORT)ptl.x, (SHORT)ptl.y,
  703.                                     0,
  704.                                     PU_HCONSTRAIN | PU_VCONSTRAIN |
  705.                                     PU_MOUSEBUTTON1 | PU_MOUSEBUTTON2 | PU_KEYBOARD );
  706.                       
  707.                       
  708.                   return ( MRESULT ) TRUE;
  709.                    
  710.                   case CN_REALLOCPSZ:
  711.                       
  712.                      pcnrEdt = PVOIDFROMMP ( mp2 );
  713.                       
  714.                      pLst2New = (PLST2REC) pcnrEdt->pRecord;
  715.                       
  716.                      ulOff = pcnrEdt->pFieldInfo->offStruct;
  717.                       
  718.                      if ( ! pLst2New ) {
  719.                          
  720.                         *pcnrEdt->ppszText = realloc ( *pcnrEdt->ppszText, pcnrEdt->cbText );
  721.                         //pcnrEdt->pFieldInfo->pTitleData = realloc ( pcnrEdt->pFieldInfo->pTitleData, pcnrEdt->cbText );
  722.                          
  723.                      }
  724.                       
  725.                      else {
  726.                          
  727.                         if ( ulOff == FIELDOFFSET ( LST2REC, psz1 ) ) {
  728.                             
  729.                            pLst2New->psz1 = realloc ( pLst2New->psz1, pcnrEdt->cbText );
  730.                             
  731.                         }
  732.                         else if ( ulOff == FIELDOFFSET ( LST2REC, psz2 ) ) {
  733.                             
  734.                            pLst2New->psz2 = realloc ( pLst2New->psz2, pcnrEdt->cbText );
  735.                             
  736.                         }
  737.                         else {
  738.                             
  739.                            return (MRESULT) FALSE;
  740.                             
  741.                         }
  742.                          
  743.                         pfnSetWhen ( &pLst2New->cdCur, NULL );
  744.                          
  745.                      }
  746.                       
  747.                      pRecScn->pdr->fbModified = TRUE;
  748.                      fbModified = TRUE;
  749.                       
  750.                   return ( MRESULT ) TRUE;
  751.                    
  752.                   case CN_HELP:
  753.                       
  754.                      WinSendMsg ( hwndH, HM_DISPLAY_HELP,
  755.                                   MPFROMSHORT ( HID_LIST ), MPFROMSHORT ( HM_RESOURCEID ) );
  756.                       
  757.                   break;
  758.                    
  759.                }
  760.                 
  761.             break;
  762.              
  763.          }
  764.           
  765.       break;
  766.        
  767.       case UWM_SAVE:
  768.           
  769.          pdr = pRecScn->pdr;
  770.           
  771.          pdr->ulDLen = pfnNodeScan  ( pdr->hwndE, SCB_SIZE, WID_LIST, pdr->pvDat );
  772.           
  773.          /* Get Column Titles */
  774.           
  775.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  776.                               MPFROMP ( NULL ),
  777.                               MPFROM2SHORT ( CMA_FIRST, CMA_ITEMORDER ) );
  778.           
  779.          pszCol = pfinf->pTitleData;
  780.          ulLen = strlen ( pszCol ) + 1;
  781.          pdr->ulDLen += ulLen;
  782.           
  783.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  784.                               MPFROMP ( pfinf ),
  785.                               MPFROM2SHORT ( CMA_NEXT, CMA_ITEMORDER ) );
  786.           
  787.          pszCol = pfinf->pTitleData;
  788.          ulLen = strlen ( pszCol ) + 1;
  789.          pdr->ulDLen += ulLen;
  790.           
  791.          pdr->pvDat = realloc ( pdr->pvDat, pdr->ulDLen );
  792.           
  793.          pbDat = pdr->pvDat;
  794.           
  795.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  796.                               MPFROMP ( NULL ),
  797.                               MPFROM2SHORT ( CMA_FIRST, CMA_ITEMORDER ) );
  798.           
  799.          pszCol = pfinf->pTitleData;
  800.          ulLen = strlen ( pszCol ) + 1;
  801.          memcpy ( pbDat, pszCol, ulLen );
  802.          pbDat += ulLen;
  803.           
  804.          pfinf = WinSendMsg ( pdr->hwndE, CM_QUERYDETAILFIELDINFO,
  805.                               MPFROMP ( pfinf ),
  806.                               MPFROM2SHORT ( CMA_NEXT, CMA_ITEMORDER ) );
  807.           
  808.          pszCol = pfinf->pTitleData;
  809.          ulLen = strlen ( pszCol ) + 1;
  810.          memcpy ( pbDat, pszCol, ulLen );
  811.          pbDat += ulLen;
  812.           
  813.           
  814.          pdr->ulDEnt = pfnNodeScan  ( pdr->hwndE, SCB_WRITE, WID_LIST, pbDat );
  815.           
  816.          pdr->fbModified = FALSE;
  817.           
  818.          /* Set Completion States */
  819.           
  820.          pfnSetWhen ( &pRecScn->cdWri, &pRecScn->ctWri );
  821.           
  822.          pfnGetWinPos ( hwnd, pdr );
  823.           
  824.          WinSendMsg ( pdr->hwndE, CM_QUERYCNRINFO,
  825.                       MPFROMP( &cnrinf ), MPFROMSHORT ( sizeof ( cnrinf ) ) );
  826.           
  827.          pdr->ulXVS = cnrinf.xVertSplitbar;
  828.           
  829.          fbModified = TRUE;
  830.           
  831.           
  832.       break;
  833.        
  834.       case WM_CLOSE:
  835.           
  836.          pdr = pRecScn->pdr;
  837.           
  838.          if ( pdr->fbModified ) {
  839.              
  840.             usResp = WinMessageBox ( HWND_DESKTOP, hwnd,
  841.                                      "This entry has been modified. Save changes ?",
  842.                                      "PM Scrapbook", 0, MB_YESNO | MB_ICONQUESTION );
  843.              
  844.             if ( usResp == MBID_YES ) {
  845.                 
  846.                WinSendMsg ( hwnd, UWM_SAVE, NULL, NULL );
  847.                 
  848.             }
  849.              
  850.          }
  851.           
  852.          pdr->ulOpts &= ~SCB_OPENED;
  853.           
  854.          pdr->hwndD   = 0;
  855.           
  856.          free ( pdr->pszStat );
  857.           
  858.          WinSendMsg ( hwndC, CM_SETRECORDEMPHASIS,
  859.                       MPFROMP ( pRecScn ),
  860.                       MPFROM2SHORT ( FALSE, CRA_INUSE ) );
  861.           
  862.          WinDestroyWindow ( WinQueryWindow ( hwnd, QW_PARENT ) );
  863.           
  864.       break;
  865.        
  866.       case WM_ERASEBACKGROUND:
  867.           
  868.       return ( MRESULT ) ( TRUE );
  869.        
  870.       default:
  871.       return WinDefWindowProc ( hwnd, msg, mp1, mp2 );
  872.        
  873.    }
  874.     
  875.    return ( MRESULT ) FALSE;
  876.     
  877. }
  878.  
  879. SHORT   APIENTRY pfnLst2Sort  ( PRECORDCORE pRec1, PRECORDCORE pRec2, PVOID pv ) {
  880.     
  881.    /* Local Vars */
  882.     
  883.    PULONG pulTyp;
  884.     
  885.    SHORT  sRet;
  886.     
  887.    /* Container Stuff */
  888.     
  889.    PLST2REC  pLst21;
  890.    PLST2REC  pLst22;
  891.     
  892.     
  893.     
  894.    pLst21 = (PLST2REC) pRec1;
  895.    pLst22 = (PLST2REC) pRec2;
  896.     
  897.    pulTyp = (PULONG) pv;
  898.     
  899.    if ( *pulTyp == MID_LIST_SORT_C1 ) {
  900.        
  901.       sRet = strcmp ( pLst21->psz1, pLst22->psz1 );
  902.        
  903.       }
  904.       else {
  905.        
  906.       sRet = strcmp ( pLst21->psz2, pLst22->psz2 );
  907.        
  908.    }
  909.     
  910.    return sRet;
  911.     
  912. }
  913.  
  914. BOOL             pfnListStat  ( PUSEREC pRecScn ) {
  915.     
  916.    /* Local Vars */
  917.     
  918.    CNRINFO               cnrinf;
  919.     
  920.     
  921.    sprintf ( pRecScn->pdr->pszStat, "%d entires", pRecScn->pdr->ulDEnt );
  922.     
  923.    cnrinf.pszCnrTitle  = pRecScn->pdr->pszStat;
  924.     
  925.    WinSendMsg ( pRecScn->pdr->hwndE, CM_SETCNRINFO, &cnrinf,
  926.                 MPFROMLONG ( CMA_CNRTITLE ) );
  927.     
  928.    return TRUE;
  929.     
  930. }
  931.  
  932.