now returns bool not int.
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@93 
c3d73ce0-8a6f-49c7-b76d-
6d57e0e08775
13 files changed:
 
 Registry classes (check out wxConfig class - see issues.txt).
 
 
 Registry classes (check out wxConfig class - see issues.txt).
 
+Change DnD classes to use global symbols, and wxString.
+
 Update manual.
     wxApp changes       DONE
     wxMenu changes      DONE
 Update manual.
     wxApp changes       DONE
     wxMenu changes      DONE
     wxMsgCatalog etc.
     wxLog
     wxConfig, wxRegKey
     wxMsgCatalog etc.
     wxLog
     wxConfig, wxRegKey
+    wxTabCtrl           DONE
+    wxNotebook
+    wxWave              DONE
     wxJoystick
     wxStatusBar95 and wxFrame status bar functions
     wxListBox changes (for ownerdraw functionality)
     wxJoystick
     wxStatusBar95 and wxFrame status bar functions
     wxListBox changes (for ownerdraw functionality)
+    wxThread            DONE (except for topic overview)
     wxString
     wxTString
     Drag and drop (change API if required, e.g. const).
     wxString
     wxTString
     Drag and drop (change API if required, e.g. const).
 
-    inline wxTabCtrl(wxWindow *parent, const wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
-            const long style = 0, const wxString& name = "tabCtrl")
+    inline wxTabCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
+            long style = 0, const wxString& name = "tabCtrl")
     {
         Create(parent, id, pos, size, style, name);
     }
     {
         Create(parent, id, pos, size, style, name);
     }
 
 // Accessors
 
     // Get the selection
 
 // Accessors
 
     // Get the selection
-    int GetSelection(void) const;
+    int GetSelection() const;
 
     // Get the associated image list
 
     // Get the associated image list
-    wxImageList* GetImageList(void) const;
+    wxImageList* GetImageList() const;
 
     // Get the number of items
 
     // Get the number of items
-    int GetItemCount(void) const;
+    int GetItemCount() const;
 
     // Get the rect corresponding to the tab
 
     // Get the rect corresponding to the tab
-    bool GetItemRect(const int item, wxRect& rect) const;
+    bool GetItemRect(int item, wxRect& rect) const;
 
     // Get the number of rows
 
     // Get the number of rows
-    int GetRowCount(void) const;
+    int GetRowCount() const;
-    wxString GetItemText(const int item) const ;
+    wxString GetItemText(int item) const ;
-    int GetItemImage(const int item) const;
+    int GetItemImage(int item) const;
-    void* GetItemData(const int item) const;
+    void* GetItemData(int item) const;
-    int SetSelection(const int item);
+    int SetSelection(int item);
 
     // Set the image list
     void SetImageList(wxImageList* imageList);
 
     // Set the text for an item
 
     // Set the image list
     void SetImageList(wxImageList* imageList);
 
     // Set the text for an item
-    bool SetItemText(const int item, const wxString& text);
+    bool SetItemText(int item, const wxString& text);
 
     // Set the image for an item
 
     // Set the image for an item
-    bool SetItemImage(const int item, const int image);
+    bool SetItemImage(int item, int image);
 
     // Set the data for an item
 
     // Set the data for an item
-    bool SetItemData(const int item, void* data);
+    bool SetItemData(int item, void* data);
 
     // Set the size for a fixed-width tab control
     void SetItemSize(const wxSize& size);
 
     // Set the size for a fixed-width tab control
     void SetItemSize(const wxSize& size);
                 const long style = 0, const wxString& name = "tabCtrl");
 
     // Delete all items
                 const long style = 0, const wxString& name = "tabCtrl");
 
     // Delete all items
-    bool DeleteAllItems(void);
-    bool DeleteItem(const int item);
+    bool DeleteItem(int item);
 
     // Hit test
     int HitTest(const wxPoint& pt, long& flags);
 
     // Insert an item
 
     // Hit test
     int HitTest(const wxPoint& pt, long& flags);
 
     // Insert an item
