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