]> git.saurik.com Git - wxWidgets.git/blob - src/msw/wince/tbarwce.cpp
fix PCH-less build with wxUSE_URL_NATIVE (see #10338)
[wxWidgets.git] / src / msw / wince / tbarwce.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/wince/tbarwce.cpp
3 // Purpose: wxToolBar for Windows CE
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 2003-07-12
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 // Use the WinCE-specific toolbar only if we're either compiling
28 // with a WinCE earlier than 4, or we wish to emulate a PocketPC-style UI
29 #if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE && (_WIN32_WCE < 400 || defined(__POCKETPC__) || defined(__SMARTPHONE__))
30
31 #include "wx/toolbar.h"
32
33 #ifndef WX_PRECOMP
34 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
35 #include "wx/dynarray.h"
36 #include "wx/frame.h"
37 #include "wx/log.h"
38 #include "wx/intl.h"
39 #include "wx/settings.h"
40 #include "wx/bitmap.h"
41 #include "wx/dcmemory.h"
42 #include "wx/control.h"
43 #endif
44
45 #if !defined(__GNUWIN32__)
46 #include "malloc.h"
47 #endif
48
49 #include "wx/msw/private.h"
50 #include <windows.h>
51 #include <windowsx.h>
52 #include <tchar.h>
53 #include <ole2.h>
54 #include <shellapi.h>
55 #if defined(WINCE_WITHOUT_COMMANDBAR)
56 #include <aygshell.h>
57 #include "wx/msw/wince/resources.h"
58 #endif
59 #include "wx/msw/wince/missing.h"
60
61 #include "wx/msw/winundef.h"
62
63 #if !defined(__SMARTPHONE__)
64
65 ///////////// This implementation is for PocketPC.
66 ///////////// See later for the Smartphone dummy toolbar class.
67
68 // ----------------------------------------------------------------------------
69 // Event table
70 // ----------------------------------------------------------------------------
71
72 IMPLEMENT_DYNAMIC_CLASS(wxToolMenuBar, wxToolBar)
73
74 BEGIN_EVENT_TABLE(wxToolMenuBar, wxToolBar)
75 END_EVENT_TABLE()
76
77 // ----------------------------------------------------------------------------
78 // private classes
79 // ----------------------------------------------------------------------------
80
81 class wxToolMenuBarTool : public wxToolBarToolBase
82 {
83 public:
84 wxToolMenuBarTool(wxToolBar *tbar,
85 int id,
86 const wxString& label,
87 const wxBitmap& bmpNormal,
88 const wxBitmap& bmpDisabled,
89 wxItemKind kind,
90 wxObject *clientData,
91 const wxString& shortHelp,
92 const wxString& longHelp)
93 : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
94 clientData, shortHelp, longHelp)
95 {
96 m_nSepCount = 0;
97 m_bitmapIndex = -1;
98 }
99
100 wxToolMenuBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
101 : wxToolBarToolBase(tbar, control, label)
102 {
103 m_nSepCount = 1;
104 m_bitmapIndex = -1;
105 }
106
107 virtual void SetLabel(const wxString& label)
108 {
109 if ( label == m_label )
110 return;
111
112 wxToolBarToolBase::SetLabel(label);
113
114 // we need to update the label shown in the toolbar because it has a
115 // pointer to the internal buffer of the old label
116 //
117 // TODO: use TB_SETBUTTONINFO
118 }
119
120 // set/get the number of separators which we use to cover the space used by
121 // a control in the toolbar
122 void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
123 size_t GetSeparatorsCount() const { return m_nSepCount; }
124
125 void SetBitmapIndex(int idx) { m_bitmapIndex = idx; }
126 int GetBitmapIndex() const { return m_bitmapIndex; }
127
128 private:
129 size_t m_nSepCount;
130 int m_bitmapIndex;
131 };
132
133
134 // ============================================================================
135 // implementation
136 // ============================================================================
137
138 // ----------------------------------------------------------------------------
139 // wxToolBarTool
140 // ----------------------------------------------------------------------------
141
142 wxToolBarToolBase *wxToolMenuBar::CreateTool(int id,
143 const wxString& label,
144 const wxBitmap& bmpNormal,
145 const wxBitmap& bmpDisabled,
146 wxItemKind kind,
147 wxObject *clientData,
148 const wxString& shortHelp,
149 const wxString& longHelp)
150 {
151 return new wxToolMenuBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
152 clientData, shortHelp, longHelp);
153 }
154
155 wxToolBarToolBase *
156 wxToolMenuBar::CreateTool(wxControl *control, const wxString& label)
157 {
158 return new wxToolMenuBarTool(this, control, label);
159 }
160
161 // ----------------------------------------------------------------------------
162 // wxToolBar construction
163 // ----------------------------------------------------------------------------
164
165 void wxToolMenuBar::Init()
166 {
167 wxToolBar::Init();
168
169 m_nButtons = 0;
170 m_menuBar = NULL;
171 }
172
173 bool wxToolMenuBar::Create(wxWindow *parent,
174 wxWindowID id,
175 const wxPoint& pos,
176 const wxSize& size,
177 long style,
178 const wxString& name,
179 wxMenuBar* menuBar)
180 {
181 // common initialisation
182 if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
183 return false;
184
185 // MSW-specific initialisation
186 if ( !MSWCreateToolbar(pos, size, menuBar) )
187 return false;
188
189 // set up the colors and fonts
190 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
191 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
192
193 return true;
194 }
195
196 bool wxToolMenuBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos),
197 const wxSize& WXUNUSED(size),
198 wxMenuBar *menuBar)
199 {
200 SetMenuBar(menuBar);
201 if (m_menuBar)
202 m_menuBar->SetToolBar(this);
203
204 HWND hwndParent = GetHwndOf(GetParent());
205 wxCHECK_MSG( hwndParent, false, _T("should have valid parent HWND") );
206
207 #if defined(WINCE_WITHOUT_COMMANDBAR)
208 // create the menubar.
209 WinStruct<SHMENUBARINFO> mbi;
210
211 mbi.hwndParent = hwndParent;
212 mbi.nToolBarId = wxIDM_SHMENU;
213 mbi.hInstRes = wxGetInstance();
214
215 if ( !SHCreateMenuBar(&mbi) )
216 {
217 wxFAIL_MSG( _T("SHCreateMenuBar failed") );
218 return false;
219 }
220
221 SetHWND((WXHWND) mbi.hwndMB);
222 #else
223 HWND hWnd = CommandBar_Create(wxGetInstance(), hwndParent, GetId());
224 SetHWND((WXHWND) hWnd);
225 #endif
226
227 // install wxWidgets window proc for this window
228 SubclassWin(m_hWnd);
229
230 if (menuBar)
231 menuBar->Create();
232
233 return true;
234 }
235
236 void wxToolMenuBar::Recreate()
237 {
238 // TODO
239 }
240
241 wxToolMenuBar::~wxToolMenuBar()
242 {
243 if (GetMenuBar())
244 GetMenuBar()->SetToolBar(NULL);
245 }
246
247 // Return HMENU for the menu associated with the commandbar
248 WXHMENU wxToolMenuBar::GetHMenu()
249 {
250 #if !defined(__HANDHELDPC__)
251 if (GetHWND())
252 {
253 return (WXHMENU)::SendMessage(GetHwnd(), SHCMBM_GETMENU, 0, 0);
254 }
255 #endif
256
257 return NULL;
258 }
259
260 // ----------------------------------------------------------------------------
261 // adding/removing tools
262 // ----------------------------------------------------------------------------
263
264 bool wxToolMenuBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
265 {
266 // nothing special to do here - we really create the toolbar buttons in
267 // Realize() later
268 tool->Attach(this);
269
270 return true;
271 }
272
273 bool wxToolMenuBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
274 {
275 // the main difficulty we have here is with the controls in the toolbars:
276 // as we (sometimes) use several separators to cover up the space used by
277 // them, the indices are not the same for us and the toolbar
278
279 // first determine the position of the first button to delete: it may be
280 // different from pos if we use several separators to cover the space used
281 // by a control
282 wxToolBarToolsList::compatibility_iterator node;
283 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
284 {
285 wxToolBarToolBase *tool2 = node->GetData();
286 if ( tool2 == tool )
287 {
288 // let node point to the next node in the list
289 node = node->GetNext();
290
291 break;
292 }
293
294 if ( tool2->IsControl() )
295 {
296 pos += ((wxToolMenuBarTool *)tool2)->GetSeparatorsCount() - 1;
297 }
298 }
299
300 // now determine the number of buttons to delete and the area taken by them
301 size_t nButtonsToDelete = 1;
302
303 // get the size of the button we're going to delete
304 RECT r;
305 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) )
306 {
307 wxLogLastError(_T("TB_GETITEMRECT"));
308 }
309
310 int width = r.right - r.left;
311
312 if ( tool->IsControl() )
313 {
314 nButtonsToDelete = ((wxToolMenuBarTool *)tool)->GetSeparatorsCount();
315
316 width *= nButtonsToDelete;
317 }
318
319 // do delete all buttons
320 m_nButtons -= nButtonsToDelete;
321 while ( nButtonsToDelete-- > 0 )
322 {
323 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
324 {
325 wxLogLastError(wxT("TB_DELETEBUTTON"));
326
327 return false;
328 }
329 }
330
331 tool->Detach();
332
333 // and finally reposition all the controls after this button (the toolbar
334 // takes care of all normal items)
335 for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
336 {
337 wxToolBarToolBase *tool2 = node->GetData();
338 if ( tool2->IsControl() )
339 {
340 int x;
341 wxControl *control = tool2->GetControl();
342 control->GetPosition(&x, NULL);
343 control->Move(x - width, wxDefaultCoord);
344 }
345 }
346
347 return true;
348 }
349
350 bool wxToolMenuBar::Realize()
351 {
352 const size_t nTools = GetToolsCount();
353 if ( nTools == 0 )
354 {
355 // nothing to do
356 return true;
357 }
358
359 #if 0
360 // delete all old buttons, if any
361 for ( size_t pos = 0; pos < m_nButtons; pos++ )
362 {
363 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
364 {
365 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
366 }
367 }
368 #endif // 0
369
370 bool lastWasRadio = false;
371 wxToolBarToolsList::Node* node;
372 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
373 {
374 wxToolMenuBarTool *tool = (wxToolMenuBarTool*) node->GetData();
375
376 TBBUTTON buttons[1] ;
377
378 TBBUTTON& button = buttons[0];
379
380 wxZeroMemory(button);
381
382 bool isRadio = false;
383 switch ( tool->GetStyle() )
384 {
385 case wxTOOL_STYLE_CONTROL:
386 button.idCommand = tool->GetId();
387 // fall through: create just a separator too
388 // TODO: controls are not yet supported on wxToolMenuBar.
389
390 case wxTOOL_STYLE_SEPARATOR:
391 button.fsState = TBSTATE_ENABLED;
392 button.fsStyle = TBSTYLE_SEP;
393 break;
394
395 case wxTOOL_STYLE_BUTTON:
396
397 if ( HasFlag(wxTB_TEXT) )
398 {
399 const wxString& label = tool->GetLabel();
400 if ( !label.empty() )
401 {
402 button.iString = (int)label.wx_str();
403 }
404 }
405
406 const wxBitmap& bmp = tool->GetNormalBitmap();
407
408 wxBitmap bmpToUse = bmp;
409
410 if (bmp.GetWidth() < 16 || bmp.GetHeight() < 16 || bmp.GetMask() != NULL)
411 {
412 wxMemoryDC memDC;
413 wxBitmap b(16,16);
414 memDC.SelectObject(b);
415 wxColour col = wxColour(192,192,192);
416 memDC.SetBackground(wxBrush(col));
417 memDC.Clear();
418 int x = (16 - bmp.GetWidth())/2;
419 int y = (16 - bmp.GetHeight())/2;
420 memDC.DrawBitmap(bmp, x, y, true);
421 memDC.SelectObject(wxNullBitmap);
422
423 bmpToUse = b;
424 tool->SetNormalBitmap(b);
425 }
426
427 int n = 0;
428 if ( bmpToUse.Ok() )
429 {
430 n = ::CommandBar_AddBitmap( (HWND) GetHWND(), NULL, (int) (HBITMAP) bmpToUse.GetHBITMAP(),
431 1, 16, 16 );
432 }
433
434 button.idCommand = tool->GetId();
435 button.iBitmap = n;
436
437 if ( tool->IsEnabled() )
438 button.fsState |= TBSTATE_ENABLED;
439 if ( tool->IsToggled() )
440 button.fsState |= TBSTATE_CHECKED;
441
442 switch ( tool->GetKind() )
443 {
444 case wxITEM_RADIO:
445 button.fsStyle = TBSTYLE_CHECKGROUP;
446
447 if ( !lastWasRadio )
448 {
449 // the first item in the radio group is checked by
450 // default to be consistent with wxGTK and the menu
451 // radio items
452 button.fsState |= TBSTATE_CHECKED;
453
454 tool->Toggle(true);
455 }
456
457 isRadio = true;
458 break;
459
460 case wxITEM_CHECK:
461 button.fsStyle = TBSTYLE_CHECK;
462 break;
463
464 default:
465 wxFAIL_MSG( _T("unexpected toolbar button kind") );
466 // fall through
467
468 case wxITEM_NORMAL:
469 button.fsStyle = TBSTYLE_BUTTON;
470 }
471 break;
472 }
473
474 if ( !::CommandBar_AddButtons( (HWND) GetHWND(), 1, buttons ) )
475 {
476 wxFAIL_MSG( wxT("Could not add toolbar button."));
477 }
478
479 lastWasRadio = isRadio;
480 }
481
482 return true;
483 }
484
485 bool wxToolMenuBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
486 {
487 const int id = (signed short)id_;
488
489 wxToolBarToolBase *tool = FindById(id);
490 if ( !tool )
491 {
492 bool checked = false;
493 if ( m_menuBar )
494 {
495 wxMenuItem *item = m_menuBar->FindItem(id);
496 if ( item && item->IsCheckable() )
497 {
498 item->Toggle();
499 checked = item->IsChecked();
500 }
501 }
502
503 wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED);
504 event.SetEventObject(this);
505 event.SetId(id);
506 event.SetInt(checked);
507
508 return GetEventHandler()->ProcessEvent(event);
509 }
510
511 if ( tool->CanBeToggled() )
512 {
513 LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
514 tool->Toggle((state & TBSTATE_CHECKED) != 0);
515 }
516
517 bool toggled = tool->IsToggled();
518
519 // avoid sending the event when a radio button is released, this is not
520 // interesting
521 if ( !tool->CanBeToggled() || tool->GetKind() != wxITEM_RADIO || toggled )
522 {
523 // OnLeftClick() can veto the button state change - for buttons which
524 // may be toggled only, of couse
525 if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() )
526 {
527 // revert back
528 toggled = !toggled;
529 tool->SetToggle(toggled);
530
531 ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0));
532 }
533 }
534
535 return true;
536 }
537
538 WXLRESULT wxToolMenuBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
539 {
540 switch ( nMsg )
541 {
542 case WM_SIZE:
543 break;
544
545 case WM_MOUSEMOVE:
546 // we don't handle mouse moves, so always pass the message to
547 // wxControl::MSWWindowProc
548 HandleMouseMove(wParam, lParam);
549 break;
550
551 case WM_PAINT:
552 break;
553 }
554
555 return MSWDefWindowProc(nMsg, wParam, lParam);
556 }
557
558
559 #else
560
561 ////////////// For Smartphone
562
563 // ----------------------------------------------------------------------------
564 // Event table
565 // ----------------------------------------------------------------------------
566
567 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
568
569 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
570 END_EVENT_TABLE()
571
572 wxToolBarToolBase *wxToolBar::CreateTool(int id,
573 const wxString& label,
574 const wxBitmap& bmpNormal,
575 const wxBitmap& bmpDisabled,
576 wxItemKind kind,
577 wxObject *clientData,
578 const wxString& shortHelp,
579 const wxString& longHelp)
580 {
581 return new wxToolBarToolBase(this, id, label, bmpNormal, bmpDisabled, kind,
582 clientData, shortHelp, longHelp);
583 }
584
585 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
586 {
587 return new wxToolBarToolBase(this, control);
588 }
589
590 bool wxToolBar::Create(wxWindow *parent,
591 wxWindowID WXUNUSED(id),
592 const wxPoint& WXUNUSED(pos),
593 const wxSize& WXUNUSED(size),
594 long style,
595 const wxString& name)
596 {
597 // TODO: we may need to make this a dummy hidden window to
598 // satisfy other parts of wxWidgets.
599
600 parent->AddChild(this);
601
602 SetWindowStyle(style);
603 SetName(name);
604
605 return true;
606 }
607
608 // ----------------------------------------------------------------------------
609 // adding/removing tools
610 // ----------------------------------------------------------------------------
611
612 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
613 {
614 tool->Attach(this);
615 return true;
616 }
617
618 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
619 {
620 tool->Detach();
621 return true;
622 }
623
624 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y)) const
625 {
626 return NULL;
627 }
628
629 // ----------------------------------------------------------------------------
630 // tool state
631 // ----------------------------------------------------------------------------
632
633 void wxToolBar::DoEnableTool(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(enable))
634 {
635 }
636
637 void wxToolBar::DoToggleTool(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
638 {
639 }
640
641 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
642 {
643 wxFAIL_MSG( _T("not implemented") );
644 }
645
646 #endif
647 // !__SMARTPHONE__
648
649 #endif // wxUSE_TOOLBAR