-    int InsertItem(const int item, const wxString& text, const int imageId = -1, void* data = NULL);
+    bool InsertItem(int item, const wxString& text, int imageId = -1, void* data = NULL);
 
 #pragma interface "wave.h"
 #endif
 
 #pragma interface "wave.h"
 #endif
 
 
 class wxWave : public wxObject
 {
 public:
 
 class wxWave : public wxObject
 {
 public:
   wxWave(const wxString& fileName, bool isResource = FALSE);
   wxWave(const wxString& fileName, bool isResource = FALSE);
-  bool  Create(const wxString& sFileName, bool isResource = FALSE);
-  bool  IsOk(void) const { return (m_waveData ? TRUE : FALSE); };
+  bool  Create(const wxString& fileName, bool isResource = FALSE);
+  bool  IsOk() const { return (m_waveData ? TRUE : FALSE); };
   bool  Play(bool async = TRUE, bool looped = FALSE) const;
 
 protected:
   bool  Play(bool async = TRUE, bool looped = FALSE) const;
 
 protected:
 
 private:
   byte* m_waveData;
 
 private:
   byte* m_waveData;
 
 class WXDLLEXPORT wxMutex {
 public:
   // constructor & destructor 
 class WXDLLEXPORT wxMutex {
 public:
   // constructor & destructor 
-  wxMutex(void);
-  ~wxMutex(void);
+  wxMutex();
+  ~wxMutex();
-  wxMutexError Lock(void);
   // Try to lock the mutex: if it can't, returns immediately with an error.
   // Try to lock the mutex: if it can't, returns immediately with an error.
-  wxMutexError TryLock(void);
+  wxMutexError TryLock();
-  wxMutexError Unlock(void);
 
   // Returns true if the mutex is locked.
 
   // Returns true if the mutex is locked.
-  bool IsLocked(void) { return (m_locked > 0); }
+  bool IsLocked() const { return (m_locked > 0); }
 protected:
   friend class wxCondition;
 
 protected:
   friend class wxCondition;
 
 class WXDLLEXPORT wxCondition {
 public:
   // constructor & destructor
 class WXDLLEXPORT wxCondition {
 public:
   // constructor & destructor
-  wxCondition(void);
-  ~wxCondition(void);
+  wxCondition();
+  ~wxCondition();
   void Wait(wxMutex& mutex);
   // Waits until a signal is raised or the timeout is elapsed.
   bool Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec);
   // Raises a signal: only one "Waiter" is released.
   void Wait(wxMutex& mutex);
   // Waits until a signal is raised or the timeout is elapsed.
   bool Wait(wxMutex& mutex, unsigned long sec, unsigned long nsec);
   // Raises a signal: only one "Waiter" is released.
   // Broadcasts to all "Waiters".
   // Broadcasts to all "Waiters".
 private:
   wxConditionInternal *p_internal;
 };
 private:
   wxConditionInternal *p_internal;
 };
 class WXDLLEXPORT wxThread {
 public:
   // constructor & destructor.
 class WXDLLEXPORT wxThread {
 public:
   // constructor & destructor.
-  wxThread(void);
-  virtual ~wxThread(void);
+  wxThread();
+  virtual ~wxThread();
 
   // Create a new thread, this method should check there is only one thread
   // running by object.
 
   // Create a new thread, this method should check there is only one thread
   // running by object.
-  wxThreadError Create(void);
+  wxThreadError Create();
-  // Destroys the thread immediately if the flag DIFFER isn't true.
-  wxThreadError Destroy(void);
+  // Destroys the thread immediately if the defer flag isn't true.
+  wxThreadError Destroy();
-  // Switches on the DIFFER flag.
+  // Switches on the defer flag.
   void DeferDestroy(bool on);
 
   // Waits for the termination of the thread.
   void DeferDestroy(bool on);
 
   // Waits for the termination of the thread.
 
   // Sets the priority to "prio". (Warning: The priority can only be set before
   // the thread is created)
   void SetPriority(int prio);
   // Get the current priority.
 
   // Sets the priority to "prio". (Warning: The priority can only be set before
   // the thread is created)
   void SetPriority(int prio);
   // Get the current priority.
+  int GetPriority() const;
-  unsigned long GetID(void);
+  unsigned long GetID() const;
 
   // Returns true if the thread is alive.
 
   // Returns true if the thread is alive.
   // Returns true if the thread is the main thread (aka the GUI thread).
   // Returns true if the thread is the main thread (aka the GUI thread).
-  static bool IsMain(void);
 
   // Called when thread exits.
 
   // Called when thread exits.
-  virtual void OnExit(void);
 protected:
   // In case, the DIFFER flag is true, enables another thread to kill this one.
 protected:
   // In case, the DIFFER flag is true, enables another thread to kill this one.
-  void TestDestroy(void);
   // Exits from the current thread.
   void Exit(void *status = NULL);
 private:
   // Entry point for the thread.
   // Exits from the current thread.
   void Exit(void *status = NULL);
 private:
   // Entry point for the thread.
-  virtual void *Entry(void) = 0;
+  virtual void *Entry() = 0;
 
 private:
   friend class wxThreadInternal;
 
 private:
   friend class wxThreadInternal;
 
-MutexError wxMutex::Lock(void)
+MutexError wxMutex::Lock()
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
-MutexError wxMutex::TryLock(void)
+MutexError wxMutex::TryLock()
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
-MutexError wxMutex::Unlock(void)
+MutexError wxMutex::Unlock()
 {
   m_locked = FALSE;
   return NO_ERROR;
 }
 
 {
   m_locked = FALSE;
   return NO_ERROR;
 }
 
-wxCondition::wxCondition(void)
+wxCondition::wxCondition()
-wxCondition::~wxCondition(void)
+wxCondition::~wxCondition()
-void wxCondition::Signal(void)
+void wxCondition::Signal()
-void wxCondition::Broadcast(void)
+void wxCondition::Broadcast()
-ThreadError wxThread::Create(void)
+ThreadError wxThread::Create()
 {
   p_internal->exit_status = Entry();
   OnExit();
   return NO_ERROR;
 }
 
 {
   p_internal->exit_status = Entry();
   OnExit();
   return NO_ERROR;
 }
 
-ThreadError wxThread::Destroy(void)
+ThreadError wxThread::Destroy()
-void wxThread::DifferDestroy(void)
+void wxThread::DeferDestroy()
-void wxThread::TestDestroy(void)
+void wxThread::TestDestroy()
   return p_internal->exit_status;
 }
 
   return p_internal->exit_status;
 }
 
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
-bool wxThread::IsMain(void)
-bool wxThread::IsAlive(void)
+bool wxThread::IsAlive() const
 {
   return FALSE;
 }
 
 void wxThread::SetPriority(int WXUNUSED(prio)) { }
 {
   return FALSE;
 }
 
 void wxThread::SetPriority(int WXUNUSED(prio)) { }
-int wxThread::GetPriority(void) { }
+int wxThread::GetPriority() const { }
 
 wxMutex wxMainMutex; // controls access to all GUI functions
 
 
 wxMutex wxMainMutex; // controls access to all GUI functions
 
 
   pthread_mutex_t p_mutex;
 };
 
   pthread_mutex_t p_mutex;
 };
 
 {
   p_internal = new wxMutexInternal;
   pthread_mutex_init(&(p_internal->p_mutex), NULL);
   m_locked = false;
 }
 
 {
   p_internal = new wxMutexInternal;
   pthread_mutex_init(&(p_internal->p_mutex), NULL);
   m_locked = false;
 }
 
 {
   if (m_locked)
     pthread_mutex_unlock(&(p_internal->p_mutex));
 {
   if (m_locked)
     pthread_mutex_unlock(&(p_internal->p_mutex));
-wxMutexError wxMutex::Lock(void)
+wxMutexError wxMutex::Lock()
-wxMutexError wxMutex::TryLock(void)
+wxMutexError wxMutex::TryLock()
-wxMutexError wxMutex::Unlock(void)
+wxMutexError wxMutex::Unlock()
 {
   if (m_locked > 0) m_locked--;
   pthread_mutex_unlock(&(p_internal->p_mutex));
 {
   if (m_locked > 0) m_locked--;
   pthread_mutex_unlock(&(p_internal->p_mutex));
   pthread_cond_t p_condition;
 };
 
   pthread_cond_t p_condition;
 };
 
-wxCondition::wxCondition(void)
+wxCondition::wxCondition()
 {
   p_internal = new wxConditionInternal;
   pthread_cond_init(&(p_internal->p_condition), NULL);
 }
 
 {
   p_internal = new wxConditionInternal;
   pthread_cond_init(&(p_internal->p_condition), NULL);
 }
 
-wxCondition::~wxCondition(void)
+wxCondition::~wxCondition()
 {
   pthread_cond_destroy(&(p_internal->p_condition));
   delete p_internal;
 {
   pthread_cond_destroy(&(p_internal->p_condition));
   delete p_internal;
   return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 }
 
   return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 }
 
-void wxCondition::Signal(void)
+void wxCondition::Signal()
 {
   pthread_cond_signal(&(p_internal->p_condition));
 }
 
 {
   pthread_cond_signal(&(p_internal->p_condition));
 }
 
-void wxCondition::Broadcast(void)
+void wxCondition::Broadcast()
 {
   pthread_cond_broadcast(&(p_internal->p_condition));
 }
 {
   pthread_cond_broadcast(&(p_internal->p_condition));
 }
   p_internal->prio = prio;
 }
 
   p_internal->prio = prio;
 }
 
-int wxThread::GetPriority(void)
+int wxThread::GetPriority() const
 {
   return p_internal->prio;
 }
 {
   return p_internal->prio;
 }
     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 }
 
     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 }
 
