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, 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             m_selection = n;
 371             m_list->Select(n);
 372             m_list->Focus(n);
 373
 374             // program allows the page change
 375             event.SetEventType(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED);
 376             (void)GetEventHandler()->ProcessEvent(event);
 377         }
 378     }
 379
 380     return oldSel;
 381 }
 382
 383 // ----------------------------------------------------------------------------
 384 // adding/removing the pages
 385 // ----------------------------------------------------------------------------
 386
 387 bool
 388 wxListbook::InsertPage(size_t n,
 389                        wxWindow *page,
 390                        const wxString& text,
 391                        bool bSelect,
 392                        int imageId)
 393 {
 394     if ( !wxBookCtrl::InsertPage(n, page, text, bSelect, imageId) )
 395         return false;
 396
 397     m_list->InsertItem(n, text, imageId);
 398
 399     // we should always have some selection if possible
 400     if ( bSelect || (m_selection == wxNOT_FOUND) )
 401     {
 402         SetSelection(n);
 403     }
 404     else // don't select this page
 405     {
 406         // it will be shown only when selected
 407         page->Hide();
 408     }
 409
 410     InvalidateBestSize();
 411     return true;
 412 }
 413
 414 wxWindow *wxListbook::DoRemovePage(size_t page)
 415 {
 416     const int page_count = GetPageCount();
 417     wxWindow *win = wxBookCtrl::DoRemovePage(page);
 418
 419     if ( win )
 420     {
 421         m_list->DeleteItem(page);
 422
 423         if (m_selection >= (int)page)
 424         {
 425             // force new sel valid if possible
 426             int sel = m_selection - 1;
 427             if (page_count == 1)
 428                 sel = wxNOT_FOUND;
 429             else if ((page_count == 2) || (sel == -1))
 430                 sel = 0;
 431
 432             // force sel invalid if deleting current page - don't try to hide it
 433             m_selection = (m_selection == (int)page) ? wxNOT_FOUND : m_selection - 1;
 434
 435             if ((sel != wxNOT_FOUND) && (sel != m_selection))
 436                 SetSelection(sel);
 437         }
 438     }
 439
 440     return win;
 441 }
 442
 443
 444 bool wxListbook::DeleteAllPages()
 445 {
 446     m_list->DeleteAllItems();
 447     return wxBookCtrl::DeleteAllPages();
 448 }
 449
 450 // ----------------------------------------------------------------------------
 451 // wxListbook events
 452 // ----------------------------------------------------------------------------
 453
 454 void wxListbook::OnListSelected(wxListEvent& eventList)
 455 {
 456     const int selNew = eventList.GetIndex();
 457     const int selOld = m_selection;
 458
 459     if ( selNew == m_selection )
 460     {
 461         // this event can only come from our own Select(m_selection) below
 462         // which we call when the page change is vetoed, so we should simply
 463         // ignore it
 464         return;
 465     }
 466
 467     // first send "change in progress" event which may be vetoed by user
 468     wxListbookEvent eventIng(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING, GetId());
 469
 470     eventIng.SetEventObject(this);
 471     eventIng.SetSelection(selNew);
 472     eventIng.SetOldSelection(selOld);
 473     if ( GetEventHandler()->ProcessEvent(eventIng) && !eventIng.IsAllowed() )
 474     {
 475         m_list->Select(m_selection);
 476         return;
 477     }
 478
 479     // change allowed: do change the page and notify the user about it
 480     SetSelection(selNew);
 481
 482     wxListbookEvent eventEd(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED, GetId());
 483
 484     eventEd.SetEventObject(this);
 485     eventEd.SetSelection(selNew);
 486     eventEd.SetOldSelection(selOld);
 487
 488     (void)GetEventHandler()->ProcessEvent(eventEd);
 489 }
 490
 491 #endif // wxUSE_LISTBOOK
 492