/* Archive::createDir * Creates a directory at [path], starting from [base]. If * [base] is NULL, the root directory is used. Returns the created * directory. If the directory requested to be created already * exists, it will be returned *******************************************************************/ ArchiveTreeNode* Archive::createDir(string path, ArchiveTreeNode* base) { // Abort if read only if (read_only) return dir_root; // If no base dir specified, set it to root if (!base) base = dir_root; if (path.IsEmpty()) return base; // Create the directory ArchiveTreeNode* dir = (ArchiveTreeNode*)((STreeNode*)base)->addChild(path); // Record undo step if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(new DirCreateDeleteUS(true, dir)); // Set the archive state to modified setModified(true); // Announce MemChunk mc; wxUIntPtr ptr = wxPtrToUInt(dir); mc.write(&ptr, sizeof(wxUIntPtr)); announce("directory_added", mc); return dir; }
/* Archive::renameDir * Renames [dir] to [new_name]. Returns false if [dir] isn't part of * the archive, true otherwise *******************************************************************/ bool Archive::renameDir(ArchiveTreeNode* dir, string new_name) { // Abort if read only if (read_only) return false; // Check the directory is part of this archive if (dir->getArchive() != this) return false; // Rename the directory if needed if (!(S_CMPNOCASE(dir->getName(), new_name))) { if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(new DirRenameUS(dir, new_name)); dir->setName(new_name); dir->getDirEntry()->setState(1); } else return true; // Announce MemChunk mc; wxUIntPtr ptr = wxPtrToUInt(dir); mc.write(&ptr, sizeof(wxUIntPtr)); announce("directory_modified", mc); // Update variables etc setModified(true); return true; }
// ----------------------------------------------------------------------------- // Renames [dir] to [new_name]. // Returns false if [dir] isn't part of the archive, true otherwise // ----------------------------------------------------------------------------- bool Archive::renameDir(ArchiveTreeNode* dir, string_view new_name) { // Abort if read only if (read_only_) return false; // Check the directory is part of this archive if (!dir || dir->archive() != this) return false; // Rename the directory if needed if (dir->name() == new_name) { if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(std::make_unique<DirRenameUS>(dir, new_name)); dir->setName(new_name); dir->dirEntry()->setState(ArchiveEntry::State::Modified); } else return true; // Announce MemChunk mc; wxUIntPtr ptr = wxPtrToUInt(dir); mc.write(&ptr, sizeof(wxUIntPtr)); announce("directory_modified", mc); // Update variables etc setModified(true); return true; }
int bmx_wxlistctrl_setitemdata(wxListCtrl * list, long item, BBObject * data) { // delete current client data if any exists bmx_releaseindexedclientdata(list, item); if (data != &bbNullObject) { BBRETAIN( data ); } return static_cast<int>(list->SetItemData(item, wxPtrToUInt((void *)data))); }
// return the id for calling Win32 API functions WXWPARAM wxMenuItem::GetMSWId() const { // we must use ids in unsigned short range with Windows functions, if we // pass ids > USHRT_MAX to them they get very confused (e.g. start // generating WM_COMMAND messages with negative high word of wParam), so // use the cast to ensure the id is in range return m_subMenu ? wxPtrToUInt(m_subMenu->GetHMenu()) : static_cast<unsigned short>(GetId()); }
void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; wxLogTrace(TRACE_THREADS, _T("Thread %p started."), THR_ID(pthread)); // associate the thread pointer with the newly created thread so that // wxThread::This() will work int rc = pthread_setspecific(gs_keySelf, thread); if ( rc != 0 ) { wxLogSysError(rc, _("Cannot start thread: error writing TLS")); return (void *)-1; } // have to declare this before pthread_cleanup_push() which defines a // block! bool dontRunAtAll; #ifdef wxHAVE_PTHREAD_CLEANUP // install the cleanup handler which will be called if the thread is // cancelled pthread_cleanup_push(wxPthreadCleanup, thread); #endif // wxHAVE_PTHREAD_CLEANUP // wait for the semaphore to be posted from Run() pthread->m_semRun.Wait(); // test whether we should run the run at all - may be it was deleted // before it started to Run()? { wxCriticalSectionLocker lock(thread->m_critsect); dontRunAtAll = pthread->GetState() == STATE_NEW && pthread->WasCancelled(); } if ( !dontRunAtAll ) { // call the main entry wxLogTrace(TRACE_THREADS, _T("Thread %p about to enter its Entry()."), THR_ID(pthread)); wxTRY { pthread->m_exitcode = thread->Entry(); wxLogTrace(TRACE_THREADS, _T("Thread %p Entry() returned %lu."), THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); } wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) {
/* Archive::removeEntry * Removes [entry] from the archive. If [delete_entry] is true, the * entry will also be deleted. Returns true if the removal succeeded *******************************************************************/ bool Archive::removeEntry(ArchiveEntry* entry, bool delete_entry) { // Abort if read only if (read_only) return false; // Check entry if (!checkEntry(entry)) return false; // Check if entry is locked if (entry->isLocked()) return false; // Get its directory ArchiveTreeNode* dir = entry->getParentDir(); // Error if entry has no parent directory if (!dir) return false; // Create undo step if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(new EntryCreateDeleteUS(false, entry)); // Get the entry index int index = dir->entryIndex(entry); // Announce (before actually removing in case entry is still needed) MemChunk mc; wxUIntPtr ptr = wxPtrToUInt(entry); mc.write(&index, sizeof(int)); mc.write(&ptr, sizeof(wxUIntPtr)); announce("entry_removing", mc); // Remove it from its directory bool ok = dir->removeEntry(index); // If it was removed ok if (ok) { // Announce removed announce("entry_removed", mc); // Delete if necessary if (delete_entry) delete entry; // Update variables etc setModified(true); } return ok; }
void OnStackFrame(const wxStackFrame& frame) { string location = "[unknown location] "; if (frame.HasSourceLocation()) location = S_FMT("(%s:%d) ", frame.GetFileName(), frame.GetLine()); wxUIntPtr address = wxPtrToUInt(frame.GetAddress()); string func_name = frame.GetName(); if (func_name.IsEmpty()) func_name = S_FMT("[unknown:%d]", address); stack_trace.Append(S_FMT("%d: %s%s\n", frame.GetLevel(), location, func_name)); }
void select_scanned_file_dlg::sort_by(size_t column, bool ascending) { auto info = compare_playlist_file_info_t{ &m_playlists, column, ascending }; m_lc_files->SortItems(compare_playlist_file_cptrs, wxPtrToUInt(&info)); if (m_sorted_by_column != column) set_column_image(m_sorted_by_column, -1); set_column_image(column, ascending ? 0 : 1); m_sorted_by_column = column; m_sorted_ascending = ascending; }
void bmx_wxlistitem_setdata(MaxListItem * item, BBObject * data) { if (item->Item().GetColumn() == 0) { // is there any data here already? BBObject * oldData = (BBObject *)wxUIntToPtr(item->Item().GetData()); if (oldData && (oldData != &bbNullObject)) { BBRELEASE(oldData); item->Item().SetData((void*)NULL); } if (data != &bbNullObject) { BBRETAIN( data ); } item->Item().SetData(wxPtrToUInt((void*)data)); } }
void wxFileListCtrl::MakeDir() { wxString new_name( _("NewName") ); wxString path( m_dirName ); path += wxFILE_SEP_PATH; path += new_name; if (wxFileExists(path)) { // try NewName0, NewName1 etc. int i = 0; do { new_name = _("NewName"); wxString num; num.Printf( wxT("%d"), i ); new_name += num; path = m_dirName; path += wxFILE_SEP_PATH; path += new_name; i++; } while (wxFileExists(path)); } wxLogNull log; if (!wxMkdir(path)) { wxMessageDialog dialog(this, _("Operation not permitted."), _("Error"), wxOK | wxICON_ERROR ); dialog.ShowModal(); return; } wxFileData *fd = new wxFileData( path, new_name, wxFileData::is_dir, wxFileIconsTable::folder ); wxListItem item; item.m_itemId = 0; item.m_col = 0; long itemid = Add( fd, item ); if (itemid != -1) { SortItems(m_sort_field, m_sort_forward); itemid = FindItem( 0, wxPtrToUInt(fd) ); EnsureVisible( itemid ); EditLabel( itemid ); } else delete fd; }
void DialogAttachments::UpdateList() { listView->ClearAll(); // Insert list columns listView->InsertColumn(0, _("Attachment name"), wxLIST_FORMAT_LEFT, 280); listView->InsertColumn(1, _("Size"), wxLIST_FORMAT_LEFT, 100); listView->InsertColumn(2, _("Group"), wxLIST_FORMAT_LEFT, 100); // Fill list for (auto attach : ass->Line | agi::of_type<AssAttachment>()) { int row = listView->GetItemCount(); listView->InsertItem(row,attach->GetFileName(true)); listView->SetItem(row,1,PrettySize(attach->GetSize())); listView->SetItem(row,2,attach->GroupHeader()); listView->SetItemPtrData(row,wxPtrToUInt(attach)); } }
// Use topic or HTML filename bool wxCHMHelpController::DisplaySection(const wxString& section) { if (m_helpFile.IsEmpty()) return false; wxString str = GetValidFilename(m_helpFile); // Is this an HTML file or a keyword? if ( section.Find(wxT(".htm")) != wxNOT_FOUND ) { // interpret as a file name return CallHtmlHelpFunction(GetParentWindow(), str, HH_DISPLAY_TOPIC, wxPtrToUInt(section.c_str())); } return KeywordSearch(section); }
bool wxDebugReport::DoAddExceptionInfo(wxXmlNode *nodeContext) { #if wxUSE_CRASHREPORT wxCrashContext c; if ( !c.code ) return false; wxXmlNode *nodeExc = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("exception")); nodeContext->AddChild(nodeExc); HexProperty(nodeExc, wxT("code"), c.code); nodeExc->AddAttribute(wxT("name"), c.GetExceptionString()); HexProperty(nodeExc, wxT("address"), wxPtrToUInt(c.addr)); #ifdef __INTEL__ wxXmlNode *nodeRegs = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("registers")); nodeContext->AddChild(nodeRegs); HexElement(nodeRegs, wxT("eax"), c.regs.eax); HexElement(nodeRegs, wxT("ebx"), c.regs.ebx); HexElement(nodeRegs, wxT("ecx"), c.regs.edx); HexElement(nodeRegs, wxT("edx"), c.regs.edx); HexElement(nodeRegs, wxT("esi"), c.regs.esi); HexElement(nodeRegs, wxT("edi"), c.regs.edi); HexElement(nodeRegs, wxT("ebp"), c.regs.ebp); HexElement(nodeRegs, wxT("esp"), c.regs.esp); HexElement(nodeRegs, wxT("eip"), c.regs.eip); HexElement(nodeRegs, wxT("cs"), c.regs.cs); HexElement(nodeRegs, wxT("ds"), c.regs.ds); HexElement(nodeRegs, wxT("es"), c.regs.es); HexElement(nodeRegs, wxT("fs"), c.regs.fs); HexElement(nodeRegs, wxT("gs"), c.regs.gs); HexElement(nodeRegs, wxT("ss"), c.regs.ss); HexElement(nodeRegs, wxT("flags"), c.regs.flags); #endif // __INTEL__ return true; #else // !wxUSE_CRASHREPORT wxUnusedVar(nodeContext); return false; #endif // wxUSE_CRASHREPORT/!wxUSE_CRASHREPORT }
/* static */ bool wxCHMHelpController::ShowContextHelpPopup(const wxString& text, const wxPoint& pos, wxWindow *window) { HH_POPUP popup; popup.cbStruct = sizeof(popup); popup.hinst = (HINSTANCE) wxGetInstance(); popup.idString = 0 ; popup.pt.x = pos.x; popup.pt.y = pos.y; popup.clrForeground = (COLORREF)-1; popup.clrBackground = (COLORREF)-1; popup.rcMargins.top = popup.rcMargins.left = popup.rcMargins.right = popup.rcMargins.bottom = -1; popup.pszFont = NULL; popup.pszText = (const wxChar*) text; return CallHtmlHelpFunction(window, NULL, HH_DISPLAY_TEXT_POPUP, wxPtrToUInt(&popup)); }
void wxFileData::MakeItem( wxListItem &item ) { item.m_text = m_fileName; item.ClearAttributes(); if (IsExe()) item.SetTextColour(*wxRED); if (IsDir()) item.SetTextColour(*wxBLUE); item.m_image = m_image; if (IsLink()) { wxColour dg = wxTheColourDatabase->Find( wxT("MEDIUM GREY") ); if ( dg.IsOk() ) item.SetTextColour(dg); } item.m_data = wxPtrToUInt(this); }
/* static */ THREAD_RETVAL wxThreadInternal::DoThreadStart(wxThread *thread) { wxON_BLOCK_EXIT1(DoThreadOnExit, thread); THREAD_RETVAL rc = THREAD_ERROR_EXIT; wxTRY { // store the thread object in the TLS if ( !::TlsSetValue(gs_tlsThisThread, thread) ) { wxLogSysError(_("Cannot start thread: error writing TLS.")); return THREAD_ERROR_EXIT; } rc = wxPtrToUInt(thread->Entry()); } wxCATCH_ALL( wxTheApp->OnUnhandledException(); ) return rc;
bool wxCHMHelpController::KeywordSearch(const wxString& k, wxHelpSearchMode WXUNUSED(mode)) { if (m_helpFile.IsEmpty()) return false; wxString str = GetValidFilename(m_helpFile); HH_AKLINK link; link.cbStruct = sizeof(HH_AKLINK) ; link.fReserved = FALSE ; link.pszKeywords = k.c_str() ; link.pszUrl = NULL ; link.pszMsgText = NULL ; link.pszMsgTitle = NULL ; link.pszWindow = NULL ; link.fIndexOnFail = TRUE ; return CallHtmlHelpFunction(GetParentWindow(), str, HH_KEYWORD_LOOKUP, wxPtrToUInt(&link)); }
// ----------------------------------------------------------------------------- // Renames [entry] with [name]. // Returns false if the entry was invalid, true otherwise // ----------------------------------------------------------------------------- bool Archive::renameEntry(ArchiveEntry* entry, string_view name) { // Abort if read only if (read_only_) return false; // Check entry if (!checkEntry(entry)) return false; // Check if entry is locked if (entry->isLocked()) return false; // Check for directory if (entry->type() == EntryType::folderType()) return renameDir(dir(entry->path(true)), name); // Announce (before actually renaming in case old name is still needed) MemChunk mc; int index = entryIndex(entry); wxUIntPtr ptr = wxPtrToUInt(entry); mc.write(&index, sizeof(int)); mc.write(&ptr, sizeof(wxUIntPtr)); announce("entry_renaming", mc); // Create undo step if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(std::make_unique<EntryRenameUS>(entry, name)); // Rename the entry entry->setName(name); entry->formatName(formatDesc()); entry->setState(ArchiveEntry::State::Modified, true); // Announce modification entryStateChanged(entry); return true; }
/* Archive::entryStateChanged * Updates the archive variables and announces if necessary that an * entry's state has changed *******************************************************************/ void Archive::entryStateChanged(ArchiveEntry* entry) { // Check the entry is valid and part of this archive if (!checkEntry(entry)) return; // Get the entry index and announce the change MemChunk mc(8); wxUIntPtr ptr = wxPtrToUInt(entry); uint32_t index = entryIndex(entry); mc.write(&index, sizeof(uint32_t)); mc.write(&ptr, sizeof(wxUIntPtr)); announce("entry_state_changed", mc); // If entry was set to unmodified, don't set the archive to modified if (entry->getState() == 0) return; // Set the archive state to modified setModified(true); }
// ----------------------------------------------------------------------------- // Adds [entry] to [dir] at [position]. // If [dir] is null it is added to the root dir. // If [position] is out of bounds, it is added to the end of the dir. // If [copy] is true, a copy of [entry] is added (rather than [entry] itself). // Returns the added entry, or null if [entry] is invalid or the archive is // read-only // ----------------------------------------------------------------------------- ArchiveEntry* Archive::addEntry(ArchiveEntry* entry, unsigned position, ArchiveTreeNode* dir, bool copy) { // Abort if read only if (read_only_) return nullptr; // Check valid entry if (!entry) return nullptr; // If no dir given, set it to the root dir if (!dir) dir = &dir_root_; // Make a copy of the entry to add if needed if (copy) entry = new ArchiveEntry(*entry); // Add the entry dir->addEntry(entry, position); entry->formatName(formatDesc()); // Update variables etc setModified(true); entry->state_ = ArchiveEntry::State::New; // Announce MemChunk mc; wxUIntPtr ptr = wxPtrToUInt(entry); mc.write(&position, sizeof(uint32_t)); mc.write(&ptr, sizeof(wxUIntPtr)); announce("entry_added", mc); // Create undo step if (UndoRedo::currentlyRecording()) UndoRedo::currentManager()->recordUndoStep(std::make_unique<EntryCreateDeleteUS>(true, entry)); return entry; }
void ItemContainerTestCase::VoidData() { wxItemContainer * const container = GetContainer(); wxString item0data("item0data"), item1data("item0data"), item2data("item0data"); void* item0 = &item0data; void* item1 = &item1data; void* item2 = &item2data; container->Append("item 0", item0); CPPUNIT_ASSERT_EQUAL(item0, container->GetClientData(0)); container->Append("item 1"); container->SetClientData(1, item1); CPPUNIT_ASSERT_EQUAL(item1, container->GetClientData(1)); container->Insert("item 2", 2, item2); CPPUNIT_ASSERT_EQUAL(item2, container->GetClientData(2)); WX_ASSERT_FAILS_WITH_ASSERT( container->SetClientData((unsigned)-1, NULL) ); WX_ASSERT_FAILS_WITH_ASSERT( container->SetClientData(12345, NULL) ); // wxMSW used to hace problems retrieving the client data of -1 from a few // standard controls, especially if the last error was set before doing it, // so test for this specially. const wxUIntPtr minus1 = static_cast<wxUIntPtr>(-1); container->Append("item -1", wxUIntToPtr(minus1)); #ifdef __WINDOWS__ ::SetLastError(ERROR_INVALID_DATA); #endif CPPUNIT_ASSERT_EQUAL( minus1, wxPtrToUInt(container->GetClientData(3)) ); }
bool wxDebugReport::DoAddLoadedModules(wxXmlNode *nodeModules) { wxDynamicLibraryDetailsArray modules(wxDynamicLibrary::ListLoaded()); const size_t count = modules.GetCount(); if ( !count ) return false; for ( size_t n = 0; n < count; n++ ) { const wxDynamicLibraryDetails& info = modules[n]; wxXmlNode *nodeModule = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("module")); nodeModules->AddChild(nodeModule); wxString path = info.GetPath(); if ( path.empty() ) path = info.GetName(); if ( !path.empty() ) nodeModule->AddAttribute(wxT("path"), path); void *addr = NULL; size_t len = 0; if ( info.GetAddress(&addr, &len) ) { HexProperty(nodeModule, wxT("address"), wxPtrToUInt(addr)); HexProperty(nodeModule, wxT("size"), len); } wxString ver = info.GetVersion(); if ( !ver.empty() ) { nodeModule->AddAttribute(wxT("version"), ver); } } return true; }
bool wxCHMHelpController::DisplayContextPopup(int contextId) { if (m_helpFile.IsEmpty()) return false; wxString str = GetValidFilename(m_helpFile); // We also have to specify the popups file (default is cshelp.txt). // str += wxT("::/cshelp.txt"); HH_POPUP popup; popup.cbStruct = sizeof(popup); popup.hinst = (HINSTANCE) wxGetInstance(); popup.idString = contextId ; GetCursorPos(& popup.pt); popup.clrForeground = ::GetSysColor(COLOR_INFOTEXT); popup.clrBackground = ::GetSysColor(COLOR_INFOBK); popup.rcMargins.top = popup.rcMargins.left = popup.rcMargins.right = popup.rcMargins.bottom = -1; popup.pszFont = NULL; popup.pszText = NULL; return CallHtmlHelpFunction(GetParentWindow(), str, HH_DISPLAY_TEXT_POPUP, wxPtrToUInt(&popup)); }
long bmx_wxlistctrl_finditemdata(wxListCtrl * list, long start, BBObject * data) { return list->FindItem(start, wxPtrToUInt((void *)data)); }
static void wxScrollBarCallback(Widget widget, XtPointer clientData, XmScaleCallbackStruct *cbs) { wxScrollBar *scrollBar = (wxScrollBar*)wxGetWindowFromTable(widget); wxOrientation orientation = (wxOrientation)wxPtrToUInt(clientData); wxEventType eventType = wxEVT_NULL; switch (cbs->reason) { case XmCR_INCREMENT: { eventType = wxEVT_SCROLL_LINEDOWN; break; } case XmCR_DECREMENT: { eventType = wxEVT_SCROLL_LINEUP; break; } case XmCR_DRAG: { eventType = wxEVT_SCROLL_THUMBTRACK; break; } case XmCR_VALUE_CHANGED: { eventType = wxEVT_SCROLL_THUMBRELEASE; break; } case XmCR_PAGE_INCREMENT: { eventType = wxEVT_SCROLL_PAGEDOWN; break; } case XmCR_PAGE_DECREMENT: { eventType = wxEVT_SCROLL_PAGEUP; break; } case XmCR_TO_TOP: { eventType = wxEVT_SCROLL_TOP; break; } case XmCR_TO_BOTTOM: { eventType = wxEVT_SCROLL_BOTTOM; break; } default: { // Should never get here wxFAIL_MSG("Unknown scroll event."); break; } } wxScrollEvent event(eventType, scrollBar->GetId(), cbs->value, orientation); event.SetEventObject(scrollBar); scrollBar->GetEventHandler()->ProcessEvent(event); }
void *wxThreadInternal::PthreadStart(wxThread *thread) { wxThreadInternal *pthread = thread->m_internal; wxLogTrace(TRACE_THREADS, _T("Thread %ld started."), THR_ID(pthread)); // associate the thread pointer with the newly created thread so that // wxThread::This() will work int rc = pthread_setspecific(gs_keySelf, thread); if ( rc != 0 ) { wxLogSysError(rc, _("Cannot start thread: error writing TLS")); return (void *)-1; } // have to declare this before pthread_cleanup_push() which defines a // block! bool dontRunAtAll; #ifdef wxHAVE_PTHREAD_CLEANUP // install the cleanup handler which will be called if the thread is // cancelled pthread_cleanup_push(wxPthreadCleanup, thread); #endif // wxHAVE_PTHREAD_CLEANUP // wait for the semaphore to be posted from Run() pthread->m_semRun.Wait(); // test whether we should run the run at all - may be it was deleted // before it started to Run()? { wxCriticalSectionLocker lock(thread->m_critsect); dontRunAtAll = pthread->GetState() == STATE_NEW && pthread->WasCancelled(); } if ( !dontRunAtAll ) { // call the main entry wxLogTrace(TRACE_THREADS, _T("Thread %ld about to enter its Entry()."), THR_ID(pthread)); pthread->m_exitcode = thread->Entry(); wxLogTrace(TRACE_THREADS, _T("Thread %ld Entry() returned %lu."), THR_ID(pthread), wxPtrToUInt(pthread->m_exitcode)); { wxCriticalSectionLocker lock(thread->m_critsect); // change the state of the thread to "exited" so that // wxPthreadCleanup handler won't do anything from now (if it's // called before we do pthread_cleanup_pop below) pthread->SetState(STATE_EXITED); } } // NB: pthread_cleanup_push/pop() are macros and pop contains the matching // '}' for the '{' in push, so they must be used in the same block! #ifdef wxHAVE_PTHREAD_CLEANUP #ifdef __DECCXX // under Tru64 we get a warning from macro expansion #pragma message save #pragma message disable(declbutnotref) #endif // remove the cleanup handler without executing it pthread_cleanup_pop(FALSE); #ifdef __DECCXX #pragma message restore #endif #endif // wxHAVE_PTHREAD_CLEANUP if ( dontRunAtAll ) { // FIXME: deleting a possibly joinable thread here??? delete thread; return EXITCODE_CANCELLED; } else { // terminate the thread thread->Exit(pthread->m_exitcode); wxFAIL_MSG(wxT("wxThread::Exit() can't return.")); return NULL; } }
bool MaxListCtrl::SetSortCallback() { return SortItems(compare, wxPtrToUInt((void*)maxHandle)); }