-wxThreadError wxThread::Destroy(void)
+wxThreadError wxThread::Destroy()
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
 {
   return (unsigned long)p_internal->thread_id;
 }
 {
   return (unsigned long)p_internal->thread_id;
 }
-bool wxThread::IsMain(void)
+bool wxThread::IsMain() const
 {
   return (bool)pthread_equal(pthread_self(), p_mainid);
 }
 {
   return (bool)pthread_equal(pthread_self(), p_mainid);
 }
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
-  virtual bool OnInit(void) {
+  virtual bool OnInit() {
     wxThreadGuiInit();
     p_mainid = pthread_self();
     wxMainMutex.Lock();
     wxThreadGuiInit();
     p_mainid = pthread_self();
     wxMainMutex.Lock();
-  virtual void OnExit(void) {
+  virtual void OnExit() {
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
 
-wxMutex::MutexError wxMutex::Lock(void)
+wxMutex::MutexError wxMutex::Lock()
 {
   spin_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 }
 
 {
   spin_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 }
 
-wxMutex::MutexError wxMutex::TryLock(void)
+wxMutex::MutexError wxMutex::TryLock()
 {
   if (acquire_lock(&(p_internal->p_mutex)) != 0)
     return BUSY;
   return NO_ERROR;
 }
 
 {
   if (acquire_lock(&(p_internal->p_mutex)) != 0)
     return BUSY;
   return NO_ERROR;
 }
 
-wxMutex::MutexError wxMutex::Unlock(void)
+wxMutex::MutexError wxMutex::Unlock()
 {
   release_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 {
   release_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 
 // GLH: Don't now how it works on SGI. Wolfram ?
 
 
 // GLH: Don't now how it works on SGI. Wolfram ?
 
-wxCondition::wxCondition(void) {}
-wxCondition::~wxCondition(void) {}
+wxCondition::wxCondition() {}
+wxCondition::~wxCondition() {}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex)) { return 0;}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex), unsigned long WXUNUSED(sec),
                       unsigned long WXUNUSED(nsec)) { return 0; }
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex)) { return 0;}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex), unsigned long WXUNUSED(sec),
                       unsigned long WXUNUSED(nsec)) { return 0; }
