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         if (m_child->HasCapture())
 202             m_child->ReleaseMouse();
 203         m_child = NULL;
 204     }
 205
 206 #ifdef __WXMSW__
 207     if ( m_focus )
 208     {
 209         if ( m_handlerFocus && !m_focus->RemoveEventHandler(m_handlerFocus) )
 210         {
 211             // see above
 212             m_handlerFocus = NULL;
 213         }
 214     }
 215 #else
 216     if ( m_handlerFocus && !RemoveEventHandler(m_handlerFocus) )
 217     {
 218         // see above
 219         m_handlerFocus = NULL;
 220     }
 221 #endif
 222
 223     // delete the handlers, they'll be created as necessary in Popup()
 224     delete m_handlerPopup;
 225     m_handlerPopup = NULL;
 226     delete m_handlerFocus;
 227     m_handlerFocus = NULL;
 228
 229     m_focus = NULL;
 230 }
 231
 232 void wxPopupTransientWindow::Popup(wxWindow *winFocus)
 233 {
 234     const wxWindowList& children = GetChildren();
 235     if ( children.GetCount() )
 236     {
 237         m_child = children.GetFirst()->GetData();
 238     }
 239     else
 240     {
 241         m_child = this;
 242     }
 243
 244     Show();
 245
 246     delete m_handlerPopup;
 247     m_handlerPopup = new wxPopupWindowHandler(this);
 248
 249     // m_child->CaptureMouse();
 250     m_child->PushEventHandler(m_handlerPopup);
 251
 252     m_focus = winFocus ? winFocus : this;
 253     m_focus->SetFocus();
 254
 255 #ifdef __WXMSW__
 256     // MSW doesn't allow to set focus to the popup window, but we need to
 257     // subclass the window which has the focus, and not winFocus passed in or
 258     // otherwise everything else breaks down
 259     m_focus = FindFocus();
 260     if ( m_focus )
 261     {
 262         delete m_handlerFocus;
 263         m_handlerFocus = new wxPopupFocusHandler(this);
 264
 265         m_focus->PushEventHandler(m_handlerFocus);
 266     }
 267 #else
 268     // GTK+ catches the activate events from the popup
 269     // window, not the focus events from the child window
 270     delete m_handlerFocus;
 271     m_handlerFocus = new wxPopupFocusHandler(this);
 272     PushEventHandler(m_handlerFocus);
 273 #endif // __WXMSW__
 274
 275 }
 276
 277 bool wxPopupTransientWindow::Show( bool show )
 278 {
 279 #ifdef __WXGTK__
 280     if (!show)
 281         gtk_grab_remove( m_widget );
 282 #endif
 283
 284     bool ret = wxPopupWindow::Show( show );
 285
 286 #ifdef __WXGTK__
 287     if (show)
 288         gtk_grab_add( m_widget );
 289 #endif
 290
 291     return ret;
 292 }
 293
 294 void wxPopupTransientWindow::Dismiss()
 295 {
 296     PopHandlers();
 297
 298     Hide();
 299 }
 300
 301 void wxPopupTransientWindow::DismissAndNotify()
 302 {
 303     Dismiss();
 304
 305     OnDismiss();
 306 }
 307
 308 void wxPopupTransientWindow::OnDismiss()
 309 {
 310     // nothing to do here - but it may be interesting for derived class
 311 }
 312
 313 bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event))
 314 {
 315     // no special processing here
 316     return false;
 317 }
 318
 319 #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 320
 321 // ----------------------------------------------------------------------------
 322 // wxPopupComboWindow
 323 // ----------------------------------------------------------------------------
 324
 325 BEGIN_EVENT_TABLE(wxPopupComboWindow, wxPopupTransientWindow)
 326     EVT_KEY_DOWN(wxPopupComboWindow::OnKeyDown)
 327 END_EVENT_TABLE()
 328
 329 wxPopupComboWindow::wxPopupComboWindow(wxComboControl *parent)
 330                   : wxPopupTransientWindow(parent)
 331 {
 332     m_combo = parent;
 333 }
 334
 335 bool wxPopupComboWindow::Create(wxComboControl *parent)
 336 {
 337     m_combo = parent;
 338
 339     return wxPopupWindow::Create(parent);
 340 }
 341
 342 void wxPopupComboWindow::PositionNearCombo()
 343 {
 344     // the origin point must be in screen coords
 345     wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0, 0));
 346
 347 #if 0 //def __WXUNIVERSAL__
 348     // account for the fact that (0, 0) is not the top left corner of the
 349     // window: there is also the border
 350     wxRect rectBorders = m_combo->GetRenderer()->
 351                             GetBorderDimensions(m_combo->GetBorder());
 352     ptOrigin.x -= rectBorders.x;
 353     ptOrigin.y -= rectBorders.y;
 354 #endif // __WXUNIVERSAL__
 355
 356     // position below or above the combobox: the width is 0 to put it exactly
 357     // below us, not to the left or to the right
 358     Position(ptOrigin, wxSize(0, m_combo->GetSize().y));
 359 }
 360
 361 void wxPopupComboWindow::OnDismiss()
 362 {
 363     m_combo->OnDismiss();
 364 }
 365
 366 void wxPopupComboWindow::OnKeyDown(wxKeyEvent& event)
 367 {
 368     m_combo->ProcessEvent(event);
 369 }
 370
 371 #endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 372
 373 // ----------------------------------------------------------------------------
 374 // wxPopupWindowHandler
 375 // ----------------------------------------------------------------------------
 376
 377 void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event)
 378 {
 379     // let the window have it first (we're the first event handler in the chain
 380     // of handlers for this window)
 381     if ( m_popup->ProcessLeftDown(event) )
 382     {
 383         return;
 384     }
 385
 386     wxPoint pos = event.GetPosition();
 387
 388     // scrollbar on which the click occured
 389     wxWindow *sbar = NULL;
 390
 391     wxWindow *win = (wxWindow *)event.GetEventObject();
 392
 393     switch ( win->HitTest(pos.x, pos.y) )
 394     {
 395         case wxHT_WINDOW_OUTSIDE:
 396             {
 397                 // do the coords translation now as after DismissAndNotify()
 398                 // m_popup may be destroyed
 399                 wxMouseEvent event2(event);
 400
 401                 m_popup->ClientToScreen(&event2.m_x, &event2.m_y);
 402
 403                 // clicking outside a popup dismisses it
 404                 m_popup->DismissAndNotify();
 405
 406                 // dismissing a tooltip shouldn't waste a click, i.e. you
 407                 // should be able to dismiss it and press the button with the
 408                 // same click, so repost this event to the window beneath us
 409                 wxWindow *win = wxFindWindowAtPoint(event2.GetPosition());
 410                 if ( win )
 411                 {
 412                     // translate the event coords to the ones of the window
 413                     // which is going to get the event
 414                     win->ScreenToClient(&event2.m_x, &event2.m_y);
 415
 416                     event2.SetEventObject(win);
 417                     wxPostEvent(win, event2);
 418                 }
 419             }
 420             break;
 421
 422 #ifdef __WXUNIVERSAL__
 423         case wxHT_WINDOW_HORZ_SCROLLBAR:
 424             sbar = win->GetScrollbar(wxHORIZONTAL);
 425             break;
 426
 427         case wxHT_WINDOW_VERT_SCROLLBAR:
 428             sbar = win->GetScrollbar(wxVERTICAL);
 429             break;
 430 #endif
 431
 432         default:
 433             // forgot to update the switch after adding a new hit test code?
 434             wxFAIL_MSG( _T("unexpected HitTest() return value") );
 435             // fall through
 436
 437         case wxHT_WINDOW_CORNER:
 438             // don't actually know if this one is good for anything, but let it
 439             // pass just in case
 440
 441         case wxHT_WINDOW_INSIDE:
 442             // let the normal processing take place
 443             event.Skip();
 444             break;
 445     }
 446
 447     if ( sbar )
 448     {
 449         // translate the event coordinates to the scrollbar ones
 450         pos = sbar->ScreenToClient(win->ClientToScreen(pos));
 451
 452         // and give the event to it
 453         wxMouseEvent event2 = event;
 454         event2.m_x = pos.x;
 455         event2.m_y = pos.y;
 456
 457         (void)sbar->GetEventHandler()->ProcessEvent(event2);
 458     }
 459 }
 460
 461 // ----------------------------------------------------------------------------
 462 // wxPopupFocusHandler
 463 // ----------------------------------------------------------------------------
 464
 465 void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event)
 466 {
 467     // when we lose focus we always disappear - unless it goes to the popup (in
 468     // which case we don't really lose it)
 469     wxWindow *win = event.GetWindow();
 470     while ( win )
 471     {
 472         if ( win == m_popup )
 473             return;
 474         win = win->GetParent();
 475     }
 476
 477     m_popup->DismissAndNotify();
 478 }
 479
 480 void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event)
 481 {
 482     // let the window have it first, it might process the keys
 483     if ( !m_popup->ProcessEvent(event) )
 484     {
 485         // by default, dismiss the popup
 486         m_popup->DismissAndNotify();
 487     }
 488 }
 489
 490 #endif // wxUSE_POPUPWIN
 491