src/generic/listbkg.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/listbkg.cpp
   3 // Purpose:     generic implementation of wxListbook
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     19.08.03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Vadim Zeitlin <vadim@wxwindows.org>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "listbook.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #if wxUSE_LISTBOOK
  32
  33 #include "wx/listctrl.h"
  34 #include "wx/statline.h"
  35 #include "wx/listbook.h"
  36 #include "wx/imaglist.h"
  37 #include "wx/settings.h"
  38
  39 // ----------------------------------------------------------------------------
  40 // constants
  41 // ----------------------------------------------------------------------------
  42
  43 // margin between the list and the page, should be bigger than wxStaticLine
  44 // size
  45 const wxCoord MARGIN = 5;
  46
  47 // ----------------------------------------------------------------------------
  48 // various wxWidgets macros
  49 // ----------------------------------------------------------------------------
  50
  51 // check that the page index is valid
  52 #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount())
  53
  54 // ----------------------------------------------------------------------------
  55 // event table
  56 // ----------------------------------------------------------------------------
  57
  58 IMPLEMENT_DYNAMIC_CLASS(wxListbook, wxControl)
  59 IMPLEMENT_DYNAMIC_CLASS(wxListbookEvent, wxNotifyEvent)
  60
  61 const wxEventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING = wxNewEventType();
  62 const wxEventType wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED = wxNewEventType();
  63 const int wxID_LISTBOOKLISTVIEW = wxNewId();
  64
  65 BEGIN_EVENT_TABLE(wxListbook, wxBookCtrl)
  66     EVT_SIZE(wxListbook::OnSize)
  67     EVT_LIST_ITEM_SELECTED(wxID_LISTBOOKLISTVIEW, wxListbook::OnListSelected)
  68 END_EVENT_TABLE()
  69
  70 // ============================================================================
  71 // wxListbook implementation
  72 // ============================================================================
  73
  74 // ----------------------------------------------------------------------------
  75 // wxListbook creation
  76 // ----------------------------------------------------------------------------
  77
  78 void wxListbook::Init()
  79 {
  80     m_list = NULL;
  81 #if wxUSE_LINE_IN_LISTBOOK
  82     m_line = NULL;
  83 #endif // wxUSE_LINE_IN_LISTBOOK
  84     m_selection = wxNOT_FOUND;
  85 }
  86
  87 bool
  88 wxListbook::Create(wxWindow *parent,
  89                    wxWindowID id,
  90                    const wxPoint& pos,
  91                    const wxSize& size,
  92                    long style,
  93                    const wxString& name)
  94 {
  95     if ( (style & wxLB_ALIGN_MASK) == wxLB_DEFAULT )
  96     {
  97 #ifdef __WXMAC__
  98         style |= wxLB_TOP;
  99 #else // !__WXMAC__
 100         style |= wxLB_LEFT;
 101 #endif // __WXMAC__/!__WXMAC__
 102     }
 103
 104     // no border for this control, it doesn't look nice together with
 105     // wxListCtrl border
 106     style &= ~wxBORDER_MASK;
 107     style |= wxBORDER_NONE;
 108
 109     if ( !wxControl::Create(parent, id, pos, size, style,
 110                             wxDefaultValidator, name) )
 111         return false;
 112
 113     m_list = new wxListView
 114                  (
 115                     this,
 116                     wxID_LISTBOOKLISTVIEW,
 117                     wxDefaultPosition,
 118                     wxDefaultSize,
 119                     wxLC_ICON | wxLC_SINGLE_SEL |
 120                         (IsVertical() ? wxLC_ALIGN_LEFT : wxLC_ALIGN_TOP)
 121                  );
 122
 123 #if wxUSE_LINE_IN_LISTBOOK
 124     m_line = new wxStaticLine
 125                  (
 126                     this,
 127                     wxID_ANY,
 128                     wxDefaultPosition,
 129                     wxDefaultSize,
 130                     IsVertical() ? wxLI_HORIZONTAL : wxLI_VERTICAL
 131                  );
 132 #endif // wxUSE_LINE_IN_LISTBOOK
 133
 134 #ifdef __WXMSW__
 135     // On XP with themes enabled the GetViewRect used in GetListSize to
 136     // determine the space needed for the list view will incorrectly return
 137     // (0,0,0,0) the first time.  So send a pending event so OnSize wiull be
 138     // called again after the window is ready to go.  Technically we don't
 139     // need to do this on non-XP windows, but if things are already sized
 140     // correctly then nothing changes and so there is no harm.
 141     wxSizeEvent evt;
 142     GetEventHandler()->AddPendingEvent(evt);
 143 #endif
 144     return true;
 145 }
 146
 147 // ----------------------------------------------------------------------------
 148 // wxListbook geometry management
 149 // ----------------------------------------------------------------------------
 150
 151 wxSize wxListbook::GetListSize() const
 152 {
 153     const wxSize sizeClient = GetClientSize(),
 154                  sizeList = m_list->GetViewRect().GetSize();
 155
 156     wxSize size;
 157     if ( IsVertical() )
 158     {
 159         size.x = sizeClient.x;
 160         size.y = sizeList.y;
 161     }
 162     else // left/right aligned
 163     {
 164         size.x = sizeList.x;
 165         size.y = sizeClient.y;
 166     }
 167
 168     return size;
 169 }
 170
 171 wxRect wxListbook::GetPageRect() const
 172 {
 173     const wxSize sizeList = m_list->GetSize();
 174
 175     wxRect rectPage(wxPoint(0, 0), GetClientSize());
 176     switch ( GetWindowStyle() & wxLB_ALIGN_MASK )
 177     {
 178         default:
 179             wxFAIL_MSG( _T("unexpected wxListbook alignment") );
 180             // fall through
 181
 182         case wxLB_TOP:
 183             rectPage.y = sizeList.y + MARGIN;
 184             // fall through
 185
 186         case wxLB_BOTTOM:
 187             rectPage.height -= sizeList.y + MARGIN;
 188             break;
 189
 190         case wxLB_LEFT:
 191             rectPage.x = sizeList.x + MARGIN;
 192             // fall through
 193
 194         case wxLB_RIGHT:
 195             rectPage.width -= sizeList.x + MARGIN;
 196             break;
 197     }
 198
 199     return rectPage;
 200 }
 201
 202 void wxListbook::OnSize(wxSizeEvent& event)
 203 {
 204     event.Skip();
 205
 206     if ( !m_list )
 207     {
 208         // we're not fully created yet
 209         return;
 210     }
 211
 212     // resize the list control and the page area to fit inside our new size
 213     const wxSize sizeClient = GetClientSize(),
 214                  sizeList = GetListSize();
 215
 216     wxPoint posList;
 217     switch ( GetWindowStyle() & wxLB_ALIGN_MASK )
 218     {
 219         default:
 220             wxFAIL_MSG( _T("unexpected wxListbook alignment") );
 221             // fall through
 222
 223         case wxLB_TOP:
 224         case wxLB_LEFT:
 225             // posList is already ok
 226             break;
 227
 228         case wxLB_BOTTOM:
 229             posList.y = sizeClient.y - sizeList.y;
 230             break;
 231
 232         case wxLB_RIGHT:
 233             posList.x = sizeClient.x - sizeList.x;
 234             break;
 235     }
 236
 237     m_list->Move(posList.x, posList.y);
 238     m_list->SetClientSize(sizeList.x, sizeList.y);
 239
 240 #if wxUSE_LINE_IN_LISTBOOK
 241     if ( m_line )
 242     {
 243         wxRect rectLine(wxPoint(0, 0), sizeClient);
 244
 245         switch ( GetWindowStyle() & wxLB_ALIGN_MASK )
 246         {
 247             case wxLB_TOP:
 248                 rectLine.y = sizeList.y + 1;
 249                 rectLine.height = MARGIN - 2;
 250                 break;
 251
 252             case wxLB_BOTTOM:
 253                 rectLine.height = MARGIN - 2;
 254                 rectLine.y = sizeClient.y - sizeList.y - rectLine.height;
 255                 break;
 256
 257             case wxLB_LEFT:
 258                 rectLine.x = sizeList.x + 1;
 259                 rectLine.width = MARGIN - 2;
 260                 break;
 261
 262             case wxLB_RIGHT:
 263                 rectLine.width = MARGIN - 2;
 264                 rectLine.x = sizeClient.x - sizeList.x - rectLine.width;
 265                 break;
 266         }
 267
 268         m_line->SetSize(rectLine);
 269     }
 270 #endif // wxUSE_LINE_IN_LISTBOOK
 271
 272     // resize the currently shown page
 273     if (m_selection != wxNOT_FOUND )
 274     {
 275         wxWindow *page = m_pages[m_selection];
 276         wxCHECK_RET( page, _T("NULL page in wxListbook?") );
 277         page->SetSize(GetPageRect());
 278         }
 279 }
 280
 281 wxSize wxListbook::CalcSizeFromPage(const wxSize& sizePage) const
 282 {
 283     // we need to add the size of the list control and the margin
 284     const wxSize sizeList = GetListSize();
 285
 286     wxSize size = sizePage;
 287     if ( IsVertical() )
 288     {
 289         size.y += sizeList.y + MARGIN;
 290     }
 291     else // left/right aligned
 292     {
 293         size.x += sizeList.x + MARGIN;
 294     }
 295
 296     return size;
 297 }
 298
 299
 300 // ----------------------------------------------------------------------------
 301 // accessing the pages
 302 // ----------------------------------------------------------------------------
 303
 304 bool wxListbook::SetPageText(size_t n, const wxString& strText)
 305 {
 306     m_list->SetItemText(n, strText);
 307
 308     return true;
 309 }
 310
 311 wxString wxListbook::GetPageText(size_t n) const
 312 {
 313     return m_list->GetItemText(n);
 314 }
 315
 316 int wxListbook::GetPageImage(size_t WXUNUSED(n)) const
 317 {
 318     wxFAIL_MSG( _T("wxListbook::GetPageImage() not implemented") );
 319
 320     return -1;
 321 }
 322
 323 bool wxListbook::SetPageImage(size_t n, int imageId)
 324 {
 325     return m_list->SetItemImage(n, imageId);
 326 }
 327
 328 // ----------------------------------------------------------------------------
 329 // image list stuff
 330 // ----------------------------------------------------------------------------
 331
 332 void wxListbook::SetImageList(wxImageList *imageList)
 333 {
 334     m_list->SetImageList(imageList, wxIMAGE_LIST_NORMAL);
 335
 336     wxBookCtrl::SetImageList(imageList);
 337 }
 338
 339 // ----------------------------------------------------------------------------
 340 // selection
 341 // ----------------------------------------------------------------------------
 342
 343 int wxListbook::GetSelection() const
 344 {
 345     return m_selection;
 346 }
 347
 348 int wxListbook::SetSelection(size_t n)
 349 {
 350     wxCHECK_MSG( IS_VALID_PAGE(n), wxNOT_FOUND,
 351                  wxT("invalid page index in wxListbook::SetSelection()") );
 352
 353     const int oldSel = m_selection;
 354
 355     if ( int(n) != m_selection )
 356     {
 357         wxListbookEvent event(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING, m_windowId);
 358         event.SetSelection(n);
 359         event.SetOldSelection(m_selection);
 360         event.SetEventObject(this);
 361         if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
 362         {
 363             if ( m_selection != wxNOT_FOUND )
 364                 m_pages[m_selection]->Hide();
 365
 366             wxWindow *page = m_pages[n];
 367             page->SetSize(GetPageRect());
 368             page->Show();
 369
 370             // change m_selection now to ignore the selection change event
 371             m_selection = n;
 372             m_list->Select(n);
 373             m_list->Focus(n);
 374
 375             // program allows the page change
 376             event.SetEventType(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED);
 377             (void)GetEventHandler()->ProcessEvent(event);
 378         }
 379     }
 380
 381     return oldSel;
 382 }
 383
 384 // ----------------------------------------------------------------------------
 385 // adding/removing the pages
 386 // ----------------------------------------------------------------------------
 387
 388 bool
 389 wxListbook::InsertPage(size_t n,
 390                        wxWindow *page,
 391                        const wxString& text,
 392                        bool bSelect,
 393                        int imageId)
 394 {
 395     if ( !wxBookCtrl::InsertPage(n, page, text, bSelect, imageId) )
 396         return false;
 397
 398     m_list->InsertItem(n, text, imageId);
 399
 400     // if the inserted page is before the selected one, we must update the
 401     // index of the selected page
 402     if ( int(n) <= m_selection )
 403     {
 404         // one extra page added
 405         m_selection++;
 406         m_list->Select(m_selection);
 407         m_list->Focus(m_selection);
 408     }
 409
 410     // some page should be selected: either this one or the first one if there
 411     // is still no selection
 412     int selNew = -1;
 413     if ( bSelect )
 414         selNew = n;
 415     else if ( m_selection == -1 )
 416         selNew = 0;
 417
 418     if ( selNew != m_selection )
 419         page->Hide();
 420
 421     if ( selNew != -1 )
 422         SetSelection(selNew);
 423
 424     InvalidateBestSize();
 425     return true;
 426 }
 427
 428 wxWindow *wxListbook::DoRemovePage(size_t page)
 429 {
 430     const int page_count = GetPageCount();
 431     wxWindow *win = wxBookCtrl::DoRemovePage(page);
 432
 433     if ( win )
 434     {
 435         m_list->DeleteItem(page);
 436
 437         if (m_selection >= (int)page)
 438         {
 439             // force new sel valid if possible
 440             int sel = m_selection - 1;
 441             if (page_count == 1)
 442                 sel = wxNOT_FOUND;
 443             else if ((page_count == 2) || (sel == -1))
 444                 sel = 0;
 445
 446             // force sel invalid if deleting current page - don't try to hide it
 447             m_selection = (m_selection == (int)page) ? wxNOT_FOUND : m_selection - 1;
 448
 449             if ((sel != wxNOT_FOUND) && (sel != m_selection))
 450                 SetSelection(sel);
 451         }
 452     }
 453
 454     return win;
 455 }
 456
 457
 458 bool wxListbook::DeleteAllPages()
 459 {
 460     m_list->DeleteAllItems();
 461     return wxBookCtrl::DeleteAllPages();
 462 }
 463
 464 // ----------------------------------------------------------------------------
 465 // wxListbook events
 466 // ----------------------------------------------------------------------------
 467
 468 void wxListbook::OnListSelected(wxListEvent& eventList)
 469 {
 470     const int selNew = eventList.GetIndex();
 471
 472     if ( selNew == m_selection )
 473     {
 474         // this event can only come from our own Select(m_selection) below
 475         // which we call when the page change is vetoed, so we should simply
 476         // ignore it
 477         return;
 478     }
 479
 480     SetSelection(selNew);
 481
 482     // change wasn't allowed, return to previous state
 483     if (m_selection != selNew)
 484     {
 485         m_list->Select(m_selection);
 486         m_list->Focus(m_selection);
 487     }
 488 }
 489
 490 #endif // wxUSE_LISTBOOK
 491