diff --git a/EventMonitor/App.cpp b/EventMonitor/App.cpp index 237b955..40249eb 100644 --- a/EventMonitor/App.cpp +++ b/EventMonitor/App.cpp @@ -78,7 +78,7 @@ bool wxEventMonitorApp::OnInit() } #endif - m_mainWnd = new wxEventMonitorFrame(); + m_mainWnd = new wxEventMonitorFrame(NULL); wxPersistentRegisterAndRestore(m_mainWnd); m_mainWnd->Show(); diff --git a/EventMonitor/ETWLog.cpp b/EventMonitor/ETWLog.cpp index 929fc33..5fbf8ce 100644 --- a/EventMonitor/ETWLog.cpp +++ b/EventMonitor/ETWLog.cpp @@ -48,8 +48,6 @@ wxETWEvent::wxETWEvent(wxEventType type, const EVENT_RECORD &record) : m_record(record), wxEvent(0, type) { - DoSetExtendedData(record.ExtendedDataCount, record.ExtendedData); - DoSetUserData(record.UserDataLength, record.UserData); } @@ -57,92 +55,6 @@ wxETWEvent::wxETWEvent(const wxETWEvent& event) : m_record(event.m_record), wxEvent(event) { - DoSetExtendedData(event.m_record.ExtendedDataCount, event.m_record.ExtendedData); - DoSetUserData(event.m_record.UserDataLength, event.m_record.UserData); -} - - -wxETWEvent::~wxETWEvent() -{ - if (m_record.ExtendedData) - delete (unsigned char*)m_record.ExtendedData; - - if (m_record.UserData) - delete (unsigned char*)m_record.UserData; -} - - -bool wxETWEvent::SetExtendedData(size_t extended_data_count, const EVENT_HEADER_EXTENDED_DATA_ITEM *extended_data) -{ - if (m_record.ExtendedData) - delete (unsigned char*)m_record.ExtendedData; - - return DoSetExtendedData(extended_data_count, extended_data); -} - - -bool wxETWEvent::SetUserData(size_t user_data_length, const void *user_data) -{ - if (m_record.UserData) - delete (unsigned char*)m_record.UserData; - - return DoSetUserData(user_data_length, user_data); -} - - -bool wxETWEvent::DoSetExtendedData(size_t extended_data_count, const EVENT_HEADER_EXTENDED_DATA_ITEM *extended_data) -{ - if (extended_data_count) { - wxASSERT_MSG(extended_data, wxT("extended data is NULL")); - - // Count the total required memory. - size_t data_size = 0; - for (size_t i = 0; i < extended_data_count; i++) - data_size += extended_data[i].DataSize; - - // Allocate memory for extended data. - m_record.ExtendedData = (EVENT_HEADER_EXTENDED_DATA_ITEM*)(new unsigned char[sizeof(EVENT_HEADER_EXTENDED_DATA_ITEM)*extended_data_count + data_size]); - wxCHECK_MSG(m_record.ExtendedData, false, wxT("extended data memory allocation failed")); - - // Bulk-copy extended data descriptors. - memcpy(m_record.ExtendedData, extended_data, sizeof(EVENT_HEADER_EXTENDED_DATA_ITEM) * extended_data_count); - - // Copy the data. - unsigned char *ptr = (unsigned char*)(m_record.ExtendedData + extended_data_count); - for (size_t i = 0; i < extended_data_count; i++) { - if (extended_data[i].DataSize) { - memcpy(ptr, (void*)(extended_data[i].DataPtr), extended_data[i].DataSize); - m_record.ExtendedData[i].DataPtr = (ULONGLONG)ptr; - ptr += extended_data[i].DataSize; - } else - m_record.ExtendedData[i].DataPtr = NULL; - } - } else - m_record.ExtendedData = NULL; - - m_record.ExtendedDataCount = extended_data_count; - - return true; -} - - -bool wxETWEvent::DoSetUserData(size_t user_data_length, const void *user_data) -{ - if (user_data_length) { - wxASSERT_MSG(user_data, wxT("user data is NULL")); - - // Allocate memory for user data. - m_record.UserData = new unsigned char[user_data_length]; - wxCHECK_MSG(m_record.UserData, false, wxT("user data memory allocation failed")); - - // Copy user data. - memcpy(m_record.UserData, user_data, user_data_length); - } else - m_record.UserData = NULL; - - m_record.UserDataLength = user_data_length; - - return true; } @@ -238,12 +150,22 @@ END_EVENT_TABLE() // {6EB8DB94-FE96-443F-A366-5FE0CEE7FB1C} -const GUID wxETWListCtrl::s_provider_eaphost = { 0X6EB8DB94, 0XFE96, 0X443F, { 0XA3, 0X66, 0X5F, 0XE0, 0XCE, 0XE7, 0XFB, 0X1C } }; +const GUID wxETWListCtrl::s_provider_eaphost = { 0x6EB8DB94, 0xFE96, 0x443F, { 0xA3, 0x66, 0x5F, 0xE0, 0xCE, 0xE7, 0xFB, 0x1C } }; + +// {1F678132-5938-4686-9FDC-C8FF68F15C85} +const GUID wxETWListCtrl::s_provider_schannel = { 0x1F678132, 0x5938, 0x4686, { 0x9F, 0xDC, 0xC8, 0xFF, 0x68, 0xF1, 0x5C, 0x85 } }; wxETWListCtrl::wxETWListCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator, const wxString& name) : m_proc(NULL), m_item_id(0), + m_scroll_auto(true), + m_source_eaphost(false), + m_source_schannel(false), + m_source_product(true), + m_level(TRACE_LEVEL_INFORMATION), + m_rec_db(wxETWEVENT_RECORDS_MAX), + m_rec_idx(wxETWEVENT_RECORDS_MAX), wxListCtrl(parent, id, pos, size, style, validator, name) { this->AppendColumn(_("Time" ), wxLIST_FORMAT_LEFT, 100); @@ -252,6 +174,32 @@ wxETWListCtrl::wxETWListCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos this->AppendColumn(_("Source"), wxLIST_FORMAT_LEFT, 100); this->AppendColumn(_("Event" ), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE_USEHEADER); + // Maximum expected column widths for pre-formatted row display + m_col_format_width[0] = 26; + m_col_format_width[1] = 5; + m_col_format_width[2] = 5; + m_col_format_width[3] = std::max(std::max(_countof("EAPHost"), _countof("Schannel")), _countof(PRODUCT_NAME_STR)) - 1; + m_col_format_width[4] = 0; + + // Prepare all possible item attributes. + wxColour col_bg((unsigned long)0xffffff); + m_item_attr[0][0].SetBackgroundColour(col_bg ); + m_item_attr[0][0].SetTextColour ((unsigned long)0x666666); + m_item_attr[0][1].SetBackgroundColour(col_bg ); + m_item_attr[0][1].SetTextColour ((unsigned long)0x000000); + m_item_attr[0][2].SetBackgroundColour(col_bg ); + m_item_attr[0][2].SetTextColour ((unsigned long)0x00aacc); + m_item_attr[0][3].SetBackgroundColour(col_bg ); + m_item_attr[0][3].SetTextColour ((unsigned long)0x0000ff); + m_item_attr[1][0].SetBackgroundColour(col_bg ); + m_item_attr[1][0].SetTextColour ((unsigned long)0xcccccc); + m_item_attr[1][1].SetBackgroundColour(col_bg ); + m_item_attr[1][1].SetTextColour ((unsigned long)0xaaaaaa); + m_item_attr[1][2].SetBackgroundColour(col_bg ); + m_item_attr[1][2].SetTextColour ((unsigned long)0xaaeeee); + m_item_attr[1][3].SetBackgroundColour(col_bg ); + m_item_attr[1][3].SetTextColour ((unsigned long)0xaaaaff); + // Start a new session. ULONG ulResult; for (unsigned int i = 0; ; i++) { @@ -307,6 +255,7 @@ wxETWListCtrl::wxETWListCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos wxLogError(_("Error enabling event provider (error %u)."), ulResult); return; } + if ((ulResult = EnableTraceEx( &s_provider_eaphost, &((const EVENT_TRACE_PROPERTIES*)m_session)->Wnode.Guid, @@ -321,10 +270,24 @@ wxETWListCtrl::wxETWListCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos wxLogDebug(_("Error enabling EAPHost event provider (error %u)."), ulResult); } + if ((ulResult = EnableTraceEx( + &s_provider_schannel, + &((const EVENT_TRACE_PROPERTIES*)m_session)->Wnode.Guid, + m_session, + EVENT_CONTROL_CODE_ENABLE_PROVIDER, + TRACE_LEVEL_VERBOSE, + 0, 0, + 0, + NULL)) != ERROR_SUCCESS) + { + // If the Schannel trace provider failed to enable, do not despair. + wxLogDebug(_("Error enabling Schannel event provider (error %u)."), ulResult); + } + // Process events in separate thread, not to block wxWidgets' message pump. wxArrayString sessions; sessions.Add(m_session.name()); - m_proc = new wxEventTraceProcessorThread(this->GetEventHandler(), sessions); + m_proc = new wxEventTraceProcessorThread(GetEventHandler(), sessions); wxASSERT_MSG(m_proc, wxT("error allocating thread memory")); if (m_proc->Run() != wxTHREAD_NO_ERROR) { wxFAIL_MSG("Can't create the thread!"); @@ -344,6 +307,16 @@ wxETWListCtrl::~wxETWListCtrl() } // Disable event providers. + EnableTraceEx( + &s_provider_schannel, + &((const EVENT_TRACE_PROPERTIES*)m_session)->Wnode.Guid, + m_session, + EVENT_CONTROL_CODE_DISABLE_PROVIDER, + TRACE_LEVEL_VERBOSE, + 0, 0, + 0, + NULL); + EnableTraceEx( &s_provider_eaphost, &((const EVENT_TRACE_PROPERTIES*)m_session)->Wnode.Guid, @@ -367,27 +340,240 @@ wxETWListCtrl::~wxETWListCtrl() } -void wxETWListCtrl::OnETWEvent(wxETWEvent& event) +void wxETWListCtrl::CopySelected() const { - EVENT_RECORD &rec = event.GetRecord(); + // Prepare text in ANSI and Unicode flavours. + string dataA, rowA; + wstring dataW, rowW; + for (long item = -1; (item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED)) != -1;) { + FormatRow(m_rec_db.at_abs(m_rec_idx.at(item)), rowA, rowW); + rowA += "\r\n"; dataA += rowA; + rowW += L"\r\n"; dataW += rowW; + } + + // Put text to clipboard. + CopyToClipboard(dataA, dataW); +} + + +void wxETWListCtrl::CopyAll() const +{ + // Prepare text in ANSI and Unicode flavours. + string dataA, rowA; + wstring dataW, rowW; + for (size_t i = 0, n = m_rec_db.size(); i < n; i++) { + FormatRow(m_rec_db[i], rowA, rowW); + rowA += "\r\n"; dataA += rowA; + rowW += L"\r\n"; dataW += rowW; + } + + // Put text to clipboard. + CopyToClipboard(dataA, dataW); + +} + + +void wxETWListCtrl::ClearAll() +{ + m_rec_idx.clear(); + m_rec_db.clear(); + if (GetItemCount()) + SetItemCount(0); +} + + +void wxETWListCtrl::SelectAll() +{ + for (long item = 0, count = GetItemCount(); item < count; item++) + SetItemState(item, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED); +} + + +void wxETWListCtrl::SelectNone() +{ + for (long item = -1; (item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED)) != -1;) + SetItemState(item, 0, wxLIST_STATE_SELECTED); +} + + +void wxETWListCtrl::RebuildItems() +{ + ChildrenRepositioningGuard child_reposition(this); + + // Get current focus and selection. + set focus, selection; + for (long item = -1; (item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_FOCUSED)) != -1;) + focus.insert(m_rec_idx[item]); + for (long item = -1; (item = GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED)) != -1;) + selection.insert(m_rec_idx[item]); + + // Get current view position (scrolling). + long + item_top = GetTopItem(), + item_page_count = GetCountPerPage(), + item_center = std::min( + item_top + item_page_count / 2, // Index of item in the centre of the view + (item_top + m_rec_idx.size()) / 2); // Index of the item in the centre between top viewed item and the last (when list is not overflowed) + size_t center = item_center < m_rec_idx.size() ? m_rec_idx[item_center] : -1; + + // Rebuild the index. + m_rec_idx.clear(); + set::const_iterator selection_end = selection.end(), focus_end = focus.end(); + vector selection_out, focus_out; + long center_out = -1; + for (size_t i = 0, n = m_rec_db.size(); i < n; i++) { + size_t i_abs = m_rec_db.abs(i); + if (i_abs == center) + center_out = m_rec_idx.size(); + if (IsVisible(m_rec_db[i])) { + if (selection.find(i_abs) != selection_end) + selection_out.push_back(m_rec_idx.size()); + if (focus.find(i_abs) != focus_end) + focus_out.push_back(m_rec_idx.size()); + m_rec_idx.push_back(i_abs); + } + } + + // Set new item count. + long item_count = (long)m_rec_idx.size(); + if (GetItemCount() != item_count) + SetItemCount(item_count); + + if (item_count) { + // Restore focus and selection. + for (size_t i = 0, n = focus_out.size(); i < n; i++) + SetItemState(focus_out[i], wxLIST_STATE_FOCUSED, wxLIST_STATE_FOCUSED); + SelectNone(); + for (size_t i = 0, n = selection_out.size(); i < n; i++) + SetItemState(selection_out[i], wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED); + + // Restore scrolling. + if (center_out != -1) { + wxRect pos1, pos2; + GetItemRect(GetTopItem(), pos1); + GetItemRect(std::max(std::min(center_out, item_count - 1) - item_page_count / 2, 0), pos2); + ScrollList(pos2.x - pos1.x, pos2.y - pos1.y); + } else + EnsureVisible(item_count - 1); + + // Refresh items. + item_top = GetTopItem(); + RefreshItems(item_top, std::min(item_top + item_page_count, item_count)); + } +} + + +bool wxETWListCtrl::IsVisible(const EVENT_RECORD &rec) const +{ + return + (m_source_product && IsEqualGUID(rec.EventHeader.ProviderId, EAPMETHOD_TRACE_EVENT_PROVIDER) || + m_source_eaphost && IsEqualGUID(rec.EventHeader.ProviderId, s_provider_eaphost ) || + m_source_schannel && IsEqualGUID(rec.EventHeader.ProviderId, s_provider_schannel )) && + rec.EventHeader.EventDescriptor.Level <= m_level; +} + + +void wxETWListCtrl::FormatRow(const event_rec &rec, std::string &rowA, std::wstring &rowW) const +{ + rowA.clear(); + rowW.clear(); + + // Merge columns. + string colA; + wxString colW; + for (size_t i = 0; i < _countof(m_col_format_width); i++) { + // Get column text. + colW = OnGetItemText(rec, i); + size_t len = colW.Length(); + if (len < m_col_format_width[i]) { + // Pad it to required length. + colW.Append(wxT(' '), m_col_format_width[i] - len); + } else if (m_col_format_width[i] && len > m_col_format_width[i]) { + // Truncate it and add horizontal ellipsis. + colW.Truncate(m_col_format_width[i] - 3); + colW.Append(wxT("...")); + } + + // Convert to ACP. + WideCharToMultiByte(CP_ACP, 0, colW.c_str(), -1, colA, NULL, NULL); + + // Append to output. + if (i) { + rowA += " "; + rowW += L" "; + } + rowA += colA; + rowW += colW; + } +} + + +bool wxETWListCtrl::CopyToClipboard(const std::string &dataA, const std::wstring &dataW) const +{ + if (OpenClipboard(GetHWND())) { + EmptyClipboard(); + + HGLOBAL h; + size_t size; + + size = (dataA.length() + 1) * sizeof(CHAR); + h = GlobalAlloc(GMEM_MOVEABLE, size); + if (h) { + LPVOID d = GlobalLock(h); + if (d) { + memcpy(d, dataA.data(), size); + GlobalUnlock(h); + SetClipboardData(CF_TEXT, h); + } + } + + size = (dataW.length() + 1) * sizeof(WCHAR); + h = GlobalAlloc(GMEM_MOVEABLE, size); + if (h) { + LPVOID d = GlobalLock(h); + if (d) { + memcpy(d, dataW.data(), size); + GlobalUnlock(h); + SetClipboardData(CF_UNICODETEXT, h); + } + } + + CloseClipboard(); + + return true; + } else + return false; +} + + +wxListItemAttr *wxETWListCtrl::OnGetItemAttr(long item) const +{ + const event_rec &rec = m_rec_db.at_abs(m_rec_idx.at(item)); bool is_ours = IsEqualGUID(rec.EventHeader.ProviderId, EAPMETHOD_TRACE_EVENT_PROVIDER) ? true : false; - int column = 0; - // Prepare item to insert into the list. - wxListItem item; - item.SetId(m_item_id++); - item.SetTextColour( - rec.EventHeader.EventDescriptor.Level >= TRACE_LEVEL_VERBOSE ? (is_ours ? 0x666666 : 0xcccccc) : - rec.EventHeader.EventDescriptor.Level >= TRACE_LEVEL_INFORMATION ? (is_ours ? 0x000000 : 0xaaaaaa) : - rec.EventHeader.EventDescriptor.Level >= TRACE_LEVEL_WARNING ? (is_ours ? 0x00aacc : 0xaaeeee) : - (is_ours ? 0x0000ff : 0xaaaaff)); - item.SetBackgroundColour(0xffffff); + // Select appropriate attributes acording to race, colour, or creed... + return (wxListItemAttr*)( + ((const EVENT_RECORD&)rec).EventHeader.EventDescriptor.Level >= TRACE_LEVEL_VERBOSE ? (is_ours ? &(m_item_attr[0][0]) : &(m_item_attr[1][0])) : + ((const EVENT_RECORD&)rec).EventHeader.EventDescriptor.Level >= TRACE_LEVEL_INFORMATION ? (is_ours ? &(m_item_attr[0][1]) : &(m_item_attr[1][1])) : + ((const EVENT_RECORD&)rec).EventHeader.EventDescriptor.Level >= TRACE_LEVEL_WARNING ? (is_ours ? &(m_item_attr[0][2]) : &(m_item_attr[1][2])) : + (is_ours ? &(m_item_attr[0][3]) : &(m_item_attr[1][3]))); +} - { - // Output event time-stamp. + +wxString wxETWListCtrl::OnGetItemText(long item, long column) const +{ + return OnGetItemText(m_rec_db.at_abs(m_rec_idx.at(item)), column); +} + + +wxString wxETWListCtrl::OnGetItemText(const event_rec &rec, long column) const +{ + switch (column) { + case 0: { + // Get event time-stamp. FILETIME ft; ft.dwHighDateTime = rec.EventHeader.TimeStamp.HighPart; - ft.dwLowDateTime = rec.EventHeader.TimeStamp.LowPart; + ft.dwLowDateTime = rec.EventHeader.TimeStamp.LowPart; SYSTEMTIME st, st_local; FileTimeToSystemTime(&ft, &st); @@ -395,39 +581,36 @@ void wxETWListCtrl::OnETWEvent(wxETWEvent& event) ULONGLONG ts = rec.EventHeader.TimeStamp.QuadPart, - nanosec = (ts % 10000000) * 100; + microsec = (ts % 10000000) / 10; - item.SetColumn(column++); - item.SetText(tstring_printf(_T("%04d-%02d-%02d %02d:%02d:%02d.%09I64u"), - st_local.wYear, st_local.wMonth, st_local.wDay, st_local.wHour, st_local.wMinute, st_local.wSecond, nanosec)); - this->InsertItem(item); + return tstring_printf(_T("%04d-%02d-%02d %02d:%02d:%02d.%06I64u"), + st_local.wYear, st_local.wMonth, st_local.wDay, st_local.wHour, st_local.wMinute, st_local.wSecond, microsec); } - // Output process ID. - item.SetColumn(column++); - item.SetText(wxString::Format(wxT("%u"), rec.EventHeader.ProcessId)); - this->SetItem(item); + case 1: + // Get process ID. + return wxString::Format(wxT("%u"), rec.EventHeader.ProcessId); - // Output thread ID. - item.SetColumn(column++); - item.SetText(wxString::Format(wxT("%u"), rec.EventHeader.ThreadId)); - this->SetItem(item); + case 2: + // Get thread ID. + return wxString::Format(wxT("%u"), rec.EventHeader.ThreadId); - // Output event source. - item.SetColumn(column++); - item.SetText(is_ours ? wxT(PRODUCT_NAME_STR) : wxT("EAPHost")); - this->SetItem(item); + case 3: + // Get event source. + return + IsEqualGUID(rec.EventHeader.ProviderId, EAPMETHOD_TRACE_EVENT_PROVIDER) ? wxT(PRODUCT_NAME_STR) : + IsEqualGUID(rec.EventHeader.ProviderId, s_provider_eaphost ) ? wxT("EAPHost" ) : + IsEqualGUID(rec.EventHeader.ProviderId, s_provider_schannel ) ? wxT("Schannel" ) : wxEmptyString; - item.SetColumn(column++); - { + case 4: { // Get event meta-info. unique_ptr info; ULONG ulResult; - if ((ulResult = TdhGetEventInformation(&rec, 0, NULL, info)) == ERROR_SUCCESS) { + if ((ulResult = TdhGetEventInformation((PEVENT_RECORD)&rec, 0, NULL, info)) == ERROR_SUCCESS) { if (info->DecodingSource != DecodingSourceWPP) { if (rec.EventHeader.Flags & EVENT_HEADER_FLAG_STRING_ONLY) { // This is a string-only event. Print it. - item.SetText((LPCWSTR)rec.UserData); + return (LPCWSTR)rec.UserData; } else { // This is not a string-only event. Prepare parameters. @@ -437,25 +620,130 @@ void wxETWListCtrl::OnETWEvent(wxETWEvent& event) props.reserve(info->TopLevelPropertyCount); props_msg.reserve(info->TopLevelPropertyCount); for (ULONG i = 0; i < info->TopLevelPropertyCount; i++) { - props.push_back(std::move(PropertyToString(&rec, info.get(), i, NULL, 0, nPtrSize))); + props.push_back(std::move(PropertyToString((PEVENT_RECORD)&rec, info.get(), i, NULL, 0, nPtrSize))); props_msg.push_back((DWORD_PTR)props[i].c_str()); } if (info->EventMessageOffset) { // Format the message. - item.SetText(wstring_msg(0, (LPCTSTR)((LPCBYTE)info.get() + info->EventMessageOffset), props_msg.data()).c_str()); + return wstring_msg(0, (LPCTSTR)((LPCBYTE)info.get() + info->EventMessageOffset), props_msg.data()).c_str(); } } } else if (info->EventMessageOffset) { // This is a WPP event. - item.SetText((LPCWSTR)((LPCBYTE)info.get() + info->EventMessageOffset)); + return (LPCWSTR)((LPCBYTE)info.get() + info->EventMessageOffset); } } } - this->SetItem(item); + } - // Bring the record into view. - this->EnsureVisible(item.GetId()); + return wxEmptyString; +} + + +void wxETWListCtrl::OnETWEvent(wxETWEvent& event) +{ + // Move event, since event handlers will have no use of it and destroy it in the end. + // This way we save memory allocation and copying. + event_rec rec(std::move(event.GetRecord())); + + // Is event visible according to current view settings? + bool is_visible = IsVisible(rec); + + // Move event to the end of the queue. + size_t pos = m_rec_db.push_back(std::move(rec)); + + bool has_moved; + if (!m_rec_idx.empty() && m_rec_idx.front() == pos) { + // This event overwrote previous head element in index. + m_rec_idx.pop_front(); + has_moved = true; + } else + has_moved = false; + + if (is_visible) { + // Push event absolute subscript to the index too. + m_rec_idx.push_back(pos); + } + + long item_count = (long)m_rec_idx.size(); + if (GetItemCount() != item_count) + SetItemCount(item_count); + + if (item_count) { + if (m_scroll_auto) { + // Bring the record into view. + EnsureVisible(item_count - 1); + } + + if (has_moved) { + long item_top = GetTopItem(); + RefreshItems(item_top, std::min(item_top + GetCountPerPage(), item_count)); + } + } +} + + +////////////////////////////////////////////////////////////////////////// +// wxPersistentETWListCtrl +////////////////////////////////////////////////////////////////////////// + +wxPersistentETWListCtrl::wxPersistentETWListCtrl(wxETWListCtrl *wnd) : wxPersistentWindow(wnd) +{ +} + + +wxString wxPersistentETWListCtrl::GetKind() const +{ + return wxT(wxPERSIST_TLW_KIND); +} + + +void wxPersistentETWListCtrl::Save() const +{ + const wxETWListCtrl * const wnd = static_cast(GetWindow()); + + // Save log's column widths. + wxListItem col; + col.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_WIDTH); + for (int i = 0, n = wnd->GetColumnCount(); i < n; i++) { + wnd->GetColumn(i, col); + SaveValue(wxString::Format(wxT("Column%sWidth"), col.GetText().c_str()), col.GetWidth()); + } + + SaveValue(wxT("ScrollAuto" ), wnd->m_scroll_auto ); + SaveValue(wxT("SourceEAPHost" ), wnd->m_source_eaphost ); + SaveValue(wxT("SourceSchannel"), wnd->m_source_schannel); + SaveValue(wxT("SourceProduct" ), wnd->m_source_product ); + SaveValue(wxT("Level" ), (int)wnd->m_level ); +} + + +bool wxPersistentETWListCtrl::Restore() +{ + wxETWListCtrl * const wnd = static_cast(GetWindow()); + + // Restore log's column widths. + wxListItem col; + col.SetMask(wxLIST_MASK_TEXT); + for (int i = 0, n = wnd->GetColumnCount(); i < n; i++) { + wnd->GetColumn(i, col); + + int width; + if (RestoreValue(wxString::Format(wxT("Column%sWidth"), col.GetText().c_str()), &width)) + wnd->SetColumnWidth(i, width); + } + + int dummy_int; + + RestoreValue(wxT("ScrollAuto" ), &(wnd->m_scroll_auto )); + RestoreValue(wxT("SourceEAPHost" ), &(wnd->m_source_eaphost )); + RestoreValue(wxT("SourceSchannel"), &(wnd->m_source_schannel)); + RestoreValue(wxT("SourceProduct" ), &(wnd->m_source_product )); + if (RestoreValue(wxT("Level"), &dummy_int)) + wnd->m_level = (UCHAR)std::min(std::max(dummy_int, TRACE_LEVEL_ERROR), TRACE_LEVEL_VERBOSE); + + return true; } diff --git a/EventMonitor/ETWLog.h b/EventMonitor/ETWLog.h index f8d6ba6..0f30efe 100644 --- a/EventMonitor/ETWLog.h +++ b/EventMonitor/ETWLog.h @@ -20,6 +20,11 @@ #include +/// +/// Maximum number of event records kept +/// +#define wxETWEVENT_RECORDS_MAX 1000000 + /// /// ETW event /// @@ -28,23 +33,30 @@ wxDECLARE_EVENT(wxEVT_ETW_EVENT, wxETWEvent); #define wxETWEventHandler(func) wxEVENT_HANDLER_CAST(wxETWEventFunction, func) #define EVT_ETW_EVENT(func) wx__DECLARE_EVT0(wxEVT_ETW_EVENT, wxETWEventHandler(func)) +/// +/// Event trace processor +/// +class wxEventTraceProcessorThread; + /// /// Event list control /// class wxETWListCtrl; /// -/// Event trace processor +/// Supports saving/restoring wxETWListCtrl state /// -class wxEventTraceProcessorThread; +class wxPersistentETWListCtrl; #pragma once #include +#include #include #include +#include #include @@ -53,23 +65,10 @@ class wxETWEvent : public wxEvent public: wxETWEvent(wxEventType type = wxEVT_NULL, const EVENT_RECORD &record = s_record_null); wxETWEvent(const wxETWEvent& event); - virtual ~wxETWEvent(); virtual wxEvent *Clone() const { return new wxETWEvent(*this); } - inline const EVENT_RECORD& GetRecord() const { return m_record; } - inline EVENT_RECORD& GetRecord() { return m_record; } - - inline const EVENT_HEADER& GetHeader() const { return m_record.EventHeader; } - - inline const ETW_BUFFER_CONTEXT& GetBufferContext() const { return m_record.BufferContext; } - - bool SetExtendedData(size_t extended_data_count, const EVENT_HEADER_EXTENDED_DATA_ITEM *extended_data); - inline size_t GetExtendedDataCount() const { return m_record.ExtendedDataCount; } - inline const EVENT_HEADER_EXTENDED_DATA_ITEM& GetExtendedData(size_t index) const { wxASSERT(index < m_record.ExtendedDataCount); return m_record.ExtendedData[index]; } - - bool SetUserData(size_t user_data_length, const void *user_data); - inline size_t GetUserDataLength() const { return m_record.UserDataLength; } - inline void *GetUserData() const { return m_record.UserData; } + inline const winstd::event_rec& GetRecord() const { return m_record; } + inline winstd::event_rec& GetRecord() { return m_record; } protected: bool DoSetExtendedData(size_t extended_data_count, const EVENT_HEADER_EXTENDED_DATA_ITEM *extended_data); @@ -82,7 +81,7 @@ public: static const EVENT_RECORD s_record_null; protected: - EVENT_RECORD m_record; ///< ETW event record + winstd::event_rec m_record; ///< ETW event record }; @@ -117,20 +116,67 @@ public: wxWindowID id = wxID_ANY, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize, - long style = wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL|wxNO_BORDER, + long style = wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VIRTUAL|wxNO_BORDER, const wxValidator &validator = wxDefaultValidator, const wxString &name = wxListCtrlNameStr); virtual ~wxETWListCtrl(); + bool IsEmpty() const { return m_rec_db.empty(); } + void CopySelected() const; + void CopyAll() const; + void ClearAll(); + void SelectAll(); + void SelectNone(); + void RebuildItems(); + + friend class wxPersistentETWListCtrl; // Allow saving/restoring window state. + protected: + bool IsVisible(const EVENT_RECORD &rec) const; + void FormatRow(const winstd::event_rec &rec, std::string &rowA, std::wstring &rowW) const; + bool CopyToClipboard(const std::string &dataA, const std::wstring &dataW) const; + + virtual wxListItemAttr *OnGetItemAttr(long item) const; + virtual wxString OnGetItemText(long item, long column) const; + virtual wxString OnGetItemText(const winstd::event_rec &rec, long column) const; void OnETWEvent(wxETWEvent& event); DECLARE_EVENT_TABLE() public: - static const GUID s_provider_eaphost; ///< EAPHost event provider ID + bool m_scroll_auto; ///< Is autoscrolling enabled? + bool m_source_eaphost; ///< Shows EAPHost messages + bool m_source_schannel; ///< Shows Schannel messages + bool m_source_product; ///< Shows native messages + UCHAR m_level; ///< Shows messages up to this level of verboseness + + static const GUID s_provider_eaphost; ///< EAPHost event provider ID + static const GUID s_provider_schannel; ///< Schannel event provider ID protected: - winstd::event_session m_session; ///< Event session - wxEventTraceProcessorThread *m_proc; ///< Processor thread - long m_item_id; ///< Next free list item ID + winstd::event_session m_session; ///< Event session + wxEventTraceProcessorThread *m_proc; ///< Processor thread + long m_item_id; ///< Next free list item ID + + wxListItemAttr m_item_attr[2][4]; ///< Current item attributes + winstd::vector_queue m_rec_db; ///< Event record database + winstd::vector_queue m_rec_idx; ///< Event record database indices of shown records + + size_t m_col_format_width[5]; ///< Column widths for pre-formatted row display (0 = unlimited) }; + + +class wxPersistentETWListCtrl : public wxPersistentWindow +{ +public: + wxPersistentETWListCtrl(wxETWListCtrl *wnd); + + virtual wxString GetKind() const; + virtual void Save() const; + virtual bool Restore(); +}; + + +inline wxPersistentObject *wxCreatePersistentObject(wxETWListCtrl *wnd) +{ + return new wxPersistentETWListCtrl(wnd); +} diff --git a/EventMonitor/EventMonitor.rc b/EventMonitor/EventMonitor.rc index 16e27f3..7994ae7 100644 Binary files a/EventMonitor/EventMonitor.rc and b/EventMonitor/EventMonitor.rc differ diff --git a/EventMonitor/Frame.cpp b/EventMonitor/Frame.cpp index 16cae5f..ede6b9c 100644 --- a/EventMonitor/Frame.cpp +++ b/EventMonitor/Frame.cpp @@ -25,27 +25,219 @@ // wxEventMonitorFrame ////////////////////////////////////////////////////////////////////////// -wxBEGIN_EVENT_TABLE(wxEventMonitorFrame, wxEventMonitorFrameBase) - EVT_MENU(wxID_EXIT, wxEventMonitorFrame::OnExit) -wxEND_EVENT_TABLE() - -wxEventMonitorFrame::wxEventMonitorFrame() : wxEventMonitorFrameBase(NULL) +wxEventMonitorFrame::wxEventMonitorFrame(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style, const wxString& name) : + wxFrame(parent, id, title, pos, size, style, name) { + this->SetSizeHints(wxSize(150,150), wxDefaultSize); + m_mgr.SetManagedWindow(this); + m_mgr.SetFlags(wxAUI_MGR_DEFAULT); + // Load main window icons. #ifdef __WINDOWS__ - wxIcon icon_small(wxT("00_EventMonitor.ico"), wxBITMAP_TYPE_ICO_RESOURCE, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON)); wxIconBundle icons; - icons.AddIcon(icon_small); - icons.AddIcon(wxIcon(wxT("00_EventMonitor.ico"), wxBITMAP_TYPE_ICO_RESOURCE, ::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON))); - SetIcons(icons); + icons.AddIcon(wxIcon(wxT("00_EventMonitor.ico"), wxBITMAP_TYPE_ICO_RESOURCE, ::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON))); + icons.AddIcon(wxIcon(wxT("00_EventMonitor.ico"), wxBITMAP_TYPE_ICO_RESOURCE, ::GetSystemMetrics(SM_CXICON ), ::GetSystemMetrics(SM_CYICON ))); + this->SetIcons(icons); #else - wxIcon icon_small(wxICON(00_EventMonitor.ico)); - SetIcon(icon_small); + this->SetIcon(wxIcon(wxICON(00_EventMonitor.ico))); #endif + wxString prod_name(wxT(PRODUCT_NAME_STR)); + wxString prod_status_bar; + prod_status_bar.Printf(_("Toggles %s rows"), wxT(PRODUCT_NAME_STR)); + + winstd::library lib_comres; + lib_comres.load(_T("comres.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE); + + winstd::library lib_ieframe; + lib_ieframe.load(_T("ieframe.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE); + + winstd::library lib_shell32; + lib_shell32.load(_T("shell32.dll"), NULL, LOAD_LIBRARY_AS_DATAFILE | LOAD_LIBRARY_AS_IMAGE_RESOURCE); + + wxSize size_menu(GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON)); + wxSize size_tool(size_menu); + + m_menubar = new wxMenuBar(0); + m_menuProgram = new wxMenu(); + wxMenuItem* m_menuItemExit; + m_menuItemExit = new wxMenuItem(m_menuProgram, wxID_EXIT, wxString(_("E&xit")) + wxT('\t') + wxT("Alt+F4"), _("Quit this program"), wxITEM_NORMAL); + m_menuItemExit->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(240), size_menu)); + m_menuProgram->Append(m_menuItemExit); + + m_menubar->Append(m_menuProgram, _("&Program")); + + m_menuEdit = new wxMenu(); + wxMenuItem* m_menuEditCopy; + m_menuEditCopy = new wxMenuItem(m_menuEdit, wxID_COPY, wxString(wxEmptyString) , wxEmptyString, wxITEM_NORMAL); + m_menuEditCopy->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(243), size_menu)); + m_menuEdit->Append(m_menuEditCopy); + + wxMenuItem* m_menuEditCopyAll; + m_menuEditCopyAll = new wxMenuItem(m_menuEdit, wxID_COPY_ALL, wxString(_("Copy All")) + wxT('\t') + wxT("Ctrl+Shift+C"), _("Copies all rows to clipboard"), wxITEM_NORMAL); + m_menuEditCopyAll->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(133), size_menu)); + m_menuEdit->Append(m_menuEditCopyAll); + + wxMenuItem* m_menuEditClear; + m_menuEditClear = new wxMenuItem(m_menuEdit, wxID_CLEAR, wxString(_("Clear")) , _("Clears all rows from log"), wxITEM_NORMAL); + m_menuEditClear->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(200), size_menu)); + m_menuEdit->Append(m_menuEditClear); + + m_menuEdit->AppendSeparator(); + + wxMenuItem* m_menuEditSelectAll; + m_menuEditSelectAll = new wxMenuItem(m_menuEdit, wxID_SELECT_ALL, wxString(_("Select &All")) + wxT('\t') + wxT("Ctrl+A"), _("Selects all rows"), wxITEM_NORMAL); + m_menuEdit->Append(m_menuEditSelectAll); + + wxMenuItem* m_menuEditSelectNone; + m_menuEditSelectNone = new wxMenuItem(m_menuEdit, wxID_SELECT_NONE, wxString(_("Select &None")) , _("Clears row selection"), wxITEM_NORMAL); + m_menuEdit->Append(m_menuEditSelectNone); + + m_menubar->Append(m_menuEdit, _("&Edit")); + + m_menuView = new wxMenu(); + wxMenuItem* m_menuViewScrollAuto; + m_menuViewScrollAuto = new wxMenuItem(m_menuView, wxID_VIEW_SCROLL_AUTO, wxString(_("Auto Scroll")) + wxT('\t') + wxT("Ctrl+S"), _("Automatically scrolls to the recent rows as they come-in."), wxITEM_CHECK); + //m_menuViewScrollAuto->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(231), size_menu)); + m_menuView->Append(m_menuViewScrollAuto); + + m_menuView->AppendSeparator(); + + wxMenuItem* m_menuViewSourceEAPHost; + m_menuViewSourceEAPHost = new wxMenuItem(m_menuView, wxID_VIEW_SOURCE_EAPHOST, wxString("EAPHost") , _("Toggles EAPHost rows"), wxITEM_CHECK); + //m_menuViewSourceEAPHost->SetBitmaps(wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(273), size_menu)); + m_menuView->Append(m_menuViewSourceEAPHost); + + wxMenuItem* m_menuViewSourceSchannel; + m_menuViewSourceSchannel = new wxMenuItem(m_menuView, wxID_VIEW_SOURCE_SCHANNEL, wxString("Schannel") , _("Toggles Schannel rows"), wxITEM_CHECK); + //m_menuViewSourceSchannel->SetBitmaps(wxLoadIconFromResource(lib_ieframe, MAKEINTRESOURCE(36870), size_menu)); + m_menuView->Append(m_menuViewSourceSchannel); + + m_menuViewSourceProduct = new wxMenuItem(m_menuView, wxID_VIEW_SOURCE_PRODUCT, prod_name , prod_status_bar, wxITEM_CHECK); + //m_menuViewSourceProduct->SetBitmaps(wxIcon(wxT("product.ico"), wxBITMAP_TYPE_ICO_RESOURCE, size_menu.GetWidth(), size_menu.GetHeight())); + m_menuView->Append(m_menuViewSourceProduct); + + m_menuView->AppendSeparator(); + + m_menuViewLevelVerbose = new wxMenuItem(m_menuView, wxID_VIEW_LEVEL_VERBOSE, wxString(_("Verbose")) + wxT('\t') + wxT("Ctrl+1"), _("Shows all rows up to verbose level"), wxITEM_RADIO); + //m_menuViewLevelVerbose->SetBitmaps(wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2863), size_menu)); + m_menuView->Append(m_menuViewLevelVerbose); + + m_menuViewLevelInformation = new wxMenuItem(m_menuView, wxID_VIEW_LEVEL_INFORMATION, wxString(_("Informational")) + wxT('\t') + wxT("Ctrl+2"), _("Shows all rows up to informational level"), wxITEM_RADIO); + //m_menuViewLevelInformation->SetBitmaps(wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2859), size_menu)); + m_menuView->Append(m_menuViewLevelInformation); + + m_menuViewLevelWarning = new wxMenuItem(m_menuView, wxID_VIEW_LEVEL_WARNING, wxString(_("Warning")) + wxT('\t') + wxT("Ctrl+3"), _("Shows all rows up to warning level"), wxITEM_RADIO); + //m_menuViewLevelWarning->SetBitmaps(wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2865), size_menu)); + m_menuView->Append(m_menuViewLevelWarning); + + m_menuViewLevelError = new wxMenuItem(m_menuView, wxID_VIEW_LEVEL_ERROR, wxString(_("Error")) + wxT('\t') + wxT("Ctrl+4"), _("Shows all rows up to error level"), wxITEM_RADIO); + //m_menuViewLevelError->SetBitmaps(wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2861), size_menu)); + m_menuView->Append(m_menuViewLevelError); + + m_menubar->Append(m_menuView, _("&View")); + + this->SetMenuBar(m_menubar); + + m_toolbarEdit = new wxAuiToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_TB_HORZ_LAYOUT); + m_toolEditCopy = m_toolbarEdit->AddTool(wxID_COPY, _("Copy"), wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(243), size_tool), wxNullBitmap, wxITEM_NORMAL, _("Copy"), _("Copies selected rows to clipboard"), NULL); + + m_toolEditCopyAll = m_toolbarEdit->AddTool(wxID_COPY_ALL, _("Copy All"), wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(133), size_tool), wxNullBitmap, wxITEM_NORMAL, _("Copy All"), _("Copies all rows to clipboard"), NULL); + + m_toolEditClear = m_toolbarEdit->AddTool(wxID_CLEAR, _("Clear"), wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(200), size_tool), wxNullBitmap, wxITEM_NORMAL, _("Clear All"), _("Clears all rows from the log"), NULL); + + m_toolbarEdit->Realize(); + m_mgr.AddPane(m_toolbarEdit, wxAuiPaneInfo().Name(wxT("ToolbarEdit")).Top().Caption(_("Edit")).PinButton(true).Dock().Resizable().FloatingSize(wxDefaultSize).LeftDockable(false).RightDockable(false).Layer(1).ToolbarPane()); + + m_toolbarView = new wxAuiToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_TB_HORZ_LAYOUT); + m_toolViewScrollAuto = m_toolbarView->AddTool(wxID_VIEW_SCROLL_AUTO, _("Auto Scroll"), wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(231), size_tool), wxNullBitmap, wxITEM_CHECK, _("Automatically scroll"), _("Automatically scrolls to the recent rows as they come-in."), NULL); + + m_toolbarView->AddSeparator(); + + m_toolViewSourceEAPHost = m_toolbarView->AddTool(wxID_VIEW_SOURCE_EAPHOST, "EAPHost", wxLoadIconFromResource(lib_shell32, MAKEINTRESOURCE(273), size_tool), wxNullBitmap, wxITEM_CHECK, _("Toggles EAPHost rows"), _("Toggles EAPHost rows"), NULL); + + m_toolViewSourceSchannel = m_toolbarView->AddTool(wxID_VIEW_SOURCE_SCHANNEL, "Schannel", wxLoadIconFromResource(lib_ieframe, MAKEINTRESOURCE(36870), size_tool), wxNullBitmap, wxITEM_CHECK, _("Toggles Schannel rows"), _("Toggles Schannel rows"), NULL); + + m_toolViewSourceProduct = m_toolbarView->AddTool(wxID_VIEW_SOURCE_PRODUCT, prod_name, wxIcon(wxT("product.ico"), wxBITMAP_TYPE_ICO_RESOURCE, size_tool.GetWidth(), size_tool.GetHeight()), wxNullBitmap, wxITEM_CHECK, prod_status_bar, prod_status_bar, NULL); + + m_toolbarView->AddSeparator(); + + m_toolViewLevelVerbose = m_toolbarView->AddTool(wxID_VIEW_LEVEL_VERBOSE, _("Verbose"), wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2863), size_tool), wxNullBitmap, wxITEM_RADIO, _("Shows verbose rows"), _("Shows all rows up to verbose level"), NULL); + + m_toolViewLevelInformation = m_toolbarView->AddTool(wxID_VIEW_LEVEL_INFORMATION, _("Informational"), wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2859), size_tool), wxNullBitmap, wxITEM_RADIO, _("Shows informational rows"), _("Shows all rows up to informational level"), NULL); + + m_toolViewLevelWarning = m_toolbarView->AddTool(wxID_VIEW_LEVEL_WARNING, _("Warning"), wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2865), size_tool), wxNullBitmap, wxITEM_RADIO, _("Shows warning rows"), _("Shows all rows up to warning level"), NULL); + + m_toolViewLevelError = m_toolbarView->AddTool(wxID_VIEW_LEVEL_ERROR, _("Error"), wxLoadIconFromResource(lib_comres, MAKEINTRESOURCE(2861), size_tool), wxNullBitmap, wxITEM_RADIO, _("Shows Error rows"), _("Shows all rows up to error level"), NULL); + + m_toolbarView->Realize(); + m_mgr.AddPane(m_toolbarView, wxAuiPaneInfo().Name(wxT("ToolbarView")).Top().Caption(_("View")).PinButton(true).Dock().Resizable().FloatingSize(wxDefaultSize).LeftDockable(false).RightDockable(false).Layer(1).ToolbarPane()); + + m_panel = new wxEventMonitorLogPanel(this); + + m_mgr.AddPane(m_panel, wxAuiPaneInfo() .Name(wxT("LogPanel")).Center() .Caption(_("Log Trace")).CaptionVisible(false).CloseButton(false).PaneBorder(false).Dock().Resizable().FloatingSize(wxDefaultSize).Floatable(false)); + + m_statusBar = this->CreateStatusBar(1, wxST_SIZEGRIP, wxID_ANY); + + m_mgr.Update(); + this->Centre(wxBOTH); + // Restore persistent state of wxAuiManager manually, since m_mgr is not on the heap. wxPersistentAuiManager(&m_mgr).Restore(); + + // Connect Events + this->Connect(wxID_EXIT , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnExit )); + this->Connect(wxID_COPY , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditCopyUpdate )); + this->Connect(wxID_COPY , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditCopy )); + this->Connect(wxID_COPY_ALL , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditCopyAllUpdate )); + this->Connect(wxID_COPY_ALL , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditCopyAll )); + this->Connect(wxID_CLEAR , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditClearUpdate )); + this->Connect(wxID_CLEAR , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditClear )); + this->Connect(wxID_SELECT_ALL , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditSelectAllUpdate )); + this->Connect(wxID_SELECT_ALL , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditSelectAll )); + this->Connect(wxID_SELECT_NONE , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditSelectNoneUpdate )); + this->Connect(wxID_SELECT_NONE , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditSelectNone )); + this->Connect(wxID_VIEW_SCROLL_AUTO , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewScrollUpdate )); + this->Connect(wxID_VIEW_SCROLL_AUTO , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewScroll )); + this->Connect(wxID_VIEW_SOURCE_EAPHOST , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceEAPHostUpdate )); + this->Connect(wxID_VIEW_SOURCE_EAPHOST , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceEAPHost )); + this->Connect(wxID_VIEW_SOURCE_SCHANNEL, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceSchannelUpdate)); + this->Connect(wxID_VIEW_SOURCE_SCHANNEL, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceSchannel )); + this->Connect(wxID_VIEW_SOURCE_PRODUCT , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceProductUpdate )); + this->Connect(wxID_VIEW_SOURCE_PRODUCT , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceProduct )); + this->Connect(wxID_VIEW_LEVEL_VERBOSE , wxID_VIEW_LEVEL_ERROR, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewLevelUpdate )); + this->Connect(wxID_VIEW_LEVEL_VERBOSE , wxID_VIEW_LEVEL_ERROR, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewLevel )); +} + + +wxEventMonitorFrame::~wxEventMonitorFrame() +{ + // Disconnect Events + this->Disconnect(wxID_EXIT , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnExit )); + this->Disconnect(wxID_COPY , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditCopyUpdate )); + this->Disconnect(wxID_COPY , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditCopy )); + this->Disconnect(wxID_COPY_ALL , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditCopyAllUpdate )); + this->Disconnect(wxID_COPY_ALL , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditCopyAll )); + this->Disconnect(wxID_CLEAR , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditClearUpdate )); + this->Disconnect(wxID_CLEAR , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditClear )); + this->Disconnect(wxID_SELECT_ALL , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditSelectAllUpdate )); + this->Disconnect(wxID_SELECT_ALL , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditSelectAll )); + this->Disconnect(wxID_SELECT_NONE , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnEditSelectNoneUpdate )); + this->Disconnect(wxID_SELECT_NONE , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnEditSelectNone )); + this->Disconnect(wxID_VIEW_SCROLL_AUTO , wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewScrollUpdate )); + this->Disconnect(wxID_VIEW_SCROLL_AUTO , wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewScroll )); + this->Disconnect(wxID_VIEW_SOURCE_EAPHOST, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceEAPHostUpdate)); + this->Disconnect(wxID_VIEW_SOURCE_EAPHOST, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceEAPHost )); + this->Disconnect(wxID_VIEW_SOURCE_SCHANNEL, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceSchannelUpdate)); + this->Disconnect(wxID_VIEW_SOURCE_SCHANNEL, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceSchannel )); + this->Disconnect(wxID_VIEW_SOURCE_PRODUCT, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewSourceProductUpdate)); + this->Disconnect(wxID_VIEW_SOURCE_PRODUCT, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewSourceProduct )); + this->Disconnect(wxID_VIEW_LEVEL_VERBOSE , wxID_VIEW_LEVEL_ERROR, wxEVT_UPDATE_UI, wxUpdateUIEventHandler(wxEventMonitorFrame::OnViewLevelUpdate )); + this->Disconnect(wxID_VIEW_LEVEL_VERBOSE , wxID_VIEW_LEVEL_ERROR, wxEVT_MENU , wxCommandEventHandler (wxEventMonitorFrame::OnViewLevel )); + + m_mgr.UnInit(); + } @@ -55,6 +247,147 @@ void wxEventMonitorFrame::OnExit(wxCommandEvent& /*event*/) } +void wxEventMonitorFrame::OnEditCopyUpdate(wxUpdateUIEvent& event) +{ + event.Enable(m_panel->m_log->GetSelectedItemCount() != 0); +} + + +void wxEventMonitorFrame::OnEditCopy(wxCommandEvent& /*event*/) +{ + m_panel->m_log->CopySelected(); +} + + +void wxEventMonitorFrame::OnEditCopyAllUpdate(wxUpdateUIEvent& event) +{ + event.Enable(!m_panel->m_log->IsEmpty()); +} + + +void wxEventMonitorFrame::OnEditCopyAll(wxCommandEvent& /*event*/) +{ + m_panel->m_log->CopyAll(); +} + + +void wxEventMonitorFrame::OnEditClearUpdate(wxUpdateUIEvent& event) +{ + event.Enable(!m_panel->m_log->IsEmpty()); +} + + +void wxEventMonitorFrame::OnEditClear(wxCommandEvent& /*event*/) +{ + m_panel->m_log->ClearAll(); +} + + +void wxEventMonitorFrame::OnEditSelectAllUpdate(wxUpdateUIEvent& event) +{ + event.Enable(m_panel->m_log->GetSelectedItemCount() != m_panel->m_log->GetItemCount()); +} + + +void wxEventMonitorFrame::OnEditSelectAll(wxCommandEvent& /*event*/) +{ + m_panel->m_log->SelectAll(); +} + + +void wxEventMonitorFrame::OnEditSelectNoneUpdate(wxUpdateUIEvent& event) +{ + event.Enable(m_panel->m_log->GetSelectedItemCount() != 0); +} + + +void wxEventMonitorFrame::OnEditSelectNone(wxCommandEvent& /*event*/) +{ + m_panel->m_log->SelectNone(); +} + + +void wxEventMonitorFrame::OnViewScrollUpdate(wxUpdateUIEvent& event) +{ + event.Check(m_panel->m_log->m_scroll_auto); +} + + +void wxEventMonitorFrame::OnViewScroll(wxCommandEvent& event) +{ + m_panel->m_log->m_scroll_auto = event.IsChecked(); + if (m_panel->m_log->m_scroll_auto) { + long count = m_panel->m_log->GetItemCount(); + if (count) + m_panel->m_log->EnsureVisible(count - 1); + } +} + + +void wxEventMonitorFrame::OnViewSourceEAPHostUpdate(wxUpdateUIEvent& event) +{ + event.Check(m_panel->m_log->m_source_eaphost); +} + + +void wxEventMonitorFrame::OnViewSourceEAPHost(wxCommandEvent& event) +{ + bool state_new = event.IsChecked(); + if (m_panel->m_log->m_source_eaphost != state_new) { + m_panel->m_log->m_source_eaphost = state_new; + m_panel->m_log->RebuildItems(); + } +} + + +void wxEventMonitorFrame::OnViewSourceSchannelUpdate(wxUpdateUIEvent& event) +{ + event.Check(m_panel->m_log->m_source_schannel); +} + + +void wxEventMonitorFrame::OnViewSourceSchannel(wxCommandEvent& event) +{ + bool state_new = event.IsChecked(); + if (m_panel->m_log->m_source_schannel != state_new) { + m_panel->m_log->m_source_schannel = state_new; + m_panel->m_log->RebuildItems(); + } +} + + +void wxEventMonitorFrame::OnViewSourceProductUpdate(wxUpdateUIEvent& event) +{ + event.Check(m_panel->m_log->m_source_product); +} + + +void wxEventMonitorFrame::OnViewSourceProduct(wxCommandEvent& event) +{ + bool state_new = event.IsChecked(); + if (m_panel->m_log->m_source_product != state_new) { + m_panel->m_log->m_source_product = state_new; + m_panel->m_log->RebuildItems(); + } +} + + +void wxEventMonitorFrame::OnViewLevelUpdate(wxUpdateUIEvent& event) +{ + event.Check(TRACE_LEVEL_ERROR + wxID_VIEW_LEVEL_ERROR - event.GetId() == m_panel->m_log->m_level); +} + + +void wxEventMonitorFrame::OnViewLevel(wxCommandEvent& event) +{ + UCHAR state_new = TRACE_LEVEL_ERROR + wxID_VIEW_LEVEL_ERROR - event.GetId(); + if (m_panel->m_log->m_level != state_new) { + m_panel->m_log->m_level = state_new; + m_panel->m_log->RebuildItems(); + } +} + + ////////////////////////////////////////////////////////////////////////// // wxPersistentEventMonitorFrame ////////////////////////////////////////////////////////////////////////// diff --git a/EventMonitor/Frame.h b/EventMonitor/Frame.h index d4f662a..ac1912c 100644 --- a/EventMonitor/Frame.h +++ b/EventMonitor/Frame.h @@ -30,20 +30,92 @@ class wxPersistentEventMonitorFrame; #pragma once; +#include "LogPanel.h" + #include "wxEventMonitor_UI.h" + +#include +#include +#include +#include +#include #include +#include -class wxEventMonitorFrame : public wxEventMonitorFrameBase + +class wxEventMonitorFrame : public wxFrame { +protected: + enum { + wxID_COPY_ALL = 1000, + wxID_SELECT_ALL, + wxID_SELECT_NONE, + wxID_VIEW_SCROLL_AUTO, + wxID_VIEW_SOURCE_EAPHOST, + wxID_VIEW_SOURCE_SCHANNEL, + wxID_VIEW_SOURCE_PRODUCT, + wxID_VIEW_LEVEL_VERBOSE, + wxID_VIEW_LEVEL_INFORMATION, + wxID_VIEW_LEVEL_WARNING, + wxID_VIEW_LEVEL_ERROR + }; + public: - wxEventMonitorFrame(); + wxEventMonitorFrame(wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Event Monitor"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize(600,400), long style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL, const wxString& name = wxT("EventMonitor")); + ~wxEventMonitorFrame(); friend class wxPersistentEventMonitorFrame; protected: void OnExit(wxCommandEvent& event); - wxDECLARE_EVENT_TABLE(); + void OnEditCopyUpdate(wxUpdateUIEvent& event); + void OnEditCopy(wxCommandEvent& event); + void OnEditCopyAllUpdate(wxUpdateUIEvent& event); + void OnEditCopyAll(wxCommandEvent& event); + void OnEditClearUpdate(wxUpdateUIEvent& event); + void OnEditClear(wxCommandEvent& event); + void OnEditSelectAllUpdate(wxUpdateUIEvent& event); + void OnEditSelectAll(wxCommandEvent& event); + void OnEditSelectNoneUpdate(wxUpdateUIEvent& event); + void OnEditSelectNone(wxCommandEvent& event); + void OnViewScrollUpdate(wxUpdateUIEvent& event); + void OnViewScroll(wxCommandEvent& event); + void OnViewSourceEAPHostUpdate(wxUpdateUIEvent& event); + void OnViewSourceEAPHost(wxCommandEvent& event); + void OnViewSourceSchannelUpdate(wxUpdateUIEvent& event); + void OnViewSourceSchannel(wxCommandEvent& event); + void OnViewSourceProductUpdate(wxUpdateUIEvent& event); + void OnViewSourceProduct(wxCommandEvent& event); + void OnViewLevelUpdate(wxUpdateUIEvent& event); + void OnViewLevel(wxCommandEvent& event); + +protected: + wxMenuBar* m_menubar; + wxMenu* m_menuProgram; + wxMenu* m_menuEdit; + wxMenu* m_menuView; + wxMenuItem* m_menuViewSourceProduct; + wxMenuItem* m_menuViewLevelVerbose; + wxMenuItem* m_menuViewLevelInformation; + wxMenuItem* m_menuViewLevelWarning; + wxMenuItem* m_menuViewLevelError; + wxAuiToolBar* m_toolbarEdit; + wxAuiToolBarItem* m_toolEditCopy; + wxAuiToolBarItem* m_toolEditCopyAll; + wxAuiToolBarItem* m_toolEditClear; + wxAuiToolBar* m_toolbarView; + wxAuiToolBarItem* m_toolViewScrollAuto; + wxAuiToolBarItem* m_toolViewSourceEAPHost; + wxAuiToolBarItem* m_toolViewSourceSchannel; + wxAuiToolBarItem* m_toolViewSourceProduct; + wxAuiToolBarItem* m_toolViewLevelVerbose; + wxAuiToolBarItem* m_toolViewLevelInformation; + wxAuiToolBarItem* m_toolViewLevelWarning; + wxAuiToolBarItem* m_toolViewLevelError; + wxStatusBar* m_statusBar; + wxEventMonitorLogPanel* m_panel; + wxAuiManager m_mgr; }; diff --git a/EventMonitor/LogPanel.cpp b/EventMonitor/LogPanel.cpp index 33af11a..ea94f75 100644 --- a/EventMonitor/LogPanel.cpp +++ b/EventMonitor/LogPanel.cpp @@ -51,13 +51,7 @@ void wxPersistentEventMonitorLogPanel::Save() const { const wxEventMonitorLogPanel * const wnd = static_cast(GetWindow()); - // Save log's column widths. - wxListItem col; - col.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_WIDTH); - for (int i = 0, n = wnd->m_log->GetColumnCount(); i < n; i++) { - wnd->m_log->GetColumn(i, col); - SaveValue(wxString::Format(wxT("Column%sWidth"), col.GetText().c_str()), col.GetWidth()); - } + wxPersistentETWListCtrl(wnd->m_log).Save(); } @@ -65,16 +59,7 @@ bool wxPersistentEventMonitorLogPanel::Restore() { wxEventMonitorLogPanel * const wnd = static_cast(GetWindow()); - // Restore log's column widths. - wxListItem col; - col.SetMask(wxLIST_MASK_TEXT); - for (int i = 0, n = wnd->m_log->GetColumnCount(); i < n; i++) { - wnd->m_log->GetColumn(i, col); - - int width; - if (RestoreValue(wxString::Format(wxT("Column%sWidth"), col.GetText().c_str()), &width)) - wnd->m_log->SetColumnWidth(i, width); - } + wxPersistentETWListCtrl(wnd->m_log).Restore(); return true; } diff --git a/EventMonitor/StdAfx.h b/EventMonitor/StdAfx.h index 90033a6..f0ca8ec 100644 --- a/EventMonitor/StdAfx.h +++ b/EventMonitor/StdAfx.h @@ -25,6 +25,8 @@ #include "Frame.h" #include "LogPanel.h" +#include "../lib/EAPBase_UI/include/EAP_UI.h" + #include "../include/Version.h" #include @@ -43,6 +45,8 @@ #include #include +#include #include +#include #include // Must include after diff --git a/EventMonitor/wxEventMonitor_UI.cpp b/EventMonitor/wxEventMonitor_UI.cpp index e3a63cb..92facf1 100644 --- a/EventMonitor/wxEventMonitor_UI.cpp +++ b/EventMonitor/wxEventMonitor_UI.cpp @@ -13,54 +13,12 @@ /////////////////////////////////////////////////////////////////////////// -wxEventMonitorFrameBase::wxEventMonitorFrameBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) : wxFrame( parent, id, title, pos, size, style, name ) -{ - this->SetSizeHints( wxSize( 150,150 ), wxDefaultSize ); - m_mgr.SetManagedWindow(this); - m_mgr.SetFlags(wxAUI_MGR_DEFAULT); - - m_menubar = new wxMenuBar( 0 ); - m_menuProgram = new wxMenu(); - wxMenuItem* m_menuItemExit; - m_menuItemExit = new wxMenuItem( m_menuProgram, wxID_EXIT, wxString( _("E&xit") ) + wxT('\t') + wxT("Alt+F4"), _("Quit this program"), wxITEM_NORMAL ); - m_menuProgram->Append( m_menuItemExit ); - - m_menubar->Append( m_menuProgram, _("&Program") ); - - this->SetMenuBar( m_menubar ); - - m_panel = new wxEventMonitorLogPanel( this ); - - m_mgr.AddPane( m_panel, wxAuiPaneInfo() .Name( wxT("LogPanel") ).Center() .Caption( _("Log Trace") ).CaptionVisible( false ).CloseButton( false ).PaneBorder( false ).Dock().Resizable().FloatingSize( wxDefaultSize ).Floatable( false ) ); - - m_statusBar = this->CreateStatusBar( 1, wxST_SIZEGRIP, wxID_ANY ); - - m_mgr.Update(); - this->Centre( wxBOTH ); - - // Connect Events - this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( wxEventMonitorFrameBase::OnClose ) ); - this->Connect( wxEVT_ICONIZE, wxIconizeEventHandler( wxEventMonitorFrameBase::OnIconize ) ); - this->Connect( wxEVT_IDLE, wxIdleEventHandler( wxEventMonitorFrameBase::OnIdle ) ); -} - -wxEventMonitorFrameBase::~wxEventMonitorFrameBase() -{ - // Disconnect Events - this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( wxEventMonitorFrameBase::OnClose ) ); - this->Disconnect( wxEVT_ICONIZE, wxIconizeEventHandler( wxEventMonitorFrameBase::OnIconize ) ); - this->Disconnect( wxEVT_IDLE, wxIdleEventHandler( wxEventMonitorFrameBase::OnIdle ) ); - - m_mgr.UnInit(); - -} - wxEventMonitorLogPanelBase::wxEventMonitorLogPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) : wxPanel( parent, id, pos, size, style, name ) { wxBoxSizer* bSizerMain; bSizerMain = new wxBoxSizer( wxVERTICAL ); - m_log = new wxETWListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL|wxNO_BORDER ); + m_log = new wxETWListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VIRTUAL|wxNO_BORDER ); bSizerMain->Add( m_log, 1, wxEXPAND, 5 ); diff --git a/EventMonitor/wxEventMonitor_UI.fbp b/EventMonitor/wxEventMonitor_UI.fbp index d86f5ed..9ef564c 100644 --- a/EventMonitor/wxEventMonitor_UI.fbp +++ b/EventMonitor/wxEventMonitor_UI.fbp @@ -26,261 +26,6 @@ UI 1 1 - - 1 - wxAUI_MGR_DEFAULT - - wxBOTH - - 1 - 1 - impl_virtual - - - - 0 - wxID_ANY - - 150,150 - wxEventMonitorFrameBase - - 600,400 - wxDEFAULT_FRAME_STYLE - - Event Monitor - - - EventMonitor - wxTAB_TRAVERSAL - 1 - - - - - - - - - - OnClose - - - - OnIconize - OnIdle - - - - - - - - - - - - - - - - - - - - - - - - 1 - 1 - - - 0 - wxID_ANY - Menu - - - m_menubar - protected - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - &Program - m_menuProgram - protected - - - 0 - 1 - Quit this program - wxID_EXIT - wxITEM_NORMAL - E&xit - m_menuItemExit - none - Alt+F4 - - - - - - - - 1 - 1 - 1 - 1 - - LogPanel - - - - - Log Trace - 0 - 0 - wxEventMonitorLogPanel - 0 - m_panel = new wxEventMonitorLogPanel( this ); - - 1 - wxEventMonitorLogPanel* m_panel; - 0 - Dock - 0 - Center - 1 - - 0 - - 0 - 0 - wxID_ANY - class wxEventMonitorLogPanel; - - 0 - - - 0 - - 1 - m_panel - 0 - - - public - 0 - - Resizable - - 1 - - - 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 1 - 1 - - 1 - - 0 - wxID_ANY - - - m_statusBar - protected - - - wxST_SIZEGRIP - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 wxAUI_MGR_DEFAULT @@ -381,13 +126,13 @@ 1 - protected + public 1 Resizable 1 - wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL + wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VIRTUAL wxETWListCtrl; ETWLog.h 0 diff --git a/EventMonitor/wxEventMonitor_UI.h b/EventMonitor/wxEventMonitor_UI.h index e863c18..c2cad38 100644 --- a/EventMonitor/wxEventMonitor_UI.h +++ b/EventMonitor/wxEventMonitor_UI.h @@ -13,53 +13,17 @@ #include class wxETWListCtrl; -#include -#include -#include -#include -#include +#include #include #include #include #include -class wxEventMonitorLogPanel; -#include -#include -#include -#include +#include #include #include /////////////////////////////////////////////////////////////////////////// -/////////////////////////////////////////////////////////////////////////////// -/// Class wxEventMonitorFrameBase -/////////////////////////////////////////////////////////////////////////////// -class wxEventMonitorFrameBase : public wxFrame -{ - private: - - protected: - wxMenuBar* m_menubar; - wxMenu* m_menuProgram; - wxStatusBar* m_statusBar; - - // Virtual event handlers, overide them in your derived class - virtual void OnClose( wxCloseEvent& event ) { event.Skip(); } - virtual void OnIconize( wxIconizeEvent& event ) { event.Skip(); } - virtual void OnIdle( wxIdleEvent& event ) { event.Skip(); } - - - public: - wxEventMonitorLogPanel* m_panel; - - wxEventMonitorFrameBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Event Monitor"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 600,400 ), long style = wxDEFAULT_FRAME_STYLE|wxTAB_TRAVERSAL, const wxString& name = wxT("EventMonitor") ); - wxAuiManager m_mgr; - - ~wxEventMonitorFrameBase(); - -}; - /////////////////////////////////////////////////////////////////////////////// /// Class wxEventMonitorLogPanelBase /////////////////////////////////////////////////////////////////////////////// @@ -68,9 +32,9 @@ class wxEventMonitorLogPanelBase : public wxPanel private: protected: - wxETWListCtrl* m_log; public: + wxETWListCtrl* m_log; wxEventMonitorLogPanelBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxTAB_TRAVERSAL, const wxString& name = wxT("EventMonitorLogPanel") ); ~wxEventMonitorLogPanelBase(); diff --git a/lib/WinStd b/lib/WinStd index 54ab70b..d0c6be2 160000 --- a/lib/WinStd +++ b/lib/WinStd @@ -1 +1 @@ -Subproject commit 54ab70b26356eaccec1f793bc9e15624eb2e89f8 +Subproject commit d0c6be257b5b3cfa0ecead2430f9a2002937741f