-int wxCondition::Signal(void) { return 0; }
-int wxCondition::Broadcast(void) { return 0; }
+int wxCondition::Signal() { return 0; }
+int wxCondition::Broadcast() { return 0; }
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
 {
   return (unsigned long)p_internal->thread_id;
 }
 {
   return (unsigned long)p_internal->thread_id;
 }
-int wxThread::GetPriority(void)
+int wxThread::GetPriority() const
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
-  virtual bool OnInit(void) {
+  virtual bool OnInit() {
     wxThreadGuiInit();
     p_mainid = (int)getpid();
     wxMainMutex.Lock();
   }
 
     wxThreadGuiInit();
     p_mainid = (int)getpid();
     wxMainMutex.Lock();
   }
 
-  virtual void OnExit(void) {
+  virtual void OnExit() {
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
 
-MutexError wxMutex::Lock(void)
+MutexError wxMutex::Lock()
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
-MutexError wxMutex::TryLock(void)
+MutexError wxMutex::TryLock()
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
 {
   m_locked = TRUE;
   return NO_ERROR;
 }
 
-MutexError wxMutex::Unlock(void)
+MutexError wxMutex::Unlock()
 {
   m_locked = FALSE;
   return NO_ERROR;
 }
 
 {
   m_locked = FALSE;
   return NO_ERROR;
 }
 
-wxCondition::wxCondition(void)
+wxCondition::wxCondition()
-wxCondition::~wxCondition(void)
+wxCondition::~wxCondition()
-void wxCondition::Signal(void)
+void wxCondition::Signal()
-void wxCondition::Broadcast(void)
+void wxCondition::Broadcast()
-ThreadError wxThread::Create(void)
+ThreadError wxThread::Create()
 {
   p_internal->exit_status = Entry();
   OnExit();
   return NO_ERROR;
 }
 
 {
   p_internal->exit_status = Entry();
   OnExit();
   return NO_ERROR;
 }
 
-ThreadError wxThread::Destroy(void)
+ThreadError wxThread::Destroy()
-void wxThread::DifferDestroy(void)
+void wxThread::DeferDestroy()
-void wxThread::TestDestroy(void)
+void wxThread::TestDestroy()
   return p_internal->exit_status;
 }
 
   return p_internal->exit_status;
 }
 
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
-bool wxThread::IsMain(void)
-bool wxThread::IsAlive(void)
+bool wxThread::IsAlive() const
 {
   return FALSE;
 }
 
 void wxThread::SetPriority(int WXUNUSED(prio)) { }
 {
   return FALSE;
 }
 
 void wxThread::SetPriority(int WXUNUSED(prio)) { }
