Ignore:
Timestamp:
Jan 29, 2003, 7:41:39 PM (23 years ago)
Author:
umoeller
Message:

New build system, multimedia, other misc fixes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/helpers/cctl_cnr.c

    r242 r243  
    2828#define INCL_WINWINDOWMGR
    2929#define INCL_WINFRAMEMGR
     30#define INCL_WININPUT
    3031#define INCL_WINSYS
    3132#define INCL_WINSCROLLBARS
    … …  
    6263 ********************************************************************/
    6364
    64 extern const SYSCOLORSET G_scsCnr =
    65     {
    66         TRUE,       // inherit presparams
    67         SYSCLR_WINDOW,
    68         SYSCLR_WINDOWTEXT
     65extern const CCTLCOLOR G_scsCnr[] =
     66    {
     67            TRUE, PP_BACKGROUNDCOLOR, SYSCLR_WINDOW,
     68            TRUE, PP_FOREGROUNDCOLOR, SYSCLR_WINDOWTEXT,
     69            TRUE, PP_HILITEBACKGROUNDCOLOR, SYSCLR_HILITEBACKGROUND,
     70            TRUE, PP_HILITEFOREGROUNDCOLOR, SYSCLR_HILITEFOREGROUND,
     71            TRUE, PP_BORDERCOLOR, SYSCLR_WINDOWFRAME,
     72            TRUE, PP_PAGEBACKGROUNDCOLOR, RGBCOL_WHITE,
     73            TRUE, PP_PAGEFOREGROUNDCOLOR, RGBCOL_BLACK,
     74            TRUE, PP_FIELDBACKGROUNDCOLOR, SYSCLR_SCROLLBAR
    6975    };
    7076
    … …  
    7581 ********************************************************************/
    7682
    77 VOID cnrDrawString(HPS hps,
     83/*
     84 *@@ ctnrInit:
     85 *
     86 */
     87
     88VOID ctnrInit(HWND hwnd,
     89              MPARAM mp2,
     90              ULONG flMainCnrStyle,     // in: window style bits of main cnr
     91              PDEFWINDATA pdwd)
     92{
     93    ctlInitDWD(hwnd,
     94               mp2,
     95               pdwd,
     96               WinDefWindowProc,
     97               (flMainCnrStyle & CCS_NOCONTROLPTR)
     98                    ? CCS_NOSENDCTLPTR
     99                    : 0,
     100               G_scsCnr,
     101               ARRAYITEMCOUNT(G_scsCnr));
     102}
     103
     104/*
     105 *@@ ctnrDrawString:
     106 *
     107 */
     108
     109VOID ctnrDrawString(HPS hps,
    78110                   PCSZ pcsz,              // in: string to test
    79111                   PRECTL prcl,            // in: clipping rectangle (inclusive!)
    … …  
    115147
    116148/*
     149 *@@ ctnrGetRecordRect:
     150 *      returns the rectangle of the given record
     151 *      converted to window coordinates. Works for
     152 *      all views.
     153 */
     154
     155VOID ctnrGetRecordRect(PCNRDATA pData,
     156                       PRECTL prcl,
     157                       const RECORDLISTITEM *prli)
     158{
     159    LONG    deltaWorkspace =   (   pData->scrw.szlWorkarea.cy
     160                                 - pData->dwdContent.szlWin.cy)
     161                             - pData->scrw.ptlScrollOfs.y;
     162    prcl->xLeft = 0;
     163    prcl->xRight = pData->dwdContent.szlWin.cx;
     164    prcl->yBottom = prli->ptl.y - deltaWorkspace;
     165    prcl->yTop = prcl->yBottom + prli->szlBox.cy;
     166}
     167
     168/*
     169 *@@ ctnrRepaintRecord:
     170 *
     171 */
     172
     173BOOL ctnrRepaintRecord(PCNRDATA pData,
     174                         const RECORDLISTITEM *prli)
     175{
     176    RECTL   rcl;
     177    ctnrGetRecordRect(pData, &rcl, prli);
     178    ++rcl.xRight;       // for separators, if any
     179    return WinInvalidateRect(pData->dwdContent.hwnd, &rcl, FALSE);
     180}
     181
     182/*
     183 *@@ ctnrQuerySelMode:
     184 *      returns one of CCS_EXTENDSEL, CCS_MULTIPLESEL, or
     185 *      CCS_SINGLESEL, depending on the cnr's current view
     186 *      and window style bits.
     187 */
     188
     189ULONG ctnrQuerySelMode(PCNRDATA pData)
     190{
     191    // in tree view, there is always only single-sel mode
     192    if (!(pData->CnrInfo.flWindowAttr & CV_TREE))
     193    {
     194        // not tree view: then check window style bits
     195        ULONG   flStyle = winhQueryWindowStyle(pData->dwdMain.hwnd);
     196        if (flStyle & CCS_EXTENDSEL)
     197            return CCS_EXTENDSEL;
     198        else if (flStyle & CCS_MULTIPLESEL)
     199            return CCS_MULTIPLESEL;
     200
     201        // this appears to be what the pm cnr does...
     202        // the CCS_SINGLESEL is totally superfluous cos
     203        // if none of the "selection style" bits are
     204        // set, the cnr operates in "single sel" mode
     205    }
     206
     207    return CCS_SINGLESEL;
     208}
     209
     210/*
     211 *@@ ctnrChangeEmphasis:
     212 *
     213 */
     214
     215BOOL ctnrChangeEmphasis(PCNRDATA pData,
     216                        PRECORDLISTITEM prliSet,
     217                        BOOL fTurnOn,
     218                        ULONG fsEmphasis)
     219{
     220    PRECORDLISTITEM prliOld;
     221    ULONG   flRecordAttrOld = prliSet->flRecordAttr;
     222
     223/* #define CCS_EXTENDSEL             0x00000001L
     224#define CCS_MULTIPLESEL           0x00000002L
     225#define CCS_SINGLESEL             0x00000004L */
     226
     227    ULONG ulSel = ctnrQuerySelMode(pData);
     228
     229    if (fTurnOn)
     230    {
     231        ULONG   flMask;
     232        if (ulSel == CCS_SINGLESEL)
     233            flMask = CRA_CURSORED | CRA_SELECTED;
     234        else
     235            flMask = CRA_CURSORED;
     236
     237        if (fsEmphasis & flMask)
     238        {
     239            if (prliOld = pData->prliCursored)
     240            {
     241                prliOld->flRecordAttr &= ~flMask;
     242                ctnrRepaintRecord(pData, prliOld);
     243            }
     244
     245            pData->prliCursored = prliSet;
     246        }
     247
     248        prliSet->flRecordAttr |= fsEmphasis;
     249    }
     250    else
     251        prliSet->flRecordAttr &= ~fsEmphasis;
     252
     253    if (flRecordAttrOld != prliSet->flRecordAttr)
     254        ctnrRepaintRecord(pData, prliSet);
     255
     256    return TRUE;
     257}
     258
     259/*
     260 *@@ ctnrRecordEnter:
     261 *      helper function when a record gets double-clicked
     262 *      upon or when "Enter" key gets pressed.
     263 */
     264
     265VOID ctnrRecordEnter(PCNRDATA pData,
     266                     const RECORDLISTITEM *prli,
     267                     BOOL fKeyboard)
     268{
     269    NOTIFYRECORDENTER nre;
     270    nre.hwndCnr = pData->dwdMain.hwnd;
     271    nre.fKey = fKeyboard;
     272    nre.pRecord = (prli) ? (PRECORDCORE)prli->precc : NULL;
     273
     274    ctlSendWmControl(nre.hwndCnr,
     275                     CN_ENTER,
     276                     &nre);
     277}
     278
     279/*
    117280 *@@ CreateChild:
    118281 *      creates a container child window.
    119282 */
    120283
    121 HWND CreateChild(PCNRDATA pData,
    122                  PCSZ pcszClass,
    123                  ULONG id)
     284STATIC HWND CreateChild(PCNRDATA pData,
     285                        PCSZ pcszClass,
     286                        ULONG id)
    124287{
    125288    return WinCreateWindow(pData->dwdMain.hwnd,
    … …  
    143306 */
    144307
    145 PDETAILCOLUMN FindColumnFromFI(PCNRDATA pData,
    146                                const FIELDINFO *pfi,
    147                                PLISTNODE *ppNode)       // out: listnode of column
     308STATIC PDETAILCOLUMN FindColumnFromFI(PCNRDATA pData,
     309                                      const FIELDINFO *pfi,
     310                                      PLISTNODE *ppNode)       // out: listnode of column
    148311{
    149312    PLISTNODE pNode;
    150313    FOR_ALL_NODES(&pData->llColumns, pNode)
    151314    {
    152         PDETAILCOLUMN pCol = pNode->pItemData;
     315        PDETAILCOLUMN pCol = (PDETAILCOLUMN)pNode->pItemData;
    153316        if (pCol->pfi == pfi)
    154317        {
    … …  
    164327
    165328/*
    166  *@@ FindListNodeForRecc:
    167  *
    168  */
    169 
    170 PLISTNODE FindListNodeForRecc(PCNRDATA pData,
    171                               const RECORDCORE *precc)
     329 *@@ ctnrFindListNodeForRecc:
     330 *
     331 */
     332
     333PLISTNODE ctnrFindListNodeForRecc(PCNRDATA pData,
     334                                  const RECORDCORE *precc)
    172335{
    173336    RECORDTREEITEM  *pti;
    … …  
    180343}
    181344
     345VOID SendViewportChanged(PCNRDATA pData)
     346{
     347    CNRVIEWPORT cvp;
     348    cvp.hwndCnr = pData->dwdMain.hwnd;
     349    cvp.szlWorkarea = pData->scrw.szlWorkarea;
     350    cvp.szlWin = pData->dwdContent.szlWin;
     351    cvp.ptlScroll = pData->scrw.ptlScrollOfs;
     352
     353    ctlSendWmControl(pData->dwdMain.hwnd,
     354                     CN_VIEWPORTCHANGED,
     355                     &cvp);
     356}
     357
     358/*
     359 *@@ ctnrUpdateScrollbars:
     360 *
     361 */
     362
     363VOID ctnrUpdateScrollbars(PCNRDATA pData,
     364                          LONG cx,
     365                          LONG cy)
     366{
     367    BOOL    fNotify = FALSE;
     368
     369    if (cx && pData->scrw.hwndHScroll)
     370    {
     371        winhUpdateScrollBar(pData->scrw.hwndHScroll,
     372                            cx,
     373                            pData->scrw.szlWorkarea.cx,
     374                            pData->scrw.ptlScrollOfs.x,
     375                            FALSE);
     376        fNotify = TRUE;
     377    }
     378
     379    if (cy && pData->scrw.hwndVScroll)
     380    {
     381        winhUpdateScrollBar(pData->scrw.hwndVScroll,
     382                            cy,
     383                            pData->scrw.szlWorkarea.cy,
     384                            pData->scrw.ptlScrollOfs.y,
     385                            FALSE);
     386        fNotify = TRUE;
     387    }
     388
     389    if (fNotify)
     390        SendViewportChanged(pData);
     391}
     392
    182393/* ******************************************************************
    183394 *
    … …  
    191402 */
    192403
    193 MRESULT CnrCreate(HWND hwnd, MPARAM mp1, MPARAM mp2)
     404STATIC MRESULT CnrCreate(HWND hwnd,
     405                         MPARAM mp1,
     406                         MPARAM mp2)
    194407{
    195408    PCNRDATA    pData;
    … …  
    202415
    203416    // initialize DEFWINDOWDATA
    204     ctlInitDWD(hwnd,
    205                mp2,
    206                &pData->dwdMain,
    207                WinDefWindowProc,
    208                &G_scsCnr);
    209 
    210     if (winhQueryWindowStyle(hwnd) & CCS_MINIRECORDCORE)
     417    ctnrInit(hwnd,
     418             mp2,
     419             ((PCREATESTRUCT)mp2)->flStyle,
     420             &pData->dwdMain);
     421
     422    if (((PCREATESTRUCT)mp2)->flStyle & CCS_MINIRECORDCORE)
    211423        pData->fMiniRecords = TRUE;
    212424
    … …  
    229441    nlsQueryCountrySettings(&pData->cs);
    230442
    231     winhCreateScrollBars(hwnd,
    232                          &pData->hwndVScroll,
    233                          &pData->hwndHScroll);
    234 
    235     pData->cxScrollBar = WinQuerySysValue(HWND_DESKTOP, SV_CXVSCROLL);
    236     pData->cyScrollBar = WinQuerySysValue(HWND_DESKTOP, SV_CYHSCROLL);
     443    winhCreateScroller(hwnd,
     444                       &pData->scrw,
     445                       CID_VSCROLL,
     446                       CID_HSCROLL);
    237447
    238448    return (MRESULT)FALSE;
    … …  
    248458 */
    249459
    250 VOID CnrSem2(HWND hwnd, ULONG fl)
    251 {
    252     PCNRDATA    pData;
    253     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
    254     {
    255         if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
    256         {
    257             if (fl & (DDFL_INVALIDATECOLUMNS | DDFL_INCALIDATERECORDS))
     460STATIC VOID CnrSem2(PCNRDATA pData,
     461                    ULONG fl)
     462{
     463    HWND    hwnd = pData->dwdMain.hwnd;
     464
     465    if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
     466    {
     467        if (fl & (DDFL_INVALIDATECOLUMNS | DDFL_INVALIDATERECORDS | DDFL_INVALIDATESOME))
     468        {
     469            HPS hps = WinGetPS(hwnd);
     470            cdtlRecalcDetails(pData, hps, &fl);
     471            WinReleasePS(hps);
     472        }
     473
     474        if (fl & (DDFL_WINDOWSIZECHANGED | DDFL_WORKAREACHANGED))
     475        {
     476            LONG    y = 0,
     477                    cx = pData->dwdMain.szlWin.cx,
     478                    cy = pData->dwdMain.szlWin.cy - pData->cyColTitlesBox;
     479
     480            if (pData->scrw.hwndVScroll)
     481                cx -= pData->scrw.cxScrollBar;
     482            if (pData->scrw.hwndHScroll)
    258483            {
    259                 HPS hps = WinGetPS(hwnd);
    260                 cdtlRecalcDetails(pData, hps, &fl);
    261                 WinReleasePS(hps);
    262 
    263                 if (fl & DDFL_WINDOWSIZECHANGED)
    264                     WinInvalidateRect(pData->dwdMain.hwnd, NULL, TRUE);
     484                y += pData->scrw.cyScrollBar;
     485                cy -= pData->scrw.cyScrollBar;
    265486            }
    266487
    267             if (fl & (DDFL_WINDOWSIZECHANGED | DDFL_WORKAREACHANGED))
     488            _PmpfF(("cyColTitlesBox %d, new cy: %d", pData->cyColTitlesBox, cy));
     489
     490            if (fl & DDFL_WINDOWSIZECHANGED)
     491                WinSetWindowPos(pData->dwdContent.hwnd,
     492                                HWND_TOP,
     493                                0,
     494                                y,
     495                                cx,
     496                                cy,
     497                                SWP_MOVE | SWP_SIZE);
     498                                        // SWP_MOVE is required or PM will move our
     499                                        // subwindow to some adjustment position
     500
     501            if (pData->scrw.hwndVScroll)
    268502            {
    269                 LONG    y = 0,
    270                         cx = pData->dwdMain.szlWin.cx,
    271                         cy = pData->dwdMain.szlWin.cy - pData->cyColTitlesBox;
    272 
    273                 if (pData->hwndVScroll)
    274                     cx -= pData->cxScrollBar;
    275                 if (pData->hwndHScroll)
    276                 {
    277                     y += pData->cyScrollBar;
    278                     cy -= pData->cyScrollBar;
    279                 }
    280 
    281                 _PmpfF(("cyColTitlesBox %d, new cy: %d", pData->cyColTitlesBox, cy));
    282 
    283                 if (fl & DDFL_WINDOWSIZECHANGED)
    284                     WinSetWindowPos(pData->hwndDetails,
    285                                     HWND_TOP,
    286                                     0,
    287                                     y,
    288                                     cx,
    289                                     cy,
    290                                     SWP_MOVE | SWP_SIZE);
    291                                             // SWP_MOVE is required or PM will move our
    292                                             // subwindow to some adjustment position
    293 
    294                 if (pData->hwndVScroll)
    295                 {
    296                     WinSetWindowPos(pData->hwndVScroll,
    297                                     HWND_TOP,
    298                                     cx,
    299                                     y,
    300                                     pData->cxScrollBar,
    301                                     cy,
    302                                     SWP_MOVE | SWP_SIZE);
    303 
    304                     _PmpfF(("updating VScroll, cy: %d, szlWorkarea.cy: %d",
    305                             cy,
    306                             pData->szlWorkarea.cy));
    307 
    308                     winhUpdateScrollBar(pData->hwndVScroll,
    309                                         cy,
    310                                         pData->szlWorkarea.cy,
    311                                         pData->ptlScrollOfs.y,
    312                                         FALSE);
    313                 }
    314 
    315                 if (pData->hwndHScroll)
    316                 {
    317                     WinSetWindowPos(pData->hwndHScroll,
    318                                     HWND_TOP,
    319                                     0,
    320                                     0,
    321                                     cx,
    322                                     pData->cyScrollBar,
    323                                     SWP_MOVE | SWP_SIZE);
    324 
    325                     _PmpfF(("updating HScroll, cx: %d, szlWorkarea.cx: %d",
    326                             cx,
    327                             pData->szlWorkarea.cx));
    328 
    329                     winhUpdateScrollBar(pData->hwndHScroll,
    330                                         cx,
    331                                         pData->szlWorkarea.cx,
    332                                         pData->ptlScrollOfs.x,
    333                                         FALSE);
    334                 }
     503                WinSetWindowPos(pData->scrw.hwndVScroll,
     504                                HWND_TOP,
     505                                cx,
     506                                y,
     507                                pData->scrw.cxScrollBar,
     508                                cy,
     509                                SWP_MOVE | SWP_SIZE);
     510
     511                _PmpfF(("updating VScroll, cy: %d, scrw.szlWorkarea.cy: %d",
     512                        cy,
     513                        pData->scrw.szlWorkarea.cy));
    335514            }
     515
     516            if (pData->scrw.hwndHScroll)
     517            {
     518                WinSetWindowPos(pData->scrw.hwndHScroll,
     519                                HWND_TOP,
     520                                0,
     521                                0,
     522                                cx,
     523                                pData->scrw.cyScrollBar,
     524                                SWP_MOVE | SWP_SIZE);
     525
     526                _PmpfF(("updating HScroll, cx: %d, scrw.szlWorkarea.cx: %d",
     527                        cx,
     528                        pData->scrw.szlWorkarea.cx));
     529            }
     530
     531            ctnrUpdateScrollbars(pData,
     532                                 cx,
     533                                 cy);
    336534        }
    337535    }
    … …  
    341539 *@@ CnrPaint:
    342540 *      implementation for WM_PAINT in fnwpCnr.
    343  */
    344 
    345 VOID CnrPaint(HWND hwnd)
    346 {
    347     HPS         hps;
    348     PCNRDATA    pData;
    349     RECTL       rclPaint;
    350 
    351     if (    (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
    352          && (hps = WinBeginPaint(hwnd, NULLHANDLE, &rclPaint))
     541 *
     542 *      This paints only the part of the container that belongs
     543 *      to the main container window, which is the title area
     544 *      and/or the details column headings.
     545 */
     546
     547STATIC VOID CnrPaint(PCNRDATA pData)
     548{
     549    HPS     hps;
     550    RECTL   rclPaint;
     551
     552    if (    (pData)
     553         && (hps = WinBeginPaint(pData->dwdMain.hwnd, NULLHANDLE, &rclPaint))
    353554       )
    354555    {
    … …  
    376577                WinFillRect(hps,
    377578                            &rclPaint,
    378                             pData->dwdMain.lcolBackground);
     579                            ctlQueryColor(&pData->dwdMain, CTLCOL_BGND));
    379580
    380581                FOR_ALL_NODES(&pData->llColumns, pColNode)
    … …  
    386587                    ULONG       cRow;
    387588
    388                     rcl.xLeft = pCol->xLeft + COLUMN_PADDING_X - pData->ptlScrollOfs.x;
    389                     rcl.xRight = rcl.xLeft + pCol->cxTotal;
     589                    rcl.xLeft = pCol->xLeft + COLUMN_PADDING_X - pData->scrw.ptlScrollOfs.x;
     590                    rcl.xRight = rcl.xLeft + pCol->cxContent;
    390591
    391592                    // we start out at the top and work our way down,
    … …  
    402603                    else
    403604                    {
    404                         cnrDrawString(hps,
     605                        ctnrDrawString(hps,
    405606                                      (PCSZ)pfi->pTitleData,
    406607                                      &rcl,
    … …  
    438639 */
    439640
    440 MRESULT CnrWindowPosChanged(HWND hwnd,
    441                             MPARAM mp1,
    442                             MPARAM mp2)
     641STATIC MRESULT CnrWindowPosChanged(PCNRDATA pData,
     642                                   MPARAM mp1,
     643                                   MPARAM mp2)
    443644{
    444645    MRESULT mrc = 0;
    445     PCNRDATA pData;
    446     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     646
     647    if (pData)
    447648    {
    448649        mrc = ctlDefWindowProc(&pData->dwdMain, WM_WINDOWPOSCHANGED, mp1, mp2);
    … …  
    450651        if (((PSWP)mp1)->fl & SWP_SIZE)
    451652        {
    452             WinPostMsg(hwnd,
     653            WinPostMsg(pData->dwdMain.hwnd,
    453654                       WM_SEM2,
    454655                       (MPARAM)DDFL_WINDOWSIZECHANGED,
    … …  
    461662
    462663/*
    463  *@@ cnrPresParamChanged:
     664 *@@ ctnrPresParamChanged:
    464665 *      implementation for WM_PRESPARAMCHANGED for both
    465666 *      fnwpCnr and fnwpCnrDetails.
    466667 */
    467668
    468 VOID cnrPresParamChanged(HWND hwnd,
     669VOID ctnrPresParamChanged(HWND hwnd,         // in: either main cnr or content subwindow
    469670                         ULONG ulpp)
    470671{
    471     PCNRDATA pData;
     672    PCNRDATA    pData;
    472673    if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
    473674    {
    474         // note, we use the dwdMain buffer here cos
    475         // we share presparams with the cnr
     675        // note, no matter what hwnd is passed in,
     676        // we use the dwdMain buffer here cos we share presparams
     677        // between all cnr child windows
    476678        ctlRefreshColors(&pData->dwdMain);
    477679
    … …  
    480682            case 0:     // layout palette thing dropped
    481683            case PP_FONTNAMESIZE:
    482                 if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
     684                if (!pData->fSettingPP)
    483685                {
    484                     // if we got this on the details window,
    485                     // set it on the main cnr as well, and
    486                     // vice versa
    487                     PSZ pszFont;
    488                     if (pszFont = winhQueryWindowFont(hwnd))
     686                    pData->fSettingPP = TRUE;
     687
     688                    if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
    489689                    {
    490                         HWND hwndOther;
    491                         DosBeep(1000, 10);
    492                         if (hwnd == pData->dwdMain.hwnd)
    493                             hwndOther = pData->dwdContent.hwnd;
    494                         else
    495                             hwndOther = pData->dwdMain.hwnd;
    496 
    497                         winhSetWindowFont(hwndOther, pszFont);
    498                         free(pszFont);
     690                        // if we got this on the contents window,
     691                        // set it on the main cnr as well, and
     692                        // vice versa
     693                        PSZ pszFont;
     694                        if (pszFont = winhQueryWindowFont(hwnd))
     695                        {
     696                            HWND hwndOther;
     697                            if (hwnd == pData->dwdMain.hwnd)
     698                                hwndOther = pData->dwdContent.hwnd;
     699                            else
     700                                hwndOther = pData->dwdMain.hwnd;
     701
     702                            winhSetWindowFont(hwndOther, pszFont);
     703                            free(pszFont);
     704                        }
     705
     706                        WinPostMsg(pData->dwdMain.hwnd,
     707                                   WM_SEM2,
     708                                   (MPARAM)(DDFL_INVALIDATECOLUMNS | DDFL_INVALIDATERECORDS),
     709                                   0);
    499710                    }
    500711
    501                     WinPostMsg(pData->dwdMain.hwnd,
    502                                WM_SEM2,
    503                                (MPARAM)(DDFL_INVALIDATECOLUMNS | DDFL_INCALIDATERECORDS),
    504                                0);
     712                    pData->fSettingPP = FALSE;
    505713                }
    506714            break;
    … …  
    518726 */
    519727
    520 VOID CnrScroll(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
    521 {
    522     PCNRDATA pData;
    523     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
    524     {
     728STATIC VOID CnrScroll(PCNRDATA pData,
     729                      ULONG msg,
     730                      MPARAM mp1,
     731                      MPARAM mp2)
     732{
     733    if (pData)
     734    {
     735        BOOL    fNotify = FALSE;
     736
    525737        if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
    526738        {
    527             POINTL  ptlScroll;
     739            POINTL          ptlScroll;
     740            NOTIFYSCROLL    ns;
     741            ns.hwndCnr = pData->dwdMain.hwnd;
     742
    528743            if (msg == WM_HSCROLL)
    529744            {
    530745                ptlScroll.y = 0;
    531                 if (ptlScroll.x = winhHandleScrollMsg2(pData->hwndHScroll,
    532                                                        &pData->ptlScrollOfs.x,
    533                                                        pData->dwdContent.szlWin.cx,
    534                                                        pData->szlWorkarea.cx,
    535                                                        5,
    536                                                        msg,
    537                                                        mp2))
     746                if (ptlScroll.x = winhHandleScrollMsg(pData->scrw.hwndHScroll,
     747                                                      &pData->scrw.ptlScrollOfs.x,
     748                                                      pData->dwdContent.szlWin.cx,
     749                                                      pData->scrw.szlWorkarea.cx,
     750                                                      5,
     751                                                      msg,
     752                                                      mp2))
    538753                {
     754                    winhScrollWindow(pData->dwdContent.hwnd,
     755                                     NULL,
     756                                     &ptlScroll);
     757
     758                    // scroll main cnr with detail titles too
    539759                    if (pData->CnrInfo.flWindowAttr & CA_DETAILSVIEWTITLES)
    540760                    {
    … …  
    544764                        rclClip.yBottom = pData->dwdMain.szlWin.cy - pData->cyColTitlesBox;
    545765                        rclClip.yTop = pData->dwdMain.szlWin.cy;
    546                         winhScrollWindow(hwnd,
     766                        winhScrollWindow(pData->dwdMain.hwnd,
    547767                                         &rclClip,
    548768                                         &ptlScroll);
    549769                    }
    550                     winhScrollWindow(pData->hwndDetails,
    551                                      NULL,
    552                                      &ptlScroll);
     770
     771                    ns.lScrollInc = ptlScroll.y;
     772                    ns.fScroll = CMA_HORIZONTAL;        // @@todo details flags
     773                    ctlSendWmControl(pData->dwdMain.hwnd,
     774                                     CN_SCROLL,
     775                                     &ns);
     776
     777                    fNotify = TRUE;
    553778                }
    554779            }
    … …  
    556781            {
    557782                ptlScroll.x = 0;
    558                 if (ptlScroll.y = winhHandleScrollMsg2(pData->hwndVScroll,
    559                                                        &pData->ptlScrollOfs.y,
    560                                                        pData->dwdContent.szlWin.cy,
    561                                                        pData->szlWorkarea.cy,
    562                                                        5,
    563                                                        msg,
    564                                                        mp2))
    565                     winhScrollWindow(pData->hwndDetails,
     783                if (ptlScroll.y = winhHandleScrollMsg(pData->scrw.hwndVScroll,
     784                                                      &pData->scrw.ptlScrollOfs.y,
     785                                                      pData->dwdContent.szlWin.cy,
     786                                                      pData->scrw.szlWorkarea.cy,
     787                                                      5,
     788                                                      msg,
     789                                                      mp2))
     790                {
     791                    winhScrollWindow(pData->dwdContent.hwnd,
    566792                                     NULL,
    567793                                     &ptlScroll);
     794
     795                    ns.lScrollInc = ptlScroll.x;
     796                    ns.fScroll = CMA_VERTICAL;        // @@todo details flags
     797                    ctlSendWmControl(pData->dwdMain.hwnd,
     798                                     CN_SCROLL,
     799                                     &ns);
     800
     801                    fNotify = TRUE;
     802                }
    568803            }
    569804        }
     805
     806        if (fNotify)
     807            SendViewportChanged(pData);
    570808    }
    571809}
    … …  
    576814 */
    577815
    578 VOID CnrDestroy(HWND hwnd)
    579 {
    580     PCNRDATA pData;
    581     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     816STATIC VOID CnrDestroy(PCNRDATA pData)
     817{
     818    if (pData)
    582819    {
    583820        // free all data that we ever allocated;
    … …  
    605842 */
    606843
    607 USHORT CnrQueryCnrInfo(HWND hwnd,
    608                        PCNRINFO pci,        // in: mp1 of CM_QUERYCNRINFO
    609                        USHORT cb)           // in: mp2 of CM_QUERYCNRINFO
    610 {
    611     PCNRDATA pData;
    612     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     844STATIC USHORT CnrQueryCnrInfo(PCNRDATA pData,
     845                              PCNRINFO pci,        // out: target buffer (mp1 of CM_QUERYCNRINFO)
     846                              USHORT cb)           // in: mp2 of CM_QUERYCNRINFO
     847{
     848    if (pData)
    613849    {
    614850        USHORT cbCopied = max(cb, sizeof(CNRINFO));
    … …  
    629865 */
    630866
    631 BOOL CnrSetCnrInfo(HWND hwnd,
    632                    PCNRINFO pci,        // in: mp1 of CM_SETCNRINFO
    633                    ULONG flCI)          // in: CMA_* flags in mp2 of CM_SETCNRINFO
    634 {
    635     PCNRDATA pData;
    636     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     867STATIC BOOL CnrSetCnrInfo(PCNRDATA pData,
     868                          PCNRINFO pci,        // in: mp1 of CM_SETCNRINFO
     869                          ULONG flCI)          // in: CMA_* flags in mp2 of CM_SETCNRINFO
     870{
     871    if (pData)
    637872    {
    638873        ULONG   flDirty = 0;
    … …  
    680915                if (pData->CnrInfo.flWindowAttr & CV_DETAIL)
    681916                {
    682                     if (!pData->hwndDetails)
     917                    if (!pData->dwdContent.hwnd)
    683918                    {
    684                         if (pData->hwndDetails = CreateChild(pData,
    685                                                              WC_CCTL_CNR_DETAILS,
    686                                                              CID_LEFTDVWND))
     919                        if (pData->dwdContent.hwnd = CreateChild(pData,
     920                                                                 WC_CCTL_CNR_DETAILS,
     921                                                                 CID_LEFTDVWND))
    687922                        {
    688923                            flDirty = DDFL_ALL;
    … …  
    692927                else
    693928                {
    694                     winhDestroyWindow(&pData->hwndDetails);
     929                    winhDestroyWindow(&pData->dwdContent.hwnd);
    695930                }
    696931            }
    … …  
    7821017            // flWindowAttr field is not specified, these lines are not drawn.
    7831018            pData->CnrInfo.cxTreeLine = pci->cxTreeLine;
     1019
     1020            // @@todo recalc window components, repaint
    7841021        }
    7851022
    … …  
    7901027            // value is negative one (-1).
    7911028            pData->CnrInfo.xVertSplitbar = pci->xVertSplitbar;
     1029
     1030            // @@todo recalc window components, repaint
    7921031        }
    7931032
    7941033        if (flDirty)
    7951034            // post semaphore to force resize of details wnd
    796             WinPostMsg(hwnd,
     1035            WinPostMsg(pData->dwdMain.hwnd,
    7971036                       WM_SEM2,
    7981037                       (MPARAM)flDirty,
    … …  
    8051044}
    8061045
     1046/*
     1047 *@@ CnrQueryViewportRect:
     1048 *      implementation for CM_QUERYVIEWPORTRECT in fnwpCnr.
     1049 *
     1050 *      From my testing, this simply returns the extensions
     1051 *      of the container content window, which the cnr docs
     1052 *      dub the "viewport". This never returns the workarea
     1053 *      size, that is, the total size of the container's
     1054 *      viewable content.
     1055 */
     1056
     1057STATIC BOOL CnrQueryViewportRect(PCNRDATA pData,
     1058                                 PRECTL prcl,
     1059                                 USHORT usIndicator,
     1060                                 BOOL fRightSplitView)      // @@todo
     1061{
     1062    if (pData && prcl)
     1063    {
     1064        prcl->xLeft = 0;
     1065        prcl->yBottom = 0;
     1066        prcl->xRight = pData->dwdContent.szlWin.cx;
     1067        prcl->yTop = pData->dwdContent.szlWin.cy;
     1068
     1069        switch (usIndicator)
     1070        {
     1071            case CMA_WORKSPACE:
     1072                // for CMA_WORKSPACE, the PM cnr returns a 0 yBottom when
     1073                // the cnr is scrolled to the very top and negative y
     1074                // values when it has been scrolled down to some extent;
     1075                // wonder what the use for this would be
     1076                prcl->xLeft += pData->scrw.ptlScrollOfs.x;
     1077                prcl->xRight += pData->scrw.ptlScrollOfs.x;
     1078                prcl->yBottom -= pData->scrw.ptlScrollOfs.y;
     1079                prcl->yTop -= pData->scrw.ptlScrollOfs.y;
     1080            break;
     1081
     1082            case CMA_WINDOW:
     1083                // for CMA_WINDOW, the PM cnr returns a constant
     1084                // rectangle without scrolling taken into account
     1085                WinMapWindowPoints(pData->dwdContent.hwnd,
     1086                                   pData->dwdMain.hwnd,
     1087                                   (PPOINTL)prcl,
     1088                                   2);
     1089            break;
     1090        }
     1091
     1092        return TRUE;
     1093    }
     1094
     1095    return FALSE;
     1096}
     1097
    8071098/* ******************************************************************
    8081099 *
    … …  
    8181109 */
    8191110
    820 PFIELDINFO CnrAllocDetailFieldInfo(HWND hwnd,
    821                                    USHORT cFieldInfos)      // in: no. of fieldinfos to allocate (> 0)
     1111STATIC PFIELDINFO CnrAllocDetailFieldInfo(PCNRDATA pData,
     1112                                          USHORT cFieldInfos)      // in: no. of fieldinfos to allocate (> 0)
    8221113{
    8231114    PFIELDINFO  pfiFirst = NULL,
    8241115                pfiPrev = NULL;
    8251116
    826     PCNRDATA    pData;
    827     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1117    if (pData)
    8281118    {
    8291119        ULONG       ul;
    … …  
    8631153 */
    8641154
    865 USHORT CnrInsertDetailFieldInfo(HWND hwnd,
    866                                 PFIELDINFO pfiFirst,
    867                                 PFIELDINFOINSERT pfii)
     1155STATIC USHORT CnrInsertDetailFieldInfo(PCNRDATA pData,
     1156                                       PFIELDINFO pfiFirst,
     1157                                       PFIELDINFOINSERT pfii)
    8681158{
    8691159    USHORT      usrc = 0;
    870     PCNRDATA    pData;
    871     if (    (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1160
     1161    if (    (pData)
    8721162         && (pfiFirst)
    8731163         && (pfii)
    … …  
    9331223        {
    9341224            // post semaphore to force resize of details wnd
    935             WinPostMsg(hwnd,
     1225            WinPostMsg(pData->dwdMain.hwnd,
    9361226                       WM_SEM2,
    9371227                       (MPARAM)DDFL_ALL,
    … …  
    9481238 */
    9491239
    950 BOOL CnrInvalidateDetailFieldInfo(HWND hwnd)
    951 {
    952     PCNRDATA    pData;
    953     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
    954     {
    955         WinPostMsg(hwnd,
    956                    WM_SEM2,
    957                    (MPARAM)DDFL_INVALIDATECOLUMNS,
    958                    0);
    959     }
     1240STATIC BOOL CnrInvalidateDetailFieldInfo(PCNRDATA pData)
     1241{
     1242    if (pData)
     1243        return WinPostMsg(pData->dwdMain.hwnd,
     1244                          WM_SEM2,
     1245                          (MPARAM)DDFL_INVALIDATECOLUMNS,
     1246                          0);
    9601247
    9611248    return FALSE;
     1249}
     1250
     1251/*
     1252 *@@ CnrQueryDetailFieldInfo:
     1253 *      implementation for CM_QUERYDETAILFIELDINFO in fnwpCnr.
     1254 */
     1255
     1256STATIC const FIELDINFO* CnrQueryDetailFieldInfo(PCNRDATA pData,
     1257                                                PFIELDINFO pfiIn,
     1258                                                USHORT cmd)        // in: mp2 (CMA_FIRST, CMA_LAST, CMA_NEXT, CMA_PREV)
     1259{
     1260    const FIELDINFO *pfiReturn = NULL;
     1261
     1262    if (pData)
     1263    {
     1264        PLISTNODE pNode;
     1265
     1266        switch (cmd)
     1267        {
     1268            case CMA_FIRST:
     1269                pNode = lstQueryFirstNode(&pData->llColumns);
     1270            break;
     1271
     1272            case CMA_LAST:
     1273                pNode = lstQueryLastNode(&pData->llColumns);
     1274            break;
     1275
     1276            case CMA_NEXT:
     1277            case CMA_PREV:
     1278                if (FindColumnFromFI(pData,
     1279                                     pfiIn,
     1280                                     &pNode))
     1281                    if (cmd == CMA_NEXT)
     1282                        pNode = pNode->pNext;
     1283                    else
     1284                        pNode = pNode->pPrevious;
     1285            break;
     1286        }
     1287
     1288        if (pNode)
     1289            pfiReturn = ((PDETAILCOLUMN)pNode->pItemData)->pfi;
     1290    }
     1291
     1292    return pfiReturn;
    9621293}
    9631294
    … …  
    9671298 */
    9681299
    969 SHORT CnrRemoveDetailFieldInfo(HWND hwnd,
    970                                PFIELDINFO* ppafi,
    971                                USHORT cfi,
    972                                USHORT fl)
    973 {
    974     PCNRDATA    pData;
    975     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1300STATIC SHORT CnrRemoveDetailFieldInfo(PCNRDATA pData,
     1301                                      PFIELDINFO* ppafi,
     1302                                      USHORT cfi,
     1303                                      USHORT fl)
     1304{
     1305    if (pData)
    9761306    {
    9771307        SHORT   rc = lstCountItems(&pData->llColumns);
    … …  
    10111341           )
    10121342        {
    1013             WinPostMsg(hwnd,
     1343            WinPostMsg(pData->dwdMain.hwnd,
    10141344                       WM_SEM2,
    10151345                       (MPARAM)DDFL_INVALIDATECOLUMNS,
    … …  
    10281358 */
    10291359
    1030 BOOL CnrFreeDetailFieldInfo(HWND hwnd,
    1031                             PFIELDINFO *ppafi,      // in: mp1 of CM_FREEDETAILFIELDINFO
    1032                             USHORT cFieldInfos)     // in: no. of items in array
     1360STATIC BOOL CnrFreeDetailFieldInfo(PCNRDATA pData,
     1361                                   PFIELDINFO *ppafi,      // in: mp1 of CM_FREEDETAILFIELDINFO
     1362                                   USHORT cFieldInfos)     // in: no. of items in array
    10331363{
    10341364    BOOL        brc = FALSE;
    10351365
    1036     PCNRDATA    pData;
    1037     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1366    if (pData)
    10381367    {
    10391368        ULONG   ul;
    … …  
    10701399 */
    10711400
    1072 PRECORDCORE CnrAllocRecord(HWND hwnd,
    1073                            ULONG cbExtra,
    1074                            USHORT cRecords)
     1401STATIC PRECORDCORE CnrAllocRecord(PCNRDATA pData,
     1402                                  ULONG cbExtra,
     1403                                  USHORT cRecords)
    10751404{
    10761405    PRECORDCORE preccFirst = NULL;
    1077     PCNRDATA    pData;
    1078     if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1406
     1407    if (pData)
    10791408    {
    10801409        ULONG   ul;
    … …  
    11241453 */
    11251454
    1126 ULONG CnrInsertRecord(HWND hwnd,
    1127                       PRECORDCORE preccFirst,
    1128                       PRECORDINSERT pri)
     1455STATIC ULONG CnrInsertRecord(PCNRDATA pData,
     1456                             PRECORDCORE preccFirst,
     1457                             PRECORDINSERT pri)
    11291458{
    11301459    ULONG       cReturn = 0;
    1131     PCNRDATA    pData;
    1132     if (    (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     1460
     1461    if (    (pData)
    11331462         && (preccFirst)
    11341463         && (pri)
    … …  
    11631492
    11641493            default:
    1165                 pNodeInsertAfter = FindListNodeForRecc(pData,
    1166                                                        pri->pRecordOrder);
     1494                pNodeInsertAfter = ctnrFindListNodeForRecc(pData,
     1495                                                           pri->pRecordOrder);
    11671496        }
    11681497
    … …  
    11711500             ++ul)
    11721501        {
    1173             PRECORDLISTITEM pListItem;
    1174 
    1175             if (pListItem = NEW(RECORDLISTITEM))
     1502            PRECORDLISTITEM prli;
     1503
     1504            if (prli = NEW(RECORDLISTITEM))
    11761505            {
    1177                 ZERO(pListItem);
    1178 
    1179                 pListItem->precc = preccThis;
    1180                 pListItem->preccParent = pri->pRecordParent;
     1506                ZERO(prli);
     1507
     1508                prli->precc = preccThis;
     1509                prli->preccParent = pri->pRecordParent;
     1510
     1511                // make private copy of record attributes
     1512                prli->flRecordAttr = preccThis->flRecordAttr;
     1513
     1514                // PM container gives the first record in the cnr
     1515                // "cursored" and "selected" emphasis, so that's
     1516                // what we'll do too
     1517                if (    (!cReturn)       // @@todo filtered records
     1518                     && (!(prli->flRecordAttr & CRA_FILTERED))
     1519                   )
     1520                {
     1521                    prli->flRecordAttr |= CRA_CURSORED | CRA_SELECTED;
     1522
     1523                    pData->prliCursored = prli;
     1524                }
    11811525
    11821526                if (pNodeInsertAfter = lstInsertItemAfterNode(pll,
    1183                                                               pListItem,
     1527                                                              prli,
    11841528                                                              pNodeInsertAfter))
    11851529                {
    … …  
    12121556                }
    12131557
    1214                 free(pListItem);
     1558                free(prli);
    12151559            }
    12161560
    1217             free(pListItem);
     1561            free(prli);
    12181562
    12191563            cReturn = 0;
    … …  
    12251569           )
    12261570        {
    1227             WinPostMsg(hwnd,
     1571            WinPostMsg(pData->dwdMain.hwnd,
    12281572                       WM_SEM2,
    1229                        (MPARAM)DDFL_INCALIDATERECORDS,
     1573                       (MPARAM)DDFL_INVALIDATERECORDS,
    12301574                       0);
    12311575        }
    … …  
    12351579}
    12361580
     1581/*
     1582 *@@ CnrInsertRecordArray:
     1583 *      implementation for CM_INSERTRECORDARRAY in fnwpCnr.
     1584 */
     1585
     1586STATIC ULONG CnrInsertRecordArray(PCNRDATA pData,
     1587                                  PRECORDCORE *papRecords,
     1588                                  PRECORDINSERT pri)
     1589{
     1590    ULONG       cReturn = 0;
     1591
     1592    if (    (pData)
     1593         && (papRecords)
     1594         && (pri)
     1595         && (pri->cb = sizeof(RECORDINSERT))
     1596       )
     1597    {
     1598        // produce a linked list off the array and call
     1599        // the CM_INSERTRECORD implementation
     1600        ULONG   ul;
     1601        for (ul = 0;
     1602             ul < (pri->cRecordsInsert - 1);
     1603             ++ul)
     1604        {
     1605            papRecords[ul]->preccNextRecord = papRecords[ul + 1];
     1606        }
     1607
     1608        papRecords[pri->cRecordsInsert - 1]->preccNextRecord = (PRECORDCORE)NULL;
     1609
     1610        cReturn = CnrInsertRecord(pData,
     1611                                  papRecords[0],
     1612                                  pri);
     1613    }
     1614
     1615    return cReturn;
     1616}
     1617
     1618/*
     1619 *@@ CnrSetRecordEmphasis:
     1620 *      implementation for CM_SETRECORDEMPHASIS in fnwpCnr.
     1621 */
     1622
     1623STATIC BOOL CnrSetRecordEmphasis(PCNRDATA pData,
     1624                                 PRECORDCORE precc,
     1625                                 BOOL fTurnOn,
     1626                                 USHORT fsEmphasis)
     1627{
     1628    BOOL        brc = FALSE;
     1629
     1630    if (pData)
     1631    {
     1632        if (precc)
     1633        {
     1634            PLISTNODE   pNode;
     1635            if (pNode = ctnrFindListNodeForRecc(pData,
     1636                                                precc))
     1637            {
     1638                PRECORDLISTITEM prli = (PRECORDLISTITEM)pNode->pItemData;
     1639
     1640                ctnrChangeEmphasis(pData,
     1641                                   prli,
     1642                                   fTurnOn,
     1643                                   fsEmphasis);
     1644
     1645                // update caller's buffer too
     1646                precc->flRecordAttr = prli->flRecordAttr;
     1647
     1648                brc = TRUE;
     1649            }
     1650        } // if (precc)
     1651        // @@todo else set emphasis on entire cnr
     1652    }
     1653
     1654    return brc;
     1655}
     1656
     1657/*
     1658 *@@ CnrQueryRecordEmphasis:
     1659 *      implementation for CM_QUERYRECORDEMPHASIS in fnwpCnr.
     1660 *
     1661 *      Note, if several flags are set in fsEmphasis, all
     1662 *      of them must be set in the record to match.
     1663 */
     1664
     1665PRECORDCORE CnrQueryRecordEmphasis(PCNRDATA pData,
     1666                                   PRECORDCORE preccSearchAfter,
     1667                                   USHORT fsEmphasis)
     1668{
     1669    if (pData)
     1670    {
     1671        PLISTNODE pNode = NULL;
     1672        if (preccSearchAfter == (PRECORDCORE)CMA_FIRST)
     1673            pNode = lstQueryFirstNode(&pData->llRootRecords);
     1674        else
     1675            if (pNode = ctnrFindListNodeForRecc(pData, preccSearchAfter))
     1676                pNode = pNode->pNext;
     1677            else
     1678                return (PRECORDCORE)-1;
     1679        // @@todo how does this search tree subrecords?
     1680
     1681        while (pNode)
     1682        {
     1683            PRECORDLISTITEM prli = (PRECORDLISTITEM)pNode->pItemData;
     1684            if ((prli->flRecordAttr & fsEmphasis) == fsEmphasis)
     1685                return (PRECORDCORE)prli->precc;
     1686
     1687            pNode = pNode->pNext;
     1688        }
     1689    }
     1690
     1691    return NULL;
     1692}
     1693
     1694/*
     1695 *@@ CnrInvalidateRecord:
     1696 *      implementation for CM_INVALIDATERECORD in fnwpCnr.
     1697 *
     1698 */
     1699
     1700STATIC BOOL CnrInvalidateRecord(PCNRDATA pData,
     1701                                PRECORDCORE *papRecs,
     1702                                USHORT cRecs,
     1703                                USHORT fsInvalidate)
     1704{
     1705    BOOL    brc = TRUE;
     1706
     1707    if (pData)
     1708    {
     1709        if (    (!papRecs)
     1710             || (!cRecs)
     1711           )
     1712            // invalidate all:
     1713            CnrSem2(pData, DDFL_INVALIDATERECORDS);
     1714        else
     1715        {
     1716            ULONG   ul;
     1717            for (ul = 0;
     1718                 ul < cRecs;
     1719                 ++cRecs)
     1720            {
     1721                PRECORDCORE precc = papRecs[ul];
     1722                PLISTNODE pRecNode;
     1723                if (!(pRecNode = ctnrFindListNodeForRecc(pData,
     1724                                                         precc)))
     1725                {
     1726                    brc = FALSE;
     1727                    break;
     1728                }
     1729
     1730                // set special flag for recompute
     1731                ((PRECORDLISTITEM)pRecNode->pItemData)->flInvalidate = fsInvalidate;
     1732            }
     1733
     1734            if (brc)
     1735                CnrSem2(pData, DDFL_INVALIDATESOME);
     1736                // @@todo optimize: post sem only if a column size has
     1737                // actually changed
     1738        }
     1739    }
     1740
     1741    return brc;
     1742}
     1743
    12371744/* ******************************************************************
    12381745 *
    … …  
    12491756{
    12501757    MRESULT     mrc = 0;
    1251     PCNRDATA    pData;
     1758
     1759    PCNRDATA    pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1);
    12521760
    12531761    switch (msg)
    … …  
    12641772
    12651773        case WM_SEM2:
    1266             CnrSem2(hwnd, (ULONG)mp1);
     1774            CnrSem2(pData, (ULONG)mp1);
    12671775        break;
    12681776
    12691777        case WM_PAINT:
    1270             CnrPaint(hwnd);
     1778            CnrPaint(pData);
    12711779        break;
    12721780
    12731781        case WM_WINDOWPOSCHANGED:
    1274             mrc = CnrWindowPosChanged(hwnd, mp1, mp2);
     1782            mrc = CnrWindowPosChanged(pData, mp1, mp2);
     1783        break;
     1784
     1785        case WM_SYSCOLORCHANGE:
     1786            ctnrPresParamChanged(hwnd, 0);
     1787        break;
     1788
     1789        case WM_PRESPARAMCHANGED:
     1790            ctnrPresParamChanged(hwnd, (ULONG)mp1);
    12751791        break;
    12761792
    12771793        case WM_HSCROLL:
    12781794        case WM_VSCROLL:
    1279             CnrScroll(hwnd, msg, mp1, mp2);
     1795            CnrScroll(pData, msg, mp1, mp2);
    12801796        break;
    12811797
    12821798        case WM_DESTROY:
    1283             CnrDestroy(hwnd);
     1799            CnrDestroy(pData);
     1800        break;
     1801
     1802        /* ******************************************************************
     1803         *
     1804         *   Mouse and keyboard input
     1805         *
     1806         ********************************************************************/
     1807
     1808        /*
     1809         * WM_OPEN:
     1810         *      when the user double-clicks on the _main_ cnr
     1811         *      (i.e. details titles), we notify the owner
     1812         *      of a "whitespace" enter event.
     1813         */
     1814
     1815        case WM_OPEN:
     1816            ctnrRecordEnter(pData,
     1817                            NULL,
     1818                            FALSE);     // mouse, not keyboard
     1819            mrc = (MRESULT)TRUE;
    12841820        break;
    12851821
    … …  
    13011837         */
    13021838
    1303         case CM_QUERYCNRINFO:
    1304             mrc = (MRESULT)CnrQueryCnrInfo(hwnd,
     1839        case CM_QUERYCNRINFO:       // done
     1840            mrc = (MRESULT)CnrQueryCnrInfo(pData,
    13051841                                           (PCNRINFO)mp1,
    1306                                            (USHORT)mp2);
     1842                                           SHORT1FROMMP(mp2));
    13071843        break;
    13081844
    … …  
    13191855         */
    13201856
    1321         case CM_SETCNRINFO:
    1322             mrc = (MRESULT)CnrSetCnrInfo(hwnd,
     1857        case CM_SETCNRINFO:         // parlty done
     1858            mrc = (MRESULT)CnrSetCnrInfo(pData,
    13231859                                         (PCNRINFO)mp1,
    13241860                                         (ULONG)mp2);
    13251861        break;
    13261862
     1863        case CM_PAINTBACKGROUND:        // @@todo
     1864        break;
     1865
     1866        case CM_SCROLLWINDOW:           // @@todo
     1867        break;
     1868
     1869        /*
     1870         * CM_QUERYVIEWPORTRECT:
     1871         *
     1872         *      Parameters:
     1873         *
     1874         *      --  PRECTL mp1
     1875         *
     1876         *      --  SHORT1FROMMP(mp2): -- CMA_WINDOW: return window coordinates
     1877         *                             -- CMA_WORKSPACE: return workspace coordinates
     1878         *
     1879         *      --  BOOL SHORT2FROMMP(mp2): if TRUE, return right split details view
     1880         */
     1881
     1882        case CM_QUERYVIEWPORTRECT:          // done
     1883            mrc = (MRESULT)CnrQueryViewportRect(pData,
     1884                                                (PRECTL)mp1,
     1885                                                SHORT1FROMMP(mp2),
     1886                                                SHORT2FROMMP(mp2));
     1887        break;
     1888
     1889        case CM_SETTEXTVISIBILITY:      // @@todo
     1890        break;
     1891
    13271892        /* ******************************************************************
    13281893         *
    1329          *   FIELDINFO-related messages
     1894         *   Record allocation/insertion/removal
     1895         *
     1896         ********************************************************************/
     1897
     1898        /*
     1899         * CM_ALLOCRECORD:
     1900         *
     1901         *      Parameters:
     1902         *
     1903         *      --  ULONG mp1: record size in addition to (MINI)RECORDCORE size.
     1904         *
     1905         *      --  USHORT mp2: no. of records to allocate.
     1906         *
     1907         *      Returns linked list of RECORDCORE's or NULL on errors.
     1908         */
     1909
     1910        case CM_ALLOCRECORD:          // done
     1911            mrc = (MRESULT)CnrAllocRecord(pData,
     1912                                          (ULONG)mp1,
     1913                                          SHORT1FROMMP(mp2));
     1914        break;
     1915
     1916        /*
     1917         * CM_INSERTRECORD:
     1918         *      inserts one or more records. If there's more
     1919         *      than one record, we assume it's a linked list.
     1920         *
     1921         *      Parameters:
     1922         *
     1923         *      --  PRECORDCORE mp1: first record
     1924         *
     1925         *      --  PRECORDINSERT pri
     1926         *
     1927         *      Returns the no. of records in the container or 0 on errors.
     1928         */
     1929
     1930        case CM_INSERTRECORD:           // done
     1931            mrc = (MRESULT)CnrInsertRecord(pData,
     1932                                           (PRECORDCORE)mp1,
     1933                                           (PRECORDINSERT)mp2);
     1934        break;
     1935
     1936        /*
     1937         * CM_INSERTRECORDARRAY:
     1938         *      inserts one or more records. As opposed to with
     1939         *      CM_INSERTRECORD, mp1 points to an array of
     1940         *      record pointers instead of to a linked list
     1941         *      of records.
     1942         *
     1943         *      Parameters:
     1944         *
     1945         *      --  PRECORDCORE mp1: first record
     1946         *
     1947         *      --  PRECORDINSERT pri
     1948         *
     1949         *      Returns the no. of records in the container or 0 on errors.
     1950         */
     1951
     1952        case CM_INSERTRECORDARRAY:      // done
     1953            mrc = (MRESULT)CnrInsertRecordArray(pData,
     1954                                               (PRECORDCORE*)mp1,
     1955                                               (PRECORDINSERT)mp2);
     1956        break;
     1957
     1958        /*
     1959         * CM_QUERYRECORD:
     1960         *
     1961         *      Parameters:
     1962         *
     1963         *      --  PRECORDCORE mp1: preccSearch
     1964         *
     1965         *      --  SHORT1FROMMP(mp1): CMA_FIRST, CMA_LAST, CMA_NEXT, CMA_PREV
     1966         *
     1967         *          or for tree views: CMA_FIRSTCHILD, CMA_LASTCHILD, CMA_PARENT
     1968         *
     1969         *      --  SHORT2FROMMP(mp1): CMA_ITEMORDER or CMA_ZORDER
     1970         */
     1971
     1972        case CM_QUERYRECORD:            // @@todo
     1973        break;
     1974
     1975        /*
     1976         * CM_SETRECORDEMPHASIS:
     1977         *
     1978         *      Parameters:
     1979         *
     1980         *      --  PRECORDCORE mp1: record to change emphasis for.
     1981         *
     1982         *      --  SHORT1FROMMP(mp2): TRUE == turn flags on, FALSE == turn flags off.
     1983         *
     1984         *      --  SHORT2FROMMP(mp2): any combination of CRA_CURSORED, CRA_DISABLED,
     1985         *          CRA_INUSE, CRA_PICKED, CRA_SELECTED, CRA_SOURCE
     1986         *
     1987         *      Returns BOOL.
     1988         */
     1989
     1990        case CM_SETRECORDEMPHASIS:
     1991            mrc = (MRESULT)CnrSetRecordEmphasis(pData,
     1992                                                (PRECORDCORE)mp1,
     1993                                                SHORT1FROMMP(mp2),
     1994                                                SHORT2FROMMP(mp2));
     1995        break;
     1996
     1997        /*
     1998         * CM_QUERYRECORDEMPHASIS:
     1999         *
     2000         *      Parameters:
     2001         *
     2002         *      --  PRECORDCORE mp1: record after which to start search
     2003         *          or NULL to start search from beginning.
     2004         *
     2005         *      --  USHORT mp2: any combination of CRA_COLLAPSED, CRA_CURSORED,
     2006         *          CRA_DISABLED, CRA_DROPONABLE, CRA_EXPANDED, CRA_FILTERED,
     2007         *          CRA_INUSE, CRA_PICKED, CRA_SELECTED, CRA_SOURCE
     2008         */
     2009
     2010        case CM_QUERYRECORDEMPHASIS:    // done
     2011            mrc = (MRESULT)CnrQueryRecordEmphasis(pData,
     2012                                                  (PRECORDCORE)mp1,
     2013                                                  SHORT1FROMMP(mp2));
     2014        break;
     2015
     2016        case CM_QUERYRECORDFROMRECT:    // @@todo
     2017        break;
     2018
     2019        case CM_QUERYRECORDINFO:        // @@todo
     2020        break;
     2021
     2022        case CM_QUERYRECORDRECT:        // @@todo
     2023        break;
     2024
     2025        /*
     2026         * CM_INVALIDATERECORD:
     2027         *
     2028         *      Parameters:
     2029         *
     2030         *      --  PRECORDCORE* mp1: ptr to array of record pointers
     2031         *
     2032         *      --  SHORT1FROMMP(mp2): no. of records in array
     2033         *
     2034         *      --  SHORT2FROMMP(mp2): CMA_ERASE, CMA_REPOSITION,
     2035         *          CMA_NOREPOSITION, CMA_TEXTCHANGED
     2036         *
     2037         *      Returns BOOL.
     2038         */
     2039
     2040        case CM_INVALIDATERECORD:       // done
     2041            mrc = (MRESULT)CnrInvalidateRecord(pData,
     2042                                               (PRECORDCORE*)mp1,
     2043                                               SHORT1FROMMP(mp2),
     2044                                               SHORT2FROMMP(mp2));
     2045        break;
     2046
     2047        case CM_REMOVERECORD:   // @@todo
     2048        case CM_FREERECORD:     // @@todo
     2049        break;
     2050
     2051        case CM_ERASERECORD:    // @@todo
     2052        break;
     2053
     2054        case CM_ARRANGE:        // @@todo
     2055        break;
     2056
     2057        case CM_FILTER:         // @@todo
     2058        break;
     2059
     2060        case CM_QUERYDRAGIMAGE: // @@todo
     2061
     2062        case CM_SEARCHSTRING:
     2063
     2064        case CM_SORTRECORD:     // @@todo
     2065
     2066        /* ******************************************************************
     2067         *
     2068         *   Details view
    13302069         *
    13312070         ********************************************************************/
    … …  
    13432082         */
    13442083
    1345         case CM_ALLOCDETAILFIELDINFO:
    1346             mrc = (MRESULT)CnrAllocDetailFieldInfo(hwnd,
    1347                                                    (USHORT)mp1);
     2084        case CM_ALLOCDETAILFIELDINFO: // done
     2085            mrc = (MRESULT)CnrAllocDetailFieldInfo(pData,
     2086                                                   SHORT1FROMMP(mp1));
    13482087        break;
    13492088
    … …  
    13602099         */
    13612100
    1362         case CM_INSERTDETAILFIELDINFO:
    1363             mrc = (MRESULT)CnrInsertDetailFieldInfo(hwnd,
     2101        case CM_INSERTDETAILFIELDINFO:      // done
     2102            mrc = (MRESULT)CnrInsertDetailFieldInfo(pData,
    13642103                                                    (PFIELDINFO)mp1,
    13652104                                                    (PFIELDINFOINSERT)mp2);
    … …  
    13732112         */
    13742113
    1375         case CM_INVALIDATEDETAILFIELDINFO:
    1376             mrc = (MRESULT)CnrInvalidateDetailFieldInfo(hwnd);
     2114        case CM_INVALIDATEDETAILFIELDINFO:  // done
     2115            mrc = (MRESULT)CnrInvalidateDetailFieldInfo(pData);
     2116        break;
     2117
     2118        /*
     2119         * CM_QUERYDETAILFIELDINFO:
     2120         *
     2121         *      Parameters:
     2122         *
     2123         *      --  PFIELDINFO mp1
     2124         *
     2125         *      --  USHORT mp2: CMA_FIRST, CMA_LAST, CMA_NEXT, CMA_PREV
     2126         */
     2127
     2128        case CM_QUERYDETAILFIELDINFO:       // done
     2129            mrc = (MRESULT)CnrQueryDetailFieldInfo(pData,
     2130                                                   (PFIELDINFO)mp1,
     2131                                                   SHORT1FROMMP(mp2));
    13772132        break;
    13782133
    … …  
    13912146         */
    13922147
    1393         case CM_REMOVEDETAILFIELDINFO:
    1394             mrc = (MRESULT)CnrRemoveDetailFieldInfo(hwnd,
     2148        case CM_REMOVEDETAILFIELDINFO:      // done
     2149            mrc = (MRESULT)CnrRemoveDetailFieldInfo(pData,
    13952150                                                    (PFIELDINFO*)mp1,
    13962151                                                    SHORT1FROMMP(mp2),
    … …  
    14092164         */
    14102165
    1411         case CM_FREEDETAILFIELDINFO:
    1412             mrc = (MRESULT)CnrFreeDetailFieldInfo(hwnd,
     2166        case CM_FREEDETAILFIELDINFO:        // done
     2167            mrc = (MRESULT)CnrFreeDetailFieldInfo(pData,
    14132168                                                  (PFIELDINFO*)mp1,
    1414                                                   (USHORT)mp2);
     2169                                                  SHORT1FROMMP(mp2));
     2170        break;
     2171
     2172        case CM_HORZSCROLLSPLITWINDOW:
    14152173        break;
    14162174
    14172175        /* ******************************************************************
    14182176         *
    1419          *   Record allocation/insertion/removal
     2177         *   Icon view
    14202178         *
    14212179         ********************************************************************/
    14222180
    1423         /*
    1424          * CM_ALLOCRECORD:
    1425          *
    1426          *      Parameters:
    1427          *
    1428          *      --  ULONG mp1: record size in addition to (MINI)RECORDCORE size.
    1429          *
    1430          *      --  USHORT mp2: no. of records to allocate.
    1431          *
    1432          *      Returns linked list of RECORDCORE's or NULL on errors.
    1433          */
    1434 
    1435         case CM_ALLOCRECORD:
    1436             mrc = (MRESULT)CnrAllocRecord(hwnd,
    1437                                           (ULONG)mp1,
    1438                                           (USHORT)mp2);
    1439         break;
    1440 
    1441         /*
    1442          * CM_INSERTRECORD:
    1443          *
    1444          *      Parameters:
    1445          *
    1446          *      --  PRECORDCORE mp1: first record
    1447          *
    1448          *      --  PRECORDINSERT pri
    1449          *
    1450          *      Returns the no. of records in the container or 0 on errors.
    1451          */
    1452 
    1453         case CM_INSERTRECORD:
    1454             mrc = (MRESULT)CnrInsertRecord(hwnd,
    1455                                            (PRECORDCORE)mp1,
    1456                                            (PRECORDINSERT)mp2);
    1457         break;
     2181        case CM_SETGRIDINFO:    // @@todo
     2182        case CM_QUERYGRIDINFO:  // @@todo
     2183        case CM_SNAPTOGRID:     // @@todo
     2184        break;
     2185
     2186        /* ******************************************************************
     2187         *
     2188         *   Tree management
     2189         *
     2190         ********************************************************************/
     2191
     2192        case CM_COLLAPSETREE:   // @@todo
     2193        case CM_EXPANDTREE:
     2194        case CM_MOVETREE:       // @@todo
     2195        break;
     2196
     2197        /* ******************************************************************
     2198         *
     2199         *   Direct editing
     2200         *
     2201         ********************************************************************/
     2202
     2203        case CM_OPENEDIT:       // @@todo
     2204
     2205        case CM_CLOSEEDIT:      // @@todo
     2206        break;
     2207
    14582208
    14592209        default:
    1460             if (pData = (PCNRDATA)WinQueryWindowPtr(hwnd, QWL_USER + 1))
     2210            if (pData)
    14612211                mrc = ctlDefWindowProc(&pData->dwdMain, msg, mp1, mp2);
    14622212        break;
Note: See TracChangeset for help on using the changeset viewer.