/* 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));
}
