wxMenu( const wxString& title = wxEmptyString, const wxFunction func = NULL );
// operations
+ // title
+ void SetTitle(const wxString& label);
+ const wxString GetTitle() const;
// menu creation
void AppendSeparator();
void Append(int id, const wxString &item,
wxMenu( const wxString& title = wxEmptyString, const wxFunction func = NULL );
// operations
+ // title
+ void SetTitle(const wxString& label);
+ const wxString GetTitle() const;
// menu creation
void AppendSeparator();
void Append(int id, const wxString &item,
DECLARE_DYNAMIC_CLASS(wxIndividualLayoutConstraint)
protected:
+ // To be allowed to modify the internal variables
+ friend class wxIndividualLayoutConstraint_Serialize;
+
// 'This' window is the parent or sibling of otherWin
wxWindow *otherWin;
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
-#ifndef _WX_THREADH__
-#define _WX_THREADH__
+#ifndef __THREADH__
+#define __THREADH__
#ifdef __GNUG__
#pragma interface "thread.h"
THREAD_NO_ERROR=0, // No error
THREAD_NO_RESOURCE, // No resource left to create a new thread
THREAD_RUNNING, // The thread is already running
- THREAD_NOT_RUNNING // The thread isn't running
+ THREAD_NOT_RUNNING, // The thread isn't running
+ THREAD_MISC_ERROR // Some other error
} wxThreadError;
// defines the interval of priority.
// ---------------------------------------------------------------------------
// Mutex handler
-class wxMutexInternal;
+class WXDLLEXPORT wxMutexInternal;
class WXDLLEXPORT wxMutex {
public:
// constructor & destructor
// Destroys the thread immediately if the defer flag isn't true.
wxThreadError Destroy();
+ // Pause a running thread
+ wxThreadError Pause();
+
+ // Resume a paused thread
+ wxThreadError Resume();
+
// Switches on the defer flag.
void DeferDestroy(bool on);
// Returns true if the thread is alive.
bool IsAlive() const;
+ // Returns true if the thread is running (not paused, not killed).
+ bool IsRunning() const;
// Returns true if the thread is the main thread (aka the GUI thread).
static bool IsMain();
// Called when thread exits.
virtual void OnExit();
+
+ // Returns the wxThread object which corresponds to the ID.
+ static wxThread *GetThreadFromID(unsigned long id);
protected:
// In case, the DIFFER flag is true, enables another thread to kill this one.
void TestDestroy();
}
}
+void wxMenu::SetTitle( const wxString& title )
+{
+ // Waiting for something better.
+ m_title = title;
+}
+
+const wxString wxMenu::GetTitle() const
+{
+ return m_title;
+}
+
void wxMenu::AppendSeparator()
{
wxMenuItem *mitem = new wxMenuItem();
wxThreadError wxThread::Destroy()
{
- return THREAD_RUNNING;
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NOT_RUNNING;
}
void wxThread::DeferDestroy( bool WXUNUSED(on) )
return TRUE;
}
+bool wxThread::IsRunning() const
+{
+ return FALSE;
+}
+
bool wxThread::IsAlive() const
{
return FALSE;
enum thread_state {
STATE_IDLE = 0,
STATE_RUNNING,
+ STATE_PAUSING,
+ STATE_PAUSED,
STATE_CANCELED,
STATE_EXITED
};
/////////////////////////////////////////////////////////////////////////////
static pthread_t p_mainid;
+static wxMutex p_list_mutex;
+static wxList p_threads_list;
+
wxMutex wxMainMutex; // controls access to all GUI functions
/////////////////////////////////////////////////////////////////////////////
pthread_t thread_id;
int state;
int prio;
+ int defer_destroy;
+ int id;
};
void *wxThreadInternal::PthreadStart(void *ptr)
{
wxThread *thread = (wxThread *)ptr;
+ // Add the current thread to the list
+ p_list_mutex.Lock();
+ thread->p_internal->id = p_threads_list.Number();
+ p_threads_list.Append((wxObject *)thread);
+ p_list_mutex.Unlock();
+
+ // Call the main entry
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
void* status = thread->Entry();
+
+ // Delete the current thread from the list
+ p_list_mutex.Lock();
+ delete node_thread;
+ p_list_mutex.Unlock();
+
thread->Exit(status);
return NULL;
return THREAD_NO_RESOURCE;
}
pthread_attr_destroy(&a);
+
return THREAD_NO_ERROR;
}
if (res == 0)
p_internal->state = STATE_CANCELED;
}
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ if (p_internal->state != STATE_RUNNING)
+ return THREAD_NOT_RUNNING;
+
+ if (!p_internal->defer_destroy)
+ return THREAD_MISC_ERROR;
+
+ p_internal->state = STATE_PAUSING;
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ if (p_internal->state == STATE_PAUSING || p_internal->state == STATE_PAUSED)
+ p_internal->state = STATE_RUNNING;
+
return THREAD_NO_ERROR;
}
pthread_join(p_internal->thread_id, &status);
if (do_unlock)
wxMainMutex.Lock();
+
+ p_list_mutex.Lock();
+ delete p_threads_list.Nth(p_internal->id);
+ p_list_mutex.Unlock();
+
p_internal->state = STATE_IDLE;
}
return status;
unsigned long wxThread::GetID() const
{
- return (unsigned long)p_internal->thread_id;
+ return p_internal->id;
+}
+
+wxThread *wxThread::GetThreadFromID(unsigned long id)
+{
+ wxNode *node = p_threads_list.Nth(id);
+
+ if (!node)
+ return NULL;
+ return (wxThread *)node->Data();
}
void wxThread::Exit(void *status)
void wxThread::TestDestroy()
{
+ if (p_internal->state == STATE_PAUSING) {
+ p_internal->state = STATE_PAUSED;
+ while (p_internal->state == STATE_PAUSED) {
+ pthread_testcancel();
+ usleep(1);
+ }
+ }
pthread_testcancel();
}
return (bool)pthread_equal(pthread_self(), p_mainid);
}
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING) ||
+ (p_internal->state == STATE_PAUSING) ||
+ (p_internal->state == STATE_PAUSED);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadInternal();
// The default callback just joins the thread and throws away the result.
void wxThread::OnExit()
{
+ Join();
}
// Automatic initialization
virtual bool OnInit() {
wxThreadGuiInit();
p_mainid = pthread_self();
+ p_threads_list = wxList(wxKEY_INTEGER);
wxMainMutex.Lock();
return TRUE;
return THREAD_NO_ERROR;
}
-void wxThread::Destroy()
+wxThreadError wxThread::Destroy()
{
if (p_internal->state == STATE_RUNNING)
p_internal->state = STATE_CANCELED;
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NO_ERROR;
}
void *wxThread::Join()
return 0;
}
-bool wxThreadIsMain()
+bool wxThread::IsMain()
{
return (int)getpid() == main_id;
}
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadPrivate();
}
}
+void wxMenu::SetTitle( const wxString& title )
+{
+ // Waiting for something better.
+ m_title = title;
+}
+
+const wxString wxMenu::GetTitle() const
+{
+ return m_title;
+}
+
void wxMenu::AppendSeparator()
{
wxMenuItem *mitem = new wxMenuItem();
wxThreadError wxThread::Destroy()
{
- return THREAD_RUNNING;
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NOT_RUNNING;
}
void wxThread::DeferDestroy( bool WXUNUSED(on) )
return TRUE;
}
+bool wxThread::IsRunning() const
+{
+ return FALSE;
+}
+
bool wxThread::IsAlive() const
{
return FALSE;
enum thread_state {
STATE_IDLE = 0,
STATE_RUNNING,
+ STATE_PAUSING,
+ STATE_PAUSED,
STATE_CANCELED,
STATE_EXITED
};
/////////////////////////////////////////////////////////////////////////////
static pthread_t p_mainid;
+static wxMutex p_list_mutex;
+static wxList p_threads_list;
+
wxMutex wxMainMutex; // controls access to all GUI functions
/////////////////////////////////////////////////////////////////////////////
pthread_t thread_id;
int state;
int prio;
+ int defer_destroy;
+ int id;
};
void *wxThreadInternal::PthreadStart(void *ptr)
{
wxThread *thread = (wxThread *)ptr;
+ // Add the current thread to the list
+ p_list_mutex.Lock();
+ thread->p_internal->id = p_threads_list.Number();
+ p_threads_list.Append((wxObject *)thread);
+ p_list_mutex.Unlock();
+
+ // Call the main entry
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
void* status = thread->Entry();
+
+ // Delete the current thread from the list
+ p_list_mutex.Lock();
+ delete node_thread;
+ p_list_mutex.Unlock();
+
thread->Exit(status);
return NULL;
return THREAD_NO_RESOURCE;
}
pthread_attr_destroy(&a);
+
return THREAD_NO_ERROR;
}
if (res == 0)
p_internal->state = STATE_CANCELED;
}
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ if (p_internal->state != STATE_RUNNING)
+ return THREAD_NOT_RUNNING;
+
+ if (!p_internal->defer_destroy)
+ return THREAD_MISC_ERROR;
+
+ p_internal->state = STATE_PAUSING;
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ if (p_internal->state == STATE_PAUSING || p_internal->state == STATE_PAUSED)
+ p_internal->state = STATE_RUNNING;
+
return THREAD_NO_ERROR;
}
pthread_join(p_internal->thread_id, &status);
if (do_unlock)
wxMainMutex.Lock();
+
+ p_list_mutex.Lock();
+ delete p_threads_list.Nth(p_internal->id);
+ p_list_mutex.Unlock();
+
p_internal->state = STATE_IDLE;
}
return status;
unsigned long wxThread::GetID() const
{
- return (unsigned long)p_internal->thread_id;
+ return p_internal->id;
+}
+
+wxThread *wxThread::GetThreadFromID(unsigned long id)
+{
+ wxNode *node = p_threads_list.Nth(id);
+
+ if (!node)
+ return NULL;
+ return (wxThread *)node->Data();
}
void wxThread::Exit(void *status)
void wxThread::TestDestroy()
{
+ if (p_internal->state == STATE_PAUSING) {
+ p_internal->state = STATE_PAUSED;
+ while (p_internal->state == STATE_PAUSED) {
+ pthread_testcancel();
+ usleep(1);
+ }
+ }
pthread_testcancel();
}
return (bool)pthread_equal(pthread_self(), p_mainid);
}
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING) ||
+ (p_internal->state == STATE_PAUSING) ||
+ (p_internal->state == STATE_PAUSED);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadInternal();
// The default callback just joins the thread and throws away the result.
void wxThread::OnExit()
{
+ Join();
}
// Automatic initialization
virtual bool OnInit() {
wxThreadGuiInit();
p_mainid = pthread_self();
+ p_threads_list = wxList(wxKEY_INTEGER);
wxMainMutex.Lock();
return TRUE;
return THREAD_NO_ERROR;
}
-void wxThread::Destroy()
+wxThreadError wxThread::Destroy()
{
if (p_internal->state == STATE_RUNNING)
p_internal->state = STATE_CANCELED;
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NO_ERROR;
}
void *wxThread::Join()
return 0;
}
-bool wxThreadIsMain()
+bool wxThread::IsMain()
{
return (int)getpid() == main_id;
}
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadPrivate();
wxThreadError wxThread::Destroy()
{
- return THREAD_RUNNING;
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NOT_RUNNING;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NOT_RUNNING;
}
void wxThread::DeferDestroy( bool WXUNUSED(on) )
return 0;
}
+wxThread *wxThread::GetThreadFromID(unsigned long WXUNUSED(id)) const
+{
+ return NULL;
+}
+
bool wxThread::IsMain()
{
return TRUE;
}
+bool wxThread::IsRunning() const
+{
+ return FALSE;
+}
+
bool wxThread::IsAlive() const
{
return FALSE;
enum thread_state {
STATE_IDLE = 0,
STATE_RUNNING,
+ STATE_PAUSING,
+ STATE_PAUSED,
STATE_CANCELED,
STATE_EXITED
};
/////////////////////////////////////////////////////////////////////////////
static pthread_t p_mainid;
+static wxMutex p_list_mutex;
+static wxList p_threads_list;
+
wxMutex wxMainMutex; // controls access to all GUI functions
/////////////////////////////////////////////////////////////////////////////
pthread_t thread_id;
int state;
int prio;
+ int defer_destroy;
+ int id;
};
void *wxThreadInternal::PthreadStart(void *ptr)
{
wxThread *thread = (wxThread *)ptr;
+ // Add the current thread to the list
+ p_list_mutex.Lock();
+ thread->p_internal->id = p_threads_list.Number();
+ p_threads_list.Append((wxObject *)thread);
+ p_list_mutex.Unlock();
+
+ // Call the main entry
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
void* status = thread->Entry();
+
+ // Delete the current thread from the list
+ p_list_mutex.Lock();
+ delete node_thread;
+ p_list_mutex.Unlock();
+
thread->Exit(status);
return NULL;
return THREAD_NO_RESOURCE;
}
pthread_attr_destroy(&a);
+
return THREAD_NO_ERROR;
}
if (res == 0)
p_internal->state = STATE_CANCELED;
}
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ if (p_internal->state != STATE_RUNNING)
+ return THREAD_NOT_RUNNING;
+
+ if (!p_internal->defer_destroy)
+ return THREAD_MISC_ERROR;
+
+ p_internal->state = STATE_PAUSING;
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ if (p_internal->state == STATE_PAUSING || p_internal->state == STATE_PAUSED)
+ p_internal->state = STATE_RUNNING;
+
return THREAD_NO_ERROR;
}
pthread_join(p_internal->thread_id, &status);
if (do_unlock)
wxMainMutex.Lock();
+
+ p_list_mutex.Lock();
+ delete p_threads_list.Nth(p_internal->id);
+ p_list_mutex.Unlock();
+
p_internal->state = STATE_IDLE;
}
return status;
unsigned long wxThread::GetID() const
{
- return (unsigned long)p_internal->thread_id;
+ return p_internal->id;
+}
+
+wxThread *wxThread::GetThreadFromID(unsigned long id)
+{
+ wxNode *node = p_threads_list.Nth(id);
+
+ if (!node)
+ return NULL;
+ return (wxThread *)node->Data();
}
void wxThread::Exit(void *status)
void wxThread::TestDestroy()
{
+ if (p_internal->state == STATE_PAUSING) {
+ p_internal->state = STATE_PAUSED;
+ while (p_internal->state == STATE_PAUSED) {
+ pthread_testcancel();
+ usleep(1);
+ }
+ }
pthread_testcancel();
}
return (bool)pthread_equal(pthread_self(), p_mainid);
}
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING) ||
+ (p_internal->state == STATE_PAUSING) ||
+ (p_internal->state == STATE_PAUSED);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadInternal();
// The default callback just joins the thread and throws away the result.
void wxThread::OnExit()
{
+ Join();
}
// Automatic initialization
virtual bool OnInit() {
wxThreadGuiInit();
p_mainid = pthread_self();
+ p_threads_list = wxList(wxKEY_INTEGER);
wxMainMutex.Lock();
return TRUE;
return THREAD_NO_ERROR;
}
-void wxThread::Destroy()
+wxThreadError wxThread::Destroy()
{
if (p_internal->state == STATE_RUNNING)
p_internal->state = STATE_CANCELED;
+
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Pause()
+{
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ return THREAD_NO_ERROR;
}
void *wxThread::Join()
return 0;
}
-bool wxThreadIsMain()
+bool wxThread::IsMain()
{
return (int)getpid() == main_id;
}
+bool wxThread::IsAlive() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
+bool wxThread::IsRunning() const
+{
+ return (p_internal->state == STATE_RUNNING);
+}
+
wxThread::wxThread()
{
p_internal = new wxThreadPrivate();
return THREAD_NO_ERROR;
}
+wxThreadError wxThread::Pause()
+{
+ // TODO
+ return THREAD_NO_ERROR;
+}
+
+wxThreadError wxThread::Resume()
+{
+ // TODO
+ return THREAD_NO_ERROR;
+}
+
void wxThread::Exit(void *status)
{
// TODO
return 0;
}
+wxThread *wxThread::GetThreadFromID(unsigned long id)
+{
+ // TODO
+ return NULL;
+}
+
+bool wxThread::IsAlive() const
+{
+ // TODO
+ return FALSE;
+}
+
+bool wxThread::IsRunning() const
+{
+ // TODO
+ return FALSE;
+}
+
bool wxThread::IsMain()
{
// TODO
#include <wx/radiobox.h>
#include <wx/stattext.h>
#include <wx/combobox.h>
+#include <wx/imaglist.h>
#include <wx/objstrm.h>
#include <wx/datstrm.h>
#include <wx/serbase.h>
printf("label = %s\n", WXSTRINGCAST m_label);
button->Create(m_parent, m_id, m_label, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- m_style, m_name);
+ m_style, *m_validator, m_name);
}
void WXSERIAL(wxCheckBox)::StoreObject(wxObjectOutputStream& s)
wxCheckBox *chkbox = (wxCheckBox *)Object();
chkbox->Create(m_parent, m_id, m_label, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- m_style, m_name);
+ m_style, *m_validator, m_name);
chkbox->SetValue(data_s.Read8());
}
value = data_s.Read32();
slider->Create(m_parent, m_id, value, min, max, wxPoint(m_x, m_y),
- wxSize(m_w, m_h), m_style, m_name);
+ wxSize(m_w, m_h), m_style, *m_validator, m_name);
slider->SetTickFreq( 0, data_s.Read32() );
slider->SetPageSize( data_s.Read32() );
range = data_s.Read32();
gauge->Create(m_parent, m_id, range, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- m_style, m_name);
+ m_style, *m_validator, m_name);
gauge->SetShadowWidth( data_s.Read8() );
gauge->SetBezelFace( data_s.Read8() );
int i,num = data_s.Read32();
choice->Create(m_parent, m_id, wxPoint(m_x, m_y), wxSize(m_w, m_h), 0, NULL,
- m_style, m_name);
+ m_style, *m_validator, m_name);
for (i=0;i<num;i++)
choice->Append( data_s.ReadString() );
void WXSERIAL(wxNotebook)::StoreObject(wxObjectOutputStream& s)
{
wxNotebook *notebook = (wxNotebook *)Object();
+ wxImageList *imaglist = notebook->GetImageList();
int i, pcount = notebook->GetPageCount();
- WXSERIAL(wxControl)::StoreObject(s);
-
if (s.FirstStage()) {
- // Don't know how to retrieve images from wxImageList (copy to a DC ?)
+ s.AddChild(imaglist);
+ WXSERIAL(wxControl)::StoreObject(s);
return;
}
wxDataOutputStream data_s(s);
data_s.Write8( pcount );
+ WXSERIAL(wxControl)::StoreObject(s);
+
for (i=0;i<pcount;i++)
data_s.WriteString( notebook->GetPageText(i) );
+
}
void WXSERIAL(wxNotebook)::LoadObject(wxObjectInputStream& s)
{
wxNotebook *notebook = (wxNotebook *)Object();
int i, pcount;
+ wxImageList *imaglist;
+
+ imaglist = (wxImageList *)s.GetChild(0);
+ s.RemoveChildren(1);
WXSERIAL(wxControl)::LoadObject(s);
items[i] = data_s.ReadString();
box->Create(m_parent, m_id, m_title, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- n_items, items, 0, m_style, m_name);
+ n_items, items, 0, m_style, *m_validator, m_name);
}
void WXSERIAL(wxComboBox)::StoreObject(wxObjectOutputStream& s)
int i, num, selection;
box->Create(m_parent, m_id, wxEmptyString, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- 0, NULL, m_style, m_name);
+ 0, NULL, m_style, *m_validator, m_name);
num = data_s.Read8();
selection = data_s.Read8();
#include <wx/pen.h>
#include <wx/brush.h>
#include <wx/serbase.h>
+#include <wx/imaglist.h>
#include "sergdi.h"
IMPLEMENT_SERIAL_CLASS(wxBitmap, wxObject)
IMPLEMENT_SERIAL_CLASS(wxFont, wxGDIObject)
IMPLEMENT_SERIAL_CLASS(wxPen, wxGDIObject)
IMPLEMENT_SERIAL_CLASS(wxBrush, wxGDIObject)
+IMPLEMENT_SERIAL_CLASS(wxImageList, wxObject)
IMPLEMENT_ALIAS_SERIAL_CLASS(wxPenList, wxList)
IMPLEMENT_ALIAS_SERIAL_CLASS(wxBrushList, wxList)
*font = wxFont(psize, face_name, family, style, weight, underlined);
}
+
+void WXSERIAL(wxImageList)::StoreObject(wxObjectOutputStream& s)
+{
+ wxImageList *list = (wxImageList *)Object();
+ int i;
+
+ if (s.FirstStage()) {
+ for (i=0;i<list->GetImageCount();i++)
+ s.AddChild(list->GetBitmap(i));
+ }
+
+ wxDataOutputStream data_s(s);
+
+ data_s.Write32(list->GetImageCount());
+}
+
+void WXSERIAL(wxImageList)::LoadObject(wxObjectInputStream& s)
+{
+ int i, count;
+ wxImageList *list = (wxImageList *)Object();
+ wxDataInputStream data_s(s);
+
+ count = data_s.Read32();
+ for (i=0;i<count;i++)
+ list->Add(*((wxBitmap *)s.GetChild(i)));
+}
DECLARE_SERIAL_CLASS(wxFont, wxGDIObject)
DECLARE_SERIAL_CLASS(wxPen, wxGDIObject)
DECLARE_SERIAL_CLASS(wxBrush, wxGDIObject)
+DECLARE_SERIAL_CLASS(wxImageList, wxObject)
//DECLARE_SERIAL_CLASS(wxSize, wxObject)
//DECLARE_SERIAL_CLASS(wxRealPoint, wxObject)
#include <wx/frame.h>
#include <wx/panel.h>
#include <wx/menu.h>
+#include <wx/dialog.h>
#include <wx/serbase.h>
+#include <wx/statusbr.h>
+#include <wx/mdi.h>
#include "serwnd.h"
+
IMPLEMENT_SERIAL_CLASS(wxWindow, wxObject)
IMPLEMENT_SERIAL_CLASS(wxIndividualLayoutConstraint, wxObject)
IMPLEMENT_SERIAL_CLASS(wxLayoutConstraints, wxObject)
+IMPLEMENT_ALIAS_SERIAL_CLASS(wxValidator, wxObject)
IMPLEMENT_SERIAL_CLASS(wxFrame, wxWindow)
IMPLEMENT_SERIAL_CLASS(wxPanel, wxWindow)
-//IMPLEMENT_SERIAL_CLASS(wxDialog, wxWindow)
+IMPLEMENT_SERIAL_CLASS(wxDialog, wxWindow)
IMPLEMENT_SERIAL_CLASS(wxMenuBar, wxWindow)
IMPLEMENT_SERIAL_CLASS(wxMenuItem, wxObject)
IMPLEMENT_SERIAL_CLASS(wxMenu, wxObject)
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxWindow)::StoreObject(wxObjectOutputStream& s)
{
wxWindow *win_object = (wxWindow *)Object();
if (s.FirstStage()) {
s.AddChild(win_object->GetConstraints());
-// s.AddChild(&(win_object->GetDefaultBackgroundColour()));
-// s.AddChild(&(win_object->GetDefaultForegroundColour()));
+ s.AddChild(win_object->GetValidator());
+
+ // BAD HACK, but I don't have access to the internal variable of wxWindow.
+ m_bg_colour = win_object->GetDefaultBackgroundColour();
+ m_fg_colour = win_object->GetDefaultForegroundColour();
+ s.AddChild(&m_bg_colour);
+ s.AddChild(&m_fg_colour);
s.AddChild(win_object->GetFont());
while (node) {
s.AddChild(node->Data());
/* I assume we will never create raw wxWindow object */
- // This will be done by wxLayoutConstraints, as we need an initialized object.
-// win_object->SetConstraints((wxLayoutConstraints *)s.GetChild(0));
-// win_object->SetDefaultBackgroundColour(*((wxColour *)s.GetChild(1)));
-// win_object->SetDefaultForegroundColour(*((wxColour *)s.GetChild(2)));
- win_object->SetFont(*((wxFont *)s.GetChild(1)));
+ m_validator = (wxValidator *)s.GetChild(1);
+ win_object->SetDefaultBackgroundColour(*((wxColour *)s.GetChild(2)));
+ win_object->SetDefaultForegroundColour(*((wxColour *)s.GetChild(3)));
+ win_object->SetFont(*((wxFont *)s.GetChild(4)));
return;
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxIndividualLayoutConstraint)::StoreObject
(wxObjectOutputStream& s)
{
lay_object->otherEdge = (wxEdge)data_s.Read8();
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxLayoutConstraints)::StoreObject(wxObjectOutputStream& s)
{
wxLayoutConstraints *lay_object = (wxLayoutConstraints *)Object();
((wxWindow *)s.GetParent())->SetConstraints(lay_object);
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxFrame)::StoreObject(wxObjectOutputStream& s)
{
wxFrame *frame = (wxFrame *)Object();
wxDataInputStream data_s(s);
frame->SetMenuBar(mbar);
- frame->Create(m_parent, m_id, m_title, wxPoint(m_x, m_y), wxSize(m_w, m_h),
- m_style, m_name);
+ if (frame->GetClassInfo() == CLASSINFO(wxFrame))
+ frame->Create(m_parent, m_id, m_title, wxPoint(m_x, m_y),
+ wxSize(m_w, m_h), m_style, m_name);
frame->CreateStatusBar(data_s.Read8());
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxMenuBar)::StoreObject(wxObjectOutputStream& s)
{
wxMenuBar *mbar = (wxMenuBar *)Object();
// WXSERIAL(wxWindow)::LoadObject(s);
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxMenu)::StoreObject(wxObjectOutputStream& s)
{
wxMenu *menu = (wxMenu *)Object();
}
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxMenuItem)::StoreObject(wxObjectOutputStream& s)
{
wxMenuItem *item = (wxMenuItem *)Object();
item->SetSubMenu( (wxMenu *)s.GetChild(0) );
}
+/////////////////////////////////////////////////////////////////////////////
+
void WXSERIAL(wxPanel)::StoreObject(wxObjectOutputStream& s)
{
WXSERIAL(wxWindow)::StoreObject(s);
((wxPanel *)Object())->Create(m_parent, m_id, wxPoint(m_x, m_y),
wxSize(m_w, m_h), m_style, m_name);
}
+
+/////////////////////////////////////////////////////////////////////////////
+
+void WXSERIAL(wxDialog)::StoreObject(wxObjectOutputStream& s)
+{
+ WXSERIAL(wxWindow)::StoreObject(s);
+}
+
+void WXSERIAL(wxDialog)::LoadObject(wxObjectInputStream& s)
+{
+ WXSERIAL(wxWindow)::LoadObject(s);
+
+ ((wxDialog *)Object())->Create(m_parent, m_id, m_title, wxPoint(m_x, m_y),
+ wxSize(m_w, m_h), m_style, m_name);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+void WXSERIAL(wxMDIParentFrame)::StoreObject(wxObjectOutputStream& s)
+{
+ wxMDIParentFrame *frame = (wxMDIParentFrame *)Object();
+
+ if (s.FirstStage()) {
+ s.AddChild(frame->GetClientWindow());
+ WXSERIAL(wxMDIParentFrame)::StoreObject(s);
+ return;
+ }
+
+ WXSERIAL(wxMDIParentFrame)::StoreObject(s);
+}
+
+void WXSERIAL(wxMDIParentFrame)::LoadObject(wxObjectInputStream& s)
+{
+ wxMDIParentFrame *frame = (wxMDIParentFrame *)Object();
+ wxMDIClientWindow *client;
+
+ client = (wxMDIClientWindow *) s.GetChild(0);
+ s.RemoveChildren(1);
+
+ frame->Create(m_parent, m_id, m_title, wxPoint(m_x, m_y),
+ wxSize(m_w, m_h), m_style, m_name);
+// client->CreateClient(this, style_client);
+
+ WXSERIAL(wxFrame)::LoadObject(s);
+}
wxWindowID m_id;
wxString m_name, m_title, m_label;
wxWindow *m_parent;
+ wxValidator *m_validator;
+ wxColour m_bg_colour, m_fg_colour;
long m_style;
};
DECLARE_SERIAL_CLASS(wxIndividualLayoutConstraint, wxObject)
DECLARE_SERIAL_CLASS(wxLayoutConstraints, wxObject)
+DECLARE_ALIAS_SERIAL_CLASS(wxValidator, wxObject)
DECLARE_SERIAL_CLASS(wxFrame, wxWindow)
DECLARE_SERIAL_CLASS(wxPanel, wxWindow)
-//DECLARE_SERIAL_CLASS(wxDialog, wxWindow)
+DECLARE_SERIAL_CLASS(wxDialog, wxWindow)
DECLARE_SERIAL_CLASS(wxMenuBar, wxWindow)
DECLARE_SERIAL_CLASS(wxMenuItem, wxObject)
DECLARE_SERIAL_CLASS(wxMenu, wxObject)
+DECLARE_SERIAL_CLASS(wxMDIParentFrame, wxFrame)
#endif
projects / wxWidgets.git / commitdiff