-int wxThread::GetPriority(void) { }
+int wxThread::GetPriority() const { }
 
 wxMutex wxMainMutex; // controls access to all GUI functions
 
 
 wxMutex wxMainMutex; // controls access to all GUI functions
 
 
   pthread_mutex_t p_mutex;
 };
 
   pthread_mutex_t p_mutex;
 };
 
 {
   p_internal = new wxMutexInternal;
   pthread_mutex_init(&(p_internal->p_mutex), NULL);
   m_locked = false;
 }
 
 {
   p_internal = new wxMutexInternal;
   pthread_mutex_init(&(p_internal->p_mutex), NULL);
   m_locked = false;
 }
 
 {
   if (m_locked)
     pthread_mutex_unlock(&(p_internal->p_mutex));
 {
   if (m_locked)
     pthread_mutex_unlock(&(p_internal->p_mutex));
-wxMutexError wxMutex::Lock(void)
+wxMutexError wxMutex::Lock()
-wxMutexError wxMutex::TryLock(void)
+wxMutexError wxMutex::TryLock()
-wxMutexError wxMutex::Unlock(void)
+wxMutexError wxMutex::Unlock()
 {
   if (m_locked > 0) m_locked--;
   pthread_mutex_unlock(&(p_internal->p_mutex));
 {
   if (m_locked > 0) m_locked--;
   pthread_mutex_unlock(&(p_internal->p_mutex));
   pthread_cond_t p_condition;
 };
 
   pthread_cond_t p_condition;
 };
 
-wxCondition::wxCondition(void)
+wxCondition::wxCondition()
 {
   p_internal = new wxConditionInternal;
   pthread_cond_init(&(p_internal->p_condition), NULL);
 }
 
 {
   p_internal = new wxConditionInternal;
   pthread_cond_init(&(p_internal->p_condition), NULL);
 }
 
-wxCondition::~wxCondition(void)
+wxCondition::~wxCondition()
 {
   pthread_cond_destroy(&(p_internal->p_condition));
   delete p_internal;
 {
   pthread_cond_destroy(&(p_internal->p_condition));
   delete p_internal;
   return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 }
 
   return (pthread_cond_timedwait(&(p_internal->p_condition), &(mutex.p_internal->p_mutex), &tspec) != ETIMEDOUT);
 }
 
-void wxCondition::Signal(void)
+void wxCondition::Signal()
 {
   pthread_cond_signal(&(p_internal->p_condition));
 }
 
 {
   pthread_cond_signal(&(p_internal->p_condition));
 }
 
-void wxCondition::Broadcast(void)
+void wxCondition::Broadcast()
 {
   pthread_cond_broadcast(&(p_internal->p_condition));
 }
 {
   pthread_cond_broadcast(&(p_internal->p_condition));
 }
   p_internal->prio = prio;
 }
 
   p_internal->prio = prio;
 }
 
-int wxThread::GetPriority(void)
+int wxThread::GetPriority() const
 {
   return p_internal->prio;
 }
 {
   return p_internal->prio;
 }
     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 }
 
     pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 }
 
