src/Utils/TreePropSheet/TreePropSheet.cpp

   1 /********************************************************************
   2 *
   3 * Copyright (c) 2002 Sven Wiegand <mail@sven-wiegand.de>
   4 *
   5 * You can use this and modify this in any way you want,
   6 * BUT LEAVE THIS HEADER INTACT.
   7 *
   8 * Redistribution is appreciated.
   9 *
  10 * $Workfile:$
  11 * $Revision:$
  12 * $Modtime:$
  13 * $Author:$
  14 *
  15 * Revision History:
  16 *       $History:$
  17 *
  18 *********************************************************************/
  19
  20
  21 #include "stdafx.h"
  22 #include "TreePropSheet.h"
  23 #include "PropPageFrameDefault.h"
  24 #include "HighColorTab.hpp"
  25
  26 #ifdef _DEBUG
  27 #define new DEBUG_NEW
  28 #undef THIS_FILE
  29 static char THIS_FILE[] = __FILE__;
  30 #endif
  31
  32
  33
  34 namespace TreePropSheet
  35 {
  36
  37 //-------------------------------------------------------------------
  38 // class CTreePropSheet
  39 //-------------------------------------------------------------------
  40
  41 BEGIN_MESSAGE_MAP(CTreePropSheet, CPropertySheet)
  42         //{{AFX_MSG_MAP(CTreePropSheet)
  43         ON_WM_DESTROY()
  44         //}}AFX_MSG_MAP
  45         ON_MESSAGE(PSM_ADDPAGE, OnAddPage)
  46         ON_MESSAGE(PSM_REMOVEPAGE, OnRemovePage)
  47         ON_MESSAGE(PSM_SETCURSEL, OnSetCurSel)
  48         ON_MESSAGE(PSM_SETCURSELID, OnSetCurSelId)
  49         ON_MESSAGE(PSM_ISDIALOGMESSAGE, OnIsDialogMessage)
  50
  51         ON_NOTIFY(TVN_SELCHANGINGA, s_unPageTreeId, OnPageTreeSelChanging)
  52         ON_NOTIFY(TVN_SELCHANGINGW, s_unPageTreeId, OnPageTreeSelChanging)
  53         ON_NOTIFY(TVN_SELCHANGEDA, s_unPageTreeId, OnPageTreeSelChanged)
  54         ON_NOTIFY(TVN_SELCHANGEDW, s_unPageTreeId, OnPageTreeSelChanged)
  55 END_MESSAGE_MAP()
  56
  57 IMPLEMENT_DYNAMIC(CTreePropSheet, CPropertySheet)
  58
  59 const UINT CTreePropSheet::s_unPageTreeId = 0x7EEE;
  60
  61 CTreePropSheet::CTreePropSheet()
  62 :       CPropertySheet(),
  63         m_bPageTreeSelChangedActive(FALSE),
  64         m_bTreeViewMode(TRUE),
  65         m_bPageCaption(FALSE),
  66         m_bTreeImages(FALSE),
  67         m_nPageTreeWidth(150),
  68         m_pwndPageTree(NULL),
  69         m_pFrame(NULL)
  70 {}
  71
  72
  73 CTreePropSheet::CTreePropSheet(UINT nIDCaption, CWnd* pParentWnd, UINT iSelectPage)
  74 :       CPropertySheet(nIDCaption, pParentWnd, iSelectPage),
  75         m_bPageTreeSelChangedActive(FALSE),
  76         m_bTreeViewMode(TRUE),
  77         m_bPageCaption(FALSE),
  78         m_bTreeImages(FALSE),
  79         m_nPageTreeWidth(150),
  80         m_pwndPageTree(NULL),
  81         m_pFrame(NULL)
  82 {
  83 }
  84
  85
  86 CTreePropSheet::CTreePropSheet(LPCTSTR pszCaption, CWnd* pParentWnd, UINT iSelectPage)
  87 :       CPropertySheet(pszCaption, pParentWnd, iSelectPage),
  88         m_bPageTreeSelChangedActive(FALSE),
  89         m_bTreeViewMode(TRUE),
  90         m_bPageCaption(FALSE),
  91         m_bTreeImages(FALSE),
  92         m_nPageTreeWidth(150),
  93         m_pwndPageTree(NULL),
  94         m_pFrame(NULL)
  95 {
  96 }
  97
  98
  99 CTreePropSheet::~CTreePropSheet()
 100 {
 101 }
 102
 103
 104 /////////////////////////////////////////////////////////////////////
 105 // Operationen
 106
 107 BOOL CTreePropSheet::SetTreeViewMode(BOOL bTreeViewMode /* = TRUE */, BOOL bPageCaption /* = FALSE */, BOOL bTreeImages /* = FALSE */)
 108 {
 109         if (IsWindow(m_hWnd))
 110         {
 111                 // needs to becalled, before the window has been created
 112                 ASSERT(FALSE);
 113                 return FALSE;
 114         }
 115
 116         m_bTreeViewMode = bTreeViewMode;
 117         if (m_bTreeViewMode)
 118         {
 119                 m_bPageCaption = bPageCaption;
 120                 m_bTreeImages = bTreeImages;
 121         }
 122
 123         return TRUE;
 124 }
 125
 126
 127 BOOL CTreePropSheet::SetTreeWidth(int nWidth)
 128 {
 129         if (IsWindow(m_hWnd))
 130         {
 131                 // needs to be called, before the window is created.
 132                 ASSERT(FALSE);
 133                 return FALSE;
 134         }
 135
 136         m_nPageTreeWidth = nWidth;
 137
 138         return TRUE;
 139 }
 140
 141
 142 void CTreePropSheet::SetEmptyPageText(LPCTSTR lpszEmptyPageText)
 143 {
 144         m_strEmptyPageMessage = lpszEmptyPageText;
 145 }
 146
 147
 148 DWORD   CTreePropSheet::SetEmptyPageTextFormat(DWORD dwFormat)
 149 {
 150         DWORD   dwPrevFormat = m_pFrame->GetMsgFormat();
 151         m_pFrame->SetMsgFormat(dwFormat);
 152         return dwPrevFormat;
 153 }
 154
 155
 156 BOOL CTreePropSheet::SetTreeDefaultImages(CImageList *pImages)
 157 {
 158         if (pImages->GetImageCount() != 2)
 159         {
 160                 ASSERT(FALSE);
 161                 return FALSE;
 162         }
 163
 164         if (m_DefaultImages.GetSafeHandle())
 165                 m_DefaultImages.DeleteImageList();
 166         m_DefaultImages.Create(pImages);
 167
 168         // update, if necessary
 169         if (IsWindow(m_hWnd))
 170                 RefillPageTree();
 171
 172         return TRUE;
 173 }
 174
 175
 176 BOOL CTreePropSheet::SetTreeDefaultImages(UINT unBitmapID, int cx, COLORREF crMask)
 177 {
 178         if (m_DefaultImages.GetSafeHandle())
 179                 m_DefaultImages.DeleteImageList();
 180         if (!m_DefaultImages.Create(unBitmapID, cx, 0, crMask))
 181                 return FALSE;
 182
 183         if (m_DefaultImages.GetImageCount() != 2)
 184         {
 185                 m_DefaultImages.DeleteImageList();
 186                 return FALSE;
 187         }
 188
 189         return TRUE;
 190 }
 191
 192
 193 CTreeCtrl* CTreePropSheet::GetPageTreeControl()
 194 {
 195         return m_pwndPageTree;
 196 }
 197
 198
 199 /////////////////////////////////////////////////////////////////////
 200 // public helpers
 201
 202 BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, HICON hIcon)
 203 {
 204         pPage->m_psp.dwFlags|= PSP_USEHICON;
 205         pPage->m_psp.hIcon = hIcon;
 206         return TRUE;
 207 }
 208
 209
 210 BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, UINT unIconId)
 211 {
 212         HICON   hIcon = AfxGetApp()->LoadIcon(unIconId);
 213         if (!hIcon)
 214                 return FALSE;
 215
 216         return SetPageIcon(pPage, hIcon);
 217 }
 218
 219
 220 BOOL CTreePropSheet::SetPageIcon(CPropertyPage *pPage, CImageList &Images, int nImage)
 221 {
 222         HICON   hIcon = Images.ExtractIcon(nImage);
 223         if (!hIcon)
 224                 return FALSE;
 225
 226         return SetPageIcon(pPage, hIcon);
 227 }
 228
 229
 230 BOOL CTreePropSheet::DestroyPageIcon(CPropertyPage *pPage)
 231 {
 232         if (!pPage || !(pPage->m_psp.dwFlags&PSP_USEHICON) || !pPage->m_psp.hIcon)
 233                 return FALSE;
 234
 235         DestroyIcon(pPage->m_psp.hIcon);
 236         pPage->m_psp.dwFlags&= ~PSP_USEHICON;
 237         pPage->m_psp.hIcon = NULL;
 238
 239         return TRUE;
 240 }
 241
 242
 243 /////////////////////////////////////////////////////////////////////
 244 // Overridable implementation helpers
 245
 246 CString CTreePropSheet::GenerateEmptyPageMessage(LPCTSTR lpszEmptyPageMessage, LPCTSTR lpszCaption)
 247 {
 248         CString strMsg;
 249         strMsg.Format(lpszEmptyPageMessage, lpszCaption);
 250         return strMsg;
 251 }
 252
 253
 254 CTreeCtrl* CTreePropSheet::CreatePageTreeObject()
 255 {
 256         return new CTreeCtrl;
 257 }
 258
 259
 260 CPropPageFrame* CTreePropSheet::CreatePageFrame()
 261 {
 262         return new CPropPageFrameDefault;
 263 }
 264
 265
 266 /////////////////////////////////////////////////////////////////////
 267 // Implementation helpers
 268
 269 void CTreePropSheet::MoveChildWindows(int nDx, int nDy)
 270 {
 271         CWnd    *pWnd = GetWindow(GW_CHILD);
 272         while (pWnd)
 273         {
 274                 CRect   rect;
 275                 pWnd->GetWindowRect(rect);
 276                 rect.OffsetRect(nDx, nDy);
 277                 ScreenToClient(rect);
 278                 pWnd->MoveWindow(rect);
 279
 280                 pWnd = pWnd->GetNextWindow();
 281         }
 282 }
 283
 284
 285 void CTreePropSheet::RefillPageTree()
 286 {
 287         if (!IsWindow(m_hWnd))
 288                 return;
 289
 290         m_pwndPageTree->DeleteAllItems();
 291
 292         CTabCtrl        *pTabCtrl = GetTabControl();
 293         if (!IsWindow(pTabCtrl->GetSafeHwnd()))
 294         {
 295                 ASSERT(FALSE);
 296                 return;
 297         }
 298
 299         const int       nPageCount = pTabCtrl->GetItemCount();
 300
 301         // rebuild image list
 302         if (m_bTreeImages)
 303         {
 304                 for (int i = m_Images.GetImageCount()-1; i >= 0; --i)
 305                         m_Images.Remove(i);
 306
 307                 // add page images
 308                 CImageList      *pPageImages = pTabCtrl->GetImageList();
 309                 if (pPageImages)
 310                 {
 311                         for (int nImage = 0; nImage < pPageImages->GetImageCount(); ++nImage)
 312                         {
 313                                 HICON   hIcon = pPageImages->ExtractIcon(nImage);
 314                                 m_Images.Add(hIcon);
 315                                 DestroyIcon(hIcon);
 316                         }
 317                 }
 318
 319                 // add default images
 320                 if (m_DefaultImages.GetSafeHandle())
 321                 {
 322                         HICON   hIcon;
 323
 324                         // add default images
 325                         hIcon = m_DefaultImages.ExtractIcon(0);
 326                         if (hIcon)
 327                         {
 328                                 m_Images.Add(hIcon);
 329                                 DestroyIcon(hIcon);
 330                         }
 331                         hIcon = m_DefaultImages.ExtractIcon(1);
 332                         {
 333                                 m_Images.Add(hIcon);
 334                                 DestroyIcon(hIcon);
 335                         }
 336                 }
 337         }
 338
 339         // insert tree items
 340         for (int nPage = 0; nPage < nPageCount; ++nPage)
 341         {
 342                 // Get title and image of the page
 343                 CString strPagePath;
 344
 345                 TCITEM  ti;
 346                 SecureZeroMemory(&ti, sizeof(ti));
 347                 ti.mask = TCIF_TEXT|TCIF_IMAGE;
 348                 ti.cchTextMax = MAX_PATH;
 349                 ti.pszText = strPagePath.GetBuffer(ti.cchTextMax);
 350                 ASSERT(ti.pszText);
 351                 if (!ti.pszText)
 352                         return;
 353
 354                 pTabCtrl->GetItem(nPage, &ti);
 355                 strPagePath.ReleaseBuffer();
 356
 357                 // Create an item in the tree for the page
 358                 HTREEITEM       hItem = CreatePageTreeItem(ti.pszText);
 359                 ASSERT(hItem);
 360                 if (hItem)
 361                 {
 362                         m_pwndPageTree->SetItemData(hItem, nPage);
 363
 364                         // set image
 365                         if (m_bTreeImages)
 366                         {
 367                                 int     nImage = ti.iImage;
 368                                 if (nImage < 0 || nImage >= m_Images.GetImageCount())
 369                                         nImage = m_DefaultImages.GetSafeHandle()? m_Images.GetImageCount()-1 : -1;
 370
 371                                 m_pwndPageTree->SetItemImage(hItem, nImage, nImage);
 372                         }
 373                         m_pwndPageTree->Expand(m_pwndPageTree->GetParentItem(hItem), TVE_EXPAND);
 374                 }
 375         }
 376 }
 377
 378
 379 HTREEITEM CTreePropSheet::CreatePageTreeItem(LPCTSTR lpszPath, HTREEITEM hParent /* = TVI_ROOT */)
 380 {
 381         CString         strPath(lpszPath);
 382         CString         strTopMostItem(SplitPageTreePath(strPath));
 383
 384         // Check if an item with the given text does already exist
 385         HTREEITEM       hItem = NULL;
 386         HTREEITEM       hChild = m_pwndPageTree->GetChildItem(hParent);
 387         while (hChild)
 388         {
 389                 if (m_pwndPageTree->GetItemText(hChild) == strTopMostItem)
 390                 {
 391                         hItem = hChild;
 392                         break;
 393                 }
 394                 hChild = m_pwndPageTree->GetNextItem(hChild, TVGN_NEXT);
 395         }
 396
 397         // If item with that text does not already exist, create a new one
 398         if (!hItem)
 399         {
 400                 hItem = m_pwndPageTree->InsertItem(strTopMostItem, hParent);
 401                 m_pwndPageTree->SetItemData(hItem, (DWORD_PTR)-1);
 402                 if (!strPath.IsEmpty() && m_bTreeImages && m_DefaultImages.GetSafeHandle())
 403                         // set folder image
 404                         m_pwndPageTree->SetItemImage(hItem, m_Images.GetImageCount()-2, m_Images.GetImageCount()-2);
 405         }
 406         if (!hItem)
 407         {
 408                 ASSERT(FALSE);
 409                 return NULL;
 410         }
 411
 412         if (strPath.IsEmpty())
 413                 return hItem;
 414         else
 415                 return CreatePageTreeItem(strPath, hItem);
 416 }
 417
 418
 419 CString CTreePropSheet::SplitPageTreePath(CString &strRest)
 420 {
 421         int     nSeperatorPos = 0;
 422 #pragma warning(push)
 423 #pragma warning(disable: 4127)  // conditional expression constant
 424         while (TRUE)
 425         {
 426                 nSeperatorPos = strRest.Find(_T("::"), nSeperatorPos);
 427                 if (nSeperatorPos == -1)
 428                 {
 429                         CString strItem(strRest);
 430                         strRest.Empty();
 431                         return strItem;
 432                 }
 433                 else if (nSeperatorPos>0)
 434                 {
 435                         // if there is an odd number of backslashes infront of the
 436                         // seperator, than do not interpret it as separator
 437                         int     nBackslashCount = 0;
 438                         for (int nPos = nSeperatorPos-1; nPos >= 0 && strRest[nPos]==_T('\\'); --nPos, ++nBackslashCount);
 439                         if (nBackslashCount%2 == 0)
 440                                 break;
 441                         else
 442                                 ++nSeperatorPos;
 443                 }
 444         }
 445 #pragma warning(pop)
 446
 447         CString strItem(strRest.Left(nSeperatorPos));
 448         strItem.Replace(_T("\\::"), _T("::"));
 449         strItem.Replace(_T("\\\\"), _T("\\"));
 450         strRest = strRest.Mid(nSeperatorPos+2);
 451         return strItem;
 452 }
 453
 454
 455 BOOL CTreePropSheet::KillActiveCurrentPage()
 456 {
 457         HWND    hCurrentPage = PropSheet_GetCurrentPageHwnd(m_hWnd);
 458         if (!IsWindow(hCurrentPage))
 459         {
 460                 ASSERT(FALSE);
 461                 return TRUE;
 462         }
 463
 464         // Check if the current page is really active (if page is invisible
 465         // an virtual empty page is the active one.
 466         if (!::IsWindowVisible(hCurrentPage))
 467                 return TRUE;
 468
 469         // Try to deactivate current page
 470         PSHNOTIFY       pshn;
 471         pshn.hdr.code = PSN_KILLACTIVE;
 472         pshn.hdr.hwndFrom = m_hWnd;
 473         pshn.hdr.idFrom = GetDlgCtrlID();
 474         pshn.lParam = 0;
 475         if (::SendMessage(hCurrentPage, WM_NOTIFY, pshn.hdr.idFrom, (LPARAM)&pshn))
 476                 // current page does not allow page change
 477                 return FALSE;
 478
 479         // Hide the page
 480         ::ShowWindow(hCurrentPage, SW_HIDE);
 481
 482         return TRUE;
 483 }
 484
 485
 486 HTREEITEM CTreePropSheet::GetPageTreeItem(int nPage, HTREEITEM hRoot /* = TVI_ROOT */)
 487 {
 488         // Special handling for root case
 489         if (hRoot == TVI_ROOT)
 490                 hRoot = m_pwndPageTree->GetNextItem(NULL, TVGN_ROOT);
 491
 492         // Check parameters
 493         if (nPage < 0 || nPage >= GetPageCount())
 494         {
 495                 ASSERT(FALSE);
 496                 return NULL;
 497         }
 498
 499         if (hRoot == NULL)
 500         {
 501                 ASSERT(FALSE);
 502                 return NULL;
 503         }
 504
 505         // we are performing a simple linear search here, because we are
 506         // expecting only little data
 507         HTREEITEM       hItem = hRoot;
 508         while (hItem)
 509         {
 510                 if ((signed)m_pwndPageTree->GetItemData(hItem) == nPage)
 511                         return hItem;
 512                 if (m_pwndPageTree->ItemHasChildren(hItem))
 513                 {
 514                         HTREEITEM       hResult = GetPageTreeItem(nPage, m_pwndPageTree->GetNextItem(hItem, TVGN_CHILD));
 515                         if (hResult)
 516                                 return hResult;
 517                 }
 518
 519                 hItem = m_pwndPageTree->GetNextItem(hItem, TVGN_NEXT);
 520         }
 521
 522         // we've found nothing, if we arrive here
 523         return hItem;
 524 }
 525
 526
 527 BOOL CTreePropSheet::SelectPageTreeItem(int nPage)
 528 {
 529         HTREEITEM       hItem = GetPageTreeItem(nPage);
 530         if (!hItem)
 531                 return FALSE;
 532
 533         return m_pwndPageTree->SelectItem(hItem);
 534 }
 535
 536
 537 BOOL CTreePropSheet::SelectCurrentPageTreeItem()
 538 {
 539         CTabCtrl        *pTab = GetTabControl();
 540         if (!IsWindow(pTab->GetSafeHwnd()))
 541                 return FALSE;
 542
 543         return SelectPageTreeItem(pTab->GetCurSel());
 544 }
 545
 546
 547 void CTreePropSheet::UpdateCaption()
 548 {
 549         HWND                    hPage = PropSheet_GetCurrentPageHwnd(GetSafeHwnd());
 550         BOOL                    bRealPage = IsWindow(hPage) && ::IsWindowVisible(hPage);
 551         HTREEITEM       hItem = m_pwndPageTree->GetSelectedItem();
 552         if (!hItem)
 553                 return;
 554
 555         CString         strCaption = m_pwndPageTree->GetItemText(hItem);
 556
 557         // if empty page, then update empty page message
 558         if (!bRealPage)
 559                 m_pFrame->SetMsgText(GenerateEmptyPageMessage(m_strEmptyPageMessage, strCaption));
 560
 561         // if no captions are displayed, cancel here
 562         if (!m_pFrame->GetShowCaption())
 563                 return;
 564
 565         // get tab control, to the the images from
 566         CTabCtrl        *pTabCtrl = GetTabControl();
 567         if (!IsWindow(pTabCtrl->GetSafeHwnd()))
 568         {
 569                 ASSERT(FALSE);
 570                 return;
 571         }
 572
 573         if (m_bTreeImages)
 574         {
 575                 // get image from tree
 576                 int     nImage;
 577                 m_pwndPageTree->GetItemImage(hItem, nImage, nImage);
 578                 HICON   hIcon = m_Images.ExtractIcon(nImage);
 579                 m_pFrame->SetCaption(strCaption, hIcon);
 580                 if (hIcon)
 581                         DestroyIcon(hIcon);
 582         }
 583         else if (bRealPage)
 584         {
 585                 // get image from hidden (original) tab provided by the original
 586                 // implementation
 587                 CImageList      *pImages = pTabCtrl->GetImageList();
 588                 if (pImages)
 589                 {
 590                         TCITEM  ti;
 591                         SecureZeroMemory(&ti, sizeof(ti));
 592                         ti.mask = TCIF_IMAGE;
 593
 594                         HICON   hIcon = NULL;
 595                         if (pTabCtrl->GetItem((int)m_pwndPageTree->GetItemData(hItem), &ti))
 596                                 hIcon = pImages->ExtractIcon(ti.iImage);
 597
 598                         m_pFrame->SetCaption(strCaption, hIcon);
 599                         if (hIcon)
 600                                 DestroyIcon(hIcon);
 601                 }
 602                 else
 603                         m_pFrame->SetCaption(strCaption);
 604         }
 605         else
 606                 m_pFrame->SetCaption(strCaption);
 607 }
 608
 609
 610 void CTreePropSheet::ActivatePreviousPage()
 611 {
 612         if (!IsWindow(m_hWnd))
 613                 return;
 614
 615         if (!IsWindow(m_pwndPageTree->GetSafeHwnd()))
 616         {
 617                 // normal tab property sheet. Simply use page index
 618                 int     nPageIndex = GetActiveIndex();
 619                 if (nPageIndex<0 || nPageIndex>=GetPageCount())
 620                         return;
 621
 622                 int     nPrevIndex = (nPageIndex==0)? GetPageCount()-1 : nPageIndex-1;
 623                 SetActivePage(nPrevIndex);
 624         }
 625         else
 626         {
 627                 // property sheet with page tree.
 628                 // we need a more sophisticated handling here, than simply using
 629                 // the page index, because we won't skip empty pages.
 630                 // so we have to walk the page tree
 631                 HTREEITEM       hItem = m_pwndPageTree->GetSelectedItem();
 632                 ASSERT(hItem);
 633                 if (!hItem)
 634                         return;
 635
 636                 HTREEITEM       hPrevItem = NULL;
 637                 if ((hPrevItem=m_pwndPageTree->GetPrevSiblingItem(hItem))!=0)
 638                 {
 639                         while (m_pwndPageTree->ItemHasChildren(hPrevItem))
 640                         {
 641                                 hPrevItem = m_pwndPageTree->GetChildItem(hPrevItem);
 642                                 while (m_pwndPageTree->GetNextSiblingItem(hPrevItem))
 643                                         hPrevItem = m_pwndPageTree->GetNextSiblingItem(hPrevItem);
 644                         }
 645                 }
 646                 else
 647                         hPrevItem=m_pwndPageTree->GetParentItem(hItem);
 648
 649                 if (!hPrevItem)
 650                 {
 651                         // no prev item, so cycle to the last item
 652                         hPrevItem = m_pwndPageTree->GetRootItem();
 653
 654 #pragma warning(push)
 655 #pragma warning(disable: 4127)  // conditional expression constant
 656                         while (TRUE)
 657                         {
 658                                 while (m_pwndPageTree->GetNextSiblingItem(hPrevItem))
 659                                         hPrevItem = m_pwndPageTree->GetNextSiblingItem(hPrevItem);
 660
 661                                 if (m_pwndPageTree->ItemHasChildren(hPrevItem))
 662                                         hPrevItem = m_pwndPageTree->GetChildItem(hPrevItem);
 663                                 else
 664                                         break;
 665                         }
 666 #pragma warning(pop)
 667                 }
 668
 669                 if (hPrevItem)
 670                         m_pwndPageTree->SelectItem(hPrevItem);
 671         }
 672 }
 673
 674
 675 void CTreePropSheet::ActivateNextPage()
 676 {
 677         if (!IsWindow(m_hWnd))
 678                 return;
 679
 680         if (!IsWindow(m_pwndPageTree->GetSafeHwnd()))
 681         {
 682                 // normal tab property sheet. Simply use page index
 683                 int     nPageIndex = GetActiveIndex();
 684                 if (nPageIndex<0 || nPageIndex>=GetPageCount())
 685                         return;
 686
 687                 int     nNextIndex = (nPageIndex==GetPageCount()-1)? 0 : nPageIndex+1;
 688                 SetActivePage(nNextIndex);
 689         }
 690         else
 691         {
 692                 // property sheet with page tree.
 693                 // we need a more sophisticated handling here, than simply using
 694                 // the page index, because we won't skip empty pages.
 695                 // so we have to walk the page tree
 696                 HTREEITEM       hItem = m_pwndPageTree->GetSelectedItem();
 697                 ASSERT(hItem);
 698                 if (!hItem)
 699                         return;
 700
 701                 HTREEITEM       hNextItem = NULL;
 702                 if ((hNextItem=m_pwndPageTree->GetChildItem(hItem))!=0)
 703                         ;
 704                 else if ((hNextItem=m_pwndPageTree->GetNextSiblingItem(hItem))!=0)
 705                         ;
 706                 else if (m_pwndPageTree->GetParentItem(hItem))
 707                 {
 708                         while (!hNextItem)
 709                         {
 710                                 hItem = m_pwndPageTree->GetParentItem(hItem);
 711                                 if (!hItem)
 712                                         break;
 713
 714                                 hNextItem       = m_pwndPageTree->GetNextSiblingItem(hItem);
 715                         }
 716                 }
 717
 718                 if (!hNextItem)
 719                         // no next item -- so cycle to the first item
 720                         hNextItem = m_pwndPageTree->GetRootItem();
 721
 722                 if (hNextItem)
 723                         m_pwndPageTree->SelectItem(hNextItem);
 724         }
 725 }
 726
 727
 728 /////////////////////////////////////////////////////////////////////
 729 // Overridings
 730
 731 BOOL CTreePropSheet::OnInitDialog()
 732 {
 733         if (m_bTreeViewMode)
 734         {
 735                 // be sure, there are no stacked tabs, because otherwise the
 736                 // page caption will be to large in tree view mode
 737                 EnableStackedTabs(FALSE);
 738
 739                 // Initialize image list.
 740                 if (m_DefaultImages.GetSafeHandle())
 741                 {
 742                         IMAGEINFO       ii;
 743                         m_DefaultImages.GetImageInfo(0, &ii);
 744                         if (ii.hbmImage) DeleteObject(ii.hbmImage);
 745                         if (ii.hbmMask) DeleteObject(ii.hbmMask);
 746                         m_Images.Create(ii.rcImage.right-ii.rcImage.left, ii.rcImage.bottom-ii.rcImage.top, ILC_COLOR32|ILC_MASK, 0, 1);
 747                 }
 748                 else
 749                         m_Images.Create(16, 16, ILC_COLOR32|ILC_MASK, 0, 1);
 750         }
 751
 752         // perform default implementation
 753         BOOL bResult = CPropertySheet::OnInitDialog();
 754         HighColorTab::UpdateImageList(*this);
 755
 756         if (!m_bTreeViewMode)
 757                 // stop here, if we would like to use tabs
 758                 return bResult;
 759
 760         // Get tab control...
 761         CTabCtrl        *pTab = GetTabControl();
 762         if (!IsWindow(pTab->GetSafeHwnd()))
 763         {
 764                 ASSERT(FALSE);
 765                 return bResult;
 766         }
 767
 768         // ... and hide it
 769         pTab->ShowWindow(SW_HIDE);
 770         pTab->EnableWindow(FALSE);
 771
 772         // Place another (empty) tab ctrl, to get a frame instead
 773         CRect   rectFrame;
 774         pTab->GetWindowRect(rectFrame);
 775         ScreenToClient(rectFrame);
 776
 777         m_pFrame = CreatePageFrame();
 778         if (!m_pFrame)
 779         {
 780                 ASSERT(FALSE);
 781                 AfxThrowMemoryException();
 782         }
 783         m_pFrame->Create(WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, rectFrame, this, 0xFFFF);
 784         m_pFrame->ShowCaption(m_bPageCaption);
 785
 786         // Lets make place for the tree ctrl
 787         const int       nTreeWidth = m_nPageTreeWidth;
 788         const int       nTreeSpace = 5;
 789
 790         CRect   rectSheet;
 791         GetWindowRect(rectSheet);
 792         rectSheet.right+= nTreeWidth;
 793         SetWindowPos(NULL, -1, -1, rectSheet.Width(), rectSheet.Height(), SWP_NOZORDER|SWP_NOMOVE);
 794         CenterWindow();
 795
 796         MoveChildWindows(nTreeWidth, 0);
 797
 798         // Lets calculate the rectangle for the tree ctrl
 799         CRect   rectTree(rectFrame);
 800         rectTree.right = rectTree.left + nTreeWidth - nTreeSpace;
 801
 802         // calculate caption height
 803         CTabCtrl        wndTabCtrl;
 804         wndTabCtrl.Create(WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS, rectFrame, this, 0x1234);
 805         wndTabCtrl.InsertItem(0, _T(""));
 806         CRect   rectFrameCaption;
 807         wndTabCtrl.GetItemRect(0, rectFrameCaption);
 808         wndTabCtrl.DestroyWindow();
 809         m_pFrame->SetCaptionHeight(rectFrameCaption.Height());
 810
 811         // if no caption should be displayed, make the window smaller in
 812         // height
 813         if (!m_bPageCaption)
 814         {
 815                 // make frame smaller
 816                 m_pFrame->GetWnd()->GetWindowRect(rectFrame);
 817                 ScreenToClient(rectFrame);
 818                 rectFrame.top+= rectFrameCaption.Height();
 819                 m_pFrame->GetWnd()->MoveWindow(rectFrame);
 820
 821                 // move all child windows up
 822                 MoveChildWindows(0, -rectFrameCaption.Height());
 823
 824                 // modify rectangle for the tree ctrl
 825                 rectTree.bottom-= rectFrameCaption.Height();
 826
 827                 // make us smaller
 828                 CRect   rect;
 829                 GetWindowRect(rect);
 830                 rect.top+= rectFrameCaption.Height()/2;
 831                 rect.bottom-= rectFrameCaption.Height()-rectFrameCaption.Height()/2;
 832                 if (GetParent())
 833                         GetParent()->ScreenToClient(rect);
 834                 MoveWindow(rect);
 835         }
 836
 837         // finally create the tree control
 838         const DWORD     dwTreeStyle = TVS_SHOWSELALWAYS|TVS_TRACKSELECT|TVS_HASLINES|TVS_LINESATROOT|TVS_HASBUTTONS;
 839         m_pwndPageTree = CreatePageTreeObject();
 840         if (!m_pwndPageTree)
 841         {
 842                 ASSERT(FALSE);
 843                 AfxThrowMemoryException();
 844         }
 845
 846         // MFC7-support here (Thanks to Rainer Wollgarten)
 847         // YT: Cast tree control to CWnd and calls CWnd::CreateEx in all cases (VC 6 and7).
 848         ((CWnd*)m_pwndPageTree)->CreateEx(
 849                 WS_EX_CLIENTEDGE|WS_EX_NOPARENTNOTIFY|TVS_EX_DOUBLEBUFFER,
 850                 _T("SysTreeView32"), _T("PageTree"),
 851                 WS_TABSTOP|WS_CHILD|WS_VISIBLE|dwTreeStyle,
 852                 rectTree, this, s_unPageTreeId);
 853
 854         if (m_bTreeImages)
 855         {
 856                 m_pwndPageTree->SetImageList(&m_Images, TVSIL_NORMAL);
 857                 m_pwndPageTree->SetImageList(&m_Images, TVSIL_STATE);
 858         }
 859         SetWindowTheme(m_pwndPageTree->GetSafeHwnd(), L"Explorer", NULL);
 860
 861         // Fill the tree ctrl
 862         RefillPageTree();
 863
 864         // Select item for the current page
 865         if (pTab->GetCurSel() > -1)
 866                 SelectPageTreeItem(pTab->GetCurSel());
 867
 868         return bResult;
 869 }
 870
 871
 872 void CTreePropSheet::OnDestroy()
 873 {
 874         CPropertySheet::OnDestroy();
 875
 876         if (m_Images.GetSafeHandle())
 877                 m_Images.DeleteImageList();
 878
 879         delete m_pwndPageTree;
 880         m_pwndPageTree = NULL;
 881
 882         delete m_pFrame;
 883         m_pFrame = NULL;
 884 }
 885
 886
 887 LRESULT CTreePropSheet::OnAddPage(WPARAM wParam, LPARAM lParam)
 888 {
 889         LRESULT lResult = DefWindowProc(PSM_ADDPAGE, wParam, lParam);
 890         if (!m_bTreeViewMode)
 891                 return lResult;
 892
 893         RefillPageTree();
 894         SelectCurrentPageTreeItem();
 895
 896         return lResult;
 897 }
 898
 899
 900 LRESULT CTreePropSheet::OnRemovePage(WPARAM wParam, LPARAM lParam)
 901 {
 902         LRESULT lResult = DefWindowProc(PSM_REMOVEPAGE, wParam, lParam);
 903         if (!m_bTreeViewMode)
 904                 return lResult;
 905
 906         RefillPageTree();
 907         SelectCurrentPageTreeItem();
 908
 909         return lResult;
 910 }
 911
 912
 913 LRESULT CTreePropSheet::OnSetCurSel(WPARAM wParam, LPARAM lParam)
 914 {
 915         LRESULT lResult = DefWindowProc(PSM_SETCURSEL, wParam, lParam);
 916         if (!m_bTreeViewMode)
 917                 return lResult;
 918
 919         SelectCurrentPageTreeItem();
 920         UpdateCaption();
 921         return lResult;
 922 }
 923
 924 LRESULT CTreePropSheet::OnSetCurSelId(WPARAM wParam, LPARAM lParam)
 925 {
 926         return OnSetCurSel(wParam, lParam);
 927 }
 928
 929
 930 void CTreePropSheet::OnPageTreeSelChanging(NMHDR *pNotifyStruct, LRESULT *plResult)
 931 {
 932         *plResult = 0;
 933         if (m_bPageTreeSelChangedActive)
 934                 return;
 935         else
 936                 m_bPageTreeSelChangedActive = TRUE;
 937
 938         NMTREEVIEW      *pTvn = reinterpret_cast<NMTREEVIEW*>(pNotifyStruct);
 939         int nPage = (int)m_pwndPageTree->GetItemData(pTvn->itemNew.hItem);
 940         if (nPage < 0)
 941         {
 942                 HTREEITEM nextItem = m_pwndPageTree->GetChildItem(pTvn->itemNew.hItem);
 943                 nPage = (int)m_pwndPageTree->GetItemData(nextItem);
 944         }
 945         BOOL                            bResult;
 946         if (nPage >= (int)m_pwndPageTree->GetCount())
 947                 bResult = KillActiveCurrentPage();
 948         else
 949                 bResult = SetActivePage((int)nPage);
 950
 951         if (!bResult)
 952                 // prevent selection to change
 953                 *plResult = TRUE;
 954
 955         // Set focus to tree ctrl (I guess that's what the user expects)
 956         m_pwndPageTree->SetFocus();
 957
 958         m_bPageTreeSelChangedActive = FALSE;
 959
 960         return;
 961 }
 962
 963
 964 void CTreePropSheet::OnPageTreeSelChanged(NMHDR * /*pNotifyStruct*/, LRESULT *plResult)
 965 {
 966         *plResult = 0;
 967
 968         UpdateCaption();
 969
 970         return;
 971 }
 972
 973
 974 LRESULT CTreePropSheet::OnIsDialogMessage(WPARAM wParam, LPARAM lParam)
 975 {
 976         MSG     *pMsg = reinterpret_cast<MSG*>(lParam);
 977         if (pMsg->message==WM_KEYDOWN && pMsg->wParam==VK_TAB && GetKeyState(VK_CONTROL)&0x8000)
 978         {
 979                 if (GetKeyState(VK_SHIFT)&0x8000)
 980                         ActivatePreviousPage();
 981                 else
 982                         ActivateNextPage();
 983                 return TRUE;
 984         }
 985
 986
 987         return CPropertySheet::DefWindowProc(PSM_ISDIALOGMESSAGE, wParam, lParam);
 988 }
 989
 990 } //namespace TreePropSheet