← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/wxWidgets3/src/msw/wince/tbarwce.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

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