-wxThreadError wxThread::Destroy(void)
+wxThreadError wxThread::Destroy()
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
 {
   return (unsigned long)p_internal->thread_id;
 }
 {
   return (unsigned long)p_internal->thread_id;
 }
-bool wxThread::IsMain(void)
+bool wxThread::IsMain() const
 {
   return (bool)pthread_equal(pthread_self(), p_mainid);
 }
 {
   return (bool)pthread_equal(pthread_self(), p_mainid);
 }
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
-  virtual bool OnInit(void) {
+  virtual bool OnInit() {
     wxThreadGuiInit();
     p_mainid = pthread_self();
     wxMainMutex.Lock();
     wxThreadGuiInit();
     p_mainid = pthread_self();
     wxMainMutex.Lock();
-  virtual void OnExit(void) {
+  virtual void OnExit() {
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
 
-wxMutex::MutexError wxMutex::Lock(void)
+wxMutex::MutexError wxMutex::Lock()
 {
   spin_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 }
 
 {
   spin_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 }
 
-wxMutex::MutexError wxMutex::TryLock(void)
+wxMutex::MutexError wxMutex::TryLock()
 {
   if (acquire_lock(&(p_internal->p_mutex)) != 0)
     return BUSY;
   return NO_ERROR;
 }
 
 {
   if (acquire_lock(&(p_internal->p_mutex)) != 0)
     return BUSY;
   return NO_ERROR;
 }
 
-wxMutex::MutexError wxMutex::Unlock(void)
+wxMutex::MutexError wxMutex::Unlock()
 {
   release_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 {
   release_lock(&(p_internal->p_mutex));
   return NO_ERROR;
 
 // GLH: Don't now how it works on SGI. Wolfram ?
 
 
 // GLH: Don't now how it works on SGI. Wolfram ?
 
-wxCondition::wxCondition(void) {}
-wxCondition::~wxCondition(void) {}
+wxCondition::wxCondition() {}
+wxCondition::~wxCondition() {}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex)) { return 0;}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex), unsigned long WXUNUSED(sec),
                       unsigned long WXUNUSED(nsec)) { return 0; }
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex)) { return 0;}
 int wxCondition::Wait(wxMutex& WXUNUSED(mutex), unsigned long WXUNUSED(sec),
                       unsigned long WXUNUSED(nsec)) { return 0; }
-int wxCondition::Signal(void) { return 0; }
-int wxCondition::Broadcast(void) { return 0; }
+int wxCondition::Signal() { return 0; }
+int wxCondition::Broadcast() { return 0; }
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
 {
   return (unsigned long)p_internal->thread_id;
 }
 {
   return (unsigned long)p_internal->thread_id;
 }
-int wxThread::GetPriority(void)
+int wxThread::GetPriority() const
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
-  virtual bool OnInit(void) {
+  virtual bool OnInit() {
     wxThreadGuiInit();
     p_mainid = (int)getpid();
     wxMainMutex.Lock();
   }
 
     wxThreadGuiInit();
     p_mainid = (int)getpid();
     wxMainMutex.Lock();
   }
 
-  virtual void OnExit(void) {
+  virtual void OnExit() {
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
     wxMainMutex.Unlock();
     wxThreadGuiExit();
   }
 
-wxTabCtrl::wxTabCtrl(void)
-bool wxTabCtrl::Create(wxWindow *parent, const wxWindowID id, const wxPoint& pos, const wxSize& size,
-            const long style, const wxString& name)
+bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
+            long style, const wxString& name)
-wxTabCtrl::~wxTabCtrl(void)
-bool wxTabCtrl::DeleteAllItems(void)
+bool wxTabCtrl::DeleteAllItems()
 {
     return ( TabCtrl_DeleteAllItems( (HWND) GetHWND() ) != FALSE );
 }
 
 // Delete an item
 {
     return ( TabCtrl_DeleteAllItems( (HWND) GetHWND() ) != FALSE );
 }
 
 // Delete an item
-bool wxTabCtrl::DeleteItem(const int item)
+bool wxTabCtrl::DeleteItem(int item)
 {
     return ( TabCtrl_DeleteItem( (HWND) GetHWND(), item) != FALSE );
 }
 
 // Get the selection
 {
     return ( TabCtrl_DeleteItem( (HWND) GetHWND(), item) != FALSE );
 }
 
 // Get the selection
