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 license
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  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 && !defined(__WXMOTIF__)
  32
  33 #include "wx/popupwin.h"
  34
  35 #ifndef WX_PRECOMP
  36     #include "wx/combobox.h"        // wxComboControl
  37 #endif //WX_PRECOMP
  38
  39 #ifdef __WXUNIVERSAL__
  40     #include "wx/univ/renderer.h"
  41 #endif // __WXUNIVERSAL__
  42
  43 // there is no src/{msw,mgl}/popupwin.cpp to put this in, so we do it here - BTW we
  44 // probably could do it for all ports here just as well
  45 #if defined(__WXMSW__) || defined(__WXMGL__)
  46     IMPLEMENT_DYNAMIC_CLASS(wxPopupWindow, wxWindow)
  47 #endif // __WXMSW__
  48
  49 IMPLEMENT_DYNAMIC_CLASS(wxPopupTransientWindow, wxPopupWindow)
  50
  51 #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
  52     IMPLEMENT_DYNAMIC_CLASS(wxPopupComboWindow, wxPopupTransientWindow)
  53 #endif
  54
  55 // ----------------------------------------------------------------------------
  56 // private classes
  57 // ----------------------------------------------------------------------------
  58
  59 // event handlers which we use to intercept events which cause the popup to
  60 // disappear
  61 class wxPopupWindowHandler : public wxEvtHandler
  62 {
  63 public:
  64     wxPopupWindowHandler(wxPopupTransientWindow *popup) { m_popup = popup; }
  65
  66 protected:
  67     // event handlers
  68     void OnLeftDown(wxMouseEvent& event);
  69
  70 private:
  71     wxPopupTransientWindow *m_popup;
  72
  73     DECLARE_EVENT_TABLE()
  74 };
  75
  76 class wxPopupFocusHandler : public wxEvtHandler
  77 {
  78 public:
  79     wxPopupFocusHandler(wxPopupTransientWindow *popup)
  80     {
  81         m_popup = popup;
  82
  83 #ifdef __WXGTK__
  84         // ignore the next few OnKillFocus() calls
  85         m_creationTime = time(NULL);
  86 #endif // __WXGTK__
  87     }
  88
  89 protected:
  90     // event handlers
  91     void OnKillFocus(wxFocusEvent& event);
  92     void OnKeyDown(wxKeyEvent& event);
  93
  94 private:
  95     wxPopupTransientWindow *m_popup;
  96
  97     // hack around wxGTK bug: we always get several kill focus events
  98     // immediately after creation!
  99 #ifdef __WXGTK__
 100     time_t m_creationTime;
 101 #endif // __WXGTK__
 102
 103     DECLARE_EVENT_TABLE()
 104 };
 105
 106 // ----------------------------------------------------------------------------
 107 // event tables
 108 // ----------------------------------------------------------------------------
 109
 110 BEGIN_EVENT_TABLE(wxPopupWindowHandler, wxEvtHandler)
 111     EVT_LEFT_DOWN(wxPopupWindowHandler::OnLeftDown)
 112 END_EVENT_TABLE()
 113
 114 BEGIN_EVENT_TABLE(wxPopupFocusHandler, wxEvtHandler)
 115     EVT_KILL_FOCUS(wxPopupFocusHandler::OnKillFocus)
 116     EVT_KEY_DOWN(wxPopupFocusHandler::OnKeyDown)
 117 END_EVENT_TABLE()
 118
 119 // ============================================================================
 120 // implementation
 121 // ============================================================================
 122
 123 // ----------------------------------------------------------------------------
 124 // wxPopupWindowBase
 125 // ----------------------------------------------------------------------------
 126
 127 wxPopupWindowBase::~wxPopupWindowBase()
 128 {
 129     // this destructor is required for Darwin
 130 }
 131
 132 bool wxPopupWindowBase::Create(wxWindow* WXUNUSED(parent), int WXUNUSED(flags))
 133 {
 134     return TRUE;
 135 }
 136
 137 void wxPopupWindowBase::Position(const wxPoint& ptOrigin,
 138                                  const wxSize& size)
 139 {
 140     wxSize sizeScreen = wxGetDisplaySize(),
 141            sizeSelf = GetSize();
 142
 143     // is there enough space to put the popup below the window (where we put it
 144     // by default)?
 145     wxCoord y = ptOrigin.y + size.y;
 146     if ( y + sizeSelf.y > sizeScreen.y )
 147     {
 148         // check if there is enough space above
 149         if ( ptOrigin.y > sizeSelf.y )
 150         {
 151             // do position the control above the window
 152             y -= size.y + sizeSelf.y;
 153         }
 154         //else: not enough space below nor above, leave below
 155     }
 156
 157     // now check left/right too
 158     wxCoord x = ptOrigin.x + size.x;
 159     if ( x + sizeSelf.x > sizeScreen.x )
 160     {
 161         // check if there is enough space to the left
 162         if ( ptOrigin.x > sizeSelf.x )
 163         {
 164             // do position the control to the left
 165             x -= size.x + sizeSelf.x;
 166         }
 167         //else: not enough space there neither, leave in default position
 168     }
 169
 170     Move(x, y, wxSIZE_NO_ADJUSTMENTS);
 171 }
 172
 173 // ----------------------------------------------------------------------------
 174 // wxPopupTransientWindow
 175 // ----------------------------------------------------------------------------
 176
 177 void wxPopupTransientWindow::Init()
 178 {
 179     m_child =
 180     m_focus = (wxWindow *)NULL;
 181
 182     m_handlerFocus = NULL;
 183     m_handlerPopup = NULL;
 184 }
 185
 186 wxPopupTransientWindow::wxPopupTransientWindow(wxWindow *parent, int style)
 187 {
 188     Init();
 189
 190     (void)Create(parent, style);
 191 }
 192
 193 wxPopupTransientWindow::~wxPopupTransientWindow()
 194 {
 195     PopHandlers();
 196
 197     delete m_handlerFocus;
 198     delete m_handlerPopup;
 199 }
 200
 201 void wxPopupTransientWindow::PopHandlers()
 202 {
 203     if ( m_child )
 204     {
 205         if ( !m_child->RemoveEventHandler(m_handlerPopup) )
 206         {
 207             // something is very wrong and someone else probably deleted our
 208             // handler - so don't risk deleting it second time
 209             m_handlerPopup = NULL;
 210         }
 211
 212         m_child->ReleaseMouse();
 213         m_child = NULL;
 214     }
 215
 216     if ( m_focus )
 217     {
 218         if ( !m_focus->RemoveEventHandler(m_handlerFocus) )
 219         {
 220             // see above
 221             m_handlerFocus = NULL;
 222         }
 223
 224         m_focus = NULL;
 225     }
 226 }
 227
 228 void wxPopupTransientWindow::Popup(wxWindow *winFocus)
 229 {
 230     const wxWindowList& children = GetChildren();
 231     if ( children.GetCount() )
 232     {
 233         m_child = children.GetFirst()->GetData();
 234     }
 235     else
 236     {
 237         m_child = this;
 238     }
 239
 240     // we can't capture mouse before the window is shown in wxGTK, so do it
 241     // first
 242     Show();
 243
 244     delete m_handlerPopup;
 245     m_handlerPopup = new wxPopupWindowHandler(this);
 246
 247     m_child->CaptureMouse();
 248     m_child->PushEventHandler(m_handlerPopup);
 249
 250     m_focus = winFocus ? winFocus : this;
 251     m_focus->SetFocus();
 252
 253 #ifdef __WXMSW__
 254     // MSW doesn't allow to set focus to the popup window, but we need to
 255     // subclass the window which has the focus, and not winFocus passed in or
 256     // otherwise everything else breaks down
 257     m_focus = FindFocus();
 258     if ( m_focus )
 259 #endif // __WXMSW__
 260     {
 261         delete m_handlerFocus;
 262         m_handlerFocus = new wxPopupFocusHandler(this);
 263
 264         m_focus->PushEventHandler(m_handlerFocus);
 265     }
 266 }
 267
 268 void wxPopupTransientWindow::Dismiss()
 269 {
 270     PopHandlers();
 271
 272     Hide();
 273 }
 274
 275 void wxPopupTransientWindow::DismissAndNotify()
 276 {
 277     Dismiss();
 278
 279     OnDismiss();
 280 }
 281
 282 void wxPopupTransientWindow::OnDismiss()
 283 {
 284     // nothing to do here - but it may be interesting for derived class
 285 }
 286
 287 bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent& WXUNUSED(event))
 288 {
 289     // no special processing here
 290     return FALSE;
 291 }
 292
 293 #if wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 294
 295 // ----------------------------------------------------------------------------
 296 // wxPopupComboWindow
 297 // ----------------------------------------------------------------------------
 298
 299 wxPopupComboWindow::wxPopupComboWindow(wxComboControl *parent)
 300                   : wxPopupTransientWindow(parent)
 301 {
 302     m_combo = parent;
 303 }
 304
 305 bool wxPopupComboWindow::Create(wxComboControl *parent)
 306 {
 307     m_combo = parent;
 308
 309     return wxPopupWindow::Create(parent);
 310 }
 311
 312 void wxPopupComboWindow::PositionNearCombo()
 313 {
 314     // the origin point must be in screen coords
 315     wxPoint ptOrigin = m_combo->ClientToScreen(wxPoint(0, 0));
 316
 317 #if 0 //def __WXUNIVERSAL__
 318     // account for the fact that (0, 0) is not the top left corner of the
 319     // window: there is also the border
 320     wxRect rectBorders = m_combo->GetRenderer()->
 321                             GetBorderDimensions(m_combo->GetBorder());
 322     ptOrigin.x -= rectBorders.x;
 323     ptOrigin.y -= rectBorders.y;
 324 #endif // __WXUNIVERSAL__
 325
 326     // position below or above the combobox: the width is 0 to put it exactly
 327     // below us, not to the left or to the right
 328     Position(ptOrigin, wxSize(0, m_combo->GetSize().y));
 329 }
 330
 331 void wxPopupComboWindow::OnDismiss()
 332 {
 333     m_combo->OnDismiss();
 334 }
 335
 336 #endif // wxUSE_COMBOBOX && defined(__WXUNIVERSAL__)
 337
 338 // ----------------------------------------------------------------------------
 339 // wxPopupWindowHandler
 340 // ----------------------------------------------------------------------------
 341
 342 void wxPopupWindowHandler::OnLeftDown(wxMouseEvent& event)
 343 {
 344     // let the window have it first (we're the first event handler in the chain
 345     // of handlers for this window)
 346     if ( m_popup->ProcessLeftDown(event) )
 347     {
 348         return;
 349     }
 350
 351     wxPoint pos = event.GetPosition();
 352
 353     // scrollbar on which the click occured
 354     wxWindow *sbar = NULL;
 355
 356     wxWindow *win = (wxWindow *)event.GetEventObject();
 357     switch ( win->HitTest(pos.x, pos.y) )
 358     {
 359         case wxHT_WINDOW_OUTSIDE:
 360             // clicking outside a popup dismisses it
 361             m_popup->DismissAndNotify();
 362             break;
 363
 364 #ifdef __WXUNIVERSAL__
 365         case wxHT_WINDOW_HORZ_SCROLLBAR:
 366             sbar = win->GetScrollbar(wxHORIZONTAL);
 367             break;
 368
 369         case wxHT_WINDOW_VERT_SCROLLBAR:
 370             sbar = win->GetScrollbar(wxVERTICAL);
 371             break;
 372 #endif
 373
 374         default:
 375             // forgot to update the switch after adding a new hit test code?
 376             wxFAIL_MSG( _T("unexpected HitTest() return value") );
 377             // fall through
 378
 379         case wxHT_WINDOW_CORNER:
 380             // don't actually know if this one is good for anything, but let it
 381             // pass just in case
 382
 383         case wxHT_WINDOW_INSIDE:
 384             // let the normal processing take place
 385             event.Skip();
 386             break;
 387     }
 388
 389     if ( sbar )
 390     {
 391         // translate the event coordinates to the scrollbar ones
 392         pos = sbar->ScreenToClient(win->ClientToScreen(pos));
 393
 394         // and give the event to it
 395         wxMouseEvent event2 = event;
 396         event2.m_x = pos.x;
 397         event2.m_y = pos.y;
 398
 399         (void)sbar->GetEventHandler()->ProcessEvent(event2);
 400     }
 401 }
 402
 403 // ----------------------------------------------------------------------------
 404 // wxPopupFocusHandler
 405 // ----------------------------------------------------------------------------
 406
 407 void wxPopupFocusHandler::OnKillFocus(wxFocusEvent& event)
 408 {
 409 #ifdef __WXGTK__
 410     // ignore the next OnKillFocus() call
 411     if ( time(NULL) < m_creationTime + 1 )
 412     {
 413         event.Skip();
 414
 415         return;
 416     }
 417 #endif // __WXGTK__
 418
 419     // when we lose focus we always disappear - unless it goes to the popup (in
 420     // which case we don't really lose it)
 421     wxWindow *win = event.GetWindow();
 422     while ( win )
 423     {
 424         if ( win == m_popup )
 425             return;
 426         win = win->GetParent();
 427     }
 428     m_popup->DismissAndNotify();
 429 }
 430
 431 void wxPopupFocusHandler::OnKeyDown(wxKeyEvent& event)
 432 {
 433     // let the window have it first, it might process the keys
 434     if ( !m_popup->ProcessEvent(event) )
 435     {
 436         // by default, dismiss the popup
 437         m_popup->DismissAndNotify();
 438     }
 439 }
 440
 441 #endif // wxUSE_POPUPWIN
 442