]>
Commit | Line | Data |
---|---|---|
1 | /////////////////////////////////////////////////////////////////////////////// | |
2 | // Name: src/msw/notebook.cpp | |
3 | // Purpose: implementation of wxNotebook | |
4 | // Author: Vadim Zeitlin | |
5 | // Modified by: | |
6 | // Created: 11.06.98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
9 | // Licence: wxWindows licence | |
10 | /////////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | // For compilers that support precompilation, includes "wx.h". | |
13 | #include "wx/wxprec.h" | |
14 | ||
15 | #ifdef __BORLANDC__ | |
16 | #pragma hdrstop | |
17 | #endif | |
18 | ||
19 | #if wxUSE_NOTEBOOK | |
20 | ||
21 | #include "wx/notebook.h" | |
22 | ||
23 | #ifndef WX_PRECOMP | |
24 | #include "wx/string.h" | |
25 | #include "wx/dc.h" | |
26 | #include "wx/log.h" | |
27 | #include "wx/event.h" | |
28 | #include "wx/app.h" | |
29 | #include "wx/dcclient.h" | |
30 | #include "wx/dcmemory.h" | |
31 | #endif // WX_PRECOMP | |
32 | ||
33 | #include "wx/imaglist.h" | |
34 | #include "wx/control.h" | |
35 | #include "wx/sysopt.h" | |
36 | ||
37 | #include "wx/msw/private.h" | |
38 | ||
39 | #include <windowsx.h> | |
40 | ||
41 | #include <commctrl.h> | |
42 | ||
43 | #include "wx/msw/winundef.h" | |
44 | ||
45 | #if wxUSE_UXTHEME | |
46 | #include "wx/msw/uxtheme.h" | |
47 | #endif | |
48 | ||
49 | // ---------------------------------------------------------------------------- | |
50 | // macros | |
51 | // ---------------------------------------------------------------------------- | |
52 | ||
53 | // check that the page index is valid | |
54 | #define IS_VALID_PAGE(nPage) ((nPage) < GetPageCount()) | |
55 | ||
56 | // you can set USE_NOTEBOOK_ANTIFLICKER to 0 for desktop Windows versions too | |
57 | // to disable code whih results in flicker-less notebook redrawing at the | |
58 | // expense of some extra GDI resource consumption | |
59 | #ifdef __WXWINCE__ | |
60 | // notebooks are never resized under CE anyhow | |
61 | #define USE_NOTEBOOK_ANTIFLICKER 0 | |
62 | #else | |
63 | #define USE_NOTEBOOK_ANTIFLICKER 1 | |
64 | #endif | |
65 | ||
66 | // ---------------------------------------------------------------------------- | |
67 | // constants | |
68 | // ---------------------------------------------------------------------------- | |
69 | ||
70 | // This is a work-around for missing defines in gcc-2.95 headers | |
71 | #ifndef TCS_RIGHT | |
72 | #define TCS_RIGHT 0x0002 | |
73 | #endif | |
74 | ||
75 | #ifndef TCS_VERTICAL | |
76 | #define TCS_VERTICAL 0x0080 | |
77 | #endif | |
78 | ||
79 | #ifndef TCS_BOTTOM | |
80 | #define TCS_BOTTOM TCS_RIGHT | |
81 | #endif | |
82 | ||
83 | // ---------------------------------------------------------------------------- | |
84 | // global variables | |
85 | // ---------------------------------------------------------------------------- | |
86 | ||
87 | #if USE_NOTEBOOK_ANTIFLICKER | |
88 | ||
89 | // the pointer to standard spin button wnd proc | |
90 | static WXFARPROC gs_wndprocNotebookSpinBtn = (WXFARPROC)NULL; | |
91 | ||
92 | // the pointer to standard tab control wnd proc | |
93 | static WXFARPROC gs_wndprocNotebook = (WXFARPROC)NULL; | |
94 | ||
95 | LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd, | |
96 | UINT message, | |
97 | WPARAM wParam, | |
98 | LPARAM lParam); | |
99 | ||
100 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
101 | ||
102 | // ---------------------------------------------------------------------------- | |
103 | // event table | |
104 | // ---------------------------------------------------------------------------- | |
105 | ||
106 | #include "wx/listimpl.cpp" | |
107 | ||
108 | WX_DEFINE_LIST( wxNotebookPageInfoList ) | |
109 | ||
110 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED) | |
111 | DEFINE_EVENT_TYPE(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING) | |
112 | ||
113 | BEGIN_EVENT_TABLE(wxNotebook, wxControl) | |
114 | EVT_NOTEBOOK_PAGE_CHANGED(wxID_ANY, wxNotebook::OnSelChange) | |
115 | EVT_SIZE(wxNotebook::OnSize) | |
116 | EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey) | |
117 | ||
118 | #if USE_NOTEBOOK_ANTIFLICKER | |
119 | EVT_ERASE_BACKGROUND(wxNotebook::OnEraseBackground) | |
120 | EVT_PAINT(wxNotebook::OnPaint) | |
121 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
122 | END_EVENT_TABLE() | |
123 | ||
124 | #if wxUSE_EXTENDED_RTTI | |
125 | WX_DEFINE_FLAGS( wxNotebookStyle ) | |
126 | ||
127 | wxBEGIN_FLAGS( wxNotebookStyle ) | |
128 | // new style border flags, we put them first to | |
129 | // use them for streaming out | |
130 | wxFLAGS_MEMBER(wxBORDER_SIMPLE) | |
131 | wxFLAGS_MEMBER(wxBORDER_SUNKEN) | |
132 | wxFLAGS_MEMBER(wxBORDER_DOUBLE) | |
133 | wxFLAGS_MEMBER(wxBORDER_RAISED) | |
134 | wxFLAGS_MEMBER(wxBORDER_STATIC) | |
135 | wxFLAGS_MEMBER(wxBORDER_NONE) | |
136 | ||
137 | // old style border flags | |
138 | wxFLAGS_MEMBER(wxSIMPLE_BORDER) | |
139 | wxFLAGS_MEMBER(wxSUNKEN_BORDER) | |
140 | wxFLAGS_MEMBER(wxDOUBLE_BORDER) | |
141 | wxFLAGS_MEMBER(wxRAISED_BORDER) | |
142 | wxFLAGS_MEMBER(wxSTATIC_BORDER) | |
143 | wxFLAGS_MEMBER(wxBORDER) | |
144 | ||
145 | // standard window styles | |
146 | wxFLAGS_MEMBER(wxTAB_TRAVERSAL) | |
147 | wxFLAGS_MEMBER(wxCLIP_CHILDREN) | |
148 | wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW) | |
149 | wxFLAGS_MEMBER(wxWANTS_CHARS) | |
150 | wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE) | |
151 | wxFLAGS_MEMBER(wxALWAYS_SHOW_SB ) | |
152 | wxFLAGS_MEMBER(wxVSCROLL) | |
153 | wxFLAGS_MEMBER(wxHSCROLL) | |
154 | ||
155 | wxFLAGS_MEMBER(wxNB_FIXEDWIDTH) | |
156 | wxFLAGS_MEMBER(wxBK_DEFAULT) | |
157 | wxFLAGS_MEMBER(wxBK_TOP) | |
158 | wxFLAGS_MEMBER(wxBK_LEFT) | |
159 | wxFLAGS_MEMBER(wxBK_RIGHT) | |
160 | wxFLAGS_MEMBER(wxBK_BOTTOM) | |
161 | wxFLAGS_MEMBER(wxNB_NOPAGETHEME) | |
162 | wxFLAGS_MEMBER(wxNB_FLAT) | |
163 | ||
164 | wxEND_FLAGS( wxNotebookStyle ) | |
165 | ||
166 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebook, wxControl,"wx/notebook.h") | |
167 | IMPLEMENT_DYNAMIC_CLASS_XTI(wxNotebookPageInfo, wxObject , "wx/notebook.h" ) | |
168 | ||
169 | wxCOLLECTION_TYPE_INFO( wxNotebookPageInfo * , wxNotebookPageInfoList ) ; | |
170 | ||
171 | template<> void wxCollectionToVariantArray( wxNotebookPageInfoList const &theList, wxxVariantArray &value) | |
172 | { | |
173 | wxListCollectionToVariantArray<wxNotebookPageInfoList::compatibility_iterator>( theList , value ) ; | |
174 | } | |
175 | ||
176 | wxBEGIN_PROPERTIES_TABLE(wxNotebook) | |
177 | wxEVENT_PROPERTY( PageChanging , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING , wxNotebookEvent ) | |
178 | wxEVENT_PROPERTY( PageChanged , wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED , wxNotebookEvent ) | |
179 | ||
180 | wxPROPERTY_COLLECTION( PageInfos , wxNotebookPageInfoList , wxNotebookPageInfo* , AddPageInfo , GetPageInfos , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
181 | wxPROPERTY_FLAGS( WindowStyle , wxNotebookStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style | |
182 | wxEND_PROPERTIES_TABLE() | |
183 | ||
184 | wxBEGIN_HANDLERS_TABLE(wxNotebook) | |
185 | wxEND_HANDLERS_TABLE() | |
186 | ||
187 | wxCONSTRUCTOR_5( wxNotebook , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle) | |
188 | ||
189 | ||
190 | wxBEGIN_PROPERTIES_TABLE(wxNotebookPageInfo) | |
191 | wxREADONLY_PROPERTY( Page , wxNotebookPage* , GetPage , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
192 | wxREADONLY_PROPERTY( Text , wxString , GetText , wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
193 | wxREADONLY_PROPERTY( Selected , bool , GetSelected , false, 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) | |
194 | wxREADONLY_PROPERTY( ImageId , int , GetImageId , -1 , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) | |
195 | wxEND_PROPERTIES_TABLE() | |
196 | ||
197 | wxBEGIN_HANDLERS_TABLE(wxNotebookPageInfo) | |
198 | wxEND_HANDLERS_TABLE() | |
199 | ||
200 | wxCONSTRUCTOR_4( wxNotebookPageInfo , wxNotebookPage* , Page , wxString , Text , bool , Selected , int , ImageId ) | |
201 | ||
202 | #else | |
203 | IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl) | |
204 | IMPLEMENT_DYNAMIC_CLASS(wxNotebookPageInfo, wxObject ) | |
205 | #endif | |
206 | IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxNotifyEvent) | |
207 | ||
208 | // ============================================================================ | |
209 | // implementation | |
210 | // ============================================================================ | |
211 | ||
212 | // ---------------------------------------------------------------------------- | |
213 | // wxNotebook construction | |
214 | // ---------------------------------------------------------------------------- | |
215 | ||
216 | const wxNotebookPageInfoList& wxNotebook::GetPageInfos() const | |
217 | { | |
218 | wxNotebookPageInfoList* list = const_cast< wxNotebookPageInfoList* >( &m_pageInfos ) ; | |
219 | WX_CLEAR_LIST( wxNotebookPageInfoList , *list ) ; | |
220 | for( size_t i = 0 ; i < GetPageCount() ; ++i ) | |
221 | { | |
222 | wxNotebookPageInfo *info = new wxNotebookPageInfo() ; | |
223 | info->Create( const_cast<wxNotebook*>(this)->GetPage(i) , GetPageText(i) , GetSelection() == int(i) , GetPageImage(i) ) ; | |
224 | list->Append( info ) ; | |
225 | } | |
226 | return m_pageInfos ; | |
227 | } | |
228 | ||
229 | // common part of all ctors | |
230 | void wxNotebook::Init() | |
231 | { | |
232 | m_imageList = NULL; | |
233 | m_nSelection = -1; | |
234 | ||
235 | #if wxUSE_UXTHEME | |
236 | m_hbrBackground = NULL; | |
237 | #endif // wxUSE_UXTHEME | |
238 | ||
239 | #if USE_NOTEBOOK_ANTIFLICKER | |
240 | m_hasSubclassedUpdown = false; | |
241 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
242 | } | |
243 | ||
244 | // default for dynamic class | |
245 | wxNotebook::wxNotebook() | |
246 | { | |
247 | Init(); | |
248 | } | |
249 | ||
250 | // the same arguments as for wxControl | |
251 | wxNotebook::wxNotebook(wxWindow *parent, | |
252 | wxWindowID id, | |
253 | const wxPoint& pos, | |
254 | const wxSize& size, | |
255 | long style, | |
256 | const wxString& name) | |
257 | { | |
258 | Init(); | |
259 | ||
260 | Create(parent, id, pos, size, style, name); | |
261 | } | |
262 | ||
263 | // Create() function | |
264 | bool wxNotebook::Create(wxWindow *parent, | |
265 | wxWindowID id, | |
266 | const wxPoint& pos, | |
267 | const wxSize& size, | |
268 | long style, | |
269 | const wxString& name) | |
270 | { | |
271 | #ifdef __WXWINCE__ | |
272 | // Not sure why, but without this style, there is no border | |
273 | // around the notebook tabs. | |
274 | if (style & wxNB_FLAT) | |
275 | style |= wxBORDER_SUNKEN; | |
276 | #endif | |
277 | ||
278 | #if !wxUSE_UXTHEME | |
279 | // ComCtl32 notebook tabs simply don't work unless they're on top if we have uxtheme, we can | |
280 | // work around it later (after control creation), but if we don't have uxtheme, we have to clear | |
281 | // those styles | |
282 | const int verComCtl32 = wxApp::GetComCtl32Version(); | |
283 | if ( verComCtl32 == 600 ) | |
284 | { | |
285 | style &= ~(wxBK_BOTTOM | wxBK_LEFT | wxBK_RIGHT); | |
286 | } | |
287 | #endif //wxUSE_UXTHEME | |
288 | ||
289 | LPCTSTR className = WC_TABCONTROL; | |
290 | ||
291 | #if USE_NOTEBOOK_ANTIFLICKER | |
292 | // SysTabCtl32 class has natively CS_HREDRAW and CS_VREDRAW enabled and it | |
293 | // causes horrible flicker when resizing notebook, so get rid of it by | |
294 | // using a class without these styles (but otherwise identical to it) | |
295 | if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) ) | |
296 | { | |
297 | static ClassRegistrar s_clsNotebook; | |
298 | if ( !s_clsNotebook.IsInitialized() ) | |
299 | { | |
300 | // get a copy of standard class and modify it | |
301 | WNDCLASS wc; | |
302 | ||
303 | if ( ::GetClassInfo(NULL, WC_TABCONTROL, &wc) ) | |
304 | { | |
305 | gs_wndprocNotebook = | |
306 | wx_reinterpret_cast(WXFARPROC, wc.lpfnWndProc); | |
307 | wc.lpszClassName = wxT("_wx_SysTabCtl32"); | |
308 | wc.style &= ~(CS_HREDRAW | CS_VREDRAW); | |
309 | wc.hInstance = wxGetInstance(); | |
310 | wc.lpfnWndProc = wxNotebookWndProc; | |
311 | s_clsNotebook.Register(wc); | |
312 | } | |
313 | else | |
314 | { | |
315 | wxLogLastError(_T("GetClassInfoEx(SysTabCtl32)")); | |
316 | } | |
317 | } | |
318 | ||
319 | // use our custom class if available but fall back to the standard | |
320 | // notebook if we failed to register it | |
321 | if ( s_clsNotebook.IsRegistered() ) | |
322 | { | |
323 | // it's ok to use c_str() here as the static s_clsNotebook object | |
324 | // has sufficiently long lifetime | |
325 | className = s_clsNotebook.GetName().c_str(); | |
326 | } | |
327 | } | |
328 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
329 | ||
330 | if ( !CreateControl(parent, id, pos, size, style | wxTAB_TRAVERSAL, | |
331 | wxDefaultValidator, name) ) | |
332 | return false; | |
333 | ||
334 | if ( !MSWCreateControl(className, wxEmptyString, pos, size) ) | |
335 | return false; | |
336 | ||
337 | #if wxUSE_UXTHEME | |
338 | if ( HasFlag(wxNB_NOPAGETHEME) || | |
339 | wxSystemOptions::IsFalse(wxT("msw.notebook.themed-background")) ) | |
340 | { | |
341 | SetBackgroundColour(GetThemeBackgroundColour()); | |
342 | } | |
343 | else // use themed background by default | |
344 | { | |
345 | // create backing store | |
346 | UpdateBgBrush(); | |
347 | } | |
348 | ||
349 | // comctl32.dll 6.0 doesn't support non-top tabs with visual styles (the | |
350 | // control is simply not rendered correctly), so we disable themes | |
351 | // if possible, otherwise we simply clear the styles. | |
352 | // It's probably not possible to have UXTHEME without ComCtl32 6 or better, but lets | |
353 | // check it anyway. | |
354 | const int verComCtl32 = wxApp::GetComCtl32Version(); | |
355 | if ( verComCtl32 == 600 ) | |
356 | { | |
357 | // check if we use themes at all -- if we don't, we're still okay | |
358 | if ( wxUxThemeEngine::GetIfActive() && (style & (wxBK_BOTTOM|wxBK_LEFT|wxBK_RIGHT))) | |
359 | { | |
360 | wxUxThemeEngine::GetIfActive()->SetWindowTheme((HWND)this->GetHandle(), L"", L""); | |
361 | SetBackgroundColour(GetThemeBackgroundColour()); //correct the background color for the new non-themed control | |
362 | } | |
363 | } | |
364 | #endif // wxUSE_UXTHEME | |
365 | ||
366 | // Undocumented hack to get flat notebook style | |
367 | // In fact, we should probably only do this in some | |
368 | // curcumstances, i.e. if we know we will have a border | |
369 | // at the bottom (the tab control doesn't draw it itself) | |
370 | #if defined(__POCKETPC__) || defined(__SMARTPHONE__) | |
371 | if (HasFlag(wxNB_FLAT)) | |
372 | { | |
373 | SendMessage(GetHwnd(), CCM_SETVERSION, COMCTL32_VERSION, 0); | |
374 | if (!m_hasBgCol) | |
375 | SetBackgroundColour(*wxWHITE); | |
376 | } | |
377 | #endif | |
378 | return true; | |
379 | } | |
380 | ||
381 | WXDWORD wxNotebook::MSWGetStyle(long style, WXDWORD *exstyle) const | |
382 | { | |
383 | WXDWORD tabStyle = wxControl::MSWGetStyle(style, exstyle); | |
384 | ||
385 | tabStyle |= WS_TABSTOP | TCS_TABS; | |
386 | ||
387 | if ( style & wxNB_MULTILINE ) | |
388 | tabStyle |= TCS_MULTILINE; | |
389 | if ( style & wxNB_FIXEDWIDTH ) | |
390 | tabStyle |= TCS_FIXEDWIDTH; | |
391 | ||
392 | if ( style & wxBK_BOTTOM ) | |
393 | tabStyle |= TCS_RIGHT; | |
394 | else if ( style & wxBK_LEFT ) | |
395 | tabStyle |= TCS_VERTICAL; | |
396 | else if ( style & wxBK_RIGHT ) | |
397 | tabStyle |= TCS_VERTICAL | TCS_RIGHT; | |
398 | ||
399 | // ex style | |
400 | if ( exstyle ) | |
401 | { | |
402 | // note that we never want to have the default WS_EX_CLIENTEDGE style | |
403 | // as it looks too ugly for the notebooks | |
404 | *exstyle = 0; | |
405 | } | |
406 | ||
407 | return tabStyle; | |
408 | } | |
409 | ||
410 | wxNotebook::~wxNotebook() | |
411 | { | |
412 | #if wxUSE_UXTHEME | |
413 | if ( m_hbrBackground ) | |
414 | ::DeleteObject((HBRUSH)m_hbrBackground); | |
415 | #endif // wxUSE_UXTHEME | |
416 | } | |
417 | ||
418 | // ---------------------------------------------------------------------------- | |
419 | // wxNotebook accessors | |
420 | // ---------------------------------------------------------------------------- | |
421 | ||
422 | size_t wxNotebook::GetPageCount() const | |
423 | { | |
424 | // consistency check | |
425 | wxASSERT( (int)m_pages.Count() == TabCtrl_GetItemCount(GetHwnd()) ); | |
426 | ||
427 | return m_pages.Count(); | |
428 | } | |
429 | ||
430 | int wxNotebook::GetRowCount() const | |
431 | { | |
432 | return TabCtrl_GetRowCount(GetHwnd()); | |
433 | } | |
434 | ||
435 | int wxNotebook::SetSelection(size_t nPage) | |
436 | { | |
437 | wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") ); | |
438 | ||
439 | if ( int(nPage) != m_nSelection ) | |
440 | { | |
441 | wxNotebookEvent event(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, m_windowId); | |
442 | event.SetSelection(nPage); | |
443 | event.SetOldSelection(m_nSelection); | |
444 | event.SetEventObject(this); | |
445 | if ( !GetEventHandler()->ProcessEvent(event) || event.IsAllowed() ) | |
446 | { | |
447 | // program allows the page change | |
448 | event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED); | |
449 | (void)GetEventHandler()->ProcessEvent(event); | |
450 | ||
451 | TabCtrl_SetCurSel(GetHwnd(), nPage); | |
452 | } | |
453 | } | |
454 | ||
455 | return m_nSelection; | |
456 | } | |
457 | ||
458 | bool wxNotebook::SetPageText(size_t nPage, const wxString& strText) | |
459 | { | |
460 | wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") ); | |
461 | ||
462 | TC_ITEM tcItem; | |
463 | tcItem.mask = TCIF_TEXT; | |
464 | tcItem.pszText = (wxChar *)strText.c_str(); | |
465 | ||
466 | if ( !HasFlag(wxNB_MULTILINE) ) | |
467 | return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0; | |
468 | ||
469 | // multiline - we need to set new page size if a line is added or removed | |
470 | int rows = GetRowCount(); | |
471 | bool ret = TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0; | |
472 | ||
473 | if ( ret && rows != GetRowCount() ) | |
474 | { | |
475 | const wxRect r = GetPageSize(); | |
476 | const size_t count = m_pages.Count(); | |
477 | for ( size_t page = 0; page < count; page++ ) | |
478 | m_pages[page]->SetSize(r); | |
479 | } | |
480 | ||
481 | return ret; | |
482 | } | |
483 | ||
484 | wxString wxNotebook::GetPageText(size_t nPage) const | |
485 | { | |
486 | wxCHECK_MSG( IS_VALID_PAGE(nPage), wxEmptyString, wxT("notebook page out of range") ); | |
487 | ||
488 | wxChar buf[256]; | |
489 | TC_ITEM tcItem; | |
490 | tcItem.mask = TCIF_TEXT; | |
491 | tcItem.pszText = buf; | |
492 | tcItem.cchTextMax = WXSIZEOF(buf); | |
493 | ||
494 | wxString str; | |
495 | if ( TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) ) | |
496 | str = tcItem.pszText; | |
497 | ||
498 | return str; | |
499 | } | |
500 | ||
501 | int wxNotebook::GetPageImage(size_t nPage) const | |
502 | { | |
503 | wxCHECK_MSG( IS_VALID_PAGE(nPage), wxNOT_FOUND, wxT("notebook page out of range") ); | |
504 | ||
505 | TC_ITEM tcItem; | |
506 | tcItem.mask = TCIF_IMAGE; | |
507 | ||
508 | return TabCtrl_GetItem(GetHwnd(), nPage, &tcItem) ? tcItem.iImage : wxNOT_FOUND; | |
509 | } | |
510 | ||
511 | bool wxNotebook::SetPageImage(size_t nPage, int nImage) | |
512 | { | |
513 | wxCHECK_MSG( IS_VALID_PAGE(nPage), false, wxT("notebook page out of range") ); | |
514 | ||
515 | TC_ITEM tcItem; | |
516 | tcItem.mask = TCIF_IMAGE; | |
517 | tcItem.iImage = nImage; | |
518 | ||
519 | return TabCtrl_SetItem(GetHwnd(), nPage, &tcItem) != 0; | |
520 | } | |
521 | ||
522 | void wxNotebook::SetImageList(wxImageList* imageList) | |
523 | { | |
524 | wxNotebookBase::SetImageList(imageList); | |
525 | ||
526 | if ( imageList ) | |
527 | { | |
528 | (void) TabCtrl_SetImageList(GetHwnd(), (HIMAGELIST)imageList->GetHIMAGELIST()); | |
529 | } | |
530 | } | |
531 | ||
532 | // ---------------------------------------------------------------------------- | |
533 | // wxNotebook size settings | |
534 | // ---------------------------------------------------------------------------- | |
535 | ||
536 | wxRect wxNotebook::GetPageSize() const | |
537 | { | |
538 | wxRect r; | |
539 | ||
540 | RECT rc; | |
541 | ::GetClientRect(GetHwnd(), &rc); | |
542 | ||
543 | // This check is to work around a bug in TabCtrl_AdjustRect which will | |
544 | // cause a crash on win2k or on XP with themes disabled if either | |
545 | // wxNB_MULTILINE is used or tabs are placed on a side, if the rectangle | |
546 | // is too small. | |
547 | // | |
548 | // The value of 20 is chosen arbitrarily but seems to work | |
549 | if ( rc.right > 20 && rc.bottom > 20 ) | |
550 | { | |
551 | TabCtrl_AdjustRect(GetHwnd(), false, &rc); | |
552 | ||
553 | wxCopyRECTToRect(rc, r); | |
554 | } | |
555 | ||
556 | return r; | |
557 | } | |
558 | ||
559 | void wxNotebook::SetPageSize(const wxSize& size) | |
560 | { | |
561 | // transform the page size into the notebook size | |
562 | RECT rc; | |
563 | rc.left = | |
564 | rc.top = 0; | |
565 | rc.right = size.x; | |
566 | rc.bottom = size.y; | |
567 | ||
568 | TabCtrl_AdjustRect(GetHwnd(), true, &rc); | |
569 | ||
570 | // and now set it | |
571 | SetSize(rc.right - rc.left, rc.bottom - rc.top); | |
572 | } | |
573 | ||
574 | void wxNotebook::SetPadding(const wxSize& padding) | |
575 | { | |
576 | TabCtrl_SetPadding(GetHwnd(), padding.x, padding.y); | |
577 | } | |
578 | ||
579 | // Windows-only at present. Also, you must use the wxNB_FIXEDWIDTH | |
580 | // style. | |
581 | void wxNotebook::SetTabSize(const wxSize& sz) | |
582 | { | |
583 | ::SendMessage(GetHwnd(), TCM_SETITEMSIZE, 0, MAKELPARAM(sz.x, sz.y)); | |
584 | } | |
585 | ||
586 | wxSize wxNotebook::CalcSizeFromPage(const wxSize& sizePage) const | |
587 | { | |
588 | wxSize sizeTotal = sizePage; | |
589 | ||
590 | // We need to make getting tab size part of the wxWidgets API. | |
591 | wxSize tabSize; | |
592 | if (GetPageCount() > 0) | |
593 | { | |
594 | RECT rect; | |
595 | TabCtrl_GetItemRect((HWND) GetHWND(), 0, & rect); | |
596 | tabSize.x = rect.right - rect.left; | |
597 | tabSize.y = rect.bottom - rect.top; | |
598 | } | |
599 | if ( HasFlag(wxBK_LEFT) || HasFlag(wxBK_RIGHT) ) | |
600 | { | |
601 | sizeTotal.x += tabSize.x + 7; | |
602 | sizeTotal.y += 7; | |
603 | } | |
604 | else | |
605 | { | |
606 | sizeTotal.x += 7; | |
607 | sizeTotal.y += tabSize.y + 7; | |
608 | } | |
609 | ||
610 | return sizeTotal; | |
611 | } | |
612 | ||
613 | void wxNotebook::AdjustPageSize(wxNotebookPage *page) | |
614 | { | |
615 | wxCHECK_RET( page, _T("NULL page in wxNotebook::AdjustPageSize") ); | |
616 | ||
617 | const wxRect r = GetPageSize(); | |
618 | if ( !r.IsEmpty() ) | |
619 | { | |
620 | page->SetSize(r); | |
621 | } | |
622 | } | |
623 | ||
624 | // ---------------------------------------------------------------------------- | |
625 | // wxNotebook operations | |
626 | // ---------------------------------------------------------------------------- | |
627 | ||
628 | // remove one page from the notebook, without deleting | |
629 | wxNotebookPage *wxNotebook::DoRemovePage(size_t nPage) | |
630 | { | |
631 | wxNotebookPage *pageRemoved = wxNotebookBase::DoRemovePage(nPage); | |
632 | if ( !pageRemoved ) | |
633 | return NULL; | |
634 | ||
635 | TabCtrl_DeleteItem(GetHwnd(), nPage); | |
636 | ||
637 | if ( m_pages.IsEmpty() ) | |
638 | { | |
639 | // no selection any more, the notebook becamse empty | |
640 | m_nSelection = -1; | |
641 | } | |
642 | else // notebook still not empty | |
643 | { | |
644 | int selNew = TabCtrl_GetCurSel(GetHwnd()); | |
645 | if (selNew != -1) | |
646 | { | |
647 | // No selection change, just refresh the current selection. | |
648 | // Because it could be that the slection index changed | |
649 | // we need to update it. | |
650 | // Note: this does not mean the selection it self changed. | |
651 | m_nSelection = selNew; | |
652 | m_pages[m_nSelection]->Refresh(); | |
653 | } | |
654 | else if (int(nPage) == m_nSelection) | |
655 | { | |
656 | // The selection was deleted. | |
657 | ||
658 | // Determine new selection. | |
659 | if (m_nSelection == int(GetPageCount())) | |
660 | selNew = m_nSelection - 1; | |
661 | else | |
662 | selNew = m_nSelection; | |
663 | ||
664 | // m_nSelection must be always valid so reset it before calling | |
665 | // SetSelection() | |
666 | m_nSelection = -1; | |
667 | SetSelection(selNew); | |
668 | } | |
669 | else | |
670 | { | |
671 | wxFAIL; // Windows did not behave ok. | |
672 | } | |
673 | } | |
674 | ||
675 | return pageRemoved; | |
676 | } | |
677 | ||
678 | // remove all pages | |
679 | bool wxNotebook::DeleteAllPages() | |
680 | { | |
681 | size_t nPageCount = GetPageCount(); | |
682 | size_t nPage; | |
683 | for ( nPage = 0; nPage < nPageCount; nPage++ ) | |
684 | delete m_pages[nPage]; | |
685 | ||
686 | m_pages.Clear(); | |
687 | ||
688 | TabCtrl_DeleteAllItems(GetHwnd()); | |
689 | ||
690 | m_nSelection = -1; | |
691 | ||
692 | InvalidateBestSize(); | |
693 | return true; | |
694 | } | |
695 | ||
696 | // same as AddPage() but does it at given position | |
697 | bool wxNotebook::InsertPage(size_t nPage, | |
698 | wxNotebookPage *pPage, | |
699 | const wxString& strText, | |
700 | bool bSelect, | |
701 | int imageId) | |
702 | { | |
703 | wxCHECK_MSG( pPage != NULL, false, _T("NULL page in wxNotebook::InsertPage") ); | |
704 | wxCHECK_MSG( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), false, | |
705 | _T("invalid index in wxNotebook::InsertPage") ); | |
706 | ||
707 | wxASSERT_MSG( pPage->GetParent() == this, | |
708 | _T("notebook pages must have notebook as parent") ); | |
709 | ||
710 | // add a new tab to the control | |
711 | // ---------------------------- | |
712 | ||
713 | // init all fields to 0 | |
714 | TC_ITEM tcItem; | |
715 | wxZeroMemory(tcItem); | |
716 | ||
717 | // set the image, if any | |
718 | if ( imageId != -1 ) | |
719 | { | |
720 | tcItem.mask |= TCIF_IMAGE; | |
721 | tcItem.iImage = imageId; | |
722 | } | |
723 | ||
724 | // and the text | |
725 | if ( !strText.empty() ) | |
726 | { | |
727 | tcItem.mask |= TCIF_TEXT; | |
728 | tcItem.pszText = (wxChar *)strText.c_str(); // const_cast | |
729 | } | |
730 | ||
731 | // hide the page: unless it is selected, it shouldn't be shown (and if it | |
732 | // is selected it will be shown later) | |
733 | HWND hwnd = GetWinHwnd(pPage); | |
734 | SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_VISIBLE); | |
735 | ||
736 | // this updates internal flag too -- otherwise it would get out of sync | |
737 | // with the real state | |
738 | pPage->Show(false); | |
739 | ||
740 | ||
741 | // fit the notebook page to the tab control's display area: this should be | |
742 | // done before adding it to the notebook or TabCtrl_InsertItem() will | |
743 | // change the notebooks size itself! | |
744 | AdjustPageSize(pPage); | |
745 | ||
746 | // finally do insert it | |
747 | if ( TabCtrl_InsertItem(GetHwnd(), nPage, &tcItem) == -1 ) | |
748 | { | |
749 | wxLogError(wxT("Can't create the notebook page '%s'."), strText.c_str()); | |
750 | ||
751 | return false; | |
752 | } | |
753 | ||
754 | // succeeded: save the pointer to the page | |
755 | m_pages.Insert(pPage, nPage); | |
756 | ||
757 | // we may need to adjust the size again if the notebook size changed: | |
758 | // normally this only happens for the first page we add (the tabs which | |
759 | // hadn't been there before are now shown) but for a multiline notebook it | |
760 | // can happen for any page at all as a new row could have been started | |
761 | if ( m_pages.GetCount() == 1 || HasFlag(wxNB_MULTILINE) ) | |
762 | { | |
763 | AdjustPageSize(pPage); | |
764 | } | |
765 | ||
766 | // now deal with the selection | |
767 | // --------------------------- | |
768 | ||
769 | // if the inserted page is before the selected one, we must update the | |
770 | // index of the selected page | |
771 | if ( int(nPage) <= m_nSelection ) | |
772 | { | |
773 | // one extra page added | |
774 | m_nSelection++; | |
775 | } | |
776 | ||
777 | // some page should be selected: either this one or the first one if there | |
778 | // is still no selection | |
779 | int selNew = -1; | |
780 | if ( bSelect ) | |
781 | selNew = nPage; | |
782 | else if ( m_nSelection == -1 ) | |
783 | selNew = 0; | |
784 | ||
785 | if ( selNew != -1 ) | |
786 | SetSelection(selNew); | |
787 | ||
788 | InvalidateBestSize(); | |
789 | ||
790 | return true; | |
791 | } | |
792 | ||
793 | int wxNotebook::HitTest(const wxPoint& pt, long *flags) const | |
794 | { | |
795 | TC_HITTESTINFO hitTestInfo; | |
796 | hitTestInfo.pt.x = pt.x; | |
797 | hitTestInfo.pt.y = pt.y; | |
798 | int item = TabCtrl_HitTest(GetHwnd(), &hitTestInfo); | |
799 | ||
800 | if ( flags ) | |
801 | { | |
802 | *flags = 0; | |
803 | ||
804 | if ((hitTestInfo.flags & TCHT_NOWHERE) == TCHT_NOWHERE) | |
805 | *flags |= wxNB_HITTEST_NOWHERE; | |
806 | if ((hitTestInfo.flags & TCHT_ONITEM) == TCHT_ONITEM) | |
807 | *flags |= wxNB_HITTEST_ONITEM; | |
808 | if ((hitTestInfo.flags & TCHT_ONITEMICON) == TCHT_ONITEMICON) | |
809 | *flags |= wxNB_HITTEST_ONICON; | |
810 | if ((hitTestInfo.flags & TCHT_ONITEMLABEL) == TCHT_ONITEMLABEL) | |
811 | *flags |= wxNB_HITTEST_ONLABEL; | |
812 | } | |
813 | ||
814 | return item; | |
815 | } | |
816 | ||
817 | // ---------------------------------------------------------------------------- | |
818 | // flicker-less notebook redraw | |
819 | // ---------------------------------------------------------------------------- | |
820 | ||
821 | #if USE_NOTEBOOK_ANTIFLICKER | |
822 | ||
823 | // wnd proc for the spin button | |
824 | LRESULT APIENTRY _EXPORT wxNotebookSpinBtnWndProc(HWND hwnd, | |
825 | UINT message, | |
826 | WPARAM wParam, | |
827 | LPARAM lParam) | |
828 | { | |
829 | if ( message == WM_ERASEBKGND ) | |
830 | return 0; | |
831 | ||
832 | return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebookSpinBtn, | |
833 | hwnd, message, wParam, lParam); | |
834 | } | |
835 | ||
836 | LRESULT APIENTRY _EXPORT wxNotebookWndProc(HWND hwnd, | |
837 | UINT message, | |
838 | WPARAM wParam, | |
839 | LPARAM lParam) | |
840 | { | |
841 | return ::CallWindowProc(CASTWNDPROC gs_wndprocNotebook, | |
842 | hwnd, message, wParam, lParam); | |
843 | } | |
844 | ||
845 | void wxNotebook::OnEraseBackground(wxEraseEvent& WXUNUSED(event)) | |
846 | { | |
847 | // do nothing here | |
848 | } | |
849 | ||
850 | void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event)) | |
851 | { | |
852 | wxPaintDC dc(this); | |
853 | wxMemoryDC memdc; | |
854 | RECT rc; | |
855 | ::GetClientRect(GetHwnd(), &rc); | |
856 | wxBitmap bmp(rc.right, rc.bottom); | |
857 | memdc.SelectObject(bmp); | |
858 | ||
859 | // if there is no special brush just use the solid background colour | |
860 | #if wxUSE_UXTHEME | |
861 | HBRUSH hbr = (HBRUSH)m_hbrBackground; | |
862 | #else | |
863 | HBRUSH hbr = 0; | |
864 | #endif | |
865 | wxBrush brush; | |
866 | if ( !hbr ) | |
867 | { | |
868 | brush = wxBrush(GetBackgroundColour()); | |
869 | hbr = GetHbrushOf(brush); | |
870 | } | |
871 | ||
872 | ::FillRect(GetHdcOf(memdc), &rc, hbr); | |
873 | ||
874 | MSWDefWindowProc(WM_PAINT, (WPARAM)memdc.GetHDC(), 0); | |
875 | ||
876 | dc.Blit(0, 0, rc.right, rc.bottom, &memdc, 0, 0); | |
877 | } | |
878 | ||
879 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
880 | ||
881 | // ---------------------------------------------------------------------------- | |
882 | // wxNotebook callbacks | |
883 | // ---------------------------------------------------------------------------- | |
884 | ||
885 | void wxNotebook::OnSize(wxSizeEvent& event) | |
886 | { | |
887 | if ( GetPageCount() == 0 ) | |
888 | { | |
889 | // Prevents droppings on resize, but does cause some flicker | |
890 | // when there are no pages. | |
891 | Refresh(); | |
892 | event.Skip(); | |
893 | return; | |
894 | } | |
895 | #ifndef __WXWINCE__ | |
896 | else | |
897 | { | |
898 | // Without this, we can sometimes get droppings at the edges | |
899 | // of a notebook, for example a notebook in a splitter window. | |
900 | // This needs to be reconciled with the RefreshRect calls | |
901 | // at the end of this function, which weren't enough to prevent | |
902 | // the droppings. | |
903 | ||
904 | wxSize sz = GetClientSize(); | |
905 | ||
906 | // Refresh right side | |
907 | wxRect rect(sz.x-4, 0, 4, sz.y); | |
908 | RefreshRect(rect); | |
909 | ||
910 | // Refresh bottom side | |
911 | rect = wxRect(0, sz.y-4, sz.x, 4); | |
912 | RefreshRect(rect); | |
913 | ||
914 | // Refresh left side | |
915 | rect = wxRect(0, 0, 4, sz.y); | |
916 | RefreshRect(rect); | |
917 | } | |
918 | #endif // !__WXWINCE__ | |
919 | ||
920 | // fit all the notebook pages to the tab control's display area | |
921 | ||
922 | RECT rc; | |
923 | rc.left = rc.top = 0; | |
924 | GetSize((int *)&rc.right, (int *)&rc.bottom); | |
925 | ||
926 | // save the total size, we'll use it below | |
927 | int widthNbook = rc.right - rc.left, | |
928 | heightNbook = rc.bottom - rc.top; | |
929 | ||
930 | // there seems to be a bug in the implementation of TabCtrl_AdjustRect(): it | |
931 | // returns completely false values for multiline tab controls after the tabs | |
932 | // are added but before getting the first WM_SIZE (off by ~50 pixels, see | |
933 | // | |
934 | // http://sf.net/tracker/index.php?func=detail&aid=645323&group_id=9863&atid=109863 | |
935 | // | |
936 | // and the only work around I could find was this ugly hack... without it | |
937 | // simply toggling the "multiline" checkbox in the notebook sample resulted | |
938 | // in a noticeable page displacement | |
939 | if ( HasFlag(wxNB_MULTILINE) ) | |
940 | { | |
941 | // avoid an infinite recursion: we get another notification too! | |
942 | static bool s_isInOnSize = false; | |
943 | ||
944 | if ( !s_isInOnSize ) | |
945 | { | |
946 | s_isInOnSize = true; | |
947 | SendMessage(GetHwnd(), WM_SIZE, SIZE_RESTORED, | |
948 | MAKELPARAM(rc.right, rc.bottom)); | |
949 | s_isInOnSize = false; | |
950 | } | |
951 | } | |
952 | ||
953 | #if wxUSE_UXTHEME | |
954 | // background bitmap size has changed, update the brush using it too | |
955 | UpdateBgBrush(); | |
956 | #endif // wxUSE_UXTHEME | |
957 | ||
958 | TabCtrl_AdjustRect(GetHwnd(), false, &rc); | |
959 | ||
960 | int width = rc.right - rc.left, | |
961 | height = rc.bottom - rc.top; | |
962 | size_t nCount = m_pages.Count(); | |
963 | for ( size_t nPage = 0; nPage < nCount; nPage++ ) { | |
964 | wxNotebookPage *pPage = m_pages[nPage]; | |
965 | pPage->SetSize(rc.left, rc.top, width, height); | |
966 | } | |
967 | ||
968 | ||
969 | // unless we had already repainted everything, we now need to refresh | |
970 | if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) ) | |
971 | { | |
972 | // invalidate areas not covered by pages | |
973 | RefreshRect(wxRect(0, 0, widthNbook, rc.top), false); | |
974 | RefreshRect(wxRect(0, rc.top, rc.left, height), false); | |
975 | RefreshRect(wxRect(0, rc.bottom, widthNbook, heightNbook - rc.bottom), | |
976 | false); | |
977 | RefreshRect(wxRect(rc.right, rc.top, widthNbook - rc.right, height), | |
978 | false); | |
979 | } | |
980 | ||
981 | #if USE_NOTEBOOK_ANTIFLICKER | |
982 | // subclass the spin control used by the notebook to scroll pages to | |
983 | // prevent it from flickering on resize | |
984 | if ( !m_hasSubclassedUpdown ) | |
985 | { | |
986 | // iterate over all child windows to find spin button | |
987 | for ( HWND child = ::GetWindow(GetHwnd(), GW_CHILD); | |
988 | child; | |
989 | child = ::GetWindow(child, GW_HWNDNEXT) ) | |
990 | { | |
991 | wxWindow *childWindow = wxFindWinFromHandle((WXHWND)child); | |
992 | ||
993 | // see if it exists, if no wxWindow found then assume it's the spin | |
994 | // btn | |
995 | if ( !childWindow ) | |
996 | { | |
997 | // subclass the spin button to override WM_ERASEBKGND | |
998 | if ( !gs_wndprocNotebookSpinBtn ) | |
999 | gs_wndprocNotebookSpinBtn = (WXFARPROC)wxGetWindowProc(child); | |
1000 | ||
1001 | wxSetWindowProc(child, wxNotebookSpinBtnWndProc); | |
1002 | m_hasSubclassedUpdown = true; | |
1003 | break; | |
1004 | } | |
1005 | } | |
1006 | } | |
1007 | #endif // USE_NOTEBOOK_ANTIFLICKER | |
1008 | ||
1009 | event.Skip(); | |
1010 | } | |
1011 | ||
1012 | void wxNotebook::OnSelChange(wxNotebookEvent& event) | |
1013 | { | |
1014 | // is it our tab control? | |
1015 | if ( event.GetEventObject() == this ) | |
1016 | { | |
1017 | int sel = event.GetOldSelection(); | |
1018 | if ( sel != -1 ) | |
1019 | m_pages[sel]->Show(false); | |
1020 | ||
1021 | sel = event.GetSelection(); | |
1022 | if ( sel != -1 ) | |
1023 | { | |
1024 | wxNotebookPage *pPage = m_pages[sel]; | |
1025 | pPage->Show(true); | |
1026 | } | |
1027 | ||
1028 | // Changing the page should give the focus to it but, as per bug report | |
1029 | // http://sf.net/tracker/index.php?func=detail&aid=1150659&group_id=9863&atid=109863, | |
1030 | // we should not set the focus to it directly since it erroneously | |
1031 | // selects radio buttons and breaks keyboard handling for a notebook's | |
1032 | // scroll buttons. So give focus to the notebook and not the page. | |
1033 | ||
1034 | // but don't do this is the notebook is hidden | |
1035 | if ( ::IsWindowVisible(GetHwnd()) ) | |
1036 | SetFocus(); | |
1037 | ||
1038 | m_nSelection = sel; | |
1039 | } | |
1040 | ||
1041 | // we want to give others a chance to process this message as well | |
1042 | event.Skip(); | |
1043 | } | |
1044 | ||
1045 | bool wxNotebook::MSWTranslateMessage(WXMSG *wxmsg) | |
1046 | { | |
1047 | const MSG * const msg = (MSG *)wxmsg; | |
1048 | ||
1049 | // intercept TAB, CTRL+TAB and CTRL+SHIFT+TAB for processing by wxNotebook. | |
1050 | // TAB will be passed to the currently selected page, CTRL+TAB and | |
1051 | // CTRL+SHIFT+TAB will be processed by the notebook itself. do not | |
1052 | // intercept SHIFT+TAB. This goes to the parent of the notebook which will | |
1053 | // process it. | |
1054 | if ( msg->message == WM_KEYDOWN && msg->wParam == VK_TAB && | |
1055 | msg->hwnd == GetHwnd() && | |
1056 | (wxIsCtrlDown() || !wxIsShiftDown()) ) | |
1057 | { | |
1058 | return MSWProcessMessage(wxmsg); | |
1059 | } | |
1060 | ||
1061 | return false; | |
1062 | } | |
1063 | ||
1064 | void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event) | |
1065 | { | |
1066 | if ( event.IsWindowChange() ) { | |
1067 | // change pages | |
1068 | AdvanceSelection(event.GetDirection()); | |
1069 | } | |
1070 | else { | |
1071 | // we get this event in 3 cases | |
1072 | // | |
1073 | // a) one of our pages might have generated it because the user TABbed | |
1074 | // out from it in which case we should propagate the event upwards and | |
1075 | // our parent will take care of setting the focus to prev/next sibling | |
1076 | // | |
1077 | // or | |
1078 | // | |
1079 | // b) the parent panel wants to give the focus to us so that we | |
1080 | // forward it to our selected page. We can't deal with this in | |
1081 | // OnSetFocus() because we don't know which direction the focus came | |
1082 | // from in this case and so can't choose between setting the focus to | |
1083 | // first or last panel child | |
1084 | // | |
1085 | // or | |
1086 | // | |
1087 | // c) we ourselves (see MSWTranslateMessage) generated the event | |
1088 | // | |
1089 | wxWindow * const parent = GetParent(); | |
1090 | ||
1091 | // the wxObject* casts are required to avoid MinGW GCC 2.95.3 ICE | |
1092 | const bool isFromParent = event.GetEventObject() == (wxObject*) parent; | |
1093 | const bool isFromSelf = event.GetEventObject() == (wxObject*) this; | |
1094 | ||
1095 | if ( isFromParent || isFromSelf ) | |
1096 | { | |
1097 | // no, it doesn't come from child, case (b) or (c): forward to a | |
1098 | // page but only if direction is backwards (TAB) or from ourselves, | |
1099 | if ( m_nSelection != -1 && | |
1100 | (!event.GetDirection() || isFromSelf) ) | |
1101 | { | |
1102 | // so that the page knows that the event comes from it's parent | |
1103 | // and is being propagated downwards | |
1104 | event.SetEventObject(this); | |
1105 | ||
1106 | wxWindow *page = m_pages[m_nSelection]; | |
1107 | if ( !page->GetEventHandler()->ProcessEvent(event) ) | |
1108 | { | |
1109 | page->SetFocus(); | |
1110 | } | |
1111 | //else: page manages focus inside it itself | |
1112 | } | |
1113 | else // otherwise set the focus to the notebook itself | |
1114 | { | |
1115 | SetFocus(); | |
1116 | } | |
1117 | } | |
1118 | else | |
1119 | { | |
1120 | // it comes from our child, case (a), pass to the parent, but only | |
1121 | // if the direction is forwards. Otherwise set the focus to the | |
1122 | // notebook itself. The notebook is always the 'first' control of a | |
1123 | // page. | |
1124 | if ( !event.GetDirection() ) | |
1125 | { | |
1126 | SetFocus(); | |
1127 | } | |
1128 | else if ( parent ) | |
1129 | { | |
1130 | event.SetCurrentFocus(this); | |
1131 | parent->GetEventHandler()->ProcessEvent(event); | |
1132 | } | |
1133 | } | |
1134 | } | |
1135 | } | |
1136 | ||
1137 | #if wxUSE_UXTHEME | |
1138 | ||
1139 | bool wxNotebook::DoDrawBackground(WXHDC hDC, wxWindow *child) | |
1140 | { | |
1141 | wxUxThemeHandle theme(child ? child : this, L"TAB"); | |
1142 | if ( !theme ) | |
1143 | return false; | |
1144 | ||
1145 | // get the notebook client rect (we're not interested in drawing tabs | |
1146 | // themselves) | |
1147 | wxRect r = GetPageSize(); | |
1148 | if ( r.IsEmpty() ) | |
1149 | return false; | |
1150 | ||
1151 | RECT rc; | |
1152 | wxCopyRectToRECT(r, rc); | |
1153 | ||
1154 | // map rect to the coords of the window we're drawing in | |
1155 | if ( child ) | |
1156 | ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2); | |
1157 | ||
1158 | // we have the content area (page size), but we need to draw all of the | |
1159 | // background for it to be aligned correctly | |
1160 | wxUxThemeEngine::Get()->GetThemeBackgroundExtent | |
1161 | ( | |
1162 | theme, | |
1163 | (HDC) hDC, | |
1164 | 9 /* TABP_PANE */, | |
1165 | 0, | |
1166 | &rc, | |
1167 | &rc | |
1168 | ); | |
1169 | wxUxThemeEngine::Get()->DrawThemeBackground | |
1170 | ( | |
1171 | theme, | |
1172 | (HDC) hDC, | |
1173 | 9 /* TABP_PANE */, | |
1174 | 0, | |
1175 | &rc, | |
1176 | NULL | |
1177 | ); | |
1178 | ||
1179 | return true; | |
1180 | } | |
1181 | ||
1182 | WXHBRUSH wxNotebook::QueryBgBitmap() | |
1183 | { | |
1184 | wxRect r = GetPageSize(); | |
1185 | if ( r.IsEmpty() ) | |
1186 | return 0; | |
1187 | ||
1188 | WindowHDC hDC(GetHwnd()); | |
1189 | MemoryHDC hDCMem(hDC); | |
1190 | CompatibleBitmap hBmp(hDC, r.x + r.width, r.y + r.height); | |
1191 | ||
1192 | SelectInHDC selectBmp(hDCMem, hBmp); | |
1193 | ||
1194 | if ( !DoDrawBackground((WXHDC)(HDC)hDCMem) ) | |
1195 | return 0; | |
1196 | ||
1197 | return (WXHBRUSH)::CreatePatternBrush(hBmp); | |
1198 | } | |
1199 | ||
1200 | void wxNotebook::UpdateBgBrush() | |
1201 | { | |
1202 | if ( m_hbrBackground ) | |
1203 | ::DeleteObject((HBRUSH)m_hbrBackground); | |
1204 | ||
1205 | if ( !m_hasBgCol && wxUxThemeEngine::GetIfActive() ) | |
1206 | { | |
1207 | m_hbrBackground = QueryBgBitmap(); | |
1208 | } | |
1209 | else // no themes or we've got user-defined solid colour | |
1210 | { | |
1211 | m_hbrBackground = NULL; | |
1212 | } | |
1213 | } | |
1214 | ||
1215 | WXHBRUSH wxNotebook::MSWGetBgBrushForChild(WXHDC hDC, WXHWND hWnd) | |
1216 | { | |
1217 | if ( m_hbrBackground ) | |
1218 | { | |
1219 | // before drawing with the background brush, we need to position it | |
1220 | // correctly | |
1221 | RECT rc; | |
1222 | ::GetWindowRect((HWND)hWnd, &rc); | |
1223 | ||
1224 | ::MapWindowPoints(NULL, GetHwnd(), (POINT *)&rc, 1); | |
1225 | ||
1226 | if ( !::SetBrushOrgEx((HDC)hDC, -rc.left, -rc.top, NULL) ) | |
1227 | { | |
1228 | wxLogLastError(_T("SetBrushOrgEx(notebook bg brush)")); | |
1229 | } | |
1230 | ||
1231 | return m_hbrBackground; | |
1232 | } | |
1233 | ||
1234 | return wxNotebookBase::MSWGetBgBrushForChild(hDC, hWnd); | |
1235 | } | |
1236 | ||
1237 | bool wxNotebook::MSWPrintChild(WXHDC hDC, wxWindow *child) | |
1238 | { | |
1239 | // solid background colour overrides themed background drawing | |
1240 | if ( !UseBgCol() && DoDrawBackground(hDC, child) ) | |
1241 | return true; | |
1242 | ||
1243 | // If we're using a solid colour (for example if we've switched off | |
1244 | // theming for this notebook), paint it | |
1245 | if (UseBgCol()) | |
1246 | { | |
1247 | wxRect r = GetPageSize(); | |
1248 | if ( r.IsEmpty() ) | |
1249 | return false; | |
1250 | ||
1251 | RECT rc; | |
1252 | wxCopyRectToRECT(r, rc); | |
1253 | ||
1254 | // map rect to the coords of the window we're drawing in | |
1255 | if ( child ) | |
1256 | ::MapWindowPoints(GetHwnd(), GetHwndOf(child), (POINT *)&rc, 2); | |
1257 | ||
1258 | wxBrush brush(GetBackgroundColour()); | |
1259 | HBRUSH hbr = GetHbrushOf(brush); | |
1260 | ||
1261 | ::FillRect((HDC) hDC, &rc, hbr); | |
1262 | ||
1263 | return true; | |
1264 | } | |
1265 | ||
1266 | return wxNotebookBase::MSWPrintChild(hDC, child); | |
1267 | } | |
1268 | ||
1269 | #endif // wxUSE_UXTHEME | |
1270 | ||
1271 | // Windows only: attempts to get colour for UX theme page background | |
1272 | wxColour wxNotebook::GetThemeBackgroundColour() const | |
1273 | { | |
1274 | #if wxUSE_UXTHEME | |
1275 | if (wxUxThemeEngine::Get()) | |
1276 | { | |
1277 | wxUxThemeHandle hTheme((wxNotebook*) this, L"TAB"); | |
1278 | if (hTheme) | |
1279 | { | |
1280 | // This is total guesswork. | |
1281 | // See PlatformSDK\Include\Tmschema.h for values | |
1282 | COLORREF themeColor; | |
1283 | wxUxThemeEngine::Get()->GetThemeColor( | |
1284 | hTheme, | |
1285 | 10 /* TABP_BODY */, | |
1286 | 1 /* NORMAL */, | |
1287 | 3821 /* FILLCOLORHINT */, | |
1288 | &themeColor); | |
1289 | ||
1290 | /* | |
1291 | [DS] Workaround for WindowBlinds: | |
1292 | Some themes return a near black theme color using FILLCOLORHINT, | |
1293 | this makes notebook pages have an ugly black background and makes | |
1294 | text (usually black) unreadable. Retry again with FILLCOLOR. | |
1295 | ||
1296 | This workaround potentially breaks appearance of some themes, | |
1297 | but in practice it already fixes some themes. | |
1298 | */ | |
1299 | if (themeColor == 1) | |
1300 | { | |
1301 | wxUxThemeEngine::Get()->GetThemeColor( | |
1302 | hTheme, | |
1303 | 10 /* TABP_BODY */, | |
1304 | 1 /* NORMAL */, | |
1305 | 3802 /* FILLCOLOR */, | |
1306 | &themeColor); | |
1307 | } | |
1308 | ||
1309 | return wxRGBToColour(themeColor); | |
1310 | } | |
1311 | } | |
1312 | #endif // wxUSE_UXTHEME | |
1313 | ||
1314 | return GetBackgroundColour(); | |
1315 | } | |
1316 | ||
1317 | // ---------------------------------------------------------------------------- | |
1318 | // wxNotebook base class virtuals | |
1319 | // ---------------------------------------------------------------------------- | |
1320 | ||
1321 | #if wxUSE_CONSTRAINTS | |
1322 | ||
1323 | // override these 2 functions to do nothing: everything is done in OnSize | |
1324 | ||
1325 | void wxNotebook::SetConstraintSizes(bool WXUNUSED(recurse)) | |
1326 | { | |
1327 | // don't set the sizes of the pages - their correct size is not yet known | |
1328 | wxControl::SetConstraintSizes(false); | |
1329 | } | |
1330 | ||
1331 | bool wxNotebook::DoPhase(int WXUNUSED(nPhase)) | |
1332 | { | |
1333 | return true; | |
1334 | } | |
1335 | ||
1336 | #endif // wxUSE_CONSTRAINTS | |
1337 | ||
1338 | // ---------------------------------------------------------------------------- | |
1339 | // wxNotebook Windows message handlers | |
1340 | // ---------------------------------------------------------------------------- | |
1341 | ||
1342 | bool wxNotebook::MSWOnScroll(int orientation, WXWORD nSBCode, | |
1343 | WXWORD pos, WXHWND control) | |
1344 | { | |
1345 | // don't generate EVT_SCROLLWIN events for the WM_SCROLLs coming from the | |
1346 | // up-down control | |
1347 | if ( control ) | |
1348 | return false; | |
1349 | ||
1350 | return wxNotebookBase::MSWOnScroll(orientation, nSBCode, pos, control); | |
1351 | } | |
1352 | ||
1353 | bool wxNotebook::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM* result) | |
1354 | { | |
1355 | wxNotebookEvent event(wxEVT_NULL, m_windowId); | |
1356 | ||
1357 | NMHDR* hdr = (NMHDR *)lParam; | |
1358 | switch ( hdr->code ) { | |
1359 | case TCN_SELCHANGE: | |
1360 | event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED); | |
1361 | break; | |
1362 | ||
1363 | case TCN_SELCHANGING: | |
1364 | event.SetEventType(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING); | |
1365 | break; | |
1366 | ||
1367 | default: | |
1368 | return wxControl::MSWOnNotify(idCtrl, lParam, result); | |
1369 | } | |
1370 | ||
1371 | event.SetSelection(TabCtrl_GetCurSel(GetHwnd())); | |
1372 | event.SetOldSelection(m_nSelection); | |
1373 | event.SetEventObject(this); | |
1374 | event.SetInt(idCtrl); | |
1375 | ||
1376 | bool processed = GetEventHandler()->ProcessEvent(event); | |
1377 | *result = !event.IsAllowed(); | |
1378 | return processed; | |
1379 | } | |
1380 | ||
1381 | #endif // wxUSE_NOTEBOOK |