-int wxTabCtrl::GetSelection(void) const
+int wxTabCtrl::GetSelection() const
 {
     return (int) TabCtrl_GetCurSel( (HWND) GetHWND() );
 }
 
 // Get the associated image list
 {
     return (int) TabCtrl_GetCurSel( (HWND) GetHWND() );
 }
 
 // Get the associated image list
-wxImageList* wxTabCtrl::GetImageList(void) const
+wxImageList* wxTabCtrl::GetImageList() const
 {
     return m_imageList;
 }
 
 // Get the number of items
 {
     return m_imageList;
 }
 
 // Get the number of items
-int wxTabCtrl::GetItemCount(void) const
+int wxTabCtrl::GetItemCount() const
 {
     return (int) TabCtrl_GetItemCount( (HWND) GetHWND() );
 }
 
 // Get the rect corresponding to the tab
 {
     return (int) TabCtrl_GetItemCount( (HWND) GetHWND() );
 }
 
 // Get the rect corresponding to the tab
-bool wxTabCtrl::GetItemRect(const int item, wxRect& wxrect) const
+bool wxTabCtrl::GetItemRect(int item, wxRect& wxrect) const
 {
     RECT rect;
     if ( !TabCtrl_GetItemRect( (HWND) GetHWND(), item, & rect) )
 {
     RECT rect;
     if ( !TabCtrl_GetItemRect( (HWND) GetHWND(), item, & rect) )
 }
 
 // Get the number of rows
 }
 
 // Get the number of rows
-int wxTabCtrl::GetRowCount(void) const
+int wxTabCtrl::GetRowCount() const
 {
     return (int) TabCtrl_GetRowCount( (HWND) GetHWND() );
 }
 
 // Get the item text
 {
     return (int) TabCtrl_GetRowCount( (HWND) GetHWND() );
 }
 
 // Get the item text
-wxString wxTabCtrl::GetItemText(const int item) const
+wxString wxTabCtrl::GetItemText(int item) const
 {
     char buf[256];
     wxString str("");
 {
     char buf[256];
     wxString str("");
-int wxTabCtrl::GetItemImage(const int item) const
+int wxTabCtrl::GetItemImage(int item) const
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_IMAGE;
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_IMAGE;
-void* wxTabCtrl::GetItemData(const int item) const
+void* wxTabCtrl::GetItemData(int item) const
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_PARAM;
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_PARAM;
-int wxTabCtrl::InsertItem(const int item, const wxString& text, const int imageId, void* data)
+bool wxTabCtrl::InsertItem(int item, const wxString& text, int imageId, void* data)
 {
     char buf[256];
     TC_ITEM tcItem;
 {
     char buf[256];
     TC_ITEM tcItem;
         tcItem.iImage = imageId;
     }
 
         tcItem.iImage = imageId;
     }
 
-    return (int) TabCtrl_InsertItem( (HWND) GetHWND(), item, & tcItem);
+    return (TabCtrl_InsertItem( (HWND) GetHWND(), item, & tcItem) != -1);
-int wxTabCtrl::SetSelection(const int item)
+int wxTabCtrl::SetSelection(int item)
 {
     return (int) TabCtrl_SetCurSel( (HWND) GetHWND(), item );
 }
 {
     return (int) TabCtrl_SetCurSel( (HWND) GetHWND(), item );
 }
 }
 
 // Set the text for an item
 }
 
 // Set the text for an item
-bool wxTabCtrl::SetItemText(const int item, const wxString& text)
+bool wxTabCtrl::SetItemText(int item, const wxString& text)
 {
     char buf[256];
     TC_ITEM tcItem;
 {
     char buf[256];
     TC_ITEM tcItem;
 }
 
 // Set the image for an item
 }
 
 // Set the image for an item
-bool wxTabCtrl::SetItemImage(const int item, const int image)
+bool wxTabCtrl::SetItemImage(int item, int image)
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_IMAGE;
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_IMAGE;
 }
 
 // Set the data for an item
 }
 
 // Set the data for an item
