/*++ Copyright (c) 1990-1995 Microsoft Corporation Module Name: treeview.c Abstract: This module contains tree view function for the printer driver Author: 19-Jun-1995 Mon 11:50:26 created -by- Daniel Chou (danielc) [Environment:] NT Windows - Common Printer Driver UI DLL. [Notes:] Revision History: --*/ #include "precomp.h" #pragma hdrstop #define DBG_CPSUIFILENAME DbgTreeView #define DBG_AI 0x00000001 #define DBG_UTV 0x00000002 #define DBG_MAI 0x00000004 #define DBG_CTVWND 0x00000008 #define DBG_AC 0x00000010 #define DBG_TVPROC 0x00000020 #define DBG_STVS 0x00000040 #define DBG_AIG 0x00000080 #define DBGITEM_INS 0x00000100 #define DBGITEM_SET 0x00000200 #define DBGITEM_AIG 0x00000400 #define DBGITEM_SETUP 0x00000800 #define DBGITEM_HIT 0x00001000 #define DBGITEM_NEXTGRP 0x00002000 #define DBGITEM_ADDITEM 0x00004000 #define DBG_LBSIZE 0x00008000 #define DBG_COTD 0x00010000 #define DBG_INITDLG 0x00020000 #define DBG_APG 0x00040000 #define DBGITEM_SELCHG 0x00080000 #define DBGITEM_UTV 0x00100000 #define DBG_MSR 0x00200000 #define DBGITEM_NEWICON 0x00400000 #define DBG_TVHT 0x00800000 #define DBGITEM_CREVERT 0x01000000 #define DBGITEM_REVERT 0x02000000 #define DBG_OEM_ITEM 0x04000000 #define DBG_SCID 0x08000000 #define DBG_KEYS 0x10000000 #define DBG_ASSERT 0x80000000 DEFINE_DBGVAR(0); CPSUIDBGBLK(extern LPSTR pTVOTName[]) #define ICON_SIZE_ANY 0 extern HINSTANCE hInstDLL; extern OPTTYPE OptTypeHdrPush; extern OPTPARAM OptParamHdrPush; static const TVDLGITEM TVDlgItem[] = { { 5, 0, IDD_3STATES_1 }, // 0 TVOT_2STATES { 5, 0, IDD_3STATES_1 }, // 1 TVOT_3STATES { 4, 0, IDD_TV_UDARROW }, // 2 TVOT_UDARROW { 3, 0, IDD_TV_TRACKBAR }, // 3 TVOT_TRACKBAR { 3, 0, IDD_TV_SB }, // 4 TVOT_SCROLLBAR { 1, 0, IDD_TV_LB }, // 5 TVOT_LISTBOX { 1, 0, IDD_TV_CB }, // 6 TVOT_COMBOBOX { 3, 0, IDD_TV_EDIT_EDIT }, // 7 TVOT_EDITBOX { 1, 0, IDD_TV_PUSH }, // 8 TVOT_PUSHBUTTON { 1, 0, IDD_TV_CHKBOX }, // 9 TVOT_CHKBOX { 1, 0, IDD_TV_EXTPUSH }, { 1, 0, IDD_TV_EXTCHKBOX } }; #define ITVGF_BPCL (ITVGF_BOLD | ITVGF_COLLAPSE) static const INTTVGRP IntTVGrpPaper[] = { { 1, DMPUB_HDR_PAPER }, { 2, DMPUB_FORMNAME }, { 2, DMPUB_ORIENTATION }, { 2, DMPUB_DEFSOURCE }, { 2, DMPUB_OUTPUTBIN }, { 2, DMPUB_MEDIATYPE }, { 2, DMPUB_COPIES_COLLATE }, { 2, DMPUB_DUPLEX }, { 2, DMPUB_PAGEORDER }, { 2, DMPUB_NUP }, { 0, DMPUB_HDR_TVROOT } }; static const INTTVGRP IntTVGrpGraphic[] = { { 1, DMPUB_HDR_GRAPHIC }, { 2, DMPUB_QUALITY }, { 2, DMPUB_PRINTQUALITY }, { 2 , DMPUB_COLOR }, { 2 | ITVGF_BOLD, DMPUB_HDR_ICM }, { 3, DMPUB_ICMMETHOD }, { 3, DMPUB_ICMINTENT }, { 2, DMPUB_SCALE }, { 2, DMPUB_DITHERTYPE }, { 2, DMPUB_TTOPTION }, { 0, DMPUB_HDR_TVROOT } }; static const WORD ChkBoxStrID[] = { IDS_CPSUI_FALSE, IDS_CPSUI_TRUE, IDS_CPSUI_NO, IDS_CPSUI_YES, IDS_CPSUI_OFF, IDS_CPSUI_ON, IDS_CPSUI_FALSE, 0, IDS_CPSUI_NO, 0, IDS_CPSUI_OFF, 0, IDS_CPSUI_NONE, 0 }; #define STVS_REINIT 0x0001 #define STVS_ACTIVE 0x0002 POPTITEM GetOptions( PTVWND pTVWnd, LPARAM lParam ) { TVLP tvlp; tvlp = GET_TVLP(lParam); if (tvlp.ItemIdx >= INTIDX_FIRST) { return(PIDX_INTOPTITEM(pTVWnd, tvlp.ItemIdx)); } else if (tvlp.ItemIdx < pTVWnd->ComPropSheetUI.cOptItem) { return(pTVWnd->ComPropSheetUI.pOptItem + tvlp.ItemIdx); } else { CPSUIERR(("ERROR: GetOptions(tvlp): Idx=%04lx, cName=%ld, Flags=%02lx", (DWORD)tvlp.ItemIdx, (DWORD)tvlp.cName, (DWORD)tvlp.Flags)); return(PIDX_INTOPTITEM(pTVWnd, INTIDX_TVROOT)); } } #if (DO_IN_PLACE == 0) VOID MoveStateRadios( HWND hDlg, PTVWND pTVWnd, POPTTYPE pOptType, WORD InitFlags ) /*++ Routine Description: Arguments: Return Value: Author: 02-Sep-1995 Sat 21:08:14 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hCtrl; UINT x; UINT CtrlID; UINT Count; UINT HideBits; TVOTSTATESINFO TSI; x = (InitFlags & INITCF_HAS_EXT) ? 0 : 1; if ((HideBits = (UINT)(_OT_FLAGS(pOptType) & OTINTF_STATES_HIDE_MASK)) || (pOptType->Type == TVOT_2STATES)) { TSI = pTVWnd->SI2[x]; if (!HideBits) { HideBits |= 0x04; } } else { TSI = pTVWnd->SI3[x]; } CPSUIDBG(DBG_MSR, ("!! %hs: TSI: Top=%d, Inc=%d, Hide=%02x", pTVOTName[pOptType->Type], TSI.Top, TSI.Inc, HideBits)); x = (UINT)pTVWnd->xCtrls; Count = 3; CtrlID = IDD_3STATES_1; while (Count--) { if (hCtrl = GetDlgItem(hDlg, CtrlID)) { if (HideBits & 0x01) { ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); CPSUIDBG(DBG_MSR, ("HIDE Radio Idx=%d (%d, %d)", 3-Count, x, TSI.Top)); } else { CPSUIDBG(DBG_MSR, ("SHOW Radio Idx=%d (%d, %d)", 3-Count, x, TSI.Top)); SetWindowPos(hCtrl, NULL, x, TSI.Top, 0, 0, SWP_NOSIZE | SWP_NOZORDER); TSI.Top += TSI.Inc; } } CtrlID += 2; HideBits >>= 1; } } #endif VOID SetOptHeader( HWND hDlg, PTVWND pTVWnd, POPTITEM pItem, BOOL HdrPush ) /*++ Routine Description: This function setup the string in the TREEVIEW page change item windows group box title. Arguments: Return Value: Author: 16-Oct-1995 Mon 19:23:36 created -by- Daniel Chou (danielc) Revision History: 20-Jul-1996 Sat 00:26:33 updated -by- Daniel Chou (danielc) Fixed the internationalize problem for compsition dynamic user data --*/ { POPTITEM pRootItem = PIDX_INTOPTITEM(pTVWnd, INTIDX_TVROOT); UINT IntFmtStrID; GSBUF_DEF(pItem, MAX_RES_STR_CHARS + 80); if (HdrPush) { // // Root Header item: XXX Document/Advance Document/Device Settings // Other Header Item: XXX Options if (pItem == pRootItem) { GSBUF_FLAGS |= GBF_PREFIX_OK | GBF_DUP_PREFIX; IntFmtStrID = (UINT)pRootItem->UserData; } else { IntFmtStrID = (UINT)IDS_INT_CPSUI_OPTIONS; } } else { IntFmtStrID = IDS_INT_CPSUI_CHANGE_SET; } GSBUF_COMPOSE(IntFmtStrID, pItem->pName, 0, 0); SetWindowText(GetDlgItem(hDlg, IDD_TV_OPTION), GSBUF_BUF); } VOID ChangeOptTypeDisplay( HWND hDlg, PTVWND pTVWnd, POPTTYPE pOldOptType, POPTTYPE pNewOptType, BOOL NewTypeUpdatePermission ) /*++ Routine Description: This function hide the old type and enable the new type's option header/icon depends on the NewTypeEnable flag Arguments: hDlg - Handle to the dialog box pTVWnd - Pointer to TVWND structure of our instance data pCurItem - Pointer to OPTITEM associate with NewType pOldOptType - Pointer to the OLD OPTTYPE pNewOptType - Pointer to the NEW OPTTYPE NewTypeUpdatePermission - TRUE if new type is not disabled Return Value: VOID Author: 21-Jun-1995 Wed 20:30:53 created -by- Daniel Chou (danielc) 31-Aug-1995 Thu 18:34:16 updated -by- Daniel Chou (danielc) Updated according to the usage of DlgCtrl.c Revision History: --*/ { HWND hCtrl; BOOL Enable; UINT OldType; UINT NewType; INT swMode; if ((pOldOptType != pNewOptType) && (pOldOptType) && ((OldType = (UINT)pOldOptType->Type) <= TVOT_LAST)) { TVDLGITEM tdi; #if DO_IN_PLACE CPSUIINT(("OldType=%ld, NewType=%ld, hWndEdit=%08lx:%08lx:%08lx", OldType, (pNewOptType) ? pNewOptType->Type : - 1, pTVWnd->hWndEdit[0], pTVWnd->hWndEdit[1], pTVWnd->hWndEdit[2])); switch (OldType) { case TVOT_2STATES: case TVOT_3STATES: case TVOT_LISTBOX: case TVOT_CHKBOX: OldType = TVOT_COMBOBOX; break; case TVOT_SCROLLBAR: case TVOT_TRACKBAR: #if 1 OldType = TVOT_UDARROW; #else if (pOldOptType->pOptParam[2].IconID <= 1) { OldType = TVOT_UDARROW; } #endif break; default: break; } pTVWnd->chWndEdit = 0; #endif CPSUIINT(("OldType=%ld, NewType=%ld", OldType, (pNewOptType) ? pNewOptType->Type : - 1)); tdi = TVDlgItem[OldType]; while (tdi.cItem--) { if (hCtrl = GetDlgItem(hDlg, tdi.BegID++)) { EnableWindow(hCtrl, FALSE); ShowWindow(hCtrl, SW_HIDE); CPSUIINT(("Disable/Hide hCtrl=%08lx (%ld)", hCtrl, tdi.BegID - 1)); } if (tdi.BegID == (IDD_TV_TRACKBAR + 1)) { tdi.BegID = IDD_TV_SB_LOW; } } } // // Display option header, icon if any // NewType = (UINT)((pNewOptType) ? pNewOptType->Type : TVOT_NONE); if (Enable = (BOOL)(NewType <= TVOT_LAST)) { swMode = SW_SHOW; if ((!NewTypeUpdatePermission) || (!(pTVWnd->Flags & TWF_CAN_UPDATE))) { Enable = FALSE; } } else { swMode = SW_HIDE; } ShowWindow(hCtrl = GetDlgItem(hDlg, IDD_TV_OPTION), swMode); EnableWindow(hCtrl, Enable); ShowWindow(GetDlgItem(hDlg, IDD_TV_ICON), swMode); // // We only show the hdr push icon if it is not disabled // #if 0 ShowWindow(GetDlgItem(hDlg, IDD_TV_HDR_PUSH_ICON), ((pNewOptType) && (IS_HDR_PUSH(pNewOptType)) && (!(pNewOptType->Flags & OPTTF_TYPE_DISABLED))) ? SW_SHOW : SW_HIDE); #endif CPSUIDBG(DBG_COTD, ("OldType=%ld, NewType=%ld, Enable=%ld, swMode=%ld", (LONG)OldType, (LONG)NewType, (DWORD)Enable, (DWORD)swMode)); } LRESULT CALLBACK MyEditWndProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ) /*++ Routine Description: This is the subclass WNDPROC for the numberical edit control, it check valid input for the number entered. Arguments: WNDPROC standard Return Value: INT (The original WNDPROC returned), if the entered keys are not valid then it return right away without processing Author: 20-Mar-1996 Wed 15:36:48 created -by- Daniel Chou (danielc) Revision History: --*/ { PTVWND pTVWnd; WNDPROC OldWndProc; if (OldWndProc = (WNDPROC)GetProp(hWnd, CPSUIPROP_WNDPROC)) { switch (Msg) { case WM_KEYDOWN: if (ChkEditKEYDOWN(hWnd, wParam)) { return(0); } break; case WM_DESTROY: SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LPARAM)OldWndProc); RemoveProp(hWnd, CPSUIPROP_WNDPROC); RemoveProp(hWnd, CPSUIPROP_PTVWND); break; default: break; } return(CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam)); } else { CPSUIERR(("MyEditWndProc: GetProc(%08lx) FAILED", hWnd)); return(0); } } VOID DrawPushFocusRect( HWND hWnd ) /*++ Routine Description: Arguments: Return Value: Author: 13-Aug-1998 Thu 11:21:49 created -by- Daniel Chou (danielc) Revision History: --*/ { if (GetFocus() == hWnd) { HDC hDC; RECT rc; GetClientRect(hWnd, &rc); hDC = GetWindowDC(hWnd); rc.left += 3; rc.top += 3; rc.right -= 3; rc.bottom -= 3; if (hDC) { DrawFocusRect(hDC, &rc); ReleaseDC(hWnd, hDC); } } } LRESULT CALLBACK PushWndProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ) /*++ Routine Description: This is the subclass WNDPROC for the numberical edit control, it check valid input for the number entered. Arguments: WNDPROC standard Return Value: INT (The original WNDPROC returned), if the entered keys are not valid then it return right away without processing Author: 20-Mar-1996 Wed 15:36:48 created -by- Daniel Chou (danielc) Revision History: --*/ { HDC hDC; PTVWND pTVWnd; WNDPROC OldWndProc; RECT rc; LRESULT Result; if (OldWndProc = (WNDPROC)GetProp(hWnd, CPSUIPROP_WNDPROC)) { switch (Msg) { case WM_KILLFOCUS: break; case WM_SETFOCUS: InvalidateRect(hWnd, NULL, FALSE); break; case WM_PAINT: case WM_NCPAINT: Result = CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam); DrawPushFocusRect(hWnd); return(Result); case WM_GETDLGCODE: return(DLGC_WANTARROWS); case WM_KEYDOWN: CPSUIDBG(DBG_KEYS, ("PushWndProc: WM_KEYDOWN, VKey=%ld", wParam)); if (ChkhWndEdit0KEYDOWN(hWnd, wParam)) { return(0); } break; case WM_DESTROY: SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LPARAM)OldWndProc); RemoveProp(hWnd, CPSUIPROP_WNDPROC); RemoveProp(hWnd, CPSUIPROP_PTVWND); break; default: break; } return(CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam)); } else { CPSUIERR(("PushWndProc: GetProc(%08lx) FAILED", hWnd)); return(0); } } LRESULT CALLBACK ExtWndProc( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ) /*++ Routine Description: This is the subclass WNDPROC for the numberical edit control, it check valid input for the number entered. Arguments: WNDPROC standard Return Value: INT (The original WNDPROC returned), if the entered keys are not valid then it return right away without processing Author: 20-Mar-1996 Wed 15:36:48 created -by- Daniel Chou (danielc) Revision History: --*/ { HDC hDC; PTVWND pTVWnd; WNDPROC OldWndProc; RECT rc; LRESULT Result; if (OldWndProc = (WNDPROC)GetProp(hWnd, CPSUIPROP_WNDPROC)) { switch (Msg) { case WM_KILLFOCUS: break; case WM_SETFOCUS: InvalidateRect(hWnd, NULL, FALSE); break; case WM_PAINT: case WM_NCPAINT: Result = CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam); if ((GetWindowLongPtr(hWnd, GWL_STYLE) & 0x0F) == 0) { DrawPushFocusRect(hWnd); } return(Result); case WM_GETDLGCODE: return(DLGC_WANTARROWS); case WM_KEYDOWN: CPSUIDBG(DBG_KEYS, ("ExtWndProc: WM_KEYDOWN, VKey=%ld", wParam)); switch (wParam) { case VK_LEFT: case VK_BACK: case VK_RIGHT: if (pTVWnd = (PTVWND)GetProp(hWnd, CPSUIPROP_PTVWND)) { switch (wParam) { case VK_LEFT: case VK_BACK: if (pTVWnd->hWndEdit[0]) { SetFocus(pTVWnd->hWndEdit[0]); return(0); } case VK_RIGHT: return(0); default: break; } } break; } break; case WM_DESTROY: SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LPARAM)OldWndProc); RemoveProp(hWnd, CPSUIPROP_WNDPROC); RemoveProp(hWnd, CPSUIPROP_PTVWND); break; default: break; } return(CallWindowProc(OldWndProc, hWnd, Msg, wParam, lParam)); } else { CPSUIERR(("MyCBWndProc: GetProc(%08lx) FAILED", hWnd)); return(0); } } VOID InitDlgCtrl( HWND hDlg, PTVWND pTVWnd ) /*++ Routine Description: Arguments: Return Value: Author: 05-Jul-1995 Wed 17:49:58 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = pTVWnd->hWndTV; HFONT hFont; HWND hCtrl; RECT rc; RECT rc2; DWORD dw; WORD tECB; WORD bECB; WORD tLB; WORD bLB; WORD cyUnit; WORD cyStates; LONG tOpt; LONG bOpt; LONG cx; LONG cy; UINT i; WORD InitItemIdx = 0xFFFE; ReCreateLBCB(hDlg, IDD_TV_LB, TRUE); dw = ReCreateLBCB(hDlg, IDD_TV_CB, FALSE); CreateTrackBar(hDlg, IDD_TV_TRACKBAR); CreateUDArrow(hDlg, IDD_TV_UDARROW_EDIT, IDD_TV_UDARROW, 0, 100, 50); #if DO_IN_PLACE CtrlIDrcWnd(hDlg, IDD_TV_UDARROW, &rc); CtrlIDrcWnd(hDlg, IDD_TV_UDARROW_EDIT, &rc2); pTVWnd->cxCBAdd = LOWORD(dw); pTVWnd->cxMaxUDEdit += LOWORD(dw); CtrlIDrcWnd(hDlg, IDD_TV_CHKBOX, &rc); pTVWnd->cxChkBoxAdd = (WORD)(rc.right - rc.left); pTVWnd->cxChkBoxAdd = (WORD)GetSystemMetrics(SM_CXSMICON); CPSUIINT(("cxCBAdd = %ld, cxChkBoxAdd=%ld", pTVWnd->cxCBAdd, pTVWnd->cxChkBoxAdd)); if (hCtrl = GetDlgItem(hDlg, IDD_TV_EDIT_EDIT)) { SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetProp(hCtrl, CPSUIPROP_PTVWND, (HANDLE)pTVWnd); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)MyEditWndProc); } if (hCtrl = GetDlgItem(hDlg, IDD_TV_PUSH)) { SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetProp(hCtrl, CPSUIPROP_PTVWND, (HANDLE)pTVWnd); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)PushWndProc); } hFont = pTVWnd->hTVFont[0]; #endif for (i = 0; i < COUNT_ARRAY(TVDlgItem); i++) { TVDLGITEM tdi; HWND hCtrl; tdi = TVDlgItem[i]; while (tdi.cItem--) { if (hCtrl = GetDlgItem(hDlg, tdi.BegID++)) { ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); SETCTRLDATA(hCtrl, CTRLS_TV_STATIC, 0); #if DO_IN_PLACE SetParent(hCtrl, hWndTV); SendMessage(hCtrl, WM_SETFONT, (WPARAM)hFont, 0); SetWindowLongPtr(hCtrl, GWL_EXSTYLE, GetWindowLongPtr(hCtrl, GWL_EXSTYLE) | WS_EX_CONTEXTHELP); #endif if (tdi.BegID == (IDD_TV_TRACKBAR + 1)) { tdi.BegID = IDD_TV_SB_LOW; } } } } // // Set MSAA name label as a child of treeview dialog // if (hCtrl = GetDlgItem(hDlg, IDD_TV_MSAA_NAME)) { SetParent(hCtrl, hWndTV); } // // Figure how to expand/shrink the listbox in the treeview page, the // maximum for non ExtChkBox/ExtPush is at bottom of Extended control // otherwise the maximu is at top of Extended control - space between // bottom of extended control and option header bottom // #if DO_IN_PLACE hCtrl = GetDlgItem(hWndTV, IDD_TV_EXTPUSH); #else hCtrl = GetDlgItem(hDlg, IDD_TV_EXTPUSH); #endif ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetProp(hCtrl, CPSUIPROP_PTVWND, (HANDLE)pTVWnd); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)ExtWndProc); #if DO_IN_PLACE hCtrl = CtrlIDrcWnd(hWndTV, IDD_TV_EXTCHKBOX, &rc); #else hCtrl = CtrlIDrcWnd(hDlg, IDD_TV_EXTCHKBOX, &rc); #endif ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); SETCTRLDATA(hCtrl, CTRLS_TV_STATIC, 0); pTVWnd->yECB = tECB = (WORD)rc.top; bECB = (WORD)rc.bottom; #if DO_IN_PLACE SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetProp(hCtrl, CPSUIPROP_PTVWND, (HANDLE)pTVWnd); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)ExtWndProc); CtrlIDrcWnd(hWndTV, IDD_TV_LB, &rc); #else CtrlIDrcWnd(hDlg, IDD_TV_LB, &rc); #endif pTVWnd->xCtrls = (WORD)rc.left; pTVWnd->tLB = tLB = (WORD)rc.top; bLB = (WORD)rc.bottom; hCtrl = CtrlIDrcWnd(hDlg, IDD_TV_OPTION, &rc); ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, TRUE); SETCTRLDATA(hCtrl, CTRLS_TV_STATIC, 0); pTVWnd->yLB[0] = (WORD)(tECB - (rc.bottom - bECB) - tLB); pTVWnd->yLB[1] = bECB - tLB; tOpt = tLB; bOpt = tECB; CPSUIDBG(DBG_INITDLG, ("!! yLB=(%ld / %ld) !!", pTVWnd->yLB[0], pTVWnd->yLB[1])); // // Figure how to move 2 states, and 3 states, basically this is range // in the space between top and bottom of options header // #if DO_IN_PLACE CtrlIDrcWnd(hWndTV, IDD_3STATES_1, &rc); #else CtrlIDrcWnd(hDlg, IDD_3STATES_1, &rc); #endif cyStates = (WORD)(rc.bottom - rc.top); // // For 2/3 states, there is top, increment, one with extended and one not // cy = (LONG)(bLB - tLB); cyUnit = (WORD)((cy - (cyStates * 2) + 1) / 3); pTVWnd->SI2[0].Top = tLB + (WORD)cyUnit; pTVWnd->SI2[0].Inc = (WORD)(cyStates + cyUnit); cyUnit = (WORD)((cy - (cyStates * 3) + 2) / 4); pTVWnd->SI3[0].Top = tLB + (WORD)cyUnit; pTVWnd->SI3[0].Inc = (WORD)(cyStates + cyUnit); cy = (LONG)(bOpt - tOpt); cyUnit = (WORD)((cy - (cyStates * 2) + 1) / 3); pTVWnd->SI2[1].Top = (WORD)tOpt + (WORD)cyUnit; pTVWnd->SI2[1].Inc = (WORD)(cyStates + cyUnit); cyUnit = (WORD)((cy - (cyStates * 3) + 2) / 4); pTVWnd->SI3[1].Top = (WORD)tOpt + (WORD)cyUnit; pTVWnd->SI3[1].Inc = (WORD)(cyStates + cyUnit); CPSUIINT(("SI2[0]=%d, %d, SI2[1]=%d, %d, SI3[0]=%d, %d, SI3[1]=%d, %d", pTVWnd->SI2[0].Top, pTVWnd->SI2[0].Inc, pTVWnd->SI2[1].Top, pTVWnd->SI2[1].Inc, pTVWnd->SI3[0].Top, pTVWnd->SI3[0].Inc, pTVWnd->SI3[1].Top, pTVWnd->SI3[1].Inc)); // // Change the static rectangle to the static ICON style and how big the // icon will stretch to // hCtrl = CtrlIDrcWnd(hDlg, IDD_TV_ICON, &rc); dw = (DWORD)GetWindowLongPtr(hCtrl, GWL_STYLE); dw &= ~SS_TYPEMASK; dw |= (SS_ICON | SS_CENTERIMAGE); SetWindowLongPtr(hCtrl, GWL_STYLE, dw); ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, TRUE); SETCTRLDATA(hCtrl, CTRLS_TV_STATIC, 0); // // We want to make sure that the cx/cy TVICON is the same size, if not // then we will correct it and adjust it to the right size // #if ICON_SIZE_ANY if ((cx = rc.right - rc.left) != (cy = rc.bottom - rc.top)) { CPSUIINT(("\nORIGINAL TVIcon=(%ld, %ld) %ld x %ld", rc.left, rc.top, cx, cy)); cy = cx; } #else cx = cy = 32; #endif rc.left = rc.left + ((rc.right - rc.left - cx + 1) / 2); rc.top = (LONG)(tOpt + ((bOpt - tOpt - cy + 1) / 2)); SetWindowPos(hCtrl, NULL, rc.left, rc.top, cx, cy, SWP_NOZORDER); CPSUIINT(("\nCHANGED TVIcon=(%ld, %ld) %ld x %ld", rc.left, rc.top, cx, cy)); pTVWnd->cxcyTVIcon = (WORD)cx; CPSUIDBG(DBG_CTVWND, ("\nIDD_TV_ICON Style=%08lx", dw)); // // now check it out ECB icon // hCtrl = CtrlIDrcWnd(hDlg, IDD_TV_ECB_ICON, &rc); dw = (DWORD)GetWindowLongPtr(hCtrl = GetDlgItem(hDlg, IDD_TV_ECB_ICON), GWL_STYLE); dw &= ~SS_TYPEMASK; dw |= (SS_ICON | SS_CENTERIMAGE); SetWindowLongPtr(hCtrl, GWL_STYLE, dw); // // We want to make sure that the cx/cy ECBICON is the same size, if not // then we will correct it and adjust it to the right size // if ((cx = rc.right - rc.left) != (cy = rc.bottom - rc.top)) { CPSUIINT(("\nORIGINAL ECBIcon=(%ld, %ld) %ld x %ld", rc.left, rc.top, cx, cy)); rc.right = rc.left + (cx = cy); SetWindowPos(hCtrl, NULL, rc.left, rc.top, cx, cy, SWP_NOZORDER); CPSUIINT(("\nCHANGED ECBIcon=(%ld, %ld) %ld x %ld", rc.left, rc.top, cx, cy)); } pTVWnd->cxcyECBIcon = (WORD)cx; CPSUIDBG(DBG_CTVWND, ("\nTVIcon=%ld x %ld, ECBIcon=%ld x %ld", (DWORD)pTVWnd->cxcyTVIcon, (DWORD)pTVWnd->cxcyTVIcon, (DWORD)pTVWnd->cxcyECBIcon, (DWORD)pTVWnd->cxcyECBIcon)); } HTREEITEM SelectFirstVisibleOptItem( PTVWND pTVWnd, HTREEITEM hItem ) /*++ Routine Description: Arguments: Return Value: Author: 21-Sep-1995 Thu 14:31:01 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = pTVWnd->hWndTV; // // Do all the siblings and for each calling the child to do their work // while (hItem) { POPTITEM pItem; TV_ITEM tvi; tvi.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_PARAM | TVIF_STATE; tvi.hItem = hItem; TreeView_GetItem(hWndTV, &tvi); // // Now check if we can do it // if ((pItem = GetOptions(pTVWnd, tvi.lParam)) && (pItem->pOptType) && (!IS_HDR_PUSH(pItem->pOptType)) && (pItem->pOptType->Type <= TVOT_LAST)) { TreeView_SelectItem(hWndTV, hItem); return(hItem); } if ((tvi.cChildren) && (tvi.state & TVIS_EXPANDED) && (hItem = TreeView_GetChild(hWndTV, hItem)) && (hItem = SelectFirstVisibleOptItem(pTVWnd, hItem))) { return(hItem); } hItem = TreeView_GetNextSibling(hWndTV, hItem); } return(hItem); } UINT CountRevertOptItem( PTVWND pTVWnd, POPTITEM pOptItem, HTREEITEM hItem, DWORD Flags ) /*++ Routine Description: Arguments: Return Value: Author: 21-Sep-1995 Thu 14:31:01 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = pTVWnd->hWndTV; POPTITEM pLastItem; UINT cRevert = 0; NM_TREEVIEW NMtv; // // Do all the siblings and for each calling the child to do their work // if ((hWndTV) && (hItem)) { pOptItem = pLastItem = NULL; } else { Flags |= CROIF_DO_SIBLING; hItem = (HTREEITEM)1; if (!pOptItem) { pOptItem = pTVWnd->ComPropSheetUI.pOptItem; pLastItem = pTVWnd->pLastItem; } else { pLastItem = pOptItem; } } while (hItem) { POPTITEM pItem; PDEVHTADJDATA pDevHTAdjData; POPTTYPE pOptType; POPTPARAM pOptParam; TV_ITEM tvi; UINT cAdd = 0; if (pOptItem) { pItem = pOptItem; } else { tvi.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_PARAM | TVIF_STATE; tvi.hItem = hItem; TreeView_GetItem(hWndTV, &tvi); pItem = GetOptions(pTVWnd, tvi.lParam); } // // Now check if we can do it // if ((pItem) && ((pItem->Flags & OPTIF_CHANGEONCE) || (Flags & CROIF_REVERT_DEF2)) && (pOptType = pItem->pOptType)) { LPBYTE pDefSelMem; LPVOID pDefSel; LPVOID pvAlloc; DWORD DefOPTIF; pvAlloc = pDefSel = (LPVOID)(pDefSelMem = (LPBYTE)_OI_PDEFSEL(pItem)); if (Flags & CROIF_REVERT_DEF2) { DefOPTIF = (DWORD)_OI_DEF_OPTIF2(pItem); pDefSelMem += _OI_CBPDEFSEL(pItem); pDefSel = _OI_PDEFSEL2(pItem); } else { DefOPTIF = (DWORD)_OI_DEF_OPTIF(pItem); } switch (pOptType->Type) { case TVOT_EDITBOX: if (!pvAlloc) { CPSUIASSERT(0, "CountRevertOptItem(EDITBOX:pvAlloc=NULL)", pvAlloc, 0); break; } if (pTVWnd->Flags & TWF_ANSI_CALL) { CPSUIINT(("pEdit=%hs, pDefEdit=%hs", pItem->pSel, pDefSel)); if (lstrcmpA((LPSTR)(LONG_PTR)pItem->Sel, (LPSTR)pDefSelMem)) { cAdd = 1; if (Flags & CROIF_REVERT) { lstrcpyA((LPSTR)pItem->pSel, (LPSTR)pDefSelMem); } } } else { CPSUIINT(("pEdit=%s, pDefEdit=%s", pItem->pSel, pDefSel)); if (lstrcmp(pItem->pSel, (LPWSTR)pDefSelMem)) { cAdd = 1; if (Flags & CROIF_REVERT) { lstrcpy((LPWSTR)pItem->pSel, (LPWSTR)pDefSelMem); } } } break; case TVOT_PUSHBUTTON: pOptParam = pOptType->pOptParam; switch (pOptParam->Style) { case PUSHBUTTON_TYPE_HTSETUP: if (!pvAlloc) { CPSUIASSERT(0, "CountRevertOptItem(HTSETUP:pvAlloc=NULL)", pvAlloc, 0); break; } pDevHTAdjData = (PDEVHTADJDATA)(pOptParam->pData); if (memcmp(pDefSelMem, pDevHTAdjData->pAdjHTInfo, sizeof(DEVHTINFO))) { cAdd = 1; if (Flags & CROIF_REVERT) { CopyMemory(pDevHTAdjData->pAdjHTInfo, pDefSelMem, sizeof(DEVHTINFO)); } } break; case PUSHBUTTON_TYPE_HTCLRADJ: if (!pvAlloc) { CPSUIASSERT(0, "CountRevertOptItem(HTCLRADJ:pvAlloc=NULL)", pvAlloc, 0); break; } if (memcmp(pDefSelMem, pOptParam->pData, sizeof(COLORADJUSTMENT))) { cAdd = 1; if (Flags & CROIF_REVERT) { CopyMemory(pOptParam->pData, pDefSelMem, sizeof(COLORADJUSTMENT)); } } break; default: break; } break; default: if (pItem->pSel != (LPVOID)pDefSel) { cAdd = 1; if (Flags & CROIF_REVERT) { pItem->pSel = pDefSel; } } break; } if ((pItem->pExtChkBox) && (!(pItem->Flags & OPTIF_EXT_IS_EXTPUSH)) && ((pItem->Flags & OPTIF_ECB_MASK) != (DefOPTIF & OPTIF_ECB_MASK))) { cAdd = 1; if (Flags & CROIF_REVERT) { pItem->Flags &= ~OPTIF_ECB_MASK; pItem->Flags |= (DWORD)(DefOPTIF & OPTIF_ECB_MASK); } } if (cAdd) { if (Flags & CROIF_REVERT) { pItem->Flags |= OPTIF_CHANGED; // // Call the callback function if there is one, and update the current // selected item after changing the content // DoCallBack(pTVWnd->hDlgTV, pTVWnd, pItem, pItem->pSel, NULL, NULL, 0, CPSUICB_REASON_SEL_CHANGED); // // Refresh the current selected item data, otherwise the data may // not be consistent // NMtv.itemNew.hItem = TreeView_GetSelection(pTVWnd->hWndTV); NMtv.itemNew.mask = TVIF_HANDLE | TVIF_PARAM; if (TreeView_GetItem(pTVWnd->hWndTV, &(NMtv.itemNew))) { NMtv.itemOld = NMtv.itemNew; SetupTVSelect(pTVWnd->hDlgTV, &NMtv, STVS_REINIT); } } CPSUIOPTITEM(DBGITEM_CREVERT, pTVWnd, "CountRevertOptItem", 0, pItem); } cRevert += cAdd; } if (pOptItem) { if (++pOptItem > pLastItem) { hItem = NULL; } else { ++(ULONG_PTR)hItem; } } else { if (tvi.cChildren) { cRevert += CountRevertOptItem(pTVWnd, NULL, TreeView_GetChild(hWndTV, hItem), Flags | CROIF_DO_SIBLING); } hItem = (Flags & CROIF_DO_SIBLING) ? TreeView_GetNextSibling(hWndTV, hItem) : NULL; } } CPSUIDBG(DBG_CTVWND, ("hWndTV=%08lx, hItem=%08lx, pOptItem=%08lx, cRevert=%u", hWndTV, hItem, pOptItem, cRevert)); return(cRevert); } CPSUICALLBACK InternalRevertDef2( PCPSUICBPARAM pCBParam ) /*++ Routine Description: Arguments: Return Value: Author: 21-Sep-1995 Thu 10:50:19 created -by- Daniel Chou (danielc) Revision History: --*/ { PTVWND pTVWnd; POPTITEM pItem; UINT cRevert; CPSUIINT(("INTERNAL CALLBACK: GOT Internal RevertOptItem() PUSH")); pTVWnd = GET_PTVWND(pCBParam->hDlg); pItem = pCBParam->pCurItem; CPSUIOPTITEM(DBGITEM_REVERT, pTVWnd, "InternalRevertOptItem", 2, pItem); cRevert = CountRevertOptItem(pTVWnd, NULL, NULL, CROIF_REVERT | CROIF_REVERT_DEF2); // // Now is the time to hide the push button // return((cRevert) ? CPSUICB_ACTION_OPTIF_CHANGED : CPSUICB_ACTION_NONE); } CPSUICALLBACK InternalRevertOptItem( PCPSUICBPARAM pCBParam ) /*++ Routine Description: Arguments: Return Value: Author: 21-Sep-1995 Thu 10:50:19 created -by- Daniel Chou (danielc) Revision History: --*/ { PTVWND pTVWnd; POPTITEM pItem; UINT cRevert; CPSUIINT(("INTERNAL CALLBACK: GOT Internal RevertOptItem() PUSH")); pTVWnd = GET_PTVWND(pCBParam->hDlg); pItem = pCBParam->pCurItem; CPSUIOPTITEM(DBGITEM_REVERT, pTVWnd, "InternalRevertOptItem", 2, pItem); cRevert = CountRevertOptItem(pTVWnd, pItem, _OI_HITEM(pItem), CROIF_REVERT); // // Now is the time to hide the push button // #if DO_IN_PLACE return((cRevert) ? CPSUICB_ACTION_OPTIF_CHANGED : CPSUICB_ACTION_NONE); #else if (cRevert) { if ((pItem >= pTVWnd->ComPropSheetUI.pOptItem) && (pItem <= pTVWnd->pLastItem)) { pItem->Flags |= OPTIF_CHANGED; } else { UpdateTreeViewItem(pCBParam->hDlg, pTVWnd, pItem, TRUE); } return(CPSUICB_ACTION_OPTIF_CHANGED); } else { return(CPSUICB_ACTION_NONE); } #endif } BOOL SetTVItemImage( PTVWND pTVWnd, TV_DISPINFO *ptvdi ) /*++ Routine Description: This function either insert a item to the tree or reset the content of the tree item Arguments: pTVWnd - Pointer to the TVWND for common UI instance data ptvi - pointer to TV_ITEM strucuture. Return Value: BOOLEAN Author: 06-Jul-1995 Thu 19:38:51 created -by- Daniel Chou (danielc) 31-Aug-1995 Thu 12:03:32 updated -by- Daniel Chou (danielc) Updated so it will not take pStrName anymore and it will also insert the item at this function Revision History: --*/ { TV_ITEM *ptvi = &(ptvdi->item); if (ptvi->mask & (TVIF_IMAGE | TVIF_SELECTEDIMAGE)) { POPTTYPE pOptType; POPTITEM pItem; ULONG_PTR IconResID; DWORD IntIconID; pItem = GetOptions(pTVWnd, ptvi->lParam); if (IS_HDR_PUSH(pOptType = GET_POPTTYPE(pItem))) { IconResID = GETSELICONID(pItem); IntIconID = IDI_CPSUI_GENERIC_OPTION; } else { PEXTCHKBOX pECB; POPTPARAM pOptParam = pOptType->pOptParam; switch (pOptType->Type) { case TVOT_COMBOBOX: case TVOT_LISTBOX: if ((DWORD)pItem->Sel >= (DWORD)pOptType->Count) { pOptParam = &pTVWnd->OptParamNone; break; } case TVOT_2STATES: case TVOT_3STATES: pOptParam += (DWORD)pItem->Sel; break; case TVOT_CHKBOX: case TVOT_TRACKBAR: case TVOT_SCROLLBAR: case TVOT_UDARROW: case TVOT_PUSHBUTTON: case TVOT_EDITBOX: break; } IconResID = GET_ICONID(pOptParam, OPTPF_ICONID_AS_HICON); IntIconID = IDI_CPSUI_GENERIC_ITEM; } ptvi->iSelectedImage = ptvi->iImage = (INT)GetIcon16Idx(pTVWnd, _OI_HINST(pItem), IconResID, IntIconID); ptvi->hItem = _OI_HITEM(pItem); ptvi->mask = (TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_HANDLE); SendMessage(pTVWnd->hWndTV, TVM_SETITEM, 0, (LPARAM)ptvi); CPSUIOPTITEM(DBGITEM_NEWICON, pTVWnd, "SetTVItemImage", 0, pItem); } return(TRUE); } VOID SetTVItemState( PTVWND pTVWnd, TV_INSERTSTRUCT *ptvins, POPTITEM pCurItem ) /*++ Routine Description: This function either insert a item to the tree or reset the content of the tree item Arguments: pTVWnd - Pointer to the TVWND for common UI instance data ptvins - pointer to TV_INSERTSTRUCT strucuture, if it is not NULL then this item will be inserted to the tree pCurItem - Pointer to the current OPTITEM Return Value: WORD - Icon resource ID Author: 06-Jul-1995 Thu 19:38:51 created -by- Daniel Chou (danielc) 31-Aug-1995 Thu 12:03:32 updated -by- Daniel Chou (danielc) Updated so it will not take pStrName anymore and it will also insert the item at this function 20-Jul-1996 Sat 00:26:33 updated -by- Daniel Chou (danielc) Fixed the internationalize problem for compsition dynamic user data Revision History: --*/ { POPTTYPE pOptType; TV_INSERTSTRUCT tvins; TVLP tvlp; ULONG_PTR IconResID; DWORD IntIconID; DWORD Flags; GSBUF_DEF(pCurItem, MAX_RES_STR_CHARS * 2); if (ptvins) { tvins = *ptvins; tvins.item.mask |= TVIF_TEXT | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE; } else { CPSUIASSERT(0, "SetTVItemState, NULL hItem", _OI_HITEM(pCurItem),0); if (!(tvins.item.hItem = _OI_HITEM(pCurItem))) { CPSUIOPTITEM(DBG_ASSERT, pTVWnd, "SetTVItemState(NULL)", 1, pCurItem); return; } tvins.item.state = tvins.item.stateMask = 0; tvins.item.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_STATE; } if ((pCurItem >= pTVWnd->ComPropSheetUI.pOptItem) && (pCurItem <= pTVWnd->pLastItem)) { tvlp.ItemIdx = (WORD)(pCurItem - pTVWnd->ComPropSheetUI.pOptItem); } else if ((pCurItem >= PBEG_INTOPTITEM(pTVWnd)) && (pCurItem <= PEND_INTOPTITEM(pTVWnd))) { tvlp.ItemIdx = (WORD)IIDX_INTOPTITEM(pTVWnd, pCurItem); } else { CPSUIERR(("ERROR: SetupTVItemState(Invalid pOptItem=%08lx)", pCurItem)); tvlp.ItemIdx = INTIDX_TVROOT; } tvins.item.pszText = GSBUF_BUF; // // Check if we need to overlay CPSUI provided icons // tvlp.Flags = ((Flags = pCurItem->Flags) & OPTIF_OVERLAY_WARNING_ICON) ? TVLPF_WARNING : 0; if (Flags & (OPTIF_OVERLAY_STOP_ICON | OPTIF_HIDE)) { tvlp.Flags |= TVLPF_STOP; } if (Flags & OPTIF_OVERLAY_NO_ICON) { tvlp.Flags |= TVLPF_NO; } if (IS_HDR_PUSH(pOptType = GET_POPTTYPE(pCurItem))) { POPTITEM pRootItem = PIDX_INTOPTITEM(pTVWnd, INTIDX_TVROOT); if (pCurItem == pRootItem) { GSBUF_FLAGS |= GBF_PREFIX_OK; GSBUF_COMPOSE(LODWORD(pCurItem->UserData), pCurItem->pName, 0, 0); } else if (pCurItem == PIDX_INTOPTITEM(pTVWnd, INTIDX_OPTIONS)) { // // Make it 'Document Options' here // GSBUF_GETINTSTR(IDS_INT_CPSUI_OPTIONS); } else { GSBUF_GETSTR(pCurItem->pName); } tvlp.cName = (BYTE)(GSBUF_COUNT); CPSUIINT(("HeaderItem (%ld): '%ws'", tvlp.cName, GSBUF_BUF)); IconResID = GETSELICONID(pCurItem); IntIconID = IDI_CPSUI_GENERIC_OPTION; #if DO_IN_PLACE if ((!IconResID) || (!GetIcon16Idx(pTVWnd, _OI_HINST(pCurItem), IconResID, IDI_CPSUI_EMPTY))) { tvins.item.mask &= ~(TVIF_IMAGE | TVIF_SELECTEDIMAGE); tvlp.Flags |= TVLPF_EMPTYICON; } #endif } else { POPTPARAM pOptParam; PEXTCHKBOX pECB; LPTSTR pEndText = NULL; UINT Idx; BOOL RealECBChecked; BOOL EndTextAddSpace; #if DO_IN_PLACE tvins.item.mask &= ~(TVIF_IMAGE | TVIF_SELECTEDIMAGE); tvlp.Flags |= TVLPF_EMPTYICON; #endif GSBUF_GETSTR(pCurItem->pName); pOptParam = pOptType->pOptParam; if (RealECBChecked = REAL_ECB_CHECKED(pCurItem, pECB)) { if (pECB->Flags & ECBF_OVERLAY_ECBICON_IF_CHECKED) { tvlp.Flags |= TVLPF_ECBICON; if (pECB->Flags & ECBF_OVERLAY_WARNING_ICON) { tvlp.Flags |= TVLPF_WARNING; } if (pECB->Flags & ECBF_OVERLAY_STOP_ICON) { tvlp.Flags |= TVLPF_STOP; } if (pECB->Flags & ECBF_OVERLAY_NO_ICON) { tvlp.Flags |= TVLPF_NO; } } } if ((RealECBChecked) && ((!(Flags & OPTIF_EXT_DISABLED)) || (!(pECB->Flags & ECBF_CHECKNAME_ONLY_ENABLED)))) { NULL; } else { pECB = NULL; } // // PUSHBUTTON: PusName... // if (pOptType->Type == TVOT_PUSHBUTTON) { if (!(pOptType->Style & OTS_PUSH_NO_DOT_DOT_DOT)) { GSBUF_GETSTR(IDS_CPSUI_MORE); } } else { GSBUF_GETSTR(IDS_CPSUI_COLON_SEP); } tvlp.cName = (BYTE)(GSBUF_COUNT); CPSUIINT(("TreeviewItem (%ld): '%ws'", tvlp.cName, GSBUF_BUF)); if ((pECB) && (pECB->Flags & ECBF_CHECKNAME_ONLY)){ GSBUF_GETSTR(pECB->pCheckedName); pECB = NULL; } else { if ((pECB) && (pECB->Flags & ECBF_CHECKNAME_AT_FRONT)) { // // pName: // GSBUF_GETSTR(pECB->pCheckedName); GSBUF_GETSTR(pECB->pSeparator); pECB = NULL; } EndTextAddSpace = (!(pOptType->Flags & OPTTF_NOSPACE_BEFORE_POSTFIX)); switch (pOptType->Type) { case TVOT_CHKBOX: Idx = (UINT)(pCurItem->Sel + (pOptParam->Style << 1)); if (!(pEndText = (LPTSTR)ChkBoxStrID[Idx])) { pEndText = pOptParam->pData; } GSBUF_GETSTR(pEndText); pEndText = NULL; break; case TVOT_COMBOBOX: case TVOT_LISTBOX: if ((DWORD)pCurItem->Sel >= (DWORD)pOptType->Count) { pOptParam = &pTVWnd->OptParamNone; } else { pOptParam += (DWORD)pCurItem->Sel; } GSBUF_GETSTR(pOptParam->pData); break; case TVOT_2STATES: case TVOT_3STATES: pOptParam += pCurItem->Sel; GSBUF_GETSTR(pOptParam->pData); break; case TVOT_TRACKBAR: case TVOT_SCROLLBAR: GSBUF_ADDNUM(pCurItem->Sel * (LONG)pOptParam[2].IconID, TRUE); pEndText = pOptParam->pData; break; case TVOT_UDARROW: GSBUF_ADDNUM(pCurItem->Sel, TRUE); pEndText = pOptParam->pData; break; case TVOT_PUSHBUTTON: Flags &= ~OPTIF_CHANGEONCE; break; case TVOT_EDITBOX: GSBUF_GETSTR(pCurItem->pSel); pEndText = pOptParam->pData; break; } if (pEndText) { LPWSTR pwBuf; if (EndTextAddSpace) { GSBUF_ADD_SPACE(1); } pwBuf = GSBUF_PBUF; GSBUF_GETSTR(pEndText); if ((GSBUF_PBUF == pwBuf) && (EndTextAddSpace)) { GSBUF_SUB_SIZE(1); } } } if (pECB) { GSBUF_GETSTR(pECB->pSeparator); GSBUF_GETSTR(pECB->pCheckedName); } IconResID = GET_ICONID(pOptParam, OPTPF_ICONID_AS_HICON); IntIconID = IDI_CPSUI_GENERIC_ITEM; if (pOptParam->Flags & OPTPF_OVERLAY_WARNING_ICON) { tvlp.Flags |= TVLPF_WARNING; } if (pOptParam->Flags & OPTPF_OVERLAY_STOP_ICON) { tvlp.Flags |= TVLPF_STOP; } if (pOptParam->Flags & OPTPF_OVERLAY_NO_ICON) { tvlp.Flags |= TVLPF_NO; } } if (ptvins) { tvins.item.iImage = tvins.item.iSelectedImage = -1; } else { tvins.item.iSelectedImage = tvins.item.iImage = (INT)GetIcon16Idx(pTVWnd, _OI_HINST(pCurItem), IconResID, IntIconID); } tvins.item.cchTextMax = GSBUF_COUNT; #if DO_IN_PLACE if (tvins.item.mask & (TVIF_IMAGE | TVIF_SELECTEDIMAGE)) { tvins.item.state |= TVIS_OVERLAYMASK | TVIS_STATEIMAGEMASK; } else { tvins.item.state &= ~(TVIS_OVERLAYMASK | TVIS_STATEIMAGEMASK); } #endif tvins.item.stateMask |= TVIS_OVERLAYMASK | TVIS_STATEIMAGEMASK; // // Change the overlay mask // if ((!(pTVWnd->Flags & TWF_CAN_UPDATE)) || (pCurItem->Flags & OPTIF_DISABLED)) { tvlp.Flags |= TVLPF_DISABLED; } if (Flags & OPTIF_CHANGEONCE) { tvlp.Flags |= TVLPF_CHANGEONCE; } tvins.item.lParam = TVLP2LP(tvlp); if (ptvins) { _OI_HITEM(pCurItem) = TreeView_InsertItem(pTVWnd->hWndTV, &tvins); CPSUIOPTITEM(DBGITEM_INS, pTVWnd, "SetTVItemState(INSERT)", 1, pCurItem); } else { if (_OI_INTFLAGS(pCurItem) & OIDF_ZERO_SEL_LEN) { UINT cSpace; // // Do not update string while is selected // if (pTVWnd->cxItem > pTVWnd->cxMaxItem) { cSpace = (UINT)(((DWORD)pTVWnd->cxEdit + (DWORD)pTVWnd->cxSpace - 1) / (DWORD)pTVWnd->cxSpace) + 1; GSBUF_PBUF = GSBUF_BUF + tvlp.cName; GSBUF_ADD_SPACE(cSpace); CPSUIINT(("!! ZERO_SEL_LEN Item: %ld GREATER Than %ld, cName=%ld, cSpace=%ld", pTVWnd->cxItem, pTVWnd->cxMaxItem, tvlp.cName, cSpace)); pTVWnd->cxMaxItem = pTVWnd->cxItem; TreeView_SetItem(pTVWnd->hWndTV, &(tvins.item)); } else { CPSUIINT(("!! ZERO_SEL_LEN Item: %ld Less than %ld, cName=%ld", pTVWnd->cxItem, pTVWnd->cxMaxItem, tvlp.cName)); } GSBUF_BUF[tvlp.cName] = L'\0'; CPSUIINT(("!! ZERO_SEL_LEN Item pszText='%ws'", tvins.item.pszText)); } TreeView_SetItem(pTVWnd->hWndTV, &(tvins.item)); CPSUIOPTITEM(DBGITEM_SET, pTVWnd, "SetTVItemState(SET)", 1, pCurItem); } } POPTITEM SetupTVSelect( HWND hDlg, NM_TREEVIEW *pNMTV, DWORD STVSMode ) /*++ Routine Description: Arguments: Return Value: Author: 21-Jun-1995 Wed 15:14:54 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hParent; HWND hCtrl; HWND hWndTV; PTVWND pTVWnd = GET_PTVWND(hDlg); POPTTYPE pOldOptType; POPTITEM pOldItem; POPTTYPE pOptType; POPTITEM pNewItem; POPTPARAM pOptParam; TVLP tvlp; WORD InitFlags; WORD InitItemIdx; WORD IconMode = 0; BYTE NewType; BOOL CanUpdate; hWndTV = pTVWnd->hWndTV; pNewItem = GetOptions(pTVWnd, pNMTV->itemNew.lParam); tvlp = GET_TVLP(pNMTV->itemNew.lParam); InitItemIdx = tvlp.ItemIdx; if (!pTVWnd->pCurTVItem) { pOldItem = NULL; pOldOptType = NULL; } else { pOldItem = GetOptions(pTVWnd, pNMTV->itemOld.lParam); pOldOptType = GET_POPTTYPE(pOldItem); } CPSUIOPTITEM(DBGITEM_SETUP, pTVWnd, "Setup OLD", 0, pOldItem); CPSUIOPTITEM(DBGITEM_SETUP, pTVWnd, "Setup New", 0, pNewItem); pOptType = GET_POPTTYPE(pNewItem); #if DO_IN_PLACE hParent = hWndTV; switch (NewType = pOptType->Type) { case TVOT_2STATES: case TVOT_3STATES: case TVOT_LISTBOX: NewType = TVOT_COMBOBOX; break; case TVOT_SCROLLBAR: case TVOT_TRACKBAR: #if 1 NewType = TVOT_UDARROW; #else if (pOptType->pOptParam[2].IconID <= 1) { NewType = TVOT_UDARROW; } #endif break; default: break; } #else hParent = hDlg; NewType = pOptType->Type; #endif // // If we have push button, and it said we always can call it then update // is true // if ((STVSMode & STVS_ACTIVE) && (pOldItem != pNewItem) && (pNewItem->Flags & OPTIF_CALLBACK) && (InitItemIdx < pTVWnd->ComPropSheetUI.cOptItem)) { // // Callback back ONLY for the user item which has CALLBACK // DoCallBack(hDlg, pTVWnd, pNewItem, pNewItem->pSel, NULL, NULL, 0, CPSUICB_REASON_OPTITEM_SETFOCUS); } if ((pNewItem == PIDX_INTOPTITEM(pTVWnd, INTIDX_TVROOT)) || ((NewType == TVOT_PUSHBUTTON) && (pOptType->Flags & OTS_PUSH_ENABLE_ALWAYS))) { CanUpdate = TRUE; } else { CanUpdate = (BOOL)(pTVWnd->Flags & TWF_CAN_UPDATE); } pTVWnd->Flags &= ~TWF_TVITEM_NOTYPE; if (IS_HDR_PUSH(pOptType)) { #if DO_IN_PLACE pOptType = NULL; NewType = TVOT_NONE; #else HTREEITEM hItem; UINT cRevert; if ((!CanUpdate) || (!(cRevert = CountRevertOptItem(pTVWnd, pNewItem, _OI_HITEM(pNewItem), 0)))) { CPSUIINT(("CountRevertOptItem=0, NOT REVERT")); // // We always enable the ROOT // if ((InitItemIdx == INTIDX_TVROOT) || ((pNewItem->pExtChkBox) && (!(pNewItem->Flags & OPTIF_EXT_HIDE)))) { pTVWnd->Flags |= TWF_ONE_REVERT_ITEM; pOptType->Flags |= OPTTF_TYPE_DISABLED; } else { pTVWnd->Flags |= TWF_TVITEM_NOTYPE; pOptType = NULL; NewType = TVOT_NONE; } } else { pOptType->Flags &= ~OPTTF_TYPE_DISABLED; if (cRevert == 1) { pTVWnd->Flags |= TWF_ONE_REVERT_ITEM; } else { pTVWnd->Flags &= ~TWF_ONE_REVERT_ITEM; } CPSUIINT(("CountRevertOptItem=%d, Let's do the PUSH", cRevert)); } #endif } if ((pNewItem->Flags & OPTIF_DISABLED) || (!CanUpdate)) { InitFlags = INITCF_TVDLG; } else { InitFlags = INITCF_ENABLE | INITCF_TVDLG; } if ((STVSMode & STVS_REINIT) || (pOldItem != pNewItem)) { InitFlags |= (INITCF_INIT | INITCF_SETCTRLDATA); ChangeOptTypeDisplay(hParent, pTVWnd, pOldOptType, pOptType, InitFlags & INITCF_ENABLE); } // // The extended check box will also looked at TWF_CAN_UPDATE flags to // disable the ECB if the flag is clear // if (pOptType) { if (INIT_EXTENDED(pTVWnd, hParent, pNewItem, IDD_TV_EXTCHKBOX, IDD_TV_EXTPUSH, IDD_TV_ECB_ICON, InitItemIdx, InitFlags)) { InitFlags |= INITCF_HAS_EXT; } } else if (InitFlags & INITCF_INIT) { if (hCtrl = GetDlgItem(hParent, IDD_TV_EXTPUSH)) { CPSUIINT(("!! DISABLE/HIDE HEADER EXTPUSH !!!")); EnableWindow(hCtrl, FALSE); ShowWindow(hCtrl, SW_HIDE); } if (hCtrl = GetDlgItem(hParent, IDD_TV_EXTCHKBOX)) { CPSUIINT(("!! DISABLE/HIDE HEADER EXTCHKBOX !!")); EnableWindow(hCtrl, FALSE); ShowWindow(hCtrl, SW_HIDE); } } if (pOptType) { LONG Select; UINT IDSetCurSel = CB_SETCURSEL; UINT idLBCB = IDD_TV_CB; UINT cyLBMax = 0; ULONG_PTR IconResID; WORD BegCtrlID; WORD IntIconID = IDI_CPSUI_GENERIC_ITEM; if (pNewItem->Flags & OPTIF_OVERLAY_WARNING_ICON) { IconMode |= MIM_WARNING_OVERLAY; } if (pNewItem->Flags & (OPTIF_OVERLAY_STOP_ICON | OPTIF_HIDE)) { IconMode |= MIM_STOP_OVERLAY; } if (pNewItem->Flags & OPTIF_OVERLAY_NO_ICON) { IconMode |= MIM_NO_OVERLAY; } if (pOptType->Flags & OPTTF_TYPE_DISABLED) { InitFlags &= ~INITCF_ENABLE; } // // We have something to do here, if we have same option type // with the old one then we need not to re-create them // and if we have same select then we do not need to re-draw // // Now set the option text to reflect the changes // pOptParam = pOptType->pOptParam; // // Compose '&Change xxxx Option' or // 'xxxxx Option" // #if (DO_IN_PLACE == 0) if (InitFlags & INITCF_INIT) { SetOptHeader(hDlg, pTVWnd, pNewItem, IS_HDR_PUSH(pOptType)); } #endif Select = pNewItem->Sel; BegCtrlID = pOptType->BegCtrlID; CPSUIDBG(DBG_STVS, ("TVOT_TYPE=%hs, InitFlags=%04lx, InitItemIdx = %ld, Select=%ld [%08lx]", (LPTSTR)pTVOTName[NewType], (DWORD)InitFlags, (DWORD)InitItemIdx, Select, Select)); switch(NewType) { case TVOT_2STATES: case TVOT_3STATES: #if (DO_IN_PLACE == 0) if (InitFlags & INITCF_INIT) { MoveStateRadios(hDlg, pTVWnd, pOptType, InitFlags); } #endif #if DO_IN_PLACE cyLBMax = pTVWnd->yLB[(InitFlags & INITCF_HAS_EXT) ? 0 : 1]; InitLBCB(pTVWnd, hParent, pNewItem, idLBCB, IDSetCurSel, pOptType, InitItemIdx, Select, InitFlags, cyLBMax); #else InitStates(pTVWnd, hParent, pNewItem, pOptType, IDD_3STATES_1, InitItemIdx, Select, InitFlags); #endif pOptParam += Select; break; case TVOT_UDARROW: InitUDArrow(pTVWnd, hParent, pNewItem, pOptParam, IDD_TV_UDARROW, IDD_TV_UDARROW_EDIT, IDD_TV_UDARROW_ENDTEXT, IDD_TV_UDARROW_HELP, InitItemIdx, Select, InitFlags); break; case TVOT_SCROLLBAR: case TVOT_TRACKBAR: CPSUIINT(("hParent=%08lx, NewType=%ld, hCtrl=%08lx", hParent, NewType, GetDlgItem(hParent, (NewType == TVOT_TRACKBAR) ? IDD_TV_TRACKBAR : IDD_TV_SB))); InitTBSB(pTVWnd, hParent, pNewItem, GetDlgItem(hParent, (NewType == TVOT_TRACKBAR) ? IDD_TV_TRACKBAR : IDD_TV_SB), pOptType, 0, IDD_TV_SB_LOW, IDD_TV_SB_HIGH, InitItemIdx, Select, InitFlags); break; case TVOT_LISTBOX: // // If we only has one item then make it combo box // cyLBMax = pTVWnd->yLB[(InitFlags & INITCF_HAS_EXT) ? 0 : 1]; IDSetCurSel = LB_SETCURSEL; idLBCB = IDD_TV_LB; // // Fall through // case TVOT_COMBOBOX: InitLBCB(pTVWnd, hParent, pNewItem, idLBCB, IDSetCurSel, pOptType, InitItemIdx, Select, InitFlags, cyLBMax); if ((DWORD)Select >= (DWORD)pOptType->Count) { CPSUIDBG(DBG_STVS, ("Get NONE type of select=%ld", Select)); pOptParam = &pTVWnd->OptParamNone; } else { pOptParam += (DWORD)Select; } break; case TVOT_EDITBOX: InitEditBox(pTVWnd, hParent, pNewItem, pOptParam, IDD_TV_EDIT_EDIT, IDD_TV_EDIT_ENDTEXT, IDD_TV_EDIT_HELP, InitItemIdx, pNewItem->pSel, InitFlags); break; case TVOT_PUSHBUTTON: InitPushButton(pTVWnd, hParent, pNewItem, IDD_TV_PUSH, InitItemIdx, InitFlags); break; case TVOT_CHKBOX: #if DO_IN_PLACE #if 0 InitChkBox(pTVWnd, hParent, pNewItem, IDD_TV_CHKBOX, pNewItem->pName, InitItemIdx, (BOOL)Select, InitFlags); #else { OPTTYPE ChkBoxOT; OPTPARAM ChkBoxOP[2]; UINT Idx; ChkBoxOT = *pOptType; ChkBoxOT.Type = TVOT_COMBOBOX; ChkBoxOT.Count = 2; ChkBoxOT.pOptParam = ChkBoxOP; ChkBoxOP[0] = ChkBoxOP[1] = *pOptParam; ChkBoxOP[0].Style = ChkBoxOP[1].Style = 0; ChkBoxOP[0].IconID = ChkBoxOP[1].IconID = 0; Idx = (UINT)(pOptParam->Style << 1); if (ChkBoxStrID[Idx]) { ChkBoxOP[0].pData = (LPTSTR)ChkBoxStrID[Idx]; } if (ChkBoxStrID[Idx + 1]) { ChkBoxOP[1].pData = (LPTSTR)ChkBoxStrID[Idx + 1]; } cyLBMax = pTVWnd->yLB[(InitFlags & INITCF_HAS_EXT) ? 0 : 1]; InitLBCB(pTVWnd, hParent, pNewItem, idLBCB, IDSetCurSel, &ChkBoxOT, InitItemIdx, Select, InitFlags, cyLBMax); } #endif #else InitChkBox(pTVWnd, hParent, pNewItem, IDD_TV_CHKBOX, pNewItem->pName, InitItemIdx, (BOOL)Select, InitFlags); #endif break; } if (IS_HDR_PUSH(pOptType)) { IconResID = GETSELICONID(pNewItem); IntIconID = IDI_CPSUI_GENERIC_OPTION; } else { IconResID = GET_ICONID(pOptParam, OPTPF_ICONID_AS_HICON); if (pOptParam->Flags & OPTPF_OVERLAY_WARNING_ICON) { IconMode |= MIM_WARNING_OVERLAY; } if (pOptParam->Flags & OPTPF_OVERLAY_STOP_ICON) { IconMode |= MIM_STOP_OVERLAY; } if (pOptParam->Flags & OPTPF_OVERLAY_NO_ICON) { IconMode |= MIM_NO_OVERLAY; } } #if (DO_IN_PLACE == 0) SetIcon(_OI_HINST(pNewItem), GetDlgItem(hParent, IDD_TV_ICON), IconResID, MK_INTICONID(IntIconID, IconMode), pTVWnd->cxcyTVIcon); #endif } #if DO_IN_PLACE #if 0 EnableWindow(GetDlgItem(hDlg, IDD_PRE_EDIT), (BOOL)pTVWnd->chWndEdit); EnableWindow(GetDlgItem(hDlg, IDD_POST_EDIT), (BOOL)pTVWnd->chWndEdit); #endif #endif return(pNewItem); } LONG UpdateTreeViewItem( HWND hDlg, PTVWND pTVWnd, POPTITEM pItem, BOOL ReInit ) /*++ Routine Description: This function update a single item in the treeview, and reset the bottom option change controls if this item also the current selected one Arguments: hDlg - Handle to the dialog box pTVWnd - Handle to common UI instance data pItem - Pointer to OPTITEM to be updated Return Value: LONG Author: 01-Sep-1995 Fri 01:05:56 created -by- Daniel Chou (danielc) Revision History: --*/ { if ((pItem) && (!(pItem->Flags & OPTIF_INT_HIDE))) { SetTVItemState(pTVWnd, NULL, pItem); if (pItem == pTVWnd->pCurTVItem) { NM_TREEVIEW NMtv; NMtv.itemNew.hItem = _OI_HITEM(pItem); NMtv.itemNew.mask = TVIF_HANDLE | TVIF_PARAM; if (IS_HDR_PUSH(GET_POPTTYPE(pItem))) { ReInit = TRUE; } if (TreeView_GetItem(pTVWnd->hWndTV, &(NMtv.itemNew))) { NMtv.itemOld = NMtv.itemNew; SetupTVSelect(hDlg, &NMtv, (ReInit) ? STVS_REINIT : 0); CPSUIDBG(DBG_UTV, ("*UpdateTreeViewItem: Item=Current Selection")); } } return(1); } else { return(0); } } LONG UpdateTreeView( HWND hDlg, PMYDLGPAGE pCurMyDP ) /*++ Routine Description: Arguments: Return Value: Author: 08-Aug-1995 Tue 15:37:16 created -by- Daniel Chou (danielc) Revision History: --*/ { INT cUpdated = 0; if (pCurMyDP->Flags & (MYDPF_CHANGED | MYDPF_REINIT)) { PTVWND pTVWnd; POPTITEM pItem; UINT cItem; BOOL ReInit; BOOL TVByPush; BYTE TVPageIdx; pTVWnd = (PTVWND)pCurMyDP->pTVWnd; pItem = pTVWnd->ComPropSheetUI.pOptItem; cItem = (UINT)pTVWnd->ComPropSheetUI.cOptItem; ReInit = (pCurMyDP->Flags & MYDPF_REINIT); TVByPush = (BOOL)(pTVWnd->Flags & TWF_TV_BY_PUSH); TVPageIdx = pTVWnd->TVPageIdx; CPSUIASSERT(0, "UpdateTreeView: DlgPage not treevie page (%ld)", ((pCurMyDP->DlgPage.DlgTemplateID == DP_STD_TREEVIEWPAGE) || (pCurMyDP->DlgPage.DlgTemplateID == DP_STD_INT_TVPAGE)) && ((BYTE)pCurMyDP->PageIdx == TVPageIdx), (BYTE)pCurMyDP->PageIdx); CPSUIDBG(DBGITEM_UTV, ("UpdateTreeView (OPTIF_INT_TV_CHANGED)")); while (cItem--) { if (pItem->Flags & OPTIF_INT_TV_CHANGED) { if ((!TVByPush) || (pItem->DlgPageIdx == TVPageIdx)) { CPSUIOPTITEM(DBGITEM_UTV, pTVWnd, "UpdateTreeView", 1, pItem); UpdateTreeViewItem(hDlg, pTVWnd, pItem, ReInit); ++cUpdated; } pItem->Flags &= ~OPTIF_INT_TV_CHANGED; } pItem++; } pCurMyDP->Flags &= ~(MYDPF_CHANGED | MYDPF_REINIT); } return((LONG)cUpdated); } POPTITEM TreeViewHitTest( PTVWND pTVWnd, LONG MousePos, UINT TVHTMask ) /*++ Routine Description: Arguments: Return Value: Author: 07-Sep-1995 Thu 22:32:04 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = pTVWnd->hWndTV; TV_HITTESTINFO ht; // // Find out the mouse cursor location if on the state icon/bmp // if (MousePos != -1) { ht.pt.x = (LONG)LOWORD(MousePos); ht.pt.y = (LONG)HIWORD(MousePos); } else { GetCursorPos(&ht.pt); } ScreenToClient(hWndTV, &ht.pt); TreeView_HitTest(hWndTV, &ht); CPSUIDBG(DBG_TVHT, ("TreeViewHitTest: pt=(%ld, %ld), HitTest=%04lx, TVHT_xx=%ld", (DWORD)ht.pt.x, (DWORD)ht.pt.y, TVHTMask, (DWORD)ht.flags)); if (ht.flags & TVHTMask) { POPTTYPE pOptType; POPTITEM pItem; TV_ITEM tvi; tvi.hItem = ht.hItem; tvi.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_STATE | TVIF_PARAM; tvi.stateMask = TVIS_STATEIMAGEMASK; if (TreeView_GetItem(hWndTV, &tvi)) { return(GetOptions(pTVWnd, tvi.lParam)); } } return(NULL); } VOID TreeViewChangeMode( PTVWND pTVWnd, POPTITEM pItem, UINT Mode ) /*++ Routine Description: Arguments: Return Value: Author: 07-Sep-1995 Thu 22:56:05 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = pTVWnd->hWndTV; POPTTYPE pOptType; TV_ITEM tvi; tvi.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_STATE | TVIF_PARAM; if ((!pItem) || (!(tvi.hItem = _OI_HITEM(pItem))) || (!TreeView_GetItem(hWndTV, &tvi))) { return; } switch (Mode) { case TVCM_TOGGLE: if (tvi.cChildren) { PostMessage(hWndTV, TVM_EXPAND, (WPARAM)TVE_TOGGLE, (LPARAM)tvi.hItem); } break; case TVCM_SELECT: PostMessage(hWndTV, TVM_SELECTITEM, (WPARAM)TVGN_CARET, (LPARAM)tvi.hItem); // // We will go to the next control only if the item is not disabled // and has an update permisson (push button always has one). // #if DO_IN_PLACE if ((!tvi.cChildren) && (!(pItem->Flags & OPTIF_DISABLED)) && (pOptType = GET_POPTTYPE(pItem)) && (!IS_HDR_PUSH(pOptType)) && ((pTVWnd->Flags & TWF_CAN_UPDATE) || (pOptType->Flags & OTS_PUSH_ENABLE_ALWAYS))) { if (pOptType->Type == TVOT_PUSHBUTTON) { PostMessage(pTVWnd->hDlgTV, WM_COMMAND, MAKEWPARAM(IDD_TV_PUSH, BN_CLICKED), (LPARAM)GetDlgItem(pTVWnd->hWndTV, IDD_TV_PUSH)); } else if (pTVWnd->chWndEdit) { PostMessage(pTVWnd->hDlgTV, WM_NEXTDLGCTL, (WPARAM)pTVWnd->hWndEdit[0], (LPARAM)1); } } #else if ((!tvi.cChildren) && (!(pItem->Flags & OPTIF_DISABLED)) && (pOptType = GET_POPTTYPE(pItem)) && (pOptType->Type == TVOT_PUSHBUTTON) && (!IS_HDR_PUSH(pOptType)) && ((pTVWnd->Flags & TWF_CAN_UPDATE) || (pOptType->Flags & OTS_PUSH_ENABLE_ALWAYS))) { PostMessage(pTVWnd->hDlgTV, WM_COMMAND, MAKEWPARAM(IDD_TV_PUSH, BN_CLICKED), (LPARAM)GetDlgItem(pTVWnd->hDlgTV, IDD_TV_PUSH)); } #endif break; } } VOID MouseSelectItem( HWND hDlg, PTVWND pTVWnd ) /*++ Routine Description: Arguments: Return Value: Author: 22-Jun-1995 Thu 13:44:18 created -by- Daniel Chou (danielc) Revision History: --*/ { POPTITEM pItem; // // Find out the mouse cursor location if on the state icon/bmp // if (pItem = TreeViewHitTest(pTVWnd, -1, TVHT_ONITEM)) { TreeViewChangeMode(pTVWnd, pItem, TVCM_SELECT); } } #if 0 BOOL CreateTVCtrls( HWND hDlg ) /*++ Routine Description: This function create any treeview change control that not in the static template Arguments: Return Value: Author: 06-Feb-1998 Fri 15:57:42 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hCtrl; // // Create TrackBar Control // if (hCtrl = CreateTrackBar(hDlg, IDD_TV_TRACKBAR)) { EnableWindow(hCtrl, FALSE); ShowWindow(hCtrl, SW_HIDE); // // Create Up/Down Control // if (hCtrl = CreateUDArrow(hDlg, IDD_TV_UDARROW_EDIT, IDD_TV_UDARROW)) { ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); return(TRUE); } } return(FALSE); } #endif HWND CreatehWndTV( HWND hDlg, PTVWND pTVWnd ) /*++ Routine Description: This function create TREE VIEW window Arguments: hDlg - Handle to the dialog for the treeview to be created, it must have item identify as IDD_TV_WND for the treeview window location Return Value: HWND for the treeview window Author: 21-Jun-1995 Wed 13:33:29 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV = NULL; HWND hCtrl; DWORD dw; RECT rc; WORD InitItemIdx = 0xFFFE; #if 0 if (!CreateTVCtrls(hDlg)) { return(NULL); } #endif // // Create TreeView Window, Get the window size for the treeview // hCtrl = CtrlIDrcWnd(hDlg, IDD_TV_WND, &rc); if (hCtrl) { SETCTRLDATA(hCtrl, CTRLS_TV_STATIC, 0); ShowWindow(hCtrl, SW_HIDE); CPSUIDBG(DBG_CTVWND, ("\nINIT DEV DLG, CLIENT rc=(%ld, %ld) - (%ld, %ld) = %ld x %ld", rc.left, rc.top, rc.right, rc.bottom, rc.right - rc.left, rc.bottom - rc.top)); if (hWndTV = CreateWindowEx(WS_EX_NOPARENTNOTIFY | WS_EX_CLIENTEDGE, WC_TREEVIEW, L"", WS_VISIBLE | TVS_HASBUTTONS | TVS_SHOWSELALWAYS | TVS_DISABLEDRAGDROP | // TVS_LINESATROOT | TVS_HASLINES | WS_CLIPCHILDREN | WS_CHILD | WS_BORDER | WS_TABSTOP | WS_CLIPSIBLINGS | WS_GROUP, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, hDlg, (HMENU)(IDD_TV_WND + 0), hInstDLL, 0)) { DestroyWindow(hCtrl); pTVWnd->hWndTV = hWndTV; SetWindowPos(hWndTV, GetDlgItem(hDlg, IDD_TV_WND), 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW); InitItemIdx = 0xFFFF; SETCTRLDATA(hWndTV, CTRLS_TV_WND, 0); #if DO_IN_PLACE #if 1 #if 0 if (hCtrl = GetDlgItem(hDlg, IDD_PRE_EDIT)) { ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); } if (hCtrl = GetDlgItem(hDlg, IDD_POST_EDIT)) { ShowWindow(hCtrl, SW_HIDE); EnableWindow(hCtrl, FALSE); } #endif #else if (hCtrl = GetDlgItem(hDlg, IDD_PRE_EDIT)) { SetWindowPos(hWndTV, hCtrl, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOREDRAW); SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)FocusCtrlProc); SetWindowPos(hCtrl, NULL, -10000, -10000, 0, 0, SWP_NOSIZE | SWP_NOZORDER); } // // Doing Post window // if (hCtrl = GetDlgItem(hDlg, IDD_POST_EDIT)) { SetWindowPos(hCtrl, hWndTV, -9000, -9000, 0, 0, SWP_NOSIZE | SWP_NOREDRAW); SetProp(hCtrl, CPSUIPROP_WNDPROC, (HANDLE)GetWindowLongPtr(hCtrl, GWLP_WNDPROC)); SetWindowLongPtr(hCtrl, GWLP_WNDPROC, (LPARAM)FocusCtrlProc); } #endif if (pTVWnd->hDCTVWnd = GetWindowDC(hWndTV)) { CreateTVFonts(pTVWnd, (HANDLE)SendMessage(hWndTV, WM_GETFONT, 0, 0)); } #endif pTVWnd->TVWndProc = (WNDPROC)SetWindowLongPtr(hWndTV, GWLP_WNDPROC, (LPARAM)MyTVWndProc); } CPSUIDBG(DBG_CTVWND, ("\nINIT DLG (%08lx), hWndTV = %08lx", hDlg, hWndTV)); } return(hWndTV); } HTREEITEM AddItem( PTVWND pTVWnd, HTREEITEM hParent, POPTITEM pItem, UINT DefTVIS, UINT TVLevel ) /*++ Routine Description: This function add a item to the end of list of treeview specified by Arguments: hParent - handle to the parent item for the item to be added pItem - Pointer to the OPTITEM to be added ItemIdx - Index to the pOptItem DefTVIS - default TVIS_xxxx Return Value: HTREEITEM of the item added or NULL if nothing added Author: 19-Jun-1995 Mon 16:38:27 created -by- Daniel Chou (danielc) 08-Sep-1995 Fri 13:43:34 updated -by- Daniel Chou (danielc) Re-write to make it more compact Revision History: --*/ { WORD ItemIdx; DWORD Flags; if ((VALID_PTR(pItem)) && (pItem >= pTVWnd->ComPropSheetUI.pOptItem) && (pItem <= pTVWnd->pLastItem)) { ItemIdx = (WORD)(pItem - pTVWnd->ComPropSheetUI.pOptItem); } else { ItemIdx = LOWORD(LODWORD(pItem)); pItem = PIDX_INTOPTITEM(pTVWnd, ItemIdx); if ((ItemIdx == INTIDX_PAPER) || (ItemIdx == INTIDX_GRAPHIC)) { if (pTVWnd->Flags & TWF_ADVDOCPROP) { DefTVIS &= ~TVIS_EXPANDED; } else { DefTVIS |= TVIS_EXPANDED; } } } CPSUIDBG(DBG_AI, ("ItemIdx = %ld (%08lx)", ItemIdx, ItemIdx)); CPSUIOPTITEM(DBG_AI, pTVWnd, "AddItem", 1, pItem); if (!(pItem->Flags & (OPTIF_INT_ADDED | OPTIF_ITEM_HIDE))) { TV_INSERTSTRUCT tvins; // // Set to internal added if this item is a user item // _OI_TVLEVEL(pItem) = (BYTE)TVLevel; tvins.item.state = DefTVIS; tvins.item.stateMask = TVIS_EXPANDED; // | TVIS_BOLD; tvins.item.mask = TVIF_TEXT | TVIF_STATE | TVIF_IMAGE | TVIF_SELECTEDIMAGE; tvins.hInsertAfter = TVI_LAST; tvins.hParent = hParent; SetTVItemState(pTVWnd, &tvins, pItem); if ((pItem->Flags |= OPTIF_INT_ADDED) & OPTIF_INITIAL_TVITEM) { if (pTVWnd->pCurTVItem) { CPSUIWARN(("Treeview: More than one OPTIF_INITIAL_TVITEM, OverRide")); } pTVWnd->pCurTVItem = pItem; } return(_OI_HITEM(pItem)); } return(NULL); } UINT AddItemGroup( PTVWND pTVWnd, HTREEITEM hParent, POPTITEM *ppItem, UINT TVLevel, UINT BegDMPubID, UINT EndDMPubID ) /*++ Routine Description: This function add items starting from the *ppItem, the item added includes item's sibling and all theirs children until end of the the pOptItem array. It also skip all the OPTIF_INT_ADDED and OPTIF_ITEM_HIDE items and its children Arguments: pTVWnd - Pointer to the TVWND instance data hParent - Parent of the starting item ppItem - Pointer to POPTITEM for the starting item in the pOptItem array at return this pointer is updated to the next item which either at end of array or the parent's sibling Return Value: UINT, count of item added to the treeview, it also update ppItem pointer Author: 27-Jun-1995 Tue 18:44:16 created -by- Daniel Chou (danielc) Revision History: --*/ { POPTITEM pItem; HTREEITEM hCurGrp; POPTITEM pLastItem; BYTE GrpLevel; BYTE CurLevel; UINT cAdd; pItem = *ppItem; pLastItem = pTVWnd->pLastItem; GrpLevel = pItem->Level; hCurGrp = hParent; cAdd = 0; while (pItem <= pLastItem) { if ((CurLevel = pItem->Level) < GrpLevel) { // // Finished the group level // break; } else if (pItem->Flags & (OPTIF_ITEM_HIDE | OPTIF_INT_ADDED)) { // // Skip this item and all its children // CPSUIOPTITEM(DBGITEM_AIG, pTVWnd, "Skip HIDE/INT_ADDED Item", 1, pItem); while ((++pItem <= pLastItem) && (pItem->Level > CurLevel)); } else if (CurLevel > GrpLevel) { // // Adding its children only if this item is not OPTIF_INT_ADDED and // OPTIF_ITEM_HIDE // CPSUIOPTITEM(DBG_AIG, pTVWnd, "AddItemGroup", 1, pItem); cAdd += AddItemGroup(pTVWnd, hCurGrp, &pItem, TVLevel + 1, 0, 0xFFFF); } else if (((UINT)pItem->DMPubID < BegDMPubID) || ((UINT)pItem->DMPubID > EndDMPubID)) { // // Skip this item and all its children // CPSUIOPTITEM(DBGITEM_AIG, pTVWnd, "Skip DMPubID Item", 1, pItem); CPSUIDBG(DBGITEM_AIG, ("Skip %ld (ONLY DMPubID=%ld-%ld Items)", pItem->DMPubID, BegDMPubID, EndDMPubID)); while ((++pItem <= pLastItem) && (pItem->Level > CurLevel)); } else { HTREEITEM hAdd; UINT DefTVIS = 0; // // Adding its sibling, checking if we could have children, if // we do then add the TVIS_BOLD flag to it, at return we want to // know if did add the item, if we do then this is his childrern's // parent handle // DefTVIS = (pItem->Flags & OPTIF_COLLAPSE) ? 0 : TVIS_EXPANDED; if ((pItem < pLastItem) && ((pItem + 1)->Level > CurLevel)) { DefTVIS |= TVIS_BOLD; } if (hAdd = AddItem(pTVWnd, hParent, pItem, DefTVIS, TVLevel)) { hCurGrp = hAdd; cAdd++; } pItem++; } } *ppItem = pItem; return(cAdd); } UINT AddPubGroup( PTVWND pTVWnd, HTREEITEM hParent, PINTTVGRP *ppitvg, UINT TVLevel, UINT DMPubIDAdd ) /*++ Routine Description: Arguments: Return Value: Author: 09-Sep-1995 Sat 11:58:59 created -by- Daniel Chou (danielc) Revision History: --*/ { POPTITEM pItem = NULL; HTREEITEM hLastGrp; HTREEITEM hCurGrp; PINTTVGRP pitvg; LPWORD pDMPubIdx; UINT cAdd; WORD Idx; BYTE GrpLevel; BYTE CurLevel; pitvg = *ppitvg; pDMPubIdx = pTVWnd->DMPubIdx; GrpLevel = (BYTE)(pitvg->LevelFlags & ITVG_LEVEL_MASK); hLastGrp = NULL; hCurGrp = hParent; cAdd = 0; while ((CurLevel = (pitvg->LevelFlags & ITVG_LEVEL_MASK)) >= GrpLevel) { if (CurLevel > GrpLevel) { // // Adding its children // PINTTVGRP pParentitvg = pitvg - 1; CPSUIASSERT(0, "AddPubGroup: Internal ERROR, no parent=%ld", (cAdd) && (hCurGrp), UIntToPtr(cAdd)); if (Idx = (WORD)AddPubGroup(pTVWnd, hCurGrp, &pitvg, TVLevel + 1, DMPubIDAdd)) { cAdd += (UINT)Idx; } else { CPSUIDBG(DBG_APG, ("AddPubGroup(Level=%02lx, ID=%ld), pItem=%08lx", pParentitvg->LevelFlags, pParentitvg->DMPubID, pItem)); if ((pParentitvg->DMPubID >= DMPUB_HDR_FIRST) || ((pItem) && (pItem->pOptType == NULL))) { // // Nothing added for this group, if this is the internal // group item then delete otherwise do not delete user's // item if the item has OPTTYPE // CPSUIINT(("0 Added, DELETE its Parent")); TreeView_DeleteItem(pTVWnd->hWndTV, hCurGrp); --cAdd; hCurGrp = hLastGrp; hLastGrp = NULL; } else { // // We need to take out the BOLD status // TV_ITEM tvi; tvi.mask = TVIF_STATE; tvi.hItem = hCurGrp; tvi.state = 0; tvi.stateMask = TVIS_BOLD; CPSUIINT(("0 Added, Remove pItem's BOLD")); TreeView_SetItem(pTVWnd->hWndTV, &tvi); } } } else { HTREEITEM hAdd = NULL; UINT DefTVIS; BYTE DMPubID; BOOL IsHdr; // // Adding its sibling, checking if we could have children, if // we do then add the TVIS_BOLD flag to it, at return we want to // know if did add the item, if we do then this is his childrern's // parent handle // if (pitvg->LevelFlags & ITVGF_COLLAPSE) { DefTVIS = 0; } else { DefTVIS = TVIS_EXPANDED; } if (pitvg->LevelFlags & ITVGF_BOLD) { DefTVIS |= TVIS_BOLD; } if ((DMPubID = pitvg->DMPubID) >= DMPUB_HDR_FIRST) { pItem = (POPTITEM)UIntToPtr(DMPubID - DMPUB_HDR_FIRST + INTIDX_FIRST); DefTVIS |= TVIS_BOLD; } else if ((Idx = pDMPubIdx[DMPubID - DMPUB_FIRST]) != 0xFFFF) { pItem = pTVWnd->ComPropSheetUI.pOptItem + Idx; } else { pItem = NULL; } if ((pItem) && (hAdd = AddItem(pTVWnd, hParent, pItem, DefTVIS, TVLevel))) { hLastGrp = hCurGrp; hCurGrp = hAdd; cAdd++; // // If this item has children, add the children // if ((VALID_PTR(pItem)) && (++pItem <= pTVWnd->pLastItem) && (pItem->Level > (pItem-1)->Level)) { cAdd += AddItemGroup(pTVWnd, hAdd, &pItem, TVLevel + 1, 0, 0xFFFF); } pitvg++; } else { // // Skip all the childrens belongs to him // CPSUIDBG(DBG_APG, ("Eiter pItem=NULL(%08lx) or AddItem()=NULL(%08lx)", pItem, hAdd)); while (((++pitvg)->LevelFlags & ITVG_LEVEL_MASK) > CurLevel) { // // We need to skip all the internal header and hide all // the real user items // if ((DMPubID = pitvg->DMPubID) && (DMPubID <= DMPUB_LAST) && ((Idx = pDMPubIdx[DMPubID - DMPUB_FIRST]) != 0xFFFF)) { POPTITEM pLastItem; BYTE ItemLevel; pItem = pTVWnd->ComPropSheetUI.pOptItem + Idx; pLastItem = pTVWnd->pLastItem; ItemLevel = pItem->Level; CPSUIOPTITEM(DBG_APG, pTVWnd, "Skip ITVG", 1, pItem); SKIP_CHILDREN_ORFLAGS(pItem, pLastItem, ItemLevel, OPTIF_INT_ADDED); } } } } } if ((GrpLevel == 1) && (hCurGrp)) { CPSUIDBG(DBG_OEM_ITEM, ("Add OEM Item Group, DMPubID=%ld", DMPubIDAdd)); pItem = pTVWnd->ComPropSheetUI.pOptItem; cAdd += AddItemGroup(pTVWnd, hCurGrp, &pItem, TVLevel, DMPubIDAdd, DMPubIDAdd); } *ppitvg = pitvg; return(cAdd); } BOOL AddOptItemToTreeView( PTVWND pTVWnd ) /*++ Routine Description: Arguments: Return Value: Author: 18-Aug-1995 Fri 14:39:32 created -by- Daniel Chou (danielc) Revision History: 30-Jul-1997 Wed 14:02:36 updated -by- Daniel Chou (danielc) Added codes that allowed DMPubID 0 to be added to Root --*/ { HTREEITEM hParent; HTREEITEM hRoot; POPTITEM pItem; UINT DefTVIS = TVIS_EXPANDED; UINT TVLevel = 0; // // Adding the header to it as Icon: CallerName XXXX // hRoot = hParent = AddItem(pTVWnd, TVI_ROOT, (POPTITEM)INTIDX_TVROOT, DefTVIS | TVIS_BOLD, TVLevel); TVLevel += 1; if (pTVWnd->Flags & TWF_TVPAGE_CHK_DMPUB) { if (pTVWnd->Flags & TWF_TVPAGE_NODMPUB) { POPTITEM pLastItem = pTVWnd->pLastItem; // // Mark all the DMPUB_xxx to OPTIF_INT_ADDED // pItem = pTVWnd->ComPropSheetUI.pOptItem; while (pItem <= pLastItem) { BYTE CurLevel = pItem->Level; if ((pItem->DMPubID != DMPUB_NONE) && (pItem->DMPubID < DMPUB_USER)) { SKIP_CHILDREN_ORFLAGS(pItem, pLastItem, CurLevel, OPTIF_INT_ADDED); } else { SKIP_CHILDREN(pItem, pLastItem, CurLevel); } } } else { HTREEITEM hHdrGrp; PINTTVGRP pitvg; pitvg = (PINTTVGRP)IntTVGrpPaper; AddPubGroup(pTVWnd, hRoot, &pitvg, TVLevel, DMPUB_OEM_PAPER_ITEM); pitvg = (PINTTVGRP)IntTVGrpGraphic; AddPubGroup(pTVWnd, hRoot, &pitvg, TVLevel, DMPUB_OEM_GRAPHIC_ITEM); DefTVIS = 0; } } if (pTVWnd->IntTVOptIdx) { pItem = PIDX_INTOPTITEM(pTVWnd, pTVWnd->IntTVOptIdx); if (pTVWnd->Flags & (TWF_ADVDOCPROP | TWF_TV_BY_PUSH)) { pItem->Flags &= ~OPTIF_COLLAPSE; } if (pItem->Flags & OPTIF_COLLAPSE) { DefTVIS &= ~TVIS_EXPANDED; } else { DefTVIS |= TVIS_EXPANDED; } hParent = AddItem(pTVWnd, hRoot, (POPTITEM)pTVWnd->IntTVOptIdx, DefTVIS | TVIS_BOLD, TVLevel); // // Add OEM items that under the TVROOT // CPSUIDBG(DBG_OEM_ITEM, ("Add OEM Item Group, DMPubID=%ld", DMPUB_OEM_ROOT_ITEM)); pItem = pTVWnd->ComPropSheetUI.pOptItem; AddItemGroup(pTVWnd, hRoot, &pItem, TVLevel, DMPUB_OEM_ROOT_ITEM, DMPUB_OEM_ROOT_ITEM); TVLevel += 1; } // // Add rest of the OPTITEMS // pItem = pTVWnd->ComPropSheetUI.pOptItem; if ((!AddItemGroup(pTVWnd, hParent, &pItem, TVLevel, 0, 0xFFFF)) && (hParent != hRoot)) { // // Since we did not add any item, s delete the Options header if any // CPSUIINT(("There is NO 'Options' items, delete the header")); TreeView_DeleteItem(pTVWnd->hWndTV, hParent); } return(TRUE); } HWND CreateTVOption( HWND hDlg, PTVWND pTVWnd ) /*++ Routine Description: Arguments: Return Value: Author: 19-Jun-1995 Mon 16:18:43 created -by- Daniel Chou (danielc) Revision History: --*/ { HWND hWndTV; HTREEITEM hRoot; POPTITEM pItem; POPTITEM pCurTVItem; POPTITEM pLastItem; BYTE TVPageIdx; pTVWnd->hDlgTV = hDlg; pCurTVItem = pTVWnd->pCurTVItem; if (hWndTV = CreatehWndTV(hDlg, pTVWnd)) { pItem = &(pTVWnd->IntOptItem[0]); pLastItem = &(pTVWnd->IntOptItem[INTIDX_TOTAL - 1]); TVPageIdx = (BYTE)(pTVWnd->cMyDlgPage - 1); while (pItem <= pLastItem) { _OI_HITEM(pItem) = NULL; pItem->Flags &= ~(OPTIF_INT_ADDED | OPTIF_INITIAL_TVITEM); pItem->DlgPageIdx = TVPageIdx; if (pItem == pCurTVItem) { pItem->Flags |= OPTIF_INITIAL_TVITEM; } ++pItem; } pItem = pTVWnd->ComPropSheetUI.pOptItem; pLastItem = pTVWnd->pLastItem; while (pItem <= pLastItem) { _OI_HITEM(pItem) = NULL; pItem->Flags &= ~(OPTIF_INT_ADDED | OPTIF_INITIAL_TVITEM); if ((pTVWnd->Flags & TWF_TV_BY_PUSH) && (pItem->DlgPageIdx != TVPageIdx)) { pItem->Flags |= OPTIF_INT_ADDED; } if (pItem == pCurTVItem) { pItem->Flags |= OPTIF_INITIAL_TVITEM; } ++pItem; } pTVWnd->pCurTVItem = NULL; InitDlgCtrl(hDlg, pTVWnd); SendMessage(pTVWnd->hWndTV, TVM_SETIMAGELIST, (WPARAM)TVSIL_NORMAL, (LPARAM)pTVWnd->himi); AddOptItemToTreeView(pTVWnd); } else { CPSUIERR(("\nCreatehWndTV() failed")); } return(hWndTV); } #if DBG #if 0 LRESULT CALLBACK ShowChildWndProc( HWND hWnd, LPARAM lParam ) { HWND hParent = (HWND)hWnd; DWORD dw; WCHAR Buf[64]; dw = 0; while ((HWND)lParam != hParent) { Buf[dw++] = L' '; Buf[dw++] = L' '; hParent = GetParent(hParent); } Buf[dw++] = L'\0'; CPSUIDBG(DBG_SCID, ("%wshWnd=%08lx, hParent=%08lx, ID=%5ld", Buf, hWnd, GetParent(hWnd), GetWindowLongPtr(hWnd, GWLP_ID))); return(TRUE); } #endif #endif INT_PTR CALLBACK TreeViewProc( HWND hDlg, UINT Msg, WPARAM wParam, LPARAM lParam ) /*++ Routine Description: Arguments: Return Value: Author: 28-Jun-1995 Wed 17:00:44 created -by- Daniel Chou (danielc) Revision History: --*/ { POPTITEM pItem; HWND hWndTV; HWND *phWnd; HICON hIcon; PTVWND pTVWnd; PMYDLGPAGE pCurMyDP; NM_TREEVIEW *pNMTV; DWORD dw; HTREEITEM hItem; if (Msg == WM_INITDIALOG) { CPSUIINT(("Treeview WM_INITDIALOG: hDlg=%08lx, pPSP=%08lx", hDlg, lParam)); pCurMyDP = (PMYDLGPAGE)(((LPPROPSHEETPAGE)lParam)->lParam); pTVWnd = (PTVWND)pCurMyDP->pTVWnd; pCurMyDP->pPSPInfo = PPSPINFO_FROM_WM_INITDIALOG_LPARAM(lParam); pCurMyDP->hDlgChild = NULL; pTVWnd->Flags |= TWF_IN_TVPAGE; SetWindowLongPtr(hDlg, GWL_EXSTYLE, GetWindowLongPtr(hDlg, GWL_EXSTYLE) | WS_EX_CONTEXTHELP); if (!ADD_PMYDLGPAGE(hDlg, pCurMyDP)) { return(FALSE); } if (pTVWnd->Flags & TWF_TV_BY_PUSH) { SetWindowText(hDlg, ((LPPROPSHEETPAGE)lParam)->pszTitle); } CreateImageList(hDlg, pTVWnd); CreateTVOption(hDlg, pTVWnd); SetUniqChildID(hDlg); CommonPropSheetUIHelpSetup(NULL, pTVWnd); UpdateCallBackChanges(hDlg, pTVWnd, TRUE); if (pItem = pTVWnd->pCurTVItem) { pTVWnd->pCurTVItem = NULL; if (!TreeView_SelectItem(pTVWnd->hWndTV, _OI_HITEM(pItem))) { pItem = NULL; } } if ((!pItem) && (hItem = TreeView_GetRoot(pTVWnd->hWndTV)) && (!SelectFirstVisibleOptItem(pTVWnd, hItem))) { TreeView_SelectItem(pTVWnd->hWndTV, hItem); } if (pTVWnd->Flags & TWF_TV_BY_PUSH) { SetOptItemNewDef(hDlg, pTVWnd, TRUE); } SetFocus(pTVWnd->hWndTV); return(FALSE); } if (pCurMyDP = GET_PMYDLGPAGE(hDlg)) { pTVWnd = pCurMyDP->pTVWnd; hWndTV = pTVWnd->hWndTV; switch(Msg) { case WM_GETDLGCODE: CPSUIINT(("TreeViewProc: WM_GETDLGCODE")); break; case WM_NEXTDLGCTL: CPSUIINT(("TreeViewProc: WM_NEXTDLGCTL: flHandle=%ld, wParam=%08lx", LOWORD(lParam), wParam)); break; case WM_DRAWITEM: return(DrawLBCBItem(pTVWnd, (LPDRAWITEMSTRUCT)lParam)); case WM_COMMAND: if (pTVWnd->Flags & TWF_TV_BY_PUSH) { switch (LOWORD(wParam)) { case IDCANCEL: pItem = PIDX_INTOPTITEM(pTVWnd, INTIDX_TVROOT); DoCallBack(hDlg, pTVWnd, pItem, pItem->pSel, (_CPSUICALLBACK)InternalRevertDef2, NULL, 0, CPSUICB_REASON_SEL_CHANGED); UpdateCallBackChanges(hDlg, pTVWnd, TRUE); EndDialog(hDlg, 0); return(TRUE); case IDOK: UpdateCallBackChanges(hDlg, pTVWnd, TRUE); EndDialog(hDlg, 1); return(TRUE); default: break; } } // // Fall though // case WM_HSCROLL: if (pItem = DlgHScrollCommand(hDlg, pTVWnd, (HWND)lParam, wParam)) { UpdateTreeViewItem(hDlg, pTVWnd, pItem, FALSE); } break; case WM_ACTIVATE: if (LOWORD(wParam) != WA_INACTIVE) { CPSUIINT(("!! WM_SETACTIVE: cEdit=%ld !!", pTVWnd->chWndEdit)); InvalidateRect(hWndTV, NULL, FALSE); if (dw = (DWORD)pTVWnd->chWndEdit) { phWnd = pTVWnd->hWndEdit; while (dw--) { if (hWndTV = *phWnd++) { SetWindowPos(hWndTV, NULL, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE | SWP_FRAMECHANGED); InvalidateRect(hWndTV, NULL, FALSE); } } } } break; case WM_HELP: wParam = (WPARAM)((LPHELPINFO)lParam)->hItemHandle; lParam = (LPARAM)MAKELONG(((LPHELPINFO)lParam)->MousePos.x, ((LPHELPINFO)lParam)->MousePos.y); case WM_CONTEXTMENU: if (lParam == 0xFFFFFFFF) { RECT rc; if ((HWND)(wParam = (WPARAM)GetFocus()) == hWndTV) { pTVWnd->VKeyTV = VK_F1; if (TreeView_GetItemRect(hWndTV, _OI_HITEM(pTVWnd->pCurTVItem), &rc, TRUE)) { ClientToScreen(hWndTV, (LPPOINT)&rc.left); ClientToScreen(hWndTV, (LPPOINT)&rc.right); } else { GetWindowRect((HWND)wParam, &rc); } } else { GetWindowRect((HWND)wParam, &rc); } CPSUIINT(("MousePos=0xFFFFFFFF, GetFocus=%08lx, rc=(%ld, %ld)-(%ld, %ld)", (HWND)wParam, rc.left, rc.top, rc.right, rc.bottom)); rc.left += ((rc.right - rc.left) / 2); rc.top += ((rc.bottom - rc.top) / 2); lParam = (LPARAM)MAKELONG(rc.left, rc.top); } CPSUIINT(("--- WM_%ws --hWndTV=%08lx, wParam=%08lx. Mouse=(%ld, %ld)----", (Msg == WM_HELP) ? L"HELP" : L"CONTEXTMENU", hWndTV, wParam, LOWORD(lParam), HIWORD(lParam))); if ((HWND)wParam == hWndTV) { pItem = (pTVWnd->VKeyTV == VK_F1) ? pTVWnd->pCurTVItem : TreeViewHitTest(pTVWnd, (LONG)lParam, TVHT_ONITEM); if (!pItem) { CPSUIINT(("pItem=NULL, hWnd=%08lx, ID=%ld", wParam, GetWindowLongPtr((HWND)wParam, GWLP_ID))); pItem = pItemFromhWnd(hWndTV, pTVWnd, NULL, (LONG)lParam); } } else { pItem = pItemFromhWnd(hDlg, pTVWnd, (HWND)wParam, (LONG)lParam); } // // Reset key now // pTVWnd->VKeyTV = 0; if (Msg == WM_CONTEXTMENU) { DoContextMenu(pTVWnd, hDlg, pItem, lParam); } else if (pItem) { CommonPropSheetUIHelp(hDlg, pTVWnd, (HWND)hWndTV, (DWORD)lParam, pItem, HELP_WM_HELP); } break; case WM_NOTIFY: pNMTV = (NM_TREEVIEW *)lParam; dw = 0; switch (pNMTV->hdr.code) { case NM_DBLCLK: TreeViewChangeMode(pTVWnd, pTVWnd->pCurTVItem, TVCM_SELECT); break; case NM_SETFOCUS: case NM_CLICK: case NM_RDBLCLK: case NM_RCLICK: break; case TVN_ITEMEXPANDING: CPSUIDBG(DBG_TVPROC, ("TVN_ITEMEXPANDING:")); break; case TVN_ITEMEXPANDED: CPSUIDBG(DBG_TVPROC, ("TVN_ITEMEXPANDED:")); if ((pTVWnd->IntTVOptIdx) && (pItem = PIDX_INTOPTITEM(pTVWnd, pTVWnd->IntTVOptIdx)) && (_OI_HITEM(pItem) == pNMTV->itemNew.hItem)) { if (pNMTV->itemNew.state & TVIS_EXPANDED) { CPSUIINT(("Internal OPTIONS Expanded")); pItem->Flags &= ~OPTIF_COLLAPSE; } else { CPSUIINT(("Internal OPTIONS Collapse")); pItem->Flags |= OPTIF_COLLAPSE; } } break; case TVN_KEYDOWN: pTVWnd->VKeyTV = ((TV_KEYDOWN *)lParam)->wVKey; CPSUIDBG(DBG_KEYS, ("TVN_KEYDOWN: VKey=%ld", pTVWnd->VKeyTV)); if ((pItem = pTVWnd->pCurTVItem) && (hItem = _OI_HITEM(pItem))) { switch (pTVWnd->VKeyTV) { case VK_LEFT: case VK_BACK: if ((!TreeView_GetChild(hWndTV, hItem)) && (hItem = TreeView_GetParent(hWndTV, hItem))) { PostMessage(hWndTV, TVM_SELECTITEM, (WPARAM)TVGN_CARET, (LPARAM)hItem); } break; case VK_RIGHT: if ((pTVWnd->chWndEdit) && (pTVWnd->hWndEdit[0])) { SetFocus(pTVWnd->hWndEdit[0]); } break; } } break; case TVN_GETDISPINFO: SetTVItemImage(pTVWnd, (TV_DISPINFO *)lParam); break; case TVN_SELCHANGED: #if DO_IN_PLACE if (pItem = pTVWnd->pCurTVItem) { _OI_INTFLAGS(pItem) &= ~OIDF_ZERO_SEL_LEN; SetTVItemState(pTVWnd, NULL, pItem); } if ((pItem = GetOptions(pTVWnd, pNMTV->itemNew.lParam)) && (!(pItem->Flags & OPTIF_INT_HIDE))) { CPSUIINT(("pOldItem=%08lx, pNewItem=%08lx, cxItem=%ld/%ld", pTVWnd->pCurTVItem, pItem, pTVWnd->cxItem, pTVWnd->cxMaxItem)); _OI_INTFLAGS(pItem) |= OIDF_ZERO_SEL_LEN; SetTVItemState(pTVWnd, NULL, pItem); } pTVWnd->pCurTVItem = (POPTITEM)~0; #endif pTVWnd->pCurTVItem = SetupTVSelect(hDlg, pNMTV, STVS_REINIT | STVS_ACTIVE); #if DO_IN_PLACE if (pTVWnd->cxItem > pTVWnd->cxMaxItem) { CPSUIINT(("pCurTVItem=%08lx, cxItem=%ld <= %ld, Redo SetTVItemState()", pTVWnd->pCurTVItem, pTVWnd->cxItem, pTVWnd->cxMaxItem)); SetTVItemState(pTVWnd, NULL, pTVWnd->pCurTVItem); } #endif CPSUIOPTITEM(DBGITEM_SELCHG, pTVWnd, "TVN_SELCHANGED", 1, pTVWnd->pCurTVItem); CPSUIDBG(DBG_SCID, ("\n-----EnumChild of (%08lx)-----", GetParent(hDlg))); #if DBG #if 0 EnumChildWindows(GetParent(hDlg), ShowChildWndProc, (LPARAM)GetParent(hDlg)); #endif #endif break; case PSN_SETACTIVE: CPSUIDBG(DBG_TVPROC, ("\nTreeView: Got PSN_SETACTIVE, pTVWnd=%08lx (%ld), Page=%u -> %u\n", pTVWnd, pTVWnd->cMyDlgPage, (UINT)pTVWnd->ActiveDlgPage, (UINT)pCurMyDP->PageIdx)); pCurMyDP->Flags |= MYDPF_PAGE_ACTIVE; pTVWnd->ActiveDlgPage = pCurMyDP->PageIdx; pTVWnd->Flags |= TWF_IN_TVPAGE; DoCallBack(hDlg, pTVWnd, pTVWnd->ComPropSheetUI.pOptItem, (LPVOID)-1, NULL, NULL, 0, CPSUICB_REASON_SETACTIVE); if ((pTVWnd->pCurTVItem) && (IS_HDR_PUSH(GET_POPTTYPE(pTVWnd->pCurTVItem)))) { UpdateTreeViewItem(hDlg, pTVWnd, pTVWnd->pCurTVItem, TRUE); } UpdateTreeView(hDlg, pCurMyDP); CPSUIINT(("!! WM_SETACTIVE: cEdit=%ld", pTVWnd->chWndEdit)); InvalidateRect(hWndTV, NULL, FALSE); if (dw = (DWORD)pTVWnd->chWndEdit) { phWnd = pTVWnd->hWndEdit; while (dw--) { if (hWndTV = *phWnd++) { InvalidateRect(hWndTV, NULL, FALSE); } } } dw = 0; break; case PSN_KILLACTIVE: CPSUIDBG(DBG_TVPROC, ("TreeView: Got PSN_KILLACTIVE, pTVWnd=%08lx (%ld)", pTVWnd, pTVWnd->cMyDlgPage)); if (pCurMyDP) { pCurMyDP->hWndFocus = GetFocus(); pCurMyDP->Flags &= ~MYDPF_PAGE_ACTIVE; DoCallBack(hDlg, pTVWnd, pTVWnd->ComPropSheetUI.pOptItem, (LPVOID)-1, NULL, NULL, 0, CPSUICB_REASON_KILLACTIVE); pTVWnd->Flags &= ~TWF_IN_TVPAGE; } break; case PSN_APPLY: if ((pTVWnd->Flags & TWF_CAN_UPDATE) && (pTVWnd->ActiveDlgPage == pCurMyDP->PageIdx)) { CPSUIDBG(DBG_TVPROC, ("\nTreeViewPage: Do PSN_APPLY(%ld), Page: Cur=%u, Active=%u, Flags=%04lx, CALLBACK", (pTVWnd->Flags & TWF_APPLY_NO_NEWDEF) ? 1 : 0, (UINT)pCurMyDP->PageIdx, (UINT)pTVWnd->ActiveDlgPage, pTVWnd->Flags)); if (DoCallBack(hDlg, pTVWnd, (pTVWnd->Flags & TWF_APPLY_NO_NEWDEF) ? NULL : pTVWnd->ComPropSheetUI.pOptItem, (LPVOID)-1, NULL, NULL, 0, CPSUICB_REASON_APPLYNOW) == CPSUICB_ACTION_NO_APPLY_EXIT) { // send a PSN_SETACTIVE message to treeview page so that we will set the // flags like TWF_IN_TVPAGE HWND hParent; if (hParent = GetParent(pTVWnd->hDlgTV)) { PropSheet_SetCurSelByID(hParent, pCurMyDP->DlgPage.DlgTemplateID); } dw = PSNRET_INVALID_NOCHANGEPAGE; } } else { CPSUIDBG(DBG_TVPROC, ("\nTreeViewPage: Ignore PSN_APPLY, Page: Cur=%u, Active=%u, Flags=%04lx, DO NOTHING", (UINT)pCurMyDP->PageIdx, (UINT)pTVWnd->ActiveDlgPage, pTVWnd->Flags)); } break; case PSN_RESET: CPSUIDBG(DBG_TVPROC, ("\nTreeView: Got PSN_RESET (Cancel)\n")); break; case PSN_HELP: CPSUIDBG(DBG_TVPROC, ("\nTreeView: Got PSN_HELP (Help)\n")); CommonPropSheetUIHelp(hDlg, pTVWnd, hWndTV, 0, NULL, HELP_CONTENTS); break; default: CPSUIDBG(DBG_TVPROC, ("*TVProc: Unknow WM_NOTIFY=%08lx, id=%ld, hWnd=%08lx", (DWORD)pNMTV->hdr.code, pNMTV->hdr.idFrom, pNMTV->hdr.hwndFrom)); break; } SetWindowLongPtr(hDlg, DWLP_MSGRESULT, (LPARAM)dw); return(TRUE); break; case WM_DESTROY: CPSUIINT(("TreeViewProc: Get WM_DESTROY Message")); SetWindowLongPtr(hWndTV, GWLP_WNDPROC, (LPARAM)pTVWnd->TVWndProc); CommonPropSheetUIHelpSetup(hDlg, pTVWnd); DeleteTVFonts(pTVWnd); if (pTVWnd->hDCTVWnd) { ReleaseDC(hWndTV, pTVWnd->hDCTVWnd); pTVWnd->hDCTVWnd = NULL; } if (hIcon = (HICON)SendDlgItemMessage(hDlg, IDD_TV_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)NULL)) { DestroyIcon(hIcon); } if (hIcon = (HICON)SendDlgItemMessage(hDlg, IDD_TV_ECB_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)NULL)) { DestroyIcon(hIcon); } #if 0 if (hIcon = (HICON)SendDlgItemMessage(hDlg, IDD_TV_HDR_PUSH_ICON, STM_SETIMAGE, (WPARAM)IMAGE_ICON, (LPARAM)NULL)) { DestroyIcon(hIcon); } #endif SendMessage(hWndTV, TVM_SETIMAGELIST, (WPARAM)TVSIL_NORMAL, (LPARAM)NULL); DEL_PMYDLGPAGE(hDlg); pTVWnd->hWndTV = NULL; pTVWnd->Flags &= ~TWF_IN_TVPAGE; break; } } return(FALSE); #undef pPSPInfo }