src/common/popupcmn.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        common/popupcmn.cpp
   3 // Purpose:     implementation of wxPopupTransientWindow
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     06.01.01
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2001 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // License:     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 "popupwinbase.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 #if wxUSE_POPUPWIN
  32
  33 #include "wx/popupwin.h"
  34
  35 #ifndef WX_PRECOMP
  36     #include "wx/combobox.h"        // wxComboControl
  37     #include "wx/app.h"             // wxPostEvent
  38     #include "wx/log.h"
  39     #include "wx/app.h"
  40 #endif //WX_PRECOMP
  41
  42 #ifdef __WXUNIVERSAL__
  43     #include "wx/univ/renderer.h"
  44 #endif // __WXUNIVERSAL__
  45
  46 #ifdef __WXGTK__
  47     #include <gtk/gtk.h>
  48 #endif
  49
  50 IMPLEMENT_DYNAMIC_CLASS(wxPopupWindow, wxWindow)
  51 IMPLEMENT_DYNAMIC_CLASS(wxPopupTransientWindow, wxPopupWindow)
  52
  53 #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
  54     IMPLEMENT_DYNAMIC_CLASS(wxPopupComboWindow, wxPopupTransientWindow)
  55 #endif
  56
  57 // ----------------------------------------------------------------------------
  58 // private classes
  59 // ----------------------------------------------------------------------------
  60
  61 // event handlers which we use to intercept events which cause the popup to
  62 // disappear
  63 class wxPopupWindowHandler : public wxEvtHandler
  64 {
  65 public:
  66     wxPopupWindowHandler(wxPopupTransientWindow *popup) { m_popup = popup; }
  67
  68 protected:
  69     // event handlers
  70     void OnLeftDown(wxMouseEvent& event);
  71
  72 private:
  73     wxPopupTransientWindow *m_popup;
  74
  75     DECLARE_EVENT_TABLE()
  76     DECLARE_NO_COPY_CLASS(wxPopupWindowHandler)
  77 };
  78
  79 class wxPopupFocusHandler : public wxEvtHandler
  80 {
  81 public:
  82     wxPopupFocusHandler(wxPopupTransientWindow *popup)
  83     {
  84         m_popup = popup;
  85     }
  86
  87 protected:
  88     void OnKillFocus(wxFocusEvent& event);
  89     void OnKeyDown(wxKeyEvent& event);
  90
  91 private:
  92     wxPopupTransientWindow *m_popup;
  93
  94     DECLARE_EVENT_TABLE()
  95     DECLARE_NO_COPY_CLASS(wxPopupFocusHandler)
  96 };
  97
  98 // ----------------------------------------------------------------------------
  99 // event tables
 100 // ----------------------------------------------------------------------------
 101
 102 BEGIN_EVENT_TABLE(wxPopupWindowHandler, wxEvtHandler)
 103     EVT_LEFT_DOWN(wxPopupWindowHandler::OnLeftDown)
 104 END_EVENT_TABLE()
 105
 106 BEGIN_EVENT_TABLE(wxPopupFocusHandler, wxEvtHandler)
 107     EVT_KILL_FOCUS(wxPopupFocusHandler::OnKillFocus)
 108     EVT_KEY_DOWN(wxPopupFocusHandler::OnKeyDown)
 109 END_EVENT_TABLE()
 110
 111 // ============================================================================
 112 // implementation
 113 // ============================================================================
 114
 115 // ----------------------------------------------------------------------------
 116 // wxPopupWindowBase
 117 // ----------------------------------------------------------------------------
 118
 119 wxPopupWindowBase::~wxPopupWindowBase()
 120 {
 121     // this destructor is required for Darwin
 122 }
 123
 124 bool wxPopupWindowBase::Create(wxWindow* WXUNUSED(parent), int WXUNUSED(flags))
 125 {
 126     return true;
 127 }
 128
 129 void wxPopupWindowBase::Position(const wxPoint& ptOrigin,
 130                                  const wxSize& size)
 131 {
 132     wxSize sizeScreen = wxGetDisplaySize(),
 133            sizeSelf = GetSize();
 134
 135     // is there enough space to put the popup below the window (where we put it
 136     // by default)?
 137     wxCoord y = ptOrigin.y + size.y;
 138     if ( y + sizeSelf.y > sizeScreen.y )
 139     {
 140         // check if there is enough space above
 141         if ( ptOrigin.y > sizeSelf.y )
 142         {
 143             // do position the control above the window
 144             y -= size.y + sizeSelf.y;
 145         }
 146         //else: not enough space below nor above, leave below
 147     }
 148
 149     // now check left/right too
 150     wxCoord x = ptOrigin.x + size.x;
 151     if ( x + sizeSelf.x > sizeScreen.x )
 152     {
 153         // check if there is enough space to the left
 154         if ( ptOrigin.x > sizeSelf.x )
 155         {
 156             // do position the control to the left
 157             x -= size.x + sizeSelf.x;
 158         }
 159         //else: not enough space there neither, leave in default position
 160     }
 161
 162     Move(x, y, wxSIZE_NO_ADJUSTMENTS);
 163 }
 164
 165 // ----------------------------------------------------------------------------
 166 // wxPopupTransientWindow
 167 // ----------------------------------------------------------------------------
 168
 169 void wxPopupTransientWindow::Init()
 170 {
 171     m_child =
 172     m_focus = (wxWindow *)NULL;
 173
 174     m_handlerFocus = NULL;
 175     m_handlerPopup = NULL;
 176 }
 177
 178 wxPopupTransientWindow::wxPopupTransientWindow(wxWindow *parent, int style)
 179 {
 180     Init();
 181
 182     (void)Create(parent, style);
 183 }
 184
 185 wxPopupTransientWindow::~wxPopupTransientWindow()
 186 {
 187     PopHandlers();
 188 }
 189
 190 void wxPopupTransientWindow::PopHandlers()
 191 {
 192     if ( m_child )
 193     {
 194         if ( m_handlerPopup && !m_child->RemoveEventHandler(m_handlerPopup) )
 195         {
 196             // something is very wrong and someone else probably deleted our
 197             // handler - so don't risk deleting it second time
 198             m_handlerPopup = NULL;
 199         }
 200
 201         // m_child->ReleaseMouse();
 202         m_child = NULL;
 203     }
 204
 205 #ifdef __WXMSW__
 206     if ( m_focus )
 207     {
 208         if ( m_handlerFocus && !m_focus->RemoveEventHandler(m_handlerFocus) )
 209         {
 210             // see above
 211             m_handlerFocus = NULL;
 212         }
 213     }
 214 #else
 215     if ( m_handlerFocus && !RemoveEventHandler(m_handlerFocus) )
 216     {
 217         // see above
 218         m_handlerFocus = NULL;
 219     }
 220 #endif
 221
 222     // delete the handlers, they'll be created as necessary in Popup()
 223     delete m_handlerPopup;
 224     m_handlerPopup = NULL;
 225     delete m_handlerFocus;
 226     m_handlerFocus = NULL;
 227
 228     m_focus = NULL;
 229 }
 230
 231 void wxPopupTransientWindow::Popup(wxWindow *winFocus)
 232 {
 233     const wxWindowList& children = GetChildren();
 234     if ( children.GetCount() )
 235     {
 236         m_child = children.GetFirst()->GetData();
 237     }
 238     else
 239     {
 240         m_child = this;
 241     }
 242
 243     Show();
 244
 245     delete m_handlerPopup;
 246     m_handlerPopup = new wxPopupWindowHandler(this);
 247
 248     // m_child->CaptureMouse();
 249     m_child->PushEventHandler(m_handlerPopup);
 250
 251     m_focus = winFocus ? winFocus : this;
 252     m_focus->SetFocus();
 253
 254 #ifdef __WXMSW__
 255     // MSW doesn't allow to set focus to the popup window, but we need to
 256     // subclass the window which has the focus, and not winFocus passed in or
 257     // otherwise everything else breaks down
 258     m_focus = FindFocus();
 259     if ( m_focus )
 260     {
 261         delete m_handlerFocus;
 262         m_handlerFocus = new wxPopupFocusHandler(this);
 263
 264         m_focus->PushEventHandler(m_handlerFocus);
 265     }
 266 #else
 267     // GTK+ catches the activate events from the popup
 268     // window, not the focus events from the child window
 269     delete m_handlerFocus;
 270     m_handlerFocus = new wxPopupFocusHandler(this);
 271     PushEventHandler(m_handlerFocus);
 272 #endif // __WXMSW__
 273
 274 }
 275
 276 bool wxPopupTransientWindow::Show( bool show )
 277 {
 278 #ifdef __WXGTK__
 279     if (!show)
 280     {
 281         gdk_pointer_ungrab( (guint32)GDK_CURRENT_TIME );
 282
 283         gtk_grab_remove( m_widget );
 284     }
 285 #endif
 286
 287     bool ret = wxPopupWindow::Show( show );
 288
 289 #ifdef __WXGTK__
 290     if (show)
 291     {
 292         gtk_grab_add( m_widget );
 293
 294         gdk_pointer_grab( m_widget->window, TRUE,
 295                           (GdkEventMask)
 296                             (GDK_BUTTON_PRESS_MASK |
 297                              GDK_BUTTON_RELEASE_MASK |
 298                              GDK_POINTER_MOTION_HINT_MASK |
 299                              GDK_POINTER_MOTION_MASK),
 300                           (GdkWindow *) NULL,
 301                           (GdkCursor *) NULL,
 302                           (guint32)GDK_CURRENT_TIME );
 303     }
 304 #endif
 305
 306     return ret;
 307 }
 308
 309 void wxPopupTransientWindow::Dismiss()
 310 {
 311     PopHandlers();
 312
 313     Hide();
 314 }
 315
 316 void wxPopupTransientWindow::DismissAndNotify()
 317 {
 318     Dismiss();
 319
 320     OnDismiss();
 321 }
 322
 323 void wxPopupTransientWindow::OnDismiss()
 324 {
 325     // nothing to do here - but it may be interesting for derived class
 326 }
 327
 328 bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event))
 329 {
 330     // no special processing here
 331     return false;
 332 }
 333
 334 #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 335
 336 // ----------------------------------------------------------------------------
 337 // wxPopupComboWindow
 338 // ----------------------------------------------------------------------------
 339
 340 BEGIN_EVENT_TABLE(wxPopupComboWindow, wxPopupTransientWindow)
 341     EVT_KEY_DOWN(wxPopupComboWindow::OnKeyDown)
 342 END_EVENT_TABLE()
 343
 344 wxPopupComboWindow::wxPopupComboWindow(wxComboControl *parent)
 345                   : wxPopupTransientWindow(parent)
 346 {
 347     m_combo = parent;
 348 }
 349
 350 bool wxPopupComboWindow::Create(wxComboControl *parent)
 351 {
 352     m_combo = parent;
 353
 354     return wxPopupWindow::Create(parent);
 355 }
 356
 357 void wxPopupComboWindow::PositionNearCombo()
 358 {
 359     // the origin point must be in screen coords
 360     wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0, 0));
 361
 362 #if 0 //def __WXUNIVERSAL__
 363     // account for the fact that (0, 0) is not the top left corner of the
 364     // window: there is also the border
 365     wxRect rectBorders = m_combo->GetRenderer()->
 366                             GetBorderDimensions(m_combo->GetBorder());
 367     ptOrigin.x -= rectBorders.x;
 368     ptOrigin.y -= rectBorders.y;
 369 #endif // __WXUNIVERSAL__
 370
 371     // position below or above the combobox: the width is 0 to put it exactly
 372     // below us, not to the left or to the right
 373     Position(ptOrigin, wxSize(0, m_combo->GetSize().y));
 374 }
 375
 376 void wxPopupComboWindow::OnDismiss()
 377 {
 378     m_combo->OnDismiss();
 379 }
 380
 381 void wxPopupComboWindow::OnKeyDown(wxKeyEvent& event)
 382 {
 383     m_combo->ProcessEvent(event);
 384 }
 385
 386 #endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 387
 388 // ----------------------------------------------------------------------------
 389 // wxPopupWindowHandler
 390 // ----------------------------------------------------------------------------
 391
 392 void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event)
 393 {
 394     // let the window have it first (we're the first event handler in the chain
 395     // of handlers for this window)
 396     if ( m_popup->ProcessLeftDown(event) )
 397     {
 398         return;
 399     }
 400
 401     wxPoint pos = event.GetPosition();
 402
 403     // scrollbar on which the click occured
 404     wxWindow *sbar = NULL;
 405
 406     wxWindow *win = (wxWindow *)event.GetEventObject();
 407
 408     switch ( win->HitTest(pos.x, pos.y) )
 409     {
 410         case wxHT_WINDOW_OUTSIDE:
 411             {
 412                 // do the coords translation now as after DismissAndNotify()
 413                 // m_popup may be destroyed
 414                 wxMouseEvent event2(event);
 415
 416                 m_popup->ClientToScreen(&event2.m_x, &event2.m_y);
 417
 418                 // clicking outside a popup dismisses it
 419                 m_popup->DismissAndNotify();
 420
 421                 // dismissing a tooltip shouldn't waste a click, i.e. you
 422                 // should be able to dismiss it and press the button with the
 423                 // same click, so repost this event to the window beneath us
 424                 wxWindow *win = wxFindWindowAtPoint(event2.GetPosition());
 425                 if ( win )
 426                 {
 427                     // translate the event coords to the ones of the window
 428                     // which is going to get the event
 429                     win->ScreenToClient(&event2.m_x, &event2.m_y);
 430
 431                     event2.SetEventObject(win);
 432                     wxPostEvent(win, event2);
 433                 }
 434             }
 435             break;
 436
 437 #ifdef __WXUNIVERSAL__
 438         case wxHT_WINDOW_HORZ_SCROLLBAR:
 439             sbar = win->GetScrollbar(wxHORIZONTAL);
 440             break;
 441
 442         case wxHT_WINDOW_VERT_SCROLLBAR:
 443             sbar = win->GetScrollbar(wxVERTICAL);
 444             break;
 445 #endif
 446
 447         default:
 448             // forgot to update the switch after adding a new hit test code?
 449             wxFAIL_MSG( _T("unexpected HitTest() return value") );
 450             // fall through
 451
 452         case wxHT_WINDOW_CORNER:
 453             // don't actually know if this one is good for anything, but let it
 454             // pass just in case
 455
 456         case wxHT_WINDOW_INSIDE:
 457             // let the normal processing take place
 458             event.Skip();
 459             break;
 460     }
 461
 462     if ( sbar )
 463     {
 464         // translate the event coordinates to the scrollbar ones
 465         pos = sbar->ScreenToClient(win->ClientToScreen(pos));
 466
 467         // and give the event to it
 468         wxMouseEvent event2 = event;
 469         event2.m_x = pos.x;
 470         event2.m_y = pos.y;
 471
 472         (void)sbar->GetEventHandler()->ProcessEvent(event2);
 473     }
 474 }
 475
 476 // ----------------------------------------------------------------------------
 477 // wxPopupFocusHandler
 478 // ----------------------------------------------------------------------------
 479
 480 void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event)
 481 {
 482     // when we lose focus we always disappear - unless it goes to the popup (in
 483     // which case we don't really lose it)
 484     wxWindow *win = event.GetWindow();
 485     while ( win )
 486     {
 487         if ( win == m_popup )
 488             return;
 489         win = win->GetParent();
 490     }
 491
 492     m_popup->DismissAndNotify();
 493 }
 494
 495 void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event)
 496 {
 497     // let the window have it first, it might process the keys
 498     if ( !m_popup->ProcessEvent(event) )
 499     {
 500         // by default, dismiss the popup
 501         m_popup->DismissAndNotify();
 502     }
 503 }
 504
 505 #endif // wxUSE_POPUPWIN
 506