src/msw/wince/tbarwce.cpp

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