-bool wxTabCtrl::SetItemData(const int item, void* data)
+bool wxTabCtrl::SetItemData(int item, void* data)
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_PARAM;
 {
     TC_ITEM tcItem;
     tcItem.mask = TCIF_PARAM;
 
 {
   p_internal = new wxMutexInternal;
   p_internal->p_mutex = CreateMutex(NULL, FALSE, NULL);
   m_locked = 0;
 }
 
 {
   p_internal = new wxMutexInternal;
   p_internal->p_mutex = CreateMutex(NULL, FALSE, NULL);
   m_locked = 0;
 }
 
 {
   CloseHandle(p_internal->p_mutex);
 }
 
 {
   CloseHandle(p_internal->p_mutex);
 }
 
-wxMutexError wxMutex::Lock(void)
+wxMutexError wxMutex::Lock()
-wxMutexError wxMutex::TryLock(void)
+wxMutexError wxMutex::TryLock()
-wxMutexError wxMutex::Unlock(void)
+wxMutexError wxMutex::Unlock()
-wxCondition::wxCondition(void)
+wxCondition::wxCondition()
 {
   p_internal = new wxConditionInternal;
   p_internal->event = CreateEvent(NULL, FALSE, FALSE, NULL);
   p_internal->waiters = 0;
 }
 
 {
   p_internal = new wxConditionInternal;
   p_internal->event = CreateEvent(NULL, FALSE, FALSE, NULL);
   p_internal->waiters = 0;
 }
 
-wxCondition::~wxCondition(void)
+wxCondition::~wxCondition()
 {
   CloseHandle(p_internal->event);
 }
 {
   CloseHandle(p_internal->event);
 }
   return (ret != WAIT_TIMEOUT);
 }
 
   return (ret != WAIT_TIMEOUT);
 }
 
-void wxCondition::Signal(void)
+void wxCondition::Signal()
 {
   SetEvent(p_internal->event);
 }
 
 {
   SetEvent(p_internal->event);
 }
 
-void wxCondition::Broadcast(void)
+void wxCondition::Broadcast()
-wxThreadError wxThread::Create(void)
+wxThreadError wxThread::Create()
 {
   int win_prio, prio = p_internal->prio;
 
 {
   int win_prio, prio = p_internal->prio;
 
   p_internal->prio = prio;
 }
 
   p_internal->prio = prio;
 }
 
-int wxThread::GetPriority(void)
+int wxThread::GetPriority()
 {
   return p_internal->prio;
 }
 {
   return p_internal->prio;
 }
   return (void *)exit_code;
 }
 
   return (void *)exit_code;
 }
 
-unsigned long wxThread::GetID()
+unsigned long wxThread::GetID() const
 {
   return (unsigned long)p_internal->tid;
 }
 
 {
   return (unsigned long)p_internal->tid;
 }
 
+bool wxThread::IsMain() const
 {
   return (GetCurrentThread() == p_mainid);
 }
 {
   return (GetCurrentThread() == p_mainid);
 }
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
 class wxThreadModule : public wxModule {
   DECLARE_DYNAMIC_CLASS(wxThreadModule)
 public:
-  virtual bool OnInit(void) {
+  virtual bool OnInit() {
     p_mainid = GetCurrentThread();
     wxMainMutex.Lock();
     return TRUE;
   }
 
   // Global cleanup
     p_mainid = GetCurrentThread();
     wxMainMutex.Lock();
     return TRUE;
   }
 
   // Global cleanup
-  virtual void OnExit(void) {
+  virtual void OnExit() {
     wxMainMutex.Unlock();
   }
 };
     wxMainMutex.Unlock();
   }
 };
 
 #endif
 
 #ifndef WX_PRECOMP
 #endif
 
 #ifndef WX_PRECOMP
-#include <wx/file.h>
-#include <wx/msw/wave.h>
-#include <wx/msw/private.h>
+#include "wx/file.h"
+#include "wx/msw/wave.h"
+#include "wx/msw/private.h"
 
 #include <windows.h>
 #include <windowsx.h>
 
 #include <windows.h>
 #include <windowsx.h>
 #endif
 
 #ifdef __GNUWIN32__
 #endif
 
 #ifdef __GNUWIN32__
-#include <wx/msw/gnuwin32/extra.h>
+#include "wx/msw/gnuwin32/extra.h"
   : m_waveLength(0), m_isResource(FALSE), m_waveData(NULL)
 {
 }
   : m_waveLength(0), m_isResource(FALSE), m_waveData(NULL)
 {
 }
-bool
-wxWave::Free(void)