From e9576ca53db96b462ed4c0b4bdf47d64c40203e4 Mon Sep 17 00:00:00 2001 From: Stefan Csomor Date: Fri, 1 Jan 1999 15:56:08 +0000 Subject: [PATCH] started once again from stubs git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1296 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- src/mac/accel.cpp | 93 +++ src/mac/app.cpp | 391 +++++++++++ src/mac/bitmap.cpp | 430 ++++++++++++ src/mac/bmpbuttn.cpp | 65 ++ src/mac/brush.cpp | 140 ++++ src/mac/button.cpp | 75 ++ src/mac/carbon/accel.cpp | 93 +++ src/mac/carbon/app.cpp | 391 +++++++++++ src/mac/carbon/bitmap.cpp | 430 ++++++++++++ src/mac/carbon/bmpbuttn.cpp | 65 ++ src/mac/carbon/brush.cpp | 140 ++++ src/mac/carbon/button.cpp | 75 ++ src/mac/carbon/checkbox.cpp | 117 ++++ src/mac/carbon/checklst.cpp | 74 ++ src/mac/carbon/choice.cpp | 119 ++++ src/mac/carbon/clipbrd.cpp | 237 +++++++ src/mac/carbon/colordlg.cpp | 53 ++ src/mac/carbon/colour.cpp | 103 +++ src/mac/carbon/combobox.cpp | 165 +++++ src/mac/carbon/control.cpp | 95 +++ src/mac/carbon/cursor.cpp | 187 +++++ src/mac/carbon/data.cpp | 151 ++++ src/mac/carbon/dc.cpp | 385 +++++++++++ src/mac/carbon/dcclient.cpp | 635 +++++++++++++++++ src/mac/carbon/dcmemory.cpp | 64 ++ src/mac/carbon/dcscreen.cpp | 32 + src/mac/carbon/dialog.cpp | 287 ++++++++ src/mac/carbon/dirdlg.cpp | 42 ++ src/mac/carbon/dnd.cpp | 133 ++++ src/mac/carbon/filedlg.cpp | 143 ++++ src/mac/carbon/font.cpp | 244 +++++++ src/mac/carbon/fontdlg.cpp | 55 ++ src/mac/carbon/frame.cpp | 571 ++++++++++++++++ src/mac/carbon/gauge.cpp | 95 +++ src/mac/carbon/gdiobj.cpp | 22 + src/mac/carbon/helpxxxx.cpp | 83 +++ src/mac/carbon/icon.cpp | 70 ++ src/mac/carbon/imaglist.cpp | 118 ++++ src/mac/carbon/joystick.cpp | 279 ++++++++ src/mac/carbon/listbox.cpp | 235 +++++++ src/mac/carbon/listctrl.cpp | 596 ++++++++++++++++ src/mac/carbon/main.cpp | 18 + src/mac/carbon/makefile.nt | 955 ++++++++++++++++++++++++++ src/mac/carbon/makefile.unx | 200 ++++++ src/mac/carbon/mdi.cpp | 265 +++++++ src/mac/carbon/menu.cpp | 571 ++++++++++++++++ src/mac/carbon/menuitem.cpp | 96 +++ src/mac/carbon/metafile.cpp | 239 +++++++ src/mac/carbon/minifram.cpp | 22 + src/mac/carbon/msgdlg.cpp | 36 + src/mac/carbon/notebook.cpp | 377 ++++++++++ src/mac/carbon/palette.cpp | 82 +++ src/mac/carbon/pen.cpp | 202 ++++++ src/mac/carbon/print.cpp | 82 +++ src/mac/carbon/printdlg.cpp | 115 ++++ src/mac/carbon/radiobox.cpp | 194 ++++++ src/mac/carbon/radiobut.cpp | 68 ++ src/mac/carbon/region.cpp | 363 ++++++++++ src/mac/carbon/scrolbar.cpp | 78 +++ src/mac/carbon/settings.cpp | 176 +++++ src/mac/carbon/slider.cpp | 190 ++++++ src/mac/carbon/spinbutt.cpp | 78 +++ src/mac/carbon/statbmp.cpp | 59 ++ src/mac/carbon/statbox.cpp | 62 ++ src/mac/carbon/stattext.cpp | 60 ++ src/mac/carbon/statusbr.cpp | 162 +++++ src/mac/carbon/tabctrl.cpp | 201 ++++++ src/mac/carbon/taskbar.cpp | 70 ++ src/mac/carbon/textctrl.cpp | 447 ++++++++++++ src/mac/carbon/thread.cpp | 261 +++++++ src/mac/carbon/timer.cpp | 52 ++ src/mac/carbon/toolbar.cpp | 145 ++++ src/mac/carbon/treectrl.cpp | 418 ++++++++++++ src/mac/carbon/utils.cpp | 272 ++++++++ src/mac/carbon/utilsexc.cpp | 28 + src/mac/carbon/wave.cpp | 61 ++ src/mac/carbon/window.cpp | 1292 +++++++++++++++++++++++++++++++++++ src/mac/checkbox.cpp | 117 ++++ src/mac/checklst.cpp | 74 ++ src/mac/choice.cpp | 119 ++++ src/mac/clipbrd.cpp | 237 +++++++ src/mac/colordlg.cpp | 53 ++ src/mac/colour.cpp | 103 +++ src/mac/combobox.cpp | 165 +++++ src/mac/control.cpp | 95 +++ src/mac/cursor.cpp | 187 +++++ src/mac/data.cpp | 151 ++++ src/mac/dc.cpp | 385 +++++++++++ src/mac/dcclient.cpp | 635 +++++++++++++++++ src/mac/dcmemory.cpp | 64 ++ src/mac/dcscreen.cpp | 32 + src/mac/dialog.cpp | 287 ++++++++ src/mac/dirdlg.cpp | 42 ++ src/mac/dnd.cpp | 133 ++++ src/mac/filedlg.cpp | 143 ++++ src/mac/font.cpp | 244 +++++++ src/mac/fontdlg.cpp | 55 ++ src/mac/frame.cpp | 571 ++++++++++++++++ src/mac/gauge.cpp | 95 +++ src/mac/gdiobj.cpp | 22 + src/mac/helpxxxx.cpp | 83 +++ src/mac/icon.cpp | 70 ++ src/mac/imaglist.cpp | 118 ++++ src/mac/joystick.cpp | 279 ++++++++ src/mac/listbox.cpp | 235 +++++++ src/mac/listctrl.cpp | 596 ++++++++++++++++ src/mac/main.cpp | 18 + src/mac/makefile.nt | 955 ++++++++++++++++++++++++++ src/mac/makefile.unx | 200 ++++++ src/mac/mdi.cpp | 265 +++++++ src/mac/menu.cpp | 571 ++++++++++++++++ src/mac/menuitem.cpp | 96 +++ src/mac/metafile.cpp | 239 +++++++ src/mac/minifram.cpp | 22 + src/mac/msgdlg.cpp | 36 + src/mac/notebook.cpp | 377 ++++++++++ src/mac/palette.cpp | 82 +++ src/mac/pen.cpp | 202 ++++++ src/mac/print.cpp | 82 +++ src/mac/printdlg.cpp | 115 ++++ src/mac/radiobox.cpp | 194 ++++++ src/mac/radiobut.cpp | 68 ++ src/mac/region.cpp | 363 ++++++++++ src/mac/scrolbar.cpp | 78 +++ src/mac/settings.cpp | 176 +++++ src/mac/slider.cpp | 190 ++++++ src/mac/spinbutt.cpp | 78 +++ src/mac/statbmp.cpp | 59 ++ src/mac/statbox.cpp | 62 ++ src/mac/stattext.cpp | 60 ++ src/mac/statusbr.cpp | 162 +++++ src/mac/tabctrl.cpp | 201 ++++++ src/mac/taskbar.cpp | 70 ++ src/mac/textctrl.cpp | 447 ++++++++++++ src/mac/thread.cpp | 261 +++++++ src/mac/timer.cpp | 52 ++ src/mac/toolbar.cpp | 145 ++++ src/mac/treectrl.cpp | 418 ++++++++++++ src/mac/utils.cpp | 272 ++++++++ src/mac/utilsexc.cpp | 28 + src/mac/wave.cpp | 61 ++ src/mac/window.cpp | 1292 +++++++++++++++++++++++++++++++++++ 142 files changed, 29162 insertions(+) create mode 100644 src/mac/accel.cpp create mode 100644 src/mac/app.cpp create mode 100644 src/mac/bitmap.cpp create mode 100644 src/mac/bmpbuttn.cpp create mode 100644 src/mac/brush.cpp create mode 100644 src/mac/button.cpp create mode 100644 src/mac/carbon/accel.cpp create mode 100644 src/mac/carbon/app.cpp create mode 100644 src/mac/carbon/bitmap.cpp create mode 100644 src/mac/carbon/bmpbuttn.cpp create mode 100644 src/mac/carbon/brush.cpp create mode 100644 src/mac/carbon/button.cpp create mode 100644 src/mac/carbon/checkbox.cpp create mode 100644 src/mac/carbon/checklst.cpp create mode 100644 src/mac/carbon/choice.cpp create mode 100644 src/mac/carbon/clipbrd.cpp create mode 100644 src/mac/carbon/colordlg.cpp create mode 100644 src/mac/carbon/colour.cpp create mode 100644 src/mac/carbon/combobox.cpp create mode 100644 src/mac/carbon/control.cpp create mode 100644 src/mac/carbon/cursor.cpp create mode 100644 src/mac/carbon/data.cpp create mode 100644 src/mac/carbon/dc.cpp create mode 100644 src/mac/carbon/dcclient.cpp create mode 100644 src/mac/carbon/dcmemory.cpp create mode 100644 src/mac/carbon/dcscreen.cpp create mode 100644 src/mac/carbon/dialog.cpp create mode 100644 src/mac/carbon/dirdlg.cpp create mode 100644 src/mac/carbon/dnd.cpp create mode 100644 src/mac/carbon/filedlg.cpp create mode 100644 src/mac/carbon/font.cpp create mode 100644 src/mac/carbon/fontdlg.cpp create mode 100644 src/mac/carbon/frame.cpp create mode 100644 src/mac/carbon/gauge.cpp create mode 100644 src/mac/carbon/gdiobj.cpp create mode 100644 src/mac/carbon/helpxxxx.cpp create mode 100644 src/mac/carbon/icon.cpp create mode 100644 src/mac/carbon/imaglist.cpp create mode 100644 src/mac/carbon/joystick.cpp create mode 100644 src/mac/carbon/listbox.cpp create mode 100644 src/mac/carbon/listctrl.cpp create mode 100644 src/mac/carbon/main.cpp create mode 100644 src/mac/carbon/makefile.nt create mode 100644 src/mac/carbon/makefile.unx create mode 100644 src/mac/carbon/mdi.cpp create mode 100644 src/mac/carbon/menu.cpp create mode 100644 src/mac/carbon/menuitem.cpp create mode 100644 src/mac/carbon/metafile.cpp create mode 100644 src/mac/carbon/minifram.cpp create mode 100644 src/mac/carbon/msgdlg.cpp create mode 100644 src/mac/carbon/notebook.cpp create mode 100644 src/mac/carbon/palette.cpp create mode 100644 src/mac/carbon/pen.cpp create mode 100644 src/mac/carbon/print.cpp create mode 100644 src/mac/carbon/printdlg.cpp create mode 100644 src/mac/carbon/radiobox.cpp create mode 100644 src/mac/carbon/radiobut.cpp create mode 100644 src/mac/carbon/region.cpp create mode 100644 src/mac/carbon/scrolbar.cpp create mode 100644 src/mac/carbon/settings.cpp create mode 100644 src/mac/carbon/slider.cpp create mode 100644 src/mac/carbon/spinbutt.cpp create mode 100644 src/mac/carbon/statbmp.cpp create mode 100644 src/mac/carbon/statbox.cpp create mode 100644 src/mac/carbon/stattext.cpp create mode 100644 src/mac/carbon/statusbr.cpp create mode 100644 src/mac/carbon/tabctrl.cpp create mode 100644 src/mac/carbon/taskbar.cpp create mode 100644 src/mac/carbon/textctrl.cpp create mode 100644 src/mac/carbon/thread.cpp create mode 100644 src/mac/carbon/timer.cpp create mode 100644 src/mac/carbon/toolbar.cpp create mode 100644 src/mac/carbon/treectrl.cpp create mode 100644 src/mac/carbon/utils.cpp create mode 100644 src/mac/carbon/utilsexc.cpp create mode 100644 src/mac/carbon/wave.cpp create mode 100644 src/mac/carbon/window.cpp create mode 100644 src/mac/checkbox.cpp create mode 100644 src/mac/checklst.cpp create mode 100644 src/mac/choice.cpp create mode 100644 src/mac/clipbrd.cpp create mode 100644 src/mac/colordlg.cpp create mode 100644 src/mac/colour.cpp create mode 100644 src/mac/combobox.cpp create mode 100644 src/mac/control.cpp create mode 100644 src/mac/cursor.cpp create mode 100644 src/mac/data.cpp create mode 100644 src/mac/dc.cpp create mode 100644 src/mac/dcclient.cpp create mode 100644 src/mac/dcmemory.cpp create mode 100644 src/mac/dcscreen.cpp create mode 100644 src/mac/dialog.cpp create mode 100644 src/mac/dirdlg.cpp create mode 100644 src/mac/dnd.cpp create mode 100644 src/mac/filedlg.cpp create mode 100644 src/mac/font.cpp create mode 100644 src/mac/fontdlg.cpp create mode 100644 src/mac/frame.cpp create mode 100644 src/mac/gauge.cpp create mode 100644 src/mac/gdiobj.cpp create mode 100644 src/mac/helpxxxx.cpp create mode 100644 src/mac/icon.cpp create mode 100644 src/mac/imaglist.cpp create mode 100644 src/mac/joystick.cpp create mode 100644 src/mac/listbox.cpp create mode 100644 src/mac/listctrl.cpp create mode 100644 src/mac/main.cpp create mode 100644 src/mac/makefile.nt create mode 100644 src/mac/makefile.unx create mode 100644 src/mac/mdi.cpp create mode 100644 src/mac/menu.cpp create mode 100644 src/mac/menuitem.cpp create mode 100644 src/mac/metafile.cpp create mode 100644 src/mac/minifram.cpp create mode 100644 src/mac/msgdlg.cpp create mode 100644 src/mac/notebook.cpp create mode 100644 src/mac/palette.cpp create mode 100644 src/mac/pen.cpp create mode 100644 src/mac/print.cpp create mode 100644 src/mac/printdlg.cpp create mode 100644 src/mac/radiobox.cpp create mode 100644 src/mac/radiobut.cpp create mode 100644 src/mac/region.cpp create mode 100644 src/mac/scrolbar.cpp create mode 100644 src/mac/settings.cpp create mode 100644 src/mac/slider.cpp create mode 100644 src/mac/spinbutt.cpp create mode 100644 src/mac/statbmp.cpp create mode 100644 src/mac/statbox.cpp create mode 100644 src/mac/stattext.cpp create mode 100644 src/mac/statusbr.cpp create mode 100644 src/mac/tabctrl.cpp create mode 100644 src/mac/taskbar.cpp create mode 100644 src/mac/textctrl.cpp create mode 100644 src/mac/thread.cpp create mode 100644 src/mac/timer.cpp create mode 100644 src/mac/toolbar.cpp create mode 100644 src/mac/treectrl.cpp create mode 100644 src/mac/utils.cpp create mode 100644 src/mac/utilsexc.cpp create mode 100644 src/mac/wave.cpp create mode 100644 src/mac/window.cpp diff --git a/src/mac/accel.cpp b/src/mac/accel.cpp new file mode 100644 index 0000000000..b0b8734d55 --- /dev/null +++ b/src/mac/accel.cpp @@ -0,0 +1,93 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/string.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/mac/app.cpp b/src/mac/app.cpp new file mode 100644 index 0000000000..b04a01bbe2 --- /dev/null +++ b/src/mac/app.cpp @@ -0,0 +1,391 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/memory.h" + +#if wxUSE_WX_RESOURCES +#include "wx/resource.h" +#endif + +#include + +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; + +bool wxApp::Initialize() +{ +#ifdef __WXMSW__ + wxBuffer = new char[1500]; +#else + wxBuffer = new char[BUFSIZ + 512]; +#endif + +/* No longer used +#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT + + streambuf* sBuf = new wxDebugStreamBuf; + ostream* oStr = new ostream(sBuf) ; + wxDebugContext::SetStream(oStr, sBuf); +#endif +*/ + + wxClassInfo::InitializeClasses(); + + wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING); + wxTheColourDatabase->Initialize(); + + wxInitializeStockLists(); + wxInitializeStockObjects(); + +#if wxUSE_WX_RESOURCES + wxInitializeResourceSystem(); +#endif + + wxBitmap::InitStandardHandlers(); + + wxModule::RegisterModules(); + wxASSERT( wxModule::InitializeModules() == TRUE ); + + return TRUE; +} + +void wxApp::CleanUp() +{ + wxModule::CleanUpModules(); + +#if wxUSE_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; + + wxBitmap::CleanUpHandlers(); + + delete[] wxBuffer; + wxBuffer = NULL; + + wxClassInfo::CleanUpClasses(); + + delete wxTheApp; + wxTheApp = NULL; + +#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_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 + + // do it as the very last thing because everything else can log messages + wxLog::DontCreateOnDemand(); + // do it as the very last thing because everything else can log messages + delete wxLog::SetActiveTarget(NULL); +} + +int wxEntry( int argc, char *argv[] ) +{ + if (!wxApp::Initialize()) + return FALSE; + if (!wxTheApp) + { + if (!wxApp::GetInitializerFunction()) + { + printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" ); + return 0; + }; + + wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) (); + }; + + if (!wxTheApp) + { + printf( "wxWindows error: wxTheApp == NULL\n" ); + return 0; + }; + + wxTheApp->argc = argc; + wxTheApp->argv = argv; + + // 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; + + int retValue = 0; + + if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun(); + + if (wxTheApp->GetTopWindow()) + { + delete wxTheApp->GetTopWindow(); + wxTheApp->SetTopWindow(NULL); + } + + wxTheApp->DeletePendingObjects(); + + wxTheApp->OnExit(); + + wxApp::CleanUp(); + + 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::CleanUp(); +/* + * 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/mac/bitmap.cpp b/src/mac/bitmap.cpp new file mode 100644 index 0000000000..1e6255f551 --- /dev/null +++ b/src/mac/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/mac/bmpbuttn.cpp b/src/mac/bmpbuttn.cpp new file mode 100644 index 0000000000..169f0d557a --- /dev/null +++ b/src/mac/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->GetBackgroundColour() ; + m_foregroundColour = parent->GetForegroundColour() ; + 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/mac/brush.cpp b/src/mac/brush.cpp new file mode 100644 index 0000000000..4f28e92f53 --- /dev/null +++ b/src/mac/brush.cpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 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(unsigned char r, unsigned char g, 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(); +} + +bool wxBrush::RealizeResource() +{ +// TODO: create the brush + return FALSE; +} + diff --git a/src/mac/button.cpp b/src/mac/button.cpp new file mode 100644 index 0000000000..befd0d7156 --- /dev/null +++ b/src/mac/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/mac/carbon/accel.cpp b/src/mac/carbon/accel.cpp new file mode 100644 index 0000000000..b0b8734d55 --- /dev/null +++ b/src/mac/carbon/accel.cpp @@ -0,0 +1,93 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/string.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/mac/carbon/app.cpp b/src/mac/carbon/app.cpp new file mode 100644 index 0000000000..b04a01bbe2 --- /dev/null +++ b/src/mac/carbon/app.cpp @@ -0,0 +1,391 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/memory.h" + +#if wxUSE_WX_RESOURCES +#include "wx/resource.h" +#endif + +#include + +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; + +bool wxApp::Initialize() +{ +#ifdef __WXMSW__ + wxBuffer = new char[1500]; +#else + wxBuffer = new char[BUFSIZ + 512]; +#endif + +/* No longer used +#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT + + streambuf* sBuf = new wxDebugStreamBuf; + ostream* oStr = new ostream(sBuf) ; + wxDebugContext::SetStream(oStr, sBuf); +#endif +*/ + + wxClassInfo::InitializeClasses(); + + wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING); + wxTheColourDatabase->Initialize(); + + wxInitializeStockLists(); + wxInitializeStockObjects(); + +#if wxUSE_WX_RESOURCES + wxInitializeResourceSystem(); +#endif + + wxBitmap::InitStandardHandlers(); + + wxModule::RegisterModules(); + wxASSERT( wxModule::InitializeModules() == TRUE ); + + return TRUE; +} + +void wxApp::CleanUp() +{ + wxModule::CleanUpModules(); + +#if wxUSE_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; + + wxBitmap::CleanUpHandlers(); + + delete[] wxBuffer; + wxBuffer = NULL; + + wxClassInfo::CleanUpClasses(); + + delete wxTheApp; + wxTheApp = NULL; + +#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_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 + + // do it as the very last thing because everything else can log messages + wxLog::DontCreateOnDemand(); + // do it as the very last thing because everything else can log messages + delete wxLog::SetActiveTarget(NULL); +} + +int wxEntry( int argc, char *argv[] ) +{ + if (!wxApp::Initialize()) + return FALSE; + if (!wxTheApp) + { + if (!wxApp::GetInitializerFunction()) + { + printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" ); + return 0; + }; + + wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) (); + }; + + if (!wxTheApp) + { + printf( "wxWindows error: wxTheApp == NULL\n" ); + return 0; + }; + + wxTheApp->argc = argc; + wxTheApp->argv = argv; + + // 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; + + int retValue = 0; + + if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun(); + + if (wxTheApp->GetTopWindow()) + { + delete wxTheApp->GetTopWindow(); + wxTheApp->SetTopWindow(NULL); + } + + wxTheApp->DeletePendingObjects(); + + wxTheApp->OnExit(); + + wxApp::CleanUp(); + + 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::CleanUp(); +/* + * 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/mac/carbon/bitmap.cpp b/src/mac/carbon/bitmap.cpp new file mode 100644 index 0000000000..1e6255f551 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/bmpbuttn.cpp b/src/mac/carbon/bmpbuttn.cpp new file mode 100644 index 0000000000..169f0d557a --- /dev/null +++ b/src/mac/carbon/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->GetBackgroundColour() ; + m_foregroundColour = parent->GetForegroundColour() ; + 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/mac/carbon/brush.cpp b/src/mac/carbon/brush.cpp new file mode 100644 index 0000000000..4f28e92f53 --- /dev/null +++ b/src/mac/carbon/brush.cpp @@ -0,0 +1,140 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 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(unsigned char r, unsigned char g, 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(); +} + +bool wxBrush::RealizeResource() +{ +// TODO: create the brush + return FALSE; +} + diff --git a/src/mac/carbon/button.cpp b/src/mac/carbon/button.cpp new file mode 100644 index 0000000000..befd0d7156 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/checkbox.cpp b/src/mac/carbon/checkbox.cpp new file mode 100644 index 0000000000..dd2e2abe7a --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/checklst.cpp b/src/mac/carbon/checklst.cpp new file mode 100644 index 0000000000..2f43152c2a --- /dev/null +++ b/src/mac/carbon/checklst.cpp @@ -0,0 +1,74 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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) +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(size_t uiIndex) const +{ + // TODO + return FALSE; +} + +void wxCheckListBox::Check(size_t uiIndex, bool bCheck) +{ + // TODO +} + + diff --git a/src/mac/carbon/choice.cpp b/src/mac/carbon/choice.cpp new file mode 100644 index 0000000000..a584d5303f --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/clipbrd.cpp b/src/mac/carbon/clipbrd.cpp new file mode 100644 index 0000000000..3fe9ebfb72 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/colordlg.cpp b/src/mac/carbon/colordlg.cpp new file mode 100644 index 0000000000..2275a9a39d --- /dev/null +++ b/src/mac/carbon/colordlg.cpp @@ -0,0 +1,53 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colordlg.cpp +// Purpose: wxColourDialog class. NOTE: you can use the generic class +// if you wish, instead of implementing this. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "colordlg.h" +#endif + +#include "wx/stubs/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/mac/carbon/colour.cpp b/src/mac/carbon/colour.cpp new file mode 100644 index 0000000000..8d0827ef1d --- /dev/null +++ b/src/mac/carbon/colour.cpp @@ -0,0 +1,103 @@ +///////////////////////////////////////////////////////////////////////////// +// 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; +} + +void wxColour::InitFromName(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 () +{ +} + +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/mac/carbon/combobox.cpp b/src/mac/carbon/combobox.cpp new file mode 100644 index 0000000000..0be841bad4 --- /dev/null +++ b/src/mac/carbon/combobox.cpp @@ -0,0 +1,165 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 +} + +void wxComboBox::Append(const wxString& item) +{ + // TODO +} + +void wxComboBox::Delete(int n) +{ + // TODO +} + +void wxComboBox::Clear() +{ + // TODO +} + +int wxComboBox::GetSelection() const +{ + // TODO + return -1; +} + +void wxComboBox::SetSelection(int n) +{ + // TODO +} + +int wxComboBox::FindString(const wxString& s) const +{ + // TODO + return -1; +} + +wxString wxComboBox::GetString(int n) const +{ + // TODO + return wxString(""); +} + +wxString wxComboBox::GetStringSelection() const +{ + // TODO + return wxString(""); +} + +bool wxComboBox::SetStringSelection(const wxString& sel) +{ + // TODO + return FALSE; +} diff --git a/src/mac/carbon/control.cpp b/src/mac/carbon/control.cpp new file mode 100644 index 0000000000..b141a80ff1 --- /dev/null +++ b/src/mac/carbon/control.cpp @@ -0,0 +1,95 @@ +///////////////////////////////////////////////////////////////////////////// +// 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() == (wxButton*) this) + parent->SetDefaultItem(NULL); + } +} + +void wxControl::SetLabel(const wxString& label) +{ + // TODO +} + +wxString wxControl::GetLabel() const +{ + // TODO + return wxString(""); +} + +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::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/mac/carbon/cursor.cpp b/src/mac/carbon/cursor.cpp new file mode 100644 index 0000000000..4333364c93 --- /dev/null +++ b/src/mac/carbon/cursor.cpp @@ -0,0 +1,187 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/icon.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 wxCursorRefData; + + // TODO: create cursor from a file +} + +// Cursors by stock number +wxCursor::wxCursor(int cursor_type) +{ + m_refData = new wxCursorRefData; + +/* 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/mac/carbon/data.cpp b/src/mac/carbon/data.cpp new file mode 100644 index 0000000000..5e6c418519 --- /dev/null +++ b/src/mac/carbon/data.cpp @@ -0,0 +1,151 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +#if wxUSE_POSTSCRIPT +#include "wx/postscrp.h" +#endif + +#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 wxUSE_POSTSCRIPT +wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL; +#endif + +#if wxUSE_SHARED_LIBRARY +///// 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 } }; +#endif + +const wxSize wxDefaultSize(-1, -1); +const wxPoint wxDefaultPosition(-1, -1); diff --git a/src/mac/carbon/dc.cpp b/src/mac/carbon/dc.cpp new file mode 100644 index 0000000000..642dc1edc5 --- /dev/null +++ b/src/mac/carbon/dc.cpp @@ -0,0 +1,385 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 +//----------------------------------------------------------------------------- + +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( 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/mac/carbon/dcclient.cpp b/src/mac/carbon/dcclient.cpp new file mode 100644 index 0000000000..925d9609ee --- /dev/null +++ b/src/mac/carbon/dcclient.cpp @@ -0,0 +1,635 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 "wx/region.h" +#include + +//----------------------------------------------------------------------------- +// constants +//----------------------------------------------------------------------------- + +#define RAD2DEG 57.2957795131 + +//----------------------------------------------------------------------------- +// wxPaintDC +//----------------------------------------------------------------------------- + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC) +IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC) +IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC) +#endif + +/* + * wxWindowDC + */ + +wxWindowDC::wxWindowDC(void) +{ +}; + +wxWindowDC::wxWindowDC( wxWindow *window ) +{ +}; + +wxWindowDC::~wxWindowDC(void) +{ +}; + +void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), + const wxColour& WXUNUSED(col), int WXUNUSED(style) ) +{ +}; + +bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const +{ + return FALSE; +}; + +void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 ) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::CrossHair( long x, long y ) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long 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 wxWindowDC::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 wxWindowDC::DrawPoint( long x, long y ) +{ + if (!Ok()) return; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[], + long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxWindowDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset), + long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::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 wxWindowDC::CanDrawBitmap(void) const +{ + return TRUE; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::DrawText( const wxString &text, long x, long y, bool +WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + + + +bool wxWindowDC::CanGetTextExtent(void) const +{ + return TRUE; +}; + +void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height, + long *WXUNUSED(descent), long *WXUNUSED(externalLeading), + wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + +long wxWindowDC::GetCharWidth(void) +{ + if (!Ok()) return 0; + return 0; +}; + +long wxWindowDC::GetCharHeight(void) +{ + if (!Ok()) return 0; + return 0; +}; + +void wxWindowDC::Clear(void) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::SetFont( const wxFont &font ) +{ + if (!Ok()) return; + + m_font = font; +}; + +void wxWindowDC::SetPen( const wxPen &pen ) +{ + if (!Ok()) return; + + if (m_pen == pen) return; + + m_pen = pen; + + if (!m_pen.Ok()) return; +}; + +void wxWindowDC::SetBrush( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_brush == brush) return; + + m_brush = brush; + + if (!m_brush.Ok()) return; + +}; + +void wxWindowDC::SetBackground( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_backgroundBrush == brush) return; + + m_backgroundBrush = brush; + + if (!m_backgroundBrush.Ok()) return; + +}; + +void wxWindowDC::SetLogicalFunction( int function ) +{ + if (m_logicalFunction == function) return; +}; + +void wxWindowDC::SetTextForeground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textForegroundColour == col) return; + + m_textForegroundColour = col; + if (!m_textForegroundColour.Ok()) return; +}; + +void wxWindowDC::SetTextBackground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textBackgroundColour == col) return; + + m_textBackgroundColour = col; + if (!m_textBackgroundColour.Ok()) return; +}; + +void wxWindowDC::SetBackgroundMode( int mode ) +{ + m_backgroundMode = mode; + + if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT) + { + } +}; + +void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) ) +{ +}; + +void wxWindowDC::SetClippingRegion( long x, long y, long width, long height ) +{ + wxDC::SetClippingRegion( x, y, width, height ); + + // TODO + +}; + +void wxWindowDC::SetClippingRegion( const wxRegion& region ) +{ + wxRect box = region.GetBox(); + + wxDC::SetClippingRegion( box.x, box.y, box.width, box.height ); + + // TODO +} + +void wxWindowDC::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 wxWindowDC::DrawSpline( 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/mac/carbon/dcmemory.cpp b/src/mac/carbon/dcmemory.cpp new file mode 100644 index 0000000000..7cbd330821 --- /dev/null +++ b/src/mac/carbon/dcmemory.cpp @@ -0,0 +1,64 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +//----------------------------------------------------------------------------- +// 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/mac/carbon/dcscreen.cpp b/src/mac/carbon/dcscreen.cpp new file mode 100644 index 0000000000..e03bbac0c8 --- /dev/null +++ b/src/mac/carbon/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, wxWindowDC) +#endif + +// Create a DC representing the whole screen +wxScreenDC::wxScreenDC() +{ + // TODO +} + +wxScreenDC::~wxScreenDC() +{ + // TODO +} + diff --git a/src/mac/carbon/dialog.cpp b/src/mac/carbon/dialog.cpp new file mode 100644 index 0000000000..7d6d99744d --- /dev/null +++ b/src/mac/carbon/dialog.cpp @@ -0,0 +1,287 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 (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; + wxWindow *parent = GetParent(); + if ((direction & wxCENTER_FRAME) && parent) + { + parent->GetPosition(&x_offset,&y_offset) ; + parent->GetSize(&display_width,&display_height) ; + } + else + { + 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(); +} + +void wxDialog::Fit() +{ +} diff --git a/src/mac/carbon/dirdlg.cpp b/src/mac/carbon/dirdlg.cpp new file mode 100644 index 0000000000..095621b978 --- /dev/null +++ b/src/mac/carbon/dirdlg.cpp @@ -0,0 +1,42 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +#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/mac/carbon/dnd.cpp b/src/mac/carbon/dnd.cpp new file mode 100644 index 0000000000..32088eef0f --- /dev/null +++ b/src/mac/carbon/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) +{ +}; + +wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) ) +{ + // TODO + return wxDragError; +}; + diff --git a/src/mac/carbon/filedlg.cpp b/src/mac/carbon/filedlg.cpp new file mode 100644 index 0000000000..2aeffdf926 --- /dev/null +++ b/src/mac/carbon/filedlg.cpp @@ -0,0 +1,143 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/intl.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 + return 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/mac/carbon/font.cpp b/src/mac/carbon/font.cpp new file mode 100644 index 0000000000..493a6a25ba --- /dev/null +++ b/src/mac/carbon/font.cpp @@ -0,0 +1,244 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/defs.h" +#include "wx/string.h" +#include "wx/font.h" +#include "wx/gdicmn.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/mac/carbon/fontdlg.cpp b/src/mac/carbon/fontdlg.cpp new file mode 100644 index 0000000000..60e8e9b987 --- /dev/null +++ b/src/mac/carbon/fontdlg.cpp @@ -0,0 +1,55 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: fontdlg.cpp +// Purpose: wxFontDialog class. NOTE: you can use the generic class +// if you wish, instead of implementing this. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "fontdlg.h" +#endif + +#include "wx/stubs/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/mac/carbon/frame.cpp b/src/mac/carbon/frame.cpp new file mode 100644 index 0000000000..1e8c9e9ae5 --- /dev/null +++ b/src/mac/carbon/frame.cpp @@ -0,0 +1,571 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/menu.h" +#include "wx/dcclient.h" +#include "wx/dialog.h" +#include "wx/settings.h" +#include "wx/app.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 wxUSE_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; +} + +// Is the frame maximized? +bool wxFrame::IsMaximized(void) 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 +} + +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 wxUSE_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))) + { + 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; +} + +void wxFrame::ScreenToClient(int *x, int *y) const +{ + wxWindow::ScreenToClient(x, y); + + // We may be faking the client origin. + // So a window that's really at (0, 30) may appear + // (to wxWin apps) to be at (0, 0). + wxPoint pt(GetClientAreaOrigin()); + *x -= pt.x; + *y -= pt.y; +} + +void wxFrame::ClientToScreen(int *x, int *y) const +{ + // We may be faking the client origin. + // So a window that's really at (0, 30) may appear + // (to wxWin apps) to be at (0, 0). + wxPoint pt1(GetClientAreaOrigin()); + *x += pt1.x; + *y += pt1.y; + + wxWindow::ClientToScreen(x, y); +} + +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. + + 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/mac/carbon/gauge.cpp b/src/mac/carbon/gauge.cpp new file mode 100644 index 0000000000..a85fbc498f --- /dev/null +++ b/src/mac/carbon/gauge.cpp @@ -0,0 +1,95 @@ +///////////////////////////////////////////////////////////////////////////// +// 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; +} + diff --git a/src/mac/carbon/gdiobj.cpp b/src/mac/carbon/gdiobj.cpp new file mode 100644 index 0000000000..63697c8354 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/helpxxxx.cpp b/src/mac/carbon/helpxxxx.cpp new file mode 100644 index 0000000000..086762c646 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/icon.cpp b/src/mac/carbon/icon.cpp new file mode 100644 index 0000000000..6deee7dbdc --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/imaglist.cpp b/src/mac/carbon/imaglist.cpp new file mode 100644 index 0000000000..4cb47b4e69 --- /dev/null +++ b/src/mac/carbon/imaglist.cpp @@ -0,0 +1,118 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: imaglist.cpp +// Purpose: wxImageList. You may wish to use the generic version. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "imaglist.h" +#endif + +#include "wx/stubs/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/mac/carbon/joystick.cpp b/src/mac/carbon/joystick.cpp new file mode 100644 index 0000000000..6677277f48 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/listbox.cpp b/src/mac/carbon/listbox.cpp new file mode 100644 index 0000000000..1dad21e12c --- /dev/null +++ b/src/mac/carbon/listbox.cpp @@ -0,0 +1,235 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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/settings.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::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/mac/carbon/listctrl.cpp b/src/mac/carbon/listctrl.cpp new file mode 100644 index 0000000000..d1d8445652 --- /dev/null +++ b/src/mac/carbon/listctrl.cpp @@ -0,0 +1,596 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/stubs/textctrl.h" +#include "wx/stubs/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, wxRect& 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 ) + { + m_imageListNormal = imageList; + } + else if ( which == wxIMAGE_LIST_SMALL ) + { + m_imageListSmall = imageList; + } + else if ( which == wxIMAGE_LIST_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/mac/carbon/main.cpp b/src/mac/carbon/main.cpp new file mode 100644 index 0000000000..47a9924bae --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/makefile.nt b/src/mac/carbon/makefile.nt new file mode 100644 index 0000000000..2865fbcec3 --- /dev/null +++ b/src/mac/carbon/makefile.nt @@ -0,0 +1,955 @@ +# +# File: makefile.nt +# Author: Julian Smart +# Created: 1997 +# Updated: +# Copyright: (c) 1997, Julian Smart +# +# "%W% %G%" +# +# Makefile : Builds wxWindows stubs library wxstubs.lib for VC++ (32-bit) +# Arguments: +# +# FINAL=1 argument to nmake to build version with no debugging info. +# + +!include + +APPVER=3.50 # 4.0 +# This means 'enable Windows 95 features' (in wxWindows and in VC++ 4.0). +WINVERSION=-DWINVER=0x0400 + +# On Alpha machines, change to CPU=ALPHA +CPU=i386 + +# Suffixes +OBJSUFF=obj +SRCSUFF=cpp + +WINFLAGS=-c -W3 -Dtry=__try -Dexcept=__except -Dleave=__leave -Dfinally=__finally -DCRTAPI1=_cdecl -DCRTAPI2=_cdecl -nologo -D_X86_=1 $(WINVERSION) -D__WIN32__ -D__WINDOWS__ +WINLINKFLAGS=/INCREMENTAL:NO /NOLOGO -align:0x1000 -machine:$(CPU) -subsystem:windows,$(APPVER) +WINLIBS=kernel32.lib user32.lib gdi32.lib comdlg32.lib winspool.lib winmm.lib shell32.lib oldnames.lib\ + comctl32.lib ctl3d32.lib odbc32.lib ole32.lib oleaut32.lib uuid.lib rpcrt4.lib advapi32.lib # libci.lib # libci.lib required for VC++ 4.2 + +# Change this to your WXWIN directory +WXDIR=$(WXWIN) + +WXSRC=$(WXDIR)\src\stubs +WXINC=$(WXDIR)\include +WXBASESRC=$(WXDIR)\src\common + +WXLIB=$(WXDIR)\lib\wxstubs.lib + +EXTRADLLFLAGS= + +INC=-I$(WXINC) -I$(WXDIR)/src/png -I$(WXDIR)/src/zlib $(EXTRAINC) +LIBS = $(EXTRALIBS) $(WXLIB) $(WINLIBS) + +!ifndef FINAL +FINAL=0 +DEBUG=1 +!endif + +# Set this to 1 if you don't want to use precompiled headers +NOPCH=1 + +OPTIONS= + +!if "$(FINAL)" == "0" +OPT = /Od /Gy +# ***N.B.*** to save space/time, comment out /FR to avoid browse info (.sbr files) being generated +DEBUG_FLAGS= /Zi # /FR +LINK_DEBUG_FLAGS=-debug:full -debugtype:cv # /PDB:NONE +CRTFLAG=/MD +!else +# /O1 - smallest code +# /O2 - fastest code +OPT = /O1 # /O2 # /Od +DEBUG_FLAGS= +LINK_DEBUG_FLAGS=/RELEASE +CRTFLAG=/MD +!endif + +PCH= +PRECOMP= +MAKEPRECOMP= + +CPPFLAGS=$(WINFLAGS) $(DEBUG_FLAGS) $(PRECOMP) $(EXTRAFLAGS) /D__WXSTUBS__ /DDEBUG=1 $(INC) $(OPT) $(CRTFLAG) /GX /D__WXDEBUG__ /DWXDEBUG=1 +# If you don't include wxprec.h, use CPPFLAGS2 +CPPFLAGS2=$(WINFLAGS) $(DEBUG_FLAGS) /D__WXSTUBS__ /DDEBUG=1 $(INC) $(EXTRAFLAGS) $(OPT) $(CRTFLAG) /GX /D__WXDEBUG__ /DWXDEBUG=1 +LINKFLAGS=$(LINK_DEBUG_FLAGS) $(WINLINKFLAGS) -entry:WinMainCRTStartup + +THISDIR=$(WXWIN)\src\stubs + +LIBTARGET=$(WXLIB) + +# Please set these according to the settings in wx_setup.h, so we can include +# the appropriate libraries in wx.lib + +PERIPH_LIBS= +PERIPH_TARGET= +PERIPH_CLEAN_TARGET= + +GENDIR=..\generic +COMMDIR=..\common +STUBSDIR=. + +DOCDIR = $(WXDIR)\docs + +GENERICOBJS= \ + $(GENDIR)\choicdgg.obj \ + $(GENDIR)\colrdlgg.obj \ + $(GENDIR)\fontdlgg.obj \ + $(GENDIR)\gridg.obj \ + $(GENDIR)\msgdlgg.obj \ + $(GENDIR)\panelg.obj \ + $(GENDIR)\printps.obj \ + $(GENDIR)\prntdlgg.obj \ + $(GENDIR)\scrolwin.obj \ + $(GENDIR)\splitter.obj \ + $(GENDIR)\statusbr.obj \ + $(GENDIR)\tabg.obj \ + $(GENDIR)\textdlgg.obj + +# $(GENDIR)\helpxlp.obj \ + +COMMONOBJS = \ + $(COMMDIR)\cmndata.obj \ + $(COMMDIR)\config.obj \ + $(COMMDIR)\docview.obj \ + $(COMMDIR)\docmdi.obj \ + $(COMMDIR)\dynarray.obj \ + $(COMMDIR)\event.obj \ + $(COMMDIR)\file.obj \ + $(COMMDIR)\filefn.obj \ + $(COMMDIR)\fileconf.obj \ + $(COMMDIR)\framecmn.obj \ + $(COMMDIR)\gdicmn.obj \ + $(COMMDIR)\intl.obj \ + $(COMMDIR)\ipcbase.obj \ + $(COMMDIR)\helpbase.obj \ + $(COMMDIR)\layout.obj \ + $(COMMDIR)\log.obj \ + $(COMMDIR)\memory.obj \ + $(COMMDIR)\module.obj \ + $(COMMDIR)\object.obj \ + $(COMMDIR)\postscrp.obj \ + $(COMMDIR)\prntbase.obj \ + $(COMMDIR)\resource.obj \ + $(COMMDIR)\tbarbase.obj \ + $(COMMDIR)\tbarsmpl.obj \ + $(COMMDIR)\textfile.obj \ + $(COMMDIR)\timercmn.obj \ + $(COMMDIR)\utilscmn.obj \ + $(COMMDIR)\validate.obj \ + $(COMMDIR)\valtext.obj \ + $(COMMDIR)\date.obj \ + $(COMMDIR)\hash.obj \ + $(COMMDIR)\list.obj \ + $(COMMDIR)\string.obj \ + $(COMMDIR)\time.obj \ + $(COMMDIR)\wxexpr.obj \ + $(COMMDIR)\y_tab.obj \ + $(COMMDIR)\extended.obj \ + $(COMMDIR)\process.obj \ + $(COMMDIR)\fstream.obj \ + $(COMMDIR)\mstream.obj \ + $(COMMDIR)\zstream.obj \ + $(COMMDIR)\stream.obj \ + $(COMMDIR)\datstrm.obj \ + $(COMMDIR)\wincmn.obj + +# $(COMMDIR)\odbc.obj \ + +STUBSOBJS = \ + $(STUBSDIR)\accel.obj \ + $(STUBSDIR)\app.obj \ + $(STUBSDIR)\bitmap.obj \ + $(STUBSDIR)\bmpbuttn.obj \ + $(STUBSDIR)\brush.obj \ + $(STUBSDIR)\button.obj \ + $(STUBSDIR)\checkbox.obj \ + $(STUBSDIR)\checklst.obj \ + $(STUBSDIR)\choice.obj \ + $(STUBSDIR)\clipbrd.obj \ + $(STUBSDIR)\colordlg.obj \ + $(STUBSDIR)\colour.obj \ + $(STUBSDIR)\combobox.obj \ + $(STUBSDIR)\control.obj \ + $(STUBSDIR)\cursor.obj \ + $(STUBSDIR)\data.obj \ + $(STUBSDIR)\dc.obj \ + $(STUBSDIR)\dcmemory.obj \ + $(STUBSDIR)\dcclient.obj \ + $(STUBSDIR)\dcscreen.obj \ + $(STUBSDIR)\dialog.obj \ + $(STUBSDIR)\dirdlg.obj \ + $(STUBSDIR)\filedlg.obj \ + $(STUBSDIR)\font.obj \ + $(STUBSDIR)\fontdlg.obj \ + $(STUBSDIR)\frame.obj \ + $(STUBSDIR)\gauge.obj \ + $(STUBSDIR)\gdiobj.obj \ + $(STUBSDIR)\helpxxxx.obj \ + $(STUBSDIR)\icon.obj \ + $(STUBSDIR)\imaglist.obj \ + $(STUBSDIR)\joystick.obj \ + $(STUBSDIR)\listbox.obj \ + $(STUBSDIR)\listctrl.obj \ + $(STUBSDIR)\main.obj \ + $(STUBSDIR)\mdi.obj \ + $(STUBSDIR)\menu.obj \ + $(STUBSDIR)\menuitem.obj \ + $(STUBSDIR)\metafile.obj \ + $(STUBSDIR)\minifram.obj \ + $(STUBSDIR)\msgdlg.obj \ + $(STUBSDIR)\notebook.obj \ + $(STUBSDIR)\palette.obj \ + $(STUBSDIR)\pen.obj \ + $(STUBSDIR)\printdlg.obj \ + $(STUBSDIR)\print.obj \ + $(STUBSDIR)\radiobox.obj \ + $(STUBSDIR)\radiobut.obj \ + $(STUBSDIR)\region.obj \ + $(STUBSDIR)\scrolbar.obj \ + $(STUBSDIR)\settings.obj \ + $(STUBSDIR)\slider.obj \ + $(STUBSDIR)\spinbutt.obj \ + $(STUBSDIR)\statbmp.obj \ + $(STUBSDIR)\statbox.obj \ + $(STUBSDIR)\statusbr.obj \ + $(STUBSDIR)\stattext.obj \ + $(STUBSDIR)\tabctrl.obj \ + $(STUBSDIR)\taskbar.obj \ + $(STUBSDIR)\toolbar.obj \ + $(STUBSDIR)\textctrl.obj \ + $(STUBSDIR)\thread.obj \ + $(STUBSDIR)\timer.obj \ + $(STUBSDIR)\treectrl.obj \ + $(STUBSDIR)\utils.obj \ + $(STUBSDIR)\utilsexc.obj \ + $(STUBSDIR)\wave.obj \ + $(STUBSDIR)\window.obj + + +OBJECTS = $(COMMONOBJS) $(GENERICOBJS) $(STUBSOBJS) + +# Normal, static library +all: $(OBJECTS) $(PERIPH_TARGET) $(LIBTARGET) + +$(WXDIR)\lib\wxstubs.lib: $(OBJECTS) $(PERIPH_LIBS) + -erase $(LIBTARGET) + $(implib) @<< +-out:$@ +-machine:$(CPU) +$(OBJECTS) $(PERIPH_LIBS) +<< + +######################################################## +# Windows-specific objects + +$(STUBSDIR)/accel.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/app.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/bitmap.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/bmpbuttn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/brush.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/button.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/choice.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/checkbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/checklst.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/clipbrd.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/colordlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/colour.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/combobox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/control.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/cursor.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/data.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcmemory.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcclient.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcprint.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcscreen.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dialog.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dirdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/filedlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/font.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/fontdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/frame.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/gauge.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/gdiobj.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/icon.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/imaglist.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/joystick.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/listbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF) +<< + +$(STUBSDIR)/listctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF) +<< + +$(STUBSDIR)/main.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/mdi.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/menu.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/menuitem.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/metafile.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/minifram.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/msgdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/notebook.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/palette.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/pen.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/printdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/print.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/radiobox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/radiobut.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/region.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/scrolbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/settings.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/slider.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/spinbutt.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statbmp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statusbr.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/stattext.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/tabctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/taskbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/toolbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/textctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/thread.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/timer.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/treectrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/utils.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/utilsexc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/wave.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/window.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +######################################################## +# Common objects (always compiled) + +$(COMMDIR)/cmndata.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/config.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/db.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/dbtable.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/docview.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/docmdi.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/dynarray.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/event.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/file.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/fileconf.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/filefn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/framecmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/gdicmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/intl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/ipcbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/helpbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/layout.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/log.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/memory.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/module.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/object.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/odbc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/postscrp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/prntbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/resource.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/tbarbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/tbarsmpl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/textfile.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/timercmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/utilscmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/validate.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/valtext.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/date.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/wxexpr.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/hash.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/list.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/string.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/matrix.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +#$(COMMDIR)/wxstrgnu/wxstrgnu.obj: $*.$(SRCSUFF) +# cl @<< +#$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +#<< + +#$(COMMDIR)/wxstrgnu/wxregex.obj: $*.$(SRCSUFF) +# cl @<< +#$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +#<< + +$(COMMDIR)/time.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\stream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\fstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\mstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\zstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\datstrm.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/extended.obj: $*.c + cl @<< +$(CPPFLAGS2) /c /Tp $*.c /Fo$@ +<< + +$(COMMDIR)/process.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/wincmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/y_tab.obj: $*.c $(COMMDIR)/lex_yy.c + cl @<< +$(CPPFLAGS2) /c $*.c -DUSE_DEFINE -DYY_USE_PROTOS /Fo$@ +<< + +$(COMMDIR)/y_tab.c: $(COMMDIR)/dosyacc.c + copy $(COMMDIR)\dosyacc.c $(COMMDIR)\y_tab.c + +$(COMMDIR)/lex_yy.c: $(COMMDIR)/doslex.c + copy $(COMMDIR)\doslex.c $(COMMDIR)\lex_yy.c + +######################################################## +# Generic objects (not always compiled, depending on +# whether platforms have native implementations) + +$(GENDIR)/choicdgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/colrdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/fontdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/gridg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/helpxlp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/msgdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/panelg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/printps.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/prntdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/scrolwin.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/splitter.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/statusbr.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/tabg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/textdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(OBJECTS): $(WXDIR)/include/wx/stubs/setup.h + +clean: $(PERIPH_CLEAN_TARGET) + -erase *.obj + -erase $(LIBTARGET) + -erase $(WXDIR)\lib\*.pdb + -erase *.pdb + -erase *.sbr + -erase *.pch + cd $(WXDIR)\src\stubs + cd $(GENDIR) + -erase *.pdb + -erase *.sbr + -erase *.obj + cd $(WXDIR)\src\stubs + cd $(COMMDIR) + -erase *.pdb + -erase *.sbr + -erase *.obj + -erase y_tab.c + -erase lex_yy.c + cd $(WXDIR)\src\stubs + +cleanall: clean + diff --git a/src/mac/carbon/makefile.unx b/src/mac/carbon/makefile.unx new file mode 100644 index 0000000000..5bd62163fd --- /dev/null +++ b/src/mac/carbon/makefile.unx @@ -0,0 +1,200 @@ +# +# File: makefile.unx +# Author: Julian Smart +# Created: 1998 +# Updated: +# Copyright: (c) 1998 +# +# +# Makefile for wxStubs library, Unix + +EXTRACFLAGS=-DLEX_SCANNER + +include ../make.env + +LIB_CPP_SRC=\ +\ + ../common/cmndata.cpp \ + ../common/config.cpp \ + ../common/date.cpp \ + ../common/docmdi.cpp \ + ../common/docview.cpp \ + ../common/dynarray.cpp \ + ../common/dynlib.cpp \ + ../common/event.cpp \ + ../common/file.cpp \ + ../common/fileconf.cpp \ + ../common/filefn.cpp \ + ../common/gdicmn.cpp \ + ../common/hash.cpp \ + ../common/helpbase.cpp \ + ../common/intl.cpp \ + ../common/ipcbase.cpp \ + ../common/layout.cpp \ + ../common/list.cpp \ + ../common/log.cpp \ + ../common/matrix.cpp \ + ../common/memory.cpp \ + ../common/module.cpp \ + ../common/object.cpp \ + ../common/odbc.cpp \ + ../common/postscrp.cpp \ + ../common/prntbase.cpp \ + ../common/resource.cpp \ + ../common/serbase.cpp \ + ../common/string.cpp \ + ../common/textfile.cpp \ + ../common/tbarbase.cpp \ + ../common/tbarsmpl.cpp \ + ../common/timercmn.cpp \ + ../common/utilscmn.cpp \ + ../common/wincmn.cpp \ + ../common/framecmn.cpp \ + ../common/stream.cpp \ + ../common/datstrm.cpp \ + ../common/fstream.cpp \ + ../common/mstream.cpp \ + ../common/zstream.cpp \ + ../common/objstrm.cpp \ + ../common/sckstrm.cpp \ + ../common/validate.cpp \ + ../common/valtext.cpp \ + ../common/variant.cpp \ + ../common/wxexpr.cpp \ + ../common/socket.cpp \ + ../common/sckaddr.cpp \ + ../common/sckipc.cpp \ + ../common/protocol.cpp \ + ../common/ftp.cpp \ + ../common/http.cpp \ + ../common/url.cpp \ + ../common/tokenzr.cpp \ +\ + accel.cpp \ + app.cpp \ + bitmap.cpp \ + bmpbuttn.cpp \ + brush.cpp \ + button.cpp \ + checkbox.cpp \ + choice.cpp \ + clipbrd.cpp \ + colour.cpp \ + colordlg.cpp \ + control.cpp \ + combobox.cpp \ + cursor.cpp \ + data.cpp \ + dc.cpp \ + dcclient.cpp \ + dcmemory.cpp \ + dcscreen.cpp \ + dialog.cpp \ + dnd.cpp \ + filedlg.cpp \ + font.cpp \ + fontdlg.cpp \ + frame.cpp \ + gauge.cpp \ + gdiobj.cpp \ + helpxxxx.cpp \ + icon.cpp \ + listbox.cpp \ + joystick.cpp \ + main.cpp \ + mdi.cpp \ + menu.cpp \ + menuitem.cpp \ + metafile.cpp \ + minifram.cpp \ + msgdlg.cpp \ + notebook.cpp \ + palette.cpp \ + pen.cpp \ + print.cpp \ + radiobox.cpp \ + radiobut.cpp \ + region.cpp \ + scrolbar.cpp \ + settings.cpp \ + slider.cpp \ + spinbutt.cpp \ + statbox.cpp \ + statbmp.cpp \ + stattext.cpp \ + taskbar.cpp \ + textctrl.cpp \ + thread.cpp \ + timer.cpp \ + toolbar.cpp \ + utils.cpp \ + utilsexc.cpp \ + wave.cpp \ + window.cpp \ +\ + ../generic/choicdgg.cpp \ + ../generic/colrdlgg.cpp \ + ../generic/dirdlgg.cpp \ + ../generic/fontdlgg.cpp \ + ../generic/gridg.cpp \ + ../generic/imaglist.cpp \ + ../generic/listctrl.cpp \ + ../generic/laywin.cpp \ + ../generic/msgdlgg.cpp \ + ../generic/panelg.cpp \ + ../generic/printps.cpp \ + ../generic/prntdlgg.cpp \ + ../generic/sashwin.cpp \ + ../generic/scrolwin.cpp \ + ../generic/splitter.cpp \ + ../generic/statusbr.cpp \ + ../generic/tabg.cpp \ + ../generic/textdlgg.cpp \ + ../generic/treectrl.cpp + +# If you're not using the generic ones, you +# may wish to define platform-specific ones +# dirdlg.cpp \ +# treectrl.cpp \ +# listctrl.cpp \ +# imaglist.cpp \ +# statusbr.cpp \ + +LIB_C_SRC=\ +\ + ../common/y_tab.c \ + ../common/extended.c + +all: $(WXLIB) + +# Define library objects +OBJECTS=\ + $(LIB_CPP_SRC:.cpp=.o) $(LIB_C_SRC:.c=.o) + +$(WXLIB) : $(OBJECTS) + ar $(AROPTIONS) $@ $(OBJECTS) + $(RANLIB) $@ + +../common/y_tab.$(OBJSUFF): ../common/y_tab.c ../common/lex_yy.c + $(CCLEX) -c $(CFLAGS) -o $@ ../common/y_tab.c + +# Replace lex with flex if you run into compilation +# problems with lex_yy.c. See also note about LEX_SCANNER +# above. +../common/lex_yy.c: ../common/lexer.l + $(LEX) -o../common/lex.yy.c ../common/lexer.l + sed -e "s/BUFSIZ/5000/g" < ../common/lex.yy.c | \ + sed -e "s/yyoutput(c)/void yyoutput(c)/g" | \ + sed -e "s/YYLMAX 200/YYLMAX 5000/g" > ../common/lex_yy.c + /bin/rm -f ../common/lex.yy.c + +# Replace yacc with bison if you run into compilation +# problems with y_tab.c. +../common/y_tab.c: ../common/parser.y + $(YACC) ../common/parser.y + mv y.tab.c ../common/y_tab.c + + +clean: + rm -f $(OBJECTS) $(WXLIB) + diff --git a/src/mac/carbon/mdi.cpp b/src/mac/carbon/mdi.cpp new file mode 100644 index 0000000000..4869697cd7 --- /dev/null +++ b/src/mac/carbon/mdi.cpp @@ -0,0 +1,265 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/menu.h" +#include "wx/settings.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 wxUSE_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/mac/carbon/menu.cpp b/src/mac/carbon/menu.cpp new file mode 100644 index 0000000000..1fc7c4a229 --- /dev/null +++ b/src/mac/carbon/menu.cpp @@ -0,0 +1,571 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/utils.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; + m_clientData = (void*) 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); + } +/* TODO + // 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 *menus[], 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)) + return wxString(m_menus[i]->GetHelpString (Id)); + } + return wxString(""); +} + + diff --git a/src/mac/carbon/menuitem.cpp b/src/mac/carbon/menuitem.cpp new file mode 100644 index 0000000000..bd2f876a38 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/metafile.cpp b/src/mac/carbon/metafile.cpp new file mode 100644 index 0000000000..a92874b336 --- /dev/null +++ b/src/mac/carbon/metafile.cpp @@ -0,0 +1,239 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/string.h" +#include "wx/dc.h" +#include "wx/stubs/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/mac/carbon/minifram.cpp b/src/mac/carbon/minifram.cpp new file mode 100644 index 0000000000..4f6f5e5fcb --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/msgdlg.cpp b/src/mac/carbon/msgdlg.cpp new file mode 100644 index 0000000000..775ac8f064 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/notebook.cpp b/src/mac/carbon/notebook.cpp new file mode 100644 index 0000000000..312dd0f3d3 --- /dev/null +++ b/src/mac/carbon/notebook.cpp @@ -0,0 +1,377 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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; + + // 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 one page from the notebook, without deleting the window +bool wxNotebook::RemovePage(int nPage) +{ + wxCHECK( IS_VALID_PAGE(nPage), FALSE ); + + 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, h; + GetSize(&w, &h); + + unsigned int nCount = m_aPages.Count(); + for ( unsigned int 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/mac/carbon/palette.cpp b/src/mac/carbon/palette.cpp new file mode 100644 index 0000000000..f8db96f8d0 --- /dev/null +++ b/src/mac/carbon/palette.cpp @@ -0,0 +1,82 @@ +///////////////////////////////////////////////////////////////////////////// +// 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::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/mac/carbon/pen.cpp b/src/mac/carbon/pen.cpp new file mode 100644 index 0000000000..1e3ced2a3a --- /dev/null +++ b/src/mac/carbon/pen.cpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////// +// 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); +} + +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(unsigned char r, unsigned char g, 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/mac/carbon/print.cpp b/src/mac/carbon/print.cpp new file mode 100644 index 0000000000..61fd6e7e99 --- /dev/null +++ b/src/mac/carbon/print.cpp @@ -0,0 +1,82 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/stubs/print.h" +#include "wx/stubs/printdlg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxPrinter, wxPrinterBase) +IMPLEMENT_CLASS(wxPrintPreview, 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, & m_printData); + return (dialog.ShowModal() == wxID_OK); +} + +bool wxPrinter::Setup(wxWindow *parent) +{ + wxPrintDialog dialog(parent, & m_printData); + dialog.GetPrintData().SetSetupDialog(TRUE); + return (dialog.ShowModal() == wxID_OK); +} + +/* + * Print preview + */ + +wxPrintPreview::wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data): + wxPrintPreviewBase(printout, printoutForPrinting, data) +{ + DetermineScaling(); +} + +wxPrintPreview::~wxPrintPreview() +{ +} + +bool wxPrintPreview::Print(bool interactive) +{ + if (!m_printPrintout) + return FALSE; + wxPrinter printer(&m_printData); + return printer.Print(m_previewFrame, m_printPrintout, interactive); +} + +void wxPrintPreview::DetermineScaling() +{ + // TODO +} + diff --git a/src/mac/carbon/printdlg.cpp b/src/mac/carbon/printdlg.cpp new file mode 100644 index 0000000000..eae3b95568 --- /dev/null +++ b/src/mac/carbon/printdlg.cpp @@ -0,0 +1,115 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/stubs/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() +{ + m_dialogParent = NULL; + m_printerDC = NULL; +} + +wxPrintDialog::wxPrintDialog(wxWindow *p, wxPrintData* data): + wxDialog() +{ + Create(p, data); +} + +bool wxPrintDialog::Create(wxWindow *p, wxPrintData* data) +{ + m_dialogParent = p; + m_printerDC = NULL; + + if ( data ) + m_printData = *data; + + return TRUE; +} + +wxPrintDialog::~wxPrintDialog() +{ + if (m_printerDC) + delete m_printerDC; +} + +int wxPrintDialog::ShowModal() +{ + // TODO + return wxID_CANCEL; +} + +wxDC *wxPrintDialog::GetPrintDC() +{ + if (m_printerDC) + { + wxDC* dc = m_printerDC; + m_printerDC = NULL; + return dc; + } + 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/mac/carbon/radiobox.cpp b/src/mac/carbon/radiobox.cpp new file mode 100644 index 0000000000..da582d0e52 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/radiobut.cpp b/src/mac/carbon/radiobut.cpp new file mode 100644 index 0000000000..65baab38b6 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/region.cpp b/src/mac/carbon/region.cpp new file mode 100644 index 0000000000..c71d4c605a --- /dev/null +++ b/src/mac/carbon/region.cpp @@ -0,0 +1,363 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/region.h" +#include "wx/gdicmn.h" + +#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 + } +}; + + +//----------------------------------------------------------------------------- +// 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/mac/carbon/scrolbar.cpp b/src/mac/carbon/scrolbar.cpp new file mode 100644 index 0000000000..54df181166 --- /dev/null +++ b/src/mac/carbon/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::SetThumbPosition(int viewStart) +{ + // TODO +} + +int wxScrollBar::GetThumbPosition() 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) +{ + SetThumbPosition(event.m_commandInt); + ProcessCommand(event); +} + diff --git a/src/mac/carbon/settings.cpp b/src/mac/carbon/settings.cpp new file mode 100644 index 0000000000..2beda5c2a6 --- /dev/null +++ b/src/mac/carbon/settings.cpp @@ -0,0 +1,176 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 wxColour(); +} + +wxFont wxSystemSettings::GetSystemFont(int index) +{ + // TODO + switch (index) + { + case wxSYS_DEVICE_DEFAULT_FONT: + { + break; + } + case wxSYS_DEFAULT_PALETTE: + { + break; + } + case wxSYS_SYSTEM_FIXED_FONT: + { + break; + } + case wxSYS_SYSTEM_FONT: + { + break; + } + default: + case wxSYS_DEFAULT_GUI_FONT: + { + break; + } + } + + 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/mac/carbon/slider.cpp b/src/mac/carbon/slider.cpp new file mode 100644 index 0000000000..c9952342a9 --- /dev/null +++ b/src/mac/carbon/slider.cpp @@ -0,0 +1,190 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/slider.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl) + +BEGIN_EVENT_TABLE(wxSlider, wxControl) +END_EVENT_TABLE() +#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/mac/carbon/spinbutt.cpp b/src/mac/carbon/spinbutt.cpp new file mode 100644 index 0000000000..cbea725592 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/statbmp.cpp b/src/mac/carbon/statbmp.cpp new file mode 100644 index 0000000000..a67c558465 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/statbox.cpp b/src/mac/carbon/statbox.cpp new file mode 100644 index 0000000000..b239dc738c --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/stattext.cpp b/src/mac/carbon/stattext.cpp new file mode 100644 index 0000000000..3b19c7184d --- /dev/null +++ b/src/mac/carbon/stattext.cpp @@ -0,0 +1,60 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#include "wx/app.h" +#include "wx/stattext.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->GetBackgroundColour()) ; + SetForegroundColour(parent->GetForegroundColour()) ; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_windowStyle = style; + + SetFont(parent->GetFont()); + + // TODO + return FALSE; +} + +void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxStaticText::SetLabel(const wxString& label) +{ + // TODO +} + diff --git a/src/mac/carbon/statusbr.cpp b/src/mac/carbon/statusbr.cpp new file mode 100644 index 0000000000..dff1ddec34 --- /dev/null +++ b/src/mac/carbon/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::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::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::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/mac/carbon/tabctrl.cpp b/src/mac/carbon/tabctrl.cpp new file mode 100644 index 0000000000..b3b45a72d1 --- /dev/null +++ b/src/mac/carbon/tabctrl.cpp @@ -0,0 +1,201 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/control.h" +#include "wx/tabctrl.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTabCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTabCtrl, wxControl) +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/mac/carbon/taskbar.cpp b/src/mac/carbon/taskbar.cpp new file mode 100644 index 0000000000..5c91250cf0 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/textctrl.cpp b/src/mac/carbon/textctrl.cpp new file mode 100644 index 0000000000..4171b868b6 --- /dev/null +++ b/src/mac/carbon/textctrl.cpp @@ -0,0 +1,447 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#ifndef __WXMAC__ +#include +#include +#else +#include +#endif +#include + +#include "wx/textctrl.h" +#include "wx/settings.h" +#include "wx/filefn.h" +#include "wx/utils.h" + +#if defined(__BORLANDC__) && !defined(__WIN32__) +#include +#else +#ifndef __MWERKS__ +#ifndef __GNUWIN32__ +#include +#endif +#endif +#endif + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) + EVT_DROP_FILES(wxTextCtrl::OnDropFiles) +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 +} + +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(); + +#ifndef __WXMAC__ + ifstream input((char*) (const char*) file, ios::nocreate | ios::in); +#else + ifstream input((char*) (const char*) file, ios::in); +#endif + 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/mac/carbon/thread.cpp b/src/mac/carbon/thread.cpp new file mode 100644 index 0000000000..82fff92ba3 --- /dev/null +++ b/src/mac/carbon/thread.cpp @@ -0,0 +1,261 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/utils.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 wxMUTEX_NO_ERROR; +} + +wxMutexError wxMutex::TryLock() +{ + // TODO + m_locked++; + return wxMUTEX_NO_ERROR; +} + +wxMutexError wxMutex::Unlock() +{ + if (m_locked > 0) + m_locked--; + + // TODO + return wxMUTEX_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 wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Destroy() +{ + // TODO + return wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Pause() +{ + // TODO + return wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Resume() +{ + // TODO + return wxTHREAD_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; +} + +/* is this needed somewhere ? +wxThread *wxThread::GetThreadFromID(unsigned long id) +{ + // TODO + return NULL; +} +*/ + +bool wxThread::IsAlive() const +{ + // TODO + return FALSE; +} + +bool wxThread::IsRunning() const +{ + // TODO + return FALSE; +} + +bool wxThread::IsMain() +{ + // TODO + return FALSE; +} + +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 = new wxMutex(); + wxMainMutex->Lock(); + return TRUE; + } + + // Global cleanup + virtual void OnExit() { + wxMainMutex->Unlock(); + delete wxMainMutex; + } +}; + +IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule) + diff --git a/src/mac/carbon/timer.cpp b/src/mac/carbon/timer.cpp new file mode 100644 index 0000000000..5262040cf6 --- /dev/null +++ b/src/mac/carbon/timer.cpp @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////// +// 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_id = 0; + m_oneShot = FALSE; +} + +wxTimer::~wxTimer() +{ + Stop(); +} + +bool wxTimer::Start(int milliseconds,bool mode) +{ + m_oneShot = mode ; + if (milliseconds <= 0) + return FALSE; + + m_milli = milliseconds; + + // TODO: set the timer going. + return FALSE; +} + +void wxTimer::Stop() +{ + m_id = 0 ; + m_milli = 0 ; +} + + diff --git a/src/mac/carbon/toolbar.cpp b/src/mac/carbon/toolbar.cpp new file mode 100644 index 0000000000..3cb859e366 --- /dev/null +++ b/src/mac/carbon/toolbar.cpp @@ -0,0 +1,145 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#include "wx/wx.h" +#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, wxNullBitmap, 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/mac/carbon/treectrl.cpp b/src/mac/carbon/treectrl.cpp new file mode 100644 index 0000000000..137a885dbf --- /dev/null +++ b/src/mac/carbon/treectrl.cpp @@ -0,0 +1,418 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: treectrl.cpp +// Purpose: wxTreeCtrl. See also Robert's generic 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/stubs/textctrl.h" +#include "wx/stubs/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, wxRect& 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: + break; + + case wxTREE_EXPAND_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/mac/carbon/utils.cpp b/src/mac/carbon/utils.cpp new file mode 100644 index 0000000000..940bdc21bc --- /dev/null +++ b/src/mac/carbon/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 wxUSE_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 // wxUSE_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/mac/carbon/utilsexc.cpp b/src/mac/carbon/utilsexc.cpp new file mode 100644 index 0000000000..b842d08e90 --- /dev/null +++ b/src/mac/carbon/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/mac/carbon/wave.cpp b/src/mac/carbon/wave.cpp new file mode 100644 index 0000000000..c25681858c --- /dev/null +++ b/src/mac/carbon/wave.cpp @@ -0,0 +1,61 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/string.h" +#include "wx/stubs/wave.h" + +wxWave::wxWave() + : m_waveData(NULL), m_waveLength(0), m_isResource(FALSE) +{ +} + +wxWave::wxWave(const wxString& sFileName, bool isResource) + : m_waveData(NULL), m_waveLength(0), m_isResource(FALSE) +{ + 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/mac/carbon/window.cpp b/src/mac/carbon/window.cpp new file mode 100644 index 0000000000..10ec3976dd --- /dev/null +++ b/src/mac/carbon/window.cpp @@ -0,0 +1,1292 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/frame.h" + +#include "wx/menuitem.h" +#include "wx/log.h" + +#if wxUSE_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_3DFACE) ; + // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ; + m_foregroundColour = *wxBLACK; + +#if wxUSE_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 wxUSE_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 wxUSE_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_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ; + m_foregroundColour = *wxBLACK; + + 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 wxUSE_DRAG_AND_DROP + +void wxWindow::SetDropTarget(wxDropTarget *pDropTarget) +{ + if ( m_pDropTarget != 0 ) { + delete m_pDropTarget; + } + + m_pDropTarget = pDropTarget; + if ( m_pDropTarget != 0 ) + { + // TODO + } +} + +#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 wxRect *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; +} + +// 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 wxRect *rect) +{ + // TODO + return; +} + +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) +{ + GetChildren().DeleteObject(child); + child->m_windowParent = NULL; +} + +void wxWindow::DestroyChildren() +{ + 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 + 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) ; +} + +void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel) +{ + m_acceleratorTable = accel; +} + +// 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); +} + +/* + * Allocates control IDs + */ + +int wxWindow::NewControlId() +{ + static int s_controlId = 0; + s_controlId ++; + return s_controlId; +} + + diff --git a/src/mac/checkbox.cpp b/src/mac/checkbox.cpp new file mode 100644 index 0000000000..dd2e2abe7a --- /dev/null +++ b/src/mac/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/mac/checklst.cpp b/src/mac/checklst.cpp new file mode 100644 index 0000000000..2f43152c2a --- /dev/null +++ b/src/mac/checklst.cpp @@ -0,0 +1,74 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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) +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(size_t uiIndex) const +{ + // TODO + return FALSE; +} + +void wxCheckListBox::Check(size_t uiIndex, bool bCheck) +{ + // TODO +} + + diff --git a/src/mac/choice.cpp b/src/mac/choice.cpp new file mode 100644 index 0000000000..a584d5303f --- /dev/null +++ b/src/mac/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/mac/clipbrd.cpp b/src/mac/clipbrd.cpp new file mode 100644 index 0000000000..3fe9ebfb72 --- /dev/null +++ b/src/mac/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/mac/colordlg.cpp b/src/mac/colordlg.cpp new file mode 100644 index 0000000000..2275a9a39d --- /dev/null +++ b/src/mac/colordlg.cpp @@ -0,0 +1,53 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: colordlg.cpp +// Purpose: wxColourDialog class. NOTE: you can use the generic class +// if you wish, instead of implementing this. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "colordlg.h" +#endif + +#include "wx/stubs/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/mac/colour.cpp b/src/mac/colour.cpp new file mode 100644 index 0000000000..8d0827ef1d --- /dev/null +++ b/src/mac/colour.cpp @@ -0,0 +1,103 @@ +///////////////////////////////////////////////////////////////////////////// +// 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; +} + +void wxColour::InitFromName(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 () +{ +} + +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/mac/combobox.cpp b/src/mac/combobox.cpp new file mode 100644 index 0000000000..0be841bad4 --- /dev/null +++ b/src/mac/combobox.cpp @@ -0,0 +1,165 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 +} + +void wxComboBox::Append(const wxString& item) +{ + // TODO +} + +void wxComboBox::Delete(int n) +{ + // TODO +} + +void wxComboBox::Clear() +{ + // TODO +} + +int wxComboBox::GetSelection() const +{ + // TODO + return -1; +} + +void wxComboBox::SetSelection(int n) +{ + // TODO +} + +int wxComboBox::FindString(const wxString& s) const +{ + // TODO + return -1; +} + +wxString wxComboBox::GetString(int n) const +{ + // TODO + return wxString(""); +} + +wxString wxComboBox::GetStringSelection() const +{ + // TODO + return wxString(""); +} + +bool wxComboBox::SetStringSelection(const wxString& sel) +{ + // TODO + return FALSE; +} diff --git a/src/mac/control.cpp b/src/mac/control.cpp new file mode 100644 index 0000000000..b141a80ff1 --- /dev/null +++ b/src/mac/control.cpp @@ -0,0 +1,95 @@ +///////////////////////////////////////////////////////////////////////////// +// 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() == (wxButton*) this) + parent->SetDefaultItem(NULL); + } +} + +void wxControl::SetLabel(const wxString& label) +{ + // TODO +} + +wxString wxControl::GetLabel() const +{ + // TODO + return wxString(""); +} + +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::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/mac/cursor.cpp b/src/mac/cursor.cpp new file mode 100644 index 0000000000..4333364c93 --- /dev/null +++ b/src/mac/cursor.cpp @@ -0,0 +1,187 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/icon.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 wxCursorRefData; + + // TODO: create cursor from a file +} + +// Cursors by stock number +wxCursor::wxCursor(int cursor_type) +{ + m_refData = new wxCursorRefData; + +/* 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/mac/data.cpp b/src/mac/data.cpp new file mode 100644 index 0000000000..5e6c418519 --- /dev/null +++ b/src/mac/data.cpp @@ -0,0 +1,151 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +#if wxUSE_POSTSCRIPT +#include "wx/postscrp.h" +#endif + +#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 wxUSE_POSTSCRIPT +wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL; +#endif + +#if wxUSE_SHARED_LIBRARY +///// 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 } }; +#endif + +const wxSize wxDefaultSize(-1, -1); +const wxPoint wxDefaultPosition(-1, -1); diff --git a/src/mac/dc.cpp b/src/mac/dc.cpp new file mode 100644 index 0000000000..642dc1edc5 --- /dev/null +++ b/src/mac/dc.cpp @@ -0,0 +1,385 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 +//----------------------------------------------------------------------------- + +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( 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/mac/dcclient.cpp b/src/mac/dcclient.cpp new file mode 100644 index 0000000000..925d9609ee --- /dev/null +++ b/src/mac/dcclient.cpp @@ -0,0 +1,635 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 "wx/region.h" +#include + +//----------------------------------------------------------------------------- +// constants +//----------------------------------------------------------------------------- + +#define RAD2DEG 57.2957795131 + +//----------------------------------------------------------------------------- +// wxPaintDC +//----------------------------------------------------------------------------- + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC) +IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC) +IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxWindowDC) +#endif + +/* + * wxWindowDC + */ + +wxWindowDC::wxWindowDC(void) +{ +}; + +wxWindowDC::wxWindowDC( wxWindow *window ) +{ +}; + +wxWindowDC::~wxWindowDC(void) +{ +}; + +void wxWindowDC::FloodFill( long WXUNUSED(x1), long WXUNUSED(y1), + const wxColour& WXUNUSED(col), int WXUNUSED(style) ) +{ +}; + +bool wxWindowDC::GetPixel( long WXUNUSED(x1), long WXUNUSED(y1), wxColour *WXUNUSED(col) ) const +{ + return FALSE; +}; + +void wxWindowDC::DrawLine( long x1, long y1, long x2, long y2 ) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::CrossHair( long x, long y ) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::DrawArc( long x1, long y1, long x2, long y2, long xc, long 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 wxWindowDC::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 wxWindowDC::DrawPoint( long x, long y ) +{ + if (!Ok()) return; + + if (m_pen.GetStyle() != wxTRANSPARENT) {}; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::DrawPolygon( int WXUNUSED(n), wxPoint WXUNUSED(points)[], + long WXUNUSED(xoffset), long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxWindowDC::DrawPolygon( wxList *WXUNUSED(lines), long WXUNUSED(xoffset), + long WXUNUSED(yoffset), int WXUNUSED(fillStyle) ) +{ + if (!Ok()) return; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::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 wxWindowDC::CanDrawBitmap(void) const +{ + return TRUE; +}; + +void wxWindowDC::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 wxWindowDC::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 wxWindowDC::DrawText( const wxString &text, long x, long y, bool +WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + + + +bool wxWindowDC::CanGetTextExtent(void) const +{ + return TRUE; +}; + +void wxWindowDC::GetTextExtent( const wxString &string, long *width, long *height, + long *WXUNUSED(descent), long *WXUNUSED(externalLeading), + wxFont *WXUNUSED(theFont), bool WXUNUSED(use16) ) +{ + if (!Ok()) return; + +}; + +long wxWindowDC::GetCharWidth(void) +{ + if (!Ok()) return 0; + return 0; +}; + +long wxWindowDC::GetCharHeight(void) +{ + if (!Ok()) return 0; + return 0; +}; + +void wxWindowDC::Clear(void) +{ + if (!Ok()) return; + +}; + +void wxWindowDC::SetFont( const wxFont &font ) +{ + if (!Ok()) return; + + m_font = font; +}; + +void wxWindowDC::SetPen( const wxPen &pen ) +{ + if (!Ok()) return; + + if (m_pen == pen) return; + + m_pen = pen; + + if (!m_pen.Ok()) return; +}; + +void wxWindowDC::SetBrush( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_brush == brush) return; + + m_brush = brush; + + if (!m_brush.Ok()) return; + +}; + +void wxWindowDC::SetBackground( const wxBrush &brush ) +{ + if (!Ok()) return; + + if (m_backgroundBrush == brush) return; + + m_backgroundBrush = brush; + + if (!m_backgroundBrush.Ok()) return; + +}; + +void wxWindowDC::SetLogicalFunction( int function ) +{ + if (m_logicalFunction == function) return; +}; + +void wxWindowDC::SetTextForeground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textForegroundColour == col) return; + + m_textForegroundColour = col; + if (!m_textForegroundColour.Ok()) return; +}; + +void wxWindowDC::SetTextBackground( const wxColour &col ) +{ + if (!Ok()) return; + + if (m_textBackgroundColour == col) return; + + m_textBackgroundColour = col; + if (!m_textBackgroundColour.Ok()) return; +}; + +void wxWindowDC::SetBackgroundMode( int mode ) +{ + m_backgroundMode = mode; + + if (m_brush.GetStyle() != wxSOLID && m_brush.GetStyle() != wxTRANSPARENT) + { + } +}; + +void wxWindowDC::SetPalette( const wxPalette& WXUNUSED(palette) ) +{ +}; + +void wxWindowDC::SetClippingRegion( long x, long y, long width, long height ) +{ + wxDC::SetClippingRegion( x, y, width, height ); + + // TODO + +}; + +void wxWindowDC::SetClippingRegion( const wxRegion& region ) +{ + wxRect box = region.GetBox(); + + wxDC::SetClippingRegion( box.x, box.y, box.width, box.height ); + + // TODO +} + +void wxWindowDC::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 wxWindowDC::DrawSpline( 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/mac/dcmemory.cpp b/src/mac/dcmemory.cpp new file mode 100644 index 0000000000..7cbd330821 --- /dev/null +++ b/src/mac/dcmemory.cpp @@ -0,0 +1,64 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +//----------------------------------------------------------------------------- +// 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/mac/dcscreen.cpp b/src/mac/dcscreen.cpp new file mode 100644 index 0000000000..e03bbac0c8 --- /dev/null +++ b/src/mac/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, wxWindowDC) +#endif + +// Create a DC representing the whole screen +wxScreenDC::wxScreenDC() +{ + // TODO +} + +wxScreenDC::~wxScreenDC() +{ + // TODO +} + diff --git a/src/mac/dialog.cpp b/src/mac/dialog.cpp new file mode 100644 index 0000000000..7d6d99744d --- /dev/null +++ b/src/mac/dialog.cpp @@ -0,0 +1,287 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 (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; + wxWindow *parent = GetParent(); + if ((direction & wxCENTER_FRAME) && parent) + { + parent->GetPosition(&x_offset,&y_offset) ; + parent->GetSize(&display_width,&display_height) ; + } + else + { + 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(); +} + +void wxDialog::Fit() +{ +} diff --git a/src/mac/dirdlg.cpp b/src/mac/dirdlg.cpp new file mode 100644 index 0000000000..095621b978 --- /dev/null +++ b/src/mac/dirdlg.cpp @@ -0,0 +1,42 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" + +#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/mac/dnd.cpp b/src/mac/dnd.cpp new file mode 100644 index 0000000000..32088eef0f --- /dev/null +++ b/src/mac/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) +{ +}; + +wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) ) +{ + // TODO + return wxDragError; +}; + diff --git a/src/mac/filedlg.cpp b/src/mac/filedlg.cpp new file mode 100644 index 0000000000..2aeffdf926 --- /dev/null +++ b/src/mac/filedlg.cpp @@ -0,0 +1,143 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/intl.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 + return 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/mac/font.cpp b/src/mac/font.cpp new file mode 100644 index 0000000000..493a6a25ba --- /dev/null +++ b/src/mac/font.cpp @@ -0,0 +1,244 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/defs.h" +#include "wx/string.h" +#include "wx/font.h" +#include "wx/gdicmn.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/mac/fontdlg.cpp b/src/mac/fontdlg.cpp new file mode 100644 index 0000000000..60e8e9b987 --- /dev/null +++ b/src/mac/fontdlg.cpp @@ -0,0 +1,55 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: fontdlg.cpp +// Purpose: wxFontDialog class. NOTE: you can use the generic class +// if you wish, instead of implementing this. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "fontdlg.h" +#endif + +#include "wx/stubs/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/mac/frame.cpp b/src/mac/frame.cpp new file mode 100644 index 0000000000..1e8c9e9ae5 --- /dev/null +++ b/src/mac/frame.cpp @@ -0,0 +1,571 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/menu.h" +#include "wx/dcclient.h" +#include "wx/dialog.h" +#include "wx/settings.h" +#include "wx/app.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 wxUSE_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; +} + +// Is the frame maximized? +bool wxFrame::IsMaximized(void) 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 +} + +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 wxUSE_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))) + { + 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; +} + +void wxFrame::ScreenToClient(int *x, int *y) const +{ + wxWindow::ScreenToClient(x, y); + + // We may be faking the client origin. + // So a window that's really at (0, 30) may appear + // (to wxWin apps) to be at (0, 0). + wxPoint pt(GetClientAreaOrigin()); + *x -= pt.x; + *y -= pt.y; +} + +void wxFrame::ClientToScreen(int *x, int *y) const +{ + // We may be faking the client origin. + // So a window that's really at (0, 30) may appear + // (to wxWin apps) to be at (0, 0). + wxPoint pt1(GetClientAreaOrigin()); + *x += pt1.x; + *y += pt1.y; + + wxWindow::ClientToScreen(x, y); +} + +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. + + 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/mac/gauge.cpp b/src/mac/gauge.cpp new file mode 100644 index 0000000000..a85fbc498f --- /dev/null +++ b/src/mac/gauge.cpp @@ -0,0 +1,95 @@ +///////////////////////////////////////////////////////////////////////////// +// 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; +} + diff --git a/src/mac/gdiobj.cpp b/src/mac/gdiobj.cpp new file mode 100644 index 0000000000..63697c8354 --- /dev/null +++ b/src/mac/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/mac/helpxxxx.cpp b/src/mac/helpxxxx.cpp new file mode 100644 index 0000000000..086762c646 --- /dev/null +++ b/src/mac/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/mac/icon.cpp b/src/mac/icon.cpp new file mode 100644 index 0000000000..6deee7dbdc --- /dev/null +++ b/src/mac/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/mac/imaglist.cpp b/src/mac/imaglist.cpp new file mode 100644 index 0000000000..4cb47b4e69 --- /dev/null +++ b/src/mac/imaglist.cpp @@ -0,0 +1,118 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: imaglist.cpp +// Purpose: wxImageList. You may wish to use the generic version. +// Author: AUTHOR +// Modified by: +// Created: ??/??/98 +// RCS-ID: $Id$ +// Copyright: (c) AUTHOR +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifdef __GNUG__ +#pragma implementation "imaglist.h" +#endif + +#include "wx/stubs/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/mac/joystick.cpp b/src/mac/joystick.cpp new file mode 100644 index 0000000000..6677277f48 --- /dev/null +++ b/src/mac/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/mac/listbox.cpp b/src/mac/listbox.cpp new file mode 100644 index 0000000000..1dad21e12c --- /dev/null +++ b/src/mac/listbox.cpp @@ -0,0 +1,235 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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/settings.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::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/mac/listctrl.cpp b/src/mac/listctrl.cpp new file mode 100644 index 0000000000..d1d8445652 --- /dev/null +++ b/src/mac/listctrl.cpp @@ -0,0 +1,596 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/stubs/textctrl.h" +#include "wx/stubs/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, wxRect& 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 ) + { + m_imageListNormal = imageList; + } + else if ( which == wxIMAGE_LIST_SMALL ) + { + m_imageListSmall = imageList; + } + else if ( which == wxIMAGE_LIST_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/mac/main.cpp b/src/mac/main.cpp new file mode 100644 index 0000000000..47a9924bae --- /dev/null +++ b/src/mac/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/mac/makefile.nt b/src/mac/makefile.nt new file mode 100644 index 0000000000..2865fbcec3 --- /dev/null +++ b/src/mac/makefile.nt @@ -0,0 +1,955 @@ +# +# File: makefile.nt +# Author: Julian Smart +# Created: 1997 +# Updated: +# Copyright: (c) 1997, Julian Smart +# +# "%W% %G%" +# +# Makefile : Builds wxWindows stubs library wxstubs.lib for VC++ (32-bit) +# Arguments: +# +# FINAL=1 argument to nmake to build version with no debugging info. +# + +!include + +APPVER=3.50 # 4.0 +# This means 'enable Windows 95 features' (in wxWindows and in VC++ 4.0). +WINVERSION=-DWINVER=0x0400 + +# On Alpha machines, change to CPU=ALPHA +CPU=i386 + +# Suffixes +OBJSUFF=obj +SRCSUFF=cpp + +WINFLAGS=-c -W3 -Dtry=__try -Dexcept=__except -Dleave=__leave -Dfinally=__finally -DCRTAPI1=_cdecl -DCRTAPI2=_cdecl -nologo -D_X86_=1 $(WINVERSION) -D__WIN32__ -D__WINDOWS__ +WINLINKFLAGS=/INCREMENTAL:NO /NOLOGO -align:0x1000 -machine:$(CPU) -subsystem:windows,$(APPVER) +WINLIBS=kernel32.lib user32.lib gdi32.lib comdlg32.lib winspool.lib winmm.lib shell32.lib oldnames.lib\ + comctl32.lib ctl3d32.lib odbc32.lib ole32.lib oleaut32.lib uuid.lib rpcrt4.lib advapi32.lib # libci.lib # libci.lib required for VC++ 4.2 + +# Change this to your WXWIN directory +WXDIR=$(WXWIN) + +WXSRC=$(WXDIR)\src\stubs +WXINC=$(WXDIR)\include +WXBASESRC=$(WXDIR)\src\common + +WXLIB=$(WXDIR)\lib\wxstubs.lib + +EXTRADLLFLAGS= + +INC=-I$(WXINC) -I$(WXDIR)/src/png -I$(WXDIR)/src/zlib $(EXTRAINC) +LIBS = $(EXTRALIBS) $(WXLIB) $(WINLIBS) + +!ifndef FINAL +FINAL=0 +DEBUG=1 +!endif + +# Set this to 1 if you don't want to use precompiled headers +NOPCH=1 + +OPTIONS= + +!if "$(FINAL)" == "0" +OPT = /Od /Gy +# ***N.B.*** to save space/time, comment out /FR to avoid browse info (.sbr files) being generated +DEBUG_FLAGS= /Zi # /FR +LINK_DEBUG_FLAGS=-debug:full -debugtype:cv # /PDB:NONE +CRTFLAG=/MD +!else +# /O1 - smallest code +# /O2 - fastest code +OPT = /O1 # /O2 # /Od +DEBUG_FLAGS= +LINK_DEBUG_FLAGS=/RELEASE +CRTFLAG=/MD +!endif + +PCH= +PRECOMP= +MAKEPRECOMP= + +CPPFLAGS=$(WINFLAGS) $(DEBUG_FLAGS) $(PRECOMP) $(EXTRAFLAGS) /D__WXSTUBS__ /DDEBUG=1 $(INC) $(OPT) $(CRTFLAG) /GX /D__WXDEBUG__ /DWXDEBUG=1 +# If you don't include wxprec.h, use CPPFLAGS2 +CPPFLAGS2=$(WINFLAGS) $(DEBUG_FLAGS) /D__WXSTUBS__ /DDEBUG=1 $(INC) $(EXTRAFLAGS) $(OPT) $(CRTFLAG) /GX /D__WXDEBUG__ /DWXDEBUG=1 +LINKFLAGS=$(LINK_DEBUG_FLAGS) $(WINLINKFLAGS) -entry:WinMainCRTStartup + +THISDIR=$(WXWIN)\src\stubs + +LIBTARGET=$(WXLIB) + +# Please set these according to the settings in wx_setup.h, so we can include +# the appropriate libraries in wx.lib + +PERIPH_LIBS= +PERIPH_TARGET= +PERIPH_CLEAN_TARGET= + +GENDIR=..\generic +COMMDIR=..\common +STUBSDIR=. + +DOCDIR = $(WXDIR)\docs + +GENERICOBJS= \ + $(GENDIR)\choicdgg.obj \ + $(GENDIR)\colrdlgg.obj \ + $(GENDIR)\fontdlgg.obj \ + $(GENDIR)\gridg.obj \ + $(GENDIR)\msgdlgg.obj \ + $(GENDIR)\panelg.obj \ + $(GENDIR)\printps.obj \ + $(GENDIR)\prntdlgg.obj \ + $(GENDIR)\scrolwin.obj \ + $(GENDIR)\splitter.obj \ + $(GENDIR)\statusbr.obj \ + $(GENDIR)\tabg.obj \ + $(GENDIR)\textdlgg.obj + +# $(GENDIR)\helpxlp.obj \ + +COMMONOBJS = \ + $(COMMDIR)\cmndata.obj \ + $(COMMDIR)\config.obj \ + $(COMMDIR)\docview.obj \ + $(COMMDIR)\docmdi.obj \ + $(COMMDIR)\dynarray.obj \ + $(COMMDIR)\event.obj \ + $(COMMDIR)\file.obj \ + $(COMMDIR)\filefn.obj \ + $(COMMDIR)\fileconf.obj \ + $(COMMDIR)\framecmn.obj \ + $(COMMDIR)\gdicmn.obj \ + $(COMMDIR)\intl.obj \ + $(COMMDIR)\ipcbase.obj \ + $(COMMDIR)\helpbase.obj \ + $(COMMDIR)\layout.obj \ + $(COMMDIR)\log.obj \ + $(COMMDIR)\memory.obj \ + $(COMMDIR)\module.obj \ + $(COMMDIR)\object.obj \ + $(COMMDIR)\postscrp.obj \ + $(COMMDIR)\prntbase.obj \ + $(COMMDIR)\resource.obj \ + $(COMMDIR)\tbarbase.obj \ + $(COMMDIR)\tbarsmpl.obj \ + $(COMMDIR)\textfile.obj \ + $(COMMDIR)\timercmn.obj \ + $(COMMDIR)\utilscmn.obj \ + $(COMMDIR)\validate.obj \ + $(COMMDIR)\valtext.obj \ + $(COMMDIR)\date.obj \ + $(COMMDIR)\hash.obj \ + $(COMMDIR)\list.obj \ + $(COMMDIR)\string.obj \ + $(COMMDIR)\time.obj \ + $(COMMDIR)\wxexpr.obj \ + $(COMMDIR)\y_tab.obj \ + $(COMMDIR)\extended.obj \ + $(COMMDIR)\process.obj \ + $(COMMDIR)\fstream.obj \ + $(COMMDIR)\mstream.obj \ + $(COMMDIR)\zstream.obj \ + $(COMMDIR)\stream.obj \ + $(COMMDIR)\datstrm.obj \ + $(COMMDIR)\wincmn.obj + +# $(COMMDIR)\odbc.obj \ + +STUBSOBJS = \ + $(STUBSDIR)\accel.obj \ + $(STUBSDIR)\app.obj \ + $(STUBSDIR)\bitmap.obj \ + $(STUBSDIR)\bmpbuttn.obj \ + $(STUBSDIR)\brush.obj \ + $(STUBSDIR)\button.obj \ + $(STUBSDIR)\checkbox.obj \ + $(STUBSDIR)\checklst.obj \ + $(STUBSDIR)\choice.obj \ + $(STUBSDIR)\clipbrd.obj \ + $(STUBSDIR)\colordlg.obj \ + $(STUBSDIR)\colour.obj \ + $(STUBSDIR)\combobox.obj \ + $(STUBSDIR)\control.obj \ + $(STUBSDIR)\cursor.obj \ + $(STUBSDIR)\data.obj \ + $(STUBSDIR)\dc.obj \ + $(STUBSDIR)\dcmemory.obj \ + $(STUBSDIR)\dcclient.obj \ + $(STUBSDIR)\dcscreen.obj \ + $(STUBSDIR)\dialog.obj \ + $(STUBSDIR)\dirdlg.obj \ + $(STUBSDIR)\filedlg.obj \ + $(STUBSDIR)\font.obj \ + $(STUBSDIR)\fontdlg.obj \ + $(STUBSDIR)\frame.obj \ + $(STUBSDIR)\gauge.obj \ + $(STUBSDIR)\gdiobj.obj \ + $(STUBSDIR)\helpxxxx.obj \ + $(STUBSDIR)\icon.obj \ + $(STUBSDIR)\imaglist.obj \ + $(STUBSDIR)\joystick.obj \ + $(STUBSDIR)\listbox.obj \ + $(STUBSDIR)\listctrl.obj \ + $(STUBSDIR)\main.obj \ + $(STUBSDIR)\mdi.obj \ + $(STUBSDIR)\menu.obj \ + $(STUBSDIR)\menuitem.obj \ + $(STUBSDIR)\metafile.obj \ + $(STUBSDIR)\minifram.obj \ + $(STUBSDIR)\msgdlg.obj \ + $(STUBSDIR)\notebook.obj \ + $(STUBSDIR)\palette.obj \ + $(STUBSDIR)\pen.obj \ + $(STUBSDIR)\printdlg.obj \ + $(STUBSDIR)\print.obj \ + $(STUBSDIR)\radiobox.obj \ + $(STUBSDIR)\radiobut.obj \ + $(STUBSDIR)\region.obj \ + $(STUBSDIR)\scrolbar.obj \ + $(STUBSDIR)\settings.obj \ + $(STUBSDIR)\slider.obj \ + $(STUBSDIR)\spinbutt.obj \ + $(STUBSDIR)\statbmp.obj \ + $(STUBSDIR)\statbox.obj \ + $(STUBSDIR)\statusbr.obj \ + $(STUBSDIR)\stattext.obj \ + $(STUBSDIR)\tabctrl.obj \ + $(STUBSDIR)\taskbar.obj \ + $(STUBSDIR)\toolbar.obj \ + $(STUBSDIR)\textctrl.obj \ + $(STUBSDIR)\thread.obj \ + $(STUBSDIR)\timer.obj \ + $(STUBSDIR)\treectrl.obj \ + $(STUBSDIR)\utils.obj \ + $(STUBSDIR)\utilsexc.obj \ + $(STUBSDIR)\wave.obj \ + $(STUBSDIR)\window.obj + + +OBJECTS = $(COMMONOBJS) $(GENERICOBJS) $(STUBSOBJS) + +# Normal, static library +all: $(OBJECTS) $(PERIPH_TARGET) $(LIBTARGET) + +$(WXDIR)\lib\wxstubs.lib: $(OBJECTS) $(PERIPH_LIBS) + -erase $(LIBTARGET) + $(implib) @<< +-out:$@ +-machine:$(CPU) +$(OBJECTS) $(PERIPH_LIBS) +<< + +######################################################## +# Windows-specific objects + +$(STUBSDIR)/accel.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/app.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/bitmap.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/bmpbuttn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/brush.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/button.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/choice.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/checkbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/checklst.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/clipbrd.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/colordlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/colour.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/combobox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/control.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/cursor.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/data.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcmemory.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcclient.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcprint.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dcscreen.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dialog.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/dirdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/filedlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/font.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/fontdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/frame.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/gauge.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/gdiobj.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/icon.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/imaglist.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/joystick.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/listbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF) +<< + +$(STUBSDIR)/listctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /Fo$@ /c /Tp $*.$(SRCSUFF) +<< + +$(STUBSDIR)/main.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/mdi.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/menu.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/menuitem.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/metafile.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/minifram.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/msgdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/notebook.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/palette.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/pen.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/printdlg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/print.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/radiobox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/radiobut.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/region.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/scrolbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/settings.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/slider.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/spinbutt.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statbmp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statbox.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/statusbr.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/stattext.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/tabctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/taskbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/toolbar.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/textctrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/thread.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/timer.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/treectrl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/utils.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/utilsexc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/wave.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(STUBSDIR)/window.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +######################################################## +# Common objects (always compiled) + +$(COMMDIR)/cmndata.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/config.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/db.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/dbtable.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/docview.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/docmdi.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/dynarray.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/event.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/file.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/fileconf.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/filefn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/framecmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/gdicmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/intl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/ipcbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/helpbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/layout.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/log.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/memory.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/module.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/object.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/odbc.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/postscrp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/prntbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/resource.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/tbarbase.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/tbarsmpl.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/textfile.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/timercmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/utilscmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/validate.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/valtext.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/date.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/wxexpr.obj: $*.$(SRCSUFF) + echo $(CPPFLAGS) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/hash.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/list.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/string.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/matrix.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +#$(COMMDIR)/wxstrgnu/wxstrgnu.obj: $*.$(SRCSUFF) +# cl @<< +#$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +#<< + +#$(COMMDIR)/wxstrgnu/wxregex.obj: $*.$(SRCSUFF) +# cl @<< +#$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +#<< + +$(COMMDIR)/time.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\stream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\fstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\mstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\zstream.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)\datstrm.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/extended.obj: $*.c + cl @<< +$(CPPFLAGS2) /c /Tp $*.c /Fo$@ +<< + +$(COMMDIR)/process.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/wincmn.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS2) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(COMMDIR)/y_tab.obj: $*.c $(COMMDIR)/lex_yy.c + cl @<< +$(CPPFLAGS2) /c $*.c -DUSE_DEFINE -DYY_USE_PROTOS /Fo$@ +<< + +$(COMMDIR)/y_tab.c: $(COMMDIR)/dosyacc.c + copy $(COMMDIR)\dosyacc.c $(COMMDIR)\y_tab.c + +$(COMMDIR)/lex_yy.c: $(COMMDIR)/doslex.c + copy $(COMMDIR)\doslex.c $(COMMDIR)\lex_yy.c + +######################################################## +# Generic objects (not always compiled, depending on +# whether platforms have native implementations) + +$(GENDIR)/choicdgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/colrdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/fontdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/gridg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/helpxlp.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/msgdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/panelg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/printps.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/prntdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/scrolwin.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/splitter.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/statusbr.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/tabg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(GENDIR)/textdlgg.obj: $*.$(SRCSUFF) + cl @<< +$(CPPFLAGS) /c /Tp $*.$(SRCSUFF) /Fo$@ +<< + +$(OBJECTS): $(WXDIR)/include/wx/stubs/setup.h + +clean: $(PERIPH_CLEAN_TARGET) + -erase *.obj + -erase $(LIBTARGET) + -erase $(WXDIR)\lib\*.pdb + -erase *.pdb + -erase *.sbr + -erase *.pch + cd $(WXDIR)\src\stubs + cd $(GENDIR) + -erase *.pdb + -erase *.sbr + -erase *.obj + cd $(WXDIR)\src\stubs + cd $(COMMDIR) + -erase *.pdb + -erase *.sbr + -erase *.obj + -erase y_tab.c + -erase lex_yy.c + cd $(WXDIR)\src\stubs + +cleanall: clean + diff --git a/src/mac/makefile.unx b/src/mac/makefile.unx new file mode 100644 index 0000000000..5bd62163fd --- /dev/null +++ b/src/mac/makefile.unx @@ -0,0 +1,200 @@ +# +# File: makefile.unx +# Author: Julian Smart +# Created: 1998 +# Updated: +# Copyright: (c) 1998 +# +# +# Makefile for wxStubs library, Unix + +EXTRACFLAGS=-DLEX_SCANNER + +include ../make.env + +LIB_CPP_SRC=\ +\ + ../common/cmndata.cpp \ + ../common/config.cpp \ + ../common/date.cpp \ + ../common/docmdi.cpp \ + ../common/docview.cpp \ + ../common/dynarray.cpp \ + ../common/dynlib.cpp \ + ../common/event.cpp \ + ../common/file.cpp \ + ../common/fileconf.cpp \ + ../common/filefn.cpp \ + ../common/gdicmn.cpp \ + ../common/hash.cpp \ + ../common/helpbase.cpp \ + ../common/intl.cpp \ + ../common/ipcbase.cpp \ + ../common/layout.cpp \ + ../common/list.cpp \ + ../common/log.cpp \ + ../common/matrix.cpp \ + ../common/memory.cpp \ + ../common/module.cpp \ + ../common/object.cpp \ + ../common/odbc.cpp \ + ../common/postscrp.cpp \ + ../common/prntbase.cpp \ + ../common/resource.cpp \ + ../common/serbase.cpp \ + ../common/string.cpp \ + ../common/textfile.cpp \ + ../common/tbarbase.cpp \ + ../common/tbarsmpl.cpp \ + ../common/timercmn.cpp \ + ../common/utilscmn.cpp \ + ../common/wincmn.cpp \ + ../common/framecmn.cpp \ + ../common/stream.cpp \ + ../common/datstrm.cpp \ + ../common/fstream.cpp \ + ../common/mstream.cpp \ + ../common/zstream.cpp \ + ../common/objstrm.cpp \ + ../common/sckstrm.cpp \ + ../common/validate.cpp \ + ../common/valtext.cpp \ + ../common/variant.cpp \ + ../common/wxexpr.cpp \ + ../common/socket.cpp \ + ../common/sckaddr.cpp \ + ../common/sckipc.cpp \ + ../common/protocol.cpp \ + ../common/ftp.cpp \ + ../common/http.cpp \ + ../common/url.cpp \ + ../common/tokenzr.cpp \ +\ + accel.cpp \ + app.cpp \ + bitmap.cpp \ + bmpbuttn.cpp \ + brush.cpp \ + button.cpp \ + checkbox.cpp \ + choice.cpp \ + clipbrd.cpp \ + colour.cpp \ + colordlg.cpp \ + control.cpp \ + combobox.cpp \ + cursor.cpp \ + data.cpp \ + dc.cpp \ + dcclient.cpp \ + dcmemory.cpp \ + dcscreen.cpp \ + dialog.cpp \ + dnd.cpp \ + filedlg.cpp \ + font.cpp \ + fontdlg.cpp \ + frame.cpp \ + gauge.cpp \ + gdiobj.cpp \ + helpxxxx.cpp \ + icon.cpp \ + listbox.cpp \ + joystick.cpp \ + main.cpp \ + mdi.cpp \ + menu.cpp \ + menuitem.cpp \ + metafile.cpp \ + minifram.cpp \ + msgdlg.cpp \ + notebook.cpp \ + palette.cpp \ + pen.cpp \ + print.cpp \ + radiobox.cpp \ + radiobut.cpp \ + region.cpp \ + scrolbar.cpp \ + settings.cpp \ + slider.cpp \ + spinbutt.cpp \ + statbox.cpp \ + statbmp.cpp \ + stattext.cpp \ + taskbar.cpp \ + textctrl.cpp \ + thread.cpp \ + timer.cpp \ + toolbar.cpp \ + utils.cpp \ + utilsexc.cpp \ + wave.cpp \ + window.cpp \ +\ + ../generic/choicdgg.cpp \ + ../generic/colrdlgg.cpp \ + ../generic/dirdlgg.cpp \ + ../generic/fontdlgg.cpp \ + ../generic/gridg.cpp \ + ../generic/imaglist.cpp \ + ../generic/listctrl.cpp \ + ../generic/laywin.cpp \ + ../generic/msgdlgg.cpp \ + ../generic/panelg.cpp \ + ../generic/printps.cpp \ + ../generic/prntdlgg.cpp \ + ../generic/sashwin.cpp \ + ../generic/scrolwin.cpp \ + ../generic/splitter.cpp \ + ../generic/statusbr.cpp \ + ../generic/tabg.cpp \ + ../generic/textdlgg.cpp \ + ../generic/treectrl.cpp + +# If you're not using the generic ones, you +# may wish to define platform-specific ones +# dirdlg.cpp \ +# treectrl.cpp \ +# listctrl.cpp \ +# imaglist.cpp \ +# statusbr.cpp \ + +LIB_C_SRC=\ +\ + ../common/y_tab.c \ + ../common/extended.c + +all: $(WXLIB) + +# Define library objects +OBJECTS=\ + $(LIB_CPP_SRC:.cpp=.o) $(LIB_C_SRC:.c=.o) + +$(WXLIB) : $(OBJECTS) + ar $(AROPTIONS) $@ $(OBJECTS) + $(RANLIB) $@ + +../common/y_tab.$(OBJSUFF): ../common/y_tab.c ../common/lex_yy.c + $(CCLEX) -c $(CFLAGS) -o $@ ../common/y_tab.c + +# Replace lex with flex if you run into compilation +# problems with lex_yy.c. See also note about LEX_SCANNER +# above. +../common/lex_yy.c: ../common/lexer.l + $(LEX) -o../common/lex.yy.c ../common/lexer.l + sed -e "s/BUFSIZ/5000/g" < ../common/lex.yy.c | \ + sed -e "s/yyoutput(c)/void yyoutput(c)/g" | \ + sed -e "s/YYLMAX 200/YYLMAX 5000/g" > ../common/lex_yy.c + /bin/rm -f ../common/lex.yy.c + +# Replace yacc with bison if you run into compilation +# problems with y_tab.c. +../common/y_tab.c: ../common/parser.y + $(YACC) ../common/parser.y + mv y.tab.c ../common/y_tab.c + + +clean: + rm -f $(OBJECTS) $(WXLIB) + diff --git a/src/mac/mdi.cpp b/src/mac/mdi.cpp new file mode 100644 index 0000000000..4869697cd7 --- /dev/null +++ b/src/mac/mdi.cpp @@ -0,0 +1,265 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/menu.h" +#include "wx/settings.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 wxUSE_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/mac/menu.cpp b/src/mac/menu.cpp new file mode 100644 index 0000000000..1fc7c4a229 --- /dev/null +++ b/src/mac/menu.cpp @@ -0,0 +1,571 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/utils.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; + m_clientData = (void*) 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); + } +/* TODO + // 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 *menus[], 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)) + return wxString(m_menus[i]->GetHelpString (Id)); + } + return wxString(""); +} + + diff --git a/src/mac/menuitem.cpp b/src/mac/menuitem.cpp new file mode 100644 index 0000000000..bd2f876a38 --- /dev/null +++ b/src/mac/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/mac/metafile.cpp b/src/mac/metafile.cpp new file mode 100644 index 0000000000..a92874b336 --- /dev/null +++ b/src/mac/metafile.cpp @@ -0,0 +1,239 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/string.h" +#include "wx/dc.h" +#include "wx/stubs/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/mac/minifram.cpp b/src/mac/minifram.cpp new file mode 100644 index 0000000000..4f6f5e5fcb --- /dev/null +++ b/src/mac/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/mac/msgdlg.cpp b/src/mac/msgdlg.cpp new file mode 100644 index 0000000000..775ac8f064 --- /dev/null +++ b/src/mac/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/mac/notebook.cpp b/src/mac/notebook.cpp new file mode 100644 index 0000000000..312dd0f3d3 --- /dev/null +++ b/src/mac/notebook.cpp @@ -0,0 +1,377 @@ +/////////////////////////////////////////////////////////////////////////////// +// 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; + + // 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 one page from the notebook, without deleting the window +bool wxNotebook::RemovePage(int nPage) +{ + wxCHECK( IS_VALID_PAGE(nPage), FALSE ); + + 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, h; + GetSize(&w, &h); + + unsigned int nCount = m_aPages.Count(); + for ( unsigned int 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/mac/palette.cpp b/src/mac/palette.cpp new file mode 100644 index 0000000000..f8db96f8d0 --- /dev/null +++ b/src/mac/palette.cpp @@ -0,0 +1,82 @@ +///////////////////////////////////////////////////////////////////////////// +// 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::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/mac/pen.cpp b/src/mac/pen.cpp new file mode 100644 index 0000000000..1e3ced2a3a --- /dev/null +++ b/src/mac/pen.cpp @@ -0,0 +1,202 @@ +///////////////////////////////////////////////////////////////////////////// +// 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); +} + +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(unsigned char r, unsigned char g, 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/mac/print.cpp b/src/mac/print.cpp new file mode 100644 index 0000000000..61fd6e7e99 --- /dev/null +++ b/src/mac/print.cpp @@ -0,0 +1,82 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/stubs/print.h" +#include "wx/stubs/printdlg.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxPrinter, wxPrinterBase) +IMPLEMENT_CLASS(wxPrintPreview, 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, & m_printData); + return (dialog.ShowModal() == wxID_OK); +} + +bool wxPrinter::Setup(wxWindow *parent) +{ + wxPrintDialog dialog(parent, & m_printData); + dialog.GetPrintData().SetSetupDialog(TRUE); + return (dialog.ShowModal() == wxID_OK); +} + +/* + * Print preview + */ + +wxPrintPreview::wxPrintPreview(wxPrintout *printout, wxPrintout *printoutForPrinting, wxPrintData *data): + wxPrintPreviewBase(printout, printoutForPrinting, data) +{ + DetermineScaling(); +} + +wxPrintPreview::~wxPrintPreview() +{ +} + +bool wxPrintPreview::Print(bool interactive) +{ + if (!m_printPrintout) + return FALSE; + wxPrinter printer(&m_printData); + return printer.Print(m_previewFrame, m_printPrintout, interactive); +} + +void wxPrintPreview::DetermineScaling() +{ + // TODO +} + diff --git a/src/mac/printdlg.cpp b/src/mac/printdlg.cpp new file mode 100644 index 0000000000..eae3b95568 --- /dev/null +++ b/src/mac/printdlg.cpp @@ -0,0 +1,115 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/stubs/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() +{ + m_dialogParent = NULL; + m_printerDC = NULL; +} + +wxPrintDialog::wxPrintDialog(wxWindow *p, wxPrintData* data): + wxDialog() +{ + Create(p, data); +} + +bool wxPrintDialog::Create(wxWindow *p, wxPrintData* data) +{ + m_dialogParent = p; + m_printerDC = NULL; + + if ( data ) + m_printData = *data; + + return TRUE; +} + +wxPrintDialog::~wxPrintDialog() +{ + if (m_printerDC) + delete m_printerDC; +} + +int wxPrintDialog::ShowModal() +{ + // TODO + return wxID_CANCEL; +} + +wxDC *wxPrintDialog::GetPrintDC() +{ + if (m_printerDC) + { + wxDC* dc = m_printerDC; + m_printerDC = NULL; + return dc; + } + 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/mac/radiobox.cpp b/src/mac/radiobox.cpp new file mode 100644 index 0000000000..da582d0e52 --- /dev/null +++ b/src/mac/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/mac/radiobut.cpp b/src/mac/radiobut.cpp new file mode 100644 index 0000000000..65baab38b6 --- /dev/null +++ b/src/mac/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/mac/region.cpp b/src/mac/region.cpp new file mode 100644 index 0000000000..c71d4c605a --- /dev/null +++ b/src/mac/region.cpp @@ -0,0 +1,363 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/region.h" +#include "wx/gdicmn.h" + +#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 + } +}; + + +//----------------------------------------------------------------------------- +// 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/mac/scrolbar.cpp b/src/mac/scrolbar.cpp new file mode 100644 index 0000000000..54df181166 --- /dev/null +++ b/src/mac/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::SetThumbPosition(int viewStart) +{ + // TODO +} + +int wxScrollBar::GetThumbPosition() 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) +{ + SetThumbPosition(event.m_commandInt); + ProcessCommand(event); +} + diff --git a/src/mac/settings.cpp b/src/mac/settings.cpp new file mode 100644 index 0000000000..2beda5c2a6 --- /dev/null +++ b/src/mac/settings.cpp @@ -0,0 +1,176 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 wxColour(); +} + +wxFont wxSystemSettings::GetSystemFont(int index) +{ + // TODO + switch (index) + { + case wxSYS_DEVICE_DEFAULT_FONT: + { + break; + } + case wxSYS_DEFAULT_PALETTE: + { + break; + } + case wxSYS_SYSTEM_FIXED_FONT: + { + break; + } + case wxSYS_SYSTEM_FONT: + { + break; + } + default: + case wxSYS_DEFAULT_GUI_FONT: + { + break; + } + } + + 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/mac/slider.cpp b/src/mac/slider.cpp new file mode 100644 index 0000000000..c9952342a9 --- /dev/null +++ b/src/mac/slider.cpp @@ -0,0 +1,190 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/slider.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl) + +BEGIN_EVENT_TABLE(wxSlider, wxControl) +END_EVENT_TABLE() +#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/mac/spinbutt.cpp b/src/mac/spinbutt.cpp new file mode 100644 index 0000000000..cbea725592 --- /dev/null +++ b/src/mac/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/mac/statbmp.cpp b/src/mac/statbmp.cpp new file mode 100644 index 0000000000..a67c558465 --- /dev/null +++ b/src/mac/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/mac/statbox.cpp b/src/mac/statbox.cpp new file mode 100644 index 0000000000..b239dc738c --- /dev/null +++ b/src/mac/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/mac/stattext.cpp b/src/mac/stattext.cpp new file mode 100644 index 0000000000..3b19c7184d --- /dev/null +++ b/src/mac/stattext.cpp @@ -0,0 +1,60 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#include "wx/app.h" +#include "wx/stattext.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->GetBackgroundColour()) ; + SetForegroundColour(parent->GetForegroundColour()) ; + + if ( id == -1 ) + m_windowId = (int)NewControlId(); + else + m_windowId = id; + + m_windowStyle = style; + + SetFont(parent->GetFont()); + + // TODO + return FALSE; +} + +void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags) +{ + // TODO +} + +void wxStaticText::SetLabel(const wxString& label) +{ + // TODO +} + diff --git a/src/mac/statusbr.cpp b/src/mac/statusbr.cpp new file mode 100644 index 0000000000..dff1ddec34 --- /dev/null +++ b/src/mac/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::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::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::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/mac/tabctrl.cpp b/src/mac/tabctrl.cpp new file mode 100644 index 0000000000..b3b45a72d1 --- /dev/null +++ b/src/mac/tabctrl.cpp @@ -0,0 +1,201 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/control.h" +#include "wx/tabctrl.h" + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTabCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTabCtrl, wxControl) +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/mac/taskbar.cpp b/src/mac/taskbar.cpp new file mode 100644 index 0000000000..5c91250cf0 --- /dev/null +++ b/src/mac/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/mac/textctrl.cpp b/src/mac/textctrl.cpp new file mode 100644 index 0000000000..4171b868b6 --- /dev/null +++ b/src/mac/textctrl.cpp @@ -0,0 +1,447 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#ifndef __WXMAC__ +#include +#include +#else +#include +#endif +#include + +#include "wx/textctrl.h" +#include "wx/settings.h" +#include "wx/filefn.h" +#include "wx/utils.h" + +#if defined(__BORLANDC__) && !defined(__WIN32__) +#include +#else +#ifndef __MWERKS__ +#ifndef __GNUWIN32__ +#include +#endif +#endif +#endif + +#if !USE_SHARED_LIBRARY +IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl) + +BEGIN_EVENT_TABLE(wxTextCtrl, wxControl) + EVT_DROP_FILES(wxTextCtrl::OnDropFiles) +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 +} + +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(); + +#ifndef __WXMAC__ + ifstream input((char*) (const char*) file, ios::nocreate | ios::in); +#else + ifstream input((char*) (const char*) file, ios::in); +#endif + 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/mac/thread.cpp b/src/mac/thread.cpp new file mode 100644 index 0000000000..82fff92ba3 --- /dev/null +++ b/src/mac/thread.cpp @@ -0,0 +1,261 @@ +///////////////////////////////////////////////////////////////////////////// +// 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" +#include "wx/utils.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 wxMUTEX_NO_ERROR; +} + +wxMutexError wxMutex::TryLock() +{ + // TODO + m_locked++; + return wxMUTEX_NO_ERROR; +} + +wxMutexError wxMutex::Unlock() +{ + if (m_locked > 0) + m_locked--; + + // TODO + return wxMUTEX_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 wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Destroy() +{ + // TODO + return wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Pause() +{ + // TODO + return wxTHREAD_NO_ERROR; +} + +wxThreadError wxThread::Resume() +{ + // TODO + return wxTHREAD_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; +} + +/* is this needed somewhere ? +wxThread *wxThread::GetThreadFromID(unsigned long id) +{ + // TODO + return NULL; +} +*/ + +bool wxThread::IsAlive() const +{ + // TODO + return FALSE; +} + +bool wxThread::IsRunning() const +{ + // TODO + return FALSE; +} + +bool wxThread::IsMain() +{ + // TODO + return FALSE; +} + +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 = new wxMutex(); + wxMainMutex->Lock(); + return TRUE; + } + + // Global cleanup + virtual void OnExit() { + wxMainMutex->Unlock(); + delete wxMainMutex; + } +}; + +IMPLEMENT_DYNAMIC_CLASS(wxThreadModule, wxModule) + diff --git a/src/mac/timer.cpp b/src/mac/timer.cpp new file mode 100644 index 0000000000..5262040cf6 --- /dev/null +++ b/src/mac/timer.cpp @@ -0,0 +1,52 @@ +///////////////////////////////////////////////////////////////////////////// +// 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_id = 0; + m_oneShot = FALSE; +} + +wxTimer::~wxTimer() +{ + Stop(); +} + +bool wxTimer::Start(int milliseconds,bool mode) +{ + m_oneShot = mode ; + if (milliseconds <= 0) + return FALSE; + + m_milli = milliseconds; + + // TODO: set the timer going. + return FALSE; +} + +void wxTimer::Stop() +{ + m_id = 0 ; + m_milli = 0 ; +} + + diff --git a/src/mac/toolbar.cpp b/src/mac/toolbar.cpp new file mode 100644 index 0000000000..3cb859e366 --- /dev/null +++ b/src/mac/toolbar.cpp @@ -0,0 +1,145 @@ +///////////////////////////////////////////////////////////////////////////// +// 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 + +#include "wx/wx.h" +#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, wxNullBitmap, 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/mac/treectrl.cpp b/src/mac/treectrl.cpp new file mode 100644 index 0000000000..137a885dbf --- /dev/null +++ b/src/mac/treectrl.cpp @@ -0,0 +1,418 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: treectrl.cpp +// Purpose: wxTreeCtrl. See also Robert's generic 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/stubs/textctrl.h" +#include "wx/stubs/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, wxRect& 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: + break; + + case wxTREE_EXPAND_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/mac/utils.cpp b/src/mac/utils.cpp new file mode 100644 index 0000000000..940bdc21bc --- /dev/null +++ b/src/mac/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 wxUSE_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 // wxUSE_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/mac/utilsexc.cpp b/src/mac/utilsexc.cpp new file mode 100644 index 0000000000..b842d08e90 --- /dev/null +++ b/src/mac/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/mac/wave.cpp b/src/mac/wave.cpp new file mode 100644 index 0000000000..c25681858c --- /dev/null +++ b/src/mac/wave.cpp @@ -0,0 +1,61 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/object.h" +#include "wx/string.h" +#include "wx/stubs/wave.h" + +wxWave::wxWave() + : m_waveData(NULL), m_waveLength(0), m_isResource(FALSE) +{ +} + +wxWave::wxWave(const wxString& sFileName, bool isResource) + : m_waveData(NULL), m_waveLength(0), m_isResource(FALSE) +{ + 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/mac/window.cpp b/src/mac/window.cpp new file mode 100644 index 0000000000..10ec3976dd --- /dev/null +++ b/src/mac/window.cpp @@ -0,0 +1,1292 @@ +///////////////////////////////////////////////////////////////////////////// +// 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/frame.h" + +#include "wx/menuitem.h" +#include "wx/log.h" + +#if wxUSE_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_3DFACE) ; + // m_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW) ; ; + m_foregroundColour = *wxBLACK; + +#if wxUSE_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 wxUSE_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 wxUSE_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_backgroundColour = wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE) ; + m_foregroundColour = *wxBLACK; + + 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 wxUSE_DRAG_AND_DROP + +void wxWindow::SetDropTarget(wxDropTarget *pDropTarget) +{ + if ( m_pDropTarget != 0 ) { + delete m_pDropTarget; + } + + m_pDropTarget = pDropTarget; + if ( m_pDropTarget != 0 ) + { + // TODO + } +} + +#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 wxRect *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; +} + +// 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 wxRect *rect) +{ + // TODO + return; +} + +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) +{ + GetChildren().DeleteObject(child); + child->m_windowParent = NULL; +} + +void wxWindow::DestroyChildren() +{ + 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 + 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) ; +} + +void wxWindow::SetAcceleratorTable(const wxAcceleratorTable& accel) +{ + m_acceleratorTable = accel; +} + +// 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); +} + +/* + * Allocates control IDs + */ + +int wxWindow::NewControlId() +{ + static int s_controlId = 0; + s_controlId ++; + return s_controlId; +} + + -- 2.45.2