From 93cf77c076b699e8e0b3b0049bd4f80de15997dd Mon Sep 17 00:00:00 2001 From: Julian Smart Date: Sun, 9 Aug 1998 16:27:07 +0000 Subject: [PATCH] Added stubs .cpp files. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@487 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- src/stubs/accel.cpp | 92 +++ src/stubs/app.cpp | 395 +++++++++++++ src/stubs/bitmap.cpp | 430 ++++++++++++++ src/stubs/bmpbuttn.cpp | 65 ++ src/stubs/brush.cpp | 162 +++++ src/stubs/button.cpp | 75 +++ src/stubs/checkbox.cpp | 117 ++++ src/stubs/checklst.cpp | 77 +++ src/stubs/choice.cpp | 119 ++++ src/stubs/clipbrd.cpp | 237 ++++++++ src/stubs/colordlg.cpp | 52 ++ src/stubs/colour.cpp | 126 ++++ src/stubs/combobox.cpp | 116 ++++ src/stubs/control.cpp | 111 ++++ src/stubs/cursor.cpp | 186 ++++++ src/stubs/data.cpp | 145 +++++ src/stubs/dc.cpp | 392 ++++++++++++ src/stubs/dcclient.cpp | 620 +++++++++++++++++++ src/stubs/dcmemory.cpp | 68 +++ src/stubs/dcscreen.cpp | 32 + src/stubs/dialog.cpp | 294 +++++++++ src/stubs/dirdlg.cpp | 43 ++ src/stubs/dnd.cpp | 133 +++++ src/stubs/filedlg.cpp | 142 +++++ src/stubs/font.cpp | 241 ++++++++ src/stubs/fontdlg.cpp | 54 ++ src/stubs/frame.cpp | 546 +++++++++++++++++ src/stubs/gauge.cpp | 105 ++++ src/stubs/gdiobj.cpp | 22 + src/stubs/helpxxxx.cpp | 83 +++ src/stubs/icon.cpp | 70 +++ src/stubs/imaglist.cpp | 118 ++++ src/stubs/joystick.cpp | 279 +++++++++ src/stubs/listbox.cpp | 240 ++++++++ src/stubs/listctrl.cpp | 598 +++++++++++++++++++ src/stubs/main.cpp | 18 + src/stubs/mdi.cpp | 263 +++++++++ src/stubs/menu.cpp | 568 ++++++++++++++++++ src/stubs/menuitem.cpp | 96 +++ src/stubs/metafile.cpp | 236 ++++++++ src/stubs/minifram.cpp | 22 + src/stubs/msgdlg.cpp | 36 ++ src/stubs/notebook.cpp | 371 ++++++++++++ src/stubs/palette.cpp | 91 +++ src/stubs/pen.cpp | 229 +++++++ src/stubs/print.cpp | 81 +++ src/stubs/printdlg.cpp | 124 ++++ src/stubs/radiobox.cpp | 194 ++++++ src/stubs/radiobut.cpp | 68 +++ src/stubs/region.cpp | 373 ++++++++++++ src/stubs/scrolbar.cpp | 78 +++ src/stubs/settings.cpp | 151 +++++ src/stubs/slider.cpp | 185 ++++++ src/stubs/spinbutt.cpp | 78 +++ src/stubs/statbmp.cpp | 59 ++ src/stubs/statbox.cpp | 62 ++ src/stubs/stattext.cpp | 211 +++++++ src/stubs/statusbr.cpp | 162 +++++ src/stubs/tabctrl.cpp | 205 +++++++ src/stubs/taskbar.cpp | 70 +++ src/stubs/textctrl.cpp | 439 ++++++++++++++ src/stubs/thread.cpp | 225 +++++++ src/stubs/timer.cpp | 56 ++ src/stubs/toolbar.cpp | 156 +++++ src/stubs/treectrl.cpp | 419 +++++++++++++ src/stubs/utils.cpp | 272 +++++++++ src/stubs/utilsexc.cpp | 28 + src/stubs/wave.cpp | 59 ++ src/stubs/window.cpp | 1281 ++++++++++++++++++++++++++++++++++++++++ 69 files changed, 13551 insertions(+) create mode 100644 src/stubs/accel.cpp create mode 100644 src/stubs/app.cpp create mode 100644 src/stubs/bitmap.cpp create mode 100644 src/stubs/bmpbuttn.cpp create mode 100644 src/stubs/brush.cpp create mode 100644 src/stubs/button.cpp create mode 100644 src/stubs/checkbox.cpp create mode 100644 src/stubs/checklst.cpp create mode 100644 src/stubs/choice.cpp create mode 100644 src/stubs/clipbrd.cpp create mode 100644 src/stubs/colordlg.cpp create mode 100644 src/stubs/colour.cpp create mode 100644 src/stubs/combobox.cpp create mode 100644 src/stubs/control.cpp create mode 100644 src/stubs/cursor.cpp create mode 100644 src/stubs/data.cpp create mode 100644 src/stubs/dc.cpp create mode 100644 src/stubs/dcclient.cpp create mode 100644 src/stubs/dcmemory.cpp create mode 100644 src/stubs/dcscreen.cpp create mode 100644 src/stubs/dialog.cpp create mode 100644 src/stubs/dirdlg.cpp create mode 100644 src/stubs/dnd.cpp create mode 100644 src/stubs/filedlg.cpp create mode 100644 src/stubs/font.cpp create mode 100644 src/stubs/fontdlg.cpp create mode 100644 src/stubs/frame.cpp create mode 100644 src/stubs/gauge.cpp create mode 100644 src/stubs/gdiobj.cpp create mode 100644 src/stubs/helpxxxx.cpp create mode 100644 src/stubs/icon.cpp create mode 100644 src/stubs/imaglist.cpp create mode 100644 src/stubs/joystick.cpp create mode 100644 src/stubs/listbox.cpp create mode 100644 src/stubs/listctrl.cpp create mode 100644 src/stubs/main.cpp create mode 100644 src/stubs/mdi.cpp create mode 100644 src/stubs/menu.cpp create mode 100644 src/stubs/menuitem.cpp create mode 100644 src/stubs/metafile.cpp create mode 100644 src/stubs/minifram.cpp create mode 100644 src/stubs/msgdlg.cpp create mode 100644 src/stubs/notebook.cpp create mode 100644 src/stubs/palette.cpp create mode 100644 src/stubs/pen.cpp create mode 100644 src/stubs/print.cpp create mode 100644 src/stubs/printdlg.cpp create mode 100644 src/stubs/radiobox.cpp create mode 100644 src/stubs/radiobut.cpp create mode 100644 src/stubs/region.cpp create mode 100644 src/stubs/scrolbar.cpp create mode 100644 src/stubs/settings.cpp create mode 100644 src/stubs/slider.cpp create mode 100644 src/stubs/spinbutt.cpp create mode 100644 src/stubs/statbmp.cpp create mode 100644 src/stubs/statbox.cpp create mode 100644 src/stubs/stattext.cpp create mode 100644 src/stubs/statusbr.cpp create mode 100644 src/stubs/tabctrl.cpp create mode 100644 src/stubs/taskbar.cpp create mode 100644 src/stubs/textctrl.cpp create mode 100644 src/stubs/thread.cpp create mode 100644 src/stubs/timer.cpp create mode 100644 src/stubs/toolbar.cpp create mode 100644 src/stubs/treectrl.cpp create mode 100644 src/stubs/utils.cpp create mode 100644 src/stubs/utilsexc.cpp create mode 100644 src/stubs/wave.cpp create mode 100644 src/stubs/window.cpp diff --git a/src/stubs/accel.cpp b/src/stubs/accel.cpp new file mode 100644 index 0000000000..707ba496ff --- /dev/null +++ b/src/stubs/accel.cpp @@ -0,0 +1,92 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: accel.cpp +// Purpose: wxAcceleratorTable +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "accel.h" +#endif + +#include "wx/setup.h" +#include "wx/accel.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxAcceleratorTable, wxObject) +#endif + +class WXDLLEXPORT wxAcceleratorRefData: public wxObjectRefData +{ + friend class WXDLLEXPORT wxAcceleratorTable; +public: + wxAcceleratorRefData(); + ~wxAcceleratorRefData(); + +/* TODO: implementation + inline HACCEL GetHACCEL() const { return m_hAccel; } +protected: + HACCEL m_hAccel; +*/ +}; + +#define M_ACCELDATA ((wxAcceleratorRefData *)m_refData) + +wxAcceleratorRefData::wxAcceleratorRefData() +{ + // TODO +/* + HACCEL m_hAccel; +*/ +} + +wxAcceleratorRefData::~wxAcceleratorRefData() +{ +/* + if (m_hAccel) + { + DestroyAcceleratorTable((HACCEL) m_hAccel); + } + m_hAccel = 0 ; +*/ +} + +wxAcceleratorTable::wxAcceleratorTable() +{ + m_refData = NULL; +} + +wxAcceleratorTable::~wxAcceleratorTable() +{ +} + +// Load from .rc resource +wxAcceleratorTable::wxAcceleratorTable(const wxString& resource) +{ + m_refData = new wxAcceleratorRefData; + +/* TODO: load acelerator from resource, if appropriate for your platform + M_ACCELDATA->m_hAccel = hAccel; + M_ACCELDATA->m_ok = (hAccel != 0); +*/ +} + +// Create from an array +wxAcceleratorTable::wxAcceleratorTable(int n, wxAcceleratorEntry entries[]) +{ + m_refData = new wxAcceleratorRefData; + +/* TODO: create table from entries + */ +} + +bool wxAcceleratorTable::Ok() const +{ + // TODO + return FALSE; +} + diff --git a/src/stubs/app.cpp b/src/stubs/app.cpp new file mode 100644 index 0000000000..f54a6806e2 --- /dev/null +++ b/src/stubs/app.cpp @@ -0,0 +1,395 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: app.cpp +// Purpose: wxApp +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "app.h" +#endif + +#include "wx/frame.h" +#include "wx/app.h" +#include "wx/utils.h" +#include "wx/gdicmn.h" +#include "wx/pen.h" +#include "wx/brush.h" +#include "wx/cursor.h" +#include "wx/icon.h" +#include "wx/palette.h" +#include "wx/dc.h" +#include "wx/dialog.h" +#include "wx/msgdlg.h" +#include "wx/log.h" +#include "wx/module.h" + +#if USE_WX_RESOURCES +#include "wx/resource.h" +#endif + +#include + +#if defined(__WIN95__) && !defined(__GNUWIN32__) +extern char *wxBuffer; +extern wxList wxPendingDelete; + +wxApp *wxTheApp = NULL; + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) +BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) + EVT_IDLE(wxApp::OnIdle) +END_EVENT_TABLE() +#endif + +long wxApp::sm_lastMessageTime = 0; + +void wxApp::CommonInit() +{ +#ifdef __WXMSW__ + wxBuffer = new char[1500]; +#else + wxBuffer = new char[BUFSIZ + 512]; +#endif + + wxClassInfo::InitializeClasses(); + + wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING); + wxTheColourDatabase->Initialize(); + wxInitializeStockObjects(); + +#if USE_WX_RESOURCES + wxInitializeResourceSystem(); +#endif + + // For PostScript printing +#if USE_POSTSCRIPT + wxInitializePrintSetupData(); + wxThePrintPaperDatabase = new wxPrintPaperDatabase; + wxThePrintPaperDatabase->CreateDatabase(); +#endif + + wxBitmap::InitStandardHandlers(); + + wxModule::RegisterModules(); + wxASSERT( wxModule::InitializeModules() == TRUE ); +} + +void wxApp::CommonCleanUp() +{ + wxModule::CleanUpModules(); + +#if USE_WX_RESOURCES + wxCleanUpResourceSystem(); +#endif + + wxDeleteStockObjects() ; + + // Destroy all GDI lists, etc. + delete wxTheBrushList; + wxTheBrushList = NULL; + + delete wxThePenList; + wxThePenList = NULL; + + delete wxTheFontList; + wxTheFontList = NULL; + + delete wxTheBitmapList; + wxTheBitmapList = NULL; + + delete wxTheColourDatabase; + wxTheColourDatabase = NULL; + +#if USE_POSTSCRIPT + wxInitializePrintSetupData(FALSE); + delete wxThePrintPaperDatabase; + wxThePrintPaperDatabase = NULL; +#endif + + wxBitmap::CleanUpHandlers(); + + delete[] wxBuffer; + wxBuffer = NULL; + + // do it as the very last thing because everything else can log messages + delete wxLog::SetActiveTarget(NULL); +} + +int wxEntry( int argc, char *argv[] ) +{ + wxClassInfo::InitializeClasses(); + +#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT + +#if !defined(_WINDLL) + streambuf* sBuf = new wxDebugStreamBuf; +#else + streambuf* sBuf = NULL; +#endif + ostream* oStr = new ostream(sBuf) ; + wxDebugContext::SetStream(oStr, sBuf); + +#endif + + if (!wxTheApp) + { + if (!wxApp::GetInitializerFunction()) + { + printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" ); + return 0; + }; + + wxTheApp = (* wxApp::GetInitializerFunction()) (); + }; + + if (!wxTheApp) + { + printf( "wxWindows error: wxTheApp == NULL\n" ); + return 0; + }; + + wxTheApp->argc = argc; + wxTheApp->argv = argv; + + // TODO: your platform-specific initialization. + + wxApp::CommonInit(); + + // GUI-specific initialization, such as creating an app context. + wxTheApp->OnInitGui(); + + // Here frames insert themselves automatically + // into wxTopLevelWindows by getting created + // in OnInit(). + + if (!wxTheApp->OnInit()) return 0; + + wxTheApp->m_initialized = (wxTopLevelWindows.Number() > 0); + + int retValue = 0; + + if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun(); + + wxTheApp->DeletePendingObjects(); + + wxTheApp->OnExit(); + + wxApp::CommonCleanUp(); + +#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT + // At this point we want to check if there are any memory + // blocks that aren't part of the wxDebugContext itself, + // as a special case. Then when dumping we need to ignore + // wxDebugContext, too. + if (wxDebugContext::CountObjectsLeft() > 0) + { + wxTrace("There were memory leaks.\n"); + wxDebugContext::Dump(); + wxDebugContext::PrintStatistics(); + } + wxDebugContext::SetStream(NULL, NULL); +#endif + + return retValue; +}; + +// Static member initialization +wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL; + +wxApp::wxApp() +{ + m_topWindow = NULL; + wxTheApp = this; + m_className = ""; + m_wantDebugOutput = TRUE ; + m_appName = ""; + argc = 0; + argv = NULL; +#ifdef __WXMSW__ + m_printMode = wxPRINT_WINDOWS; +#else + m_printMode = wxPRINT_POSTSCRIPT; +#endif + m_exitOnFrameDelete = TRUE; + m_auto3D = TRUE; +} + +bool wxApp::Initialized() +{ + if (GetTopWindow()) + return TRUE; + else + return FALSE; +} + +int wxApp::MainLoop() +{ + m_keepGoing = TRUE; + +/* TODO: implement your main loop here, calling ProcessIdle in idle time. + while (m_keepGoing) + { + while (!::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) && + ProcessIdle()) {} + if (!DoMessage()) + m_keepGoing = FALSE; + } +*/ + + return 0; +} + +// Returns TRUE if more time is needed. +bool wxApp::ProcessIdle() +{ + wxIdleEvent event; + event.SetEventObject(this); + ProcessEvent(event); + + return event.MoreRequested(); +} + +void wxApp::ExitMainLoop() +{ + m_keepGoing = FALSE; +} + +// Is a message/event pending? +bool wxApp::Pending() +{ +/* TODO. + */ + return FALSE; +} + +// Dispatch a message. +void wxApp::Dispatch() +{ +/* TODO. + */ +} + +void wxApp::OnIdle(wxIdleEvent& event) +{ + static bool inOnIdle = FALSE; + + // Avoid recursion (via ProcessEvent default case) + if (inOnIdle) + return; + + inOnIdle = TRUE; + + // 'Garbage' collection of windows deleted with Close(). + DeletePendingObjects(); + + // flush the logged messages if any + wxLog *pLog = wxLog::GetActiveTarget(); + if ( pLog != NULL && pLog->HasPendingMessages() ) + pLog->Flush(); + + // Send OnIdle events to all windows + bool needMore = SendIdleEvents(); + + if (needMore) + event.RequestMore(TRUE); + + inOnIdle = FALSE; +} + +// Send idle event to all top-level windows +bool wxApp::SendIdleEvents() +{ + bool needMore = FALSE; + wxNode* node = wxTopLevelWindows.First(); + while (node) + { + wxWindow* win = (wxWindow*) node->Data(); + if (SendIdleEvents(win)) + needMore = TRUE; + + node = node->Next(); + } + return needMore; +} + +// Send idle event to window and all subwindows +bool wxApp::SendIdleEvents(wxWindow* win) +{ + bool needMore = FALSE; + + wxIdleEvent event; + event.SetEventObject(win); + win->ProcessEvent(event); + + if (event.MoreRequested()) + needMore = TRUE; + + wxNode* node = win->GetChildren()->First(); + while (node) + { + wxWindow* win = (wxWindow*) node->Data(); + if (SendIdleEvents(win)) + needMore = TRUE; + + node = node->Next(); + } + return needMore ; +} + +void wxApp::DeletePendingObjects() +{ + wxNode *node = wxPendingDelete.First(); + while (node) + { + wxObject *obj = (wxObject *)node->Data(); + + delete obj; + + if (wxPendingDelete.Member(obj)) + delete node; + + // Deleting one object may have deleted other pending + // objects, so start from beginning of list again. + node = wxPendingDelete.First(); + } +} + +wxLog* wxApp::CreateLogTarget() +{ + return new wxLogGui; +} + +wxWindow* wxApp::GetTopWindow() const +{ + if (m_topWindow) + return m_topWindow; + else if (wxTopLevelWindows.Number() > 0) + return (wxWindow*) wxTopLevelWindows.First()->Data(); + else + return NULL; +} + +void wxExit() +{ + wxApp::CommonCleanUp(); +/* + * TODO: Exit in some platform-specific way. Not recommended that the app calls this: + * only for emergencies. + */ +} + +// Yield to other processes +bool wxYield() +{ + /* + * TODO + */ + return TRUE; +} + diff --git a/src/stubs/bitmap.cpp b/src/stubs/bitmap.cpp new file mode 100644 index 0000000000..1e6255f551 --- /dev/null +++ b/src/stubs/bitmap.cpp @@ -0,0 +1,430 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bitmap.cpp +// Purpose: wxBitmap +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "bitmap.h" +#endif + +#include "wx/setup.h" +#include "wx/utils.h" +#include "wx/palette.h" +#include "wx/bitmap.h" +#include "wx/icon.h" +#include "wx/log.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject) +IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject) +#endif + +wxBitmapRefData::wxBitmapRefData() +{ + m_ok = FALSE; + m_width = 0; + m_height = 0; + m_depth = 0; + m_quality = 0; + m_numColors = 0; + m_bitmapMask = NULL; +} + +wxBitmapRefData::~wxBitmapRefData() +{ + /* + * TODO: delete the bitmap data here. + */ + + if (m_bitmapMask) + delete m_bitmapMask; + m_bitmapMask = NULL; +} + +wxList wxBitmap::sm_handlers; + +wxBitmap::wxBitmap() +{ + m_refData = NULL; + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +} + +wxBitmap::~wxBitmap() +{ + if (wxTheBitmapList) + wxTheBitmapList->DeleteObject(this); +} + +wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits) +{ + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_width = the_width ; + M_BITMAPDATA->m_height = the_height ; + M_BITMAPDATA->m_depth = no_bits ; + M_BITMAPDATA->m_numColors = 0; + + /* TODO: create the bitmap from data */ + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +} + +wxBitmap::wxBitmap(int w, int h, int d) +{ + (void)Create(w, h, d); + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +} + +wxBitmap::wxBitmap(void *data, long type, int width, int height, int depth) +{ + (void) Create(data, type, width, height, depth); + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +} + +wxBitmap::wxBitmap(const wxString& filename, long type) +{ + LoadFile(filename, (int)type); + + if ( wxTheBitmapList ) + wxTheBitmapList->AddBitmap(this); +} + +/* TODO: maybe allow creation from XPM +// Create from data +wxBitmap::wxBitmap(const char **data) +{ + (void) Create((void *)data, wxBITMAP_TYPE_XPM_DATA, 0, 0, 0); +} +*/ + +bool wxBitmap::Create(int w, int h, int d) +{ + UnRef(); + + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_width = w; + M_BITMAPDATA->m_height = h; + M_BITMAPDATA->m_depth = d; + + /* TODO: create new bitmap */ + + return M_BITMAPDATA->m_ok; +} + +bool wxBitmap::LoadFile(const wxString& filename, long type) +{ + UnRef(); + + m_refData = new wxBitmapRefData; + + wxBitmapHandler *handler = FindHandler(type); + + if ( handler == NULL ) { + wxLogWarning("no bitmap handler for type %d defined.", type); + + return FALSE; + } + + return handler->LoadFile(this, filename, type, -1, -1); +} + +bool wxBitmap::Create(void *data, long type, int width, int height, int depth) +{ + UnRef(); + + m_refData = new wxBitmapRefData; + + wxBitmapHandler *handler = FindHandler(type); + + if ( handler == NULL ) { + wxLogWarning("no bitmap handler for type %d defined.", type); + + return FALSE; + } + + return handler->Create(this, data, type, width, height, depth); +} + +bool wxBitmap::SaveFile(const wxString& filename, int type, const wxPalette *palette) +{ + wxBitmapHandler *handler = FindHandler(type); + + if ( handler == NULL ) { + wxLogWarning("no bitmap handler for type %d defined.", type); + + return FALSE; + } + + return handler->SaveFile(this, filename, type, palette); +} + +void wxBitmap::SetWidth(int w) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_width = w; +} + +void wxBitmap::SetHeight(int h) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_height = h; +} + +void wxBitmap::SetDepth(int d) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_depth = d; +} + +void wxBitmap::SetQuality(int q) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_quality = q; +} + +void wxBitmap::SetOk(bool isOk) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_ok = isOk; +} + +void wxBitmap::SetPalette(const wxPalette& palette) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_bitmapPalette = palette ; +} + +void wxBitmap::SetMask(wxMask *mask) +{ + if (!M_BITMAPDATA) + m_refData = new wxBitmapRefData; + + M_BITMAPDATA->m_bitmapMask = mask ; +} + +void wxBitmap::AddHandler(wxBitmapHandler *handler) +{ + sm_handlers.Append(handler); +} + +void wxBitmap::InsertHandler(wxBitmapHandler *handler) +{ + sm_handlers.Insert(handler); +} + +bool wxBitmap::RemoveHandler(const wxString& name) +{ + wxBitmapHandler *handler = FindHandler(name); + if ( handler ) + { + sm_handlers.DeleteObject(handler); + return TRUE; + } + else + return FALSE; +} + +wxBitmapHandler *wxBitmap::FindHandler(const wxString& name) +{ + wxNode *node = sm_handlers.First(); + while ( node ) + { + wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); + if ( handler->GetName() == name ) + return handler; + node = node->Next(); + } + return NULL; +} + +wxBitmapHandler *wxBitmap::FindHandler(const wxString& extension, long bitmapType) +{ + wxNode *node = sm_handlers.First(); + while ( node ) + { + wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); + if ( handler->GetExtension() == extension && + (bitmapType == -1 || handler->GetType() == bitmapType) ) + return handler; + node = node->Next(); + } + return NULL; +} + +wxBitmapHandler *wxBitmap::FindHandler(long bitmapType) +{ + wxNode *node = sm_handlers.First(); + while ( node ) + { + wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); + if (handler->GetType() == bitmapType) + return handler; + node = node->Next(); + } + return NULL; +} + +/* + * wxMask + */ + +wxMask::wxMask() +{ +/* TODO + m_maskBitmap = 0; +*/ +} + +// Construct a mask from a bitmap and a colour indicating +// the transparent area +wxMask::wxMask(const wxBitmap& bitmap, const wxColour& colour) +{ +/* TODO + m_maskBitmap = 0; +*/ + Create(bitmap, colour); +} + +// Construct a mask from a bitmap and a palette index indicating +// the transparent area +wxMask::wxMask(const wxBitmap& bitmap, int paletteIndex) +{ +/* TODO + m_maskBitmap = 0; +*/ + + Create(bitmap, paletteIndex); +} + +// Construct a mask from a mono bitmap (copies the bitmap). +wxMask::wxMask(const wxBitmap& bitmap) +{ +/* TODO + m_maskBitmap = 0; +*/ + + Create(bitmap); +} + +wxMask::~wxMask() +{ +// TODO: delete mask bitmap +} + +// Create a mask from a mono bitmap (copies the bitmap). +bool wxMask::Create(const wxBitmap& bitmap) +{ +// TODO + return FALSE; +} + +// Create a mask from a bitmap and a palette index indicating +// the transparent area +bool wxMask::Create(const wxBitmap& bitmap, int paletteIndex) +{ +// TODO + return FALSE; +} + +// Create a mask from a bitmap and a colour indicating +// the transparent area +bool wxMask::Create(const wxBitmap& bitmap, const wxColour& colour) +{ +// TODO + return FALSE; +} + +/* + * wxBitmapHandler + */ + +IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject) + +bool wxBitmapHandler::Create(wxBitmap *bitmap, void *data, long type, int width, int height, int depth) +{ + return FALSE; +} + +bool wxBitmapHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long type, + int desiredWidth, int desiredHeight) +{ + return FALSE; +} + +bool wxBitmapHandler::SaveFile(wxBitmap *bitmap, const wxString& name, int type, const wxPalette *palette) +{ + return FALSE; +} + +/* + * Standard handlers + */ + +/* TODO: bitmap handlers, a bit like this: +class WXDLLEXPORT wxBMPResourceHandler: public wxBitmapHandler +{ + DECLARE_DYNAMIC_CLASS(wxBMPResourceHandler) +public: + inline wxBMPResourceHandler() + { + m_name = "Windows bitmap resource"; + m_extension = ""; + m_type = wxBITMAP_TYPE_BMP_RESOURCE; + }; + + virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, + int desiredWidth, int desiredHeight); +}; +IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler) +*/ + +void wxBitmap::CleanUpHandlers() +{ + wxNode *node = sm_handlers.First(); + while ( node ) + { + wxBitmapHandler *handler = (wxBitmapHandler *)node->Data(); + wxNode *next = node->Next(); + delete handler; + delete node; + node = next; + } +} + +void wxBitmap::InitStandardHandlers() +{ +/* TODO: initialize all standard bitmap or derive class handlers here. + AddHandler(new wxBMPResourceHandler); + AddHandler(new wxBMPFileHandler); + AddHandler(new wxXPMFileHandler); + AddHandler(new wxXPMDataHandler); + AddHandler(new wxICOResourceHandler); + AddHandler(new wxICOFileHandler); +*/ +} diff --git a/src/stubs/bmpbuttn.cpp b/src/stubs/bmpbuttn.cpp new file mode 100644 index 0000000000..9e46c22b2b --- /dev/null +++ b/src/stubs/bmpbuttn.cpp @@ -0,0 +1,65 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: bmpbuttn.cpp +// Purpose: wxBitmapButton +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "bmpbuttn.h" +#endif + +#include "wx/bmpbuttn.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton) +#endif + +bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id, const wxBitmap& bitmap, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + m_buttonBitmap = bitmap; + SetName(name); + SetValidator(validator); + parent->AddChild(this); + + m_backgroundColour = parent->GetDefaultBackgroundColour() ; + m_foregroundColour = parent->GetDefaultForegroundColour() ; + m_windowStyle = style; + m_marginX = 0; + m_marginY = 0; + + int x = pos.x; + int y = pos.y; + int width = size.x; + int height = size.y; + + if (id == -1) + m_windowId = NewControlId(); + else + m_windowId = id; + + if ( width == -1 && bitmap.Ok()) + width = bitmap.GetWidth() + 2*m_marginX; + + if ( height == -1 && bitmap.Ok()) + height = bitmap.GetHeight() + 2*m_marginY; + + /* TODO: create bitmap button + */ + + return FALSE; +} + +void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap) +{ + m_buttonBitmap = bitmap; +} + diff --git a/src/stubs/brush.cpp b/src/stubs/brush.cpp new file mode 100644 index 0000000000..72c12935ff --- /dev/null +++ b/src/stubs/brush.cpp @@ -0,0 +1,162 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: brush.cpp +// Purpose: wxBrush +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "brush.h" +#endif + +#include "wx/setup.h" +#include "wx/utils.h" +#include "wx/brush.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject) +#endif + +wxBrushRefData::wxBrushRefData() +{ + m_style = wxSOLID; +// TODO: null data +} + +wxBrushRefData::wxBrushRefData(const wxBrushRefData& data) +{ + m_style = data.m_style; + m_stipple = data.m_stipple; + m_colour = data.m_colour; +/* TODO: null data + m_hBrush = 0; +*/ +} + +wxBrushRefData::~wxBrushRefData() +{ +// TODO: delete data +} + +// Brushes +wxBrush::wxBrush() +{ + if ( wxTheBrushList ) + wxTheBrushList->AddBrush(this); +} + +wxBrush::~wxBrush() +{ + if ( wxTheBrushList ) + wxTheBrushList->RemoveBrush(this); +} + +wxBrush::wxBrush(const wxColour& col, int Style) +{ + m_refData = new wxBrushRefData; + + M_BRUSHDATA->m_colour = col; + M_BRUSHDATA->m_style = Style; + + RealizeResource(); + + if ( wxTheBrushList ) + wxTheBrushList->AddBrush(this); +} + +wxBrush::wxBrush(const wxString& col, int Style) +{ + m_refData = new wxBrushRefData; + + // Implicit conversion from string to wxColour via colour database + M_BRUSHDATA->m_colour = col; + M_BRUSHDATA->m_style = Style; + + RealizeResource(); + + if ( wxTheBrushList ) + wxTheBrushList->AddBrush(this); +} + +wxBrush::wxBrush(const wxBitmap& stipple) +{ + m_refData = new wxBrushRefData; + + M_BRUSHDATA->m_style = wxSTIPPLE; + M_BRUSHDATA->m_stipple = stipple; + + RealizeResource(); + + if ( wxTheBrushList ) + wxTheBrushList->AddBrush(this); +} + +void wxBrush::Unshare() +{ + // Don't change shared data + if (!m_refData) + { + m_refData = new wxBrushRefData(); + } + else + { + wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData); + UnRef(); + m_refData = ref; + } +} + +void wxBrush::SetColour(const wxColour& col) +{ + Unshare(); + + M_BRUSHDATA->m_colour = col; + + RealizeResource(); +} + +void wxBrush::SetColour(const wxString& col) +{ + Unshare(); + + M_BRUSHDATA->m_colour = col; + + RealizeResource(); +} + +void wxBrush::SetColour(const unsigned char r, const unsigned char g, const unsigned char b) +{ + Unshare(); + + M_BRUSHDATA->m_colour.Set(r, g, b); + + RealizeResource(); +} + +void wxBrush::SetStyle(int Style) +{ + Unshare(); + + M_BRUSHDATA->m_style = Style; + + RealizeResource(); +} + +void wxBrush::SetStipple(const wxBitmap& Stipple) +{ + Unshare(); + + M_BRUSHDATA->m_stipple = Stipple; + + RealizeResource(); +} + +void wxBrush::RealizeResource() +{ +// TODO: create the brush +} + diff --git a/src/stubs/button.cpp b/src/stubs/button.cpp new file mode 100644 index 0000000000..befd0d7156 --- /dev/null +++ b/src/stubs/button.cpp @@ -0,0 +1,75 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: button.cpp +// Purpose: wxButton +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "button.h" +#endif + +#include "wx/button.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl) +#endif + +// Button + +bool wxButton::Create(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_windowStyle = style; + + parent->AddChild((wxButton *)this); + + if (id == -1) + m_windowId = NewControlId(); + else + m_windowId = id; + + // TODO: create button + + return FALSE; +} + +void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxButton::SetDefault() +{ + wxWindow *parent = (wxWindow *)GetParent(); + if (parent) + parent->SetDefaultItem(this); + + // TODO: make button the default +} + +wxString wxButton::GetLabel() const +{ + // TODO + return wxString(""); +} + +void wxButton::SetLabel(const wxString& label) +{ + // TODO +} + +void wxButton::Command (wxCommandEvent & event) +{ + ProcessCommand (event); +} + diff --git a/src/stubs/checkbox.cpp b/src/stubs/checkbox.cpp new file mode 100644 index 0000000000..dd2e2abe7a --- /dev/null +++ b/src/stubs/checkbox.cpp @@ -0,0 +1,117 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: checkbox.cpp +// Purpose: wxCheckBox +// Author: AUTHOR +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "checkbox.h" +#endif + +#include "wx/checkbox.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl) +IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox) +#endif + +// Single check box item +bool wxCheckBox::Create(wxWindow *parent, wxWindowID id, const wxString& label, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = NewControlId(); + else + m_windowId = id; + + // TODO: create checkbox + + return FALSE; +} + +void wxCheckBox::SetLabel(const wxString& label) +{ + // TODO +} + +void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxCheckBox::SetValue(bool val) +{ + // TODO +} + +bool wxCheckBox::GetValue() const +{ + // TODO + return FALSE; +} + +void wxCheckBox::Command (wxCommandEvent & event) +{ + SetValue ((event.GetInt() != 0)); + ProcessCommand (event); +} + +// Bitmap checkbox +bool wxBitmapCheckBox::Create(wxWindow *parent, wxWindowID id, const wxBitmap *label, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = NewControlId(); + else + m_windowId = id; + + // TODO: Create the bitmap checkbox + + return FALSE; +} + +void wxBitmapCheckBox::SetLabel(const wxBitmap *bitmap) +{ + // TODO +} + +void wxBitmapCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxBitmapCheckBox::SetValue(bool val) +{ + // TODO +} + +bool wxBitmapCheckBox::GetValue() const +{ + // TODOD + return FALSE; +} + + diff --git a/src/stubs/checklst.cpp b/src/stubs/checklst.cpp new file mode 100644 index 0000000000..c7121e553d --- /dev/null +++ b/src/stubs/checklst.cpp @@ -0,0 +1,77 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: checklst.cpp +// Purpose: implementation of wxCheckListBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +// ============================================================================ +// headers & declarations +// ============================================================================ + +#ifdef __GNUG__ +#pragma implementation "checklst.h" +#endif + +#include "wx/checklst.h" + +// ============================================================================ +// implementation +// ============================================================================ + +#if !USE_SHARED_LIBRARY + IMPLEMENT_DYNAMIC_CLASS(wxCheckListBox, wxListBox) +#endif + +// ---------------------------------------------------------------------------- +// implementation of wxCheckListBox class +// ---------------------------------------------------------------------------- + +// define event table +// ------------------ +BEGIN_EVENT_TABLE(wxCheckListBox, wxListBox) + EVT_CHAR(wxCheckListBox::OnChar) + EVT_LEFT_DOWN(wxCheckListBox::OnLeftClick) +END_EVENT_TABLE() + +// control creation +// ---------------- + +// def ctor: use Create() to really create the control +wxCheckListBox::wxCheckListBox() : wxListBox() +{ +} + +// ctor which creates the associated control +wxCheckListBox::wxCheckListBox(wxWindow *parent, wxWindowID id, + const wxPoint& pos, const wxSize& size, + int nStrings, const wxString choices[], + long style, const wxValidator& val, + const wxString& name) + : wxListBox() +{ + // TODO: you'll probably need a separate Create instead of using + // the wxListBox one as here. + Create(parent, id, pos, size, nStrings, choices, style|wxLB_OWNERDRAW, val, name); +} + +// check items +// ----------- + +bool wxCheckListBox::IsChecked(uint uiIndex) const +{ + // TODO + return FALSE; +} + +void wxCheckListBox::Check(uint uiIndex, bool bCheck) +{ + // TODO + return FALSE; +} + + diff --git a/src/stubs/choice.cpp b/src/stubs/choice.cpp new file mode 100644 index 0000000000..a584d5303f --- /dev/null +++ b/src/stubs/choice.cpp @@ -0,0 +1,119 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: choice.cpp +// Purpose: wxChoice +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "choice.h" +#endif + +// For compilers that support precompilation, includes "wx.h". +#include "wx/choice.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl) +#endif + +bool wxChoice::Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos, + const wxSize& size, + int n, const wxString choices[], + long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_noStrings = n; + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + // TODO: create choice control + return FALSE; +} + +void wxChoice::Append(const wxString& item) +{ + // TODO + m_noStrings ++; +} + +void wxChoice::Delete(int n) +{ + // TODO + m_noStrings --; +} + +void wxChoice::Clear() +{ + // TODO + m_noStrings = 0; +} + +int wxChoice::GetSelection() const +{ + // TODO + return 0; +} + +void wxChoice::SetSelection(int n) +{ + // TODO +} + +int wxChoice::FindString(const wxString& s) const +{ + // TODO + return 0; +} + +wxString wxChoice::GetString(int n) const +{ + // TODO + return wxString(""); +} + +void wxChoice::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +wxString wxChoice::GetStringSelection () const +{ + int sel = GetSelection (); + if (sel > -1) + return wxString(this->GetString (sel)); + else + return wxString(""); +} + +bool wxChoice::SetStringSelection (const wxString& s) +{ + int sel = FindString (s); + if (sel > -1) + { + SetSelection (sel); + return TRUE; + } + else + return FALSE; +} + +void wxChoice::Command(wxCommandEvent & event) +{ + SetSelection (event.GetInt()); + ProcessCommand (event); +} + diff --git a/src/stubs/clipbrd.cpp b/src/stubs/clipbrd.cpp new file mode 100644 index 0000000000..3fe9ebfb72 --- /dev/null +++ b/src/stubs/clipbrd.cpp @@ -0,0 +1,237 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: clipbrd.cpp +// Purpose: Clipboard functionality +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation +#pragma implementation "clipbrd.h" +#endif + +#include "wx/app.h" +#include "wx/frame.h" +#include "wx/bitmap.h" +#include "wx/utils.h" +#include "wx/metafile.h" +#include "wx/clipbrd.h" + +#include + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject) +IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject) +#endif + +bool wxOpenClipboard() +{ + // TODO + return FALSE; +} + +bool wxCloseClipboard() +{ + // TODO + return FALSE; +} + +bool wxEmptyClipboard() +{ + // TODO + return FALSE; +} + +bool wxClipboardOpen() +{ + // TODO + return FALSE; +} + +bool wxIsClipboardFormatAvailable(int dataFormat) +{ + // TODO + return FALSE; +} + +bool wxSetClipboardData(int dataFormat, wxObject *obj, int width, int height) +{ + // TODO + return FALSE; +} + +wxObject *wxGetClipboardData(int dataFormat, long *len) +{ + // TODO + return NULL; +} + +int wxEnumClipboardFormats(int dataFormat) +{ + // TODO + return 0; +} + +int wxRegisterClipboardFormat(char *formatName) +{ + // TODO + return 0; +} + +bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount) +{ + // TODO + return FALSE; +} + +/* + * Generalized clipboard implementation by Matthew Flatt + */ + +wxClipboard *wxTheClipboard = NULL; + +void wxInitClipboard() +{ + if (!wxTheClipboard) + wxTheClipboard = new wxClipboard; +} + +wxClipboard::wxClipboard() +{ + clipOwner = NULL; + cbString = NULL; +} + +wxClipboard::~wxClipboard() +{ + if (clipOwner) + clipOwner->BeingReplaced(); + if (cbString) + delete[] cbString; +} + +static int FormatStringToID(char *str) +{ + if (!strcmp(str, "TEXT")) + return wxDF_TEXT; + + return wxRegisterClipboardFormat(str); +} + +void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time) +{ + bool got_selection; + + if (clipOwner) + clipOwner->BeingReplaced(); + clipOwner = client; + if (cbString) { + delete[] cbString; + cbString = NULL; + } + + if (wxOpenClipboard()) { + char **formats, *data; + int i; + int ftype; + long size; + + formats = clipOwner->formats.ListToArray(FALSE); + for (i = clipOwner->formats.Number(); i--; ) { + ftype = FormatStringToID(formats[i]); + data = clipOwner->GetData(formats[i], &size); + if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) { + got_selection = FALSE; + break; + } + } + + if (i < 0) + got_selection = wxCloseClipboard(); + } else + got_selection = FALSE; + + got_selection = FALSE; // Assume another process takes over + + if (!got_selection) { + clipOwner->BeingReplaced(); + clipOwner = NULL; + } +} + +wxClipboardClient *wxClipboard::GetClipboardClient() +{ + return clipOwner; +} + +void wxClipboard::SetClipboardString(char *str, long time) +{ + bool got_selection; + + if (clipOwner) { + clipOwner->BeingReplaced(); + clipOwner = NULL; + } + if (cbString) + delete[] cbString; + + cbString = str; + + if (wxOpenClipboard()) { + if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str)) + got_selection = FALSE; + else + got_selection = wxCloseClipboard(); + } else + got_selection = FALSE; + + got_selection = FALSE; // Assume another process takes over + + if (!got_selection) { + delete[] cbString; + cbString = NULL; + } +} + +char *wxClipboard::GetClipboardString(long time) +{ + char *str; + long length; + + str = GetClipboardData("TEXT", &length, time); + if (!str) { + str = new char[1]; + *str = 0; + } + + return str; +} + +char *wxClipboard::GetClipboardData(char *format, long *length, long time) +{ + if (clipOwner) { + if (clipOwner->formats.Member(format)) + return clipOwner->GetData(format, length); + else + return NULL; + } else if (cbString) { + if (!strcmp(format, "TEXT")) + return copystring(cbString); + else + return NULL; + } else { + if (wxOpenClipboard()) { + receivedString = (char *)wxGetClipboardData(FormatStringToID(format), + length); + wxCloseClipboard(); + } else + receivedString = NULL; + + return receivedString; + } +} + diff --git a/src/stubs/colordlg.cpp b/src/stubs/colordlg.cpp new file mode 100644 index 0000000000..9e970859aa --- /dev/null +++ b/src/stubs/colordlg.cpp @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colordlg.cpp +// Purpose: wxColourDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "colordlg.h" +#endif + +#include "wx/colordlg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxColourDialog, wxDialog) +#endif + +/* + * wxColourDialog + */ + +wxColourDialog::wxColourDialog() +{ + m_dialogParent = NULL; +} + +wxColourDialog::wxColourDialog(wxWindow *parent, wxColourData *data) +{ + Create(parent, data); +} + +bool wxColourDialog::Create(wxWindow *parent, wxColourData *data) +{ + m_dialogParent = parent; + + if (data) + m_colourData = *data; + return TRUE; +} + +int wxColourDialog::ShowModal() +{ + /* TODO: implement dialog + */ + + return wxID_CANCEL; +} + diff --git a/src/stubs/colour.cpp b/src/stubs/colour.cpp new file mode 100644 index 0000000000..d342d516de --- /dev/null +++ b/src/stubs/colour.cpp @@ -0,0 +1,126 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colour.cpp +// Purpose: wxColour class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "colour.h" +#endif + +#include "wx/gdicmn.h" +#include "wx/colour.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject) +#endif + +// Colour + +wxColour::wxColour () +{ + m_isInit = FALSE; + m_red = m_blue = m_green = 0; +/* TODO + m_pixel = 0; +*/ +} + +wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b) +{ + m_red = r; + m_green = g; + m_blue = b; + m_isInit = TRUE; +/* TODO + m_pixel = PALETTERGB (m_red, m_green, m_blue); +*/ +} + +wxColour::wxColour (const wxColour& col) +{ + m_red = col.m_red; + m_green = col.m_green; + m_blue = col.m_blue; + m_isInit = col.m_isInit; +/* TODO + m_pixel = col.m_pixel; +*/ +} + +wxColour& wxColour::operator =(const wxColour& col) +{ + m_red = col.m_red; + m_green = col.m_green; + m_blue = col.m_blue; + m_isInit = col.m_isInit; +/* TODO + m_pixel = col.m_pixel; +*/ + return *this; +} + +wxColour::wxColour (const wxString& col) +{ + wxColour *the_colour = wxTheColourDatabase->FindColour (col); + if (the_colour) + { + m_red = the_colour->Red (); + m_green = the_colour->Green (); + m_blue = the_colour->Blue (); + m_isInit = TRUE; + } + else + { + m_red = 0; + m_green = 0; + m_blue = 0; + m_isInit = FALSE; + } +/* TODO + m_pixel = PALETTERGB (m_red, m_green, m_blue); +*/ +} + +wxColour::~wxColour () +{ +} + +wxColour& wxColour::operator = (const wxString& col) +{ + wxColour *the_colour = wxTheColourDatabase->FindColour (col); + if (the_colour) + { + m_red = the_colour->Red (); + m_green = the_colour->Green (); + m_blue = the_colour->Blue (); + m_isInit = TRUE; + } + else + { + m_red = 0; + m_green = 0; + m_blue = 0; + m_isInit = FALSE; + } +/* TODO + m_pixel = PALETTERGB (m_red, m_green, m_blue); +*/ + return (*this); +} + +void wxColour::Set (unsigned char r, unsigned char g, unsigned char b) +{ + m_red = r; + m_green = g; + m_blue = b; + m_isInit = TRUE; +/* TODO + m_pixel = PALETTERGB (m_red, m_green, m_blue); +*/ +} diff --git a/src/stubs/combobox.cpp b/src/stubs/combobox.cpp new file mode 100644 index 0000000000..f1bbccaeb0 --- /dev/null +++ b/src/stubs/combobox.cpp @@ -0,0 +1,116 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: combobox.cpp +// Purpose: wxComboBox class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "combobox.h" +#endif + +#include "wx/combobox.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl) +#endif + +bool wxComboBox::Create(wxWindow *parent, wxWindowID id, + const wxString& value, + const wxPoint& pos, + const wxSize& size, + int n, const wxString choices[], + long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_noStrings = n; + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + // TODO: create combobox control + + return TRUE; +} + +wxString wxComboBox::GetValue() const +{ + // TODO + return wxString(""); +} + +void wxComboBox::SetValue(const wxString& value) +{ + // TODO +} + +// Clipboard operations +void wxComboBox::Copy() +{ + // TODO +} + +void wxComboBox::Cut() +{ + // TODO +} + +void wxComboBox::Paste() +{ + // TODO +} + +void wxComboBox::SetEditable(bool editable) +{ + // TODO +} + +void wxComboBox::SetInsertionPoint(long pos) +{ + // TODO +} + +void wxComboBox::SetInsertionPointEnd() +{ + // TODO +} + +long wxComboBox::GetInsertionPoint() const +{ + // TODO + return 0; +} + +long wxComboBox::GetLastPosition() const +{ + // TODO + return 0; +} + +void wxComboBox::Replace(long from, long to, const wxString& value) +{ + // TODO +} + +void wxComboBox::Remove(long from, long to) +{ + // TODO +} + +void wxComboBox::SetSelection(long from, long to) +{ + // TODO +} + diff --git a/src/stubs/control.cpp b/src/stubs/control.cpp new file mode 100644 index 0000000000..651b272953 --- /dev/null +++ b/src/stubs/control.cpp @@ -0,0 +1,111 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: control.cpp +// Purpose: wxControl class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "control.h" +#endif + +#include "wx/control.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow) + +BEGIN_EVENT_TABLE(wxControl, wxWindow) +END_EVENT_TABLE() +#endif + +// Item members +wxControl::wxControl() +{ + m_backgroundColour = *wxWHITE; + m_foregroundColour = *wxBLACK; + m_callback = 0; +} + +wxControl::~wxControl() +{ + // If we delete an item, we should initialize the parent panel, + // because it could now be invalid. + wxWindow *parent = (wxWindow *)GetParent(); + if (parent) + { + if (parent->GetDefaultItem() == this) + parent->SetDefaultItem(NULL); + } +} + +void wxControl::SetLabel(const wxString& label) +{ + // TODO +} + +wxString wxControl::GetLabel() const +{ + // TODO + return wxString(""); +} + +/* + * Allocates control IDs within the appropriate range + */ + +int NewControlId() +{ + static int s_controlId = 0; + s_controlId ++; + return s_controlId; +} + +void wxControl::ProcessCommand (wxCommandEvent & event) +{ + // Tries: + // 1) A callback function (to become obsolete) + // 2) OnCommand, starting at this window and working up parent hierarchy + // 3) OnCommand then calls ProcessEvent to search the event tables. + if (m_callback) + { + (void) (*(m_callback)) (*this, event); + } + else + { + GetEventHandler()->OnCommand(*this, event); + } +} + +void wxControl::SetClientSize (int width, int height) +{ + SetSize (-1, -1, width, height); +} + +void wxControl::Centre (int direction) +{ + int x, y, width, height, panel_width, panel_height, new_x, new_y; + + wxWindow *parent = (wxWindow *) GetParent (); + if (!parent) + return; + + parent->GetClientSize (&panel_width, &panel_height); + GetSize (&width, &height); + GetPosition (&x, &y); + + new_x = x; + new_y = y; + + if (direction & wxHORIZONTAL) + new_x = (int) ((panel_width - width) / 2); + + if (direction & wxVERTICAL) + new_y = (int) ((panel_height - height) / 2); + + SetSize (new_x, new_y, width, height); +} + diff --git a/src/stubs/cursor.cpp b/src/stubs/cursor.cpp new file mode 100644 index 0000000000..c856f5e9e0 --- /dev/null +++ b/src/stubs/cursor.cpp @@ -0,0 +1,186 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: cursor.cpp +// Purpose: wxCursor class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "cursor.h" +#endif + +#include "wx/cursor.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap) +#endif + +wxCursorRefData::wxCursorRefData() +{ + m_width = 32; m_height = 32; + +/* TODO + m_hCursor = 0 ; +*/ +} + +wxCursorRefData::~wxCursorRefData() +{ + // TODO: destroy cursor +} + +// Cursors +wxCursor::wxCursor() +{ +} + +wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height), + int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[]) +{ +} + +wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY) +{ + m_refData = new wxIconRefData; + + // TODO: create cursor from a file +} + +// Cursors by stock number +wxCursor::wxCursor(int cursor_type) +{ + m_refData = new wxIconRefData; + +/* TODO + switch (cursor_type) + { + case wxCURSOR_WAIT: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_WAIT); + break; + case wxCURSOR_IBEAM: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_IBEAM); + break; + case wxCURSOR_CROSS: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_CROSS); + break; + case wxCURSOR_SIZENWSE: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENWSE); + break; + case wxCURSOR_SIZENESW: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENESW); + break; + case wxCURSOR_SIZEWE: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZEWE); + break; + case wxCURSOR_SIZENS: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_SIZENS); + break; + case wxCURSOR_CHAR: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW); + break; + } + case wxCURSOR_HAND: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_HAND"); + break; + } + case wxCURSOR_BULLSEYE: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BULLSEYE"); + break; + } + case wxCURSOR_PENCIL: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PENCIL"); + break; + } + case wxCURSOR_MAGNIFIER: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_MAGNIFIER"); + break; + } + case wxCURSOR_NO_ENTRY: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_NO_ENTRY"); + break; + } + case wxCURSOR_LEFT_BUTTON: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW); + break; + } + case wxCURSOR_RIGHT_BUTTON: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW); + break; + } + case wxCURSOR_MIDDLE_BUTTON: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW); + break; + } + case wxCURSOR_SIZING: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_SIZING"); + break; + } + case wxCURSOR_WATCH: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_WATCH"); + break; + } + case wxCURSOR_SPRAYCAN: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_ROLLER"); + break; + } + case wxCURSOR_PAINT_BRUSH: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PBRUSH"); + break; + } + case wxCURSOR_POINT_LEFT: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PLEFT"); + break; + } + case wxCURSOR_POINT_RIGHT: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_PRIGHT"); + break; + } + case wxCURSOR_QUESTION_ARROW: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_QARROW"); + break; + } + case wxCURSOR_BLANK: + { + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(wxGetInstance(), "wxCURSOR_BLANK"); + break; + } + default: + case wxCURSOR_ARROW: + M_CURSORDATA->m_hCursor = (WXHCURSOR) LoadCursor(NULL, IDC_ARROW); + break; + } +*/ + +} + +wxCursor::~wxCursor() +{ +} + +// Global cursor setting +void wxSetCursor(const wxCursor& cursor) +{ + // TODO (optional on platforms with no global cursor) +} + + diff --git a/src/stubs/data.cpp b/src/stubs/data.cpp new file mode 100644 index 0000000000..d706f82334 --- /dev/null +++ b/src/stubs/data.cpp @@ -0,0 +1,145 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: data.cpp +// Purpose: Various data +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation +#endif + +#include "wx/wx.h" + +#define _MAXPATHLEN 500 + +// Useful buffer, initialized in CommonInit +char *wxBuffer = NULL; + +// Windows List +wxList wxTopLevelWindows; + +// List of windows pending deletion +wxList wxPendingDelete; + +int wxPageNumber; + +// GDI Object Lists +wxBrushList *wxTheBrushList = NULL; +wxPenList *wxThePenList = NULL; +wxFontList *wxTheFontList = NULL; +wxBitmapList *wxTheBitmapList = NULL; + +wxColourDatabase *wxTheColourDatabase = NULL; + +// Stock objects +wxFont *wxNORMAL_FONT; +wxFont *wxSMALL_FONT; +wxFont *wxITALIC_FONT; +wxFont *wxSWISS_FONT; +wxPen *wxRED_PEN; + +wxPen *wxCYAN_PEN; +wxPen *wxGREEN_PEN; +wxPen *wxBLACK_PEN; +wxPen *wxWHITE_PEN; +wxPen *wxTRANSPARENT_PEN; +wxPen *wxBLACK_DASHED_PEN; +wxPen *wxGREY_PEN; +wxPen *wxMEDIUM_GREY_PEN; +wxPen *wxLIGHT_GREY_PEN; + +wxBrush *wxBLUE_BRUSH; +wxBrush *wxGREEN_BRUSH; +wxBrush *wxWHITE_BRUSH; +wxBrush *wxBLACK_BRUSH; +wxBrush *wxTRANSPARENT_BRUSH; +wxBrush *wxCYAN_BRUSH; +wxBrush *wxRED_BRUSH; +wxBrush *wxGREY_BRUSH; +wxBrush *wxMEDIUM_GREY_BRUSH; +wxBrush *wxLIGHT_GREY_BRUSH; + +wxColour *wxBLACK; +wxColour *wxWHITE; +wxColour *wxRED; +wxColour *wxBLUE; +wxColour *wxGREEN; +wxColour *wxCYAN; +wxColour *wxLIGHT_GREY; + +wxCursor *wxSTANDARD_CURSOR = NULL; +wxCursor *wxHOURGLASS_CURSOR = NULL; +wxCursor *wxCROSS_CURSOR = NULL; + +// 'Null' objects +wxAcceleratorTable wxNullAcceleratorTable; +wxBitmap wxNullBitmap; +wxIcon wxNullIcon; +wxCursor wxNullCursor; +wxPen wxNullPen; +wxBrush wxNullBrush; +wxPalette wxNullPalette; +wxFont wxNullFont; +wxColour wxNullColour; + +// Default window names +const char *wxButtonNameStr = "button"; +const char *wxCanvasNameStr = "canvas"; +const char *wxCheckBoxNameStr = "check"; +const char *wxChoiceNameStr = "choice"; +const char *wxComboBoxNameStr = "comboBox"; +const char *wxDialogNameStr = "dialog"; +const char *wxFrameNameStr = "frame"; +const char *wxGaugeNameStr = "gauge"; +const char *wxStaticBoxNameStr = "groupBox"; +const char *wxListBoxNameStr = "listBox"; +const char *wxStaticTextNameStr = "message"; +const char *wxStaticBitmapNameStr = "message"; +const char *wxMultiTextNameStr = "multitext"; +const char *wxPanelNameStr = "panel"; +const char *wxRadioBoxNameStr = "radioBox"; +const char *wxRadioButtonNameStr = "radioButton"; +const char *wxBitmapRadioButtonNameStr = "radioButton"; +const char *wxScrollBarNameStr = "scrollBar"; +const char *wxSliderNameStr = "slider"; +const char *wxStaticNameStr = "static"; +const char *wxTextCtrlWindowNameStr = "textWindow"; +const char *wxTextCtrlNameStr = "text"; +const char *wxVirtListBoxNameStr = "virtListBox"; +const char *wxButtonBarNameStr = "buttonbar"; +const char *wxEnhDialogNameStr = "Shell"; +const char *wxToolBarNameStr = "toolbar"; +const char *wxStatusLineNameStr = "status_line"; +const char *wxEmptyString = ""; +const char *wxGetTextFromUserPromptStr = "Input Text"; +const char *wxMessageBoxCaptionStr = "Message"; +const char *wxFileSelectorPromptStr = "Select a file"; +const char *wxFileSelectorDefaultWildcardStr = "*.*"; +const char *wxInternalErrorStr = "wxWindows Internal Error"; +const char *wxFatalErrorStr = "wxWindows Fatal Error"; + +// See wx/utils.h +const char *wxFloatToStringStr = "%.2f"; +const char *wxDoubleToStringStr = "%.2f"; + +#if USE_POSTSCRIPT +wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL; +#endif + +///// Event tables (also must be in one, statically-linked file for shared libraries) + +// This is the base, wxEvtHandler 'bootstrap' code which is expanded manually here +const wxEventTable *wxEvtHandler::GetEventTable() const { return &wxEvtHandler::sm_eventTable; } + +const wxEventTable wxEvtHandler::sm_eventTable = + { NULL, &wxEvtHandler::sm_eventTableEntries[0] }; + +const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = { { 0, 0, 0, NULL } }; + +const wxSize wxDefaultSize(-1, -1); +const wxPoint wxDefaultPosition(-1, -1); diff --git a/src/stubs/dc.cpp b/src/stubs/dc.cpp new file mode 100644 index 0000000000..4cfe7305cc --- /dev/null +++ b/src/stubs/dc.cpp @@ -0,0 +1,392 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dc.cpp +// Purpose: wxDC class +// Author: AUTHOR +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dc.h" +#endif + +#include "wx/dc.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject) +#endif + +//----------------------------------------------------------------------------- +// constants +//----------------------------------------------------------------------------- + +#define mm2inches 0.0393700787402 +#define inches2mm 25.4 +#define mm2twips 56.6929133859 +#define twips2mm 0.0176388888889 +#define mm2pt 2.83464566929 +#define pt2mm 0.352777777778 + +//----------------------------------------------------------------------------- +// wxDC +//----------------------------------------------------------------------------- + +IMPLEMENT_ABSTRACT_CLASS(wxDC,wxObject) + +wxDC::wxDC(void) +{ + m_ok = FALSE; + m_optimize = FALSE; + m_autoSetting = FALSE; + m_colour = TRUE; + m_clipping = FALSE; + + m_mm_to_pix_x = 1.0; + m_mm_to_pix_y = 1.0; + + m_logicalOriginX = 0; + m_logicalOriginY = 0; + m_deviceOriginX = 0; + m_deviceOriginY = 0; + m_internalDeviceOriginX = 0; + m_internalDeviceOriginY = 0; + m_externalDeviceOriginX = 0; + m_externalDeviceOriginY = 0; + + m_logicalScaleX = 1.0; + m_logicalScaleY = 1.0; + m_userScaleX = 1.0; + m_userScaleY = 1.0; + m_scaleX = 1.0; + m_scaleY = 1.0; + + m_mappingMode = MM_TEXT; + m_needComputeScaleX = FALSE; + m_needComputeScaleY = FALSE; + + m_signX = 1; // default x-axis left to right + m_signY = 1; // default y-axis top down + + m_maxX = m_maxY = -100000; + m_minY = m_minY = 100000; + + m_logicalFunction = wxCOPY; +// m_textAlignment = wxALIGN_TOP_LEFT; + m_backgroundMode = wxTRANSPARENT; + + m_textForegroundColour = *wxBLACK; + m_textBackgroundColour = *wxWHITE; + m_pen = *wxBLACK_PEN; + m_font = *wxNORMAL_FONT; + m_brush = *wxTRANSPARENT_BRUSH; + m_backgroundBrush = *wxWHITE_BRUSH; + +// m_palette = wxAPP_COLOURMAP; +}; + +wxDC::~wxDC(void) +{ +}; + +void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) ) +{ +}; + +void wxDC::DrawPoint( wxPoint& point ) +{ + DrawPoint( point.x, point.y ); +}; + +void wxDC::DrawPolygon( wxList *list, long xoffset, long yoffset, int fillStyle ) +{ + int n = list->Number(); + wxPoint *points = new wxPoint[n]; + + int i = 0; + for( wxNode *node = list->First(); node; node = node->Next() ) + { + wxPoint *point = (wxPoint *)node->Data(); + points[i].x = point->x; + points[i++].y = point->y; + }; + DrawPolygon( n, points, xoffset, yoffset, fillStyle ); + delete[] points; +}; + +void wxDC::DrawLines( wxList *list, long xoffset, long yoffset ) +{ + int n = list->Number(); + wxPoint *points = new wxPoint[n]; + + int i = 0; + for( wxNode *node = list->First(); node; node = node->Next() ) + { + wxPoint *point = (wxPoint *)node->Data(); + points[i].x = point->x; + points[i++].y = point->y; + }; + DrawLines( n, points, xoffset, yoffset ); + delete []points; +}; + +void wxDC::DrawSpline( long x1, long y1, long x2, long y2, long x3, long y3 ) +{ + wxList list; + list.Append( (wxObject*)new wxPoint(x1, y1) ); + list.Append( (wxObject*)new wxPoint(x2, y2) ); + list.Append( (wxObject*)new wxPoint(x3, y3) ); + DrawSpline(&list); + wxNode *node = list.First(); + while (node) + { + wxPoint *p = (wxPoint*)node->Data(); + delete p; + node = node->Next(); + }; +}; + +void wxDC::DrawSpline( wxList *points ) +{ + DrawOpenSpline( points ); +}; + +void wxDC::DrawSpline( int n, wxPoint points[] ) +{ + wxList list; + for (int i = 0; i < n; i++) list.Append( (wxObject*)&points[i] ); + DrawSpline( &list ); +}; + +void wxDC::SetClippingRegion( long x, long y, long width, long height ) +{ + m_clipping = TRUE; + m_clipX1 = x; + m_clipY1 = y; + m_clipX2 = x + width; + m_clipY2 = y + height; +}; + +void wxDC::DestroyClippingRegion(void) +{ + m_clipping = FALSE; +}; + +void wxDC::GetClippingBox( long *x, long *y, long *width, long *height ) const +{ + if (m_clipping) + { + if (x) *x = m_clipX1; + if (y) *y = m_clipY1; + if (width) *width = (m_clipX2 - m_clipX1); + if (height) *height = (m_clipY2 - m_clipY1); + } + else + *x = *y = *width = *height = 0; +}; + +void wxDC::GetSize( int* width, int* height ) const +{ + *width = m_maxX-m_minX; + *height = m_maxY-m_minY; +}; + +void wxDC::GetSizeMM( long* width, long* height ) const +{ + int w = 0; + int h = 0; + GetSize( &w, &h ); + *width = long( double(w) / (m_scaleX*m_mm_to_pix_x) ); + *height = long( double(h) / (m_scaleY*m_mm_to_pix_y) ); +}; + +void wxDC::SetTextForeground( const wxColour &col ) +{ + if (!Ok()) return; + m_textForegroundColour = col; +}; + +void wxDC::SetTextBackground( const wxColour &col ) +{ + if (!Ok()) return; + m_textBackgroundColour = col; +}; + +void wxDC::SetMapMode( int mode ) +{ + switch (mode) + { + case MM_TWIPS: + SetLogicalScale( twips2mm*m_mm_to_pix_x, twips2mm*m_mm_to_pix_y ); + break; + case MM_POINTS: + SetLogicalScale( pt2mm*m_mm_to_pix_x, pt2mm*m_mm_to_pix_y ); + break; + case MM_METRIC: + SetLogicalScale( m_mm_to_pix_x, m_mm_to_pix_y ); + break; + case MM_LOMETRIC: + SetLogicalScale( m_mm_to_pix_x/10.0, m_mm_to_pix_y/10.0 ); + break; + default: + case MM_TEXT: + SetLogicalScale( 1.0, 1.0 ); + break; + }; + if (mode != MM_TEXT) + { + m_needComputeScaleX = TRUE; + m_needComputeScaleY = TRUE; + }; +}; + +void wxDC::SetUserScale( double x, double y ) +{ + // allow negative ? -> no + m_userScaleX = x; + m_userScaleY = y; + ComputeScaleAndOrigin(); +}; + +void wxDC::GetUserScale( double *x, double *y ) +{ + if (x) *x = m_userScaleX; + if (y) *y = m_userScaleY; +}; + +void wxDC::SetLogicalScale( double x, double y ) +{ + // allow negative ? + m_logicalScaleX = x; + m_logicalScaleY = y; + ComputeScaleAndOrigin(); +}; + +void wxDC::GetLogicalScale( double *x, double *y ) +{ + if (x) *x = m_logicalScaleX; + if (y) *y = m_logicalScaleY; +}; + +void wxDC::SetLogicalOrigin( long x, long y ) +{ + m_logicalOriginX = x * m_signX; // is this still correct ? + m_logicalOriginY = y * m_signY; + ComputeScaleAndOrigin(); +}; + +void wxDC::GetLogicalOrigin( long *x, long *y ) +{ + if (x) *x = m_logicalOriginX; + if (y) *y = m_logicalOriginY; +}; + +void wxDC::SetDeviceOrigin( long x, long y ) +{ + m_externalDeviceOriginX = x; + m_externalDeviceOriginY = y; + ComputeScaleAndOrigin(); +}; + +void wxDC::GetDeviceOrigin( long *x, long *y ) +{ +// if (x) *x = m_externalDeviceOriginX; +// if (y) *y = m_externalDeviceOriginY; + if (x) *x = m_deviceOriginX; + if (y) *y = m_deviceOriginY; +}; + +void wxDC::SetInternalDeviceOrigin( long x, long y ) +{ + m_internalDeviceOriginX = x; + m_internalDeviceOriginY = y; + ComputeScaleAndOrigin(); +}; + +void wxDC::GetInternalDeviceOrigin( long *x, long *y ) +{ + if (x) *x = m_internalDeviceOriginX; + if (y) *y = m_internalDeviceOriginY; +}; + +void wxDC::SetAxisOrientation( bool xLeftRight, bool yBottomUp ) +{ + m_signX = (xLeftRight ? 1 : -1); + m_signY = (yBottomUp ? -1 : 1); + ComputeScaleAndOrigin(); +}; + +long wxDC::DeviceToLogicalX(long x) const +{ + return XDEV2LOG(x); +}; + +long wxDC::DeviceToLogicalY(long y) const +{ + return YDEV2LOG(y); +}; + +long wxDC::DeviceToLogicalXRel(long x) const +{ + return XDEV2LOGREL(x); +}; + +long wxDC::DeviceToLogicalYRel(long y) const +{ + return YDEV2LOGREL(y); +}; + +long wxDC::LogicalToDeviceX(long x) const +{ + return XLOG2DEV(x); +}; + +long wxDC::LogicalToDeviceY(long y) const +{ + return YLOG2DEV(y); +}; + +long wxDC::LogicalToDeviceXRel(long x) const +{ + return XLOG2DEVREL(x); +}; + +long wxDC::LogicalToDeviceYRel(long y) const +{ + return YLOG2DEVREL(y); +}; + +void wxDC::CalcBoundingBox( long x, long y ) +{ + if (x < m_minX) m_minX = x; + if (y < m_minY) m_minY = y; + if (x > m_maxX) m_maxX = x; + if (y > m_maxY) m_maxY = y; +}; + +void wxDC::ComputeScaleAndOrigin(void) +{ + // CMB: copy scale to see if it changes + double origScaleX = m_scaleX; + double origScaleY = m_scaleY; + + m_scaleX = m_logicalScaleX * m_userScaleX; + m_scaleY = m_logicalScaleY * m_userScaleY; + + m_deviceOriginX = m_internalDeviceOriginX + m_externalDeviceOriginX; + m_deviceOriginY = m_internalDeviceOriginY + m_externalDeviceOriginY; + + // CMB: if scale has changed call SetPen to recalulate the line width + if (m_scaleX != origScaleX || m_scaleY != origScaleY) + { + // this is a bit artificial, but we need to force wxDC to think + // the pen has changed + wxPen* pen = GetPen(); + wxPen tempPen; + m_pen = tempPen; + SetPen(pen); + } +}; + diff --git a/src/stubs/dcclient.cpp b/src/stubs/dcclient.cpp new file mode 100644 index 0000000000..e25920d94f --- /dev/null +++ b/src/stubs/dcclient.cpp @@ -0,0 +1,620 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcclient.cpp +// Purpose: wxClientDC class +// Author: AUTHOR +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dcclient.h" +#endif + +#include "wx/dcclient.h" +#include "wx/dcmemory.h" +#include + +//----------------------------------------------------------------------------- +// constants +//----------------------------------------------------------------------------- + +#define RAD2DEG 57.2957795131 + +//----------------------------------------------------------------------------- +// wxPaintDC +//----------------------------------------------------------------------------- + +#if !USE_SHARED_LIBRARY +//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC) +//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC) +IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC) +#endif + + +wxPaintDC::wxPaintDC(void) +{ +}; + +wxPaintDC::wxPaintDC( wxWindow *window ) +{ +}; + +wxPaintDC::~wxPaintDC(void) +{ +}; + +void wxPaintDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), + wxColour *WXUNUSED(col), int WXUNUSED(style) ) +{ +}; + +bool wxPaintDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const +{ + return FALSE; +}; + +void wxPaintDC::DrawLine( long x1, long y1, long x2, long y2 ) +{ + if (!Ok()) return; + +}; + +void wxPaintDC::CrossHair( long x, long y ) +{ + if (!Ok()) return; + +}; + +void wxPaintDC::DrawArc( long x1, long y1, long x2, long y2, double xc, double yc ) +{ + if (!Ok()) return; + + long xx1 = XLOG2DEV(x1); + long yy1 = YLOG2DEV(y1); + long xx2 = XLOG2DEV(x2); + long yy2 = YLOG2DEV(y2); + long xxc = XLOG2DEV((long)xc); + long yyc = YLOG2DEV((long)yc); + double dx = xx1 - xxc; + double dy = yy1 - yyc; + double radius = sqrt(dx*dx+dy*dy); + long r = (long)radius; + double radius1, radius2; + + if (xx1 == xx2 && yy1 == yy2) + { + radius1 = 0.0; + radius2 = 360.0; + } + else + if (radius == 0.0) + { + radius1 = radius2 = 0.0; + } + else + { + radius1 = (xx1 - xxc == 0) ? + (yy1 - yyc < 0) ? 90.0 : -90.0 : + -atan2(double(yy1-yyc), double(xx1-xxc)) * RAD2DEG; + radius2 = (xx2 - xxc == 0) ? + (yy2 - yyc < 0) ? 90.0 : -90.0 : + -atan2(double(yy2-yyc), double(xx2-xxc)) * RAD2DEG; + }; + long alpha1 = long(radius1 * 64.0); + long alpha2 = long((radius2 - radius1) * 64.0); + while (alpha2 <= 0) alpha2 += 360*64; + while (alpha1 > 360*64) alpha1 -= 360*64; + + if (m_brush.GetStyle() != wxTRANSPARENT) {}; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; + +}; + +void wxPaintDC::DrawEllipticArc( long x, long y, long width, long height, double sa, double ea ) +{ + if (!Ok()) return; + + long xx = XLOG2DEV(x); + long yy = YLOG2DEV(y); + long ww = m_signX * XLOG2DEVREL(width); + long hh = m_signY * YLOG2DEVREL(height); + + // CMB: handle -ve width and/or height + if (ww < 0) { ww = -ww; xx = xx - ww; } + if (hh < 0) { hh = -hh; yy = yy - hh; } + + long start = long(sa * 64.0); + long end = long(ea * 64.0); + if (m_brush.GetStyle() != wxTRANSPARENT) {}; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +void wxPaintDC::DrawPoint( long x, long y ) +{ + if (!Ok()) return; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +void wxPaintDC::DrawLines( int n, wxPoint points[], long xoffset, long yoffset ) +{ + if (!Ok()) return; + + if (m_pen.GetStyle() == wxTRANSPARENT) return; + + for (int i = 0; i < n-1; i++) + { + long x1 = XLOG2DEV(points[i].x + xoffset); + long x2 = XLOG2DEV(points[i+1].x + xoffset); + long y1 = YLOG2DEV(points[i].y + yoffset); // oh, what a waste + long y2 = YLOG2DEV(points[i+1].y + yoffset); + }; +}; + +void wxPaintDC::DrawLines( wxList *points, long xoffset, long yoffset ) +{ + if (!Ok()) return; + + if (m_pen.GetStyle() == wxTRANSPARENT) return; + + wxNode *node = points->First(); + while (node->Next()) + { + wxPoint *point = (wxPoint*)node->Data(); + wxPoint *npoint = (wxPoint*)node->Next()->Data(); + long x1 = XLOG2DEV(point->x + xoffset); + long x2 = XLOG2DEV(npoint->x + xoffset); + long y1 = YLOG2DEV(point->y + yoffset); // and again... + long y2 = YLOG2DEV(npoint->y + yoffset); + node = node->Next(); + }; +}; + +void wxPaintDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[], + long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxPaintDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset), + long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxPaintDC::DrawRectangle( long x, long y, long width, long height ) +{ + if (!Ok()) return; + + long xx = XLOG2DEV(x); + long yy = YLOG2DEV(y); + long ww = m_signX * XLOG2DEVREL(width); + long hh = m_signY * YLOG2DEVREL(height); + + // CMB: draw nothing if transformed w or h is 0 + if (ww == 0 || hh == 0) return; + + // CMB: handle -ve width and/or height + if (ww < 0) { ww = -ww; xx = xx - ww; } + if (hh < 0) { hh = -hh; yy = yy - hh; } + + if (m_brush.GetStyle() != wxTRANSPARENT) {}; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +void wxPaintDC::DrawRoundedRectangle( long x, long y, long width, long height, double radius ) +{ + if (!Ok()) return; + + if (radius < 0.0) radius = - radius * ((width < height) ? width : height); + + long xx = XLOG2DEV(x); + long yy = YLOG2DEV(y); + long ww = m_signX * XLOG2DEVREL(width); + long hh = m_signY * YLOG2DEVREL(height); + long rr = XLOG2DEVREL((long)radius); + + // CMB: handle -ve width and/or height + if (ww < 0) { ww = -ww; xx = xx - ww; } + if (hh < 0) { hh = -hh; yy = yy - hh; } + + // CMB: if radius is zero use DrawRectangle() instead to avoid + // X drawing errors with small radii + if (rr == 0) + { + DrawRectangle( x, y, width, height ); + return; + } + + // CMB: draw nothing if transformed w or h is 0 + if (ww == 0 || hh == 0) return; + + // CMB: adjust size if outline is drawn otherwise the result is + // 1 pixel too wide and high + if (m_pen.GetStyle() != wxTRANSPARENT) + { + ww--; + hh--; + } + + // CMB: ensure dd is not larger than rectangle otherwise we + // get an hour glass shape + long dd = 2 * rr; + if (dd > ww) dd = ww; + if (dd > hh) dd = hh; + rr = dd / 2; + + if (m_brush.GetStyle() != wxTRANSPARENT) + { + }; + + if (m_pen.GetStyle() != wxTRANSPARENT) + { + }; +}; + +void wxPaintDC::DrawEllipse( long x, long y, long width, long height ) +{ + if (!Ok()) return; + + long xx = XLOG2DEV(x); + long yy = YLOG2DEV(y); + long ww = m_signX * XLOG2DEVREL(width); + long hh = m_signY * YLOG2DEVREL(height); + + // CMB: handle -ve width and/or height + if (ww < 0) { ww = -ww; xx = xx - ww; } + if (hh < 0) { hh = -hh; yy = yy - hh; } + + if (m_brush.GetStyle() != wxTRANSPARENT) {}; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +bool wxPaintDC::CanDrawBitmap(void) const +{ + return TRUE; +}; + +void wxPaintDC::DrawIcon( const wxIcon &icon, long x, long y, bool useMask ) +{ + if (!Ok()) return; + + if (!icon.Ok()) return; + + int xx = XLOG2DEV(x); + int yy = YLOG2DEV(y); + +}; + +bool wxPaintDC::Blit( long xdest, long ydest, long width, long height, + wxDC *source, long xsrc, long ysrc, int WXUNUSED(logical_func), bool WXUNUSED(useMask) ) +{ + if (!Ok()) return FALSE; + + // CMB 20/5/98: add blitting of bitmaps + if (source->IsKindOf(CLASSINFO(wxMemoryDC))) + { + wxMemoryDC* srcDC = (wxMemoryDC*)source; + /* + GdkBitmap* bmap = srcDC->m_selected.GetBitmap(); + if (bmap) + { + gdk_draw_bitmap ( + m_window, + m_textGC, + bmap, + source->DeviceToLogicalX(xsrc), source->DeviceToLogicalY(ysrc), + XLOG2DEV(xdest), YLOG2DEV(ydest), + source->DeviceToLogicalXRel(width), source->DeviceToLogicalYRel(height) + ); + return TRUE; + } + */ + } + + return TRUE; +}; + +void wxPaintDC::DrawText( const wxString &text, long x, long y, bool +WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + + + +bool wxPaintDC::CanGetTextExtent(void) const +{ + return TRUE; +}; + +void wxPaintDC::GetTextExtent( const wxString &string, long *width, long *height, + long *WXUNUSED(descent), long *WXUNUSED(externalLeading), + wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + +long wxPaintDC::GetCharWidth(void) +{ + if (!Ok()) return 0; + +}; + +long wxPaintDC::GetCharHeight(void) +{ + if (!Ok()) return 0; + +}; + +void wxPaintDC::Clear(void) +{ + if (!Ok()) return; + +}; + +void wxPaintDC::SetFont( const wxFont &font ) +{ + if (!Ok()) return; + + m_font = font; +}; + +void wxPaintDC::SetPen( const wxPen &pen ) +{ + if (!Ok()) return; + + if (m_pen == pen) return; + + m_pen = pen; + + if (!m_pen.Ok()) return; +}; + +void wxPaintDC::SetBrush( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_brush == brush) return; + + m_brush = brush; + + if (!m_brush.Ok()) return; + +}; + +void wxPaintDC::SetBackground( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_backgroundBrush == brush) return; + + m_backgroundBrush = brush; + + if (!m_backgroundBrush.Ok()) return; + +}; + +void wxPaintDC::SetLogicalFunction( int function ) +{ + if (m_logicalFunction == function) return; +}; + +void wxPaintDC::SetTextForeground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textForegroundColour == col) return; + + m_textForegroundColour = col; + if (!m_textForegroundColour.Ok()) return; +}; + +void wxPaintDC::SetTextBackground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textBackgroundColour == col) return; + + m_textBackgroundColour = col; + if (!m_textBackgroundColour.Ok()) return; +}; + +void wxPaintDC::SetBackgroundMode( int mode ) +{ + m_backgroundMode = mode; + + if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT) + { + } +}; + +void wxPaintDC::SetPalette( const wxPalette& WXUNUSED(palette) ) +{ +}; + +void wxPaintDC::SetClippingRegion( long x, long y, long width, long height ) +{ + wxDC::SetClippingRegion( x, y, width, height ); + +}; + +void wxPaintDC::DestroyClippingRegion(void) +{ + wxDC::DestroyClippingRegion(); + +}; + +// ----------------------------------- spline code ---------------------------------------- + +void wx_quadratic_spline(double a1, double b1, double a2, double b2, + double a3, double b3, double a4, double b4); +void wx_clear_stack(void); +int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3, + double *y3, double *x4, double *y4); +void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, + double x4, double y4); +static bool wx_spline_add_point(double x, double y); +static void wx_spline_draw_point_array(wxDC *dc); + +wxList wx_spline_point_list; + +#define half(z1, z2) ((z1+z2)/2.0) +#define THRESHOLD 5 + +/* iterative version */ + +void wx_quadratic_spline(double a1, double b1, double a2, double b2, double a3, double b3, double a4, + double b4) +{ + register double xmid, ymid; + double x1, y1, x2, y2, x3, y3, x4, y4; + + wx_clear_stack(); + wx_spline_push(a1, b1, a2, b2, a3, b3, a4, b4); + + while (wx_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)) { + xmid = (double)half(x2, x3); + ymid = (double)half(y2, y3); + if (fabs(x1 - xmid) < THRESHOLD && fabs(y1 - ymid) < THRESHOLD && + fabs(xmid - x4) < THRESHOLD && fabs(ymid - y4) < THRESHOLD) { + wx_spline_add_point( x1, y1 ); + wx_spline_add_point( xmid, ymid ); + } else { + wx_spline_push(xmid, ymid, (double)half(xmid, x3), (double)half(ymid, y3), + (double)half(x3, x4), (double)half(y3, y4), x4, y4); + wx_spline_push(x1, y1, (double)half(x1, x2), (double)half(y1, y2), + (double)half(x2, xmid), (double)half(y2, ymid), xmid, ymid); + } + } +} + +/* utilities used by spline drawing routines */ + +typedef struct wx_spline_stack_struct { + double x1, y1, x2, y2, x3, y3, x4, y4; +} Stack; + +#define SPLINE_STACK_DEPTH 20 +static Stack wx_spline_stack[SPLINE_STACK_DEPTH]; +static Stack *wx_stack_top; +static int wx_stack_count; + +void wx_clear_stack(void) +{ + wx_stack_top = wx_spline_stack; + wx_stack_count = 0; +} + +void wx_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) +{ + wx_stack_top->x1 = x1; + wx_stack_top->y1 = y1; + wx_stack_top->x2 = x2; + wx_stack_top->y2 = y2; + wx_stack_top->x3 = x3; + wx_stack_top->y3 = y3; + wx_stack_top->x4 = x4; + wx_stack_top->y4 = y4; + wx_stack_top++; + wx_stack_count++; +} + +int wx_spline_pop(double *x1, double *y1, double *x2, double *y2, + double *x3, double *y3, double *x4, double *y4) +{ + if (wx_stack_count == 0) + return (0); + wx_stack_top--; + wx_stack_count--; + *x1 = wx_stack_top->x1; + *y1 = wx_stack_top->y1; + *x2 = wx_stack_top->x2; + *y2 = wx_stack_top->y2; + *x3 = wx_stack_top->x3; + *y3 = wx_stack_top->y3; + *x4 = wx_stack_top->x4; + *y4 = wx_stack_top->y4; + return (1); +} + +static bool wx_spline_add_point(double x, double y) +{ + wxPoint *point = new wxPoint ; + point->x = (int) x; + point->y = (int) y; + wx_spline_point_list.Append((wxObject*)point); + return TRUE; +} + +static void wx_spline_draw_point_array(wxDC *dc) +{ + dc->DrawLines(&wx_spline_point_list, 0, 0 ); + wxNode *node = wx_spline_point_list.First(); + while (node) + { + wxPoint *point = (wxPoint *)node->Data(); + delete point; + delete node; + node = wx_spline_point_list.First(); + } +} + +void wxPaintDC::DrawOpenSpline( wxList *points ) +{ + wxPoint *p; + double cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4; + double x1, y1, x2, y2; + + wxNode *node = points->First(); + p = (wxPoint *)node->Data(); + + x1 = p->x; + y1 = p->y; + + node = node->Next(); + p = (wxPoint *)node->Data(); + + x2 = p->x; + y2 = p->y; + cx1 = (double)((x1 + x2) / 2); + cy1 = (double)((y1 + y2) / 2); + cx2 = (double)((cx1 + x2) / 2); + cy2 = (double)((cy1 + y2) / 2); + + wx_spline_add_point(x1, y1); + + while ((node = node->Next()) != NULL) + { + p = (wxPoint *)node->Data(); + x1 = x2; + y1 = y2; + x2 = p->x; + y2 = p->y; + cx4 = (double)(x1 + x2) / 2; + cy4 = (double)(y1 + y2) / 2; + cx3 = (double)(x1 + cx4) / 2; + cy3 = (double)(y1 + cy4) / 2; + + wx_quadratic_spline(cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4); + + cx1 = cx4; + cy1 = cy4; + cx2 = (double)(cx1 + x2) / 2; + cy2 = (double)(cy1 + y2) / 2; + } + + wx_spline_add_point( cx1, cy1 ); + wx_spline_add_point( x2, y2 ); + + wx_spline_draw_point_array( this ); +}; diff --git a/src/stubs/dcmemory.cpp b/src/stubs/dcmemory.cpp new file mode 100644 index 0000000000..c6066bb1ab --- /dev/null +++ b/src/stubs/dcmemory.cpp @@ -0,0 +1,68 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcmemory.cpp +// Purpose: wxMemoryDC class +// Author: AUTHOR +// Modified by: +// Created: 01/02/97 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dcmemory.h" +#endif + +#include "wx/dcmemory.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC) +#endif + +//----------------------------------------------------------------------------- +// wxMemoryDC +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC,wxPaintDC) + +wxMemoryDC::wxMemoryDC(void) +{ + m_ok = FALSE; +}; + +wxMemoryDC::wxMemoryDC( wxDC *WXUNUSED(dc) ) +{ + m_ok = FALSE; +}; + +wxMemoryDC::~wxMemoryDC(void) +{ +}; + +void wxMemoryDC::SelectObject( const wxBitmap& bitmap ) +{ + m_selected = bitmap; + if (m_selected.Ok()) + { + } + else + { + m_ok = FALSE; + }; +}; + +void wxMemoryDC::GetSize( int *width, int *height ) const +{ + if (m_selected.Ok()) + { + if (width) (*width) = m_selected.GetWidth(); + if (height) (*height) = m_selected.GetHeight(); + } + else + { + if (width) (*width) = 0; + if (height) (*height) = 0; + }; +}; + + diff --git a/src/stubs/dcscreen.cpp b/src/stubs/dcscreen.cpp new file mode 100644 index 0000000000..04bbf4f353 --- /dev/null +++ b/src/stubs/dcscreen.cpp @@ -0,0 +1,32 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dcscreen.cpp +// Purpose: wxScreenDC class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dcscreen.h" +#endif + +#include "wx/dcscreen.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxPaintDC) +#endif + +// Create a DC representing the whole screen +wxScreenDC::wxScreenDC() +{ + // TODO +} + +wxScreenDC::~wxScreenDC() +{ + // TODO +} + diff --git a/src/stubs/dialog.cpp b/src/stubs/dialog.cpp new file mode 100644 index 0000000000..9b72fb0f69 --- /dev/null +++ b/src/stubs/dialog.cpp @@ -0,0 +1,294 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dialog.cpp +// Purpose: wxDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dialog.h" +#endif + +#include "wx/dialog.h" +#include "wx/utils.h" +#include "wx/frame.h" +#include "wx/app.h" +#include "wx/settings.h" + +// Lists to keep track of windows, so we can disable/enable them +// for modal dialogs +wxList wxModalDialogs; +wxList wxModelessWindows; // Frames and modeless dialogs +extern wxList wxPendingDelete; + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel) + +BEGIN_EVENT_TABLE(wxDialog, wxPanel) + EVT_BUTTON(wxID_OK, wxDialog::OnOK) + EVT_BUTTON(wxID_APPLY, wxDialog::OnApply) + EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel) + EVT_CHAR_HOOK(wxDialog::OnCharHook) + EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged) + EVT_CLOSE(wxDialog::OnCloseWindow) +END_EVENT_TABLE() + +#endif + +wxDialog::wxDialog() +{ + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); +} + +bool wxDialog::Create(wxWindow *parent, wxWindowID id, + const wxString& title, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + m_windowStyle = style; + + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); + SetName(name); + + if (!parent) + wxTopLevelWindows.Append(this); + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + // TODO: create dialog + + return FALSE; +} + +void wxDialog::SetModal(bool flag) +{ + if ( flag ) + m_windowStyle |= wxDIALOG_MODAL ; + else + if ( m_windowStyle & wxDIALOG_MODAL ) + m_windowStyle -= wxDIALOG_MODAL ; + + wxModelessWindows.DeleteObject(this); + if (!flag) + wxModelessWindows.Append(this); +} + +wxDialog::~wxDialog() +{ + // TODO + wxTopLevelWindows.DeleteObject(this); + + if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL ) + wxModelessWindows.DeleteObject(this); + + // If this is the last top-level window, exit. + if (wxTheApp && (wxTopLevelWindows.Number() == 0)) + { + wxTheApp->SetTopWindow(NULL); + + if (wxTheApp->GetExitOnFrameDelete()) + { + // TODO: exit + } + } +} + +// By default, pressing escape cancels the dialog +void wxDialog::OnCharHook(wxKeyEvent& event) +{ + if (GetHWND()) + { + if (event.m_keyCode == WXK_ESCAPE) + { + // Behaviour changed in 2.0: we'll send a Cancel message + // to the dialog instead of Close. + wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); + cancelEvent.SetEventObject( this ); + GetEventHandler()->ProcessEvent(cancelEvent); + + return; + } + } + // We didn't process this event. + event.Skip(); +} + +void wxDialog::Iconize(bool WXUNUSED(iconize)) +{ + // TODO +} + +bool wxDialog::IsIconized() const +{ + // TODO + return FALSE; +} + +void wxDialog::SetClientSize(int width, int height) +{ + // TODO +} + +void wxDialog::GetPosition(int *x, int *y) const +{ + // TODO +} + +bool wxDialog::Show(bool show) +{ + // TODO + return FALSE; +} + +void wxDialog::SetTitle(const wxString& title) +{ + // TODO +} + +wxString wxDialog::GetTitle() const +{ + // TODO + return wxString(""); +} + +void wxDialog::Centre(int direction) +{ + int x_offset,y_offset ; + int display_width, display_height; + int width, height, x, y; + wxFrame *frame ; + if (direction & wxCENTER_FRAME) + { + frame = (wxFrame*)GetParent() ; + if (frame) + { + frame->GetPosition(&x_offset,&y_offset) ; + frame->GetSize(&display_width,&display_height) ; + } + } + else + frame = NULL ; + + if (frame==NULL) + { + wxDisplaySize(&display_width, &display_height); + x_offset = 0 ; + y_offset = 0 ; + } + + GetSize(&width, &height); + GetPosition(&x, &y); + + if (direction & wxHORIZONTAL) + x = (int)((display_width - width)/2); + if (direction & wxVERTICAL) + y = (int)((display_height - height)/2); + + SetSize(x+x_offset, y+y_offset, width, height); +} + +// Replacement for Show(TRUE) for modal dialogs - returns return code +int wxDialog::ShowModal() +{ + m_windowStyle |= wxDIALOG_MODAL; + // TODO: modal showing + Show(TRUE); + return GetReturnCode(); +} + +void wxDialog::EndModal(int retCode) +{ + SetReturnCode(retCode); + // TODO modal un-showing + Show(FALSE); +} + +// Standard buttons +void wxDialog::OnOK(wxCommandEvent& event) +{ + if ( Validate() && TransferDataFromWindow() ) + { + if ( IsModal() ) + EndModal(wxID_OK); + else + { + SetReturnCode(wxID_OK); + this->Show(FALSE); + } + } +} + +void wxDialog::OnApply(wxCommandEvent& event) +{ + if (Validate()) + TransferDataFromWindow(); + // TODO probably need to disable the Apply button until things change again +} + +void wxDialog::OnCancel(wxCommandEvent& event) +{ + if ( IsModal() ) + EndModal(wxID_CANCEL); + else + { + SetReturnCode(wxID_CANCEL); + this->Show(FALSE); + } +} + +bool wxDialog::OnClose() +{ + // Behaviour changed in 2.0: we'll send a Cancel message by default, + // which may close the dialog. + // Check for looping if the Cancel event handler calls Close() + + static wxList closing; + + if ( closing.Member(this) ) + return FALSE; + + closing.Append(this); + + wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); + cancelEvent.SetEventObject( this ); + GetEventHandler()->ProcessEvent(cancelEvent); + + closing.DeleteObject(this); + + return FALSE; +} + +void wxDialog::OnCloseWindow(wxCloseEvent& event) +{ + // Compatibility + if ( GetEventHandler()->OnClose() || event.GetForce()) + { + this->Destroy(); + } +} + +// Destroy the window (delayed, if a managed window) +bool wxDialog::Destroy() +{ + if (!wxPendingDelete.Member(this)) + wxPendingDelete.Append(this); + return TRUE; +} + +void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event) +{ + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); + Refresh(); +} + diff --git a/src/stubs/dirdlg.cpp b/src/stubs/dirdlg.cpp new file mode 100644 index 0000000000..7fe15310ee --- /dev/null +++ b/src/stubs/dirdlg.cpp @@ -0,0 +1,43 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: dirdlg.cpp +// Purpose: wxDirDialog +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dirdlg.h" +#endif + +#include "wx/defs.h" +#include "wx/utils.h" +#include "wx/dialog.h" +#include "wx/dirdlg.h" +#endif + +#include "wx/cmndata.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_CLASS(wxDirDialog, wxDialog) +#endif + +wxDirDialog::wxDirDialog(wxWindow *parent, const wxString& message, + const wxString& defaultPath, + long style, const wxPoint& pos) +{ + m_message = message; + m_dialogStyle = style; + m_parent = parent; + m_path = defaultPath; +} + +int wxDirDialog::ShowModal() +{ + // TODO + return wxID_CANCEL; +} + diff --git a/src/stubs/dnd.cpp b/src/stubs/dnd.cpp new file mode 100644 index 0000000000..ec82cb6dc1 --- /dev/null +++ b/src/stubs/dnd.cpp @@ -0,0 +1,133 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: dnd.cpp +// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) 1998 AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "dnd.h" +#endif + +#include "wx/dnd.h" +#include "wx/window.h" +#include "wx/app.h" +#include "wx/gdicmn.h" + +// ---------------------------------------------------------------------------- +// global +// ---------------------------------------------------------------------------- + +// ---------------------------------------------------------------------------- +// wxDropTarget +// ---------------------------------------------------------------------------- + +wxDropTarget::wxDropTarget() +{ +}; + +wxDropTarget::~wxDropTarget() +{ +}; + +// ---------------------------------------------------------------------------- +// wxTextDropTarget +// ---------------------------------------------------------------------------- + +bool wxTextDropTarget::OnDrop( long x, long y, const void *pData ) +{ + OnDropText( x, y, (const char*)pData ); + return TRUE; +}; + +bool wxTextDropTarget::OnDropText( long x, long y, const char *psz ) +{ + printf( "Got dropped text: %s.\n", psz ); + printf( "At x: %d, y: %d.\n", (int)x, (int)y ); + return TRUE; +}; + +size_t wxTextDropTarget::GetFormatCount() const +{ + return 1; +} + +wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const +{ + return wxDF_TEXT; +} + +// ---------------------------------------------------------------------------- +// wxFileDropTarget +// ---------------------------------------------------------------------------- + +bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] ) +{ + printf( "Got %d dropped files.\n", (int)nFiles ); + printf( "At x: %d, y: %d.\n", (int)x, (int)y ); + return TRUE; +} + +bool wxFileDropTarget::OnDrop(long x, long y, const void *WXUNUSED(pData) ) +{ + char *str = "/this/is/a/path.txt"; + + return OnDropFiles(x, y, 1, &str ); +} + +size_t wxFileDropTarget::GetFormatCount() const +{ + return 1; +} + +wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const +{ + return wxDF_FILENAME; +} + +//------------------------------------------------------------------------- +// wxDropSource +//------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// drag request + +wxDropSource::wxDropSource( wxWindow *win ) +{ + // TODO + m_window = win; + m_data = NULL; + + m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY ); + m_goaheadCursor = wxCursor( wxCURSOR_HAND ); +}; + +wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win ) +{ + // TODO + m_window = win; + m_data = &data; + + m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY ); + m_goaheadCursor = wxCursor( wxCURSOR_HAND ); +}; + +void wxDropSource::SetData( wxDataObject &data ) +{ + m_data = &data; +}; + +wxDropSource::~wxDropSource(void) +{ +}; + +wxDropSource::DragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) ) +{ + // TODO + return Error; +}; + diff --git a/src/stubs/filedlg.cpp b/src/stubs/filedlg.cpp new file mode 100644 index 0000000000..cf096037d6 --- /dev/null +++ b/src/stubs/filedlg.cpp @@ -0,0 +1,142 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: filedlg.cpp +// Purpose: wxFileDialog +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "filedlg.h" +#endif + +#include "wx/defs.h" +#include "wx/utils.h" +#include "wx/dialog.h" +#include "wx/filedlg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_CLASS(wxFileDialog, wxDialog) +#endif + +char *wxFileSelector(const char *title, + const char *defaultDir, const char *defaultFileName, + const char *defaultExtension, const char *filter, int flags, + wxWindow *parent, int x, int y) +{ + // If there's a default extension specified but no filter, we create a suitable + // filter. + + wxString filter2(""); + if ( defaultExtension && !filter ) + filter2 = wxString("*.") + wxString(defaultExtension) ; + else if ( filter ) + filter2 = filter; + + wxString defaultDirString; + if (defaultDir) + defaultDirString = defaultDir; + else + defaultDirString = ""; + + wxString defaultFilenameString; + if (defaultFileName) + defaultFilenameString = defaultFileName; + else + defaultFilenameString = ""; + + wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y)); + + if ( fileDialog.ShowModal() == wxID_OK ) + { + strcpy(wxBuffer, (const char *)fileDialog.GetPath()); + return wxBuffer; + } + else + return NULL; +} + +char *wxFileSelectorEx(const char *title, + const char *defaultDir, + const char *defaultFileName, + int* defaultFilterIndex, + const char *filter, + int flags, + wxWindow* parent, + int x, + int y) + +{ + wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "", + defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y)); + + if ( fileDialog.ShowModal() == wxID_OK ) + { + *defaultFilterIndex = fileDialog.GetFilterIndex(); + strcpy(wxBuffer, (const char *)fileDialog.GetPath()); + return wxBuffer; + } + else + return NULL; +} + +wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message, + const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard, + long style, const wxPoint& pos) +{ + m_message = message; + m_dialogStyle = style; + m_parent = parent; + m_path = ""; + m_fileName = defaultFileName; + m_dir = defaultDir; + m_wildCard = wildCard; + m_filterIndex = 1; +} + +int wxFileDialog::ShowModal() +{ + // TODO + wxID_CANCEL; +} + +// Generic file load/save dialog +static char * +wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent) +{ + char *ext = (char *)extension; + + char prompt[50]; + wxString str; + if (load) + str = "Load %s file"; + else + str = "Save %s file"; + sprintf(prompt, wxGetTranslation(str), what); + + if (*ext == '.') ext++; + char wild[60]; + sprintf(wild, "*.%s", ext); + + return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent); +} + +// Generic file load dialog +char * +wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent) +{ + return wxDefaultFileSelector(TRUE, what, extension, default_name, parent); +} + + +// Generic file save dialog +char * +wxSaveFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent) +{ + return wxDefaultFileSelector(FALSE, what, extension, default_name, parent); +} + + diff --git a/src/stubs/font.cpp b/src/stubs/font.cpp new file mode 100644 index 0000000000..5835259696 --- /dev/null +++ b/src/stubs/font.cpp @@ -0,0 +1,241 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: font.cpp +// Purpose: wxFont class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "font.h" +#endif + +#include "wx/font.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#endif + +wxFontRefData::wxFontRefData() +{ + m_style = 0; + m_pointSize = 0; + m_family = 0; + m_style = 0; + m_weight = 0; + m_underlined = 0; + m_faceName = ""; +/* TODO + m_hFont = 0; +*/ +} + +wxFontRefData::wxFontRefData(const wxFontRefData& data) +{ + m_style = data.m_style; + m_pointSize = data.m_pointSize; + m_family = data.m_family; + m_style = data.m_style; + m_weight = data.m_weight; + m_underlined = data.m_underlined; + m_faceName = data.m_faceName; +/* TODO + m_hFont = 0; +*/ +} + +wxFontRefData::~wxFontRefData() +{ + // TODO: delete font data +} + +wxFont::wxFont() +{ + if ( wxTheFontList ) + wxTheFontList->Append(this); +} + +wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) +{ + Create(pointSize, family, style, weight, underlined, faceName); + + if ( wxTheFontList ) + wxTheFontList->Append(this); +} + +bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName) +{ + UnRef(); + m_refData = new wxFontRefData; + + M_FONTDATA->m_family = family; + M_FONTDATA->m_style = style; + M_FONTDATA->m_weight = weight; + M_FONTDATA->m_pointSize = pointSize; + M_FONTDATA->m_underlined = underlined; + M_FONTDATA->m_faceName = faceName; + + RealizeResource(); + + return TRUE; +} + +wxFont::~wxFont() +{ + if (wxTheFontList) + wxTheFontList->DeleteObject(this); +} + +bool wxFont::RealizeResource() +{ + // TODO: create the font (if there is a native font object) + return FALSE; +} + +void wxFont::Unshare() +{ + // Don't change shared data + if (!m_refData) + { + m_refData = new wxFontRefData(); + } + else + { + wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData); + UnRef(); + m_refData = ref; + } +} + +void wxFont::SetPointSize(int pointSize) +{ + Unshare(); + + M_FONTDATA->m_pointSize = pointSize; + + RealizeResource(); +} + +void wxFont::SetFamily(int family) +{ + Unshare(); + + M_FONTDATA->m_family = family; + + RealizeResource(); +} + +void wxFont::SetStyle(int style) +{ + Unshare(); + + M_FONTDATA->m_style = style; + + RealizeResource(); +} + +void wxFont::SetWeight(int weight) +{ + Unshare(); + + M_FONTDATA->m_weight = weight; + + RealizeResource(); +} + +void wxFont::SetFaceName(const wxString& faceName) +{ + Unshare(); + + M_FONTDATA->m_faceName = faceName; + + RealizeResource(); +} + +void wxFont::SetUnderlined(bool underlined) +{ + Unshare(); + + M_FONTDATA->m_underlined = underlined; + + RealizeResource(); +} + +wxString wxFont::GetFamilyString() const +{ + wxString fam(""); + switch (GetFamily()) + { + case wxDECORATIVE: + fam = "wxDECORATIVE"; + break; + case wxROMAN: + fam = "wxROMAN"; + break; + case wxSCRIPT: + fam = "wxSCRIPT"; + break; + case wxSWISS: + fam = "wxSWISS"; + break; + case wxMODERN: + fam = "wxMODERN"; + break; + case wxTELETYPE: + fam = "wxTELETYPE"; + break; + default: + fam = "wxDEFAULT"; + break; + } + return fam; +} + +/* New font system */ +wxString wxFont::GetFaceName() const +{ + wxString str(""); + if (M_FONTDATA) + str = M_FONTDATA->m_faceName ; + return str; +} + +wxString wxFont::GetStyleString() const +{ + wxString styl(""); + switch (GetStyle()) + { + case wxITALIC: + styl = "wxITALIC"; + break; + case wxSLANT: + styl = "wxSLANT"; + break; + default: + styl = "wxNORMAL"; + break; + } + return styl; +} + +wxString wxFont::GetWeightString() const +{ + wxString w(""); + switch (GetWeight()) + { + case wxBOLD: + w = "wxBOLD"; + break; + case wxLIGHT: + w = "wxLIGHT"; + break; + default: + w = "wxNORMAL"; + break; + } + return w; +} + diff --git a/src/stubs/fontdlg.cpp b/src/stubs/fontdlg.cpp new file mode 100644 index 0000000000..4bfa59eac4 --- /dev/null +++ b/src/stubs/fontdlg.cpp @@ -0,0 +1,54 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: fontdlg.cpp +// Purpose: wxFontDialog class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "fontdlg.h" +#endif + +#include "wx/fontdlg.h" +#include "wx/cmndata.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog) +#endif + +/* + * wxFontDialog + */ + +wxFontDialog::wxFontDialog() +{ + m_dialogParent = NULL; +} + +wxFontDialog::wxFontDialog(wxWindow *parent, wxFontData *data) +{ + Create(parent, data); +} + +bool wxFontDialog::Create(wxWindow *parent, wxFontData *data) +{ + m_dialogParent = parent; + + if (data) + m_fontData = *data; + + // TODO: you may need to do dialog creation here, unless it's + // done in ShowModal. + return TRUE; +} + +int wxFontDialog::ShowModal() +{ + // TODO: show (maybe create) the dialog + return wxID_CANCEL; +} + diff --git a/src/stubs/frame.cpp b/src/stubs/frame.cpp new file mode 100644 index 0000000000..3d9b5b0004 --- /dev/null +++ b/src/stubs/frame.cpp @@ -0,0 +1,546 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: frame.cpp +// Purpose: wxFrame +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "frame.h" +#endif + +#include "wx/frame.h" +#include "wx/statusbr.h" +#include "wx/toolbar.h" +#include "wx/menuitem.h" + +extern wxList wxModelessWindows; +extern wxList wxPendingDelete; + +#if !USE_SHARED_LIBRARY +BEGIN_EVENT_TABLE(wxFrame, wxWindow) + EVT_SIZE(wxFrame::OnSize) + EVT_ACTIVATE(wxFrame::OnActivate) + EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight) + EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged) + EVT_IDLE(wxFrame::OnIdle) + EVT_CLOSE(wxFrame::OnCloseWindow) +END_EVENT_TABLE() + +IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow) +#endif + +#if USE_NATIVE_STATUSBAR +bool wxFrame::m_useNativeStatusBar = TRUE; +#else +bool wxFrame::m_useNativeStatusBar = FALSE; +#endif + +wxFrame::wxFrame() +{ + m_frameToolBar = NULL ; + m_frameMenuBar = NULL; + m_frameStatusBar = NULL; + + m_windowParent = NULL; + m_iconized = FALSE; +} + +bool wxFrame::Create(wxWindow *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + if (!parent) + wxTopLevelWindows.Append(this); + + SetName(name); + m_windowStyle = style; + m_frameMenuBar = NULL; + m_frameToolBar = NULL ; + m_frameStatusBar = NULL; + + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE)); + + if ( id > -1 ) + m_windowId = id; + else + m_windowId = (int)NewControlId(); + + if (parent) parent->AddChild(this); + + wxModelessWindows.Append(this); + + // TODO: create frame. + + return FALSE; +} + +wxFrame::~wxFrame() +{ + wxTopLevelWindows.DeleteObject(this); + + if (m_frameStatusBar) + delete m_frameStatusBar; + if (m_frameMenuBar) + delete m_frameMenuBar; + +/* Check if it's the last top-level window */ + + if (wxTheApp && (wxTopLevelWindows.Number() == 0)) + { + wxTheApp->SetTopWindow(NULL); + + if (wxTheApp->GetExitOnFrameDelete()) + { + // TODO signal to the app that we're going to close + } + } + + wxModelessWindows.DeleteObject(this); +} + +// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc. +void wxFrame::GetClientSize(int *x, int *y) const +{ + // TODO +} + +// Set the client size (i.e. leave the calculation of borders etc. +// to wxWindows) +void wxFrame::SetClientSize(int width, int height) +{ + // TODO +} + +void wxFrame::GetSize(int *width, int *height) const +{ + // TODO +} + +void wxFrame::GetPosition(int *x, int *y) const +{ + // TODO +} + +void wxFrame::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +bool wxFrame::Show(bool show) +{ + // TODO + return FALSE; +} + +void wxFrame::Iconize(bool iconize) +{ + // TODO +} + +// Equivalent to maximize/restore in Windows +void wxFrame::Maximize(bool maximize) +{ + // TODO +} + +bool wxFrame::IsIconized() const +{ + // TODO + return FALSE; +} + +void wxFrame::SetTitle(const wxString& title) +{ + // TODO +} + +wxString wxFrame::GetTitle() const +{ + // TODO + return wxString(""); +} + +void wxFrame::SetIcon(const wxIcon& icon) +{ + m_icon = icon; + // TODO +} + +void wxFrame::SetAcceleratorTable(const wxAcceleratorTable& accel) +{ + m_acceleratorTable = accel; +} + +wxStatusBar *wxFrame::OnCreateStatusBar(int number, long style, wxWindowID id, + const wxString& name) +{ + wxStatusBar *statusBar = NULL; + + statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20), + style, name); + + // Set the height according to the font and the border size + wxClientDC dc(statusBar); + dc.SetFont(* statusBar->GetFont()); + + long x, y; + dc.GetTextExtent("X", &x, &y); + + int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY()); + + statusBar->SetSize(-1, -1, 100, height); + + statusBar->SetFieldsCount(number); + return statusBar; +} + +wxStatusBar* wxFrame::CreateStatusBar(int number, long style, wxWindowID id, + const wxString& name) +{ + // Calling CreateStatusBar twice is an error. + wxCHECK_MSG( m_frameStatusBar == NULL, FALSE, + "recreating status bar in wxFrame" ); + + m_frameStatusBar = OnCreateStatusBar(number, style, id, + name); + if ( m_frameStatusBar ) + { + PositionStatusBar(); + return m_frameStatusBar; + } + else + return NULL; +} + +void wxFrame::SetStatusText(const wxString& text, int number) +{ + wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" ); + + m_frameStatusBar->SetStatusText(text, number); +} + +void wxFrame::SetStatusWidths(int n, const int widths_field[]) +{ + wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" ); + + m_frameStatusBar->SetStatusWidths(n, widths_field); + PositionStatusBar(); +} + +void wxFrame::PositionStatusBar() +{ + int w, h; + GetClientSize(&w, &h); + int sw, sh; + m_frameStatusBar->GetSize(&sw, &sh); + + // Since we wish the status bar to be directly under the client area, + // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS. + m_frameStatusBar->SetSize(0, h, w, sh); +} + +void wxFrame::SetMenuBar(wxMenuBar *menuBar) +{ + if (!menuBar) + { + m_frameMenuBar = NULL; + return; + } + + m_frameMenuBar = menuBar; + + // TODO +} + +void wxFrame::Fit() +{ + // Work out max. size + wxNode *node = GetChildren()->First(); + int max_width = 0; + int max_height = 0; + while (node) + { + // Find a child that's a subwindow, but not a dialog box. + wxWindow *win = (wxWindow *)node->Data(); + + if (!win->IsKindOf(CLASSINFO(wxFrame)) && + !win->IsKindOf(CLASSINFO(wxDialog))) + { + int width, height; + int x, y; + win->GetSize(&width, &height); + win->GetPosition(&x, &y); + + if ((x + width) > max_width) + max_width = x + width; + if ((y + height) > max_height) + max_height = y + height; + } + node = node->Next(); + } + SetClientSize(max_width, max_height); +} + +// Responds to colour changes, and passes event on to children. +void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event) +{ + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE)); + Refresh(); + + if ( m_frameStatusBar ) + { + wxSysColourChangedEvent event2; + event2.SetEventObject( m_frameStatusBar ); + m_frameStatusBar->ProcessEvent(event2); + } + + // Propagate the event to the non-top-level children + wxWindow::OnSysColourChanged(event); +} + +// Default resizing behaviour - if only ONE subwindow, +// resize to client rectangle size +void wxFrame::OnSize(wxSizeEvent& event) +{ + // if we're using constraints - do use them + #if USE_CONSTRAINTS + if ( GetAutoLayout() ) { + Layout(); + return; + } + #endif + + // do we have _exactly_ one child? + wxWindow *child = NULL; + for ( wxNode *node = GetChildren()->First(); node; node = node->Next() ) + { + wxWindow *win = (wxWindow *)node->Data(); + if ( !win->IsKindOf(CLASSINFO(wxFrame)) && + !win->IsKindOf(CLASSINFO(wxDialog)) && + (win != GetStatusBar()) && + (win != GetToolBar()) ) + { + if ( child ) + return; // it's our second subwindow - nothing to do + child = win; + } + } + + if ( child ) { + // we have exactly one child - set it's size to fill the whole frame + int clientW, clientH; + GetClientSize(&clientW, &clientH); + + int x = 0; + int y = 0; + + child->SetSize(x, y, clientW, clientH); + } +} + +// Default activation behaviour - set the focus for the first child +// subwindow found. +void wxFrame::OnActivate(wxActivateEvent& event) +{ + for(wxNode *node = GetChildren()->First(); node; node = node->Next()) + { + // Find a child that's a subwindow, but not a dialog box. + wxWindow *child = (wxWindow *)node->Data(); + if (!child->IsKindOf(CLASSINFO(wxFrame)) && + !child->IsKindOf(CLASSINFO(wxDialog))) + { +#if WXDEBUG > 1 + wxDebugMsg("wxFrame::OnActivate: about to set the child's focus.\n"); +#endif + child->SetFocus(); + return; + } + } +} + +// The default implementation for the close window event - calls +// OnClose for backward compatibility. + +void wxFrame::OnCloseWindow(wxCloseEvent& event) +{ + // Compatibility + if ( GetEventHandler()->OnClose() || event.GetForce()) + { + this->Destroy(); + } +} + +bool wxFrame::OnClose() +{ + return TRUE; +} + +// Destroy the window (delayed, if a managed window) +bool wxFrame::Destroy() +{ + if (!wxPendingDelete.Member(this)) + wxPendingDelete.Append(this); + return TRUE; +} + +// Default menu selection behaviour - display a help string +void wxFrame::OnMenuHighlight(wxMenuEvent& event) +{ + if (GetStatusBar()) + { + if (event.GetMenuId() == -1) + SetStatusText(""); + else + { + wxMenuBar *menuBar = GetMenuBar(); + if (menuBar) + { + wxString helpString(menuBar->GetHelpString(event.GetMenuId())); + if (helpString != "") + SetStatusText(helpString); + } + } + } +} + +wxMenuBar *wxFrame::GetMenuBar() const +{ + return m_frameMenuBar; +} + +void wxFrame::Centre(int direction) +{ + int display_width, display_height, width, height, x, y; + wxDisplaySize(&display_width, &display_height); + + GetSize(&width, &height); + GetPosition(&x, &y); + + if (direction & wxHORIZONTAL) + x = (int)((display_width - width)/2); + if (direction & wxVERTICAL) + y = (int)((display_height - height)/2); + + SetSize(x, y, width, height); +} + +// Call this to simulate a menu command +void wxFrame::Command(int id) +{ + ProcessCommand(id); +} + +void wxFrame::ProcessCommand(int id) +{ + wxCommandEvent commandEvent(wxEVENT_TYPE_MENU_COMMAND, id); + commandEvent.SetInt( id ); + commandEvent.SetEventObject( this ); + + wxMenuBar *bar = GetMenuBar() ; + if (!bar) + return; + +/* TODO: check the menu item if required + wxMenuItem *item = bar->FindItemForId(id) ; + if (item && item->IsCheckable()) + { + bar->Check(id,!bar->Checked(id)) ; + } +*/ + + GetEventHandler()->ProcessEvent(commandEvent); +} + +// Checks if there is a toolbar, and returns the first free client position +wxPoint wxFrame::GetClientAreaOrigin() const +{ + wxPoint pt(0, 0); + if (GetToolBar()) + { + int w, h; + GetToolBar()->GetSize(& w, & h); + + if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL) + { + pt.x += w; + } + else + { + pt.y += h; + } + } + return pt; +} + +wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name) +{ + wxCHECK_MSG( m_frameToolBar == NULL, FALSE, + "recreating toolbar in wxFrame" ); + + wxToolBar* toolBar = OnCreateToolBar(style, id, name); + if (toolBar) + { + SetToolBar(toolBar); + PositionToolBar(); + return toolBar; + } + else + { + return NULL; + } +} + +wxToolBar* wxFrame::OnCreateToolBar(long style, wxWindowID id, const wxString& name) +{ + return new wxToolBar(this, id, wxDefaultPosition, wxDefaultSize, style, name); +} + +void wxFrame::PositionToolBar() +{ + int cw, ch; + + // TODO: we actually need to use the low-level client size, before + // the toolbar/status bar were added. + // So DEFINITELY replace the line below with something appropriate. + + wxCHECK_MSG( TRUE, FALSE, + "PositionToolBar not implemented properly, see frame.cpp" ); + + GetClientSize(& cw, &ch); + + if ( GetStatusBar() ) + { + int statusX, statusY; + GetStatusBar()->GetClientSize(&statusX, &statusY); + ch -= statusY; + } + + if (GetToolBar()) + { + int tw, th; + GetToolBar()->GetSize(& tw, & th); + + if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL) + { + // Use the 'real' position. wxSIZE_NO_ADJUSTMENTS + // means, pretend we don't have toolbar/status bar, so we + // have the original client size. + GetToolBar()->SetSize(0, 0, tw, ch, wxSIZE_NO_ADJUSTMENTS); + } + else + { + // Use the 'real' position + GetToolBar()->SetSize(0, 0, cw, th, wxSIZE_NO_ADJUSTMENTS); + } + } +} + diff --git a/src/stubs/gauge.cpp b/src/stubs/gauge.cpp new file mode 100644 index 0000000000..8e11c5001b --- /dev/null +++ b/src/stubs/gauge.cpp @@ -0,0 +1,105 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gauge.cpp +// Purpose: wxGauge class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "gauge.h" +#endif + +#include "wx/gauge.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl) +#endif + +bool wxGauge::Create(wxWindow *parent, wxWindowID id, + int range, + const wxPoint& pos, + const wxSize& size, + long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + m_rangeMax = range; + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + + // TODO + return FALSE; +} + +void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxGauge::SetShadowWidth(int w) +{ + // TODO optional +} + +void wxGauge::SetBezelFace(int w) +{ + // TODO optional +} + +void wxGauge::SetRange(int r) +{ + m_rangeMax = r; + // TODO +} + +void wxGauge::SetValue(int pos) +{ + m_gaugePos = pos; + // TODO +} + +int wxGauge::GetShadowWidth() const +{ + // TODO optional + return 0; +} + +int wxGauge::GetBezelFace() const +{ + // TODO optional + return 0; +} + +int wxGauge::GetRange() const +{ + return m_rangeMax; +} + +int wxGauge::GetValue() const +{ + return m_gaugePos; +} + +void wxGauge::SetForegroundColour(const wxColour& col) +{ + m_foregroundColour = col ; +} + +void wxGauge::SetBackgroundColour(const wxColour& col) +{ + m_backgroundColour = col ; +} + diff --git a/src/stubs/gdiobj.cpp b/src/stubs/gdiobj.cpp new file mode 100644 index 0000000000..63697c8354 --- /dev/null +++ b/src/stubs/gdiobj.cpp @@ -0,0 +1,22 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: gdiobj.cpp +// Purpose: wxGDIObject class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "gdiobj.h" +#endif + +#include "wx/gdiobj.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject) +#endif + +// TODO: Nothing to do, unless you want to. diff --git a/src/stubs/helpxxxx.cpp b/src/stubs/helpxxxx.cpp new file mode 100644 index 0000000000..086762c646 --- /dev/null +++ b/src/stubs/helpxxxx.cpp @@ -0,0 +1,83 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: helpxxxx.cpp +// Purpose: Help system: native implementation +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "helpxxxx.h" +#endif + +#include "wx/stubs/helpxxxx.h" + +#include + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxXXXXHelpController, wxHelpControllerBase) +#endif + +wxXXXXHelpController::wxXXXXHelpController() +{ + m_helpFile = ""; +} + +wxXXXXHelpController::~wxXXXXHelpController() +{ +} + +bool wxXXXXHelpController::Initialize(const wxString& filename) +{ + m_helpFile = filename; + // TODO any other inits + return TRUE; +} + +bool wxXXXXHelpController::LoadFile(const wxString& file) +{ + m_helpFile = file; + // TODO + return TRUE; +} + +bool wxXXXXHelpController::DisplayContents() +{ + // TODO + return FALSE; +} + +bool wxXXXXHelpController::DisplaySection(int section) +{ + // TODO + return FALSE; +} + +bool wxXXXXHelpController::DisplayBlock(long block) +{ + // TODO + return FALSE; +} + +bool wxXXXXHelpController::KeywordSearch(const wxString& k) +{ + if (m_helpFile == "") return FALSE; + + // TODO + return FALSE; +} + +// Can't close the help window explicitly in WinHelp +bool wxXXXXHelpController::Quit() +{ + // TODO + return FALSE; +} + +void wxXXXXHelpController::OnQuit() +{ +} + diff --git a/src/stubs/icon.cpp b/src/stubs/icon.cpp new file mode 100644 index 0000000000..6deee7dbdc --- /dev/null +++ b/src/stubs/icon.cpp @@ -0,0 +1,70 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: icon.cpp +// Purpose: wxIcon class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "icon.h" +#endif + +#include "wx/icon.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap) +#endif + +/* + * Icons + */ + + +wxIconRefData::wxIconRefData() +{ + // TODO: init icon handle +} + +wxIconRefData::~wxIconRefData() +{ + // TODO: destroy icon handle +} + +wxIcon::wxIcon() +{ +} + +wxIcon::wxIcon(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height)) +{ +} + +wxIcon::wxIcon(const wxString& icon_file, long flags, + int desiredWidth, int desiredHeight) + +{ + LoadFile(icon_file, flags, desiredWidth, desiredHeight); +} + +wxIcon::~wxIcon() +{ +} + +bool wxIcon::LoadFile(const wxString& filename, long type, + int desiredWidth, int desiredHeight) +{ + UnRef(); + + m_refData = new wxIconRefData; + + wxBitmapHandler *handler = FindHandler(type); + + if ( handler ) + return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); + else + return FALSE; +} + diff --git a/src/stubs/imaglist.cpp b/src/stubs/imaglist.cpp new file mode 100644 index 0000000000..7c18d9f464 --- /dev/null +++ b/src/stubs/imaglist.cpp @@ -0,0 +1,118 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: imaglist.cpp +// Purpose: wxImageList +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "imaglist.h" +#endif + +#include "wx/msw/imaglist.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject) +#endif + +wxImageList::wxImageList() +{ + // TODO: init image list handle, if any +} + +wxImageList::~wxImageList() +{ + // TODO: destroy image list handle, if any +} + + +// Attributes +//////////////////////////////////////////////////////////////////////////// + +// Returns the number of images in the image list. +int wxImageList::GetImageCount() const +{ + // TODO + return 0; +} + +// Operations +//////////////////////////////////////////////////////////////////////////// + +// Creates an image list +bool wxImageList::Create(int width, int height, bool mask, int initial) +{ + // TODO + return FALSE; +} + +// Adds a bitmap, and optionally a mask bitmap. +// Note that wxImageList creates new bitmaps, so you may delete +// 'bitmap' and 'mask'. +int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask) +{ + // TODO + return 0; +} + +// Adds a bitmap, using the specified colour to create the mask bitmap +// Note that wxImageList creates new bitmaps, so you may delete +// 'bitmap'. +int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour) +{ + // TODO + return 0; +} + +// Adds a bitmap and mask from an icon. +int wxImageList::Add(const wxIcon& icon) +{ + // TODO + return 0; +} + +// Replaces a bitmap, optionally passing a mask bitmap. +// Note that wxImageList creates new bitmaps, so you may delete +// 'bitmap' and 'mask'. +bool wxImageList::Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask) +{ + // TODO + return 0; +} + +// Replaces a bitmap and mask from an icon. +bool wxImageList::Replace(int index, const wxIcon& icon) +{ + // TODO + return 0; +} + +// Removes the image at the given index. +bool wxImageList::Remove(int index) +{ + // TODO + return FALSE; +} + +// Remove all images +bool wxImageList::RemoveAll() +{ + // TODO + return FALSE; +} + +// Draws the given image on a dc at the specified position. +// If 'solidBackground' is TRUE, Draw sets the image list background +// colour to the background colour of the wxDC, to speed up +// drawing by eliminating masked drawing where possible. +bool wxImageList::Draw(int index, wxDC& dc, int x, int y, + int flags, bool solidBackground) +{ + // TODO + return FALSE; +} + diff --git a/src/stubs/joystick.cpp b/src/stubs/joystick.cpp new file mode 100644 index 0000000000..6677277f48 --- /dev/null +++ b/src/stubs/joystick.cpp @@ -0,0 +1,279 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: joystick.cpp +// Purpose: wxJoystick class +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "joystick.h" +#endif + +#include + +IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject) + +// Attributes +//////////////////////////////////////////////////////////////////////////// + +wxPoint wxJoystick::GetPosition() const +{ + // TODO + return wxPoint(0, 0); +} + +int wxJoystick::GetZPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetButtonState() const +{ + // TODO + return 0; +} + +int wxJoystick::GetPOVPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetPOVCTSPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetRudderPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetUPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetVPosition() const +{ + // TODO + return 0; +} + +int wxJoystick::GetMovementThreshold() const +{ + // TODO + return 0; +} + +void wxJoystick::SetMovementThreshold(int threshold) +{ + // TODO +} + +// Capabilities +//////////////////////////////////////////////////////////////////////////// + +bool wxJoystick::IsOk() const +{ + // TODO + return FALSE; +} + +int wxJoystick::GetNumberJoysticks() const +{ + // TODO + return 0; +} + +int wxJoystick::GetManufacturerId() const +{ + // TODO + return 0; +} + +int wxJoystick::GetProductId() const +{ + // TODO + return 0; +} + +wxString wxJoystick::GetProductName() const +{ + // TODO + return wxString(""); +} + +int wxJoystick::GetXMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetYMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetZMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetXMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetYMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetZMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetNumberButtons() const +{ + // TODO + return 0; +} + +int wxJoystick::GetNumberAxes() const +{ + // TODO + return 0; +} + +int wxJoystick::GetMaxButtons() const +{ + // TODO + return 0; +} + +int wxJoystick::GetMaxAxes() const +{ + // TODO + return 0; +} + +int wxJoystick::GetPollingMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetPollingMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetRudderMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetRudderMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetUMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetUMax() const +{ + // TODO + return 0; +} + +int wxJoystick::GetVMin() const +{ + // TODO + return 0; +} + +int wxJoystick::GetVMax() const +{ + // TODO + return 0; +} + +bool wxJoystick::HasRudder() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasZ() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasU() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasV() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasPOV() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasPOV4Dir() const +{ + // TODO + return FALSE; +} + +bool wxJoystick::HasPOVCTS() const +{ + // TODO + return FALSE; +} + +// Operations +//////////////////////////////////////////////////////////////////////////// + +bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq) +{ + // TODO + return FALSE; +} + +bool wxJoystick::ReleaseCapture() +{ + // TODO + return FALSE; +} + diff --git a/src/stubs/listbox.cpp b/src/stubs/listbox.cpp new file mode 100644 index 0000000000..a54523ab3d --- /dev/null +++ b/src/stubs/listbox.cpp @@ -0,0 +1,240 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: listbox.cpp +// Purpose: wxListBox +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "listbox.h" +#endif + +#include "wx/listbox.h" + +#include "wx/dynarray.h" +#include "wx/log.h" + +#if !USE_SHARED_LIBRARY + IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl) +#endif + +// ============================================================================ +// list box control implementation +// ============================================================================ + +// Listbox item +wxListBox::wxListBox() +{ + m_noItems = 0; + m_selected = 0; +} + +bool wxListBox::Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos, + const wxSize& size, + int n, const wxString choices[], + long style, + const wxValidator& validator, + const wxString& name) +{ + m_noItems = n; + m_selected = 0; + + SetName(name); + SetValidator(validator); + + if (parent) parent->AddChild(this); + + wxSystemSettings settings; + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); + + m_windowId = ( id == -1 ) ? (int)NewControlId() : id; + + // TODO create listbox + + return FALSE; +} + +wxListBox::~wxListBox() +{ +} + +void wxListBox::SetupColours() +{ + SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); +} + +void wxListBox::SetFirstItem(int N) +{ + // TODO +} + +void wxListBox::SetFirstItem(const wxString& s) +{ + // TODO +} + +void wxListBox::Delete(int N) +{ + m_noItems --; + // TODO +} + +void wxListBox::Append(const wxString& item) +{ + m_noItems ++; + + // TODO +} + +void wxListBox::Append(const wxString& item, char *Client_data) +{ + m_noItems ++; + + // TODO +} + +void wxListBox::Set(int n, const wxString *choices, char** clientData) +{ + m_noItems = n; + + // TODO +} + +int wxListBox::FindString(const wxString& s) const +{ + // TODO + return -1; +} + +void wxListBox::Clear() +{ + m_noItems = 0; + // TODO +} + +void wxListBox::SetSelection(int N, bool select) +{ + // TODO +} + +bool wxListBox::Selected(int N) const +{ + // TODO + return FALSE; +} + +void wxListBox::Deselect(int N) +{ + // TODO +} + +char *wxListBox::GetClientData(int N) const +{ + // TODO + return (char *)NULL; +} + +void wxListBox::SetClientData(int N, char *Client_data) +{ + // TODO +} + +// Return number of selections and an array of selected integers +int wxListBox::GetSelections(wxArrayInt& aSelections) const +{ + aSelections.Empty(); + +/* TODO + if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED)) + { + int no_sel = ?? + for ( int n = 0; n < no_sel; n++ ) + aSelections.Add(??); + + return no_sel; + } + else // single-selection listbox + { + aSelections.Add(??); + + return 1; + } +*/ + return 0; +} + +// Get single selection, for single choice list items +int wxListBox::GetSelection() const +{ + // TODO + return -1; +} + +// Find string for position +wxString wxListBox::GetString(int N) const +{ + // TODO + return wxString(""); +} + +void wxListBox::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxListBox::InsertItems(int nItems, const wxString items[], int pos) +{ + m_noItems += nItems; + + // TODO +} + +void wxListBox::SetString(int N, const wxString& s) +{ + // TODO +} + +int wxListBox::Number () const +{ + return m_noItems; +} + +// For single selection items only +wxString wxListBox::GetStringSelection () const +{ + int sel = GetSelection (); + if (sel > -1) + return this->GetString (sel); + else + return wxString(""); +} + +bool wxListBox::SetStringSelection (const wxString& s, bool flag) +{ + int sel = FindString (s); + if (sel > -1) + { + SetSelection (sel, flag); + return TRUE; + } + else + return FALSE; +} + +void wxListBox::Command (wxCommandEvent & event) +{ + if (event.m_extraLong) + SetSelection (event.m_commandInt); + else + { + Deselect (event.m_commandInt); + return; + } + ProcessCommand (event); +} + diff --git a/src/stubs/listctrl.cpp b/src/stubs/listctrl.cpp new file mode 100644 index 0000000000..a659399c63 --- /dev/null +++ b/src/stubs/listctrl.cpp @@ -0,0 +1,598 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: listctrl.cpp +// Purpose: wxListCtrl. See also Robert's generic wxListCtrl +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "listctrl.h" +#endif + +#include "wx/listctrl.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl) +IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject) + +#endif + +wxListCtrl::wxListCtrl() +{ + m_imageListNormal = NULL; + m_imageListSmall = NULL; + m_imageListState = NULL; + m_baseStyle = 0; + m_colCount = 0; +} + +bool wxListCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, + long style, const wxValidator& validator, const wxString& name) +{ + m_imageListNormal = NULL; + m_imageListSmall = NULL; + m_imageListState = NULL; + m_colCount = 0; + + SetValidator(validator); + SetName(name); + + m_windowStyle = style; + + SetParent(parent); + + m_windowId = (id == -1) ? NewControlId() : id; + + if (parent) parent->AddChild(this); + + // TODO create list control + return TRUE; +} + +wxListCtrl::~wxListCtrl() +{ +} + +// Add or remove a single window style +void wxListCtrl::SetSingleStyle(long style, bool add) +{ + long flag = GetWindowStyleFlag(); + + // Get rid of conflicting styles + if ( add ) + { + if ( style & wxLC_MASK_TYPE) + flag = flag & ~wxLC_MASK_TYPE ; + if ( style & wxLC_MASK_ALIGN ) + flag = flag & ~wxLC_MASK_ALIGN ; + if ( style & wxLC_MASK_SORT ) + flag = flag & ~wxLC_MASK_SORT ; + } + + if ( flag & style ) + { + if ( !add ) + flag -= style; + } + else + { + if ( add ) + { + flag |= style; + } + } + + m_windowStyle = flag; + + /* TODO RecreateWindow(); */ +} + +// Set the whole window style +void wxListCtrl::SetWindowStyleFlag(long flag) +{ + m_windowStyle = flag; + + /* TODO RecreateWindow(); */ +} + + +// Gets information about this column +bool wxListCtrl::GetColumn(int col, wxListItem& item) const +{ + // TODO + return FALSE; +} + +// Sets information about this column +bool wxListCtrl::SetColumn(int col, wxListItem& item) +{ + // TODO + return FALSE; +} + +// Gets the column width +int wxListCtrl::GetColumnWidth(int col) const +{ + // TODO + return 0; +} + +// Sets the column width +bool wxListCtrl::SetColumnWidth(int col, int width) +{ + // TODO + return FALSE; +} + +// Gets the number of items that can fit vertically in the +// visible area of the list control (list or report view) +// or the total number of items in the list control (icon +// or small icon view) +int wxListCtrl::GetCountPerPage() const +{ + // TODO + return 0; +} + +// Gets the edit control for editing labels. +wxTextCtrl* wxListCtrl::GetEditControl() const +{ + return m_textCtrl; +} + +// Gets information about the item +bool wxListCtrl::GetItem(wxListItem& info) const +{ + // TODO + return FALSE; +} + +// Sets information about the item +bool wxListCtrl::SetItem(wxListItem& info) +{ + // TODO + return FALSE; +} + +long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId) +{ + wxListItem info; + info.m_text = label; + info.m_mask = wxLIST_MASK_TEXT; + info.m_itemId = index; + info.m_col = col; + if ( imageId > -1 ) + { + info.m_image = imageId; + info.m_mask |= wxLIST_MASK_IMAGE; + } + return SetItem(info); +} + + +// Gets the item state +int wxListCtrl::GetItemState(long item, long stateMask) const +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_STATE ; + info.m_stateMask = stateMask; + info.m_itemId = item; + + if (!GetItem(info)) + return 0; + + return info.m_state; +} + +// Sets the item state +bool wxListCtrl::SetItemState(long item, long state, long stateMask) +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_STATE ; + info.m_state = state; + info.m_stateMask = stateMask; + info.m_itemId = item; + + return SetItem(info); +} + +// Sets the item image +bool wxListCtrl::SetItemImage(long item, int image, int selImage) +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_IMAGE ; + info.m_image = image; + info.m_itemId = item; + + return SetItem(info); +} + +// Gets the item text +wxString wxListCtrl::GetItemText(long item) const +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_TEXT ; + info.m_itemId = item; + + if (!GetItem(info)) + return wxString(""); + return info.m_text; +} + +// Sets the item text +void wxListCtrl::SetItemText(long item, const wxString& str) +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_TEXT ; + info.m_itemId = item; + info.m_text = str; + + SetItem(info); +} + +// Gets the item data +long wxListCtrl::GetItemData(long item) const +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_DATA ; + info.m_itemId = item; + + if (!GetItem(info)) + return 0; + return info.m_data; +} + +// Sets the item data +bool wxListCtrl::SetItemData(long item, long data) +{ + wxListItem info; + + info.m_mask = wxLIST_MASK_DATA ; + info.m_itemId = item; + info.m_data = data; + + return SetItem(info); +} + +// Gets the item rectangle +bool wxListCtrl::GetItemRect(long item, wxRectangle& rect, int code) const +{ + // TODO + return FALSE; +} + +// Gets the item position +bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const +{ + // TODO + return FALSE; +} + +// Sets the item position. +bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos) +{ + // TODO + return FALSE; +} + +// Gets the number of items in the list control +int wxListCtrl::GetItemCount() const +{ + // TODO + return FALSE; +} + +// Retrieves the spacing between icons in pixels. +// If small is TRUE, gets the spacing for the small icon +// view, otherwise the large icon view. +int wxListCtrl::GetItemSpacing(bool isSmall) const +{ + // TODO + return FALSE; +} + +// Gets the number of selected items in the list control +int wxListCtrl::GetSelectedItemCount() const +{ + // TODO + return FALSE; +} + +// Gets the text colour of the listview +wxColour wxListCtrl::GetTextColour() const +{ + // TODO + return wxColour(); +} + +// Sets the text colour of the listview +void wxListCtrl::SetTextColour(const wxColour& col) +{ + // TODO +} + +// Gets the index of the topmost visible item when in +// list or report view +long wxListCtrl::GetTopItem() const +{ + // TODO + return 0; +} + +// Searches for an item, starting from 'item'. +// 'geometry' is one of +// wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT. +// 'state' is a state bit flag, one or more of +// wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT. +// item can be -1 to find the first item that matches the +// specified flags. +// Returns the item or -1 if unsuccessful. +long wxListCtrl::GetNextItem(long item, int geom, int state) const +{ + // TODO + return 0; +} + +wxImageList *wxListCtrl::GetImageList(int which) const +{ + if ( which == wxIMAGE_LIST_NORMAL ) + { + return m_imageListNormal; + } + else if ( which == wxIMAGE_LIST_SMALL ) + { + return m_imageListSmall; + } + else if ( which == wxIMAGE_LIST_STATE ) + { + return m_imageListState; + } + return NULL; +} + +void wxListCtrl::SetImageList(wxImageList *imageList, int which) +{ + int flags = 0; + if ( which == wxIMAGE_LIST_NORMAL ) + { + flags = LVSIL_NORMAL; + m_imageListNormal = imageList; + } + else if ( which == wxIMAGE_LIST_SMALL ) + { + flags = LVSIL_SMALL; + m_imageListSmall = imageList; + } + else if ( which == wxIMAGE_LIST_STATE ) + { + flags = LVSIL_STATE; + m_imageListState = imageList; + } + // TODO set image list +} + +// Operations +//////////////////////////////////////////////////////////////////////////// + +// Arranges the items +bool wxListCtrl::Arrange(int flag) +{ + // TODO + return FALSE; +} + +// Deletes an item +bool wxListCtrl::DeleteItem(long item) +{ + // TODO + return FALSE; +} + +// Deletes all items +bool wxListCtrl::DeleteAllItems() +{ + // TODO + return FALSE; +} + +// Deletes all items +bool wxListCtrl::DeleteAllColumns() +{ + // TODO + return FALSE; +} + +// Deletes a column +bool wxListCtrl::DeleteColumn(int col) +{ + // TODO + return FALSE; +} + +// Clears items, and columns if there are any. +void wxListCtrl::ClearAll() +{ + DeleteAllItems(); + if ( m_colCount > 0 ) + DeleteAllColumns(); +} + +// Edit the label +wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass) +{ + // TODO + return NULL; +} + +// End label editing, optionally cancelling the edit +bool wxListCtrl::EndEditLabel(bool cancel) +{ + // TODO + return FALSE; +} + +// Ensures this item is visible +bool wxListCtrl::EnsureVisible(long item) +{ + // TODO + return FALSE; +} + +// Find an item whose label matches this string, starting from the item after 'start' +// or the beginning if 'start' is -1. +long wxListCtrl::FindItem(long start, const wxString& str, bool partial) +{ + // TODO + return FALSE; +} + +// Find an item whose data matches this data, starting from the item after 'start' +// or the beginning if 'start' is -1. +long wxListCtrl::FindItem(long start, long data) +{ + // TODO + return 0; +} + +// Find an item nearest this position in the specified direction, starting from +// the item after 'start' or the beginning if 'start' is -1. +long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction) +{ + // TODO + return 0; +} + +// Determines which item (if any) is at the specified point, +// giving details in 'flags' (see wxLIST_HITTEST_... flags above) +long wxListCtrl::HitTest(const wxPoint& point, int& flags) +{ + // TODO + return 0; +} + +// Inserts an item, returning the index of the new item if successful, +// -1 otherwise. +long wxListCtrl::InsertItem(wxListItem& info) +{ + // TODO + return 0; +} + +long wxListCtrl::InsertItem(long index, const wxString& label) +{ + wxListItem info; + info.m_text = label; + info.m_mask = wxLIST_MASK_TEXT; + info.m_itemId = index; + return InsertItem(info); +} + +// Inserts an image item +long wxListCtrl::InsertItem(long index, int imageIndex) +{ + wxListItem info; + info.m_image = imageIndex; + info.m_mask = wxLIST_MASK_IMAGE; + info.m_itemId = index; + return InsertItem(info); +} + +// Inserts an image/string item +long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex) +{ + wxListItem info; + info.m_image = imageIndex; + info.m_text = label; + info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT; + info.m_itemId = index; + return InsertItem(info); +} + +// For list view mode (only), inserts a column. +long wxListCtrl::InsertColumn(long col, wxListItem& item) +{ + // TODO + return 0; +} + +long wxListCtrl::InsertColumn(long col, const wxString& heading, int format, + int width) +{ + wxListItem item; + item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT; + item.m_text = heading; + if ( width > -1 ) + { + item.m_mask |= wxLIST_MASK_WIDTH; + item.m_width = width; + } + item.m_format = format; + + return InsertColumn(col, item); +} + +// Scrolls the list control. If in icon, small icon or report view mode, +// x specifies the number of pixels to scroll. If in list view mode, x +// specifies the number of columns to scroll. +// If in icon, small icon or list view mode, y specifies the number of pixels +// to scroll. If in report view mode, y specifies the number of lines to scroll. +bool wxListCtrl::ScrollList(int dx, int dy) +{ + // TODO + return FALSE; +} + +// Sort items. + +// fn is a function which takes 3 long arguments: item1, item2, data. +// item1 is the long data associated with a first item (NOT the index). +// item2 is the long data associated with a second item (NOT the index). +// data is the same value as passed to SortItems. +// The return value is a negative number if the first item should precede the second +// item, a positive number of the second item should precede the first, +// or zero if the two items are equivalent. + +// data is arbitrary data to be passed to the sort function. +bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data) +{ + // TODO + return FALSE; +} + +// List item structure +wxListItem::wxListItem() +{ + m_mask = 0; + m_itemId = 0; + m_col = 0; + m_state = 0; + m_stateMask = 0; + m_image = 0; + m_data = 0; + + m_format = wxLIST_FORMAT_CENTRE; + m_width = 0; +} + +// List event +IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxCommandEvent) + +wxListEvent::wxListEvent(wxEventType commandType, int id): + wxCommandEvent(commandType, id) +{ + m_code = 0; + m_itemIndex = 0; + m_col = 0; + m_cancelled = FALSE; +} + diff --git a/src/stubs/main.cpp b/src/stubs/main.cpp new file mode 100644 index 0000000000..d90dc2c036 --- /dev/null +++ b/src/stubs/main.cpp @@ -0,0 +1,18 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: main.cpp +// Purpose: Entry point +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#include "wx/app.h" + +int main(int argc, char* argv[]) +{ + return wxEntry(argc, argv[]); +} + diff --git a/src/stubs/mdi.cpp b/src/stubs/mdi.cpp new file mode 100644 index 0000000000..bcd7785c0d --- /dev/null +++ b/src/stubs/mdi.cpp @@ -0,0 +1,263 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: mdi.cpp +// Purpose: MDI classes +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "mdi.h" +#endif + +#include "wx/mdi.h" + +extern wxList wxModelessWindows; + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame) +IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame) +IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow) + +BEGIN_EVENT_TABLE(wxMDIParentFrame, wxFrame) + EVT_SIZE(wxMDIParentFrame::OnSize) + EVT_ACTIVATE(wxMDIParentFrame::OnActivate) + EVT_SYS_COLOUR_CHANGED(wxMDIParentFrame::OnSysColourChanged) +END_EVENT_TABLE() + +BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow) + EVT_SCROLL(wxMDIClientWindow::OnScroll) +END_EVENT_TABLE() + +#endif + +// Parent frame + +wxMDIParentFrame::wxMDIParentFrame() +{ +} + +bool wxMDIParentFrame::Create(wxWindow *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + if (!parent) + wxTopLevelWindows.Append(this); + + SetName(name); + m_windowStyle = style; + + if (parent) parent->AddChild(this); + + if ( id > -1 ) + m_windowId = id; + else + m_windowId = (int)NewControlId(); + + // TODO: create MDI parent frame + + wxModelessWindows.Append(this); + + return TRUE; +} + +wxMDIParentFrame::~wxMDIParentFrame() +{ +} + +// Get size *available for subwindows* i.e. excluding menu bar. +void wxMDIParentFrame::GetClientSize(int *x, int *y) const +{ + // TODO +} + +void wxMDIParentFrame::SetMenuBar(wxMenuBar *menu_bar) +{ + // TODO + if (!menu_bar) + { + m_frameMenuBar = NULL; + return; + } + + if (menu_bar->m_menuBarFrame) + return; + + m_frameMenuBar = menu_bar; +} + +void wxMDIParentFrame::OnSize(wxSizeEvent& event) +{ +#if USE_CONSTRAINTS + if (GetAutoLayout()) + Layout(); +#endif + int x = 0; + int y = 0; + int width, height; + GetClientSize(&width, &height); + + if ( GetClientWindow() ) + GetClientWindow()->SetSize(x, y, width, height); +} + +void wxMDIParentFrame::OnActivate(wxActivateEvent& event) +{ + // Do nothing +} + +// Returns the active MDI child window +wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const +{ + // TODO + return NULL; +} + +// Create the client window class (don't Create the window, +// just return a new class) +wxMDIClientWindow *wxMDIParentFrame::OnCreateClient() +{ + return new wxMDIClientWindow ; +} + +// Responds to colour changes, and passes event on to children. +void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event) +{ + // TODO + + // Propagate the event to the non-top-level children + wxFrame::OnSysColourChanged(event); +} + +// MDI operations +void wxMDIParentFrame::Cascade() +{ + // TODO +} + +void wxMDIParentFrame::Tile() +{ + // TODO +} + +void wxMDIParentFrame::ArrangeIcons() +{ + // TODO +} + +void wxMDIParentFrame::ActivateNext() +{ + // TODO +} + +void wxMDIParentFrame::ActivatePrevious() +{ + // TODO +} + +// Child frame + +wxMDIChildFrame::wxMDIChildFrame() +{ +} + +bool wxMDIChildFrame::Create(wxMDIParentFrame *parent, + wxWindowID id, + const wxString& title, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + SetName(name); + + if ( id > -1 ) + m_windowId = id; + else + m_windowId = (int)NewControlId(); + + if (parent) parent->AddChild(this); + + // TODO: create child frame + + wxModelessWindows.Append(this); + return FALSE; +} + +wxMDIChildFrame::~wxMDIChildFrame() +{ +} + +// Set the client size (i.e. leave the calculation of borders etc. +// to wxWindows) +void wxMDIChildFrame::SetClientSize(int width, int height) +{ + // TODO +} + +void wxMDIChildFrame::GetPosition(int *x, int *y) const +{ + // TODO +} + +void wxMDIChildFrame::SetMenuBar(wxMenuBar *menu_bar) +{ + // TODO + if (!menu_bar) + { + m_frameMenuBar = NULL; + return; + } + + if (menu_bar->m_menuBarFrame) + return; + m_frameMenuBar = menu_bar; +} + +// MDI operations +void wxMDIChildFrame::Maximize() +{ + // TODO +} + +void wxMDIChildFrame::Restore() +{ + // TODO +} + +void wxMDIChildFrame::Activate() +{ + // TODO +} + +// Client window + +wxMDIClientWindow::wxMDIClientWindow() +{ +} + +wxMDIClientWindow::~wxMDIClientWindow() +{ +} + +bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style) +{ + // TODO create client window + m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE); + + return FALSE; +} + +// Explicitly call default scroll behaviour +void wxMDIClientWindow::OnScroll(wxScrollEvent& event) +{ + Default(); // Default processing +} + diff --git a/src/stubs/menu.cpp b/src/stubs/menu.cpp new file mode 100644 index 0000000000..217e6c8b88 --- /dev/null +++ b/src/stubs/menu.cpp @@ -0,0 +1,568 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: menu.cpp +// Purpose: wxMenu, wxMenuBar, wxMenuItem +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + + +// ============================================================================ +// headers & declarations +// ============================================================================ + +// wxWindows headers +// ----------------- + +#ifdef __GNUG__ +#pragma implementation "menu.h" +#pragma implementation "menuitem.h" +#endif + +#include "wx/menu.h" +#include "wx/menuitem.h" +#include "wx/log.h" + +// other standard headers +// ---------------------- +#include + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler) +IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler) +#endif + +// ============================================================================ +// implementation +// ============================================================================ + +// Menus + +// Construct a menu with optional title (then use append) +wxMenu::wxMenu(const wxString& title, const wxFunction func) +{ + m_title = title; + m_parent = NULL; + m_eventHandler = this; + m_noItems = 0; + m_menuBar = NULL; + if (m_title != "") + { + Append(-2, m_title) ; + AppendSeparator() ; + } + + Callback(func); + + // TODO create menu +} + +// The wxWindow destructor will take care of deleting the submenus. +wxMenu::~wxMenu() +{ + // TODO destroy menu and children + + wxNode *node = m_menuItems.First(); + while (node) + { + wxMenuItem *item = (wxMenuItem *)node->Data(); + + // Delete child menus. + // Beware: they must not be appended to children list!!! + // (because order of delete is significant) + if (item->GetSubMenu()) + item->DeleteSubMenu(); + + wxNode *next = node->Next(); + delete item; + delete node; + node = next; + } +} + +void wxMenu::Break() +{ + // TODO +} + +// function appends a new item or submenu to the menu +void wxMenu::Append(wxMenuItem *pItem) +{ + // TODO + + wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" ); + + m_menuItems.Append(pItem); + + m_noItems++; +} + +void wxMenu::AppendSeparator() +{ + // TODO + Append(new wxMenuItem(this, ID_SEPARATOR)); +} + +// Pullright item +void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu, + const wxString& helpString) +{ + Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu)); +} + +// Ordinary menu item +void wxMenu::Append(int Id, const wxString& label, + const wxString& helpString, bool checkable) +{ + // 'checkable' parameter is useless for Windows. + Append(new wxMenuItem(this, Id, label, helpString, checkable)); +} + +void wxMenu::Delete(int id) +{ + wxNode *node; + wxMenuItem *item; + int pos; + + for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) { + item = (wxMenuItem *)node->Data(); + if (item->GetId() == id) + break; + } + + if (!node) + return; + + m_menuItems.DeleteNode(node); + delete item; + + // TODO +} + +void wxMenu::Enable(int Id, bool Flag) +{ + wxMenuItem *item = FindItemForId(Id); + wxCHECK_RET( item != NULL, "can't enable non-existing menu item" ); + + item->Enable(Flag); +} + +bool wxMenu::Enabled(int Id) const +{ + wxMenuItem *item = FindItemForId(Id); + wxCHECK( item != NULL, FALSE ); + + return item->IsEnabled(); +} + +void wxMenu::Check(int Id, bool Flag) +{ + wxMenuItem *item = FindItemForId(Id); + wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" ); + + item->Check(Flag); +} + +bool wxMenu::Checked(int Id) const +{ + wxMenuItem *item = FindItemForId(Id); + wxCHECK( item != NULL, FALSE ); + + return item->IsChecked(); +} + +void wxMenu::SetTitle(const wxString& label) +{ + m_title = label ; + // TODO +} + +const wxString& wxMenu::GetTitle() const +{ + return m_title; +} + +void wxMenu::SetLabel(int id, const wxString& label) +{ + wxMenuItem *item = FindItemForId(id) ; + if (item==NULL) + return; + + if (item->GetSubMenu()==NULL) + { + // TODO + } + else + { + // TODO + } + item->SetName(label); +} + +wxString wxMenu::GetLabel(int Id) const +{ + // TODO + return wxString("") ; +} + +// Finds the item id matching the given string, -1 if not found. +int wxMenu::FindItem (const wxString& itemString) const +{ + char buf1[200]; + char buf2[200]; + wxStripMenuCodes ((char *)(const char *)itemString, buf1); + + for (wxNode * node = m_menuItems.First (); node; node = node->Next ()) + { + wxMenuItem *item = (wxMenuItem *) node->Data (); + if (item->GetSubMenu()) + { + int ans = item->GetSubMenu()->FindItem(itemString); + if (ans > -1) + return ans; + } + if ( !item->IsSeparator() ) + { + wxStripMenuCodes((char *)item->GetName().c_str(), buf2); + if (strcmp(buf1, buf2) == 0) + return item->GetId(); + } + } + + return -1; +} + +wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const +{ + if (itemMenu) + *itemMenu = NULL; + for (wxNode * node = m_menuItems.First (); node; node = node->Next ()) + { + wxMenuItem *item = (wxMenuItem *) node->Data (); + + if (item->GetId() == itemId) + { + if (itemMenu) + *itemMenu = (wxMenu *) this; + return item; + } + + if (item->GetSubMenu()) + { + wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu); + if (ans) + return ans; + } + } + + if (itemMenu) + *itemMenu = NULL; + return NULL; +} + +void wxMenu::SetHelpString(int itemId, const wxString& helpString) +{ + wxMenuItem *item = FindItemForId (itemId); + if (item) + item->SetHelp(helpString); +} + +wxString wxMenu::GetHelpString (int itemId) const +{ + wxMenuItem *item = FindItemForId (itemId); + wxString str(""); + return (item == NULL) ? str : item->GetHelp(); +} + +void wxMenu::ProcessCommand(wxCommandEvent & event) +{ + bool processed = FALSE; + + // Try a callback + if (m_callback) + { + (void) (*(m_callback)) (*this, event); + processed = TRUE; + } + + // Try the menu's event handler + if ( !processed && GetEventHandler()) + { + processed = GetEventHandler()->ProcessEvent(event); + } + + // Try the window the menu was popped up from (and up + // through the hierarchy) + if ( !processed && GetInvokingWindow()) + processed = GetInvokingWindow()->ProcessEvent(event); +} + +bool wxWindow::PopupMenu(wxMenu *menu, int x, int y) +{ + // TODO + return FALSE; +} + +// Menu Bar +wxMenuBar::wxMenuBar() +{ + m_eventHandler = this; + m_menuCount = 0; + m_menus = NULL; + m_titles = NULL; + m_menuBarFrame = NULL; + + // TODO +} + +wxMenuBar::wxMenuBar(int n, wxMenu *Mmnus[], const wxString titles[]) +{ + m_eventHandler = this; + m_menuCount = n; + m_menus = menus; + m_titles = new wxString[n]; + int i; + for ( i = 0; i < n; i++ ) + m_titles[i] = titles[i]; + m_menuBarFrame = NULL; + + // TODO +} + +wxMenuBar::~wxMenuBar() +{ + int i; + for (i = 0; i < m_menuCount; i++) + { + delete m_menus[i]; + } + delete[] m_menus; + delete[] m_titles; + + // TODO +} + +// Must only be used AFTER menu has been attached to frame, +// otherwise use individual menus to enable/disable items +void wxMenuBar::Enable(int id, bool flag) +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + if (!item) + return; + + // TODO +} + +void wxMenuBar::EnableTop(int pos, bool flag) +{ + // TODO +} + +// Must only be used AFTER menu has been attached to frame, +// otherwise use individual menus +void wxMenuBar::Check(int id, bool flag) +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + if (!item) + return; + + if (!item->IsCheckable()) + return ; + + // TODO +} + +bool wxMenuBar::Checked(int id) const +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + if (!item) + return FALSE; + + // TODO + return FALSE; +} + +bool wxMenuBar::Enabled(int id) const +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + if (!item) + return FALSE; + + // TODO + return FALSE ; +} + + +void wxMenuBar::SetLabel(int id, const wxString& label) +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + + if (!item) + return; + + // TODO +} + +wxString wxMenuBar::GetLabel(int id) const +{ + wxMenu *itemMenu = NULL; + wxMenuItem *item = FindItemForId(id, &itemMenu) ; + + if (!item) + return wxString(""); + + // TODO + return wxString("") ; +} + +void wxMenuBar::SetLabelTop(int pos, const wxString& label) +{ + // TODO +} + +wxString wxMenuBar::GetLabelTop(int pos) const +{ + // TODO + return wxString(""); +} + +bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos) +{ + // TODO + return FALSE; +} + +bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title) +{ + // TODO + return FALSE; +} + +void wxMenuBar::Append (wxMenu * menu, const wxString& title) +{ + if (!OnAppend(menu, title)) + return; + + m_menuCount ++; + wxMenu **new_menus = new wxMenu *[m_menuCount]; + wxString *new_titles = new wxString[m_menuCount]; + int i; + + for (i = 0; i < m_menuCount - 1; i++) + { + new_menus[i] = m_menus[i]; + m_menus[i] = NULL; + new_titles[i] = m_titles[i]; + m_titles[i] = ""; + } + if (m_menus) + { + delete[]m_menus; + delete[]m_titles; + } + m_menus = new_menus; + m_titles = new_titles; + + m_menus[m_menuCount - 1] = (wxMenu *)menu; + m_titles[m_menuCount - 1] = title; + + // TODO +} + +void wxMenuBar::Delete(wxMenu * menu, int i) +{ + int j; + int ii = (int) i; + + if (menu != 0) + { + for (ii = 0; ii < m_menuCount; ii++) + { + if (m_menus[ii] == menu) + break; + } + if (ii >= m_menuCount) + return; + } else + { + if (ii < 0 || ii >= m_menuCount) + return; + menu = m_menus[ii]; + } + + if (!OnDelete(menu, ii)) + return; + + menu->SetParent(NULL); + + -- m_menuCount; + for (j = ii; j < m_menuCount; j++) + { + m_menus[j] = m_menus[j + 1]; + m_titles[j] = m_titles[j + 1]; + } +} + +// Find the menu menuString, item itemString, and return the item id. +// Returns -1 if none found. +int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const +{ + char buf1[200]; + char buf2[200]; + wxStripMenuCodes ((char *)(const char *)menuString, buf1); + int i; + for (i = 0; i < m_menuCount; i++) + { + wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2); + if (strcmp (buf1, buf2) == 0) + return m_menus[i]->FindItem (itemString); + } + return -1; +} + +wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const +{ + if (itemMenu) + *itemMenu = NULL; + + wxMenuItem *item = NULL; + int i; + for (i = 0; i < m_menuCount; i++) + if ((item = m_menus[i]->FindItemForId (Id, itemMenu))) + return item; + return NULL; +} + +void wxMenuBar::SetHelpString (int Id, const wxString& helpString) +{ + int i; + for (i = 0; i < m_menuCount; i++) + { + if (m_menus[i]->FindItemForId (Id)) + { + m_menus[i]->SetHelpString (Id, helpString); + return; + } + } +} + +wxString wxMenuBar::GetHelpString (int Id) const +{ + int i; + for (i = 0; i < m_menuCount; i++) + { + if (m_menus[i]->FindItemForId (Id)) + eturn wxString(m_menus[i]->GetHelpString (Id)); + } + return wxString(""); +} + + diff --git a/src/stubs/menuitem.cpp b/src/stubs/menuitem.cpp new file mode 100644 index 0000000000..bd2f876a38 --- /dev/null +++ b/src/stubs/menuitem.cpp @@ -0,0 +1,96 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: menuitem.cpp +// Purpose: wxMenuItem implementation +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +// ============================================================================ +// headers & declarations +// ============================================================================ + +#include "wx/menu.h" +#include "wx/menuitem.h" + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// dynamic classes implementation +// ---------------------------------------------------------------------------- + +#if !USE_SHARED_LIBRARY + IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject) +#endif //USE_SHARED_LIBRARY + +// ---------------------------------------------------------------------------- +// wxMenuItem +// ---------------------------------------------------------------------------- + +// ctor & dtor +// ----------- + +wxMenuItem::wxMenuItem(wxMenu *pParentMenu, int id, + const wxString& strName, const wxString& strHelp, + bool bCheckable, + wxMenu *pSubMenu) : + m_bCheckable(bCheckable), + m_strName(strName), + m_strHelp(strHelp) +{ + wxASSERT( pParentMenu != NULL ); + + m_pParentMenu = pParentMenu; + m_pSubMenu = pSubMenu; + m_idItem = id; + m_bEnabled = TRUE; +} + +wxMenuItem::~wxMenuItem() +{ +} + +// misc +// ---- + +// delete the sub menu +void wxMenuItem::DeleteSubMenu() +{ + wxASSERT( m_pSubMenu != NULL ); + + delete m_pSubMenu; + m_pSubMenu = NULL; +} + +// change item state +// ----------------- + +void wxMenuItem::Enable(bool bDoEnable) +{ + if ( m_bEnabled != bDoEnable ) { + if ( m_pSubMenu == NULL ) { // normal menu item + // TODO + } + else // submenu + { + // TODO + } + + m_bEnabled = bDoEnable; + } +} + +void wxMenuItem::Check(bool bDoCheck) +{ + wxCHECK_RET( IsCheckable(), "only checkable items may be checked" ); + + if ( m_bChecked != bDoCheck ) { + // TODO + m_bChecked = bDoCheck; + } +} \ No newline at end of file diff --git a/src/stubs/metafile.cpp b/src/stubs/metafile.cpp new file mode 100644 index 0000000000..67850103ee --- /dev/null +++ b/src/stubs/metafile.cpp @@ -0,0 +1,236 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: metafile.cpp +// Purpose: wxMetaFile, wxMetaFileDC etc. These classes are optional. +// Author: AUTHOR +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "metafile.h" +#endif + +#include "wx/metafile.h" +#include "wx/clipbrd.h" + +extern bool wxClipboardIsOpen; + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject) +IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC) +#endif + +wxMetaFile::wxMetaFile(const wxString& file) +{ + // TODO +} + +wxMetaFile::~wxMetaFile() +{ + // TODO +} + +bool wxMetaFile::SetClipboard(int width, int height) +{ + bool alreadyOpen=wxClipboardOpen(); + if (!alreadyOpen) + { + wxOpenClipboard(); + if (!wxEmptyClipboard()) return FALSE; + } + bool success = wxSetClipboardData(wxDF_METAFILE,this, width,height); + if (!alreadyOpen) wxCloseClipboard(); + return (bool) success; +} + +bool wxMetaFile::Play(wxDC *dc) +{ + // TODO + return false; +} + +/* + * Metafile device context + * + */ + +// Original constructor that does not takes origin and extent. If you use this, +// *DO* give origin/extent arguments to wxMakeMetaFilePlaceable. +wxMetaFileDC::wxMetaFileDC(const wxString& file) +{ + // TODO +} + +// New constructor that takes origin and extent. If you use this, don't +// give origin/extent arguments to wxMakeMetaFilePlaceable. +wxMetaFileDC::wxMetaFileDC(const wxString& file, int xext, int yext, int xorg, int yorg) +{ + // TODO +} + +wxMetaFileDC::~wxMetaFileDC() +{ +} + +void wxMetaFileDC::GetTextExtent(const wxString& string, float *x, float *y, + float *descent, float *externalLeading, wxFont *theFont, bool use16bit) +{ + // TODO +} + +wxMetaFile *wxMetaFileDC::Close() +{ + // TODO + return NULL; +} + +void wxMetaFileDC::SetMapMode(int mode) +{ + // TODO +} + +#if 0 + +#ifdef __WIN32__ +struct RECT32 +{ + short left; + short top; + short right; + short bottom; +}; + +struct mfPLACEABLEHEADER { + DWORD key; + short hmf; + RECT32 bbox; + WORD inch; + DWORD reserved; + WORD checksum; +}; +#else +struct mfPLACEABLEHEADER { + DWORD key; + HANDLE hmf; + RECT bbox; + WORD inch; + DWORD reserved; + WORD checksum; +}; +#endif + +/* + * Pass filename of existing non-placeable metafile, and bounding box. + * Adds a placeable metafile header, sets the mapping mode to anisotropic, + * and sets the window origin and extent to mimic the MM_TEXT mapping mode. + * + */ + +bool wxMakeMetaFilePlaceable(const wxString& filename, float scale) +{ + return wxMakeMetaFilePlaceable(filename, 0, 0, 0, 0, scale, FALSE); +} + +bool wxMakeMetaFilePlaceable(const wxString& filename, int x1, int y1, int x2, int y2, float scale, bool useOriginAndExtent) +{ + // I'm not sure if this is the correct way of suggesting a scale + // to the client application, but it's the only way I can find. + int unitsPerInch = (int)(576/scale); + + mfPLACEABLEHEADER header; + header.key = 0x9AC6CDD7L; + header.hmf = 0; + header.bbox.left = (int)(x1); + header.bbox.top = (int)(y1); + header.bbox.right = (int)(x2); + header.bbox.bottom = (int)(y2); + header.inch = unitsPerInch; + header.reserved = 0; + + // Calculate checksum + WORD *p; + mfPLACEABLEHEADER *pMFHead = &header; + for (p =(WORD *)pMFHead,pMFHead -> checksum = 0; + p < (WORD *)&pMFHead ->checksum; ++p) + pMFHead ->checksum ^= *p; + + FILE *fd = fopen((char *)(const char *)filename, "rb"); + if (!fd) return FALSE; + + char tempFileBuf[256]; + wxGetTempFileName("mf", tempFileBuf); + FILE *fHandle = fopen(tempFileBuf, "wb"); + if (!fHandle) + return FALSE; + fwrite((void *)&header, sizeof(unsigned char), sizeof(mfPLACEABLEHEADER), fHandle); + + // Calculate origin and extent + int originX = x1; + int originY = y1; + int extentX = x2 - x1; + int extentY = (y2 - y1); + + // Read metafile header and write + METAHEADER metaHeader; + fread((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fd); + + if (useOriginAndExtent) + metaHeader.mtSize += 15; + else + metaHeader.mtSize += 5; + + fwrite((void *)&metaHeader, sizeof(unsigned char), sizeof(metaHeader), fHandle); + + // Write SetMapMode, SetWindowOrigin and SetWindowExt records + char modeBuffer[8]; + char originBuffer[10]; + char extentBuffer[10]; + METARECORD *modeRecord = (METARECORD *)&modeBuffer; + + METARECORD *originRecord = (METARECORD *)&originBuffer; + METARECORD *extentRecord = (METARECORD *)&extentBuffer; + + modeRecord->rdSize = 4; + modeRecord->rdFunction = META_SETMAPMODE; + modeRecord->rdParm[0] = MM_ANISOTROPIC; + + originRecord->rdSize = 5; + originRecord->rdFunction = META_SETWINDOWORG; + originRecord->rdParm[0] = originY; + originRecord->rdParm[1] = originX; + + extentRecord->rdSize = 5; + extentRecord->rdFunction = META_SETWINDOWEXT; + extentRecord->rdParm[0] = extentY; + extentRecord->rdParm[1] = extentX; + + fwrite((void *)modeBuffer, sizeof(char), 8, fHandle); + + if (useOriginAndExtent) + { + fwrite((void *)originBuffer, sizeof(char), 10, fHandle); + fwrite((void *)extentBuffer, sizeof(char), 10, fHandle); + } + + int ch = -2; + while (ch != EOF) + { + ch = getc(fd); + if (ch != EOF) + { + putc(ch, fHandle); + } + } + fclose(fHandle); + fclose(fd); + wxRemoveFile(filename); + wxCopyFile(tempFileBuf, filename); + wxRemoveFile(tempFileBuf); + return TRUE; +} + +#endif + diff --git a/src/stubs/minifram.cpp b/src/stubs/minifram.cpp new file mode 100644 index 0000000000..4f6f5e5fcb --- /dev/null +++ b/src/stubs/minifram.cpp @@ -0,0 +1,22 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: minifram.cpp +// Purpose: wxMiniFrame. Optional; identical to wxFrame if not supported. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "minifram.h" +#endif + +#include "wx/minifram.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxMiniFrame, wxFrame) +#endif + + diff --git a/src/stubs/msgdlg.cpp b/src/stubs/msgdlg.cpp new file mode 100644 index 0000000000..775ac8f064 --- /dev/null +++ b/src/stubs/msgdlg.cpp @@ -0,0 +1,36 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: msgdlg.cpp +// Purpose: wxMessageDialog +// Author: AUTHOR +// Modified by: +// Created: 04/01/98 +// RCS-ID: $$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "msgdlg.h" +#endif + +#include "wx/msgdlg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_CLASS(wxMessageDialog, wxDialog) +#endif + +wxMessageDialog::wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption, + long style, const wxPoint& pos) +{ + m_caption = caption; + m_message = message; + m_dialogStyle = style; + m_parent = parent; +} + +int wxMessageDialog::ShowModal() +{ + // TODO + return wxID_CANCEL; +} + diff --git a/src/stubs/notebook.cpp b/src/stubs/notebook.cpp new file mode 100644 index 0000000000..aecb879f4b --- /dev/null +++ b/src/stubs/notebook.cpp @@ -0,0 +1,371 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: notebook.cpp +// Purpose: implementation of wxNotebook +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- +#ifdef __GNUG__ +#pragma implementation "notebook.h" +#endif + +#include +#include +#include +#include + +// ---------------------------------------------------------------------------- +// macros +// ---------------------------------------------------------------------------- + +// check that the page index is valid +#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount())) + +// ---------------------------------------------------------------------------- +// event table +// ---------------------------------------------------------------------------- + +#if !USE_SHARED_LIBRARIES +BEGIN_EVENT_TABLE(wxNotebook, wxControl) + EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange) + + EVT_SIZE(wxNotebook::OnSize) + EVT_SET_FOCUS(wxNotebook::OnSetFocus) + EVT_NAVIGATION_KEY(wxNotebook::OnNavigationKey) +END_EVENT_TABLE() + +IMPLEMENT_DYNAMIC_CLASS(wxNotebook, wxControl) +IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent) +#endif + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxNotebook construction +// ---------------------------------------------------------------------------- + +// common part of all ctors +void wxNotebook::Init() +{ + m_pImageList = NULL; + m_nSelection = -1; +} + +// default for dynamic class +wxNotebook::wxNotebook() +{ + Init(); +} + +// the same arguments as for wxControl +wxNotebook::wxNotebook(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + Init(); + + Create(parent, id, pos, size, style, name); +} + +// Create() function +bool wxNotebook::Create(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + // base init + SetName(name); + SetParent(parent); + + m_windowId = id == -1 ? NewControlId() : id; + + // colors and font + m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE)); + m_foregroundColour = *wxBLACK ; + + // style + m_windowStyle = style; + + if ( parent != NULL ) + parent->AddChild(this); + + // TODO + + return FALSE; +} + +// dtor +wxNotebook::~wxNotebook() +{ +} + +// ---------------------------------------------------------------------------- +// wxNotebook accessors +// ---------------------------------------------------------------------------- +int wxNotebook::GetPageCount() const +{ + return m_aPages.Count(); +} + +int wxNotebook::GetRowCount() const +{ + // TODO + return 0; +} + +int wxNotebook::SetSelection(int nPage) +{ + wxASSERT( IS_VALID_PAGE(nPage) ); + + ChangePage(m_nSelection, nPage); + + // TODO + return 0; +} + +void wxNotebook::AdvanceSelection(bool bForward) +{ + int nSel = GetSelection(); + int nMax = GetPageCount() - 1; + if ( bForward ) + SetSelection(nSel == nMax ? 0 : nSel + 1); + else + SetSelection(nSel == 0 ? nMax : nSel - 1); +} + +bool wxNotebook::SetPageText(int nPage, const wxString& strText) +{ + wxASSERT( IS_VALID_PAGE(nPage) ); + + // TODO + return FALSE; +} + +wxString wxNotebook::GetPageText(int nPage) const +{ + wxASSERT( IS_VALID_PAGE(nPage) ); + + // TODO + return wxString(""); +} + +int wxNotebook::GetPageImage(int nPage) const +{ + wxASSERT( IS_VALID_PAGE(nPage) ); + + // TODO + return 0; +} + +bool wxNotebook::SetPageImage(int nPage, int nImage) +{ + wxASSERT( IS_VALID_PAGE(nPage) ); + + // TODO + return FALSE; +} + +void wxNotebook::SetImageList(wxImageList* imageList) +{ + m_pImageList = imageList; + // TODO +} + +// ---------------------------------------------------------------------------- +// wxNotebook operations +// ---------------------------------------------------------------------------- + +// remove one page from the notebook +bool wxNotebook::DeletePage(int nPage) +{ + wxCHECK( IS_VALID_PAGE(nPage), FALSE ); + + // TODO: delete native widget page + + delete m_aPages[nPage]; + m_aPages.Remove(nPage); + + return TRUE; +} + +// remove all pages +bool wxNotebook::DeleteAllPages() +{ + // TODO: delete native widget pages + + int nPageCount = GetPageCount(); + int nPage; + for ( nPage = 0; nPage < nPageCount; nPage++ ) + delete m_aPages[nPage]; + + m_aPages.Clear(); + + return TRUE; +} + +// add a page to the notebook +bool wxNotebook::AddPage(wxNotebookPage *pPage, + const wxString& strText, + bool bSelect, + int imageId) +{ + return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId); +} + +// same as AddPage() but does it at given position +bool wxNotebook::InsertPage(int nPage, + wxNotebookPage *pPage, + const wxString& strText, + bool bSelect, + int imageId) +{ + wxASSERT( pPage != NULL ); + wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE ); + + // TODO: insert native widget page + + // save the pointer to the page + m_aPages.Insert(pPage, nPage); + + // some page must be selected: either this one or the first one if there is + // still no selection + if ( bSelect ) + m_nSelection = nPage; + else if ( m_nSelection == -1 ) + m_nSelection = 0; + + return TRUE; +} + +// ---------------------------------------------------------------------------- +// wxNotebook callbacks +// ---------------------------------------------------------------------------- + +// @@@ OnSize() is used for setting the font when it's called for the first +// time because doing it in ::Create() doesn't work (for unknown reasons) +void wxNotebook::OnSize(wxSizeEvent& event) +{ + static bool s_bFirstTime = TRUE; + if ( s_bFirstTime ) { + // TODO: any first-time-size processing. + s_bFirstTime = FALSE; + } + + // TODO: all this may or may not be necessary for your platform + + // emulate page change (it's esp. important to do it first time because + // otherwise our page would stay invisible) + int nSel = m_nSelection; + m_nSelection = -1; + SetSelection(nSel); + + // fit the notebook page to the tab control's display area + int w, hl + GetSize(&w, &h); + + uint nCount = m_aPages.Count(); + for ( uint nPage = 0; nPage < nCount; nPage++ ) { + wxNotebookPage *pPage = m_aPages[nPage]; + pPage->SetSize(0, 0, w, h); + if ( pPage->GetAutoLayout() ) + pPage->Layout(); + } + + // Processing continues to next OnSize + event.Skip(); +} + +void wxNotebook::OnSelChange(wxNotebookEvent& event) +{ + // is it our tab control? + if ( event.GetEventObject() == this ) + ChangePage(event.GetOldSelection(), event.GetSelection()); + + // we want to give others a chance to process this message as well + event.Skip(); +} + +void wxNotebook::OnSetFocus(wxFocusEvent& event) +{ + // set focus to the currently selected page if any + if ( m_nSelection != -1 ) + m_aPages[m_nSelection]->SetFocus(); + + event.Skip(); +} + +void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event) +{ + if ( event.IsWindowChange() ) { + // change pages + AdvanceSelection(event.GetDirection()); + } + else { + // pass to the parent + if ( GetParent() ) { + event.SetCurrentFocus(this); + GetParent()->ProcessEvent(event); + } + } +} + +// ---------------------------------------------------------------------------- +// wxNotebook base class virtuals +// ---------------------------------------------------------------------------- + +// override these 2 functions to do nothing: everything is done in OnSize + +void wxNotebook::SetConstraintSizes(bool /* recurse */) +{ + // don't set the sizes of the pages - their correct size is not yet known + wxControl::SetConstraintSizes(FALSE); +} + +bool wxNotebook::DoPhase(int /* nPhase */) +{ + return TRUE; +} + +void wxNotebook::Command(wxCommandEvent& event) +{ + wxFAIL_MSG("wxNotebook::Command not implemented"); +} + +// ---------------------------------------------------------------------------- +// wxNotebook helper functions +// ---------------------------------------------------------------------------- + +// hide the currently active panel and show the new one +void wxNotebook::ChangePage(int nOldSel, int nSel) +{ + wxASSERT( nOldSel != nSel ); // impossible + + if ( nOldSel != -1 ) { + m_aPages[nOldSel]->Show(FALSE); + } + + wxNotebookPage *pPage = m_aPages[nSel]; + pPage->Show(TRUE); + pPage->SetFocus(); + + m_nSelection = nSel; +} + diff --git a/src/stubs/palette.cpp b/src/stubs/palette.cpp new file mode 100644 index 0000000000..445b545f0c --- /dev/null +++ b/src/stubs/palette.cpp @@ -0,0 +1,91 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: palette.cpp +// Purpose: wxPalette +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "palette.h" +#endif + +#include "wx/palette.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject) +#endif + +/* + * Palette + * + */ + +wxPaletteRefData::wxPaletteRefData() +{ + // TODO +} + +wxPaletteRefData::~wxPaletteRefData() +{ + // TODO +} + +wxPalette::wxPalette() +{ +} + +wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue) +{ + Create(n, red, green, blue); +} + +wxPalette::~wxPalette() +{ +} + +bool wxPalette::FreeResource(bool force) +{ + if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette) + { + DeleteObject((HPALETTE)M_PALETTEDATA->m_hPalette); + } + return TRUE; +} + +bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue) +{ + UnRef(); + + m_refData = new wxPaletteRefData; + + // TODO + + return FALSE; +} + +int wxPalette::GetPixel(const unsigned char red, const unsigned char green, const unsigned char blue) const +{ + if ( !m_refData ) + return FALSE; + + // TODO + return FALSE; +} + +bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const +{ + if ( !m_refData ) + return FALSE; + + if (index < 0 || index > 255) + return FALSE; + + // TODO + return FALSE; +} + + diff --git a/src/stubs/pen.cpp b/src/stubs/pen.cpp new file mode 100644 index 0000000000..d7b2ce264c --- /dev/null +++ b/src/stubs/pen.cpp @@ -0,0 +1,229 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: pen.cpp +// Purpose: wxPen +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "pen.h" +#endif + +#include "wx/setup.h" +#include "wx/utils.h" +#include "wx/pen.h" + +#if !USE_SHARED_LIBRARIES +IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject) +#endif + +wxPenRefData::wxPenRefData() +{ + m_style = wxSOLID; + m_width = 1; + m_join = wxJOIN_ROUND ; + m_cap = wxCAP_ROUND ; + m_nbDash = 0 ; + m_dash = 0 ; +/* TODO: null data + m_hPen = 0; +*/ +} + +wxPenRefData::wxPenRefData(const wxPenRefData& data) +{ + m_style = data.m_style; + m_width = data.m_width; + m_join = data.m_join; + m_cap = data.m_cap; + m_nbDash = data.m_nbDash; + m_dash = data.m_dash; + m_colour = data.m_colour; +/* TODO: null data + m_hPen = 0; +*/ +} + +wxPenRefData::~wxPenRefData() +{ + // TODO: delete data +} + +// Pens + +wxPen::wxPen() +{ + if ( wxThePenList ) + wxThePenList->AddPen(this); +} + +wxPen::~wxPen() +{ + if (wxThePenList) + wxThePenList->RemovePen(this); +} + +// Should implement Create +wxPen::wxPen(const wxColour& col, int Width, int Style) +{ + m_refData = new wxPenRefData; + + M_PENDATA->m_colour = col; + M_PENDATA->m_width = Width; + M_PENDATA->m_style = Style; + M_PENDATA->m_join = wxJOIN_ROUND ; + M_PENDATA->m_cap = wxCAP_ROUND ; + M_PENDATA->m_nbDash = 0 ; + M_PENDATA->m_dash = 0 ; + + RealizeResource(); + + if ( wxThePenList ) + wxThePenList->AddPen(this); +} + +wxPen::wxPen(const wxBitmap& stipple, int Width) +{ + m_refData = new wxPenRefData; + + M_PENDATA->m_stipple = stipple; + M_PENDATA->m_width = Width; + M_PENDATA->m_style = wxSTIPPLE; + M_PENDATA->m_join = wxJOIN_ROUND ; + M_PENDATA->m_cap = wxCAP_ROUND ; + M_PENDATA->m_nbDash = 0 ; + M_PENDATA->m_dash = 0 ; + + RealizeResource(); + + if ( wxThePenList ) + wxThePenList->AddPen(this); +} + +wxPen::wxPen(const wxString& col, int Width, int Style) +{ + m_refData = new wxPenRefData; + + M_PENDATA->m_colour = col; + M_PENDATA->m_width = Width; + M_PENDATA->m_style = Style; + M_PENDATA->m_join = wxJOIN_ROUND ; + M_PENDATA->m_cap = wxCAP_ROUND ; + M_PENDATA->m_nbDash = 0 ; + M_PENDATA->m_dash = 0 ; + + RealizeResource(); + + if ( wxThePenList ) + wxThePenList->AddPen(this); +} + +void wxPen::Unshare() +{ + // Don't change shared data + if (!m_refData) + { + m_refData = new wxPenRefData(); + } + else + { + wxPenRefData* ref = new wxPenRefData(*(wxPenRefData*)m_refData); + UnRef(); + m_refData = ref; + } +} + +void wxPen::SetColour(const wxColour& col) +{ + Unshare(); + + M_PENDATA->m_colour = col; + + RealizeResource(); +} + +void wxPen::SetColour(const wxString& col) +{ + Unshare(); + + M_PENDATA->m_colour = col; + + RealizeResource(); +} + +void wxPen::SetColour(const unsigned char r, const unsigned char g, const unsigned char b) +{ + Unshare(); + + M_PENDATA->m_colour.Set(r, g, b); + + RealizeResource(); +} + +void wxPen::SetWidth(int Width) +{ + Unshare(); + + M_PENDATA->m_width = Width; + + RealizeResource(); +} + +void wxPen::SetStyle(int Style) +{ + Unshare(); + + M_PENDATA->m_style = Style; + + RealizeResource(); +} + +void wxPen::SetStipple(const wxBitmap& Stipple) +{ + Unshare(); + + M_PENDATA->m_stipple = Stipple; + M_PENDATA->m_style = wxSTIPPLE; + + RealizeResource(); +} + +void wxPen::SetDashes(int nb_dashes, const wxDash *Dash) +{ + Unshare(); + + M_PENDATA->m_nbDash = nb_dashes; + M_PENDATA->m_dash = (wxDash *)Dash; + + RealizeResource(); +} + +void wxPen::SetJoin(int Join) +{ + Unshare(); + + M_PENDATA->m_join = Join; + + RealizeResource(); +} + +void wxPen::SetCap(int Cap) +{ + Unshare(); + + M_PENDATA->m_cap = Cap; + + RealizeResource(); +} + +bool wxPen::RealizeResource() +{ + // TODO: create actual pen + return FALSE; +} + + diff --git a/src/stubs/print.cpp b/src/stubs/print.cpp new file mode 100644 index 0000000000..2aba87f3d4 --- /dev/null +++ b/src/stubs/print.cpp @@ -0,0 +1,81 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: print.cpp +// Purpose: Print framework +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "print.h" +#endif + +#include "wx/print.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxPrinter, wxPrinterBase) +IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase) +#endif + +/* + * Printer + */ + +wxPrinter::wxPrinter(wxPrintData *data): + wxPrinterBase(data) +{ +} + +wxPrinter::~wxPrinter() +{ +} + +bool wxPrinter::Print(wxWindow *parent, wxPrintout *printout, bool prompt) +{ + // TODO. See wxPostScriptPrinter::Print for hints. + return FALSE; +} + +bool wxPrinter::PrintDialog(wxWindow *parent) +{ + wxPrintDialog dialog(parent, & printData); + return (dialog.ShowModal() == wxID_OK); +} + +bool wxPrinter::Setup(wxWindow *parent) +{ + wxPrintDialog dialog(parent, & printData); + dialog.GetPrintData().SetSetupDialog(TRUE); + return (dialog.ShowModal() == wxID_OK); +} + +/* + * Print preview + */ + +wxWindowsPrintPreview::wxWindowsPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data): + wxPrintPreviewBase(printout, printoutForPrinting, data) +{ + DetermineScaling(); +} + +wxWindowsPrintPreview::~wxWindowsPrintPreview() +{ +} + +bool wxWindowsPrintPreview::Print(bool interactive) +{ + if (!printPrintout) + return FALSE; + wxPrinter printer(&printData); + return printer.Print(previewFrame, printPrintout, interactive); +} + +void wxWindowsPrintPreview::DetermineScaling() +{ + // TODO +} + diff --git a/src/stubs/printdlg.cpp b/src/stubs/printdlg.cpp new file mode 100644 index 0000000000..4a78ae47e0 --- /dev/null +++ b/src/stubs/printdlg.cpp @@ -0,0 +1,124 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: printdlg.cpp +// Purpose: wxPrintDialog, wxPageSetupDialog +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "printdlg.h" +#endif + +#include "wx/printdlg.h" +#include "wx/dcprint.h" + +// Use generic page setup dialog: use your own native one if one exists. +#include "wx/generic/prntdlgg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxPrintDialog, wxDialog) +IMPLEMENT_CLASS(wxPageSetupDialog, wxDialog) +#endif + +wxPrintDialog::wxPrintDialog(): + wxDialog() +{ + dialogParent = NULL; + printerDC = NULL; + destroyDC = TRUE; + deviceName = NULL; + driverName = NULL; + portName = NULL; +} + +wxPrintDialog::wxPrintDialog(wxWindow *p, wxPrintData* data): + wxDialog() +{ + Create(p, data); +} + +bool wxPrintDialog::Create(wxWindow *p, wxPrintData* data) +{ + dialogParent = p; + printerDC = NULL; + destroyDC = TRUE; + deviceName = NULL; + driverName = NULL; + portName = NULL; + + if ( data ) + printData = *data; + + return TRUE; +} + +wxPrintDialog::~wxPrintDialog() +{ + if (destroyDC && printerDC) + delete printerDC; + if (deviceName) delete[] deviceName; + if (driverName) delete[] driverName; + if (portName) delete[] portName; +} + +int wxPrintDialog::ShowModal() +{ + // TODO + return wxID_CANCEL; +} + +wxDC *wxPrintDialog::GetPrintDC() +{ + if (printerDC) + { + destroyDC = FALSE; + return printerDC; + } + else + return NULL; +} + +/* + * wxPageSetupDialog + */ + +wxPageSetupDialog::wxPageSetupDialog(): + wxDialog() +{ + m_dialogParent = NULL; +} + +wxPageSetupDialog::wxPageSetupDialog(wxWindow *p, wxPageSetupData *data): + wxDialog() +{ + Create(p, data); +} + +bool wxPageSetupDialog::Create(wxWindow *p, wxPageSetupData *data) +{ + m_dialogParent = p; + + if (data) + m_pageSetupData = (*data); + + return TRUE; +} + +wxPageSetupDialog::~wxPageSetupDialog() +{ +} + +int wxPageSetupDialog::ShowModal() +{ + // Uses generic page setup dialog + wxGenericPageSetupDialog *genericPageSetupDialog = new wxGenericPageSetupDialog(GetParent(), & m_pageSetupData); + int ret = genericPageSetupDialog->ShowModal(); + m_pageSetupData = genericPageSetupDialog->GetPageSetupData(); + genericPageSetupDialog->Close(TRUE); + return ret; +} + diff --git a/src/stubs/radiobox.cpp b/src/stubs/radiobox.cpp new file mode 100644 index 0000000000..da582d0e52 --- /dev/null +++ b/src/stubs/radiobox.cpp @@ -0,0 +1,194 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobox.cpp +// Purpose: wxRadioBox +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "radiobox.h" +#endif + +#include "wx/radiobox.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl) +#endif + +// Radio box item +wxRadioBox::wxRadioBox() +{ + m_selectedButton = -1; + m_noItems = 0; + m_noRowsOrCols = 0; + m_majorDim = 0 ; +} + +bool wxRadioBox::Create(wxWindow *parent, wxWindowID id, const wxString& title, + const wxPoint& pos, const wxSize& size, + int n, const wxString choices[], + int majorDim, long style, + const wxValidator& val, const wxString& name) +{ + m_selectedButton = -1; + m_noItems = n; + + SetName(name); + SetValidator(val); + + parent->AddChild(this); + + m_windowStyle = (long&)style; + + if (id == -1) + m_windowId = NewControlId(); + else + m_windowId = id; + + m_noRowsOrCols = majorDim; + + if (majorDim==0) + m_majorDim = n ; + else + m_majorDim = majorDim ; + + + // TODO create radiobox + return FALSE; +} + + +wxRadioBox::~wxRadioBox() +{ + // TODO +} + +wxString wxRadioBox::GetLabel(int item) const +{ + // TODO + return wxString(""); +} + +void wxRadioBox::SetLabel(int item, const wxString& label) +{ + // TODO +} + +int wxRadioBox::FindString(const wxString& s) const +{ + // TODO + return -1; +} + +void wxRadioBox::SetSelection(int n) +{ + if ((n < 0) || (n >= m_noItems)) + return; + // TODO + + m_selectedButton = n; +} + +// Get single selection, for single choice list items +int wxRadioBox::GetSelection() const +{ + return m_selectedButton; +} + +// Find string for position +wxString wxRadioBox::GetString(int n) const +{ + // TODO + return wxString(""); +} + +void wxRadioBox::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxRadioBox::GetSize(int *width, int *height) const +{ + // TODO +} + +void wxRadioBox::GetPosition(int *x, int *y) const +{ + // TODO +} + +wxString wxRadioBox::GetLabel() const +{ + // TODO + return wxString(""); +} + +void wxRadioBox::SetLabel(const wxString& label) +{ + // TODO +} + +void wxRadioBox::SetFocus() +{ + // TODO +} + +bool wxRadioBox::Show(bool show) +{ + // TODO + return FALSE; +} + +// Enable a specific button +void wxRadioBox::Enable(int item, bool enable) +{ + // TODO +} + +// Enable all controls +void wxRadioBox::Enable(bool enable) +{ + wxControl::Enable(enable); + + // TODO +} + +// Show a specific button +void wxRadioBox::Show(int item, bool show) +{ + // TODO +} + +// For single selection items only +wxString wxRadioBox::GetStringSelection () const +{ + int sel = GetSelection (); + if (sel > -1) + return this->GetString (sel); + else + return wxString(""); +} + +bool wxRadioBox::SetStringSelection (const wxString& s) +{ + int sel = FindString (s); + if (sel > -1) + { + SetSelection (sel); + return TRUE; + } + else + return FALSE; +} + +void wxRadioBox::Command (wxCommandEvent & event) +{ + SetSelection (event.m_commandInt); + ProcessCommand (event); +} + + diff --git a/src/stubs/radiobut.cpp b/src/stubs/radiobut.cpp new file mode 100644 index 0000000000..65baab38b6 --- /dev/null +++ b/src/stubs/radiobut.cpp @@ -0,0 +1,68 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: radiobut.cpp +// Purpose: wxRadioButton +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "radiobut.h" +#endif + +#include "wx/radiobut.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl) +#endif + +bool wxRadioButton::Create(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_windowStyle = style ; + + // TODO create radiobutton + return FALSE; +} + +void wxRadioButton::SetLabel(const wxString& label) +{ + // TODO +} + +void wxRadioButton::SetValue(bool value) +{ + // TODO +} + +// Get single selection, for single choice list items +bool wxRadioButton::GetValue() const +{ + // TODO + return FALSE; +} + +void wxRadioButton::Command (wxCommandEvent & event) +{ + SetValue ( (event.m_commandInt != 0) ); + ProcessCommand (event); +} + + diff --git a/src/stubs/region.cpp b/src/stubs/region.cpp new file mode 100644 index 0000000000..d03d8e8020 --- /dev/null +++ b/src/stubs/region.cpp @@ -0,0 +1,373 @@ +///////////////////////////////////////////////////////////////////////////// +// File: region.cpp +// Purpose: Region class +// Author: Markus Holzem/Julian Smart/AUTHOR +// Created: Fri Oct 24 10:46:34 MET 1997 +// RCS-ID: $Id$ +// Copyright: (c) 1997 Markus Holzem/Julian Smart/AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "region.h" +#endif + +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#include "wx/msw/region.h" +#include "wx/gdicmn.h" + +#include + +#if !USE_SHARED_LIBRARY + IMPLEMENT_DYNAMIC_CLASS(wxRegion, wxGDIObject) + IMPLEMENT_DYNAMIC_CLASS(wxRegionIterator, wxObject) +#endif + +//----------------------------------------------------------------------------- +// wxRegionRefData implementation +//----------------------------------------------------------------------------- + +class WXDLLEXPORT wxRegionRefData : public wxGDIRefData { +public: + wxRegionRefData() + { + } + + wxRegionRefData(const wxRegionRefData& data) + { + // TODO + } + + ~wxRegionRefData() + { + // TODO + } + + HRGN m_region; +}; + + +//----------------------------------------------------------------------------- +// wxRegion +//----------------------------------------------------------------------------- + +/*! + * Create an empty region. + */ +wxRegion::wxRegion() +{ + m_refData = new wxRegionRefData; + // TODO create empty region +} + +wxRegion::wxRegion(long x, long y, long w, long h) +{ + m_refData = new wxRegionRefData; + // TODO create rect region +} + +wxRegion::wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight) +{ + m_refData = new wxRegionRefData; + // TODO create rect region +} + +wxRegion::wxRegion(const wxRect& rect) +{ + m_refData = new wxRegionRefData; + // TODO create rect region +} + +/*! + * Destroy the region. + */ +wxRegion::~wxRegion() +{ + // m_refData unrefed in ~wxObject +} + +//----------------------------------------------------------------------------- +//# Modify region +//----------------------------------------------------------------------------- + +//! Clear current region +void wxRegion::Clear() +{ + UnRef(); +} + +//! Combine rectangle (x, y, w, h) with this. +bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op) +{ + // Don't change shared data + if (!m_refData) { + m_refData = new wxRegionRefData(); + } else if (m_refData->GetRefCount() > 1) { + wxRegionRefData* ref = (wxRegionRefData*)m_refData; + UnRef(); + m_refData = new wxRegionRefData(*ref); + } + // If ref count is 1, that means it's 'ours' anyway so no action. + + // TODO create rect region + + int mode = 0; // TODO platform-specific code + switch (op) + { + case wxRGN_AND: + // TODO + break ; + case wxRGN_OR: + // TODO + break ; + case wxRGN_XOR: + // TODO + break ; + case wxRGN_DIFF: + // TODO + break ; + case wxRGN_COPY: + default: + // TODO + break ; + } + + // TODO do combine region + + return FALSE; +} + +//! Union /e region with this. +bool wxRegion::Combine(const wxRegion& region, wxRegionOp op) +{ + if (region.Empty()) + return FALSE; + + // Don't change shared data + if (!m_refData) { + m_refData = new wxRegionRefData(); + } else if (m_refData->GetRefCount() > 1) { + wxRegionRefData* ref = (wxRegionRefData*)m_refData; + UnRef(); + m_refData = new wxRegionRefData(*ref); + } + + int mode = 0; // TODO platform-specific code + switch (op) + { + case wxRGN_AND: + // TODO + break ; + case wxRGN_OR: + // TODO + break ; + case wxRGN_XOR: + // TODO + break ; + case wxRGN_DIFF: + // TODO + break ; + case wxRGN_COPY: + default: + // TODO + break ; + } + + // TODO combine region + + return FALSE; +} + +bool wxRegion::Combine(const wxRect& rect, wxRegionOp op) +{ + return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op); +} + +//----------------------------------------------------------------------------- +//# Information on region +//----------------------------------------------------------------------------- + +// Outer bounds of region +void wxRegion::GetBox(long& x, long& y, long&w, long &h) const +{ + if (m_refData) { + // TODO get box + } else { + x = y = w = h = 0; + } +} + +wxRect wxRegion::GetBox() const +{ + long x, y, w, h; + GetBox(x, y, w, h); + return wxRect(x, y, w, h); +} + +// Is region empty? +bool wxRegion::Empty() const +{ + // TODO + return FALSE; +} + +//----------------------------------------------------------------------------- +//# Tests +//----------------------------------------------------------------------------- + +// Does the region contain the point (x,y)? +wxRegionContain wxRegion::Contains(long x, long y) const +{ + if (!m_refData) + return wxOutRegion; + + // TODO. Return wxInRegion if within region. + if (0) + return wxInRegion; + return wxOutRegion; +} + +// Does the region contain the point pt? +wxRegionContain wxRegion::Contains(const wxPoint& pt) const +{ + if (!m_refData) + return wxOutRegion; + + // TODO. Return wxInRegion if within region. + if (0) + return wxInRegion; + else + return wxOutRegion; +} + +// Does the region contain the rectangle (x, y, w, h)? +wxRegionContain wxRegion::Contains(long x, long y, long w, long h) const +{ + if (!m_refData) + return wxOutRegion; + + // TODO. Return wxInRegion if within region. + if (0) + return wxInRegion; + else + return wxOutRegion; +} + +// Does the region contain the rectangle rect +wxRegionContain wxRegion::Contains(const wxRect& rect) const +{ + if (!m_refData) + return wxOutRegion; + + long x, y, w, h; + x = rect.x; + y = rect.y; + w = rect.GetWidth(); + h = rect.GetHeight(); + return Contains(x, y, w, h); +} + +/////////////////////////////////////////////////////////////////////////////// +// // +// wxRegionIterator // +// // +/////////////////////////////////////////////////////////////////////////////// + +/*! + * Initialize empty iterator + */ +wxRegionIterator::wxRegionIterator() : m_current(0), m_numRects(0), m_rects(NULL) +{ +} + +wxRegionIterator::~wxRegionIterator() +{ + if (m_rects) + delete[] m_rects; +} + +/*! + * Initialize iterator for region + */ +wxRegionIterator::wxRegionIterator(const wxRegion& region) +{ + m_rects = NULL; + + Reset(region); +} + +/*! + * Reset iterator for a new /e region. + */ +void wxRegionIterator::Reset(const wxRegion& region) +{ + m_current = 0; + m_region = region; + + if (m_rects) + delete[] m_rects; + + m_rects = NULL; + + if (m_region.Empty()) + m_numRects = 0; + else + { + // TODO create m_rects and fill with rectangles for this region + m_numRects = 0; + } +} + +/*! + * Increment iterator. The rectangle returned is the one after the + * incrementation. + */ +void wxRegionIterator::operator ++ () +{ + if (m_current < m_numRects) + ++m_current; +} + +/*! + * Increment iterator. The rectangle returned is the one before the + * incrementation. + */ +void wxRegionIterator::operator ++ (int) +{ + if (m_current < m_numRects) + ++m_current; +} + +long wxRegionIterator::GetX() const +{ + if (m_current < m_numRects) + return m_rects[m_current].x; + return 0; +} + +long wxRegionIterator::GetY() const +{ + if (m_current < m_numRects) + return m_rects[m_current].y; + return 0; +} + +long wxRegionIterator::GetW() const +{ + if (m_current < m_numRects) + return m_rects[m_current].width ; + return 0; +} + +long wxRegionIterator::GetH() const +{ + if (m_current < m_numRects) + return m_rects[m_current].height; + return 0; +} + diff --git a/src/stubs/scrolbar.cpp b/src/stubs/scrolbar.cpp new file mode 100644 index 0000000000..0058a14f53 --- /dev/null +++ b/src/stubs/scrolbar.cpp @@ -0,0 +1,78 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: scrolbar.cpp +// Purpose: wxScrollBar +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "scrolbar.h" +#endif + +#include "wx/scrolbar.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl) + +#endif + +// Scrollbar +bool wxScrollBar::Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + if (!parent) + return FALSE; + parent->AddChild(this); + SetName(name); + SetValidator(validator); + + m_windowStyle = style; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + // TODO create scrollbar + return TRUE; +} + +wxScrollBar::~wxScrollBar() +{ +} + +void wxScrollBar::SetPosition(int viewStart) +{ + // TODO +} + +int wxScrollBar::GetPosition() const +{ + // TODO + return 0; +} + +void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageSize, + bool refresh) +{ + m_viewSize = pageSize; + m_pageSize = thumbSize; + m_objectSize = range; + + // TODO +} + + +void wxScrollBar::Command(wxCommandEvent& event) +{ + SetValue(event.m_commandInt); + ProcessCommand(event); +} + diff --git a/src/stubs/settings.cpp b/src/stubs/settings.cpp new file mode 100644 index 0000000000..0450dbc8e4 --- /dev/null +++ b/src/stubs/settings.cpp @@ -0,0 +1,151 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: settings.cpp +// Purpose: wxSettings +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "settings.h" +#endif + +#include "wx/settings.h" + +wxColour wxSystemSettings::GetSystemColour(int index) +{ + // TODO + return col; +} + +wxFont wxSystemSettings::GetSystemFont(int index) +{ + // TODO + return wxFont; +} + +// Get a system metric, e.g. scrollbar size +int wxSystemSettings::GetSystemMetric(int index) +{ + switch ( index) + { + case wxSYS_MOUSE_BUTTONS: + // TODO + return 0; + case wxSYS_BORDER_X: + // TODO + return 0; + case wxSYS_BORDER_Y: + // TODO + return 0; + case wxSYS_CURSOR_X: + // TODO + return 0; + case wxSYS_CURSOR_Y: + // TODO + return 0; + case wxSYS_DCLICK_X: + // TODO + return 0; + case wxSYS_DCLICK_Y: + // TODO + return 0; + case wxSYS_DRAG_X: + // TODO + return 0; + case wxSYS_DRAG_Y: + // TODO + return 0; + case wxSYS_EDGE_X: + // TODO + return 0; + case wxSYS_EDGE_Y: + // TODO + return 0; + case wxSYS_HSCROLL_ARROW_X: + // TODO + return 0; + case wxSYS_HSCROLL_ARROW_Y: + // TODO + return 0; + case wxSYS_HTHUMB_X: + // TODO + return 0; + case wxSYS_ICON_X: + // TODO + return 0; + case wxSYS_ICON_Y: + // TODO + return 0; + case wxSYS_ICONSPACING_X: + // TODO + return 0; + case wxSYS_ICONSPACING_Y: + // TODO + return 0; + case wxSYS_WINDOWMIN_X: + // TODO + return 0; + case wxSYS_WINDOWMIN_Y: + // TODO + return 0; + case wxSYS_SCREEN_X: + // TODO + return 0; + case wxSYS_SCREEN_Y: + // TODO + return 0; + case wxSYS_FRAMESIZE_X: + // TODO + return 0; + case wxSYS_FRAMESIZE_Y: + // TODO + return 0; + case wxSYS_SMALLICON_X: + // TODO + return 0; + case wxSYS_SMALLICON_Y: + // TODO + return 0; + case wxSYS_HSCROLL_Y: + // TODO + return 0; + case wxSYS_VSCROLL_X: + // TODO + return 0; + case wxSYS_VSCROLL_ARROW_X: + // TODO + return 0; + case wxSYS_VSCROLL_ARROW_Y: + // TODO + return 0; + case wxSYS_VTHUMB_Y: + // TODO + return 0; + case wxSYS_CAPTION_Y: + // TODO + return 0; + case wxSYS_MENU_Y: + // TODO + return 0; + case wxSYS_NETWORK_PRESENT: + // TODO + return 0; + case wxSYS_PENWINDOWS_PRESENT: + // TODO + return 0; + case wxSYS_SHOW_SOUNDS: + // TODO + return 0; + case wxSYS_SWAP_BUTTONS: + // TODO + return 0; + default: + return 0; + } + return 0; +} + diff --git a/src/stubs/slider.cpp b/src/stubs/slider.cpp new file mode 100644 index 0000000000..97c453b989 --- /dev/null +++ b/src/stubs/slider.cpp @@ -0,0 +1,185 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: slider.cpp +// Purpose: wxSlider +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "slider.h" +#endif + +#include "wx/msw/slider.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl) +#endif + +// Slider +wxSlider::wxSlider() +{ + m_pageSize = 1; + m_lineSize = 1; + m_rangeMax = 0; + m_rangeMin = 0; + m_tickFreq = 0; +} + +bool wxSlider::Create(wxWindow *parent, wxWindowID id, + int value, int minValue, int maxValue, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + SetName(name); + SetValidator(validator); + + if (parent) parent->AddChild(this); + + m_lineSize = 1; + m_windowStyle = style; + m_tickFreq = 0; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_rangeMax = maxValue; + m_rangeMin = minValue; + + m_pageSize = (int)((maxValue-minValue)/10); + + // TODO create slider + + return FALSE; +} + +wxSlider::~wxSlider() +{ +} + +int wxSlider::GetValue() const +{ + // TODO + return 0; +} + +void wxSlider::SetValue(int value) +{ + // TODO +} + +void wxSlider::GetSize(int *width, int *height) const +{ + // TODO +} + +void wxSlider::GetPosition(int *x, int *y) const +{ + // TODO +} + +void wxSlider::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxSlider::SetRange(int minValue, int maxValue) +{ + m_rangeMin = minValue; + m_rangeMax = maxValue; + + // TODO +} + +// For trackbars only +void wxSlider::SetTickFreq(int n, int pos) +{ + // TODO + m_tickFreq = n; +} + +void wxSlider::SetPageSize(int pageSize) +{ + // TODO + m_pageSize = pageSize; +} + +int wxSlider::GetPageSize() const +{ + return m_pageSize; +} + +void wxSlider::ClearSel() +{ + // TODO +} + +void wxSlider::ClearTicks() +{ + // TODO +} + +void wxSlider::SetLineSize(int lineSize) +{ + m_lineSize = lineSize; + // TODO +} + +int wxSlider::GetLineSize() const +{ + // TODO + return 0; +} + +int wxSlider::GetSelEnd() const +{ + // TODO + return 0; +} + +int wxSlider::GetSelStart() const +{ + // TODO + return 0; +} + +void wxSlider::SetSelection(int minPos, int maxPos) +{ + // TODO +} + +void wxSlider::SetThumbLength(int len) +{ + // TODO +} + +int wxSlider::GetThumbLength() const +{ + // TODO + return 0; +} + +void wxSlider::SetTick(int tickPos) +{ + // TODO +} + +void wxSlider::Command (wxCommandEvent & event) +{ + SetValue (event.GetInt()); + ProcessCommand (event); +} + +bool wxSlider::Show(bool show) +{ + // TODO + return TRUE; +} + diff --git a/src/stubs/spinbutt.cpp b/src/stubs/spinbutt.cpp new file mode 100644 index 0000000000..cbea725592 --- /dev/null +++ b/src/stubs/spinbutt.cpp @@ -0,0 +1,78 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: spinbutt.cpp +// Purpose: wxSpinButton +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "spinbutt.h" +#endif + +#include "wx/spinbutt.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxSpinButton, wxControl) +#endif + +wxSpinButton::wxSpinButton() +{ + m_min = 0; + m_max = 100; +} + +bool wxSpinButton::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, + long style, const wxString& name) +{ + SetName(name); + + m_windowStyle = style; + + SetParent(parent); + + m_min = 0; + m_max = 100; + + m_windowId = (id == -1) ? NewControlId() : id; + + // TODO create spin button + return FALSE; +} + +wxSpinButton::~wxSpinButton() +{ +} + +// Attributes +//////////////////////////////////////////////////////////////////////////// + +int wxSpinButton::GetValue() const +{ + // TODO + return 0; +} + +void wxSpinButton::SetValue(int val) +{ + // TODO +} + +void wxSpinButton::SetRange(int minVal, int maxVal) +{ + m_min = minVal; + m_max = maxVal; + // TODO +} + +// Spin event +IMPLEMENT_DYNAMIC_CLASS(wxSpinEvent, wxScrollEvent) + +wxSpinEvent::wxSpinEvent(wxEventType commandType, int id): + wxScrollEvent(commandType, id) +{ +} + diff --git a/src/stubs/statbmp.cpp b/src/stubs/statbmp.cpp new file mode 100644 index 0000000000..a67c558465 --- /dev/null +++ b/src/stubs/statbmp.cpp @@ -0,0 +1,59 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbmp.cpp +// Purpose: wxStaticBitmap +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "statbmp.h" +#endif + +#include "wx/statbmp.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl) +#endif + +/* + * wxStaticBitmap + */ + +bool wxStaticBitmap::Create(wxWindow *parent, wxWindowID id, + const wxBitmap& bitmap, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + m_messageBitmap = bitmap; + SetName(name); + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_windowStyle = style; + + // TODO: create static bitmap control + return FALSE; +} + +void wxStaticBitmap::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap) +{ + m_messageBitmap = bitmap; + + // TODO: redraw bitmap +} + diff --git a/src/stubs/statbox.cpp b/src/stubs/statbox.cpp new file mode 100644 index 0000000000..b239dc738c --- /dev/null +++ b/src/stubs/statbox.cpp @@ -0,0 +1,62 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: statbox.cpp +// Purpose: wxStaticBox +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "statbox.h" +#endif + +#include "wx/statbox.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl) + +BEGIN_EVENT_TABLE(wxStaticBox, wxControl) + EVT_ERASE_BACKGROUND(wxStaticBox::OnEraseBackground) +END_EVENT_TABLE() + +#endif + +/* + * Static box + */ + +bool wxStaticBox::Create(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + SetName(name); + + if (parent) parent->AddChild(this); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_windowStyle = style; + + // TODO: create static box + return FALSE; +} + +void wxStaticBox::SetLabel(const wxString& label) +{ + // TODO +} + +void wxStaticBox::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + diff --git a/src/stubs/stattext.cpp b/src/stubs/stattext.cpp new file mode 100644 index 0000000000..1958826916 --- /dev/null +++ b/src/stubs/stattext.cpp @@ -0,0 +1,211 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: stattext.cpp +// Purpose: wxStaticText +// Author: AUTHOR +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "stattext.h" +#endif + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP +#include "wx/app.h" +#endif + +#include "wx/stattext.h" +#include "wx/msw/private.h" +#include + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl) +#endif + +bool wxStaticText::Create(wxWindow *parent, wxWindowID id, + const wxString& label, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + SetName(name); + if (parent) parent->AddChild(this); + + SetBackgroundColour(parent->GetDefaultBackgroundColour()) ; + SetForegroundColour(parent->GetDefaultForegroundColour()) ; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + int x = pos.x; + int y = pos.y; + int width = size.x; + int height = size.y; + + m_windowStyle = style; + + long msStyle = WS_CHILD|WS_VISIBLE; + if (m_windowStyle & wxALIGN_CENTRE) + msStyle |= SS_CENTER; + else if (m_windowStyle & wxALIGN_RIGHT) + msStyle |= SS_RIGHT; + else + msStyle |= SS_LEFT; + + // Even with extended styles, need to combine with WS_BORDER + // for them to look right. + if ((m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) || + (m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER)) + msStyle |= WS_BORDER; + + HWND static_item = CreateWindowEx(MakeExtendedStyle(m_windowStyle), "STATIC", (const char *)label, + msStyle, + 0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId, + wxGetInstance(), NULL); + +#if CTL3D +/* + if (!(GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS)) + Ctl3dSubclassCtl(static_item); +*/ +#endif + + m_hWnd = (WXHWND)static_item; + + SubclassWin((WXHWND)static_item); + + SetFont(* parent->GetFont()); + SetSize(x, y, width, height); + return TRUE; +} + +void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + int currentX, currentY; + GetPosition(¤tX, ¤tY); + int x1 = x; + int y1 = y; + + if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) + x1 = currentX; + if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE)) + y1 = currentY; + + AdjustForParentClientOrigin(x1, y1, sizeFlags); + + int actualWidth = width; + int actualHeight = height; + + char buf[300]; + int current_width; + int cyf; + + ::GetWindowText((HWND) GetHWND(), buf, 300); + GetTextExtent(buf, ¤t_width, &cyf, NULL, NULL,GetFont()); + + int ww, hh; + GetSize(&ww, &hh); + + // If we're prepared to use the existing width, then... + if (width == -1 && ((sizeFlags & wxSIZE_AUTO_WIDTH) != wxSIZE_AUTO_WIDTH)) + actualWidth = ww; + else if (width == -1) + { + int cx; + int cy; + wxGetCharSize(GetHWND(), &cx, &cy,GetFont()); + actualWidth = (int)(current_width + cx) ; + } + + // If we're prepared to use the existing height, then... + if (height == -1 && ((sizeFlags & wxSIZE_AUTO_HEIGHT) != wxSIZE_AUTO_HEIGHT)) + actualHeight = hh; + else if (height == -1) + { + actualHeight = (int)(cyf) ; + } + + MoveWindow((HWND) GetHWND(), x1, y1, actualWidth, actualHeight, TRUE); +} + +void wxStaticText::SetLabel(const wxString& label) +{ + int w, h; + RECT rect; + + wxWindow *parent = GetParent(); + GetWindowRect((HWND) GetHWND(), &rect); + + // Since we now have the absolute screen coords, + // if there's a parent we must subtract its top left corner + POINT point; + point.x = rect.left; + point.y = rect.top; + if (parent) + { + ::ScreenToClient((HWND) parent->GetHWND(), &point); + } + + GetTextExtent(label, &w, &h, NULL, NULL, GetFont()); + MoveWindow((HWND) GetHWND(), point.x, point.y, (int)(w + 10), (int)h, + TRUE); + SetWindowText((HWND) GetHWND(), (const char *)label); +} + +WXHBRUSH wxStaticText::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor, + WXUINT message, WXWPARAM wParam, WXLPARAM lParam) +{ +/* +#if CTL3D + if ( m_useCtl3D ) + { + HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam); + + if (hbrush != (HBRUSH) 0) + return hbrush; + else + return (HBRUSH)MSWDefWindowProc(message, wParam, lParam); + } +#endif +*/ + + if (GetParent()->GetTransparentBackground()) + SetBkMode((HDC) pDC, TRANSPARENT); + else + SetBkMode((HDC) pDC, OPAQUE); + + ::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue())); + ::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue())); + + wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID); + + // Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush + // has a zero usage count. +// backgroundBrush->RealizeResource(); + return (WXHBRUSH) backgroundBrush->GetResourceHandle(); +} + +long wxStaticText::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +{ + // Ensure that static items get messages. Some controls don't like this + // message to be intercepted (e.g. RichEdit), hence the tests. + if (nMsg == WM_NCHITTEST) + return (long)HTCLIENT; + + return wxWindow::MSWWindowProc(nMsg, wParam, lParam); +} + + diff --git a/src/stubs/statusbr.cpp b/src/stubs/statusbr.cpp new file mode 100644 index 0000000000..59fd64d927 --- /dev/null +++ b/src/stubs/statusbr.cpp @@ -0,0 +1,162 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: statbar.cpp +// Purpose: native implementation of wxStatusBar (optional) +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) 1998 AUTHOR +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "statusbr.h" +#endif + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + +#include "wx/stubs/statusbr.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxStatusBarXX, wxStatusBar); + +BEGIN_EVENT_TABLE(wxStatusBarXX, wxStatusBar) + EVT_SIZE(wxStatusBarXX::OnSize) +END_EVENT_TABLE() +#endif //USE_SHARED_LIBRARY + + +// ============================================================================ +// implementation +// ============================================================================ + +// ---------------------------------------------------------------------------- +// wxStatusBarXX class +// ---------------------------------------------------------------------------- + +wxStatusBarXX::wxStatusBarXX() +{ + SetParent(NULL); +} + +wxStatusBarXX::wxStatusBarXX(wxWindow *parent, wxWindowID id, long style) +{ + Create(parent, id, style); +} + +bool wxStatusBarXX::Create(wxWindow *parent, wxWindowID id, long style) +{ + SetParent(parent); + + if (id == -1) + m_windowId = NewControlId(); + else + m_windowId = id; + + // TODO: create status bar + return FALSE; +} + +void wxStatusBarXX::CopyFieldsWidth(const int widths[]) +{ + if (widths && !m_statusWidths) + m_statusWidths = new int[m_nFields]; + + if ( widths != NULL ) { + for ( int i = 0; i < m_nFields; i++ ) + m_statusWidths[i] = widths[i]; + } + else { + delete [] m_statusWidths; + m_statusWidths = NULL; + } +} + +void wxStatusBarXX::SetFieldsCount(int nFields, const int widths[]) +{ + wxASSERT( (nFields > 0) && (nFields < 255) ); + + m_nFields = nFields; + + CopyFieldsWidth(widths); + SetFieldsWidth(); +} + +void wxStatusBarXX::SetStatusWidths(int n, const int widths[]) +{ + wxASSERT( n == m_nFields ); + + CopyFieldsWidth(widths); + SetFieldsWidth(); +} + +void wxStatusBarXX::SetFieldsWidth() +{ + int *pWidths = new int[m_nFields]; + + int nWindowWidth, y; + GetClientSize(&nWindowWidth, &y); + + if ( m_statusWidths == NULL ) { + // default: all fields have the same width + int nWidth = nWindowWidth / m_nFields; + for ( int i = 0; i < m_nFields; i++ ) + pWidths[i] = (i + 1) * nWidth; + } + else { + // -1 doesn't mean the same thing for wxWindows and Win32, recalc + int nTotalWidth = 0, + nVarCount = 0, + i; + for ( i = 0; i < m_nFields; i++ ) { + if ( m_statusWidths[i] == -1 ) + nVarCount++; + else + nTotalWidth += m_statusWidths[i]; + } + + if ( nVarCount == 0 ) { + // wrong! at least one field must be of variable width + wxFAIL; + + nVarCount++; + } + + int nVarWidth = (nWindowWidth - nTotalWidth) / nVarCount; + + // do fill the array + int nCurPos = 0; + for ( i = 0; i < m_nFields; i++ ) { + if ( m_statusWidths[i] == -1 ) + nCurPos += nVarWidth; + else + nCurPos += m_statusWidths[i]; + pWidths[i] = nCurPos; + } + } + + // TODO: set widths + + delete [] pWidths; +} + +void wxStatusBarXX::SetStatusText(const wxString& strText, int nField) +{ + // TODO +} + +wxString wxStatusBarXX::GetStatusText(int nField) const +{ + wxASSERT( (nField > -1) && (nField < m_nFields) ); + + // TODO + return wxString(""); +} + +void wxStatusBarXX::OnSize(wxSizeEvent& event) +{ + // adjust fields widths to the new size + SetFieldsWidth(); +} diff --git a/src/stubs/tabctrl.cpp b/src/stubs/tabctrl.cpp new file mode 100644 index 0000000000..3a84d4d668 --- /dev/null +++ b/src/stubs/tabctrl.cpp @@ -0,0 +1,205 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: tabctrl.cpp +// Purpose: wxTabCtrl +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "tabctrl.h" +#endif + +#include "wx/tabctrl.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTabCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTabCtrl, wxControl) + EVT_SIZE(wxTabCtrl::OnSize) + EVT_PAINT(wxTabCtrl::OnPaint) + EVT_KILL_FOCUS(wxTabCtrl::OnKillFocus) + EVT_MOUSE_EVENTS(wxTabCtrl::OnMouseEvent) + EVT_SYS_COLOUR_CHANGED(wxTabCtrl::OnSysColourChanged) +END_EVENT_TABLE() +#endif + +wxTabCtrl::wxTabCtrl() +{ + m_imageList = NULL; +} + +bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, + long style, const wxString& name) +{ + m_imageList = NULL; + + SetName(name); + + m_windowStyle = style; + + SetParent(parent); + + m_windowId = (id < 0 ? NewControlId() : id); + + if (parent) parent->AddChild(this); + + // TODO: create tab control + return FALSE; +} + +wxTabCtrl::~wxTabCtrl() +{ +} + +void wxTabCtrl::Command(wxCommandEvent& event) +{ +} + +// Delete all items +bool wxTabCtrl::DeleteAllItems() +{ + // TODO + return FALSE; +} + +// Delete an item +bool wxTabCtrl::DeleteItem(int item) +{ + // TODO + return FALSE; +} + +// Get the selection +int wxTabCtrl::GetSelection() const +{ + // TODO + return 0; +} + +// Get the tab with the current keyboard focus +int wxTabCtrl::GetCurFocus() const +{ + // TODO + return 0; +} + +// Get the associated image list +wxImageList* wxTabCtrl::GetImageList() const +{ + return m_imageList; +} + +// Get the number of items +int wxTabCtrl::GetItemCount() const +{ + // TODO + return 0; +} + +// Get the rect corresponding to the tab +bool wxTabCtrl::GetItemRect(int item, wxRect& wxrect) const +{ + // TODO + return FALSE; +} + +// Get the number of rows +int wxTabCtrl::GetRowCount() const +{ + // TODO + return 0; +} + +// Get the item text +wxString wxTabCtrl::GetItemText(int item) const +{ + // TODO + return wxString(""); +} + +// Get the item image +int wxTabCtrl::GetItemImage(int item) const +{ + // TODO + return 0; +} + +// Get the item data +void* wxTabCtrl::GetItemData(int item) const +{ + // TODO + return NULL; +} + +// Hit test +int wxTabCtrl::HitTest(const wxPoint& pt, long& flags) +{ + // TODO + return 0; +} + +// Insert an item +bool wxTabCtrl::InsertItem(int item, const wxString& text, int imageId, void* data) +{ + // TODO + return FALSE; +} + +// Set the selection +int wxTabCtrl::SetSelection(int item) +{ + // TODO + return 0; +} + +// Set the image list +void wxTabCtrl::SetImageList(wxImageList* imageList) +{ + // TODO +} + +// Set the text for an item +bool wxTabCtrl::SetItemText(int item, const wxString& text) +{ + // TODO + return FALSE; +} + +// Set the image for an item +bool wxTabCtrl::SetItemImage(int item, int image) +{ + // TODO + return FALSE; +} + +// Set the data for an item +bool wxTabCtrl::SetItemData(int item, void* data) +{ + // TODO + return FALSE; +} + +// Set the size for a fixed-width tab control +void wxTabCtrl::SetItemSize(const wxSize& size) +{ + // TODO +} + +// Set the padding between tabs +void wxTabCtrl::SetPadding(const wxSize& padding) +{ + // TODO +} + +// Tab event +IMPLEMENT_DYNAMIC_CLASS(wxTabEvent, wxCommandEvent) + +wxTabEvent::wxTabEvent(wxEventType commandType, int id): + wxCommandEvent(commandType, id) +{ +} + diff --git a/src/stubs/taskbar.cpp b/src/stubs/taskbar.cpp new file mode 100644 index 0000000000..5c91250cf0 --- /dev/null +++ b/src/stubs/taskbar.cpp @@ -0,0 +1,70 @@ +///////////////////////////////////////////////////////////////////////// +// File: taskbar.cpp +// Purpose: Implements wxTaskBarIcon class for manipulating icons on +// the task bar. Optional. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "taskbar.h" +#endif + +#include + +wxTaskBarIcon::wxTaskBarIcon() +{ + // TODO +} + +wxTaskBarIcon::~wxTaskBarIcon() +{ + // TODO +} + +// Operations +bool wxTaskBarIcon::SetIcon(const wxIcon& icon, const wxString& tooltip) +{ + // TODO + return FALSE; +} + +bool wxTaskBarIcon::RemoveIcon() +{ + // TODO + return FALSE; +} + +// Overridables +void wxTaskBarIcon::OnMouseMove() +{ +} + +void wxTaskBarIcon::OnLButtonDown() +{ +} + +void wxTaskBarIcon::OnLButtonUp() +{ +} + +void wxTaskBarIcon::OnRButtonDown() +{ +} + +void wxTaskBarIcon::OnRButtonUp() +{ +} + +void wxTaskBarIcon::OnLButtonDClick() +{ +} + +void wxTaskBarIcon::OnRButtonDClick() +{ +} + diff --git a/src/stubs/textctrl.cpp b/src/stubs/textctrl.cpp new file mode 100644 index 0000000000..fb522df053 --- /dev/null +++ b/src/stubs/textctrl.cpp @@ -0,0 +1,439 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: textctrl.cpp +// Purpose: wxTextCtrl +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "textctrl.h" +#endif + +#include +#include +#include + +#include "wx/textctrl.h" +#include "wx/settings.h" + +#if defined(__BORLANDC__) && !defined(__WIN32__) +#include +#else +#ifndef __GNUWIN32__ +#include +#endif +#endif + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) + EVT_CHAR(wxTextCtrl::OnChar) + EVT_DROP_FILES(wxTextCtrl::OnDropFiles) + EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground) +END_EVENT_TABLE() +#endif + +// Text item +wxTextCtrl::wxTextCtrl() +#ifndef NO_TEXT_WINDOW_STREAM + :streambuf() +#endif +{ + m_fileName = ""; +} + +bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id, + const wxString& value, + const wxPoint& pos, + const wxSize& size, long style, + const wxValidator& validator, + const wxString& name) +{ + m_fileName = ""; + SetName(name); + SetValidator(validator); + if (parent) parent->AddChild(this); + + m_windowStyle = style; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + return TRUE; +} + +wxString wxTextCtrl::GetValue() const +{ + // TODO + return wxString(""); +} + +void wxTextCtrl::SetValue(const wxString& value) +{ + // TODO +} + +void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +// Clipboard operations +void wxTextCtrl::Copy() +{ + // TODO +} + +void wxTextCtrl::Cut() +{ + // TODO +} + +void wxTextCtrl::Paste() +{ + // TODO +} + +void wxTextCtrl::SetEditable(bool editable) +{ + // TODO +} + +void wxTextCtrl::SetInsertionPoint(long pos) +{ + // TODO +} + +void wxTextCtrl::SetInsertionPointEnd() +{ + long pos = GetLastPosition(); + SetInsertionPoint(pos); +} + +long wxTextCtrl::GetInsertionPoint() const +{ + // TODO + return 0; +} + +long wxTextCtrl::GetLastPosition() const +{ + // TODO + return 0; +} + +void wxTextCtrl::Replace(long from, long to, const wxString& value) +{ + // TODO + return 0; +} + +void wxTextCtrl::Remove(long from, long to) +{ + // TODO +} + +void wxTextCtrl::SetSelection(long from, long to) +{ + // TODO +} + +bool wxTextCtrl::LoadFile(const wxString& file) +{ + if (!wxFileExists(file)) + return FALSE; + + m_fileName = file; + + Clear(); + + ifstream input((char*) (const char*) file, ios::nocreate | ios::in); + + if (!input.bad()) + { + struct stat stat_buf; + if (stat(file, &stat_buf) < 0) + return FALSE; + // This may need to be a bigger buffer than the file size suggests, + // if it's a UNIX file. Give it an extra 1000 just in case. + char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000)); + long no_lines = 0; + long pos = 0; + while (!input.eof() && input.peek() != EOF) + { + input.getline(wxBuffer, 500); + int len = strlen(wxBuffer); + wxBuffer[len] = 13; + wxBuffer[len+1] = 10; + wxBuffer[len+2] = 0; + strcpy(tmp_buffer+pos, wxBuffer); + pos += strlen(wxBuffer); + no_lines++; + } + + // TODO add line + + free(tmp_buffer); + + return TRUE; + } + return FALSE; +} + +// If file is null, try saved file name first +// Returns TRUE if succeeds. +bool wxTextCtrl::SaveFile(const wxString& file) +{ + wxString theFile(file); + if (theFile == "") + theFile = m_fileName; + if (theFile == "") + return FALSE; + m_fileName = theFile; + + ofstream output((char*) (const char*) theFile); + if (output.bad()) + return FALSE; + + // TODO get and save text + + return FALSE; +} + +void wxTextCtrl::WriteText(const wxString& text) +{ + // TODO write text to control +} + +void wxTextCtrl::Clear() +{ + // TODO +} + +bool wxTextCtrl::IsModified() const +{ + // TODO + return FALSE; +} + +// Makes 'unmodified' +void wxTextCtrl::DiscardEdits() +{ + // TODO +} + +int wxTextCtrl::GetNumberOfLines() const +{ + // TODO + return 0; +} + +long wxTextCtrl::XYToPosition(long x, long y) const +{ + // TODO + return 0; +} + +void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const +{ + // TODO +} + +void wxTextCtrl::ShowPosition(long pos) +{ + // TODO +} + +int wxTextCtrl::GetLineLength(long lineNo) const +{ + // TODO + return 0; +} + +wxString wxTextCtrl::GetLineText(long lineNo) const +{ + // TODO + return wxString(""); +} + +/* + * Text item + */ + +void wxTextCtrl::Command(wxCommandEvent & event) +{ + SetValue (event.GetString()); + ProcessCommand (event); +} + +void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event) +{ + // By default, load the first file into the text window. + if (event.GetNumberOfFiles() > 0) + { + LoadFile(event.GetFiles()[0]); + } +} + +// The streambuf code was partly taken from chapter 3 by Jerry Schwarz of +// AT&T's "C++ Lanuage System Release 3.0 Library Manual" - Stein Somers + +//========================================================================= +// Called then the buffer is full (gcc 2.6.3) +// or when "endl" is output (Borland 4.5) +//========================================================================= +// Class declaration using multiple inheritance doesn't work properly for +// Borland. See note in wb_text.h. +#ifndef NO_TEXT_WINDOW_STREAM +int wxTextCtrl::overflow(int c) +{ + // Make sure there is a holding area + if ( allocate()==EOF ) + { + wxError("Streambuf allocation failed","Internal error"); + return EOF; + } + + // Verify that there are no characters in get area + if ( gptr() && gptr() < egptr() ) + { + wxError("Who's trespassing my get area?","Internal error"); + return EOF; + } + + // Reset get area + setg(0,0,0); + + // Make sure there is a put area + if ( ! pptr() ) + { +/* This doesn't seem to be fatal so comment out error message */ +// wxError("Put area not opened","Internal error"); + setp( base(), base() ); + } + + // Determine how many characters have been inserted but no consumed + int plen = pptr() - pbase(); + + // Now Jerry relies on the fact that the buffer is at least 2 chars + // long, but the holding area "may be as small as 1" ??? + // And we need an additional \0, so let's keep this inefficient but + // safe copy. + + // If c!=EOF, it is a character that must also be comsumed + int xtra = c==EOF? 0 : 1; + + // Write temporary C-string to wxTextWindow + { + char *txt = new char[plen+xtra+1]; + memcpy(txt, pbase(), plen); + txt[plen] = (char)c; // append c + txt[plen+xtra] = '\0'; // append '\0' or overwrite c + // If the put area already contained \0, output will be truncated there + WriteText(txt); + delete[] txt; + } + + // Reset put area + setp(pbase(), epptr()); + +#if defined(__WATCOMC__) + return __NOT_EOF; +#elif defined(zapeof) // HP-UX (all cfront based?) + return zapeof(c); +#else + return c!=EOF ? c : 0; // this should make everybody happy +#endif +} + +//========================================================================= +// called then "endl" is output (gcc) or then explicit sync is done (Borland) +//========================================================================= +int wxTextCtrl::sync() +{ + // Verify that there are no characters in get area + if ( gptr() && gptr() < egptr() ) + { + wxError("Who's trespassing my get area?","Internal error"); + return EOF; + } + + if ( pptr() && pptr() > pbase() ) return overflow(EOF); + + return 0; +/* OLD CODE + int len = pptr() - pbase(); + char *txt = new char[len+1]; + strncpy(txt, pbase(), len); + txt[len] = '\0'; + (*this) << txt; + setp(pbase(), epptr()); + delete[] txt; + return 0; +*/ +} + +//========================================================================= +// Should not be called by a "ostream". Used by a "istream" +//========================================================================= +int wxTextCtrl::underflow() +{ + return EOF; +} +#endif + +wxTextCtrl& wxTextCtrl::operator<<(const wxString& s) +{ + WriteText(s); + return *this; +} + +wxTextCtrl& wxTextCtrl::operator<<(float f) +{ + wxString str; + str.Printf("%.2f", f); + WriteText(str); + return *this; +} + +wxTextCtrl& wxTextCtrl::operator<<(double d) +{ + wxString str; + str.Printf("%.2f", d); + WriteText(str); + return *this; +} + +wxTextCtrl& wxTextCtrl::operator<<(int i) +{ + wxString str; + str.Printf("%d", i); + WriteText(str); + return *this; +} + +wxTextCtrl& wxTextCtrl::operator<<(long i) +{ + wxString str; + str.Printf("%ld", i); + WriteText(str); + return *this; +} + +wxTextCtrl& wxTextCtrl::operator<<(const char c) +{ + char buf[2]; + + buf[0] = c; + buf[1] = 0; + WriteText(buf); + return *this; +} + diff --git a/src/stubs/thread.cpp b/src/stubs/thread.cpp new file mode 100644 index 0000000000..9a03aae3cd --- /dev/null +++ b/src/stubs/thread.cpp @@ -0,0 +1,225 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: thread.cpp +// Purpose: wxThread Implementation. For Unix ports, see e.g. src/gtk +// Author: Original from Wolfram Gloger/Guilhem Lavaux +// Modified by: +// Created: 04/22/98 +// RCS-ID: $Id$ +// Copyright: (c) Wolfram Gloger (1996, 1997); Guilhem Lavaux (1998) +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "thread.h" +#endif + +#include "wx/module.h" +#include "wx/thread.h" + +enum thread_state { + STATE_IDLE = 0, + STATE_RUNNING, + STATE_CANCELED, + STATE_EXITED +}; + +///////////////////////////////////////////////////////////////////////////// +// Static variables +///////////////////////////////////////////////////////////////////////////// + +wxMutex wxMainMutex; // controls access to all GUI functions + +///////////////////////////////////////////////////////////////////////////// +// Windows implementation +///////////////////////////////////////////////////////////////////////////// + +class wxMutexInternal { +public: + // TODO: internal mutex handle +}; + +wxMutex::wxMutex() +{ + p_internal = new wxMutexInternal; + // TODO: create internal mutext handle + m_locked = 0; +} + +wxMutex::~wxMutex() +{ + if (m_locked > 0) + wxDebugMsg("wxMutex warning: freeing a locked mutex (%d locks)\n", m_locked); + // TODO: free internal mutext handle +} + +wxMutexError wxMutex::Lock() +{ + // TODO + m_locked++; + return MUTEX_NO_ERROR; +} + +wxMutexError wxMutex::TryLock() +{ + // TODO + m_locked++; + return MUTEX_NO_ERROR; +} + +wxMutexError wxMutex::Unlock() +{ + if (m_locked > 0) + m_locked--; + + // TODO + return MUTEX_NO_ERROR; +} + +class wxConditionInternal { +public: + // TODO: internal handle + int waiters; +}; + +wxCondition::wxCondition() +{ + p_internal = new wxConditionInternal; + // TODO: create internal handle + p_internal->waiters = 0; +} + +wxCondition::~wxCondition() +{ + // TODO: destroy internal handle +} + +void wxCondition::Wait(wxMutex& mutex) +{ + mutex.Unlock(); + p_internal->waiters++; + // TODO wait here + p_internal->waiters--; + mutex.Lock(); +} + +bool wxCondition::Wait(wxMutex& mutex, unsigned long sec, + unsigned long nsec) +{ + mutex.Unlock(); + p_internal->waiters++; + + // TODO wait here + p_internal->waiters--; + mutex.Lock(); + + return FALSE; +} + +void wxCondition::Signal() +{ + // TODO +} + +void wxCondition::Broadcast() +{ + // TODO +} + +class wxThreadInternal { +public: + // TODO +}; + +wxThreadError wxThread::Create() +{ + // TODO + return THREAD_NO_ERROR; +} + +wxThreadError wxThread::Destroy() +{ + // TODO + return THREAD_NO_ERROR; +} + +void wxThread::Exit(void *status) +{ + // TODO +} + +void wxThread::SetPriority(int prio) +{ + // TODO +} + +int wxThread::GetPriority() const +{ + // TODO + return 0; +} + +void wxThread::DeferDestroy(bool on) +{ + // TODO +} + +void wxThread::TestDestroy() +{ + // TODO +} + +void *wxThread::Join() +{ + // TODO + return (void*) NULL; +} + +unsigned long wxThread::GetID() const +{ + // TODO + return 0; +} + +bool wxThread::IsMain() +{ + // TODO +} + +wxThread::wxThread() +{ + p_internal = new wxThreadInternal(); + + // TODO +} + +wxThread::~wxThread() +{ + Destroy(); + Join(); + delete p_internal; +} + +// The default callback just joins the thread and throws away the result. +void wxThread::OnExit() +{ + Join(); +} + +// Automatic initialization +class wxThreadModule : public wxModule { + DECLARE_DYNAMIC_CLASS(wxThreadModule) +public: + virtual bool OnInit() { + /* TODO p_mainid = GetCurrentThread(); */ + wxMainMutex.Lock(); + return TRUE; + } + + // Global cleanup + virtual void OnExit() { + wxMainMutex.Unlock(); + } +}; + +IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule) + diff --git a/src/stubs/timer.cpp b/src/stubs/timer.cpp new file mode 100644 index 0000000000..f976056c77 --- /dev/null +++ b/src/stubs/timer.cpp @@ -0,0 +1,56 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: timer.cpp +// Purpose: wxTimer implementation +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "timer.h" +#endif + +#include "wx/timer.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject) +#endif + +wxTimer::wxTimer() +{ + m_milli = 0 ; + m_lastMilli = -1 ; + m_id = 0; + m_oneShot = FALSE; +} + +wxTimer::~wxTimer() +{ + Stop(); +} + +bool wxTimer::Start(int milliseconds,bool mode) +{ + m_oneShot = mode ; + if (m_milliseconds < 0) + m_milliseconds = lastMilli; + + if (m_milliseconds <= 0) + return FALSE; + + m_lastMilli = m_milli = m_milliseconds; + + // TODO: set the timer going. + return FALSE; +} + +void wxTimer::Stop() +{ + m_id = 0 ; + m_milli = 0 ; +} + + diff --git a/src/stubs/toolbar.cpp b/src/stubs/toolbar.cpp new file mode 100644 index 0000000000..61f34c8283 --- /dev/null +++ b/src/stubs/toolbar.cpp @@ -0,0 +1,156 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: toolbar.cpp +// Purpose: wxToolBar +// Author: AUTHOR +// Modified by: +// Created: 04/01/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "toolbar.h" +#endif + +// For compilers that support precompilation, includes "wx.h". +#include "wx/wxprec.h" + +#ifdef __BORLANDC__ +#pragma hdrstop +#endif + +#ifndef WX_PRECOMP +#include "wx.h" +#endif + +#include "wx/toolbar.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase) + +BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase) +END_EVENT_TABLE() +#endif + +wxToolBar::wxToolBar() +{ + m_maxWidth = -1; + m_maxHeight = -1; + m_defaultWidth = 24; + m_defaultHeight = 22; + // TODO +} + +bool wxToolBar::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, + long style, const wxString& name) +{ + m_maxWidth = -1; + m_maxHeight = -1; + + m_defaultWidth = 24; + m_defaultHeight = 22; + SetName(name); + + m_windowStyle = style; + + SetParent(parent); + + if (parent) parent->AddChild(this); + + // TODO create toolbar + + return FALSE; +} + +wxToolBar::~wxToolBar() +{ + // TODO +} + +bool wxToolBar::CreateTools() +{ + if (m_tools.Number() == 0) + return FALSE; + + // TODO + return FALSE; +} + +void wxToolBar::SetToolBitmapSize(const wxSize& size) +{ + m_defaultWidth = size.x; m_defaultHeight = size.y; + // TODO +} + +wxSize wxToolBar::GetMaxSize() const +{ + // TODO + return wxSize(0, 0); +} + +// The button size is bigger than the bitmap size +wxSize wxToolBar::GetToolSize() const +{ + // TODO + return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); +} + +void wxToolBar::EnableTool(int toolIndex, bool enable) +{ + wxNode *node = m_tools.Find((long)toolIndex); + if (node) + { + wxToolBarTool *tool = (wxToolBarTool *)node->Data(); + tool->m_enabled = enable; + // TODO enable button + } + } +} + +void wxToolBar::ToggleTool(int toolIndex, bool toggle) +{ + wxNode *node = m_tools.Find((long)toolIndex); + if (node) + { + wxToolBarTool *tool = (wxToolBarTool *)node->Data(); + if (tool->m_isToggle) + { + tool->m_toggleState = toggle; + // TODO: set toggle state + } + } +} + +void wxToolBar::ClearTools() +{ + // TODO + wxToolBarBase::ClearTools(); +} + +// If pushedBitmap is NULL, a reversed version of bitmap is +// created and used as the pushed/toggled image. +// If toggle is TRUE, the button toggles between the two states. + +wxToolBarTool *wxToolBar::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap, + bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2) +{ + wxToolBarTool *tool = new wxToolBarTool(index, bitmap, (wxBitmap *)NULL, toggle, xPos, yPos, helpString1, helpString2); + tool->m_clientData = clientData; + + if (xPos > -1) + tool->m_x = xPos; + else + tool->m_x = m_xMargin; + + if (yPos > -1) + tool->m_y = yPos; + else + tool->m_y = m_yMargin; + + tool->SetSize(GetDefaultButtonWidth(), GetDefaultButtonHeight()); + + m_tools.Append((long)index, tool); + return tool; +} + diff --git a/src/stubs/treectrl.cpp b/src/stubs/treectrl.cpp new file mode 100644 index 0000000000..0b405a7106 --- /dev/null +++ b/src/stubs/treectrl.cpp @@ -0,0 +1,419 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: treectrl.cpp +// Purpose: wxTreeCtrl +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "treectrl.h" +#endif + +#include "wx/treectrl.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTreeCtrl, wxControl) +IMPLEMENT_DYNAMIC_CLASS(wxTreeItem, wxObject) + +#endif + +wxTreeCtrl::wxTreeCtrl() +{ + m_imageListNormal = NULL; + m_imageListState = NULL; + m_textCtrl = NULL; +} + +bool wxTreeCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, + long style, const wxValidator& validator, const wxString& name) +{ + SetName(name); + SetValidator(validator); + + m_imageListNormal = NULL; + m_imageListState = NULL; + m_textCtrl = NULL; + + m_windowStyle = style; + + SetParent(parent); + + m_windowId = (id == -1) ? NewControlId() : id; + + if (parent) parent->AddChild(this); + + // TODO create tree control + + return FALSE; +} + +wxTreeCtrl::~wxTreeCtrl() +{ + if (m_textCtrl) + { + delete m_textCtrl; + } +} + +// Attributes +int wxTreeCtrl::GetCount() const +{ + // TODO + return 0; +} + +int wxTreeCtrl::GetIndent() const +{ + // TODO + return 0; +} + +void wxTreeCtrl::SetIndent(int indent) +{ + // TODO +} + +wxImageList *wxTreeCtrl::GetImageList(int which) const +{ + if ( which == wxIMAGE_LIST_NORMAL ) + { + return m_imageListNormal; + } + else if ( which == wxIMAGE_LIST_STATE ) + { + return m_imageListState; + } + return NULL; +} + +void wxTreeCtrl::SetImageList(wxImageList *imageList, int which) +{ + if ( which == wxIMAGE_LIST_NORMAL ) + { + m_imageListNormal = imageList; + } + else if ( which == wxIMAGE_LIST_STATE ) + { + m_imageListState = imageList; + } + // TODO +} + +long wxTreeCtrl::GetNextItem(long item, int code) const +{ + // TODO + return 0; +} + +bool wxTreeCtrl::ItemHasChildren(long item) const +{ + // TODO + return FALSE; +} + +long wxTreeCtrl::GetChild(long item) const +{ + // TODO + return 0; +} + +long wxTreeCtrl::GetParent(long item) const +{ + // TODO + return 0; +} + +long wxTreeCtrl::GetFirstVisibleItem() const +{ + // TODO + return 0; +} + +long wxTreeCtrl::GetNextVisibleItem(long item) const +{ + // TODO + return 0; +} + +long wxTreeCtrl::GetSelection() const +{ + // TODO + return 0; +} + +long wxTreeCtrl::GetRootItem() const +{ + // TODO + return 0; +} + +bool wxTreeCtrl::GetItem(wxTreeItem& info) const +{ + // TODO + return FALSE; +} + +bool wxTreeCtrl::SetItem(wxTreeItem& info) +{ + // TODO + return FALSE; +} + +int wxTreeCtrl::GetItemState(long item, long stateMask) const +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_STATE ; + info.m_stateMask = stateMask; + info.m_itemId = item; + + if (!GetItem(info)) + return 0; + + return info.m_state; +} + +bool wxTreeCtrl::SetItemState(long item, long state, long stateMask) +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_STATE ; + info.m_state = state; + info.m_stateMask = stateMask; + info.m_itemId = item; + + return SetItem(info); +} + +bool wxTreeCtrl::SetItemImage(long item, int image, int selImage) +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_IMAGE ; + info.m_image = image; + if ( selImage > -1) + { + info.m_selectedImage = selImage; + info.m_mask |= wxTREE_MASK_SELECTED_IMAGE; + } + info.m_itemId = item; + + return SetItem(info); +} + +wxString wxTreeCtrl::GetItemText(long item) const +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_TEXT ; + info.m_itemId = item; + + if (!GetItem(info)) + return wxString(""); + return info.m_text; +} + +void wxTreeCtrl::SetItemText(long item, const wxString& str) +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_TEXT ; + info.m_itemId = item; + info.m_text = str; + + SetItem(info); +} + +long wxTreeCtrl::GetItemData(long item) const +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_DATA ; + info.m_itemId = item; + + if (!GetItem(info)) + return 0; + return info.m_data; +} + +bool wxTreeCtrl::SetItemData(long item, long data) +{ + wxTreeItem info; + + info.m_mask = wxTREE_MASK_DATA ; + info.m_itemId = item; + info.m_data = data; + + return SetItem(info); +} + +bool wxTreeCtrl::GetItemRect(long item, wxRectangle& rect, bool textOnly) const +{ + // TODO + return FALSE; +} + +wxTextCtrl* wxTreeCtrl::GetEditControl() const +{ + return m_textCtrl; +} + +// Operations +bool wxTreeCtrl::DeleteItem(long item) +{ + // TODO + return FALSE; +} + +bool wxTreeCtrl::ExpandItem(long item, int action) +{ + // TODO + switch ( action ) + { + case wxTREE_EXPAND_EXPAND: + break; + + case wxTREE_EXPAND_COLLAPSE: + break; + + case wxTREE_EXPAND_COLLAPSE_RESET: + mswAction = TVE_COLLAPSERESET; + break; + + case wxTREE_EXPAND_TOGGLE: + mswAction = TVE_TOGGLE; + break; + + default: + wxFAIL_MSG("unknown action in wxTreeCtrl::ExpandItem"); + } + + bool bOk = FALSE; // TODO expand item + + // May not send messages, so emulate them + if ( bOk ) { + wxTreeEvent event(wxEVT_NULL, m_windowId); + event.m_item.m_itemId = item; + event.m_item.m_mask = + event.m_item.m_stateMask = 0xffff; // get all + GetItem(event.m_item); + + bool bIsExpanded = (event.m_item.m_state & wxTREE_STATE_EXPANDED) != 0; + + event.m_code = action; + event.SetEventObject(this); + + // @@@ return values of {EXPAND|COLLAPS}ING event handler is discarded + event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDING + : wxEVT_COMMAND_TREE_ITEM_COLLAPSING); + GetEventHandler()->ProcessEvent(event); + + event.SetEventType(bIsExpanded ? wxEVT_COMMAND_TREE_ITEM_EXPANDED + : wxEVT_COMMAND_TREE_ITEM_COLLAPSED); + GetEventHandler()->ProcessEvent(event); + } + + return bOk; +} + +long wxTreeCtrl::InsertItem(long parent, wxTreeItem& info, long insertAfter) +{ + // TODO + return 0; +} + +long wxTreeCtrl::InsertItem(long parent, const wxString& label, int image, int selImage, + long insertAfter) +{ + wxTreeItem info; + info.m_text = label; + info.m_mask = wxTREE_MASK_TEXT; + if ( image > -1 ) + { + info.m_mask |= wxTREE_MASK_IMAGE | wxTREE_MASK_SELECTED_IMAGE; + info.m_image = image; + if ( selImage == -1 ) + info.m_selectedImage = image; + else + info.m_selectedImage = selImage; + } + + return InsertItem(parent, info, insertAfter); +} + +bool wxTreeCtrl::SelectItem(long item) +{ + // TODO + return FALSE; +} + +bool wxTreeCtrl::ScrollTo(long item) +{ + // TODO + return FALSE; +} + +bool wxTreeCtrl::DeleteAllItems() +{ + // TODO + return FALSE; +} + +wxTextCtrl* wxTreeCtrl::EditLabel(long item, wxClassInfo* textControlClass) +{ + // TODO + return NULL; +} + +// End label editing, optionally cancelling the edit +bool wxTreeCtrl::EndEditLabel(bool cancel) +{ + // TODO + return FALSE; +} + +long wxTreeCtrl::HitTest(const wxPoint& point, int& flags) +{ + // TODO + return 0; +} + +bool wxTreeCtrl::SortChildren(long item) +{ + // TODO + return FALSE; +} + +bool wxTreeCtrl::EnsureVisible(long item) +{ + // TODO + return FALSE; +} + +// Tree item structure +wxTreeItem::wxTreeItem() +{ + m_mask = 0; + m_itemId = 0; + m_state = 0; + m_stateMask = 0; + m_image = -1; + m_selectedImage = -1; + m_children = 0; + m_data = 0; +} + +// Tree event +IMPLEMENT_DYNAMIC_CLASS(wxTreeEvent, wxCommandEvent) + +wxTreeEvent::wxTreeEvent(wxEventType commandType, int id): + wxCommandEvent(commandType, id) +{ + m_code = 0; + m_oldItem = 0; +} + diff --git a/src/stubs/utils.cpp b/src/stubs/utils.cpp new file mode 100644 index 0000000000..8d9cbf0387 --- /dev/null +++ b/src/stubs/utils.cpp @@ -0,0 +1,272 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: utils.cpp +// Purpose: Various utilities +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +// Note: this is done in utilscmn.cpp now. +// #pragma implementation +// #pragma implementation "utils.h" +#endif + +#include "wx/setup.h" +#include "wx/utils.h" +#include "wx/app.h" + +#include + +#include +#include +#include +#include + +// Get full hostname (eg. DoDo.BSn-Germany.crg.de) +bool wxGetHostName(char *buf, int maxSize) +{ + // TODO + return FALSE; +} + +// Get user ID e.g. jacs +bool wxGetUserId(char *buf, int maxSize) +{ + // TODO + return FALSE; +} + +// Get user name e.g. AUTHOR +bool wxGetUserName(char *buf, int maxSize) +{ + // TODO + return FALSE; +} + +int wxKill(long pid, int sig) +{ + // TODO + return 0; +} + +// +// Execute a program in an Interactive Shell +// +bool wxShell(const wxString& command) +{ + // TODO + return FALSE; +} + +// Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX) +long wxGetFreeMemory() +{ + // TODO + return 0; +} + +void wxSleep(int nSecs) +{ + // TODO +} + +// Consume all events until no more left +void wxFlushEvents() +{ +} + +// Output a debug message, in a system dependent fashion. +void wxDebugMsg(const char *fmt ...) +{ + va_list ap; + static char buffer[512]; + + if (!wxTheApp->GetWantDebugOutput()) + return ; + + va_start(ap, fmt); + + // wvsprintf(buffer,fmt,ap) ; + // TODO: output buffer + + va_end(ap); +} + +// Non-fatal error: pop up message box and (possibly) continue +void wxError(const wxString& msg, const wxString& title) +{ + // TODO + wxExit(); +} + +// Fatal error: pop up message box and abort +void wxFatalError(const wxString& msg, const wxString& title) +{ + // TODO +} + +// Emit a beeeeeep +void wxBell() +{ + // TODO +} + +int wxGetOsVersion(int *majorVsn, int *minorVsn) +{ + // TODO + return 0; +} + +// Reading and writing resources (eg WIN.INI, .Xdefaults) +#if USE_RESOURCES +bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file) +{ + // TODO + return FALSE; +} + +bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file) +{ + char buf[50]; + sprintf(buf, "%.4f", value); + return wxWriteResource(section, entry, buf, file); +} + +bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file) +{ + char buf[50]; + sprintf(buf, "%ld", value); + return wxWriteResource(section, entry, buf, file); +} + +bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file) +{ + char buf[50]; + sprintf(buf, "%d", value); + return wxWriteResource(section, entry, buf, file); +} + +bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file) +{ + // TODO + return FALSE; +} + +bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file) +{ + char *s = NULL; + bool succ = wxGetResource(section, entry, (char **)&s, file); + if (succ) + { + *value = (float)strtod(s, NULL); + delete[] s; + return TRUE; + } + else return FALSE; +} + +bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file) +{ + char *s = NULL; + bool succ = wxGetResource(section, entry, (char **)&s, file); + if (succ) + { + *value = strtol(s, NULL, 10); + delete[] s; + return TRUE; + } + else return FALSE; +} + +bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file) +{ + char *s = NULL; + bool succ = wxGetResource(section, entry, (char **)&s, file); + if (succ) + { + *value = (int)strtol(s, NULL, 10); + delete[] s; + return TRUE; + } + else return FALSE; +} +#endif // USE_RESOURCES + +static int wxBusyCursorCount = 0; + +// Set the cursor to the busy cursor for all windows +void wxBeginBusyCursor(wxCursor *cursor) +{ + wxBusyCursorCount ++; + if (wxBusyCursorCount == 1) + { + // TODO + } + else + { + // TODO + } +} + +// Restore cursor to normal +void wxEndBusyCursor() +{ + if (wxBusyCursorCount == 0) + return; + + wxBusyCursorCount --; + if (wxBusyCursorCount == 0) + { + // TODO + } +} + +// TRUE if we're between the above two calls +bool wxIsBusy() +{ + return (wxBusyCursorCount > 0); +} + +char *wxGetUserHome (const wxString& user) +{ + // TODO + return NULL; +} + +// Check whether this window wants to process messages, e.g. Stop button +// in long calculations. +bool wxCheckForInterrupt(wxWindow *wnd) +{ + // TODO + return FALSE; +} + +void wxGetMousePosition( int* x, int* y ) +{ + // TODO +}; + +// Return TRUE if we have a colour display +bool wxColourDisplay() +{ + // TODO + return TRUE; +} + +// Returns depth of screen +int wxDisplayDepth() +{ + // TODO + return 0; +} + +// Get size of display +void wxDisplaySize(int *width, int *height) +{ + // TODO +} + diff --git a/src/stubs/utilsexc.cpp b/src/stubs/utilsexc.cpp new file mode 100644 index 0000000000..b842d08e90 --- /dev/null +++ b/src/stubs/utilsexc.cpp @@ -0,0 +1,28 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: utilsexec.cpp +// Purpose: Execution-related utilities +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation +#endif + +#include "wx/utils.h" + +#include +#include +#include + +#define wxEXECUTE_WIN_MESSAGE 10000 + +long wxExecute(const wxString& command, bool sync, wxProcess *handler) +{ + // TODO + return 0; +} diff --git a/src/stubs/wave.cpp b/src/stubs/wave.cpp new file mode 100644 index 0000000000..e908428ce4 --- /dev/null +++ b/src/stubs/wave.cpp @@ -0,0 +1,59 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wave.cpp +// Purpose: wxWave class implementation: optional +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "wave.h" +#endif + +#include "wx/stubs/wave.h" + +wxWave::wxWave() + : m_waveLength(0), m_isResource(FALSE), m_waveData(NULL) +{ +} + +wxWave::wxWave(const wxString& sFileName, bool isResource) + : m_waveLength(0), m_isResource(isResource), m_waveData(NULL) +{ + Create(sFileName, isResource); +} + + +wxWave::~wxWave() +{ + Free(); +} + +bool wxWave::Create(const wxString& fileName, bool isResource) +{ + Free(); + + // TODO + + return FALSE; +} + +bool wxWave::Play(bool async, bool looped) const +{ + if (!IsOk()) + return FALSE; + + // TODO + return FALSE; +} + +bool wxWave::Free() +{ + // TODO + return FALSE; +} + + diff --git a/src/stubs/window.cpp b/src/stubs/window.cpp new file mode 100644 index 0000000000..341ad00e51 --- /dev/null +++ b/src/stubs/window.cpp @@ -0,0 +1,1281 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: windows.cpp +// Purpose: wxWindow +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "window.h" +#endif + +#include "wx/setup.h" +#include "wx/menu.h" +#include "wx/dc.h" +#include "wx/dcclient.h" +#include "wx/utils.h" +#include "wx/app.h" +#include "wx/panel.h" +#include "wx/layout.h" +#include "wx/dialog.h" +#include "wx/listbox.h" +#include "wx/button.h" +#include "wx/settings.h" +#include "wx/msgdlg.h" + +#include "wx/menuitem.h" +#include "wx/log.h" + +#if USE_DRAG_AND_DROP +#include "wx/dnd.h" +#endif + +#include + +extern wxList wxPendingDelete; + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler) + +BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler) + EVT_CHAR(wxWindow::OnChar) + EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground) + EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged) + EVT_INIT_DIALOG(wxWindow::OnInitDialog) + EVT_IDLE(wxWindow::OnIdle) +END_EVENT_TABLE() + +#endif + + +// Constructor +wxWindow::wxWindow() +{ + // Generic + m_windowId = 0; + m_windowStyle = 0; + m_windowParent = NULL; + m_windowEventHandler = this; + m_windowName = ""; + m_windowCursor = *wxSTANDARD_CURSOR; + m_children = new wxList; + m_constraints = NULL; + m_constraintsInvolvedIn = NULL; + m_windowSizer = NULL; + m_sizerParent = NULL; + m_autoLayout = FALSE; + m_windowValidator = NULL; + m_defaultItem = NULL; + m_returnCode = 0; + m_caretWidth = 0; m_caretHeight = 0; + m_caretEnabled = FALSE; + m_caretShown = FALSE; + m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ; + m_foregroundColour = *wxBLACK; + m_defaultForegroundColour = *wxBLACK ; + m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ; + +#if USE_DRAG_AND_DROP + m_pDropTarget = NULL; +#endif +} + +// Destructor +wxWindow::~wxWindow() +{ + // Have to delete constraints/sizer FIRST otherwise + // sizers may try to look at deleted windows as they + // delete themselves. +#if USE_CONSTRAINTS + DeleteRelatedConstraints(); + if (m_constraints) + { + // This removes any dangling pointers to this window + // in other windows' constraintsInvolvedIn lists. + UnsetConstraints(m_constraints); + delete m_constraints; + m_constraints = NULL; + } + if (m_windowSizer) + { + delete m_windowSizer; + m_windowSizer = NULL; + } + // If this is a child of a sizer, remove self from parent + if (m_sizerParent) + m_sizerParent->RemoveChild((wxWindow *)this); +#endif + + if (m_windowParent) + m_windowParent->RemoveChild(this); + + DestroyChildren(); + + // TODO: destroy the window + + delete m_children; + m_children = NULL; + + // Just in case the window has been Closed, but + // we're then deleting immediately: don't leave + // dangling pointers. + wxPendingDelete.DeleteObject(this); + + if ( m_windowValidator ) + delete m_windowValidator; +} + +// Destroy the window (delayed, if a managed window) +bool wxWindow::Destroy() +{ + delete this; + return TRUE; +} + +// Constructor +bool wxWindow::Create(wxWindow *parent, wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + // Generic + m_windowId = 0; + m_windowStyle = 0; + m_windowParent = NULL; + m_windowEventHandler = this; + m_windowName = ""; + m_windowCursor = *wxSTANDARD_CURSOR; + m_constraints = NULL; + m_constraintsInvolvedIn = NULL; + m_windowSizer = NULL; + m_sizerParent = NULL; + m_autoLayout = FALSE; + m_windowValidator = NULL; + +#if USE_DRAG_AND_DROP + m_pDropTarget = NULL; +#endif + + m_caretWidth = 0; m_caretHeight = 0; + m_caretEnabled = FALSE; + m_caretShown = FALSE; + m_minSizeX = -1; + m_minSizeY = -1; + m_maxSizeX = -1; + m_maxSizeY = -1; + m_defaultItem = NULL; + m_windowParent = NULL; + if (!parent) + return FALSE; + + if (parent) parent->AddChild(this); + + m_returnCode = 0; + + SetName(name); + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ; + m_foregroundColour = *wxBLACK; + m_defaultForegroundColour = *wxBLACK ; + m_defaultBackgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ; + + m_windowStyle = style; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + // TODO: create the window + + return TRUE; +} + +void wxWindow::SetFocus() +{ + // TODO +} + +void wxWindow::Enable(bool enable) +{ + // TODO +} + +void wxWindow::CaptureMouse() +{ + // TODO +} + +void wxWindow::ReleaseMouse() +{ + // TODO +} + +// Push/pop event handler (i.e. allow a chain of event handlers +// be searched) +void wxWindow::PushEventHandler(wxEvtHandler *handler) +{ + handler->SetNextHandler(GetEventHandler()); + SetEventHandler(handler); +} + +wxEvtHandler *wxWindow::PopEventHandler(bool deleteHandler) +{ + if ( GetEventHandler() ) + { + wxEvtHandler *handlerA = GetEventHandler(); + wxEvtHandler *handlerB = handlerA->GetNextHandler(); + handlerA->SetNextHandler(NULL); + SetEventHandler(handlerB); + if ( deleteHandler ) + { + delete handlerA; + return NULL; + } + else + return handlerA; + } + else + return NULL; +} + +#if USE_DRAG_AND_DROP + +void wxWindow::SetDropTarget(wxDropTarget *pDropTarget) +{ + if ( m_pDropTarget != 0 ) { + m_pDropTarget->Revoke(m_hWnd); + delete m_pDropTarget; + } + + m_pDropTarget = pDropTarget; + if ( m_pDropTarget != 0 ) + m_pDropTarget->Register(m_hWnd); +} + +#endif + +// Old style file-manager drag&drop +void wxWindow::DragAcceptFiles(bool accept) +{ + // TODO +} + +// Get total size +void wxWindow::GetSize(int *x, int *y) const +{ + // TODO +} + +void wxWindow::GetPosition(int *x, int *y) const +{ + // TODO +} + +void wxWindow::ScreenToClient(int *x, int *y) const +{ + // TODO +} + +void wxWindow::ClientToScreen(int *x, int *y) const +{ + // TODO +} + +void wxWindow::SetCursor(const wxCursor& cursor) +{ + m_windowCursor = cursor; + if (m_windowCursor.Ok()) + { + // TODO + } +} + + +// Get size *available for subwindows* i.e. excluding menu bar etc. +void wxWindow::GetClientSize(int *x, int *y) const +{ + // TODO +} + +void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxWindow::SetClientSize(int width, int height) +{ + // TODO +} + +// For implementation purposes - sometimes decorations make the client area +// smaller +wxPoint wxWindow::GetClientAreaOrigin() const +{ + return wxPoint(0, 0); +} + +// Makes an adjustment to the window position (for example, a frame that has +// a toolbar that it manages itself). +void wxWindow::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) +{ + if (((sizeFlags & wxSIZE_NO_ADJUSTMENTS) == 0) && GetParent()) + { + wxPoint pt(GetParent()->GetClientAreaOrigin()); + x += pt.x; y += pt.y; + } +} + +bool wxWindow::Show(bool show) +{ + // TODO + return FALSE; +} + +bool wxWindow::IsShown() const +{ + // TODO + return FALSE; +} + +int wxWindow::GetCharHeight() const +{ + // TODO + return 0; +} + +int wxWindow::GetCharWidth() const +{ + // TODO + return 0; +} + +void wxWindow::GetTextExtent(const wxString& string, int *x, int *y, + int *descent, int *externalLeading, const wxFont *theFont, bool) const +{ + wxFont *fontToUse = (wxFont *)theFont; + if (!fontToUse) + fontToUse = (wxFont *) & m_windowFont; + + // TODO +} + +void wxWindow::Refresh(bool eraseBack, const wxRectangle *rect) +{ + // TODO +} + +// Responds to colour changes: passes event on to children. +void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event) +{ + wxNode *node = GetChildren()->First(); + while ( node ) + { + // Only propagate to non-top-level windows + wxWindow *win = (wxWindow *)node->Data(); + if ( win->GetParent() ) + { + wxSysColourChangedEvent event2; + event.m_eventObject = win; + win->GetEventHandler()->ProcessEvent(event2); + } + + node = node->Next(); + } +} + +// This can be called by the app (or wxWindows) to do default processing for the current +// event. Save message/event info in wxWindow so they can be used in this function. +long wxWindow::Default() +{ + // TODO + return 0; +} + +void wxWindow::InitDialog() +{ + wxInitDialogEvent event(GetId()); + event.SetEventObject( this ); + GetEventHandler()->ProcessEvent(event); +} + +// Default init dialog behaviour is to transfer data to window +void wxWindow::OnInitDialog(wxInitDialogEvent& event) +{ + TransferDataToWindow(); +} + +// Caret manipulation +void wxWindow::CreateCaret(int w, int h) +{ + m_caretWidth = w; + m_caretHeight = h; + m_caretEnabled = TRUE; +} + +void wxWindow::CreateCaret(const wxBitmap *WXUNUSED(bitmap)) +{ + // TODO +} + +void wxWindow::ShowCaret(bool show) +{ + // TODO +} + +void wxWindow::DestroyCaret() +{ + // TODO + m_caretEnabled = FALSE; +} + +void wxWindow::SetCaretPos(int x, int y) +{ + // TODO +} + +void wxWindow::GetCaretPos(int *x, int *y) const +{ + // TODO +} + +wxWindow *wxGetActiveWindow() +{ + // TODO + return NULL; +} + +void wxWindow::SetSizeHints(int minW, int minH, int maxW, int maxH, int WXUNUSED(incW), int WXUNUSED(incH)) +{ + m_minSizeX = minW; + m_minSizeY = minH; + m_maxSizeX = maxW; + m_maxSizeY = maxH; +} + +void wxWindow::Centre(int direction) +{ + int x, y, width, height, panel_width, panel_height, new_x, new_y; + + wxWindow *father = (wxWindow *)GetParent(); + if (!father) + return; + + father->GetClientSize(&panel_width, &panel_height); + GetSize(&width, &height); + GetPosition(&x, &y); + + new_x = -1; + new_y = -1; + + if (direction & wxHORIZONTAL) + new_x = (int)((panel_width - width)/2); + + if (direction & wxVERTICAL) + new_y = (int)((panel_height - height)/2); + + SetSize(new_x, new_y, -1, -1); + +} + +// Coordinates relative to the window +void wxWindow::WarpPointer (int x_pos, int y_pos) +{ + // TODO +} + +void wxWindow::OnEraseBackground(wxEraseEvent& event) +{ + // TODO + Default(); +} + +int wxWindow::GetScrollPos(int orient) const +{ + // TODO + return 0; +} + +// This now returns the whole range, not just the number +// of positions that we can scroll. +int wxWindow::GetScrollRange(int orient) const +{ + // TODO + return 0; +} + +int wxWindow::GetScrollThumb(int orient) const +{ + // TODO + return 0; +} + +void wxWindow::SetScrollPos(int orient, int pos, bool refresh) +{ + // TODO + return 0; +} + +// New function that will replace some of the above. +void wxWindow::SetScrollbar(int orient, int pos, int thumbVisible, + int range, bool refresh) +{ + // TODO +} + +// Does a physical scroll +void wxWindow::ScrollWindow(int dx, int dy, const wxRectangle *rect) +{ + // TODO + return 0; +} + +void wxWindow::SetFont(const wxFont& font) +{ + m_windowFont = font; + + if (!m_windowFont.Ok()) + return; + // TODO +} + +void wxWindow::OnChar(wxKeyEvent& event) +{ + if ( event.KeyCode() == WXK_TAB ) { + // propagate the TABs to the parent - it's up to it to decide what + // to do with it + if ( GetParent() ) { + if ( GetParent()->ProcessEvent(event) ) + return; + } + } +} + +void wxWindow::OnPaint(wxPaintEvent& event) +{ + Default(); +} + +bool wxWindow::IsEnabled() const +{ + // TODO + return FALSE; +} + +// Dialog support: override these and call +// base class members to add functionality +// that can't be done using validators. +// NOTE: these functions assume that controls +// are direct children of this window, not grandchildren +// or other levels of descendant. + +// Transfer values to controls. If returns FALSE, +// it's an application error (pops up a dialog) +bool wxWindow::TransferDataToWindow() +{ + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *child = (wxWindow *)node->Data(); + if ( child->GetValidator() && + !child->GetValidator()->TransferToWindow() ) + { + wxMessageBox("Application Error", "Could not transfer data to window", wxOK|wxICON_EXCLAMATION); + return FALSE; + } + + node = node->Next(); + } + return TRUE; +} + +// Transfer values from controls. If returns FALSE, +// validation failed: don't quit +bool wxWindow::TransferDataFromWindow() +{ + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *child = (wxWindow *)node->Data(); + if ( child->GetValidator() && !child->GetValidator()->TransferFromWindow() ) + { + return FALSE; + } + + node = node->Next(); + } + return TRUE; +} + +bool wxWindow::Validate() +{ + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *child = (wxWindow *)node->Data(); + if ( child->GetValidator() && /* child->GetValidator()->Ok() && */ !child->GetValidator()->Validate(this) ) + { + return FALSE; + } + + node = node->Next(); + } + return TRUE; +} + +// Get the window with the focus +wxWindow *wxWindow::FindFocus() +{ + // TODO + return NULL; +} + +void wxWindow::AddChild(wxWindow *child) +{ + GetChildren()->Append(child); + child->m_windowParent = this; +} + +void wxWindow::RemoveChild(wxWindow *child) +{ + if (GetChildren()) + GetChildren()->DeleteObject(child); + child->m_windowParent = NULL; +} + +void wxWindow::DestroyChildren() +{ + if (GetChildren()) { + wxNode *node; + while ((node = GetChildren()->First()) != (wxNode *)NULL) { + wxWindow *child; + if ((child = (wxWindow *)node->Data()) != (wxWindow *)NULL) { + delete child; + if ( GetChildren()->Member(child) ) + delete node; + } + } /* while */ + } +} + +void wxWindow::MakeModal(bool modal) +{ + // Disable all other windows + if (this->IsKindOf(CLASSINFO(wxDialog)) || this->IsKindOf(CLASSINFO(wxFrame))) + { + wxNode *node = wxTopLevelWindows.First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + if (win != this) + win->Enable(!modal); + + node = node->Next(); + } + } +} + +// If nothing defined for this, try the parent. +// E.g. we may be a button loaded from a resource, with no callback function +// defined. +void wxWindow::OnCommand(wxWindow& win, wxCommandEvent& event) +{ + if (GetEventHandler()->ProcessEvent(event) ) + return; + if (m_windowParent) + m_windowParent->GetEventHandler()->OnCommand(win, event); +} + +void wxWindow::SetConstraints(wxLayoutConstraints *c) +{ + if (m_constraints) + { + UnsetConstraints(m_constraints); + delete m_constraints; + } + m_constraints = c; + if (m_constraints) + { + // Make sure other windows know they're part of a 'meaningful relationship' + if (m_constraints->left.GetOtherWindow() && (m_constraints->left.GetOtherWindow() != this)) + m_constraints->left.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->top.GetOtherWindow() && (m_constraints->top.GetOtherWindow() != this)) + m_constraints->top.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->right.GetOtherWindow() && (m_constraints->right.GetOtherWindow() != this)) + m_constraints->right.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->bottom.GetOtherWindow() && (m_constraints->bottom.GetOtherWindow() != this)) + m_constraints->bottom.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->width.GetOtherWindow() && (m_constraints->width.GetOtherWindow() != this)) + m_constraints->width.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->height.GetOtherWindow() && (m_constraints->height.GetOtherWindow() != this)) + m_constraints->height.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->centreX.GetOtherWindow() && (m_constraints->centreX.GetOtherWindow() != this)) + m_constraints->centreX.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + if (m_constraints->centreY.GetOtherWindow() && (m_constraints->centreY.GetOtherWindow() != this)) + m_constraints->centreY.GetOtherWindow()->AddConstraintReference((wxWindow *)this); + } +} + +// This removes any dangling pointers to this window +// in other windows' constraintsInvolvedIn lists. +void wxWindow::UnsetConstraints(wxLayoutConstraints *c) +{ + if (c) + { + if (c->left.GetOtherWindow() && (c->top.GetOtherWindow() != this)) + c->left.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->top.GetOtherWindow() && (c->top.GetOtherWindow() != this)) + c->top.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->right.GetOtherWindow() && (c->right.GetOtherWindow() != this)) + c->right.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->bottom.GetOtherWindow() && (c->bottom.GetOtherWindow() != this)) + c->bottom.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->width.GetOtherWindow() && (c->width.GetOtherWindow() != this)) + c->width.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->height.GetOtherWindow() && (c->height.GetOtherWindow() != this)) + c->height.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->centreX.GetOtherWindow() && (c->centreX.GetOtherWindow() != this)) + c->centreX.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + if (c->centreY.GetOtherWindow() && (c->centreY.GetOtherWindow() != this)) + c->centreY.GetOtherWindow()->RemoveConstraintReference((wxWindow *)this); + } +} + +// Back-pointer to other windows we're involved with, so if we delete +// this window, we must delete any constraints we're involved with. +void wxWindow::AddConstraintReference(wxWindow *otherWin) +{ + if (!m_constraintsInvolvedIn) + m_constraintsInvolvedIn = new wxList; + if (!m_constraintsInvolvedIn->Member(otherWin)) + m_constraintsInvolvedIn->Append(otherWin); +} + +// REMOVE back-pointer to other windows we're involved with. +void wxWindow::RemoveConstraintReference(wxWindow *otherWin) +{ + if (m_constraintsInvolvedIn) + m_constraintsInvolvedIn->DeleteObject(otherWin); +} + +// Reset any constraints that mention this window +void wxWindow::DeleteRelatedConstraints() +{ + if (m_constraintsInvolvedIn) + { + wxNode *node = m_constraintsInvolvedIn->First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + wxNode *next = node->Next(); + wxLayoutConstraints *constr = win->GetConstraints(); + + // Reset any constraints involving this window + if (constr) + { + constr->left.ResetIfWin((wxWindow *)this); + constr->top.ResetIfWin((wxWindow *)this); + constr->right.ResetIfWin((wxWindow *)this); + constr->bottom.ResetIfWin((wxWindow *)this); + constr->width.ResetIfWin((wxWindow *)this); + constr->height.ResetIfWin((wxWindow *)this); + constr->centreX.ResetIfWin((wxWindow *)this); + constr->centreY.ResetIfWin((wxWindow *)this); + } + delete node; + node = next; + } + delete m_constraintsInvolvedIn; + m_constraintsInvolvedIn = NULL; + } +} + +void wxWindow::SetSizer(wxSizer *sizer) +{ + m_windowSizer = sizer; + if (sizer) + sizer->SetSizerParent((wxWindow *)this); +} + +/* + * New version + */ + +bool wxWindow::Layout() +{ + if (GetConstraints()) + { + int w, h; + GetClientSize(&w, &h); + GetConstraints()->width.SetValue(w); + GetConstraints()->height.SetValue(h); + } + + // If top level (one sizer), evaluate the sizer's constraints. + if (GetSizer()) + { + int noChanges; + GetSizer()->ResetConstraints(); // Mark all constraints as unevaluated + GetSizer()->LayoutPhase1(&noChanges); + GetSizer()->LayoutPhase2(&noChanges); + GetSizer()->SetConstraintSizes(); // Recursively set the real window sizes + return TRUE; + } + else + { + // Otherwise, evaluate child constraints + ResetConstraints(); // Mark all constraints as unevaluated + DoPhase(1); // Just one phase need if no sizers involved + DoPhase(2); + SetConstraintSizes(); // Recursively set the real window sizes + } + return TRUE; +} + + +// Do a phase of evaluating constraints: +// the default behaviour. wxSizers may do a similar +// thing, but also impose their own 'constraints' +// and order the evaluation differently. +bool wxWindow::LayoutPhase1(int *noChanges) +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + return constr->SatisfyConstraints((wxWindow *)this, noChanges); + } + else + return TRUE; +} + +bool wxWindow::LayoutPhase2(int *noChanges) +{ + *noChanges = 0; + + // Layout children + DoPhase(1); + DoPhase(2); + return TRUE; +} + +// Do a phase of evaluating child constraints +bool wxWindow::DoPhase(int phase) +{ + int noIterations = 0; + int maxIterations = 500; + int noChanges = 1; + int noFailures = 0; + wxList succeeded; + while ((noChanges > 0) && (noIterations < maxIterations)) + { + noChanges = 0; + noFailures = 0; + wxNode *node = GetChildren()->First(); + while (node) + { + wxWindow *child = (wxWindow *)node->Data(); + if (!child->IsKindOf(CLASSINFO(wxFrame)) && !child->IsKindOf(CLASSINFO(wxDialog))) + { + wxLayoutConstraints *constr = child->GetConstraints(); + if (constr) + { + if (succeeded.Member(child)) + { + } + else + { + int tempNoChanges = 0; + bool success = ( (phase == 1) ? child->LayoutPhase1(&tempNoChanges) : child->LayoutPhase2(&tempNoChanges) ) ; + noChanges += tempNoChanges; + if (success) + { + succeeded.Append(child); + } + } + } + } + node = node->Next(); + } + noIterations ++; + } + return TRUE; +} + +void wxWindow::ResetConstraints() +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + constr->left.SetDone(FALSE); + constr->top.SetDone(FALSE); + constr->right.SetDone(FALSE); + constr->bottom.SetDone(FALSE); + constr->width.SetDone(FALSE); + constr->height.SetDone(FALSE); + constr->centreX.SetDone(FALSE); + constr->centreY.SetDone(FALSE); + } + wxNode *node = GetChildren()->First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog))) + win->ResetConstraints(); + node = node->Next(); + } +} + +// Need to distinguish between setting the 'fake' size for +// windows and sizers, and setting the real values. +void wxWindow::SetConstraintSizes(bool recurse) +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr && constr->left.GetDone() && constr->right.GetDone() && + constr->width.GetDone() && constr->height.GetDone()) + { + int x = constr->left.GetValue(); + int y = constr->top.GetValue(); + int w = constr->width.GetValue(); + int h = constr->height.GetValue(); + + // If we don't want to resize this window, just move it... + if ((constr->width.GetRelationship() != wxAsIs) || + (constr->height.GetRelationship() != wxAsIs)) + { + // Calls Layout() recursively. AAAGH. How can we stop that. + // Simply take Layout() out of non-top level OnSizes. + SizerSetSize(x, y, w, h); + } + else + { + SizerMove(x, y); + } + } + else if (constr) + { + char *windowClass = this->GetClassInfo()->GetClassName(); + + wxString winName; + if (GetName() == "") + winName = "unnamed"; + else + winName = GetName(); + wxDebugMsg("Constraint(s) not satisfied for window of type %s, name %s:\n", (const char *)windowClass, (const char *)winName); + if (!constr->left.GetDone()) + wxDebugMsg(" unsatisfied 'left' constraint.\n"); + if (!constr->right.GetDone()) + wxDebugMsg(" unsatisfied 'right' constraint.\n"); + if (!constr->width.GetDone()) + wxDebugMsg(" unsatisfied 'width' constraint.\n"); + if (!constr->height.GetDone()) + wxDebugMsg(" unsatisfied 'height' constraint.\n"); + wxDebugMsg("Please check constraints: try adding AsIs() constraints.\n"); + } + + if (recurse) + { + wxNode *node = GetChildren()->First(); + while (node) + { + wxWindow *win = (wxWindow *)node->Data(); + if (!win->IsKindOf(CLASSINFO(wxFrame)) && !win->IsKindOf(CLASSINFO(wxDialog))) + win->SetConstraintSizes(); + node = node->Next(); + } + } +} + +// This assumes that all sizers are 'on' the same +// window, i.e. the parent of this window. +void wxWindow::TransformSizerToActual(int *x, int *y) const +{ + if (!m_sizerParent || m_sizerParent->IsKindOf(CLASSINFO(wxDialog)) || + m_sizerParent->IsKindOf(CLASSINFO(wxFrame)) ) + return; + + int xp, yp; + m_sizerParent->GetPosition(&xp, &yp); + m_sizerParent->TransformSizerToActual(&xp, &yp); + *x += xp; + *y += yp; +} + +void wxWindow::SizerSetSize(int x, int y, int w, int h) +{ + int xx = x; + int yy = y; + TransformSizerToActual(&xx, &yy); + SetSize(xx, yy, w, h); +} + +void wxWindow::SizerMove(int x, int y) +{ + int xx = x; + int yy = y; + TransformSizerToActual(&xx, &yy); + Move(xx, yy); +} + +// Only set the size/position of the constraint (if any) +void wxWindow::SetSizeConstraint(int x, int y, int w, int h) +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + if (x != -1) + { + constr->left.SetValue(x); + constr->left.SetDone(TRUE); + } + if (y != -1) + { + constr->top.SetValue(y); + constr->top.SetDone(TRUE); + } + if (w != -1) + { + constr->width.SetValue(w); + constr->width.SetDone(TRUE); + } + if (h != -1) + { + constr->height.SetValue(h); + constr->height.SetDone(TRUE); + } + } +} + +void wxWindow::MoveConstraint(int x, int y) +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + if (x != -1) + { + constr->left.SetValue(x); + constr->left.SetDone(TRUE); + } + if (y != -1) + { + constr->top.SetValue(y); + constr->top.SetDone(TRUE); + } + } +} + +void wxWindow::GetSizeConstraint(int *w, int *h) const +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + *w = constr->width.GetValue(); + *h = constr->height.GetValue(); + } + else + GetSize(w, h); +} + +void wxWindow::GetClientSizeConstraint(int *w, int *h) const +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + *w = constr->width.GetValue(); + *h = constr->height.GetValue(); + } + else + GetClientSize(w, h); +} + +void wxWindow::GetPositionConstraint(int *x, int *y) const +{ + wxLayoutConstraints *constr = GetConstraints(); + if (constr) + { + *x = constr->left.GetValue(); + *y = constr->top.GetValue(); + } + else + GetPosition(x, y); +} + +bool wxWindow::Close(bool force) +{ + wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId); + event.SetEventObject(this); + event.SetForce(force); + + return GetEventHandler()->ProcessEvent(event); +} + +wxObject* wxWindow::GetChild(int number) const +{ + // Return a pointer to the Nth object in the window + if (!GetChildren()) + return(NULL) ; + wxNode *node = GetChildren()->First(); + int n = number; + while (node && n--) + node = node->Next() ; + if (node) + { + wxObject *obj = (wxObject *)node->Data(); + return(obj) ; + } + else + return NULL ; +} + +void wxWindow::OnDefaultAction(wxControl *initiatingItem) +{ + // Obsolete function +} + +void wxWindow::Clear() +{ + wxClientDC dc(this); + wxBrush brush(GetBackgroundColour(), wxSOLID); + dc.SetBackground(brush); + dc.Clear(); +} + +// Fits the panel around the items +void wxWindow::Fit() +{ + int maxX = 0; + int maxY = 0; + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *win = (wxWindow *)node->Data(); + int wx, wy, ww, wh; + win->GetPosition(&wx, &wy); + win->GetSize(&ww, &wh); + if ( wx + ww > maxX ) + maxX = wx + ww; + if ( wy + wh > maxY ) + maxY = wy + wh; + + node = node->Next(); + } + SetClientSize(maxX + 5, maxY + 5); +} + +void wxWindow::SetValidator(const wxValidator& validator) +{ + if ( m_windowValidator ) + delete m_windowValidator; + m_windowValidator = validator.Clone(); + + if ( m_windowValidator ) + m_windowValidator->SetWindow(this) ; +} + +// Find a window by id or name +wxWindow *wxWindow::FindWindow(long id) +{ + if ( GetId() == id) + return this; + + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *child = (wxWindow *)node->Data(); + wxWindow *found = child->FindWindow(id); + if ( found ) + return found; + node = node->Next(); + } + return NULL; +} + +wxWindow *wxWindow::FindWindow(const wxString& name) +{ + if ( GetName() == name) + return this; + + wxNode *node = GetChildren()->First(); + while ( node ) + { + wxWindow *child = (wxWindow *)node->Data(); + wxWindow *found = child->FindWindow(name); + if ( found ) + return found; + node = node->Next(); + } + return NULL; +} + +void wxWindow::OnIdle(wxIdleEvent& event) +{ +/* TODO: you may need to do something like this + * if your GUI doesn't generate enter/leave events + + // Check if we need to send a LEAVE event + if (m_mouseInWindow) + { + POINT pt; + ::GetCursorPos(&pt); + if (::WindowFromPoint(pt) != (HWND) GetHWND()) + { + // Generate a LEAVE event + m_mouseInWindow = FALSE; + MSWOnMouseLeave(pt.x, pt.y, 0); + } + } +*/ + + // This calls the UI-update mechanism (querying windows for + // menu/toolbar/control state information) + UpdateWindowUI(); +} + +// Raise the window to the top of the Z order +void wxWindow::Raise() +{ + // TODO +} + +// Lower the window to the bottom of the Z order +void wxWindow::Lower() +{ + // TODO +} + +bool wxWindow::AcceptsFocus() const +{ + return IsShown() && IsEnabled(); +} + +// Update region access +wxRegion wxWindow::GetUpdateRegion() const +{ + return m_updateRegion; +} + +bool wxWindow::IsExposed(int x, int y, int w, int h) const +{ + return (m_updateRegion.Contains(x, y, w, h) != wxOutRegion); +} + +bool wxWindow::IsExposed(const wxPoint& pt) const +{ + return (m_updateRegion.Contains(pt) != wxOutRegion); +} + +bool wxWindow::IsExposed(const wxRect& rect) const +{ + return (m_updateRegion.Contains(rect) != wxOutRegion); +} + + -- 2.45.2