#if wxUSE_GUI
#include "wx/validate.h"
+#if wxUSE_STOPWATCH
+ #include "wx/stopwatch.h"
+#endif
#endif // wxUSE_GUI
// ----------------------------------------------------------------------------
const wxEventTable wxEvtHandler::sm_eventTable =
{ (const wxEventTable *)NULL, &wxEvtHandler::sm_eventTableEntries[0] };
+wxEventHashTable &wxEvtHandler::GetEventHashTable() const
+ { return wxEvtHandler::sm_eventHashTable; }
+
+wxEventHashTable wxEvtHandler::sm_eventHashTable(wxEvtHandler::sm_eventTable);
+
const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] =
{ DECLARE_EVENT_TABLE_ENTRY(wxEVT_NULL, 0, 0, (wxObjectEventFunction)NULL, NULL) };
// common event types are defined here, other event types are defined by the
// components which use them
-
+
const wxEventType wxEVT_FIRST = 10000;
const wxEventType wxEVT_USER_FIRST = wxEVT_FIRST + 2000;
DEFINE_EVENT_TYPE(wxEVT_NAVIGATION_KEY)
DEFINE_EVENT_TYPE(wxEVT_KEY_DOWN)
DEFINE_EVENT_TYPE(wxEVT_KEY_UP)
+#if wxUSE_HOTKEY
+DEFINE_EVENT_TYPE(wxEVT_HOTKEY)
+#endif
// Set cursor event
DEFINE_EVENT_TYPE(wxEVT_SET_CURSOR)
m_skipped = FALSE;
m_callbackUserData = (wxObject *) NULL;
m_isCommandEvent = FALSE;
+ m_propagationLevel = wxEVENT_PROPAGATE_NONE;
}
wxEvent::wxEvent(const wxEvent &src)
, m_timeStamp(src.m_timeStamp)
, m_id(src.m_id)
, m_callbackUserData(src.m_callbackUserData)
+ , m_propagationLevel(src.m_propagationLevel)
, m_skipped(src.m_skipped)
, m_isCommandEvent(src.m_isCommandEvent)
{
*/
wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
- : wxEvent(theId, commandType)
+ : wxEvent(theId, commandType)
{
m_clientData = (char *) NULL;
m_clientObject = (wxClientData *) NULL;
m_extraLong = 0;
m_commandInt = 0;
- m_commandString = wxEmptyString;
m_isCommandEvent = TRUE;
+
+ // the command events are propagated upwards by default
+ m_propagationLevel = wxEVENT_PROPAGATE_MAX;
+}
+
+/*
+ * UI update events
+ */
+
+#if wxUSE_LONGLONG
+wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;
+#endif
+
+long wxUpdateUIEvent::sm_updateInterval = 0;
+
+wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL;
+
+// Can we update?
+bool wxUpdateUIEvent::CanUpdate(wxWindowBase *win)
+{
+ // Don't update if we've switched global updating off
+ // and this window doesn't support updates.
+ if (win &&
+ (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED &&
+ ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0)))
+ return FALSE;
+
+ if (sm_updateInterval == -1)
+ return FALSE;
+ else if (sm_updateInterval == 0)
+ return TRUE;
+ else
+ {
+#if wxUSE_STOPWATCH && wxUSE_LONGLONG
+ wxLongLong now = wxGetLocalTimeMillis();
+ if (now > (sm_lastUpdate + sm_updateInterval))
+ {
+ return TRUE;
+ }
+#else
+ // If we don't have wxStopWatch or wxLongLong, we
+ // should err on the safe side and update now anyway.
+ return TRUE;
+#endif
+ }
+ return FALSE;
+}
+
+// Reset the update time to provide a delay until the next
+// time we should update
+void wxUpdateUIEvent::ResetUpdateTime()
+{
+#if wxUSE_STOPWATCH && wxUSE_LONGLONG
+ if (sm_updateInterval > 0)
+ {
+ wxLongLong now = wxGetLocalTimeMillis();
+ if (now > (sm_lastUpdate + sm_updateInterval))
+ {
+ sm_lastUpdate = now;
+ }
+ }
+#endif
+}
+
+/*
+ * Idle events
+ */
+
+wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL;
+
+// Can we send an idle event?
+bool wxIdleEvent::CanSend(wxWindow* win)
+{
+ // Don't update if we've switched global updating off
+ // and this window doesn't support updates.
+ if (win &&
+ (GetMode() == wxIDLE_PROCESS_SPECIFIED &&
+ ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0)))
+ return FALSE;
+
+ return TRUE;
}
/*
#endif // wxUSE_GUI
+
+#if wxUSE_BASE
+
// ----------------------------------------------------------------------------
-// wxEvtHandler
+// wxEventHashTable
// ----------------------------------------------------------------------------
-#if wxUSE_BASE
+static const int EVENT_TYPE_TABLE_INIT_SIZE = 31; // Not to big not to small...
+
+wxEventHashTable::wxEventHashTable(const wxEventTable &table)
+ : m_table(table),
+ m_rebuildHash(TRUE)
+{
+ AllocEventTypeTable(EVENT_TYPE_TABLE_INIT_SIZE);
+}
+
+wxEventHashTable::~wxEventHashTable()
+{
+ size_t i;
+ for(i = 0; i < m_size; i++)
+ {
+ EventTypeTablePointer eTTnode = m_eventTypeTable[i];
+ if (eTTnode)
+ {
+ delete eTTnode;
+ }
+ }
+
+ delete[] m_eventTypeTable;
+}
+
+bool wxEventHashTable::HandleEvent(wxEvent &event, wxEvtHandler *self)
+{
+ if (m_rebuildHash)
+ {
+ InitHashTable();
+ m_rebuildHash = FALSE;
+ }
+
+ // Find all entries for the given event type.
+ wxEventType eventType = event.GetEventType();
+ const EventTypeTablePointer eTTnode = m_eventTypeTable[eventType % m_size];
+ if (eTTnode && eTTnode->eventType == eventType)
+ {
+ // Now start the search for an event handler
+ // that can handle an event with the given ID.
+ int eventId = event.GetId();
+ const wxEventTableEntryPointerArray &eventEntryTable = eTTnode->eventEntryTable;
+
+ size_t n;
+ size_t count = eventEntryTable.GetCount();
+ for (n = 0; n < count; n++)
+ {
+ const wxEventTableEntry* entry = eventEntryTable[n];
+ int tableId1 = entry->m_id,
+ tableId2 = entry->m_lastId;
+
+ if ((tableId1 == -1) ||
+ (tableId2 == -1 && tableId1 == eventId) ||
+ (tableId2 != -1 &&
+ (eventId >= tableId1 && eventId <= tableId2)))
+ {
+ event.Skip(FALSE);
+ event.m_callbackUserData = entry->m_callbackUserData;
+
+ (self->*((wxEventFunction) (entry->m_fn)))(event);
+
+ if (!event.GetSkipped())
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+ }
+
+ return FALSE;
+}
+
+void wxEventHashTable::InitHashTable()
+{
+ // Loop over the event tables and all its base tables.
+ const wxEventTable *table = &m_table;
+ while (table)
+ {
+ // Retrieve all valid event handler entries
+ const wxEventTableEntry *entry = table->entries;
+ while (entry->m_fn != 0)
+ {
+ // Add the event entry in the Hash.
+ AddEntry(*entry);
+
+ entry++;
+ }
+
+ table = table->baseTable;
+ }
+
+ // Lets free some memory.
+ size_t i;
+ for(i = 0; i < m_size; i++)
+ {
+ EventTypeTablePointer eTTnode = m_eventTypeTable[i];
+ if (eTTnode)
+ {
+ eTTnode->eventEntryTable.Shrink();
+ }
+ }
+}
+
+void wxEventHashTable::AddEntry(const wxEventTableEntry &entry)
+{
+ EventTypeTablePointer *peTTnode = &m_eventTypeTable[entry.m_eventType % m_size];
+ EventTypeTablePointer eTTnode = *peTTnode;
+
+ if (eTTnode)
+ {
+ if (eTTnode->eventType != entry.m_eventType)
+ {
+ // Resize the table!
+ GrowEventTypeTable();
+ // Try again to add it.
+ AddEntry(entry);
+ return;
+ }
+ }
+ else
+ {
+ eTTnode = new EventTypeTable;
+ eTTnode->eventType = entry.m_eventType;
+ *peTTnode = eTTnode;
+ }
+
+ // Fill all hash entries between entry.m_id and entry.m_lastId...
+ eTTnode->eventEntryTable.Add(&entry);
+}
+
+void wxEventHashTable::AllocEventTypeTable(size_t size)
+{
+ m_eventTypeTable = new EventTypeTablePointer[size];
+ memset((void *)m_eventTypeTable, 0, sizeof(EventTypeTablePointer)*size);
+ m_size = size;
+}
+
+void wxEventHashTable::GrowEventTypeTable()
+{
+ size_t oldSize = m_size;
+ EventTypeTablePointer *oldEventTypeTable = m_eventTypeTable;
+
+ // TODO: Search the most optimal grow sequence
+ AllocEventTypeTable(/* GetNextPrime(oldSize) */oldSize*2+1);
+
+ for ( size_t i = 0; i < oldSize; /* */ )
+ {
+ EventTypeTablePointer eTToldNode = oldEventTypeTable[i];
+ if (eTToldNode)
+ {
+ EventTypeTablePointer *peTTnode = &m_eventTypeTable[eTToldNode->eventType % m_size];
+ EventTypeTablePointer eTTnode = *peTTnode;
+
+ // Check for collision, we don't want any.
+ if (eTTnode)
+ {
+ GrowEventTypeTable();
+ continue; // Don't increment the counter,
+ // as we still need to add this element.
+ }
+ else
+ {
+ // Get the old value and put it in the new table.
+ *peTTnode = oldEventTypeTable[i];
+ }
+ }
+
+ i++;
+ }
+
+ delete[] oldEventTypeTable;
+}
+
+// ----------------------------------------------------------------------------
+// wxEvtHandler
+// ----------------------------------------------------------------------------
/*
* Event handler
if (m_dynamicEvents)
{
- wxNode *node = m_dynamicEvents->GetFirst();
- while (node)
+ wxList::iterator it = m_dynamicEvents->begin(),
+ en = m_dynamicEvents->end();
+ for (;it != en; ++it)
{
#if WXWIN_COMPATIBILITY_EVENT_TYPES
- wxEventTableEntry *entry = (wxEventTableEntry*)node->GetData();
+ wxEventTableEntry *entry = (wxEventTableEntry*)*it;
#else // !WXWIN_COMPATIBILITY_EVENT_TYPES
- wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
+ wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)*it;
#endif // WXWIN_COMPATIBILITY_EVENT_TYPES/!WXWIN_COMPATIBILITY_EVENT_TYPES
if (entry->m_callbackUserData)
delete entry->m_callbackUserData;
delete entry;
- node = node->GetNext();
}
delete m_dynamicEvents;
};
# if !defined(__VISAGECPP__)
delete m_eventsLocker;
# endif
-
+
// Remove us from wxPendingEvents if necessary.
if(wxPendingEventsLocker)
wxENTER_CRIT_SECT(*wxPendingEventsLocker);
wxENTER_CRIT_SECT( *m_eventsLocker);
#endif
- wxNode *node = m_pendingEvents->GetFirst();
+ wxList::compatibility_iterator node = m_pendingEvents->GetFirst();
while ( node )
{
wxEvent *event = (wxEvent *)node->GetData();
- delete node;
+ m_pendingEvents->Erase(node);
// In ProcessEvent, new events might get added and
// we can safely leave the crtical section here.
if ( m_dynamicEvents && SearchDynamicEventTable(event) )
return TRUE;
- // Then static per-class event tables (and search upwards through the
- // inheritance hierarchy)
- for ( const wxEventTable *table = GetEventTable();
- table;
- table = table->baseTable )
- {
- if ( SearchEventTable((wxEventTable&)*table, event) )
- return TRUE;
- }
+ // Then static per-class event tables
+ if ( GetEventHashTable().HandleEvent(event, this) )
+ return TRUE;
}
// Try going down the event handler chain
return TryParent(event);
}
+
bool wxEvtHandler::SearchEventTable(wxEventTable& table, wxEvent& event)
{
wxEventType eventType = event.GetEventType();
if (!m_dynamicEvents)
return FALSE;
- wxNode *node = m_dynamicEvents->GetFirst();
+ wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
while (node)
{
#if WXWIN_COMPATIBILITY_EVENT_TYPES
{
if (entry->m_callbackUserData)
delete entry->m_callbackUserData;
- m_dynamicEvents->DeleteNode( node );
+ m_dynamicEvents->Erase( node );
delete entry;
return TRUE;
}
int commandId = event.GetId();
- wxNode *node = m_dynamicEvents->GetFirst();
+ wxList::compatibility_iterator node = m_dynamicEvents->GetFirst();
while (node)
{
#if WXWIN_COMPATIBILITY_EVENT_TYPES
if (entry->m_eventSink)
((entry->m_eventSink)->*((wxEventFunction) (entry->m_fn)))(event);
else
-#endif
+#endif
(this->*((wxEventFunction) (entry->m_fn)))(event);
if ( ! event.GetSkipped() )
projects / wxWidgets.git / blobdiff