src/common/event.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        event.cpp
   3 // Purpose:     Event classes
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:       wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "event.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/defs.h"
  25     #include "wx/control.h"
  26     #include "wx/utils.h"
  27     #include "wx/app.h"
  28     #include "wx/dc.h"
  29 #endif
  30
  31 #include "wx/event.h"
  32 #include "wx/validate.h"
  33
  34 #if !USE_SHARED_LIBRARY
  35     IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
  36     IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
  37     IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
  38     IMPLEMENT_DYNAMIC_CLASS(wxNotifyEvent, wxCommandEvent)
  39     IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
  40     IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
  41     IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
  42     IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
  43     IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
  44     IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
  45     IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
  46     IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
  47     IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
  48     IMPLEMENT_DYNAMIC_CLASS(wxShowEvent, wxEvent)
  49     IMPLEMENT_DYNAMIC_CLASS(wxMaximizeEvent, wxEvent)
  50     IMPLEMENT_DYNAMIC_CLASS(wxIconizeEvent, wxEvent)
  51     IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
  52     IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
  53     IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
  54     IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
  55     IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
  56     IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
  57     IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
  58     IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxCommandEvent)
  59     IMPLEMENT_DYNAMIC_CLASS(wxNavigationKeyEvent, wxCommandEvent)
  60     IMPLEMENT_DYNAMIC_CLASS(wxPaletteChangedEvent, wxEvent)
  61     IMPLEMENT_DYNAMIC_CLASS(wxQueryNewPaletteEvent, wxEvent)
  62
  63     const wxEventTable *wxEvtHandler::GetEventTable() const
  64         { return &wxEvtHandler::sm_eventTable; }
  65
  66     const wxEventTable wxEvtHandler::sm_eventTable =
  67         { (const wxEventTable *)NULL, &wxEvtHandler::sm_eventTableEntries[0] };
  68
  69     const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
  70         { { 0, 0, 0,
  71     #ifdef __SGI_CC__
  72         // stupid SGI compiler --- offer aug 98
  73         0L }
  74     #else // !SGI CC
  75         NULL }
  76     #endif // SGI/!SGI
  77         };
  78
  79 #endif // !USE_SHARED_LIBRARY
  80
  81 /*
  82  * General wxWindows events, covering
  83  * all interesting things that might happen (button clicking, resizing,
  84  * setting text in widgets, etc.).
  85  *
  86  * For each completely new event type, derive a new event class.
  87  *
  88  */
  89
  90 wxEvent::wxEvent(int theId)
  91 {
  92     m_eventType = wxEVT_NULL;
  93     m_eventObject = (wxObject *) NULL;
  94     m_eventHandle = (char *) NULL;
  95     m_timeStamp = 0;
  96     m_id = theId;
  97     m_skipped = FALSE;
  98     m_callbackUserData = (wxObject *) NULL;
  99     m_isCommandEvent = FALSE;
 100 }
 101
 102 /*
 103  * Command events
 104  *
 105  */
 106
 107 wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
 108 {
 109     m_eventType = commandType;
 110     m_clientData = (char *) NULL;
 111     m_clientObject = (wxClientData *) NULL;
 112     m_extraLong = 0;
 113     m_commandInt = 0;
 114     m_id = theId;
 115     m_commandString = (char *) NULL;
 116     m_isCommandEvent = TRUE;
 117 }
 118
 119 /*
 120  * Scroll events
 121  */
 122
 123 wxScrollEvent::wxScrollEvent(wxEventType commandType,
 124                              int id,
 125                              int pos,
 126                              int orient)
 127              : wxCommandEvent(commandType, id)
 128 {
 129     m_extraLong = orient;
 130     m_commandInt = pos;
 131 }
 132
 133
 134 /*
 135  * Mouse events
 136  *
 137  */
 138
 139 wxMouseEvent::wxMouseEvent(wxEventType commandType)
 140 {
 141     m_eventType = commandType;
 142     m_metaDown = FALSE;
 143     m_altDown = FALSE;
 144     m_controlDown = FALSE;
 145     m_shiftDown = FALSE;
 146     m_leftDown = FALSE;
 147     m_rightDown = FALSE;
 148     m_middleDown = FALSE;
 149     m_x = 0;
 150     m_y = 0;
 151 }
 152
 153 // True if was a button dclick event (1 = left, 2 = middle, 3 = right)
 154 // or any button dclick event (but = -1)
 155 bool wxMouseEvent::ButtonDClick(int but) const
 156 {
 157     switch (but)
 158     {
 159         case -1:
 160             return (LeftDClick() || MiddleDClick() || RightDClick());
 161         case 1:
 162             return LeftDClick();
 163         case 2:
 164             return MiddleDClick();
 165         case 3:
 166             return RightDClick();
 167         default:
 168             wxFAIL_MSG("invalid parameter in wxMouseEvent::ButtonDClick");
 169     }
 170
 171     return FALSE;
 172 }
 173
 174 // True if was a button down event (1 = left, 2 = middle, 3 = right)
 175 // or any button down event (but = -1)
 176 bool wxMouseEvent::ButtonDown(int but) const
 177 {
 178     switch (but)
 179     {
 180         case -1:
 181             return (LeftDown() || MiddleDown() || RightDown());
 182         case 1:
 183             return LeftDown();
 184         case 2:
 185             return MiddleDown();
 186         case 3:
 187             return RightDown();
 188         default:
 189             wxFAIL_MSG("invalid parameter in wxMouseEvent::ButtonDown");
 190     }
 191
 192     return FALSE;
 193 }
 194
 195 // True if was a button up event (1 = left, 2 = middle, 3 = right)
 196 // or any button up event (but = -1)
 197 bool wxMouseEvent::ButtonUp(int but) const
 198 {
 199     switch (but) {
 200         case -1:
 201             return (LeftUp() || MiddleUp() || RightUp());
 202         case 1:
 203             return LeftUp();
 204         case 2:
 205             return MiddleUp();
 206         case 3:
 207             return RightUp();
 208         default:
 209             wxFAIL_MSG("invalid parameter in wxMouseEvent::ButtonUp");
 210     }
 211
 212     return FALSE;
 213 }
 214
 215 // True if the given button is currently changing state
 216 bool wxMouseEvent::Button(int but) const
 217 {
 218     switch (but) {
 219         case -1:
 220             return (ButtonUp(-1) || ButtonDown(-1) || ButtonDClick(-1)) ;
 221         case 1:
 222             return (LeftDown() || LeftUp() || LeftDClick());
 223         case 2:
 224             return (MiddleDown() || MiddleUp() || MiddleDClick());
 225         case 3:
 226             return (RightDown() || RightUp() || RightDClick());
 227         default:
 228             wxFAIL_MSG("invalid parameter in wxMouseEvent::Button");
 229     }
 230
 231     return FALSE;
 232 }
 233
 234 bool wxMouseEvent::ButtonIsDown(int but) const
 235 {
 236     switch (but) {
 237         case -1:
 238             return (LeftIsDown() || MiddleIsDown() || RightIsDown());
 239         case 1:
 240             return LeftIsDown();
 241         case 2:
 242             return MiddleIsDown();
 243         case 3:
 244             return RightIsDown();
 245         default:
 246             wxFAIL_MSG("invalid parameter in wxMouseEvent::ButtonIsDown");
 247     }
 248
 249     return FALSE;
 250 }
 251
 252 // Find the logical position of the event given the DC
 253 wxPoint wxMouseEvent::GetLogicalPosition(const wxDC& dc) const
 254 {
 255     wxPoint pt(dc.DeviceToLogicalX(m_x), dc.DeviceToLogicalY(m_y));
 256     return pt;
 257 }
 258
 259
 260 /*
 261  * Keyboard events
 262  *
 263  */
 264
 265 wxKeyEvent::wxKeyEvent(wxEventType type)
 266 {
 267     m_eventType = type;
 268     m_shiftDown = FALSE;
 269     m_controlDown = FALSE;
 270     m_metaDown = FALSE;
 271     m_altDown = FALSE;
 272     m_keyCode = 0;
 273 }
 274
 275 /*
 276  * Event handler
 277  */
 278
 279 wxEvtHandler::wxEvtHandler()
 280 {
 281     m_nextHandler = (wxEvtHandler *) NULL;
 282     m_previousHandler = (wxEvtHandler *) NULL;
 283     m_enabled = TRUE;
 284     m_dynamicEvents = (wxList *) NULL;
 285     m_isWindow = FALSE;
 286 }
 287
 288 wxEvtHandler::~wxEvtHandler()
 289 {
 290     // Takes itself out of the list of handlers
 291     if (m_previousHandler)
 292         m_previousHandler->m_nextHandler = m_nextHandler;
 293
 294     if (m_nextHandler)
 295         m_nextHandler->m_previousHandler = m_previousHandler;
 296
 297     if (m_dynamicEvents)
 298     {
 299         wxNode *node = m_dynamicEvents->First();
 300         while (node)
 301         {
 302             wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
 303             if (entry->m_callbackUserData) delete entry->m_callbackUserData;
 304             delete entry;
 305             node = node->Next();
 306         }
 307         delete m_dynamicEvents;
 308     };
 309 }
 310
 311 /*
 312  * Event table stuff
 313  */
 314
 315 bool wxEvtHandler::ProcessEvent(wxEvent& event)
 316 {
 317     // check that our flag corresponds to reality
 318     wxASSERT( m_isWindow == IsKindOf(CLASSINFO(wxWindow)) );
 319
 320     // An event handler can be enabled or disabled
 321     if ( GetEvtHandlerEnabled() )
 322     {
 323         // Handle per-instance dynamic event tables first
 324
 325         if ( m_dynamicEvents && SearchDynamicEventTable(event) )
 326             return TRUE;
 327
 328         // Then static per-class event tables
 329
 330         const wxEventTable *table = GetEventTable();
 331
 332         // Try the associated validator first, if this is a window.
 333         // Problem: if the event handler of the window has been replaced,
 334         // this wxEvtHandler may no longer be a window.
 335         // Therefore validators won't be processed if the handler
 336         // has been replaced with SetEventHandler.
 337         // THIS CAN BE CURED if PushEventHandler is used instead of
 338         // SetEventHandler, and then processing will be passed down the
 339         // chain of event handlers.
 340         if ( m_isWindow )
 341         {
 342             wxWindow *win = (wxWindow *)this;
 343
 344             // Can only use the validator of the window which
 345             // is receiving the event
 346             if ( win == event.GetEventObject() )
 347             {
 348                 wxValidator *validator = win->GetValidator();
 349                 if ( validator && validator->ProcessEvent(event) )
 350                 {
 351                     return TRUE;
 352                 }
 353             }
 354         }
 355
 356         // Search upwards through the inheritance hierarchy
 357         while ( table )
 358         {
 359             if ( SearchEventTable((wxEventTable&)*table, event) )
 360                 return TRUE;
 361             table = table->baseTable;
 362         }
 363     }
 364
 365     // Try going down the event handler chain
 366     if ( GetNextHandler() )
 367     {
 368         if ( GetNextHandler()->ProcessEvent(event) )
 369             return TRUE;
 370     }
 371
 372     // Carry on up the parent-child hierarchy,
 373     // but only if event is a command event: it wouldn't
 374     // make sense for a parent to receive a child's size event, for example
 375     if ( m_isWindow && event.IsCommandEvent() )
 376     {
 377         wxWindow *win = (wxWindow *)this;
 378         wxWindow *parent = win->GetParent();
 379         if (parent && !parent->IsBeingDeleted())
 380             return parent->GetEventHandler()->ProcessEvent(event);
 381     }
 382
 383     // Last try - application object.
 384     if ( wxTheApp && (this != wxTheApp) )
 385     {
 386         // Special case: don't pass wxEVT_IDLE to wxApp, since it'll always
 387         // swallow it. wxEVT_IDLE is sent explicitly to wxApp so it will be
 388         // processed appropriately via SearchEventTable.
 389         if ( event.GetEventType() != wxEVT_IDLE )
 390         {
 391             if ( wxTheApp->ProcessEvent(event) )
 392                 return TRUE;
 393         }
 394     }
 395
 396     return FALSE;
 397 }
 398
 399 bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
 400 {
 401     int i = 0;
 402     int commandId = event.GetId();
 403
 404     // BC++ doesn't like while (table.entries[i].m_fn)
 405
 406 #ifdef __SC__
 407     while (table.entries[i].m_fn != 0)
 408 #else
 409     while (table.entries[i].m_fn != 0L)
 410 #endif
 411     {
 412         if ((event.GetEventType() == table.entries[i].m_eventType) &&
 413                 (table.entries[i].m_id == -1 || // Match, if event spec says any id will do (id == -1)
 414                  (table.entries[i].m_lastId == -1 && commandId == table.entries[i].m_id) ||
 415                  (table.entries[i].m_lastId != -1 &&
 416                   (commandId >= table.entries[i].m_id && commandId <= table.entries[i].m_lastId))))
 417         {
 418             event.Skip(FALSE);
 419             event.m_callbackUserData = table.entries[i].m_callbackUserData;
 420
 421             (this->*((wxEventFunction) (table.entries[i].m_fn)))(event);
 422
 423             if ( event.GetSkipped() )
 424                 return FALSE;
 425             else
 426                 return TRUE;
 427         }
 428         i++;
 429     }
 430     return FALSE;
 431 }
 432 void wxEvtHandler::Connect( int id, int lastId,
 433                             wxEventType eventType,
 434                             wxObjectEventFunction func,
 435                             wxObject *userData )
 436 {
 437     wxEventTableEntry *entry = new wxEventTableEntry;
 438     entry->m_id = id;
 439     entry->m_lastId = lastId;
 440     entry->m_eventType = eventType;
 441     entry->m_fn = func;
 442     entry->m_callbackUserData = userData;
 443
 444     if (!m_dynamicEvents)
 445         m_dynamicEvents = new wxList;
 446
 447     m_dynamicEvents->Append( (wxObject*) entry );
 448 }
 449
 450 bool wxEvtHandler::SearchDynamicEventTable( wxEvent& event )
 451 {
 452     wxCHECK_MSG( m_dynamicEvents, FALSE,
 453                  "caller should check that we have dynamic events" );
 454
 455     int commandId = event.GetId();
 456
 457     wxNode *node = m_dynamicEvents->First();
 458     while (node)
 459     {
 460         wxEventTableEntry *entry = (wxEventTableEntry*)node->Data();
 461
 462         if (entry->m_fn)
 463         {
 464             // Match, if event spec says any id will do (id == -1)
 465             if ( (event.GetEventType() == entry->m_eventType) &&
 466                  (entry->m_id == -1 ||
 467                   (entry->m_lastId == -1 && commandId == entry->m_id) ||
 468                   (entry->m_lastId != -1 &&
 469                   (commandId >= entry->m_id && commandId <= entry->m_lastId))) )
 470             {
 471                 event.Skip(FALSE);
 472                 event.m_callbackUserData = entry->m_callbackUserData;
 473
 474                 (this->*((wxEventFunction) (entry->m_fn)))(event);
 475
 476                 if (event.GetSkipped())
 477                     return FALSE;
 478                 else
 479                     return TRUE;
 480             }
 481         }
 482         node = node->Next();
 483     }
 484     return FALSE;
 485 };
 486
 487 #if WXWIN_COMPATIBILITY
 488 bool wxEvtHandler::OnClose()
 489 {
 490     if (GetNextHandler())
 491         return GetNextHandler()->OnClose();
 492     else
 493         return FALSE;
 494 }
 495 #endif // WXWIN_COMPATIBILITY
 496