Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replaced by stubs files

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@509 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Karsten Ballüder
1998-08-12 09:16:21 +00:00
parent 0acb94947f
commit 01b2eeec59
85 changed files with 9910 additions and 7156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

525
src/qt/app.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: app.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxApp
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,223 +13,60 @@
#pragma implementation "app.h"
#endif
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/gdicmn.h"
#include "wx/utils.h"
#include "wx/postscrp.h"
#include "wx/intl.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/memory.h"
#include "wx/module.h"
#include "unistd.h"
#if USE_WX_RESOURCES
#include "wx/resource.h"
#endif
//-----------------------------------------------------------------------------
// global data
//-----------------------------------------------------------------------------
wxApp *wxTheApp = NULL;
wxAppInitializerFunction wxApp::m_appInitFn = (wxAppInitializerFunction) NULL;
#include <string.h>
#if defined(__WIN95__) && !defined(__GNUWIN32__)
extern char *wxBuffer;
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// local functions
//-----------------------------------------------------------------------------
extern void wxFlushResources(void);
//-----------------------------------------------------------------------------
// global functions
//-----------------------------------------------------------------------------
void wxExit(void)
{
};
bool wxYield(void)
{
return TRUE;
};
//-----------------------------------------------------------------------------
// wxApp
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxApp,wxEvtHandler)
wxApp *wxTheApp = NULL;
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
EVT_IDLE(wxApp::OnIdle)
END_EVENT_TABLE()
wxApp::wxApp()
{
m_topWindow = NULL;
m_exitOnFrameDelete = TRUE;
};
wxApp::~wxApp(void)
{
};
bool wxApp::OnInit(void)
{
return TRUE;
};
bool wxApp::OnInitGui(void)
{
return TRUE;
};
int wxApp::OnRun(void)
{
return MainLoop();
};
bool wxApp::ProcessIdle(void)
{
wxIdleEvent event;
event.SetEventObject( this );
ProcessEvent( event );
return event.MoreRequested();
};
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;
};
bool wxApp::SendIdleEvents(void)
{
bool needMore = FALSE;
wxNode* node = wxTopLevelWindows.First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore;
};
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 ;
};
int wxApp::OnExit(void)
{
return 0;
};
int wxApp::MainLoop(void)
{
return 0;
};
void wxApp::ExitMainLoop(void)
{
};
bool wxApp::Initialized(void)
{
return m_initialized;
};
bool wxApp::Pending(void)
{
return FALSE;
};
void wxApp::Dispatch(void)
{
};
void wxApp::DeletePendingObjects(void)
{
wxNode *node = wxPendingDelete.First();
while (node)
{
wxObject *obj = (wxObject *)node->Data();
delete obj;
if (wxPendingDelete.Member(obj))
delete node;
node = wxPendingDelete.First();
};
};
wxWindow *wxApp::GetTopWindow(void)
{
if (m_topWindow) return m_topWindow;
wxNode *node = wxTopLevelWindows.First();
if (!node) return NULL;
return (wxWindow*)node->Data();
};
void wxApp::SetTopWindow( wxWindow *win )
{
m_topWindow = win;
};
void wxApp::CommonInit(void)
{
/*
#if USE_RESOURCES
(void) wxGetResource("wxWindows", "OsVersion", &wxOsVersion);
#endif
*/
long wxApp::sm_lastMessageTime = 0;
void wxApp::CommonInit()
{
#ifdef __WXMSW__
wxBuffer = new char[1500];
#else
wxBuffer = new char[BUFSIZ + 512];
#endif
wxClassInfo::InitializeClasses();
wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
wxTheColourDatabase->Initialize();
wxInitializeStockObjects();
#if USE_WX_RESOURCES
wxInitializeResourceSystem();
#endif
// For PostScript printing
#if USE_POSTSCRIPT
wxInitializePrintSetupData();
@@ -236,36 +74,55 @@ void wxApp::CommonInit(void)
wxThePrintPaperDatabase->CreateDatabase();
#endif
/*
wxBitmap::InitStandardHandlers();
g_globalCursor = new wxCursor;
*/
wxInitializeStockObjects();
};
void wxApp::CommonCleanUp(void)
{
wxDeleteStockObjects();
wxFlushResources();
};
wxLog *wxApp::CreateLogTarget()
{
return new wxLogGui;
wxModule::RegisterModules();
wxASSERT( wxModule::InitializeModules() == TRUE );
}
//-----------------------------------------------------------------------------
// wxEntry
//-----------------------------------------------------------------------------
void wxApp::CommonCleanUp()
{
wxModule::CleanUpModules();
#if USE_WX_RESOURCES
wxCleanUpResourceSystem();
#endif
wxDeleteStockObjects() ;
// Destroy all GDI lists, etc.
delete wxTheBrushList;
wxTheBrushList = NULL;
delete wxThePenList;
wxThePenList = NULL;
delete wxTheFontList;
wxTheFontList = NULL;
delete wxTheBitmapList;
wxTheBitmapList = NULL;
delete wxTheColourDatabase;
wxTheColourDatabase = NULL;
#if USE_POSTSCRIPT
wxInitializePrintSetupData(FALSE);
delete wxThePrintPaperDatabase;
wxThePrintPaperDatabase = NULL;
#endif
wxBitmap::CleanUpHandlers();
delete[] wxBuffer;
wxBuffer = NULL;
// do it as the very last thing because everything else can log messages
delete wxLog::SetActiveTarget(NULL);
}
int wxEntry( int argc, char *argv[] )
{
wxBuffer = new char[BUFSIZ + 512];
wxClassInfo::InitializeClasses();
#if (WXDEBUG && USE_MEMORY_TRACING) || USE_DEBUG_CONTEXT
@@ -288,13 +145,7 @@ int wxEntry( int argc, char *argv[] )
return 0;
};
wxAppInitializerFunction app_ini = wxApp::GetInitializerFunction();
wxObject *test_app = app_ini();
wxTheApp = (wxApp*) test_app;
// wxTheApp = (wxApp*)( app_ini() );
wxTheApp = (* wxApp::GetInitializerFunction()) ();
};
if (!wxTheApp)
@@ -303,15 +154,14 @@ int wxEntry( int argc, char *argv[] )
return 0;
};
// printf( "Programmstart.\n" );
wxTheApp->argc = argc;
wxTheApp->argv = argv;
// Your init here !!!!
// TODO: your platform-specific initialization.
wxApp::CommonInit();
// GUI-specific initialization, such as creating an app context.
wxTheApp->OnInitGui();
// Here frames insert themselves automatically
@@ -349,18 +199,197 @@ int wxEntry( int argc, char *argv[] )
return retValue;
};
//-----------------------------------------------------------------------------
// main()
//-----------------------------------------------------------------------------
#if defined(AIX) || defined(AIX4) || defined(____HPUX__)
// main in IMPLEMENT_WX_MAIN in IMPLEMENT_APP in app.h
// 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
int main(int argc, char *argv[]) { return wxEntry(argc, argv); }
m_printMode = wxPRINT_POSTSCRIPT;
#endif
m_exitOnFrameDelete = TRUE;
m_auto3D = TRUE;
}
bool wxApp::Initialized()
{
if (GetTopWindow())
return TRUE;
else
return FALSE;
}
int wxApp::MainLoop()
{
m_keepGoing = TRUE;
/* TODO: implement your main loop here, calling ProcessIdle in idle time.
while (m_keepGoing)
{
while (!::PeekMessage(&s_currentMsg, 0, 0, 0, PM_NOREMOVE) &&
ProcessIdle()) {}
if (!DoMessage())
m_keepGoing = FALSE;
}
*/
return 0;
}
// Returns TRUE if more time is needed.
bool wxApp::ProcessIdle()
{
wxIdleEvent event;
event.SetEventObject(this);
ProcessEvent(event);
return event.MoreRequested();
}
void wxApp::ExitMainLoop()
{
m_keepGoing = FALSE;
}
// Is a message/event pending?
bool wxApp::Pending()
{
/* TODO.
*/
return FALSE;
}
// Dispatch a message.
void wxApp::Dispatch()
{
/* TODO.
*/
}
void wxApp::OnIdle(wxIdleEvent& event)
{
static bool inOnIdle = FALSE;
// Avoid recursion (via ProcessEvent default case)
if (inOnIdle)
return;
inOnIdle = TRUE;
// 'Garbage' collection of windows deleted with Close().
DeletePendingObjects();
// flush the logged messages if any
wxLog *pLog = wxLog::GetActiveTarget();
if ( pLog != NULL && pLog->HasPendingMessages() )
pLog->Flush();
// Send OnIdle events to all windows
bool needMore = SendIdleEvents();
if (needMore)
event.RequestMore(TRUE);
inOnIdle = FALSE;
}
// Send idle event to all top-level windows
bool wxApp::SendIdleEvents()
{
bool needMore = FALSE;
wxNode* node = wxTopLevelWindows.First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore;
}
// Send idle event to window and all subwindows
bool wxApp::SendIdleEvents(wxWindow* win)
{
bool needMore = FALSE;
wxIdleEvent event;
event.SetEventObject(win);
win->ProcessEvent(event);
if (event.MoreRequested())
needMore = TRUE;
wxNode* node = win->GetChildren()->First();
while (node)
{
wxWindow* win = (wxWindow*) node->Data();
if (SendIdleEvents(win))
needMore = TRUE;
node = node->Next();
}
return needMore ;
}
void wxApp::DeletePendingObjects()
{
wxNode *node = wxPendingDelete.First();
while (node)
{
wxObject *obj = (wxObject *)node->Data();
delete obj;
if (wxPendingDelete.Member(obj))
delete node;
// Deleting one object may have deleted other pending
// objects, so start from beginning of list again.
node = wxPendingDelete.First();
}
}
wxLog* wxApp::CreateLogTarget()
{
return new wxLogGui;
}
wxWindow* wxApp::GetTopWindow() const
{
if (m_topWindow)
return m_topWindow;
else if (wxTopLevelWindows.Number() > 0)
return (wxWindow*) wxTopLevelWindows.First()->Data();
else
return NULL;
}
void wxExit()
{
wxApp::CommonCleanUp();
/*
* TODO: Exit in some platform-specific way. Not recommended that the app calls this:
* only for emergencies.
*/
}
// Yield to other processes
bool wxYield()
{
/*
* TODO
*/
return TRUE;
}

609
src/qt/bitmap.cpp
View File

@@ -1,237 +1,430 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bitmap.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Purpose: wxBitmap
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// 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
//-----------------------------------------------------------------------------
// wxMask
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMask,wxObject)
wxMask::wxMask(void)
wxBitmapRefData::wxBitmapRefData()
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), const wxColour& WXUNUSED(colour) )
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap), int WXUNUSED(paletteIndex) )
{
};
wxMask::wxMask( const wxBitmap& WXUNUSED(bitmap) )
{
};
wxMask::~wxMask(void)
{
};
//-----------------------------------------------------------------------------
// wxBitmap
//-----------------------------------------------------------------------------
class wxBitmapRefData: public wxObjectRefData
{
public:
wxBitmapRefData(void);
~wxBitmapRefData(void);
wxMask *m_mask;
int m_width;
int m_height;
int m_bpp;
wxPalette *m_palette;
};
wxBitmapRefData::wxBitmapRefData(void)
{
m_mask = NULL;
m_width = 0;
m_height = 0;
m_bpp = 0;
m_palette = NULL;
};
wxBitmapRefData::~wxBitmapRefData(void)
{
if (m_mask) delete m_mask;
if (m_palette) delete m_palette;
};
//-----------------------------------------------------------------------------
#define M_BMPDATA ((wxBitmapRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap,wxGDIObject)
wxBitmap::wxBitmap(void)
{
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( int width, int height, int depth )
{
m_refData = new wxBitmapRefData();
M_BMPDATA->m_mask = NULL;
M_BMPDATA->m_width = width;
M_BMPDATA->m_height = height;
M_BMPDATA->m_bpp = depth;
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( char **WXUNUSED(bits) )
{
m_refData = new wxBitmapRefData();
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxBitmap& bmp )
{
Ref( bmp );
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxBitmap* bmp )
{
if (bmp) Ref( *bmp );
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
};
wxBitmap::wxBitmap( const wxString &filename, int type )
{
LoadFile( filename, type );
};
wxBitmap::wxBitmap( const char WXUNUSED(bits)[], int width, int height, int WXUNUSED(depth))
{
m_refData = new wxBitmapRefData();
M_BMPDATA->m_mask = NULL;
M_BMPDATA->m_width = width;
M_BMPDATA->m_height = height;
M_BMPDATA->m_bpp = 1;
if (wxTheBitmapList) wxTheBitmapList->AddBitmap(this);
m_ok = FALSE;
m_width = 0;
m_height = 0;
m_depth = 0;
m_quality = 0;
m_numColors = 0;
m_bitmapMask = NULL;
}
wxBitmap::~wxBitmap(void)
{
if (wxTheBitmapList) wxTheBitmapList->DeleteObject(this);
};
wxBitmap& wxBitmap::operator = ( const wxBitmap& bmp )
{
if (*this == bmp) return (*this);
Ref( bmp );
return *this;
};
bool wxBitmap::operator == ( const wxBitmap& bmp )
{
return m_refData == bmp.m_refData;
};
bool wxBitmap::operator != ( const wxBitmap& bmp )
{
return m_refData != bmp.m_refData;
};
bool wxBitmap::Ok(void) const
{
return m_refData != NULL;
};
int wxBitmap::GetHeight(void) const
{
if (!Ok()) return 0;
return M_BMPDATA->m_height;
};
int wxBitmap::GetWidth(void) const
wxBitmapRefData::~wxBitmapRefData()
{
if (!Ok()) return 0;
return M_BMPDATA->m_width;
};
/*
* TODO: delete the bitmap data here.
*/
int wxBitmap::GetDepth(void) const
{
if (!Ok()) return 0;
return M_BMPDATA->m_bpp;
};
if (m_bitmapMask)
delete m_bitmapMask;
m_bitmapMask = NULL;
}
void wxBitmap::SetHeight( int height )
{
if (!Ok()) return;
M_BMPDATA->m_height = height;
};
wxList wxBitmap::sm_handlers;
void wxBitmap::SetWidth( int width )
wxBitmap::wxBitmap()
{
if (!Ok()) return;
M_BMPDATA->m_width = width;
};
m_refData = NULL;
void wxBitmap::SetDepth( int depth )
{
if (!Ok()) return;
M_BMPDATA->m_bpp = depth;
};
if ( wxTheBitmapList )
wxTheBitmapList->AddBitmap(this);
}
wxMask *wxBitmap::GetMask(void) const
wxBitmap::~wxBitmap()
{
if (!Ok()) return NULL;
return M_BMPDATA->m_mask;
};
if (wxTheBitmapList)
wxTheBitmapList->DeleteObject(this);
}
void wxBitmap::SetMask( wxMask *mask )
wxBitmap::wxBitmap(const char bits[], int the_width, int the_height, int no_bits)
{
if (!Ok()) return;
if (M_BMPDATA->m_mask) delete M_BMPDATA->m_mask;
M_BMPDATA->m_mask = mask;
};
m_refData = new wxBitmapRefData;
void wxBitmap::Resize( int WXUNUSED(height), int WXUNUSED(width) )
{
if (!Ok()) return;
};
M_BITMAPDATA->m_width = the_width ;
M_BITMAPDATA->m_height = the_height ;
M_BITMAPDATA->m_depth = no_bits ;
M_BITMAPDATA->m_numColors = 0;
bool wxBitmap::SaveFile( const wxString &WXUNUSED(name), int WXUNUSED(type),
wxPalette *WXUNUSED(palette) )
{
return FALSE;
};
/* TODO: create the bitmap from data */
bool wxBitmap::LoadFile( const wxString &WXUNUSED(name), int WXUNUSED(type) )
{
return FALSE;
};
wxPalette *wxBitmap::GetPalette(void) const
{
if (!Ok()) return NULL;
return M_BMPDATA->m_palette;
};
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);
*/
}

111
src/qt/bmpbuttn.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: bmpbuttn.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxBitmapButton
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,65 +15,51 @@
#include "wx/bmpbuttn.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
#endif
class wxBitmapButton;
//-----------------------------------------------------------------------------
// wxBitmapButton
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton,wxControl)
wxBitmapButton::wxBitmapButton(void)
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);
wxBitmapButton::wxBitmapButton( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
m_backgroundColour = parent->GetDefaultBackgroundColour() ;
m_foregroundColour = parent->GetDefaultForegroundColour() ;
m_windowStyle = style;
m_marginX = 0;
m_marginY = 0;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
if (id == -1)
m_windowId = NewControlId();
else
m_windowId = id;
if ( width == -1 && bitmap.Ok())
width = bitmap.GetWidth() + 2*m_marginX;
if ( height == -1 && bitmap.Ok())
height = bitmap.GetHeight() + 2*m_marginY;
/* TODO: create bitmap button
*/
return FALSE;
}
void wxBitmapButton::SetBitmapLabel(const wxBitmap& bitmap)
{
Create( parent, id, bitmap, pos, size, style, name );
};
m_buttonBitmap = bitmap;
}
bool wxBitmapButton::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
m_needParent = TRUE;
wxSize newSize = size;
PreCreation( parent, id, pos, newSize, style, name );
m_bitmap = bitmap;
m_label = "";
if (newSize.x == -1) newSize.x = m_bitmap.GetHeight()+10;
if (newSize.y == -1) newSize.y = m_bitmap.GetWidth()+10;
SetSize( newSize.x, newSize.y );
PostCreation();
Show( TRUE );
return TRUE;
};
void wxBitmapButton::SetDefault(void)
{
};
void wxBitmapButton::SetLabel( const wxString &label )
{
wxControl::SetLabel( label );
};
wxString wxBitmapButton::GetLabel(void) const
{
return wxControl::GetLabel();
};

212
src/qt/brush.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: brush.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxBrush
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -12,121 +13,150 @@
#pragma implementation "brush.h"
#endif
#include "wx/setup.h"
#include "wx/utils.h"
#include "wx/brush.h"
//-----------------------------------------------------------------------------
// wxBrush
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
#endif
class wxBrushRefData: public wxObjectRefData
wxBrushRefData::wxBrushRefData()
{
public:
wxBrushRefData(void);
int m_style;
wxBitmap m_stipple;
wxColour m_colour;
};
m_style = wxSOLID;
// TODO: null data
}
wxBrushRefData::wxBrushRefData(void)
wxBrushRefData::wxBrushRefData(const wxBrushRefData& data)
{
m_style = 0;
};
m_style = data.m_style;
m_stipple = data.m_stipple;
m_colour = data.m_colour;
/* TODO: null data
m_hBrush = 0;
*/
}
//-----------------------------------------------------------------------------
#define M_BRUSHDATA ((wxBrushRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxBrush,wxGDIObject)
wxBrush::wxBrush(void)
wxBrushRefData::~wxBrushRefData()
{
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
// TODO: delete data
}
wxBrush::wxBrush( const wxColour &colour, int style )
// Brushes
wxBrush::wxBrush()
{
m_refData = new wxBrushRefData();
M_BRUSHDATA->m_style = style;
M_BRUSHDATA->m_colour = colour;
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::wxBrush( const wxString &colourName, int style )
wxBrush::~wxBrush()
{
m_refData = new wxBrushRefData();
M_BRUSHDATA->m_style = style;
M_BRUSHDATA->m_colour = colourName;
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
if ( wxTheBrushList )
wxTheBrushList->RemoveBrush(this);
}
wxBrush::wxBrush( const wxBitmap &stippleBitmap )
wxBrush::wxBrush(const wxColour& col, int Style)
{
m_refData = new wxBrushRefData();
M_BRUSHDATA->m_style = wxSTIPPLE;
M_BRUSHDATA->m_colour = *wxBLACK;
M_BRUSHDATA->m_stipple = stippleBitmap;
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
m_refData = new wxBrushRefData;
wxBrush::wxBrush( const wxBrush &brush )
M_BRUSHDATA->m_colour = col;
M_BRUSHDATA->m_style = Style;
RealizeResource();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::wxBrush(const wxString& col, int Style)
{
Ref( brush );
if (wxTheBrushList) wxTheBrushList->AddBrush( this );
};
m_refData = new wxBrushRefData;
wxBrush::wxBrush( const wxBrush *brush )
// Implicit conversion from string to wxColour via colour database
M_BRUSHDATA->m_colour = col;
M_BRUSHDATA->m_style = Style;
RealizeResource();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
wxBrush::wxBrush(const wxBitmap& stipple)
{
if (brush) Ref( *brush );
if (wxTheBrushList) wxTheBrushList->Append( this );
};
m_refData = new wxBrushRefData;
wxBrush::~wxBrush(void)
M_BRUSHDATA->m_style = wxSTIPPLE;
M_BRUSHDATA->m_stipple = stipple;
RealizeResource();
if ( wxTheBrushList )
wxTheBrushList->AddBrush(this);
}
void wxBrush::Unshare()
{
if (wxTheBrushList) wxTheBrushList->RemoveBrush( this );
};
// Don't change shared data
if (!m_refData)
{
m_refData = new wxBrushRefData();
}
else
{
wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
wxBrush& wxBrush::operator = ( const wxBrush& brush )
void wxBrush::SetColour(const wxColour& col)
{
if (*this == brush) return (*this);
Ref( brush );
return *this;
};
bool wxBrush::operator == ( const wxBrush& brush )
Unshare();
M_BRUSHDATA->m_colour = col;
RealizeResource();
}
void wxBrush::SetColour(const wxString& col)
{
return m_refData == brush.m_refData;
};
Unshare();
bool wxBrush::operator != ( const wxBrush& brush )
M_BRUSHDATA->m_colour = col;
RealizeResource();
}
void wxBrush::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
return m_refData != brush.m_refData;
};
Unshare();
bool wxBrush::Ok(void) const
M_BRUSHDATA->m_colour.Set(r, g, b);
RealizeResource();
}
void wxBrush::SetStyle(int Style)
{
return ((m_refData) && M_BRUSHDATA->m_colour.Ok());
};
Unshare();
int wxBrush::GetStyle(void) const
M_BRUSHDATA->m_style = Style;
RealizeResource();
}
void wxBrush::SetStipple(const wxBitmap& Stipple)
{
return M_BRUSHDATA->m_style;
};
Unshare();
wxColour &wxBrush::GetColour(void) const
M_BRUSHDATA->m_stipple = Stipple;
RealizeResource();
}
void wxBrush::RealizeResource()
{
return M_BRUSHDATA->m_colour;
};
wxBitmap *wxBrush::GetStipple(void) const
{
return &M_BRUSHDATA->m_stipple;
};
// TODO: create the brush
}

96
src/qt/button.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: button.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxButton
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,48 +15,61 @@
#include "wx/button.h"
//-----------------------------------------------------------------------------
// classes
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
#endif
class wxButton;
// Button
//-----------------------------------------------------------------------------
// wxButton
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxButton,wxControl)
//-----------------------------------------------------------------------------
wxButton::wxButton(void)
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;
wxButton::wxButton( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
parent->AddChild((wxButton *)this);
bool wxButton::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
return TRUE;
};
if (id == -1)
m_windowId = NewControlId();
else
m_windowId = id;
void wxButton::SetDefault(void)
{
};
// TODO: create button
void wxButton::SetLabel( const wxString &label )
{
wxControl::SetLabel( label );
};
return FALSE;
}
wxString wxButton::GetLabel(void) const
void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags)
{
return wxControl::GetLabel();
};
// 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);
}

123
src/qt/checkbox.cpp
View File

@@ -1,50 +1,117 @@
/////////////////////////////////////////////////////////////////////////////
// Name: checkbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxCheckBox
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox,wxControl)
wxCheckBox::wxCheckBox(void)
// 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;
wxCheckBox::wxCheckBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
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)
{
Create( parent, id, label, pos, size, style, name );
};
// TODO
}
bool wxCheckBox::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
return TRUE;
};
// TODO
}
void wxCheckBox::SetValue( bool WXUNUSED(state) )
void wxCheckBox::SetValue(bool val)
{
};
// TODO
}
bool wxCheckBox::GetValue(void) const
bool wxCheckBox::GetValue() const
{
return FALSE;
};
// 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;
}

150
src/qt/choice.cpp
View File

@@ -1,97 +1,119 @@
/////////////////////////////////////////////////////////////////////////////
// Name: choice.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxChoice
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
#endif
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxChoice,wxControl)
wxChoice::wxChoice(void)
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;
wxChoice::wxChoice( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
{
Create( parent, id, pos, size, n, choices, style, name );
};
if (parent) parent->AddChild(this);
bool wxChoice::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
{
return TRUE;
};
void wxChoice::Append( const wxString &WXUNUSED(item) )
{
};
void wxChoice::Clear(void)
{
};
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
int wxChoice::FindString( const wxString &WXUNUSED(string) ) const
{
return -1;
};
// TODO: create choice control
return FALSE;
}
int wxChoice::GetColumns(void) const
void wxChoice::Append(const wxString& item)
{
return 1;
};
// TODO
m_noStrings ++;
}
int wxChoice::GetSelection(void)
void wxChoice::Delete(int n)
{
return -1;
};
// TODO
m_noStrings --;
}
wxString wxChoice::GetString( int WXUNUSED(n) ) const
void wxChoice::Clear()
{
return "";
};
// TODO
m_noStrings = 0;
}
wxString wxChoice::GetStringSelection(void) const
int wxChoice::GetSelection() const
{
return "";
};
// TODO
return 0;
}
int wxChoice::Number(void) const
void wxChoice::SetSelection(int n)
{
return 0;
};
// TODO
}
void wxChoice::SetColumns( int WXUNUSED(n) )
int wxChoice::FindString(const wxString& s) const
{
};
// TODO
return 0;
}
void wxChoice::SetSelection( int WXUNUSED(n) )
wxString wxChoice::GetString(int n) const
{
};
// TODO
return wxString("");
}
void wxChoice::SetStringSelection( const wxString &string )
void wxChoice::SetSize(int x, int y, int width, int height, int sizeFlags)
{
int n = FindString( string );
if (n != -1) SetSelection( n );
};
// 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);
}

238
src/qt/colour.cpp
View File

@@ -1,164 +1,126 @@
/////////////////////////////////////////////////////////////////////////////
// Name: colour.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxColour
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
#endif
class wxColourRefData: public wxObjectRefData
// Colour
wxColour::wxColour ()
{
public:
wxColourRefData(void);
~wxColourRefData(void);
void FreeColour(void);
bool m_hasPixel;
friend wxColour;
};
m_isInit = FALSE;
m_red = m_blue = m_green = 0;
/* TODO
m_pixel = 0;
*/
}
wxColourRefData::wxColourRefData(void)
wxColour::wxColour (unsigned char r, unsigned char g, unsigned char b)
{
m_hasPixel = FALSE;
};
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}
wxColourRefData::~wxColourRefData(void)
wxColour::wxColour (const wxColour& col)
{
FreeColour();
};
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;
*/
}
void wxColourRefData::FreeColour(void)
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;
}
//-----------------------------------------------------------------------------
#define M_COLDATA ((wxColourRefData *)m_refData)
#define SHIFT (8*(sizeof(short int)-sizeof(char)))
IMPLEMENT_DYNAMIC_CLASS(wxColour,wxGDIObject)
wxColour::wxColour(void)
wxColour::wxColour (const wxString& col)
{
};
wxColour *the_colour = wxTheColourDatabase->FindColour (col);
if (the_colour)
{
m_red = the_colour->Red ();
m_green = the_colour->Green ();
m_blue = the_colour->Blue ();
m_isInit = TRUE;
}
else
{
m_red = 0;
m_green = 0;
m_blue = 0;
m_isInit = FALSE;
}
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}
wxColour::wxColour( char WXUNUSED(red), char WXUNUSED(green), char WXUNUSED(blue) )
wxColour::~wxColour ()
{
m_refData = new wxColourRefData();
};
wxColour::wxColour( const wxString &colourName )
}
wxColour& wxColour::operator = (const wxString& col)
{
wxNode *node = NULL;
if ( (wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
{
wxColour *col = (wxColour*)node->Data();
UnRef();
if (col) Ref( *col );
}
else
{
m_refData = new wxColourRefData();
};
};
wxColour *the_colour = wxTheColourDatabase->FindColour (col);
if (the_colour)
{
m_red = the_colour->Red ();
m_green = the_colour->Green ();
m_blue = the_colour->Blue ();
m_isInit = TRUE;
}
else
{
m_red = 0;
m_green = 0;
m_blue = 0;
m_isInit = FALSE;
}
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
return (*this);
}
wxColour::wxColour( const wxColour& col )
{
Ref( col );
};
wxColour::wxColour( const wxColour* col )
{
if (col) Ref( *col );
};
wxColour::~wxColour(void)
void wxColour::Set (unsigned char r, unsigned char g, unsigned char b)
{
};
wxColour& wxColour::operator = ( const wxColour& col )
{
if (*this == col) return (*this);
Ref( col );
return *this;
};
wxColour& wxColour::operator = ( const wxString& colourName )
{
UnRef();
wxNode *node = NULL;
if ((wxTheColourDatabase) && (node = wxTheColourDatabase->Find(colourName)) )
{
wxColour *col = (wxColour*)node->Data();
if (col) Ref( *col );
}
else
{
m_refData = new wxColourRefData();
};
return *this;
};
bool wxColour::operator == ( const wxColour& col )
{
return m_refData == col.m_refData;
};
bool wxColour::operator != ( const wxColour& col)
{
return m_refData != col.m_refData;
};
void wxColour::Set( const unsigned char WXUNUSED(red), const unsigned char WXUNUSED(green),
const unsigned char WXUNUSED(blue) )
{
UnRef();
m_refData = new wxColourRefData();
};
unsigned char wxColour::Red(void) const
{
if (!Ok()) return 0;
return 0;
};
unsigned char wxColour::Green(void) const
{
if (!Ok()) return 0;
return 0;
};
unsigned char wxColour::Blue(void) const
{
if (!Ok()) return 0;
return 0;
};
bool wxColour::Ok(void) const
{
return (m_refData);
return 0;
};
int wxColour::GetPixel(void)
{
if (!Ok()) return 0;
return 0;
};
m_red = r;
m_green = g;
m_blue = b;
m_isInit = TRUE;
/* TODO
m_pixel = PALETTERGB (m_red, m_green, m_blue);
*/
}

185
src/qt/combobox.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: combobox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxComboBox class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,136 +15,102 @@
#include "wx/combobox.h"
//-----------------------------------------------------------------------------
// wxComboBox
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
#endif
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxComboBox,wxControl)
bool wxComboBox::Create(wxWindow *parent, wxWindowID id, const wxString& value,
const wxPoint& pos, const wxSize& size, int n, const wxString choices[],
long style, const wxString& name )
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)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_noStrings = n;
m_windowStyle = style;
void wxComboBox::Clear(void)
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::Append( const wxString &item )
void wxComboBox::SetValue(const wxString& value)
{
Append( item, (char*)NULL );
};
// TODO
}
void wxComboBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
// Clipboard operations
void wxComboBox::Copy()
{
};
// TODO
}
void wxComboBox::Delete( int WXUNUSED(n) )
void wxComboBox::Cut()
{
};
// TODO
}
int wxComboBox::FindString( const wxString &WXUNUSED(item) )
void wxComboBox::Paste()
{
return -1;
};
// TODO
}
char* wxComboBox::GetClientData( int WXUNUSED(n) )
void wxComboBox::SetEditable(bool editable)
{
return (char*)NULL;
};
// TODO
}
void wxComboBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
void wxComboBox::SetInsertionPoint(long pos)
{
};
// TODO
}
int wxComboBox::GetSelection(void) const
void wxComboBox::SetInsertionPointEnd()
{
return -1;
};
// TODO
}
wxString wxComboBox::GetString( int WXUNUSED(n) ) const
long wxComboBox::GetInsertionPoint() const
{
return "";
};
// TODO
return 0;
}
wxString wxComboBox::GetStringSelection(void) const
long wxComboBox::GetLastPosition() const
{
return "";
};
// TODO
return 0;
}
int wxComboBox::Number(void) const
void wxComboBox::Replace(long from, long to, const wxString& value)
{
return 0;
};
// TODO
}
void wxComboBox::SetSelection( int WXUNUSED(n) )
void wxComboBox::Remove(long from, long to)
{
};
// TODO
}
void wxComboBox::SetStringSelection( const wxString &string )
void wxComboBox::SetSelection(long from, long to)
{
int res = FindString( string );
if (res == -1) return;
SetSelection( res );
};
// TODO
}
wxString wxComboBox::GetValue(void) const
{
return "";
};
void wxComboBox::SetValue( const wxString& WXUNUSED(value) )
{
};
void wxComboBox::Copy(void)
{
};
void wxComboBox::Cut(void)
{
};
void wxComboBox::Paste(void)
{
};
void wxComboBox::SetInsertionPoint( long WXUNUSED(pos) )
{
};
void wxComboBox::SetInsertionPointEnd(void)
{
};
long wxComboBox::GetInsertionPoint(void) const
{
return 0;
};
long wxComboBox::GetLastPosition(void) const
{
return 0;
};
void wxComboBox::Replace( long WXUNUSED(from), long WXUNUSED(to), const wxString& WXUNUSED(value) )
{
};
void wxComboBox::Remove(long WXUNUSED(from), long WXUNUSED(to) )
{
};
void wxComboBox::SetSelection( long WXUNUSED(from), long WXUNUSED(to) )
{
};
void wxComboBox::SetEditable( bool WXUNUSED(editable) )
{
};

136
src/qt/control.cpp
View File

@@ -1,11 +1,12 @@
/////////////////////////////////////////////////////////////////////////////
// Name: control.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Purpose: wxControl class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
@@ -14,46 +15,97 @@
#include "wx/control.h"
//-----------------------------------------------------------------------------
// wxControl
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
IMPLEMENT_DYNAMIC_CLASS(wxControl,wxWindow)
wxControl::wxControl(void)
{
};
wxControl::wxControl( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name ) :
wxWindow( parent, id, pos, size, style, name )
{
};
void wxControl::Command( wxCommandEvent &WXUNUSED(event) )
{
};
void wxControl::SetLabel( const wxString &label )
{
for ( const char *pc = label; *pc != '\0'; pc++ ) {
if ( *pc == '&' ) {
pc++; // skip it
#if 0 // it would be unused anyhow for now - kbd interface not done yet
if ( *pc != '&' )
m_chAccel = *pc;
BEGIN_EVENT_TABLE(wxControl, wxWindow)
END_EVENT_TABLE()
#endif
}
m_label << *pc;
}
};
wxString wxControl::GetLabel(void) const
// Item members
wxControl::wxControl()
{
return m_label;
};
m_backgroundColour = *wxWHITE;
m_foregroundColour = *wxBLACK;
m_callback = 0;
}
wxControl::~wxControl()
{
// If we delete an item, we should initialize the parent panel,
// because it could now be invalid.
wxWindow *parent = (wxWindow *)GetParent();
if (parent)
{
if (parent->GetDefaultItem() == this)
parent->SetDefaultItem(NULL);
}
}
void wxControl::SetLabel(const wxString& label)
{
// TODO
}
wxString wxControl::GetLabel() const
{
// TODO
return wxString("");
}
/*
* Allocates control IDs within the appropriate range
*/
int NewControlId()
{
static int s_controlId = 0;
s_controlId ++;
return s_controlId;
}
void wxControl::ProcessCommand (wxCommandEvent & event)
{
// Tries:
// 1) A callback function (to become obsolete)
// 2) OnCommand, starting at this window and working up parent hierarchy
// 3) OnCommand then calls ProcessEvent to search the event tables.
if (m_callback)
{
(void) (*(m_callback)) (*this, event);
}
else
{
GetEventHandler()->OnCommand(*this, event);
}
}
void wxControl::SetClientSize (int width, int height)
{
SetSize (-1, -1, width, height);
}
void wxControl::Centre (int direction)
{
int x, y, width, height, panel_width, panel_height, new_x, new_y;
wxWindow *parent = (wxWindow *) GetParent ();
if (!parent)
return;
parent->GetClientSize (&panel_width, &panel_height);
GetSize (&width, &height);
GetPosition (&x, &y);
new_x = x;
new_y = y;
if (direction & wxHORIZONTAL)
new_x = (int) ((panel_width - width) / 2);
if (direction & wxVERTICAL)
new_y = (int) ((panel_height - height) / 2);
SetSize (new_x, new_y, width, height);
}

248
src/qt/cursor.cpp
View File

@@ -1,120 +1,186 @@
/////////////////////////////////////////////////////////////////////////////
// Name: cursor.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxCursor
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
#endif
class wxCursorRefData: public wxObjectRefData
wxCursorRefData::wxCursorRefData()
{
public:
wxCursorRefData(void);
~wxCursorRefData(void);
};
m_width = 32; m_height = 32;
wxCursorRefData::wxCursorRefData(void)
/* TODO
m_hCursor = 0 ;
*/
}
wxCursorRefData::~wxCursorRefData()
{
};
// TODO: destroy cursor
}
wxCursorRefData::~wxCursorRefData(void)
// Cursors
wxCursor::wxCursor()
{
};
}
//-----------------------------------------------------------------------------
#define M_CURSORDATA ((wxCursorRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxCursor,wxObject)
wxCursor::wxCursor(void)
wxCursor::wxCursor(const char WXUNUSED(bits)[], int WXUNUSED(width), int WXUNUSED(height),
int WXUNUSED(hotSpotX), int WXUNUSED(hotSpotY), const char WXUNUSED(maskBits)[])
{
};
}
wxCursor::wxCursor( int WXUNUSED(cursorId) )
wxCursor::wxCursor(const wxString& cursor_file, long flags, int hotSpotX, int hotSpotY)
{
m_refData = new wxCursorRefData();
};
m_refData = new wxIconRefData;
wxCursor::wxCursor( const wxCursor &cursor )
// TODO: create cursor from a file
}
// Cursors by stock number
wxCursor::wxCursor(int cursor_type)
{
Ref( cursor );
};
m_refData = new wxIconRefData;
wxCursor::wxCursor( const wxCursor *cursor )
/* 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()
{
UnRef();
if (cursor) Ref( *cursor );
};
}
wxCursor::~wxCursor(void)
// Global cursor setting
void wxSetCursor(const wxCursor& cursor)
{
};
wxCursor& wxCursor::operator = ( const wxCursor& cursor )
{
if (*this == cursor) return (*this);
Ref( cursor );
return *this;
};
bool wxCursor::operator == ( const wxCursor& cursor )
{
return m_refData == cursor.m_refData;
};
bool wxCursor::operator != ( const wxCursor& cursor )
{
return m_refData != cursor.m_refData;
};
bool wxCursor::Ok(void) const
{
return TRUE;
};
//-----------------------------------------------------------------------------
// busy cursor routines
//-----------------------------------------------------------------------------
bool g_isBusy = FALSE;
void wxEndBusyCursor(void)
{
g_isBusy = FALSE;
};
void wxBeginBusyCursor( wxCursor *WXUNUSED(cursor) )
{
g_isBusy = TRUE;
};
bool wxIsBusy(void)
{
return g_isBusy;
};
void wxSetCursor( const wxCursor& cursor )
{
extern wxCursor *g_globalCursor;
if (g_globalCursor) (*g_globalCursor) = cursor;
if (cursor.Ok()) {};
};
// TODO (optional on platforms with no global cursor)
}

600
src/qt/data.cpp
View File

@@ -1,32 +1,23 @@
/////////////////////////////////////////////////////////////////////////////
// Name: data.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: Various data
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
// #pragma implementation
#pragma implementation
#endif
#include "wx/wx.h"
#define _MAXPATHLEN 500
// Used for X resources
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>
wxList wxResourceCache(wxKEY_STRING);
XrmDatabase wxResourceDatabase;
// Useful buffer, initialized in wxCommonInit
// Useful buffer, initialized in CommonInit
char *wxBuffer = NULL;
// Windows List
@@ -35,44 +26,23 @@ wxList wxTopLevelWindows;
// List of windows pending deletion
wxList wxPendingDelete;
// Current cursor, in order to hang on to
// cursor handle when setting the cursor globally
wxCursor *g_globalCursor = NULL;
// Don't allow event propagation during drag
bool g_blockEventsOnDrag = FALSE;
// Message Strings for Internationalization
char **wx_msg_str = (char**)NULL;
// Custom OS version, as optionally placed in wx.ini/.wxrc
// Currently this can be Win95, Windows, Win32s, WinNT.
// For some systems, you can't tell until run-time what services you
// have. See wxGetOsVersion, which uses this string if present.
char *wxOsVersion = NULL;
// For printing several pages
int wxPageNumber;
wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
// GDI Object Lists
wxBrushList *wxTheBrushList = NULL;
wxPenList *wxThePenList = NULL;
wxFontList *wxTheFontList = NULL;
wxColourDatabase *wxTheColourDatabase = NULL;
wxBrushList *wxTheBrushList = NULL;
wxPenList *wxThePenList = NULL;
wxFontList *wxTheFontList = NULL;
wxBitmapList *wxTheBitmapList = NULL;
// X only font names
// wxFontNameDirectory wxTheFontNameDirectory;
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;
@@ -96,7 +66,6 @@ wxBrush *wxLIGHT_GREY_BRUSH;
wxColour *wxBLACK;
wxColour *wxWHITE;
wxColour *wxGREY; // Robert Roebling
wxColour *wxRED;
wxColour *wxBLUE;
wxColour *wxGREEN;
@@ -108,14 +77,15 @@ wxCursor *wxHOURGLASS_CURSOR = NULL;
wxCursor *wxCROSS_CURSOR = NULL;
// 'Null' objects
wxAcceleratorTable wxNullAcceleratorTable;
wxBitmap wxNullBitmap;
wxIcon wxNullIcon;
wxIcon wxNullIcon;
wxCursor wxNullCursor;
wxPen wxNullPen;
wxBrush wxNullBrush;
wxPalette wxNullPalette;
wxFont wxNullFont;
wxColour wxNullColour;
wxPalette wxNullPalette;
// Default window names
const char *wxButtonNameStr = "button";
@@ -157,391 +127,10 @@ const char *wxFatalErrorStr = "wxWindows Fatal Error";
const char *wxFloatToStringStr = "%.2f";
const char *wxDoubleToStringStr = "%.2f";
#ifdef wx_msw
const char *wxUserResourceStr = "TEXT";
#endif
#if USE_SHARED_LIBRARY
/*
* For wxWindows to be made into a dynamic library (e.g. Sun),
* all IMPLEMENT_... macros must be in one place.
* But normally, the definitions are in the appropriate places.
*/
// Hand-coded IMPLEMENT... macro for wxObject (define static data)
wxClassInfo wxObject::classwxObject("wxObject", NULL, NULL, sizeof(wxObject), NULL);
wxClassInfo *wxClassInfo::first = NULL;
#include "wx/button.h"
#include "wx/bmpbuttn.h"
IMPLEMENT_DYNAMIC_CLASS(wxButton, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapButton, wxButton)
#include "wx/checkbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxCheckBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapCheckBox, wxCheckBox)
#include "wx/choice.h"
IMPLEMENT_DYNAMIC_CLASS(wxChoice, wxControl)
#if USE_CLIPBOARD
#include "wx/clipbrd.h"
IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
#endif
#if USE_COMBOBOX
#include "wx/combobox.h"
IMPLEMENT_DYNAMIC_CLASS(wxComboBox, wxControl)
#endif
#include "wx/dc.h"
#include "wx/dcmemory.h"
#include "wx/dcclient.h"
#include "wx/dcscreen.h"
IMPLEMENT_ABSTRACT_CLASS(wxDC, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxWindowDC)
#if defined(wx_msw)
#include "wx/dcprint.h"
IMPLEMENT_CLASS(wxPrinterDC, wxDC)
#endif
#include "wx/dialog.h"
IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxWindow)
#include "wx/frame.h"
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
#include "wx/mdi.h"
IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame, wxFrame)
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow, wxWindow)
#include "wx/cmndata.h"
IMPLEMENT_DYNAMIC_CLASS(wxColourData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxFontData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintData, wxObject)
#include "wx/colordlg.h"
#include "wx/fontdlg.h"
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
#include "wx/generic/colordlg.h"
#include "wx/generic/fontdlg.h"
IMPLEMENT_DYNAMIC_CLASS(wxGenericColourDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxGenericFontDialog, wxDialog)
#endif
// X defines wxColourDialog to be wxGenericColourDialog
#ifndef wx_x
IMPLEMENT_DYNAMIC_CLASS(wxColourDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxFontDialog, wxDialog)
#endif
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/font.h"
#include "wx/palette.h"
#include "wx/icon.h"
#include "wx/cursor.h"
IMPLEMENT_DYNAMIC_CLASS(wxColour, wxObject)
IMPLEMENT_CLASS(wxColourDatabase, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxFontList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxPenList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxBrushList, wxList)
IMPLEMENT_DYNAMIC_CLASS(wxBitmapList, wxList)
/*
#if (!USE_TYPEDEFS)
IMPLEMENT_DYNAMIC_CLASS(wxPoint, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxIntPoint, wxObject)
#endif
*/
#if defined(wx_x) || (defined(wx_msw) && USE_PORTABLE_FONTS_IN_MSW)
IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject)
#endif
#include "wx/hash.h"
IMPLEMENT_DYNAMIC_CLASS(wxHashTable, wxObject)
#include "wx/help.h"
IMPLEMENT_DYNAMIC_CLASS(wxHelpInstance, wxClient)
IMPLEMENT_CLASS(wxHelpConnection, wxConnection)
#include "wx/list.h"
IMPLEMENT_DYNAMIC_CLASS(wxNode, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxList, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxStringList, wxList)
#if USE_PRINTING_ARCHITECTURE
#include "wx/print.h"
IMPLEMENT_DYNAMIC_CLASS(wxPrintDialog, wxDialog)
IMPLEMENT_DYNAMIC_CLASS(wxPrinterBase, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPostScriptPrinter, wxPrinterBase)
IMPLEMENT_DYNAMIC_CLASS(wxWindowsPrinter, wxPrinterBase)
IMPLEMENT_ABSTRACT_CLASS(wxPrintout, wxObject)
IMPLEMENT_CLASS(wxPreviewCanvas, wxWindow)
IMPLEMENT_CLASS(wxPreviewControlBar, wxWindow)
IMPLEMENT_CLASS(wxPreviewFrame, wxFrame)
IMPLEMENT_CLASS(wxPrintPreviewBase, wxObject)
IMPLEMENT_CLASS(wxPostScriptPrintPreview, wxPrintPreviewBase)
IMPLEMENT_CLASS(wxWindowsPrintPreview, wxPrintPreviewBase)
IMPLEMENT_CLASS(wxGenericPrintDialog, wxDialog)
IMPLEMENT_CLASS(wxGenericPrintSetupDialog, wxDialog)
#endif
#if USE_POSTSCRIPT
#include "wx/postscrp.h"
IMPLEMENT_DYNAMIC_CLASS(wxPostScriptDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPrintSetupData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPageSetupData, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperType, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxPrintPaperDatabase, wxList)
wxPrintPaperDatabase* wxThePrintPaperDatabase = NULL;
#endif
#if USE_WX_RESOURCES
#include "wx/resource.h"
IMPLEMENT_DYNAMIC_CLASS(wxItemResource, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxResourceTable, wxHashTable)
#endif
#include "wx/event.h"
IMPLEMENT_DYNAMIC_CLASS(wxEvtHandler, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxEvent, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxCommandEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxScrollEvent, wxCommandEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMouseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxKeyEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxSizeEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxPaintEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxEraseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMoveEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxFocusEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxCloseEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxMenuEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxJoystickEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxDropFilesEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxActivateEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxInitDialogEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxSysColourChangedEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxIdleEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxUpdateUIEvent, wxEvent)
IMPLEMENT_DYNAMIC_CLASS(wxProcessEvent, wxEvent)
#include "wx/utils.h"
IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxList)
// IMPLEMENT_DYNAMIC_CLASS(wxRect, wxObject)
#include "wx/process.h"
IMPLEMENT_DYNAMIC_CLASS(wxProcess, wxEvtHandler)
#if USE_TIMEDATE
#include "wx/date.h"
IMPLEMENT_DYNAMIC_CLASS(wxDate, wxObject)
#endif
#if USE_DOC_VIEW_ARCHITECTURE
#include "wx/docview.h"
//IMPLEMENT_ABSTRACT_CLASS(wxDocItem, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxDocument, wxEvtHandler)
IMPLEMENT_ABSTRACT_CLASS(wxView, wxEvtHandler)
IMPLEMENT_ABSTRACT_CLASS(wxDocTemplate, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxDocManager, wxEvtHandler)
IMPLEMENT_CLASS(wxDocChildFrame, wxFrame)
IMPLEMENT_CLASS(wxDocParentFrame, wxFrame)
#if USE_PRINTING_ARCHITECTURE
IMPLEMENT_DYNAMIC_CLASS(wxDocPrintout, wxPrintout)
#endif
IMPLEMENT_CLASS(wxCommand, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxCommandProcessor, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxFileHistory, wxObject)
#endif
#if USE_CONSTRAINTS
#include "wx/layout.h"
IMPLEMENT_DYNAMIC_CLASS(wxIndividualLayoutConstraint, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxLayoutConstraints, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxSizer, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxRowColSizer, wxSizer)
#endif
#if USE_TOOLBAR
#include "wx/tbarbase.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarTool, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxToolBarBase, wxControl)
#include "wx/tbarsmpl.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarSimple, wxToolBarBase)
#ifdef wx_msw
#include "wx/tbarmsw.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBarMSW, wxToolBarBase)
#include "wx/tbar95.h"
IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
#endif
#endif
#include "wx/statusbr.h"
IMPLEMENT_DYNAMIC_CLASS(wxStatusBar, wxWindow)
BEGIN_EVENT_TABLE(wxStatusBar, wxWindow)
EVT_PAINT(wxStatusBar::OnPaint)
EVT_SYS_COLOUR_CHANGED(wxStatusBar::OnSysColourChanged)
END_EVENT_TABLE()
#if USE_TIMEDATE
#include "wx/time.h"
IMPLEMENT_DYNAMIC_CLASS(wxTime, wxObject)
#endif
#if !USE_GNU_WXSTRING
#include "wx/string.h"
IMPLEMENT_DYNAMIC_CLASS(wxString, wxObject)
#endif
#ifdef wx_motif
IMPLEMENT_DYNAMIC_CLASS(wxXColormap, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxXFont, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxXCursor, wxObject)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxBrush, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxCursor, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxBitmap, wxGDIObject)
IMPLEMENT_DYNAMIC_CLASS(wxMask, wxObject)
// This will presumably be implemented on other platforms too
#ifdef wx_msw
IMPLEMENT_DYNAMIC_CLASS(wxBitmapHandler, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxBMPResourceHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxBMPFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxXPMFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxXPMDataHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif
#include "wx/statbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
#if USE_IPC
#include "wx/dde.h"
IMPLEMENT_ABSTRACT_CLASS(wxDDEObject, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxDDEServer, wxDDEObject)
IMPLEMENT_DYNAMIC_CLASS(wxDDEClient, wxDDEObject)
IMPLEMENT_CLASS(wxDDEConnection, wxObject)
#endif
IMPLEMENT_ABSTRACT_CLASS(wxControl, wxWindow)
#include "wx/listbox.h"
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
#include "wx/menu.h"
IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxWindow)
IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxWindow)
#include "wx/stattext.h"
#include "wx/statbmp.h"
IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
#if USE_METAFILE
#include "wx/metafile.h"
IMPLEMENT_DYNAMIC_CLASS(wxMetaFile, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxMetaFileDC, wxDC)
#endif
#include "wx/radiobox.h"
#include "wx/radiobut.h"
IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxRadioButton, wxControl)
// IMPLEMENT_DYNAMIC_CLASS(wxBitmapRadioButton, wxRadioButton)
#include "wx/scrolbar.h"
IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
#if WXWIN_COMPATIBILITY
BEGIN_EVENT_TABLE(wxScrollBar, wxControl)
EVT_SCROLL(wxScrollBar::OnScroll)
END_EVENT_TABLE()
#endif
#include "wx/slider.h"
IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
#if WXWIN_COMPATIBILITY
BEGIN_EVENT_TABLE(wxSlider, wxControl)
EVT_SCROLL(wxSlider::OnScroll)
END_EVENT_TABLE()
#endif
#include "wx/timer.h"
IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
#include "wx/textctrl.h"
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
#include "wx/window.h"
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxEvtHandler)
#include "wx/scrolwin.h"
IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxWindow)
#include "wx/panel.h"
IMPLEMENT_DYNAMIC_CLASS(wxPanel, wxWindow)
#include "wx/msgbxdlg.h"
#include "wx/textdlg.h"
#include "wx/filedlg.h"
#include "wx/dirdlg.h"
#include "wx/choicdlg.h"
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
#include "wx/generic/msgdlgg.h"
IMPLEMENT_CLASS(wxGenericMessageDialog, wxDialog)
#endif
IMPLEMENT_CLASS(wxTextEntryDialog, wxDialog)
IMPLEMENT_CLASS(wxSingleChoiceDialog, wxDialog)
IMPLEMENT_CLASS(wxFileDialog, wxDialog)
IMPLEMENT_CLASS(wxDirDialog, wxDialog)
#ifdef wx_msw
IMPLEMENT_CLASS(wxMessageDialog)
#endif
#if USE_GAUGE
#ifdef wx_motif
#include "../../contrib/xmgauge/gauge.h"
#endif
#include "wx_gauge.h"
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif
#include "wx/grid.h"
IMPLEMENT_DYNAMIC_CLASS(wxGenericGrid, wxPanel)
///// 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
@@ -552,160 +141,5 @@ const wxEventTable wxEvtHandler::sm_eventTable =
const wxEventTableEntry wxEvtHandler::sm_eventTableEntries[] = { { 0, 0, 0, NULL } };
BEGIN_EVENT_TABLE(wxFrame, wxWindow)
EVT_ACTIVATE(wxFrame::OnActivate)
EVT_SIZE(wxFrame::OnSize)
EVT_MENU_HIGHLIGHT_ALL(wxFrame::OnMenuHighlight)
EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
EVT_IDLE(wxFrame::OnIdle)
EVT_CLOSE(wxFrame::OnCloseWindow)
END_EVENT_TABLE()
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()
BEGIN_EVENT_TABLE(wxWindow, wxEvtHandler)
EVT_CHAR(wxWindow::OnChar)
EVT_SIZE(wxWindow::Size)
EVT_ERASE_BACKGROUND(wxWindow::OnEraseBackground)
EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
EVT_INIT_DIALOG(wxWindow::OnInitDialog)
EVT_IDLE(wxWindow::OnIdle)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxScrolledWindow, wxWindow)
EVT_SCROLL(wxScrolledWindow::OnScroll)
EVT_SIZE(wxScrolledWindow::OnSize)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxPanel, wxWindow)
EVT_SYS_COLOUR_CHANGED(wxPanel::OnSysColourChanged)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
EVT_CHAR(wxTextCtrl::OnChar)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
END_EVENT_TABLE()
#ifdef wx_msw
BEGIN_EVENT_TABLE(wxMDIParentWindow, wxFrame)
EVT_SIZE(wxMDIParentWindow::OnSize)
EVT_ACTIVATE(wxMDIParentWindow::OnActivate)
EVT_SYS_COLOUR_CHANGED(wxMDIParentWindow::OnSysColourChanged)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
EVT_SCROLL(wxMDIClientWindow::OnScroll)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
EVT_SCROLL(wxToolBarBase::OnScroll)
EVT_SIZE(wxToolBarBase::OnSize)
EVT_IDLE(wxToolBarBase::OnIdle)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxToolBarSimple, wxToolBarBase)
EVT_SIZE(wxToolBarSimple::OnSize)
EVT_PAINT(wxToolBarSimple::OnPaint)
EVT_KILL_FOCUS(wxToolBarSimple::OnKillFocus)
EVT_MOUSE_EVENTS(wxToolBarSimple::OnMouseEvent)
END_EVENT_TABLE()
#ifdef wx_msw
BEGIN_EVENT_TABLE(wxToolBarMSW, wxToolBarBase)
EVT_SIZE(wxToolBarMSW::OnSize)
EVT_PAINT(wxToolBarMSW::OnPaint)
EVT_MOUSE_EVENTS(wxToolBarMSW::OnMouseEvent)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
EVT_SIZE(wxToolBar95::OnSize)
EVT_PAINT(wxToolBar95::OnPaint)
EVT_KILL_FOCUS(wxToolBar95::OnKillFocus)
EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxGenericGrid, wxPanel)
EVT_SIZE(wxGenericGrid::OnSize)
EVT_PAINT(wxGenericGrid::OnPaint)
EVT_MOUSE_EVENTS(wxGenericGrid::OnMouseEvent)
EVT_TEXT(wxGRID_TEXT_CTRL, wxGenericGrid::OnText)
EVT_COMMAND_SCROLL(wxGRID_HSCROLL, wxGenericGrid::OnGridScroll)
EVT_COMMAND_SCROLL(wxGRID_VSCROLL, wxGenericGrid::OnGridScroll)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxControl, wxWindow)
EVT_ERASE_BACKGROUND(wxControl::OnEraseBackground)
END_EVENT_TABLE()
#if !defined(wx_msw) || USE_GENERIC_DIALOGS_IN_MSW
BEGIN_EVENT_TABLE(wxGenericMessageDialog, wxDialog)
EVT_BUTTON(wxID_YES, wxGenericMessageDialog::OnYes)
EVT_BUTTON(wxID_NO, wxGenericMessageDialog::OnNo)
EVT_BUTTON(wxID_CANCEL, wxGenericMessageDialog::OnCancel)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericColourDialog, wxDialog)
EVT_BUTTON(wxID_ADD_CUSTOM, wxGenericColourDialog::OnAddCustom)
EVT_SLIDER(wxID_RED_SLIDER, wxGenericColourDialog::OnRedSlider)
EVT_SLIDER(wxID_GREEN_SLIDER, wxGenericColourDialog::OnGreenSlider)
EVT_SLIDER(wxID_BLUE_SLIDER, wxGenericColourDialog::OnBlueSlider)
EVT_PAINT(wxGenericColourDialog::OnPaint)
EVT_MOUSE_EVENTS(wxGenericColourDialog::OnMouseEvent)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericFontDialog, wxDialog)
EVT_CHECKBOX(wxID_FONT_UNDERLINE, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_STYLE, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_WEIGHT, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_FAMILY, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_COLOUR, wxGenericFontDialog::OnChangeFont)
EVT_CHOICE(wxID_FONT_SIZE, wxGenericFontDialog::OnChangeFont)
EVT_PAINT(wxGenericFontDialog::OnPaint)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxGenericPrintDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxGenericPrintDialog::OnOK)
EVT_BUTTON(wxPRINTID_SETUP, wxGenericPrintDialog::OnSetup)
EVT_RADIOBOX(wxPRINTID_RANGE, wxGenericPrintDialog::OnRange)
END_EVENT_TABLE()
#endif
BEGIN_EVENT_TABLE(wxTextEntryDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxTextEntryDialog::OnOK)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxSingleChoiceDialog, wxDialog)
EVT_BUTTON(wxID_OK, wxSingleChoiceDialog::OnOK)
END_EVENT_TABLE()
#include "wx/prntbase.h"
BEGIN_EVENT_TABLE(wxPrintAbortDialog, wxDialog)
EVT_BUTTON(wxID_CANCEL, wxPrintAbortDialog::OnCancel)
END_EVENT_TABLE()
BEGIN_EVENT_TABLE(wxPreviewControlBar, wxWindow)
EVT_BUTTON(wxID_PREVIEW_CLOSE, wxPreviewControlBar::OnClose)
EVT_BUTTON(wxID_PREVIEW_PRINT, wxPreviewControlBar::OnPrint)
EVT_BUTTON(wxID_PREVIEW_PREVIOUS, wxPreviewControlBar::OnPrevious)
EVT_BUTTON(wxID_PREVIEW_NEXT, wxPreviewControlBar::OnNext)
EVT_CHOICE(wxID_PREVIEW_ZOOM, wxPreviewControlBar::OnZoom)
END_EVENT_TABLE()
#endif
const wxSize wxDefaultSize(-1, -1);
const wxPoint wxDefaultPosition(-1, -1);

19
src/qt/dc.cpp
View File

@@ -1,20 +1,24 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dc.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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
//-----------------------------------------------------------------------------
@@ -87,12 +91,7 @@ wxDC::~wxDC(void)
{
};
void wxDC::DrawArc( long WXUNUSED(x1), long WXUNUSED(y1), long WXUNUSED(x2), long WXUNUSED(y2),
double WXUNUSED(xc), double WXUNUSED(yc) )
{
};
void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
void wxDC::DrawIcon( const wxIcon &WXUNUSED(icon), long WXUNUSED(x), long WXUNUSED(y), bool WXUNUSED(useMask) )
{
};

27
src/qt/dcclient.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcclient.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxClientDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -16,19 +17,6 @@
#include "wx/dcmemory.h"
#include <math.h>
//-----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
#include "bdiag.xbm"
#include "fdiag.xbm"
#include "cdiag.xbm"
#include "horiz.xbm"
#include "verti.xbm"
#include "cross.xbm"
#define num_hatches 6
//-----------------------------------------------------------------------------
// constants
//-----------------------------------------------------------------------------
@@ -39,7 +27,12 @@
// wxPaintDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC,wxDC)
#if !USE_SHARED_LIBRARY
//IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxDC)
//IMPLEMENT_DYNAMIC_CLASS(wxWindowDC, wxDC)
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxDC)
#endif
wxPaintDC::wxPaintDC(void)
{

11
src/qt/dcmemory.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcmemory.cpp
// Purpose:
// Author: Robert Roebling
// Purpose: wxMemoryDC class
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// RCS-ID: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,6 +15,10 @@
#include "wx/dcmemory.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMemoryDC, wxDC)
#endif
//-----------------------------------------------------------------------------
// wxMemoryDC
//-----------------------------------------------------------------------------

47
src/qt/dcscreen.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dcscreen.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxScreenDC class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,35 +14,19 @@
#endif
#include "wx/dcscreen.h"
#include "wx/window.h"
//-----------------------------------------------------------------------------
// wxScreenDC
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC, wxPaintDC)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxScreenDC,wxPaintDC)
wxScreenDC::wxScreenDC(void)
// Create a DC representing the whole screen
wxScreenDC::wxScreenDC()
{
m_ok = FALSE;
};
// TODO
}
wxScreenDC::~wxScreenDC(void)
wxScreenDC::~wxScreenDC()
{
EndDrawingOnTop();
};
// TODO
}
bool wxScreenDC::StartDrawingOnTop( wxWindow *WXUNUSED(window) )
{
return TRUE;
};
bool wxScreenDC::StartDrawingOnTop( wxRectangle *WXUNUSED(rect) )
{
return TRUE;
};
bool wxScreenDC::EndDrawingOnTop(void)
{
return TRUE;
};

399
src/qt/dialog.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: dialog.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxDialog class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,179 +14,281 @@
#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;
//-----------------------------------------------------------------------------
// wxDialog
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel)
BEGIN_EVENT_TABLE(wxDialog,wxWindow)
EVT_BUTTON (wxID_OK, wxDialog::OnOk)
EVT_BUTTON (wxID_CANCEL, wxDialog::OnCancel)
EVT_BUTTON (wxID_APPLY, wxDialog::OnApply)
EVT_CLOSE (wxDialog::OnCloseWindow)
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()
IMPLEMENT_DYNAMIC_CLASS(wxDialog,wxWindow)
#endif
wxDialog::wxDialog(void)
wxDialog::wxDialog()
{
m_title = "";
m_modalShowing = FALSE;
wxTopLevelWindows.Insert( this );
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
}
wxDialog::wxDialog( wxWindow *parent,
wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
bool wxDialog::Create(wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_modalShowing = FALSE;
wxTopLevelWindows.Insert( this );
Create( parent, id, title, pos, size, style, name );
};
m_windowStyle = style;
bool wxDialog::Create( wxWindow *parent,
wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
return TRUE;
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
SetName(name);
if (!parent)
wxTopLevelWindows.Append(this);
wxDialog::~wxDialog(void)
{
wxTopLevelWindows.DeleteObject( this );
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
};
if (parent) parent->AddChild(this);
void wxDialog::SetTitle(const wxString& title )
{
m_title = title;
};
wxString wxDialog::GetTitle(void) const
{
return (wxString&)m_title;
};
void wxDialog::OnApply( wxCommandEvent &WXUNUSED(event) )
{
if (Validate()) TransferDataFromWindow();
};
void wxDialog::OnCancel( wxCommandEvent &WXUNUSED(event) )
{
if (IsModal())
{
EndModal(wxID_CANCEL);
}
if ( id == -1 )
m_windowId = (int)NewControlId();
else
{
SetReturnCode(wxID_CANCEL);
this->Show(FALSE);
};
};
m_windowId = id;
void wxDialog::OnOk( wxCommandEvent &WXUNUSED(event) )
{
if ( Validate() && TransferDataFromWindow())
{
if (IsModal())
{
EndModal(wxID_OK);
}
else
{
SetReturnCode(wxID_OK);
this->Show(FALSE);
};
};
};
// TODO: create dialog
void wxDialog::OnPaint( wxPaintEvent& WXUNUSED(event) )
{
// yes
};
bool wxDialog::OnClose(void)
{
static wxList closing;
if (closing.Member(this)) return FALSE; // no loops
closing.Append(this);
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
GetEventHandler()->ProcessEvent(cancelEvent);
closing.DeleteObject(this);
return FALSE;
}
bool wxDialog::Destroy(void)
void wxDialog::SetModal(bool flag)
{
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
if ( flag )
m_windowStyle |= wxDIALOG_MODAL ;
else
if ( m_windowStyle & wxDIALOG_MODAL )
m_windowStyle -= wxDIALOG_MODAL ;
wxModelessWindows.DeleteObject(this);
if (!flag)
wxModelessWindows.Append(this);
}
return TRUE;
wxDialog::~wxDialog()
{
// TODO
wxTopLevelWindows.DeleteObject(this);
if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL )
wxModelessWindows.DeleteObject(this);
// If this is the last top-level window, exit.
if (wxTheApp && (wxTopLevelWindows.Number() == 0))
{
wxTheApp->SetTopWindow(NULL);
if (wxTheApp->GetExitOnFrameDelete())
{
// TODO: exit
}
}
}
// By default, pressing escape cancels the dialog
void wxDialog::OnCharHook(wxKeyEvent& event)
{
if (GetHWND())
{
if (event.m_keyCode == WXK_ESCAPE)
{
// Behaviour changed in 2.0: we'll send a Cancel message
// to the dialog instead of Close.
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
GetEventHandler()->ProcessEvent(cancelEvent);
return;
}
}
// We didn't process this event.
event.Skip();
}
void wxDialog::Iconize(bool WXUNUSED(iconize))
{
// TODO
}
bool wxDialog::IsIconized() const
{
// TODO
return FALSE;
}
void wxDialog::SetClientSize(int width, int height)
{
// TODO
}
void wxDialog::GetPosition(int *x, int *y) const
{
// TODO
}
bool wxDialog::Show(bool show)
{
// TODO
return FALSE;
}
void wxDialog::SetTitle(const wxString& title)
{
// TODO
}
wxString wxDialog::GetTitle() const
{
// TODO
return wxString("");
}
void wxDialog::Centre(int direction)
{
int x_offset,y_offset ;
int display_width, display_height;
int width, height, x, y;
wxFrame *frame ;
if (direction & wxCENTER_FRAME)
{
frame = (wxFrame*)GetParent() ;
if (frame)
{
frame->GetPosition(&x_offset,&y_offset) ;
frame->GetSize(&display_width,&display_height) ;
}
}
else
frame = NULL ;
if (frame==NULL)
{
wxDisplaySize(&display_width, &display_height);
x_offset = 0 ;
y_offset = 0 ;
}
GetSize(&width, &height);
GetPosition(&x, &y);
if (direction & wxHORIZONTAL)
x = (int)((display_width - width)/2);
if (direction & wxVERTICAL)
y = (int)((display_height - height)/2);
SetSize(x+x_offset, y+y_offset, width, height);
}
// Replacement for Show(TRUE) for modal dialogs - returns return code
int wxDialog::ShowModal()
{
m_windowStyle |= wxDIALOG_MODAL;
// TODO: modal showing
Show(TRUE);
return GetReturnCode();
}
void wxDialog::EndModal(int retCode)
{
SetReturnCode(retCode);
// TODO modal un-showing
Show(FALSE);
}
// Standard buttons
void wxDialog::OnOK(wxCommandEvent& event)
{
if ( Validate() && TransferDataFromWindow() )
{
if ( IsModal() )
EndModal(wxID_OK);
else
{
SetReturnCode(wxID_OK);
this->Show(FALSE);
}
}
}
void wxDialog::OnApply(wxCommandEvent& event)
{
if (Validate())
TransferDataFromWindow();
// TODO probably need to disable the Apply button until things change again
}
void wxDialog::OnCancel(wxCommandEvent& event)
{
if ( IsModal() )
EndModal(wxID_CANCEL);
else
{
SetReturnCode(wxID_CANCEL);
this->Show(FALSE);
}
}
bool wxDialog::OnClose()
{
// Behaviour changed in 2.0: we'll send a Cancel message by default,
// which may close the dialog.
// Check for looping if the Cancel event handler calls Close()
static wxList closing;
if ( closing.Member(this) )
return FALSE;
closing.Append(this);
wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
cancelEvent.SetEventObject( this );
GetEventHandler()->ProcessEvent(cancelEvent);
closing.DeleteObject(this);
return FALSE;
}
void wxDialog::OnCloseWindow(wxCloseEvent& event)
{
if (GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
};
};
// Compatibility
if ( GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
}
}
bool wxDialog::Show( bool show )
// Destroy the window (delayed, if a managed window)
bool wxDialog::Destroy()
{
if (!show && IsModal() && m_modalShowing)
{
EndModal( wxID_CANCEL );
};
wxWindow::Show( show );
if (show) InitDialog();
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
};
}
int wxDialog::ShowModal(void)
void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event)
{
if (m_modalShowing) return GetReturnCode();
Show( TRUE );
m_modalShowing = TRUE;
// grab here
// main here
// release here
return GetReturnCode();
};
void wxDialog::EndModal( int retCode )
{
SetReturnCode( retCode );
if (!m_modalShowing) return;
m_modalShowing = FALSE;
// quit main
};
void wxDialog::InitDialog(void)
{
wxWindow::InitDialog();
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE));
Refresh();
}

44
src/qt/dnd.cpp
View File

@@ -1,9 +1,12 @@
///////////////////////////////////////////////////////////////////////////////
// Name: dnd.cpp
// Purpose: wxDropTarget class
// Author: Robert Roebling
// Copyright: Robert Roebling
// Licence: wxWindows license
// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) 1998 AUTHOR
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
@@ -19,8 +22,6 @@
// global
// ----------------------------------------------------------------------------
extern bool g_blockEventsOnDrag;
// ----------------------------------------------------------------------------
// wxDropTarget
// ----------------------------------------------------------------------------
@@ -92,32 +93,41 @@ wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
// wxDropSource
//-------------------------------------------------------------------------
wxDropSource::wxDropSource( wxWindow *WXUNUSED(win) )
//-----------------------------------------------------------------------------
// drag request
wxDropSource::wxDropSource( wxWindow *win )
{
g_blockEventsOnDrag = TRUE;
// TODO
m_window = win;
m_data = NULL;
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *WXUNUSED(win) )
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
{
g_blockEventsOnDrag = TRUE;
m_data = &data;
// 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;
m_data = &data;
};
wxDropSource::~wxDropSource(void)
{
// if (m_data) delete m_data;
g_blockEventsOnDrag = FALSE;
};
wxDropSource::DragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
{
return Copy;
// TODO
return Error;
};

193
src/qt/filedlg.cpp
View File

@@ -1,125 +1,142 @@
/////////////////////////////////////////////////////////////////////////////
// Name: filedlg.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// 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/filedlg.h"
#include "wx/defs.h"
#include "wx/utils.h"
#include "wx/intl.h"
#include "wx/generic/msgdlgg.h"
#include "wx/dialog.h"
#include "wx/filedlg.h"
//-----------------------------------------------------------------------------
// wxFileDialog
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxFileDialog,wxDialog)
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_path = "";
m_fileName = defaultFileName;
m_dir = defaultDir;
m_wildCard = wildCard;
m_dialogStyle = style;
m_filterIndex = 1;
m_path.Append(m_dir);
if(! m_path.IsEmpty() && m_path.Last()!='/') m_path.Append('/');
m_path.Append(m_fileName);
};
int wxFileDialog::ShowModal(void)
{
int ret = wxDialog::ShowModal();
if (ret == wxID_OK)
{
};
return ret;
};
#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)
{
wxString filter2("");
if ( defaultExtension && !filter )
filter2 = wxString("*.") + wxString(defaultExtension) ;
else if ( filter )
filter2 = filter;
// If there's a default extension specified but no filter, we create a suitable
// filter.
wxString defaultDirString;
if (defaultDir)
defaultDirString = defaultDir;
else
defaultDirString = "";
wxString filter2("");
if ( defaultExtension && !filter )
filter2 = wxString("*.") + wxString(defaultExtension) ;
else if ( filter )
filter2 = filter;
wxString defaultFilenameString;
if (defaultFileName)
defaultFilenameString = defaultFileName;
else
defaultFilenameString = "";
wxString defaultDirString;
if (defaultDir)
defaultDirString = defaultDir;
else
defaultDirString = "";
wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString,
filter2, flags, wxPoint(x, y));
wxString defaultFilenameString;
if (defaultFileName)
defaultFilenameString = defaultFileName;
else
defaultFilenameString = "";
if ( fileDialog.ShowModal() == wxID_OK )
{
strcpy(wxBuffer, (const char *)fileDialog.GetPath());
return wxBuffer;
}
else
return NULL;
};
wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
char* wxLoadFileSelector(const char *what, const char *extension, const char *default_name,
wxWindow *parent )
if ( fileDialog.ShowModal() == wxID_OK )
{
strcpy(wxBuffer, (const char *)fileDialog.GetPath());
return wxBuffer;
}
else
return NULL;
}
char *wxFileSelectorEx(const char *title,
const char *defaultDir,
const char *defaultFileName,
int* defaultFilterIndex,
const char *filter,
int flags,
wxWindow* parent,
int x,
int y)
{
wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
if ( fileDialog.ShowModal() == wxID_OK )
{
*defaultFilterIndex = fileDialog.GetFilterIndex();
strcpy(wxBuffer, (const char *)fileDialog.GetPath());
return wxBuffer;
}
else
return NULL;
}
wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
long style, const wxPoint& pos)
{
m_message = message;
m_dialogStyle = style;
m_parent = parent;
m_path = "";
m_fileName = defaultFileName;
m_dir = defaultDir;
m_wildCard = wildCard;
m_filterIndex = 1;
}
int wxFileDialog::ShowModal()
{
// TODO
wxID_CANCEL;
}
// Generic file load/save dialog
static char *
wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
char *ext = (char *)extension;
char prompt[50];
wxString str = _("Load %s file");
sprintf(prompt, str, what);
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);
};
}
char* wxSaveFileSelector(const char *what, const char *extension, const char *default_name,
wxWindow *parent )
// Generic file load dialog
char *
wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
char *ext = (char *)extension;
char prompt[50];
wxString str = _("Save %s file");
sprintf(prompt, str, what);
if (*ext == '.') ext++;
char wild[60];
sprintf(wild, "*.%s", ext);
return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, 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);
}

370
src/qt/font.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: font.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFont class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,201 +14,228 @@
#endif
#include "wx/font.h"
#include "wx/utils.h"
#include <strings.h>
//-----------------------------------------------------------------------------
// local data
//-----------------------------------------------------------------------------
static char *wx_font_family [] = {
"wxDEFAULT", "wxDECORATIVE", "wxMODERN", "wxROMAN", "wxSCRIPT",
"wxSWISS", "wxTELETYPE",
};
static char *wx_font_style [] = {
"wxDEFAULT", "wxNORMAL", "wxSLANT", "wxITALIC",
};
static char *wx_font_weight [] = {
"wxDEFAULT", "wxNORMAL", "wxBOLD", "wxLIGHT",
};
extern wxFontNameDirectory wxTheFontNameDirectory;
//-----------------------------------------------------------------------------
// wxFont
//-----------------------------------------------------------------------------
class wxFontRefData: public wxObjectRefData
{
public:
wxFontRefData(void);
~wxFontRefData(void);
wxList m_scaled_xfonts;
int m_pointSize;
int m_family, m_style, m_weight;
bool m_underlined;
int m_fontId;
char* m_faceName;
};
wxFontRefData::wxFontRefData(void) : m_scaled_xfonts(wxKEY_INTEGER)
{
m_pointSize = -1;
m_family = -1;
m_style = -1;
m_weight = -1;
m_underlined = FALSE;
m_fontId = 0;
m_faceName = NULL;
};
wxFontRefData::~wxFontRefData(void)
{
wxNode *node = m_scaled_xfonts.First();
while (node)
{
wxNode *next = node->Next();
node = next;
};
if (m_faceName)
{
delete m_faceName;
m_faceName = NULL;
};
};
//-----------------------------------------------------------------------------
#define M_FONTDATA ((wxFontRefData *)m_refData)
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
#endif
wxFont::wxFont(void)
wxFontRefData::wxFontRefData()
{
if (wxTheFontList) wxTheFontList->Append( this );
};
m_style = 0;
m_pointSize = 0;
m_family = 0;
m_style = 0;
m_weight = 0;
m_underlined = 0;
m_faceName = "";
/* TODO
m_hFont = 0;
*/
}
wxFont::wxFont( char *xFontName )
wxFontRefData::wxFontRefData(const wxFontRefData& data)
{
if (!xFontName) return;
m_refData = new wxFontRefData();
};
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;
*/
}
wxFont::wxFont(int PointSize, int FontIdOrFamily, int Style, int Weight,
bool Underlined, const char* Face)
wxFontRefData::~wxFontRefData()
{
m_refData = new wxFontRefData();
// TODO: delete font data
}
if (wxTheFontList) wxTheFontList->Append( this );
};
wxFont::wxFont(int PointSize, const char *Face, int Family, int Style,
int Weight, bool Underlined)
wxFont::wxFont()
{
m_refData = new wxFontRefData();
if ( wxTheFontList )
wxTheFontList->Append(this);
}
if (wxTheFontList) wxTheFontList->Append( this );
};
wxFont::wxFont( const wxFont& font )
{
Ref( font );
};
wxFont::wxFont( const wxFont* font )
{
UnRef();
if (font) Ref( *font );
};
wxFont::~wxFont(void)
wxFont::wxFont(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
if (wxTheFontList) wxTheFontList->DeleteObject( this );
};
Create(pointSize, family, style, weight, underlined, faceName);
wxFont& wxFont::operator = ( const wxFont& font )
{
if (*this == font) return (*this);
Ref( font );
return *this;
};
if ( wxTheFontList )
wxTheFontList->Append(this);
}
bool wxFont::operator == ( const wxFont& font )
{
return m_refData == font.m_refData;
};
bool wxFont::operator != ( const wxFont& font )
{
return m_refData != font.m_refData;
};
bool wxFont::Ok()
bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName)
{
return (m_refData != NULL);
};
UnRef();
m_refData = new wxFontRefData;
int wxFont::GetPointSize(void) const
{
return M_FONTDATA->m_pointSize;
};
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;
wxString wxFont::GetFaceString(void) const
{
return "";
};
RealizeResource();
wxString wxFont::GetFaceName(void) const
{
return "";
};
return TRUE;
}
int wxFont::GetFamily(void) const
wxFont::~wxFont()
{
return M_FONTDATA->m_family;
};
if (wxTheFontList)
wxTheFontList->DeleteObject(this);
}
wxString wxFont::GetFamilyString(void) const
bool wxFont::RealizeResource()
{
wxString s = wx_font_family[M_FONTDATA->m_family];
return s;
};
// TODO: create the font (if there is a native font object)
return FALSE;
}
int wxFont::GetFontId(void) const
void wxFont::Unshare()
{
return M_FONTDATA->m_fontId; // stub
};
// Don't change shared data
if (!m_refData)
{
m_refData = new wxFontRefData();
}
else
{
wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
int wxFont::GetStyle(void) const
void wxFont::SetPointSize(int pointSize)
{
return M_FONTDATA->m_style;
};
Unshare();
wxString wxFont::GetStyleString(void) const
{
wxString s = wx_font_style[M_FONTDATA->m_style];
return s;
};
M_FONTDATA->m_pointSize = pointSize;
int wxFont::GetWeight(void) const
{
return M_FONTDATA->m_weight;
};
RealizeResource();
}
wxString wxFont::GetWeightString(void) const
void wxFont::SetFamily(int family)
{
wxString s = wx_font_weight[M_FONTDATA->m_weight];
return s;
};
Unshare();
bool wxFont::GetUnderlined(void) const
M_FONTDATA->m_family = family;
RealizeResource();
}
void wxFont::SetStyle(int style)
{
return M_FONTDATA->m_underlined;
};
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;
}

676
src/qt/frame.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: frame.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxFrame
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,240 +14,533 @@
#endif
#include "wx/frame.h"
#include "wx/dialog.h"
#include "wx/control.h"
#include "wx/app.h"
#include "wx/menu.h"
#include "wx/toolbar.h"
#include "wx/statusbr.h"
#include "wx/mdi.h"
#include "wx/toolbar.h"
#include "wx/menuitem.h"
const wxMENU_HEIGHT = 28;
const wxSTATUS_HEIGHT = 25;
extern wxList wxTopLevelWindows;
extern wxList wxModelessWindows;
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// wxFrame
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
BEGIN_EVENT_TABLE(wxFrame, wxWindow)
EVT_SIZE(wxFrame::OnSize)
EVT_CLOSE(wxFrame::OnCloseWindow)
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)
IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
#endif
#if USE_NATIVE_STATUSBAR
bool wxFrame::m_useNativeStatusBar = TRUE;
#else
bool wxFrame::m_useNativeStatusBar = FALSE;
#endif
wxFrame::wxFrame()
{
wxTopLevelWindows.Insert( this );
};
m_frameToolBar = NULL ;
m_frameMenuBar = NULL;
m_frameStatusBar = NULL;
wxFrame::wxFrame( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
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)
{
Create( parent, id, title, pos, size, style, name );
wxTopLevelWindows.Insert( this );
};
if (!parent)
wxTopLevelWindows.Append(this);
bool wxFrame::Create( wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
m_title = title;
SetName(name);
m_windowStyle = style;
m_frameMenuBar = NULL;
m_frameToolBar = NULL ;
m_frameStatusBar = NULL;
return TRUE;
};
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()
{
if (m_frameMenuBar) delete m_frameMenuBar;
if (m_frameStatusBar) delete m_frameStatusBar;
wxTopLevelWindows.DeleteObject(this);
wxTopLevelWindows.DeleteObject( this );
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
};
if (m_frameStatusBar)
delete m_frameStatusBar;
if (m_frameMenuBar)
delete m_frameMenuBar;
bool wxFrame::Show( bool show )
{
if (show)
/* Check if it's the last top-level window */
if (wxTheApp && (wxTopLevelWindows.Number() == 0))
{
wxSizeEvent event( wxSize(m_width,m_height), GetId() );
ProcessEvent( event );
};
return wxWindow::Show( show );
};
wxTheApp->SetTopWindow(NULL);
void wxFrame::Enable( bool enable )
{
wxWindow::Enable( enable );
};
if (wxTheApp->GetExitOnFrameDelete())
{
// TODO signal to the app that we're going to close
}
}
void wxFrame::OnCloseWindow( wxCloseEvent &event )
wxModelessWindows.DeleteObject(this);
}
// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
void wxFrame::GetClientSize(int *x, int *y) const
{
// TODO
}
// Set the client size (i.e. leave the calculation of borders etc.
// to wxWindows)
void wxFrame::SetClientSize(int width, int height)
{
// TODO
}
void wxFrame::GetSize(int *width, int *height) const
{
// TODO
}
void wxFrame::GetPosition(int *x, int *y) const
{
// TODO
}
void wxFrame::SetSize(int x, int y, int width, int height, int sizeFlags)
{
// TODO
}
bool wxFrame::Show(bool show)
{
// TODO
return FALSE;
}
void wxFrame::Iconize(bool iconize)
{
// TODO
}
// Equivalent to maximize/restore in Windows
void wxFrame::Maximize(bool maximize)
{
// TODO
}
bool wxFrame::IsIconized() const
{
// TODO
return FALSE;
}
void wxFrame::SetTitle(const wxString& title)
{
// TODO
}
wxString wxFrame::GetTitle() const
{
// TODO
return wxString("");
}
void wxFrame::SetIcon(const wxIcon& icon)
{
m_icon = icon;
// TODO
}
void wxFrame::SetAcceleratorTable(const wxAcceleratorTable& accel)
{
m_acceleratorTable = accel;
}
wxStatusBar *wxFrame::OnCreateStatusBar(int number, long style, wxWindowID id,
const wxString& name)
{
wxStatusBar *statusBar = NULL;
statusBar = new wxStatusBar(this, id, wxPoint(0, 0), wxSize(100, 20),
style, name);
// Set the height according to the font and the border size
wxClientDC dc(statusBar);
dc.SetFont(* statusBar->GetFont());
long x, y;
dc.GetTextExtent("X", &x, &y);
int height = (int)( (y * 1.1) + 2* statusBar->GetBorderY());
statusBar->SetSize(-1, -1, 100, height);
statusBar->SetFieldsCount(number);
return statusBar;
}
wxStatusBar* wxFrame::CreateStatusBar(int number, long style, wxWindowID id,
const wxString& name)
{
// Calling CreateStatusBar twice is an error.
wxCHECK_MSG( m_frameStatusBar == NULL, FALSE,
"recreating status bar in wxFrame" );
m_frameStatusBar = OnCreateStatusBar(number, style, id,
name);
if ( m_frameStatusBar )
{
PositionStatusBar();
return m_frameStatusBar;
}
else
return NULL;
}
void wxFrame::SetStatusText(const wxString& text, int number)
{
wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set text for" );
m_frameStatusBar->SetStatusText(text, number);
}
void wxFrame::SetStatusWidths(int n, const int widths_field[])
{
wxCHECK_RET( m_frameStatusBar != NULL, "no statusbar to set widths for" );
m_frameStatusBar->SetStatusWidths(n, widths_field);
PositionStatusBar();
}
void wxFrame::PositionStatusBar()
{
int w, h;
GetClientSize(&w, &h);
int sw, sh;
m_frameStatusBar->GetSize(&sw, &sh);
// Since we wish the status bar to be directly under the client area,
// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
m_frameStatusBar->SetSize(0, h, w, sh);
}
void wxFrame::SetMenuBar(wxMenuBar *menuBar)
{
if (!menuBar)
{
m_frameMenuBar = NULL;
return;
}
m_frameMenuBar = menuBar;
// TODO
}
void wxFrame::Fit()
{
// Work out max. size
wxNode *node = GetChildren()->First();
int max_width = 0;
int max_height = 0;
while (node)
{
// Find a child that's a subwindow, but not a dialog box.
wxWindow *win = (wxWindow *)node->Data();
if (!win->IsKindOf(CLASSINFO(wxFrame)) &&
!win->IsKindOf(CLASSINFO(wxDialog)))
{
int width, height;
int x, y;
win->GetSize(&width, &height);
win->GetPosition(&x, &y);
if ((x + width) > max_width)
max_width = x + width;
if ((y + height) > max_height)
max_height = y + height;
}
node = node->Next();
}
SetClientSize(max_width, max_height);
}
// Responds to colour changes, and passes event on to children.
void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
Refresh();
if ( m_frameStatusBar )
{
wxSysColourChangedEvent event2;
event2.SetEventObject( m_frameStatusBar );
m_frameStatusBar->ProcessEvent(event2);
}
// Propagate the event to the non-top-level children
wxWindow::OnSysColourChanged(event);
}
// Default resizing behaviour - if only ONE subwindow,
// resize to client rectangle size
void wxFrame::OnSize(wxSizeEvent& event)
{
// if we're using constraints - do use them
#if USE_CONSTRAINTS
if ( GetAutoLayout() ) {
Layout();
return;
}
#endif
// do we have _exactly_ one child?
wxWindow *child = NULL;
for ( wxNode *node = GetChildren()->First(); node; node = node->Next() )
{
wxWindow *win = (wxWindow *)node->Data();
if ( !win->IsKindOf(CLASSINFO(wxFrame)) &&
!win->IsKindOf(CLASSINFO(wxDialog)) &&
(win != GetStatusBar()) &&
(win != GetToolBar()) )
{
if ( child )
return; // it's our second subwindow - nothing to do
child = win;
}
}
if ( child ) {
// we have exactly one child - set it's size to fill the whole frame
int clientW, clientH;
GetClientSize(&clientW, &clientH);
int x = 0;
int y = 0;
child->SetSize(x, y, clientW, clientH);
}
}
// Default activation behaviour - set the focus for the first child
// subwindow found.
void wxFrame::OnActivate(wxActivateEvent& event)
{
for(wxNode *node = GetChildren()->First(); node; node = node->Next())
{
// Find a child that's a subwindow, but not a dialog box.
wxWindow *child = (wxWindow *)node->Data();
if (!child->IsKindOf(CLASSINFO(wxFrame)) &&
!child->IsKindOf(CLASSINFO(wxDialog)))
{
#if WXDEBUG > 1
wxDebugMsg("wxFrame::OnActivate: about to set the child's focus.\n");
#endif
child->SetFocus();
return;
}
}
}
// The default implementation for the close window event - calls
// OnClose for backward compatibility.
void wxFrame::OnCloseWindow(wxCloseEvent& event)
{
// Compatibility
if ( GetEventHandler()->OnClose() || event.GetForce())
{
this->Destroy();
}
};
}
bool wxFrame::OnClose()
{
return TRUE;
}
// Destroy the window (delayed, if a managed window)
bool wxFrame::Destroy()
{
if (!wxPendingDelete.Member(this))
wxPendingDelete.Append(this);
return TRUE;
}
void wxFrame::GetClientSize( int *width, int *height ) const
// Default menu selection behaviour - display a help string
void wxFrame::OnMenuHighlight(wxMenuEvent& event)
{
wxWindow::GetClientSize( width, height );
if (height)
if (GetStatusBar())
{
if (m_frameMenuBar) (*height) -= wxMENU_HEIGHT;
if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
if (m_frameToolBar)
if (event.GetMenuId() == -1)
SetStatusText("");
else
{
int y = 0;
m_frameToolBar->GetSize( NULL, &y );
(*height) -= y;
}
};
};
void wxFrame::OnSize( wxSizeEvent &WXUNUSED(event) )
{
if ( GetAutoLayout() )
Layout();
else {
// no child: go out !
if (!GetChildren()->First())
return;
// do we have exactly one child?
wxWindow *child = NULL;
for(wxNode *node = GetChildren()->First(); node; node = node->Next())
{
wxWindow *win = (wxWindow *)node->Data();
if (!IS_KIND_OF(win,wxFrame) && !IS_KIND_OF(win,wxDialog)
#if 0 // not in m_children anyway
&& (win != m_frameMenuBar) &&
(win != m_frameToolBar) &&
(win != m_frameStatusBar)
#endif
)
wxMenuBar *menuBar = GetMenuBar();
if (menuBar)
{
if ( child ) // it's the second one: do nothing
return;
child = win;
};
};
// yes: set it's size to fill all the frame
int client_x, client_y;
GetClientSize(&client_x, &client_y);
child->SetSize( 1, 1, client_x-2, client_y);
}
};
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
menu->SetInvokingWindow( win );
wxNode *node = menu->m_items.First();
while (node)
{
wxMenuItem *menuitem = (wxMenuItem*)node->Data();
if (menuitem->IsSubMenu())
SetInvokingWindow( menuitem->GetSubMenu(), win );
node = node->Next();
};
};
void wxFrame::SetMenuBar( wxMenuBar *menuBar )
{
m_frameMenuBar = menuBar;
if (m_frameMenuBar)
{
if (m_frameMenuBar->m_parent != this)
{
wxNode *node = m_frameMenuBar->m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
SetInvokingWindow( menu, this );
node = node->Next();
};
wxString helpString(menuBar->GetHelpString(event.GetMenuId()));
if (helpString != "")
SetStatusText(helpString);
}
}
}
};
}
wxMenuBar *wxFrame::GetMenuBar(void)
wxMenuBar *wxFrame::GetMenuBar() const
{
return m_frameMenuBar;
};
wxToolBar *wxFrame::CreateToolBar( long style , wxWindowID id, const wxString& name )
{
m_frameToolBar = new wxToolBar( this, id, wxDefaultPosition, wxDefaultSize, style, name );
return m_frameToolBar;
};
wxToolBar *wxFrame::GetToolBar(void)
{
return m_frameToolBar;
};
wxStatusBar* wxFrame::CreateStatusBar( int number, long style, wxWindowID id, const wxString& name )
{
if (m_frameStatusBar)
delete m_frameStatusBar;
m_frameStatusBar = new wxStatusBar( this, id, wxPoint(0,0), wxSize(100,20), style, name );
m_frameStatusBar->SetFieldsCount( number );
return m_frameStatusBar;
};
void wxFrame::SetStatusText( const wxString &text, int number )
{
if (m_frameStatusBar) m_frameStatusBar->SetStatusText( text, number );
};
void wxFrame::SetStatusWidths( int n, int *width )
{
if (m_frameStatusBar) m_frameStatusBar->SetStatusWidths( n, width );
};
wxStatusBar *wxFrame::GetStatusBar(void)
{
return m_frameStatusBar;
};
void wxFrame::SetTitle( const wxString &title )
{
m_title = title;
};
void wxFrame::SetSizeHints( int WXUNUSED(minW), int WXUNUSED(minH),
int WXUNUSED(maxW), int WXUNUSED(maxH), int WXUNUSED(incW) )
{
}
void wxFrame::SetIcon( const wxIcon &icon )
void wxFrame::Centre(int direction)
{
m_icon = icon;
if (!icon.Ok()) return;
int display_width, display_height, width, height, x, y;
wxDisplaySize(&display_width, &display_height);
GetSize(&width, &height);
GetPosition(&x, &y);
if (direction & wxHORIZONTAL)
x = (int)((display_width - width)/2);
if (direction & wxVERTICAL)
y = (int)((display_height - height)/2);
SetSize(x, y, width, height);
}
// Call this to simulate a menu command
void wxFrame::Command(int id)
{
ProcessCommand(id);
}
void wxFrame::ProcessCommand(int id)
{
wxCommandEvent commandEvent(wxEVENT_TYPE_MENU_COMMAND, id);
commandEvent.SetInt( id );
commandEvent.SetEventObject( this );
wxMenuBar *bar = GetMenuBar() ;
if (!bar)
return;
/* TODO: check the menu item if required
wxMenuItem *item = bar->FindItemForId(id) ;
if (item && item->IsCheckable())
{
bar->Check(id,!bar->Checked(id)) ;
}
*/
GetEventHandler()->ProcessEvent(commandEvent);
}
// Checks if there is a toolbar, and returns the first free client position
wxPoint wxFrame::GetClientAreaOrigin() const
{
wxPoint pt(0, 0);
if (GetToolBar())
{
int w, h;
GetToolBar()->GetSize(& w, & h);
if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
{
pt.x += w;
}
else
{
pt.y += h;
}
}
return pt;
}
wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
{
wxCHECK_MSG( m_frameToolBar == NULL, FALSE,
"recreating toolbar in wxFrame" );
wxToolBar* toolBar = OnCreateToolBar(style, id, name);
if (toolBar)
{
SetToolBar(toolBar);
PositionToolBar();
return toolBar;
}
else
{
return NULL;
}
}
wxToolBar* wxFrame::OnCreateToolBar(long style, wxWindowID id, const wxString& name)
{
return new wxToolBar(this, id, wxDefaultPosition, wxDefaultSize, style, name);
}
void wxFrame::PositionToolBar()
{
int cw, ch;
// TODO: we actually need to use the low-level client size, before
// the toolbar/status bar were added.
// So DEFINITELY replace the line below with something appropriate.
wxCHECK_MSG( TRUE, FALSE,
"PositionToolBar not implemented properly, see frame.cpp" );
GetClientSize(& cw, &ch);
if ( GetStatusBar() )
{
int statusX, statusY;
GetStatusBar()->GetClientSize(&statusX, &statusY);
ch -= statusY;
}
if (GetToolBar())
{
int tw, th;
GetToolBar()->GetSize(& tw, & th);
if (GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL)
{
// Use the 'real' position. wxSIZE_NO_ADJUSTMENTS
// means, pretend we don't have toolbar/status bar, so we
// have the original client size.
GetToolBar()->SetSize(0, 0, tw, ch, wxSIZE_NO_ADJUSTMENTS);
}
else
{
// Use the 'real' position
GetToolBar()->SetSize(0, 0, cw, th, wxSIZE_NO_ADJUSTMENTS);
}
}
}

112
src/qt/gauge.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gauge.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxGauge class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,38 +15,91 @@
#include "wx/gauge.h"
//-----------------------------------------------------------------------------
// wxGauge
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxGauge, wxControl)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxGauge,wxControl)
bool wxGauge::Create( wxWindow *parent, wxWindowID id, int range,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
bool wxGauge::Create(wxWindow *parent, wxWindowID id,
int range,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
m_rangeMax = range;
m_windowStyle = style;
void wxGauge::SetRange( int r )
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)
{
m_rangeMax = r;
if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
};
// TODO
}
void wxGauge::SetValue( int pos )
void wxGauge::SetShadowWidth(int w)
{
m_gaugePos = pos;
if (m_gaugePos > m_rangeMax) m_gaugePos = m_rangeMax;
};
// TODO optional
}
int wxGauge::GetRange(void) const
void wxGauge::SetBezelFace(int w)
{
return m_rangeMax;
};
// TODO optional
}
int wxGauge::GetValue(void) const
void wxGauge::SetRange(int r)
{
return m_gaugePos;
};
m_rangeMax = r;
// TODO
}
void wxGauge::SetValue(int pos)
{
m_gaugePos = pos;
// TODO
}
int wxGauge::GetShadowWidth() const
{
// TODO optional
return 0;
}
int wxGauge::GetBezelFace() const
{
// TODO optional
return 0;
}
int wxGauge::GetRange() const
{
return m_rangeMax;
}
int wxGauge::GetValue() const
{
return m_gaugePos;
}
void wxGauge::SetForegroundColour(const wxColour& col)
{
m_foregroundColour = col ;
}
void wxGauge::SetBackgroundColour(const wxColour& col)
{
m_backgroundColour = col ;
}

7
src/qt/gdiobj.cpp
View File

@@ -1,11 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: gdiobj.cpp
// Purpose: wxGDIObject class
// Author: Julian Smart
// Author: AUTHOR
// Modified by:
// Created: 01/02/97
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -19,3 +19,4 @@
IMPLEMENT_DYNAMIC_CLASS(wxGDIObject, wxObject)
#endif
// TODO: Nothing to do, unless you want to.

69
src/qt/icon.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: icon.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxIcon class
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,14 +15,56 @@
#include "wx/icon.h"
//-----------------------------------------------------------------------------
// wxIcon
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxIcon,wxBitmap)
/*
* Icons
*/
wxIcon::wxIcon( char **bits, int WXUNUSED(width), int WXUNUSED(height) ) :
wxBitmap( bits )
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;
}

339
src/qt/joystick.cpp
View File

@@ -1,358 +1,279 @@
/////////////////////////////////////////////////////////////////////////////
// Name: joystick.cpp
// Purpose: wxJoystick class
// Author: Ported to Linux by Guilhem Lavaux
// Author: AUTHOR
// Modified by:
// Created: 05/23/98
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) Guilhem Lavaux
// Licence: wxWindows license
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "joystick.h"
#endif
#include <linux/joystick.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include "wx/event.h"
#include "wx/window.h"
#include "wx/gtk/joystick.h"
#define JOYSTICK_AXE_MAX 32767
#define JOYSTICK_AXE_MIN -32767
#include <wx/joystick.h>
IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
wxJoystick::wxJoystick(int joystick)
{
wxString dev_name;
// Assume it's the same device name on all Linux systems ...
dev_name.Printf("/dev/js%d", (joystick == wxJOYSTICK1) ? 0 : 1);
m_joystick = open(dev_name, O_RDWR);
m_lastposition = wxPoint(-1, -1);
for (int i=0;i<15;i++)
m_axe[i] = 0;
if (m_joystick != -1)
Create();
}
////////////////////////////////////////////////////////////////////////////
// Background thread
////////////////////////////////////////////////////////////////////////////
void *wxJoystick::Entry(void)
{
struct js_event j_evt;
wxJoystickEvent jwx_event;
fd_set read_fds;
struct timeval time_out = {0, 0};
FD_ZERO(&read_fds);
DeferDestroy(TRUE);
while (1) {
TestDestroy();
if (m_polling) {
FD_SET(m_joystick, &read_fds);
select(m_joystick+1, &read_fds, NULL, NULL, &time_out);
if (FD_ISSET(m_joystick, &read_fds))
read(m_joystick, &j_evt, sizeof(j_evt));
else
j_evt.type = 0;
} else {
read(m_joystick, &j_evt, sizeof(j_evt));
}
if ((j_evt.type & JS_EVENT_AXIS) == JS_EVENT_AXIS) {
switch (j_evt.number) {
case 1:
m_lastposition.x = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
case 2:
m_lastposition.y = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
case 3:
m_axe[3] = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_ZMOVE);
break;
default:
m_axe[j_evt.number] = j_evt.value;
jwx_event.SetEventType(wxEVT_JOY_MOVE);
break;
}
jwx_event.SetPosition(m_lastposition);
jwx_event.SetZPosition(m_axe[3]);
}
if ((j_evt.type & JS_EVENT_BUTTON) == JS_EVENT_BUTTON) {
register int mask = 1 << j_evt.number;
char button = m_buttons & mask;
m_buttons &= ~mask;
if (button) {
jwx_event.SetEventType(wxEVT_JOY_BUTTON_UP);
} else {
jwx_event.SetEventType(wxEVT_JOY_BUTTON_DOWN);
m_buttons |= mask;
}
jwx_event.SetButtonState(m_buttons);
jwx_event.SetButtonChange(j_evt.number);
}
}
if (m_catchwin)
m_catchwin->ProcessEvent(jwx_event);
if (m_polling)
usleep(m_polling*1000);
}
////////////////////////////////////////////////////////////////////////////
// State
// Attributes
////////////////////////////////////////////////////////////////////////////
wxPoint wxJoystick::GetPosition(void) const
wxPoint wxJoystick::GetPosition() const
{
return m_lastposition;
// TODO
return wxPoint(0, 0);
}
int wxJoystick::GetZPosition(void) const
int wxJoystick::GetZPosition() const
{
return m_axe[3];
// TODO
return 0;
}
int wxJoystick::GetButtonState(void) const
int wxJoystick::GetButtonState() const
{
return m_buttons;
// TODO
return 0;
}
int wxJoystick::GetPOVPosition(void) const
int wxJoystick::GetPOVPosition() const
{
return 0;
// TODO
return 0;
}
int wxJoystick::GetPOVCTSPosition(void) const
int wxJoystick::GetPOVCTSPosition() const
{
return 0;
// TODO
return 0;
}
int wxJoystick::GetRudderPosition(void) const
int wxJoystick::GetRudderPosition() const
{
return m_axe[4];
// TODO
return 0;
}
int wxJoystick::GetUPosition(void) const
int wxJoystick::GetUPosition() const
{
return m_axe[5];
// TODO
return 0;
}
int wxJoystick::GetVPosition(void) const
int wxJoystick::GetVPosition() const
{
return m_axe[6];
// TODO
return 0;
}
int wxJoystick::GetMovementThreshold(void) const
int wxJoystick::GetMovementThreshold() const
{
return 0;
// TODO
return 0;
}
void wxJoystick::SetMovementThreshold(int threshold)
{
// TODO
}
////////////////////////////////////////////////////////////////////////////
// Capabilities
////////////////////////////////////////////////////////////////////////////
bool wxJoystick::IsOk(void) const
bool wxJoystick::IsOk() const
{
return (m_joystick != -1);
// TODO
return FALSE;
}
int wxJoystick::GetNumberJoysticks(void) const
int wxJoystick::GetNumberJoysticks() const
{
wxString dev_name;
int fd, j;
for (j=0;j<2;j++) {
dev_name.Printf("/dev/js%d", j);
fd = open(dev_name, O_RDONLY);
if (fd == -1)
return j;
close(fd);
}
return j;
// TODO
return 0;
}
int wxJoystick::GetManufacturerId(void) const
int wxJoystick::GetManufacturerId() const
{
return 0;
// TODO
return 0;
}
int wxJoystick::GetProductId(void) const
int wxJoystick::GetProductId() const
{
return 0;
// TODO
return 0;
}
wxString wxJoystick::GetProductName(void) const
wxString wxJoystick::GetProductName() const
{
return "";
// TODO
return wxString("");
}
int wxJoystick::GetXMin(void) const
int wxJoystick::GetXMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetYMin(void) const
int wxJoystick::GetYMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetZMin(void) const
int wxJoystick::GetZMin() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetXMax(void) const
int wxJoystick::GetXMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetYMax(void) const
int wxJoystick::GetYMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetZMax(void) const
int wxJoystick::GetZMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetNumberButtons(void) const
int wxJoystick::GetNumberButtons() const
{
int nb;
ioctl(m_joystick, JSIOCGBUTTONS, &nb);
return nb;
// TODO
return 0;
}
int wxJoystick::GetNumberAxes(void) const
int wxJoystick::GetNumberAxes() const
{
int nb;
ioctl(m_joystick, JSIOCGAXES, &nb);
return nb;
// TODO
return 0;
}
int wxJoystick::GetMaxButtons(void) const
int wxJoystick::GetMaxButtons() const
{
return 15; // internal
// TODO
return 0;
}
int wxJoystick::GetMaxAxes(void) const
int wxJoystick::GetMaxAxes() const
{
return 15; // internal
// TODO
return 0;
}
int wxJoystick::GetPollingMin(void) const
int wxJoystick::GetPollingMin() const
{
return -1;
// TODO
return 0;
}
int wxJoystick::GetPollingMax(void) const
int wxJoystick::GetPollingMax() const
{
return -1;
// TODO
return 0;
}
int wxJoystick::GetRudderMin(void) const
int wxJoystick::GetRudderMin() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetRudderMax(void) const
int wxJoystick::GetRudderMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetUMin(void) const
int wxJoystick::GetUMin() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetUMax(void) const
int wxJoystick::GetUMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
int wxJoystick::GetVMin(void) const
int wxJoystick::GetVMin() const
{
return JOYSTICK_AXE_MIN;
// TODO
return 0;
}
int wxJoystick::GetVMax(void) const
int wxJoystick::GetVMax() const
{
return JOYSTICK_AXE_MAX;
// TODO
return 0;
}
bool wxJoystick::HasRudder(void) const
bool wxJoystick::HasRudder() const
{
return GetNumberAxes() >= 4;
// TODO
return FALSE;
}
bool wxJoystick::HasZ(void) const
bool wxJoystick::HasZ() const
{
return GetNumberAxes() >= 3;
// TODO
return FALSE;
}
bool wxJoystick::HasU(void) const
bool wxJoystick::HasU() const
{
return GetNumberAxes() >= 5;
// TODO
return FALSE;
}
bool wxJoystick::HasV(void) const
bool wxJoystick::HasV() const
{
return GetNumberAxes() >= 6;
// TODO
return FALSE;
}
bool wxJoystick::HasPOV(void) const
bool wxJoystick::HasPOV() const
{
return FALSE;
// TODO
return FALSE;
}
bool wxJoystick::HasPOV4Dir(void) const
bool wxJoystick::HasPOV4Dir() const
{
return FALSE;
// TODO
return FALSE;
}
bool wxJoystick::HasPOVCTS(void) const
bool wxJoystick::HasPOVCTS() const
{
return FALSE;
// TODO
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
// Operations
////////////////////////////////////////////////////////////////////////////
bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq = 0)
bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
{
m_catchwin = win;
m_polling = pollingFreq;
return TRUE;
// TODO
return FALSE;
}
bool wxJoystick::ReleaseCapture(void)
bool wxJoystick::ReleaseCapture()
{
m_catchwin = NULL;
m_polling = 0;
return TRUE;
// TODO
return FALSE;
}

301
src/qt/listbox.cpp
View File

@@ -1,137 +1,240 @@
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: listbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// 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/dynarray.h"
#include "wx/listbox.h"
#include "wx/utils.h"
//-----------------------------------------------------------------------------
// wxListBox
//-----------------------------------------------------------------------------
#include "wx/dynarray.h"
#include "wx/log.h"
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxListBox,wxControl)
// ============================================================================
// list box control implementation
// ============================================================================
wxListBox::wxListBox(void)
// Listbox item
wxListBox::wxListBox()
{
};
m_noItems = 0;
m_selected = 0;
}
wxListBox::wxListBox( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
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)
{
Create( parent, id, pos, size, n, choices, style, name );
};
m_noItems = n;
m_selected = 0;
bool wxListBox::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxString &name )
{
return TRUE;
};
SetName(name);
SetValidator(validator);
void wxListBox::Append( const wxString &item )
{
Append( item, (char*)NULL );
};
if (parent) parent->AddChild(this);
void wxListBox::Append( const wxString &WXUNUSED(item), char *WXUNUSED(clientData) )
{
};
wxSystemSettings settings;
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
void wxListBox::Clear(void)
{
};
m_windowId = ( id == -1 ) ? (int)NewControlId() : id;
void wxListBox::Delete( int WXUNUSED(n) )
{
};
// TODO create listbox
void wxListBox::Deselect( int WXUNUSED(n) )
{
};
int wxListBox::FindString( const wxString &WXUNUSED(item) ) const
{
return -1;
};
char *wxListBox::GetClientData( int WXUNUSED(n) ) const
{
return (char*)NULL;
};
int wxListBox::GetSelection(void) const
{
return -1;
};
int wxListBox::GetSelections( wxArrayInt& WXUNUSED(aSelections) ) const
{
return 0;
};
wxString wxListBox::GetString( int WXUNUSED(n) ) const
{
return "";
};
wxString wxListBox::GetStringSelection(void) const
{
return "";
};
int wxListBox::Number(void)
{
return 0;
};
bool wxListBox::Selected( int WXUNUSED(n) )
{
return FALSE;
};
}
void wxListBox::Set( int WXUNUSED(n), const wxString *WXUNUSED(choices) )
wxListBox::~wxListBox()
{
};
}
void wxListBox::SetClientData( int WXUNUSED(n), char *WXUNUSED(clientData) )
void wxListBox::SetupColours()
{
};
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
}
void wxListBox::SetFirstItem( int WXUNUSED(n) )
void wxListBox::SetFirstItem(int N)
{
};
// TODO
}
void wxListBox::SetFirstItem( const wxString &WXUNUSED(item) )
void wxListBox::SetFirstItem(const wxString& s)
{
};
// TODO
}
void wxListBox::SetSelection( int WXUNUSED(n), bool WXUNUSED(select) )
void wxListBox::Delete(int N)
{
};
m_noItems --;
// TODO
}
void wxListBox::SetString( int WXUNUSED(n), const wxString &WXUNUSED(string) )
void wxListBox::Append(const wxString& item)
{
};
m_noItems ++;
void wxListBox::SetStringSelection( const wxString &WXUNUSED(string), bool WXUNUSED(select) )
// 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);
}

398
src/qt/mdi.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: mdi.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: MDI classes
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -13,217 +14,250 @@
#endif
#include "wx/mdi.h"
#include "wx/dialog.h"
#include "wx/menu.h"
//-----------------------------------------------------------------------------
extern wxList wxModelessWindows;
extern wxList wxPendingDelete;
//-----------------------------------------------------------------------------
// wxMDIParentFrame
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)
#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()
wxMDIParentFrame::wxMDIParentFrame(void)
{
m_clientWindow = NULL;
m_currentChild = NULL;
m_parentFrameActive = TRUE;
};
wxMDIParentFrame::wxMDIParentFrame( wxWindow *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
m_clientWindow = NULL;
m_currentChild = NULL;
m_parentFrameActive = TRUE;
Create( parent, id, title, pos, size, style, name );
};
wxMDIParentFrame::~wxMDIParentFrame(void)
{
};
bool wxMDIParentFrame::Create( wxWindow *parent,
wxWindowID id, const wxString& title,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
wxFrame::Create( parent, id, title, pos, size, style, name );
OnCreateClient();
return TRUE;
};
void wxMDIParentFrame::GetClientSize(int *width, int *height ) const
{
wxFrame::GetClientSize( width, height );
};
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild(void) const
{
return m_currentChild;
};
wxMDIClientWindow *wxMDIParentFrame::GetClientWindow(void) const
{
return m_clientWindow;
};
wxMDIClientWindow *wxMDIParentFrame::OnCreateClient(void)
{
m_clientWindow = new wxMDIClientWindow( this );
return m_clientWindow;
};
void wxMDIParentFrame::ActivateNext(void)
{
};
void wxMDIParentFrame::ActivatePrevious(void)
{
};
void wxMDIParentFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
{
};
void wxMDIParentFrame::OnSysColourChanged( wxSysColourChangedEvent& WXUNUSED(event) )
{
};
//-----------------------------------------------------------------------------
// wxMDIChildFrame
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
BEGIN_EVENT_TABLE(wxMDIClientWindow, wxWindow)
EVT_SCROLL(wxMDIClientWindow::OnScroll)
END_EVENT_TABLE()
wxMDIChildFrame::wxMDIChildFrame(void)
{
};
#endif
wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
wxWindowID id, const wxString& title,
const wxPoint& WXUNUSED(pos), const wxSize& size,
long style, const wxString& name )
{
Create( parent, id, title, wxDefaultPosition, size, style, name );
};
// Parent frame
wxMDIChildFrame::~wxMDIChildFrame(void)
wxMDIParentFrame::wxMDIParentFrame()
{
};
bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
wxWindowID id, const wxString& title,
const wxPoint& WXUNUSED(pos), const wxSize& size,
long style, const wxString& name )
{
m_title = title;
return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
};
void wxMDIChildFrame::GetClientSize( int *width, int *height ) const
{
wxWindow::GetClientSize( width, height );
}
void wxMDIChildFrame::AddChild( wxWindow *child )
bool wxMDIParentFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
wxWindow::AddChild( child );
}
static void SetInvokingWindow( wxMenu *menu, wxWindow *win )
{
menu->SetInvokingWindow( win );
wxNode *node = menu->m_items.First();
while (node)
{
wxMenuItem *menuitem = (wxMenuItem*)node->Data();
if (menuitem->IsSubMenu())
SetInvokingWindow( menuitem->GetSubMenu(), win );
node = node->Next();
};
};
if (!parent)
wxTopLevelWindows.Append(this);
void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
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()
{
m_menuBar = menu_bar;
if (m_menuBar)
{
wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->m_parent;
if (m_menuBar->m_parent != this)
}
// 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)
{
wxNode *node = m_menuBar->m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
SetInvokingWindow( menu, this );
node = node->Next();
};
m_menuBar->m_parent = mdi_frame;
m_frameMenuBar = NULL;
return;
}
mdi_frame->SetMDIMenuBar( m_menuBar );
if (menu_bar->m_menuBarFrame)
return;
}
};
m_frameMenuBar = menu_bar;
}
wxMenuBar *wxMDIChildFrame::GetMenuBar()
void wxMDIParentFrame::OnSize(wxSizeEvent& event)
{
return m_menuBar;
};
#if USE_CONSTRAINTS
if (GetAutoLayout())
Layout();
#endif
int x = 0;
int y = 0;
int width, height;
GetClientSize(&width, &height);
void wxMDIChildFrame::Activate(void)
if ( GetClientWindow() )
GetClientWindow()->SetSize(x, y, width, height);
}
void wxMDIParentFrame::OnActivate(wxActivateEvent& event)
{
};
// Do nothing
}
void wxMDIChildFrame::OnActivate( wxActivateEvent &WXUNUSED(event) )
// Returns the active MDI child window
wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
{
};
// TODO
return NULL;
}
//-----------------------------------------------------------------------------
// wxMDIClientWindow
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
wxMDIClientWindow::wxMDIClientWindow(void)
// Create the client window class (don't Create the window,
// just return a new class)
wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
{
};
return new wxMDIClientWindow ;
}
wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
// Responds to colour changes, and passes event on to children.
void wxMDIParentFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
CreateClient( parent, style );
};
// TODO
wxMDIClientWindow::~wxMDIClientWindow(void)
// Propagate the event to the non-top-level children
wxFrame::OnSysColourChanged(event);
}
// MDI operations
void wxMDIParentFrame::Cascade()
{
};
// TODO
}
bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *WXUNUSED(parent), long WXUNUSED(style) )
void wxMDIParentFrame::Tile()
{
return TRUE;
};
// TODO
}
void wxMDIClientWindow::AddChild( wxWindow *WXUNUSED(child) )
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
}

779
src/qt/menu.cpp
View File

@@ -1,293 +1,568 @@
/////////////////////////////////////////////////////////////////////////////
// Name: menu.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// 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"
//-----------------------------------------------------------------------------
// wxMenuBar
//-----------------------------------------------------------------------------
// other standard headers
// ----------------------
#include <string.h>
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar,wxWindow)
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxMenu, wxEvtHandler)
IMPLEMENT_DYNAMIC_CLASS(wxMenuBar, wxEvtHandler)
#endif
wxMenuBar::wxMenuBar()
// ============================================================================
// implementation
// ============================================================================
// Menus
// Construct a menu with optional title (then use append)
wxMenu::wxMenu(const wxString& title, const wxFunction func)
{
};
m_title = title;
m_parent = NULL;
m_eventHandler = this;
m_noItems = 0;
m_menuBar = NULL;
if (m_title != "")
{
Append(-2, m_title) ;
AppendSeparator() ;
}
void wxMenuBar::Append( wxMenu *menu, const wxString &title )
{
m_menus.Append( menu );
menu->m_title = title; // ??????
Callback(func);
int pos;
do {
pos = menu->m_title.First( '&' );
if (pos != -1) menu->m_title.Remove( pos, 1 );
} while (pos != -1);
};
static int FindMenuItemRecursive( const wxMenu *menu, const wxString &menuString, const wxString &itemString )
{
if (menu->m_title == menuString)
{
int res = menu->FindItem( itemString );
if (res != -1) return res;
};
wxNode *node = menu->m_items.First();
while (node)
{
wxMenuItem *item = (wxMenuItem*)node->Data();
if (item->IsSubMenu())
return FindMenuItemRecursive(item->GetSubMenu(), menuString, itemString);
node = node->Next();
};
return -1;
};
int wxMenuBar::FindMenuItem( const wxString &menuString, const wxString &itemString ) const
{
wxNode *node = m_menus.First();
while (node)
{
wxMenu *menu = (wxMenu*)node->Data();
int res = FindMenuItemRecursive( menu, menuString, itemString);
if (res != -1) return res;
node = node->Next();
};
return -1;
};
// Find a wxMenuItem using its id. Recurses down into sub-menus
static wxMenuItem* FindMenuItemByIdRecursive(const wxMenu* menu, int id)
{
wxMenuItem* result = menu->FindItem(id);
wxNode *node = menu->m_items.First();
while ( node && result == NULL ) {
wxMenuItem *item = (wxMenuItem*)node->Data();
if ( item->IsSubMenu() )
result = FindMenuItemByIdRecursive( item->GetSubMenu(), id );
node = node->Next();
};
return result;
};
wxMenuItem* wxMenuBar::FindMenuItemById( int id ) const
{
wxMenuItem* result = 0;
wxNode *node = m_menus.First();
while (node && result == 0)
{
wxMenu *menu = (wxMenu*)node->Data();
result = FindMenuItemByIdRecursive( menu, id );
node = node->Next();
}
return result;
// TODO create menu
}
void wxMenuBar::Check( int id, bool check )
// The wxWindow destructor will take care of deleting the submenus.
wxMenu::~wxMenu()
{
wxMenuItem* item = FindMenuItemById( id );
if (item) item->Check(check);
};
// TODO destroy menu and children
bool wxMenuBar::Checked( int id ) const
{
wxMenuItem* item = FindMenuItemById( id );
if (item) return item->IsChecked();
return FALSE;
};
wxNode *node = m_menuItems.First();
while (node)
{
wxMenuItem *item = (wxMenuItem *)node->Data();
void wxMenuBar::Enable( int id, bool enable )
{
wxMenuItem* item = FindMenuItemById( id );
if (item) item->Enable(enable);
};
// Delete child menus.
// Beware: they must not be appended to children list!!!
// (because order of delete is significant)
if (item->GetSubMenu())
item->DeleteSubMenu();
bool wxMenuBar::Enabled( int id ) const
{
wxMenuItem* item = FindMenuItemById( id );
if (item) return item->IsEnabled();
return FALSE;
};
//-----------------------------------------------------------------------------
// wxMenu
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxMenuItem,wxObject)
wxMenuItem::wxMenuItem()
{
m_id = ID_SEPARATOR;
m_isCheckMenu = FALSE;
m_isChecked = FALSE;
m_isEnabled = TRUE;
m_subMenu = NULL;
};
void wxMenuItem::SetText(const wxString& str)
{
for ( const char *pc = str; *pc != '\0'; pc++ ) {
if ( *pc == '&' )
pc++; // skip it
m_text << *pc;
}
wxNode *next = node->Next();
delete item;
delete node;
node = next;
}
}
void wxMenuItem::Check( bool check )
void wxMenu::Break()
{
wxCHECK_RET( IsCheckable(), "can't check uncheckable item!" )
m_isChecked = check;
// TODO
}
bool wxMenuItem::IsChecked() const
// function appends a new item or submenu to the menu
void wxMenu::Append(wxMenuItem *pItem)
{
wxCHECK( IsCheckable(), FALSE ); // can't get state of uncheckable item!
// TODO
return FALSE;
wxCHECK_RET( pItem != NULL, "can't append NULL item to the menu" );
m_menuItems.Append(pItem);
m_noItems++;
}
IMPLEMENT_DYNAMIC_CLASS(wxMenu,wxEvtHandler)
wxMenu::wxMenu( const wxString &title )
{
m_title = title;
m_items.DeleteContents( TRUE );
m_invokingWindow = NULL;
};
void wxMenu::AppendSeparator()
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(ID_SEPARATOR);
m_items.Append( mitem );
};
void wxMenu::Append( int id, const wxString &item, const wxString &helpStr, bool checkable )
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(id);
mitem->SetText(item);
mitem->SetHelpString(helpStr);
mitem->SetCheckable(checkable);
m_items.Append( mitem );
};
void wxMenu::Append( int id, const wxString &text, wxMenu *subMenu, const wxString &helpStr )
{
wxMenuItem *mitem = new wxMenuItem();
mitem->SetId(id);
mitem->SetText(text);
mitem->SetHelpString(helpStr);
mitem->SetSubMenu(subMenu);
m_items.Append( mitem );
};
int wxMenu::FindItem( const wxString itemString ) const
{
wxString s( itemString );
int pos;
do {
pos = s.First( '&' );
if (pos != -1) s.Remove( pos, 1 );
} while (pos != -1);
wxNode *node = m_items.First();
while (node)
{
wxMenuItem *item = (wxMenuItem*)node->Data();
if (item->GetText() == s)
return item->GetId();
node = node->Next();
};
return -1;
};
void wxMenu::Enable( int id, bool enable )
{
wxMenuItem *item = FindItem(id);
if ( item )
item->Enable(enable);
};
bool wxMenu::IsEnabled( int id ) const
{
wxMenuItem *item = FindItem(id);
if ( item )
return item->IsEnabled();
else
return FALSE;
};
void wxMenu::Check( int id, bool enable )
{
wxMenuItem *item = FindItem(id);
if ( item )
item->Check(enable);
};
bool wxMenu::IsChecked( int id ) const
{
wxMenuItem *item = FindItem(id);
if ( item )
return item->IsChecked();
else
return FALSE;
};
void wxMenu::SetLabel( int id, const wxString &label )
{
wxMenuItem *item = FindItem(id);
if ( item )
item->SetText(label);
};
wxMenuItem *wxMenu::FindItem(int id) const
{
wxNode *node = m_items.First();
while (node) {
wxMenuItem *item = (wxMenuItem*)node->Data();
if ( item->GetId() == id )
return item;
node = node->Next();
};
wxLogDebug("wxMenu::FindItem: item %d not found.", id);
return NULL;
// TODO
Append(new wxMenuItem(this, ID_SEPARATOR));
}
void wxMenu::SetInvokingWindow( wxWindow *win )
// Pullright item
void wxMenu::Append(int Id, const wxString& label, wxMenu *SubMenu,
const wxString& helpString)
{
m_invokingWindow = win;
};
Append(new wxMenuItem(this, Id, label, helpString, FALSE, SubMenu));
}
wxWindow *wxMenu::GetInvokingWindow()
// Ordinary menu item
void wxMenu::Append(int Id, const wxString& label,
const wxString& helpString, bool checkable)
{
return m_invokingWindow;
};
// 'checkable' parameter is useless for Windows.
Append(new wxMenuItem(this, Id, label, helpString, checkable));
}
void wxMenu::Delete(int id)
{
wxNode *node;
wxMenuItem *item;
int pos;
for (pos = 0, node = m_menuItems.First(); node; node = node->Next(), pos++) {
item = (wxMenuItem *)node->Data();
if (item->GetId() == id)
break;
}
if (!node)
return;
m_menuItems.DeleteNode(node);
delete item;
// TODO
}
void wxMenu::Enable(int Id, bool Flag)
{
wxMenuItem *item = FindItemForId(Id);
wxCHECK_RET( item != NULL, "can't enable non-existing menu item" );
item->Enable(Flag);
}
bool wxMenu::Enabled(int Id) const
{
wxMenuItem *item = FindItemForId(Id);
wxCHECK( item != NULL, FALSE );
return item->IsEnabled();
}
void wxMenu::Check(int Id, bool Flag)
{
wxMenuItem *item = FindItemForId(Id);
wxCHECK_RET( item != NULL, "can't get status of non-existing menu item" );
item->Check(Flag);
}
bool wxMenu::Checked(int Id) const
{
wxMenuItem *item = FindItemForId(Id);
wxCHECK( item != NULL, FALSE );
return item->IsChecked();
}
void wxMenu::SetTitle(const wxString& label)
{
m_title = label ;
// TODO
}
const wxString& wxMenu::GetTitle() const
{
return m_title;
}
void wxMenu::SetLabel(int id, const wxString& label)
{
wxMenuItem *item = FindItemForId(id) ;
if (item==NULL)
return;
if (item->GetSubMenu()==NULL)
{
// TODO
}
else
{
// TODO
}
item->SetName(label);
}
wxString wxMenu::GetLabel(int Id) const
{
// TODO
return wxString("") ;
}
// Finds the item id matching the given string, -1 if not found.
int wxMenu::FindItem (const wxString& itemString) const
{
char buf1[200];
char buf2[200];
wxStripMenuCodes ((char *)(const char *)itemString, buf1);
for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
{
wxMenuItem *item = (wxMenuItem *) node->Data ();
if (item->GetSubMenu())
{
int ans = item->GetSubMenu()->FindItem(itemString);
if (ans > -1)
return ans;
}
if ( !item->IsSeparator() )
{
wxStripMenuCodes((char *)item->GetName().c_str(), buf2);
if (strcmp(buf1, buf2) == 0)
return item->GetId();
}
}
return -1;
}
wxMenuItem *wxMenu::FindItemForId(int itemId, wxMenu ** itemMenu) const
{
if (itemMenu)
*itemMenu = NULL;
for (wxNode * node = m_menuItems.First (); node; node = node->Next ())
{
wxMenuItem *item = (wxMenuItem *) node->Data ();
if (item->GetId() == itemId)
{
if (itemMenu)
*itemMenu = (wxMenu *) this;
return item;
}
if (item->GetSubMenu())
{
wxMenuItem *ans = item->GetSubMenu()->FindItemForId (itemId, itemMenu);
if (ans)
return ans;
}
}
if (itemMenu)
*itemMenu = NULL;
return NULL;
}
void wxMenu::SetHelpString(int itemId, const wxString& helpString)
{
wxMenuItem *item = FindItemForId (itemId);
if (item)
item->SetHelp(helpString);
}
wxString wxMenu::GetHelpString (int itemId) const
{
wxMenuItem *item = FindItemForId (itemId);
wxString str("");
return (item == NULL) ? str : item->GetHelp();
}
void wxMenu::ProcessCommand(wxCommandEvent & event)
{
bool processed = FALSE;
// Try a callback
if (m_callback)
{
(void) (*(m_callback)) (*this, event);
processed = TRUE;
}
// Try the menu's event handler
if ( !processed && GetEventHandler())
{
processed = GetEventHandler()->ProcessEvent(event);
}
// Try the window the menu was popped up from (and up
// through the hierarchy)
if ( !processed && GetInvokingWindow())
processed = GetInvokingWindow()->ProcessEvent(event);
}
bool wxWindow::PopupMenu(wxMenu *menu, int x, int y)
{
// TODO
return FALSE;
}
// Menu Bar
wxMenuBar::wxMenuBar()
{
m_eventHandler = this;
m_menuCount = 0;
m_menus = NULL;
m_titles = NULL;
m_menuBarFrame = NULL;
// TODO
}
wxMenuBar::wxMenuBar(int n, wxMenu *Mmnus[], const wxString titles[])
{
m_eventHandler = this;
m_menuCount = n;
m_menus = menus;
m_titles = new wxString[n];
int i;
for ( i = 0; i < n; i++ )
m_titles[i] = titles[i];
m_menuBarFrame = NULL;
// TODO
}
wxMenuBar::~wxMenuBar()
{
int i;
for (i = 0; i < m_menuCount; i++)
{
delete m_menus[i];
}
delete[] m_menus;
delete[] m_titles;
// TODO
}
// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus to enable/disable items
void wxMenuBar::Enable(int id, bool flag)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
// TODO
}
void wxMenuBar::EnableTop(int pos, bool flag)
{
// TODO
}
// Must only be used AFTER menu has been attached to frame,
// otherwise use individual menus
void wxMenuBar::Check(int id, bool flag)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
if (!item->IsCheckable())
return ;
// TODO
}
bool wxMenuBar::Checked(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
// TODO
return FALSE;
}
bool wxMenuBar::Enabled(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return FALSE;
// TODO
return FALSE ;
}
void wxMenuBar::SetLabel(int id, const wxString& label)
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return;
// TODO
}
wxString wxMenuBar::GetLabel(int id) const
{
wxMenu *itemMenu = NULL;
wxMenuItem *item = FindItemForId(id, &itemMenu) ;
if (!item)
return wxString("");
// TODO
return wxString("") ;
}
void wxMenuBar::SetLabelTop(int pos, const wxString& label)
{
// TODO
}
wxString wxMenuBar::GetLabelTop(int pos) const
{
// TODO
return wxString("");
}
bool wxMenuBar::OnDelete(wxMenu *a_menu, int pos)
{
// TODO
return FALSE;
}
bool wxMenuBar::OnAppend(wxMenu *a_menu, const char *title)
{
// TODO
return FALSE;
}
void wxMenuBar::Append (wxMenu * menu, const wxString& title)
{
if (!OnAppend(menu, title))
return;
m_menuCount ++;
wxMenu **new_menus = new wxMenu *[m_menuCount];
wxString *new_titles = new wxString[m_menuCount];
int i;
for (i = 0; i < m_menuCount - 1; i++)
{
new_menus[i] = m_menus[i];
m_menus[i] = NULL;
new_titles[i] = m_titles[i];
m_titles[i] = "";
}
if (m_menus)
{
delete[]m_menus;
delete[]m_titles;
}
m_menus = new_menus;
m_titles = new_titles;
m_menus[m_menuCount - 1] = (wxMenu *)menu;
m_titles[m_menuCount - 1] = title;
// TODO
}
void wxMenuBar::Delete(wxMenu * menu, int i)
{
int j;
int ii = (int) i;
if (menu != 0)
{
for (ii = 0; ii < m_menuCount; ii++)
{
if (m_menus[ii] == menu)
break;
}
if (ii >= m_menuCount)
return;
} else
{
if (ii < 0 || ii >= m_menuCount)
return;
menu = m_menus[ii];
}
if (!OnDelete(menu, ii))
return;
menu->SetParent(NULL);
-- m_menuCount;
for (j = ii; j < m_menuCount; j++)
{
m_menus[j] = m_menus[j + 1];
m_titles[j] = m_titles[j + 1];
}
}
// Find the menu menuString, item itemString, and return the item id.
// Returns -1 if none found.
int wxMenuBar::FindMenuItem (const wxString& menuString, const wxString& itemString) const
{
char buf1[200];
char buf2[200];
wxStripMenuCodes ((char *)(const char *)menuString, buf1);
int i;
for (i = 0; i < m_menuCount; i++)
{
wxStripMenuCodes ((char *)(const char *)m_titles[i], buf2);
if (strcmp (buf1, buf2) == 0)
return m_menus[i]->FindItem (itemString);
}
return -1;
}
wxMenuItem *wxMenuBar::FindItemForId (int Id, wxMenu ** itemMenu) const
{
if (itemMenu)
*itemMenu = NULL;
wxMenuItem *item = NULL;
int i;
for (i = 0; i < m_menuCount; i++)
if ((item = m_menus[i]->FindItemForId (Id, itemMenu)))
return item;
return NULL;
}
void wxMenuBar::SetHelpString (int Id, const wxString& helpString)
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (Id))
{
m_menus[i]->SetHelpString (Id, helpString);
return;
}
}
}
wxString wxMenuBar::GetHelpString (int Id) const
{
int i;
for (i = 0; i < m_menuCount; i++)
{
if (m_menus[i]->FindItemForId (Id))
eturn wxString(m_menus[i]->GetHelpString (Id));
}
return wxString("");
}

426
src/qt/notebook.cpp
View File

@@ -1,185 +1,371 @@
/////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: notebook.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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 "wx/notebook.h"
#include "wx/panel.h"
#include "wx/utils.h"
#include "wx/imaglist.h"
#include "wx/log.h"
#include <wx/string.h>
#include <wx/log.h>
#include <wx/imaglist.h>
#include <wx/notebook.h>
//-----------------------------------------------------------------------------
// wxNotebookPage
//-----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// macros
// ----------------------------------------------------------------------------
class wxNotebookPage: public wxObject
{
public:
wxNotebookPage()
{
m_id = -1;
m_text = "";
m_image = -1;
m_page = NULL;
m_client = NULL;
m_parent = NULL;
};
// check that the page index is valid
#define IS_VALID_PAGE(nPage) (((nPage) >= 0) && ((nPage) < GetPageCount()))
//private:
int m_id;
wxString m_text;
int m_image;
wxWindow *m_client;
};
// ----------------------------------------------------------------------------
// event table
// ----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// wxNotebook
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
BEGIN_EVENT_TABLE(wxNotebook, wxControl)
EVT_NOTEBOOK_PAGE_CHANGED(-1, wxNotebook::OnSelChange)
IMPLEMENT_DYNAMIC_CLASS(wxNotebook,wxControl)
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_imageList = NULL;
m_pages.DeleteContents( TRUE );
m_pImageList = NULL;
m_nSelection = -1;
}
// default for dynamic class
wxNotebook::wxNotebook()
{
Init();
};
Init();
}
wxNotebook::wxNotebook( wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
// 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 );
};
Init();
Create(parent, id, pos, size, style, name);
}
// Create() function
bool wxNotebook::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// base init
SetName(name);
SetParent(parent);
m_windowId = id == -1 ? NewControlId() : id;
// colors and font
m_backgroundColour = wxColour(GetSysColor(COLOR_BTNFACE));
m_foregroundColour = *wxBLACK ;
// style
m_windowStyle = style;
if ( parent != NULL )
parent->AddChild(this);
// TODO
return FALSE;
}
// dtor
wxNotebook::~wxNotebook()
{
DeleteAllPages();
};
bool wxNotebook::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
PreCreation( parent, id, pos, size, style, name );
PostCreation();
Show( TRUE );
return TRUE;
};
int wxNotebook::GetSelection() const
{
};
}
// ----------------------------------------------------------------------------
// wxNotebook accessors
// ----------------------------------------------------------------------------
int wxNotebook::GetPageCount() const
{
};
return m_aPages.Count();
}
int wxNotebook::GetRowCount() const
{
};
// TODO
return 0;
}
wxString wxNotebook::GetPageText( int page ) const
int wxNotebook::SetSelection(int nPage)
{
};
wxASSERT( IS_VALID_PAGE(nPage) );
int wxNotebook::GetPageImage( int page ) const
{
};
ChangePage(m_nSelection, nPage);
wxNotebookPage* wxNotebook::GetNotebookPage(int page) const
{
return NULL;
};
int wxNotebook::SetSelection( int page )
{
};
// 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);
}
void wxNotebook::SetImageList( wxImageList* imageList )
bool wxNotebook::SetPageText(int nPage, const wxString& strText)
{
m_imageList = imageList;
};
wxASSERT( IS_VALID_PAGE(nPage) );
bool wxNotebook::SetPageText( int page, const wxString &text )
// TODO
return FALSE;
}
wxString wxNotebook::GetPageText(int nPage) const
{
return TRUE;
};
wxASSERT( IS_VALID_PAGE(nPage) );
bool wxNotebook::SetPageImage( int page, int image )
// TODO
return wxString("");
}
int wxNotebook::GetPageImage(int nPage) const
{
return TRUE;
};
wxASSERT( IS_VALID_PAGE(nPage) );
void wxNotebook::SetPageSize( const wxSize &WXUNUSED(size) )
// TODO
return 0;
}
bool wxNotebook::SetPageImage(int nPage, int nImage)
{
};
wxASSERT( IS_VALID_PAGE(nPage) );
void wxNotebook::SetPadding( const wxSize &WXUNUSED(padding) )
// TODO
return FALSE;
}
void wxNotebook::SetImageList(wxImageList* imageList)
{
m_pImageList = imageList;
// TODO
}
// ----------------------------------------------------------------------------
// wxNotebook operations
// ----------------------------------------------------------------------------
// remove one page from the notebook
bool wxNotebook::DeletePage(int nPage)
{
};
wxCHECK( IS_VALID_PAGE(nPage), FALSE );
// TODO: delete native widget page
delete m_aPages[nPage];
m_aPages.Remove(nPage);
return TRUE;
}
// remove all pages
bool wxNotebook::DeleteAllPages()
{
return TRUE;
};
// TODO: delete native widget pages
bool wxNotebook::DeletePage( int page )
{
return TRUE;
};
int nPageCount = GetPageCount();
int nPage;
for ( nPage = 0; nPage < nPageCount; nPage++ )
delete m_aPages[nPage];
bool wxNotebook::AddPage(wxWindow* win, const wxString& text,
bool bSelect, int imageId)
{
return TRUE;
};
m_aPages.Clear();
wxWindow *wxNotebook::GetPage( int page ) const
{
return NULL;
};
return TRUE;
}
void wxNotebook::AddChild( wxWindow *win )
// add a page to the notebook
bool wxNotebook::AddPage(wxNotebookPage *pPage,
const wxString& strText,
bool bSelect,
int imageId)
{
};
return InsertPage(GetPageCount(), pPage, strText, bSelect, imageId);
}
// same as AddPage() but does it at given position
bool wxNotebook::InsertPage(int nPage,
wxNotebookPage *pPage,
const wxString& strText,
bool bSelect,
int imageId)
{
wxASSERT( pPage != NULL );
wxCHECK( IS_VALID_PAGE(nPage) || nPage == GetPageCount(), FALSE );
// TODO: insert native widget page
// save the pointer to the page
m_aPages.Insert(pPage, nPage);
// some page must be selected: either this one or the first one if there is
// still no selection
if ( bSelect )
m_nSelection = nPage;
else if ( m_nSelection == -1 )
m_nSelection = 0;
return TRUE;
}
// ----------------------------------------------------------------------------
// wxNotebook callbacks
// ----------------------------------------------------------------------------
// @@@ OnSize() is used for setting the font when it's called for the first
// time because doing it in ::Create() doesn't work (for unknown reasons)
void wxNotebook::OnSize(wxSizeEvent& event)
{
static bool s_bFirstTime = TRUE;
if ( s_bFirstTime ) {
// TODO: any first-time-size processing.
s_bFirstTime = FALSE;
}
// TODO: all this may or may not be necessary for your platform
// emulate page change (it's esp. important to do it first time because
// otherwise our page would stay invisible)
int nSel = m_nSelection;
m_nSelection = -1;
SetSelection(nSel);
// fit the notebook page to the tab control's display area
int w, hl
GetSize(&w, &h);
uint nCount = m_aPages.Count();
for ( uint nPage = 0; nPage < nCount; nPage++ ) {
wxNotebookPage *pPage = m_aPages[nPage];
pPage->SetSize(0, 0, w, h);
if ( pPage->GetAutoLayout() )
pPage->Layout();
}
// Processing continues to next OnSize
event.Skip();
}
void wxNotebook::OnSelChange(wxNotebookEvent& event)
{
// is it our tab control?
if ( event.GetEventObject() == this )
ChangePage(event.GetOldSelection(), event.GetSelection());
// we want to give others a chance to process this message as well
event.Skip();
}
void wxNotebook::OnSetFocus(wxFocusEvent& event)
{
// set focus to the currently selected page if any
if ( m_nSelection != -1 )
m_aPages[m_nSelection]->SetFocus();
event.Skip();
}
void wxNotebook::OnNavigationKey(wxNavigationKeyEvent& event)
{
if ( event.IsWindowChange() ) {
// change pages
AdvanceSelection(event.GetDirection());
}
else {
// pass to the parent
if ( GetParent() ) {
event.SetCurrentFocus(this);
GetParent()->ProcessEvent(event);
}
}
}
// ----------------------------------------------------------------------------
// wxNotebook base class virtuals
// ----------------------------------------------------------------------------
// override these 2 functions to do nothing: everything is done in OnSize
void wxNotebook::SetConstraintSizes( bool WXUNUSED(recurse) )
void wxNotebook::SetConstraintSizes(bool /* recurse */)
{
// don't set the sizes of the pages - their correct size is not yet known
wxControl::SetConstraintSizes(FALSE);
// don't set the sizes of the pages - their correct size is not yet known
wxControl::SetConstraintSizes(FALSE);
}
bool wxNotebook::DoPhase( int WXUNUSED(nPhase) )
bool wxNotebook::DoPhase(int /* nPhase */)
{
return TRUE;
return TRUE;
}
//-----------------------------------------------------------------------------
// wxNotebookEvent
//-----------------------------------------------------------------------------
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;
}
IMPLEMENT_DYNAMIC_CLASS(wxNotebookEvent, wxCommandEvent)

126
src/qt/palette.cpp
View File

@@ -1,103 +1,91 @@
/////////////////////////////////////////////////////////////////////////////
// Name: palette.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxPalette
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxPalette, wxGDIObject)
#endif
class wxPaletteRefData: public wxObjectRefData
/*
* Palette
*
*/
wxPaletteRefData::wxPaletteRefData()
{
public:
wxPaletteRefData(void);
~wxPaletteRefData(void);
};
// TODO
}
wxPaletteRefData::wxPaletteRefData(void)
wxPaletteRefData::~wxPaletteRefData()
{
};
// TODO
}
wxPaletteRefData::~wxPaletteRefData(void)
wxPalette::wxPalette()
{
};
}
//-----------------------------------------------------------------------------
#define M_PALETTEDATA ((wxPaletteRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxPalette,wxGDIObject)
wxPalette::wxPalette(void)
wxPalette::wxPalette(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
};
Create(n, red, green, blue);
}
wxPalette::wxPalette( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue )
wxPalette::~wxPalette()
{
m_refData = new wxPaletteRefData();
Create( n, red, green, blue );
};
}
wxPalette::wxPalette( const wxPalette& palette )
bool wxPalette::FreeResource(bool force)
{
Ref( palette );
};
if ( M_PALETTEDATA && M_PALETTEDATA->m_hPalette)
{
DeleteObject((HPALETTE)M_PALETTEDATA->m_hPalette);
}
return TRUE;
}
wxPalette::wxPalette( const wxPalette* palette )
bool wxPalette::Create(int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
UnRef();
if (palette) Ref( *palette );
};
wxPalette::~wxPalette(void)
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;
wxPalette& wxPalette::operator = ( const wxPalette& palette )
// TODO
return FALSE;
}
bool wxPalette::GetRGB(int index, unsigned char *red, unsigned char *green, unsigned char *blue) const
{
if (*this == palette) return (*this);
Ref( palette );
return *this;
};
if ( !m_refData )
return FALSE;
bool wxPalette::operator == ( const wxPalette& palette )
{
return m_refData == palette.m_refData;
};
if (index < 0 || index > 255)
return FALSE;
bool wxPalette::operator != ( const wxPalette& palette )
{
return m_refData != palette.m_refData;
};
// TODO
return FALSE;
}
bool wxPalette::Ok(void) const
{
return (m_refData);
};
bool wxPalette::Create( int n, const unsigned char *red, const unsigned char *green, const unsigned char *blue)
{
};
int wxPalette::GetPixel( const unsigned char red, const unsigned char green, const unsigned char blue ) const
{
};
bool wxPalette::GetRGB( int pixel, unsigned char *red, unsigned char *green, unsigned char *blue ) const
{
};

365
src/qt/pen.cpp
View File

@@ -1,204 +1,229 @@
/////////////////////////////////////////////////////////////////////////////
// Name: pen.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxPen
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxPen, wxGDIObject)
#endif
class wxPenRefData: public wxObjectRefData
wxPenRefData::wxPenRefData()
{
public:
m_style = wxSOLID;
m_width = 1;
m_join = wxJOIN_ROUND ;
m_cap = wxCAP_ROUND ;
m_nbDash = 0 ;
m_dash = 0 ;
/* TODO: null data
m_hPen = 0;
*/
}
wxPenRefData::wxPenRefData(const wxPenRefData& data)
{
m_style = data.m_style;
m_width = data.m_width;
m_join = data.m_join;
m_cap = data.m_cap;
m_nbDash = data.m_nbDash;
m_dash = data.m_dash;
m_colour = data.m_colour;
/* TODO: null data
m_hPen = 0;
*/
}
wxPenRefData::~wxPenRefData()
{
// TODO: delete data
}
// Pens
wxPen::wxPen()
{
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::~wxPen()
{
if (wxThePenList)
wxThePenList->RemovePen(this);
}
// Should implement Create
wxPen::wxPen(const wxColour& col, int Width, int Style)
{
m_refData = new wxPenRefData;
M_PENDATA->m_colour = col;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = Style;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::wxPen(const wxBitmap& stipple, int Width)
{
m_refData = new wxPenRefData;
M_PENDATA->m_stipple = stipple;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = wxSTIPPLE;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
wxPen::wxPen(const wxString& col, int Width, int Style)
{
m_refData = new wxPenRefData;
M_PENDATA->m_colour = col;
M_PENDATA->m_width = Width;
M_PENDATA->m_style = Style;
M_PENDATA->m_join = wxJOIN_ROUND ;
M_PENDATA->m_cap = wxCAP_ROUND ;
M_PENDATA->m_nbDash = 0 ;
M_PENDATA->m_dash = 0 ;
RealizeResource();
if ( wxThePenList )
wxThePenList->AddPen(this);
}
void wxPen::Unshare()
{
// Don't change shared data
if (!m_refData)
{
m_refData = new wxPenRefData();
}
else
{
wxPenRefData* ref = new wxPenRefData(*(wxPenRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
void wxPen::SetColour(const wxColour& col)
{
Unshare();
M_PENDATA->m_colour = col;
wxPenRefData(void);
RealizeResource();
}
void wxPen::SetColour(const wxString& col)
{
Unshare();
M_PENDATA->m_colour = col;
int m_width;
int m_style;
int m_joinStyle;
int m_capStyle;
wxColour m_colour;
};
RealizeResource();
}
wxPenRefData::wxPenRefData(void)
void wxPen::SetColour(const unsigned char r, const unsigned char g, const unsigned char b)
{
m_width = 1;
m_style = wxSOLID;
m_joinStyle = wxJOIN_ROUND;
m_capStyle = wxCAP_ROUND;
};
Unshare();
//-----------------------------------------------------------------------------
M_PENDATA->m_colour.Set(r, g, b);
RealizeResource();
}
#define M_PENDATA ((wxPenRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxPen,wxGDIObject)
wxPen::wxPen(void)
void wxPen::SetWidth(int Width)
{
if (wxThePenList) wxThePenList->AddPen( this );
};
Unshare();
wxPen::wxPen( const wxColour &colour, int width, int style )
M_PENDATA->m_width = Width;
RealizeResource();
}
void wxPen::SetStyle(int Style)
{
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
M_PENDATA->m_style = style;
M_PENDATA->m_colour = colour;
if (wxThePenList) wxThePenList->AddPen( this );
};
Unshare();
wxPen::wxPen( const wxString &colourName, int width, int style )
M_PENDATA->m_style = Style;
RealizeResource();
}
void wxPen::SetStipple(const wxBitmap& Stipple)
{
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
M_PENDATA->m_style = style;
M_PENDATA->m_colour = colourName;
if (wxThePenList) wxThePenList->AddPen( this );
};
Unshare();
wxPen::wxPen( const wxPen& pen )
M_PENDATA->m_stipple = Stipple;
M_PENDATA->m_style = wxSTIPPLE;
RealizeResource();
}
void wxPen::SetDashes(int nb_dashes, const wxDash *Dash)
{
Ref( pen );
if (wxThePenList) wxThePenList->AddPen( this );
};
Unshare();
wxPen::wxPen( const wxPen* pen )
M_PENDATA->m_nbDash = nb_dashes;
M_PENDATA->m_dash = (wxDash *)Dash;
RealizeResource();
}
void wxPen::SetJoin(int Join)
{
UnRef();
if (pen) Ref( *pen );
if (wxThePenList) wxThePenList->AddPen( this );
};
Unshare();
wxPen::~wxPen(void)
M_PENDATA->m_join = Join;
RealizeResource();
}
void wxPen::SetCap(int Cap)
{
if (wxThePenList) wxThePenList->RemovePen( this );
};
Unshare();
wxPen& wxPen::operator = ( const wxPen& pen )
M_PENDATA->m_cap = Cap;
RealizeResource();
}
bool wxPen::RealizeResource()
{
if (*this == pen) return (*this);
Ref( pen );
return *this;
};
// TODO: create actual pen
return FALSE;
}
bool wxPen::operator == ( const wxPen& pen )
{
return m_refData == pen.m_refData;
};
bool wxPen::operator != ( const wxPen& pen )
{
return m_refData != pen.m_refData;
};
void wxPen::SetColour( const wxColour &colour )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_colour = colour;
};
void wxPen::SetColour( const wxString &colourName )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_colour = colourName;
};
void wxPen::SetColour( int red, int green, int blue )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_colour.Set( red, green, blue );
};
void wxPen::SetCap( int capStyle )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_capStyle = capStyle;
};
void wxPen::SetJoin( int joinStyle )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_joinStyle = joinStyle;
};
void wxPen::SetStyle( int style )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_style = style;
};
void wxPen::SetWidth( int width )
{
if (!m_refData)
m_refData = new wxPenRefData();
M_PENDATA->m_width = width;
};
int wxPen::GetCap(void) const
{
return M_PENDATA->m_capStyle;
};
int wxPen::GetJoin(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_joinStyle;
};
int wxPen::GetStyle(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_style;
};
int wxPen::GetWidth(void) const
{
if (!m_refData)
return 0;
else
return M_PENDATA->m_width;
};
wxColour &wxPen::GetColour(void) const
{
if (!m_refData)
return wxNullColour;
else
return M_PENDATA->m_colour;
};
bool wxPen::Ok(void) const
{
return (m_refData);
};

219
src/qt/radiobox.cpp
View File

@@ -1,133 +1,194 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
#include "wx/dialog.h"
#include "wx/frame.h"
//-----------------------------------------------------------------------------
// data
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxRadioBox, wxControl)
#endif
extern bool g_blockEventsOnDrag;
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxRadioBox,wxControl)
wxRadioBox::wxRadioBox(void)
// Radio box item
wxRadioBox::wxRadioBox()
{
};
m_selectedButton = -1;
m_noItems = 0;
m_noRowsOrCols = 0;
m_majorDim = 0 ;
}
wxRadioBox::wxRadioBox( wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
int majorDim, long style,
const wxString &name )
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)
{
Create( parent, id, title, pos, size, n, choices, majorDim, style, name );
};
m_selectedButton = -1;
m_noItems = n;
bool wxRadioBox::Create( wxWindow *parent, wxWindowID id, const wxString& title,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
int WXUNUSED(majorDim), long style,
const wxString &name )
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()
{
return TRUE;
};
// TODO
}
bool wxRadioBox::Show( bool show )
wxString wxRadioBox::GetLabel(int item) const
{
wxWindow::Show( show );
return TRUE;
};
// TODO
return wxString("");
}
int wxRadioBox::FindString( const wxString &s ) const
void wxRadioBox::SetLabel(int item, const wxString& label)
{
return -1;
};
// TODO
}
void wxRadioBox::SetSelection( int n )
int wxRadioBox::FindString(const wxString& s) const
{
};
// TODO
return -1;
}
int wxRadioBox::GetSelection(void) const
void wxRadioBox::SetSelection(int n)
{
return -1;
};
if ((n < 0) || (n >= m_noItems))
return;
// TODO
wxString wxRadioBox::GetString( int n ) const
m_selectedButton = n;
}
// Get single selection, for single choice list items
int wxRadioBox::GetSelection() const
{
};
return m_selectedButton;
}
wxString wxRadioBox::GetLabel(void) const
// Find string for position
wxString wxRadioBox::GetString(int n) const
{
return wxControl::GetLabel();
};
// TODO
return wxString("");
}
void wxRadioBox::SetLabel( const wxString& WXUNUSED(label) )
void wxRadioBox::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
void wxRadioBox::SetLabel( int WXUNUSED(item), const wxString& WXUNUSED(label) )
void wxRadioBox::GetSize(int *width, int *height) const
{
};
// TODO
}
void wxRadioBox::SetLabel( int WXUNUSED(item), wxBitmap *WXUNUSED(bitmap) )
void wxRadioBox::GetPosition(int *x, int *y) const
{
};
// TODO
}
wxString wxRadioBox::GetLabel( int WXUNUSED(item) ) const
wxString wxRadioBox::GetLabel() const
{
return "";
};
// TODO
return wxString("");
}
void wxRadioBox::Enable( bool WXUNUSED(enable) )
void wxRadioBox::SetLabel(const wxString& label)
{
};
// TODO
}
void wxRadioBox::Enable( int WXUNUSED(item), bool WXUNUSED(enable) )
void wxRadioBox::SetFocus()
{
};
// TODO
}
void wxRadioBox::Show( int WXUNUSED(item), bool WXUNUSED(show) )
bool wxRadioBox::Show(bool show)
{
};
// TODO
return FALSE;
}
wxString wxRadioBox::GetStringSelection(void) const
// Enable a specific button
void wxRadioBox::Enable(int item, bool enable)
{
return "";
};
// TODO
}
bool wxRadioBox::SetStringSelection( const wxString&s )
// Enable all controls
void wxRadioBox::Enable(bool enable)
{
return TRUE;
};
wxControl::Enable(enable);
int wxRadioBox::Number(void) const
// TODO
}
// Show a specific button
void wxRadioBox::Show(int item, bool show)
{
return 0;
};
// TODO
}
int wxRadioBox::GetNumberOfRowsOrCols(void) const
// For single selection items only
wxString wxRadioBox::GetStringSelection () const
{
return 1;
};
int sel = GetSelection ();
if (sel > -1)
return this->GetString (sel);
else
return wxString("");
}
void wxRadioBox::SetNumberOfRowsOrCols( int WXUNUSED(n) )
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);
}

63
src/qt/radiobut.cpp
View File

@@ -1,17 +1,68 @@
/////////////////////////////////////////////////////////////////////////////
// Name: radiobut.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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);
}

412
src/qt/region.cpp
View File

@@ -1,163 +1,373 @@
/////////////////////////////////////////////////////////////////////////////
// Name: region.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/98
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// 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/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "wx/msw/region.h"
#include "wx/gdicmn.h"
#include <windows.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
}
HRGN m_region;
};
//-----------------------------------------------------------------------------
// wxRegion
//-----------------------------------------------------------------------------
class wxRegionRefData: public wxObjectRefData
/*!
* Create an empty region.
*/
wxRegion::wxRegion()
{
public:
wxRegionRefData(void);
~wxRegionRefData(void);
public:
m_refData = new wxRegionRefData;
// TODO create empty region
}
};
wxRegionRefData::wxRegionRefData(void)
wxRegion::wxRegion(long x, long y, long w, long h)
{
};
m_refData = new wxRegionRefData;
// TODO create rect region
}
wxRegionRefData::~wxRegionRefData(void)
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
//-----------------------------------------------------------------------------
#define M_REGIONDATA ((wxRegionRefData *)m_refData)
IMPLEMENT_DYNAMIC_CLASS(wxRegion,wxGDIObject);
wxRegion::wxRegion( long x, long y, long w, long h )
//! Clear current region
void wxRegion::Clear()
{
m_refData = new wxRegionRefData();
};
UnRef();
}
wxRegion::wxRegion( const wxPoint& topLeft, const wxPoint& bottomRight )
//! Combine rectangle (x, y, w, h) with this.
bool wxRegion::Combine(long x, long y, long width, long height, wxRegionOp op)
{
m_refData = new wxRegionRefData();
};
// 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.
wxRegion::wxRegion( const wxRect& rect )
// 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)
{
m_refData = new wxRegionRefData();
};
if (region.Empty())
return FALSE;
wxRegion::wxRegion(void)
// 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)
{
m_refData = new wxRegionRefData();
};
return Combine(rect.GetLeft(), rect.GetTop(), rect.GetWidth(), rect.GetHeight(), op);
}
wxRegion::~wxRegion(void)
//-----------------------------------------------------------------------------
//# 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;
}
}
void wxRegion::Clear(void)
wxRect wxRegion::GetBox() const
{
UnRef();
m_refData = new wxRegionRefData();
};
long x, y, w, h;
GetBox(x, y, w, h);
return wxRect(x, y, w, h);
}
bool wxRegion::Union( long x, long y, long width, long height )
// Is region empty?
bool wxRegion::Empty() const
{
return TRUE;
};
// TODO
return FALSE;
}
bool wxRegion::Union( const wxRect& rect )
//-----------------------------------------------------------------------------
//# Tests
//-----------------------------------------------------------------------------
// Does the region contain the point (x,y)?
wxRegionContain wxRegion::Contains(long x, long y) const
{
return TRUE;
};
if (!m_refData)
return wxOutRegion;
bool wxRegion::Union( const wxRegion& region )
// 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
{
return TRUE;
};
if (!m_refData)
return wxOutRegion;
bool wxRegion::Intersect( long x, long y, long width, long height )
// 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
{
return TRUE;
};
if (!m_refData)
return wxOutRegion;
bool wxRegion::Intersect( const wxRect& rect )
// 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
{
return TRUE;
};
if (!m_refData)
return wxOutRegion;
bool wxRegion::Intersect( const wxRegion& region )
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)
{
return TRUE;
};
}
bool wxRegion::Subtract( long x, long y, long width, long height )
wxRegionIterator::~wxRegionIterator()
{
return TRUE;
};
if (m_rects)
delete[] m_rects;
}
bool wxRegion::Subtract( const wxRect& rect )
/*!
* Initialize iterator for region
*/
wxRegionIterator::wxRegionIterator(const wxRegion& region)
{
return TRUE;
};
m_rects = NULL;
bool wxRegion::Subtract( const wxRegion& region )
Reset(region);
}
/*!
* Reset iterator for a new /e region.
*/
void wxRegionIterator::Reset(const wxRegion& region)
{
return TRUE;
};
m_current = 0;
m_region = region;
bool wxRegion::Xor( long x, long y, long width, long height )
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 ++ ()
{
return TRUE;
};
if (m_current < m_numRects)
++m_current;
}
bool wxRegion::Xor( const wxRect& rect )
/*!
* Increment iterator. The rectangle returned is the one before the
* incrementation.
*/
void wxRegionIterator::operator ++ (int)
{
return TRUE;
};
if (m_current < m_numRects)
++m_current;
}
bool wxRegion::Xor( const wxRegion& region )
long wxRegionIterator::GetX() const
{
return TRUE;
};
if (m_current < m_numRects)
return m_rects[m_current].x;
return 0;
}
void wxRegion::GetBox( long& x, long& y, long&w, long &h ) const
long wxRegionIterator::GetY() const
{
x = 0;
y = 0;
w = -1;
h = -1;
};
if (m_current < m_numRects)
return m_rects[m_current].y;
return 0;
}
wxRect wxRegion::GetBox(void) const
long wxRegionIterator::GetW() const
{
return wxRect( 0, 0, -1, -1 );
};
if (m_current < m_numRects)
return m_rects[m_current].width ;
return 0;
}
bool wxRegion::Empty(void) const
long wxRegionIterator::GetH() const
{
};
wxRegionContain wxRegion::Contains( long x, long y ) const
{
return wxOutRegion;
};
wxRegionContain wxRegion::Contains( long x, long y, long w, long h ) const
{
return wxOutRegion;
};
if (m_current < m_numRects)
return m_rects[m_current].height;
return 0;
}

128
src/qt/scrolbar.cpp
View File

@@ -1,102 +1,78 @@
/////////////////////////////////////////////////////////////////////////////
// Name: scrolbar.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
#include "wx/utils.h"
//-----------------------------------------------------------------------------
// wxScrollBar
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxScrollBar,wxControl)
wxScrollBar::wxScrollBar(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
{
Create( parent, id, pos, size, style, name );
};
wxScrollBar::~wxScrollBar(void)
{
};
#endif
// Scrollbar
bool wxScrollBar::Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name )
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
if (!parent)
return FALSE;
parent->AddChild(this);
SetName(name);
SetValidator(validator);
m_windowStyle = style;
int wxScrollBar::GetPosition(void) const
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
// TODO create scrollbar
return TRUE;
}
wxScrollBar::~wxScrollBar()
{
};
}
int wxScrollBar::GetThumbSize() const
void wxScrollBar::SetPosition(int viewStart)
{
};
// TODO
}
int wxScrollBar::GetPageSize() const
int wxScrollBar::GetPosition() const
{
};
// TODO
return 0;
}
int wxScrollBar::GetRange() const
void wxScrollBar::SetScrollbar(int position, int thumbSize, int range, int pageSize,
bool refresh)
{
};
m_viewSize = pageSize;
m_pageSize = thumbSize;
m_objectSize = range;
void wxScrollBar::SetPosition( int viewStart )
// TODO
}
void wxScrollBar::Command(wxCommandEvent& event)
{
};
void wxScrollBar::SetScrollbar( int position, int thumbSize, int range, int pageSize,
bool WXUNUSED(refresh) )
{
};
// Backward compatibility
int wxScrollBar::GetValue(void) const
{
return GetPosition();
};
void wxScrollBar::SetValue( int viewStart )
{
SetPosition( viewStart );
};
void wxScrollBar::GetValues( int *viewStart, int *viewLength, int *objectLength, int *pageLength ) const
{
};
int wxScrollBar::GetViewLength() const
{
};
int wxScrollBar::GetObjectLength() const
{
};
void wxScrollBar::SetPageSize( int pageLength )
{
};
void wxScrollBar::SetObjectLength( int objectLength )
{
};
void wxScrollBar::SetViewLength( int viewLength )
{
};
SetValue(event.m_commandInt);
ProcessCommand(event);
}

261
src/qt/settings.cpp
View File

@@ -1,144 +1,151 @@
/////////////////////////////////////////////////////////////////////////////
// Name: settings.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
/*
#define wxSYS_COLOUR_SCROLLBAR 0
#define wxSYS_COLOUR_BACKGROUND 1
#define wxSYS_COLOUR_ACTIVECAPTION 2
#define wxSYS_COLOUR_INACTIVECAPTION 3
#define wxSYS_COLOUR_MENU 4
#define wxSYS_COLOUR_WINDOW 5
#define wxSYS_COLOUR_WINDOWFRAME 6
#define wxSYS_COLOUR_MENUTEXT 7
#define wxSYS_COLOUR_WINDOWTEXT 8
#define wxSYS_COLOUR_CAPTIONTEXT 9
#define wxSYS_COLOUR_ACTIVEBORDER 10
#define wxSYS_COLOUR_INACTIVEBORDER 11
#define wxSYS_COLOUR_APPWORKSPACE 12
#define wxSYS_COLOUR_HIGHLIGHT 13
#define wxSYS_COLOUR_HIGHLIGHTTEXT 14
#define wxSYS_COLOUR_BTNFACE 15
#define wxSYS_COLOUR_BTNSHADOW 16
#define wxSYS_COLOUR_GRAYTEXT 17
#define wxSYS_COLOUR_BTNTEXT 18
#define wxSYS_COLOUR_INACTIVECAPTIONTEXT 19
#define wxSYS_COLOUR_BTNHIGHLIGHT 20
#define wxSYS_COLOUR_3DDKSHADOW 21
#define wxSYS_COLOUR_3DLIGHT 22
#define wxSYS_COLOUR_INFOTEXT 23
#define wxSYS_COLOUR_INFOBK 24
#define wxSYS_COLOUR_DESKTOP wxSYS_COLOUR_BACKGROUND
#define wxSYS_COLOUR_3DFACE wxSYS_COLOUR_BTNFACE
#define wxSYS_COLOUR_3DSHADOW wxSYS_COLOUR_BTNSHADOW
#define wxSYS_COLOUR_3DHIGHLIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_3DHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
#define wxSYS_COLOUR_BTNHILIGHT wxSYS_COLOUR_BTNHIGHLIGHT
*/
#define SHIFT (8*(sizeof(short int)-sizeof(char)))
wxColour *g_systemBtnFaceColour = NULL;
wxColour *g_systemBtnShadowColour = NULL;
wxColour *g_systemBtnHighlightColour = NULL;
wxColour *g_systemHighlightColour = NULL;
wxColour wxSystemSettings::GetSystemColour( int index )
wxColour wxSystemSettings::GetSystemColour(int index)
{
switch (index)
{
case wxSYS_COLOUR_SCROLLBAR:
case wxSYS_COLOUR_BACKGROUND:
case wxSYS_COLOUR_ACTIVECAPTION:
case wxSYS_COLOUR_INACTIVECAPTION:
case wxSYS_COLOUR_MENU:
case wxSYS_COLOUR_WINDOW:
case wxSYS_COLOUR_WINDOWFRAME:
case wxSYS_COLOUR_ACTIVEBORDER:
case wxSYS_COLOUR_INACTIVEBORDER:
case wxSYS_COLOUR_BTNFACE:
{
return *g_systemBtnFaceColour;
};
case wxSYS_COLOUR_BTNSHADOW:
{
return *g_systemBtnShadowColour;
};
case wxSYS_COLOUR_GRAYTEXT:
case wxSYS_COLOUR_BTNHIGHLIGHT:
{
return *g_systemBtnHighlightColour;
};
case wxSYS_COLOUR_HIGHLIGHT:
{
return *g_systemHighlightColour;
};
case wxSYS_COLOUR_MENUTEXT:
case wxSYS_COLOUR_WINDOWTEXT:
case wxSYS_COLOUR_CAPTIONTEXT:
case wxSYS_COLOUR_INACTIVECAPTIONTEXT:
case wxSYS_COLOUR_INFOTEXT:
{
return *wxBLACK;
};
case wxSYS_COLOUR_HIGHLIGHTTEXT:
{
return *wxWHITE;
};
case wxSYS_COLOUR_INFOBK:
case wxSYS_COLOUR_APPWORKSPACE:
{
return *wxWHITE; // ?
};
};
return *wxWHITE;
};
// TODO
return col;
}
wxFont *g_systemFont = NULL;
wxFont wxSystemSettings::GetSystemFont( int index )
wxFont wxSystemSettings::GetSystemFont(int index)
{
switch (index)
{
case wxSYS_OEM_FIXED_FONT:
case wxSYS_ANSI_FIXED_FONT:
case wxSYS_SYSTEM_FIXED_FONT:
{
return *wxNORMAL_FONT;
};
case wxSYS_ANSI_VAR_FONT:
case wxSYS_SYSTEM_FONT:
case wxSYS_DEVICE_DEFAULT_FONT:
case wxSYS_DEFAULT_GUI_FONT:
{
return *g_systemFont;
};
};
return wxNullFont;
};
// TODO
return wxFont;
}
int wxSystemSettings::GetSystemMetric( int index )
// Get a system metric, e.g. scrollbar size
int wxSystemSettings::GetSystemMetric(int index)
{
switch (index)
{
case wxSYS_SCREEN_X: return 0;
case wxSYS_SCREEN_Y: return 0;
};
return 0;
};
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;
}

212
src/qt/slider.cpp
View File

@@ -1,147 +1,185 @@
/////////////////////////////////////////////////////////////////////////////
// Name: slider.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
#include "wx/utils.h"
#include "wx/msw/slider.h"
//-----------------------------------------------------------------------------
// wxSlider
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxSlider, wxControl)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxSlider,wxControl)
wxSlider::wxSlider(void)
// Slider
wxSlider::wxSlider()
{
};
wxSlider::wxSlider( wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos, const wxSize& size,
long style,
/* const wxValidator& validator = wxDefaultValidator, */
const wxString& name )
{
Create( parent, id, value, minValue, maxValue,
pos, size, style, name );
};
wxSlider::~wxSlider(void)
{
};
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 = wxDefaultValidator, */
const wxString& name )
int value, int minValue, int maxValue,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
return TRUE;
};
SetName(name);
SetValidator(validator);
int wxSlider::GetValue(void) const
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()
{
};
}
void wxSlider::SetValue( int value )
int wxSlider::GetValue() const
{
};
// TODO
return 0;
}
void wxSlider::SetRange( int minValue, int maxValue )
void wxSlider::SetValue(int value)
{
};
// TODO
}
int wxSlider::GetMin(void) const
void wxSlider::GetSize(int *width, int *height) const
{
};
// TODO
}
int wxSlider::GetMax(void) const
void wxSlider::GetPosition(int *x, int *y) const
{
};
// TODO
}
void wxSlider::SetPageSize( int pageSize )
void wxSlider::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
int wxSlider::GetPageSize(void) const
void wxSlider::SetRange(int minValue, int maxValue)
{
};
m_rangeMin = minValue;
m_rangeMax = maxValue;
void wxSlider::SetThumbLength( int len )
// TODO
}
// For trackbars only
void wxSlider::SetTickFreq(int n, int pos)
{
};
// TODO
m_tickFreq = n;
}
int wxSlider::GetThumbLength(void) const
void wxSlider::SetPageSize(int pageSize)
{
};
// TODO
m_pageSize = pageSize;
}
void wxSlider::SetLineSize( int WXUNUSED(lineSize) )
int wxSlider::GetPageSize() const
{
};
return m_pageSize;
}
int wxSlider::GetLineSize(void) const
void wxSlider::ClearSel()
{
};
// TODO
}
void wxSlider::GetSize( int *x, int *y ) const
void wxSlider::ClearTicks()
{
wxWindow::GetSize( x, y );
};
// TODO
}
void wxSlider::SetSize( int x, int y, int width, int height, int sizeFlags )
void wxSlider::SetLineSize(int lineSize)
{
wxWindow::SetSize( x, y, width, height, sizeFlags );
};
m_lineSize = lineSize;
// TODO
}
void wxSlider::GetPosition( int *x, int *y ) const
int wxSlider::GetLineSize() const
{
wxWindow::GetPosition( x, y );
};
// TODO
return 0;
}
void wxSlider::SetTick( int WXUNUSED(tickPos) )
int wxSlider::GetSelEnd() const
{
};
// TODO
return 0;
}
void wxSlider::SetTickFreq( int WXUNUSED(n), int WXUNUSED(pos) )
int wxSlider::GetSelStart() const
{
};
// TODO
return 0;
}
int wxSlider::GetTickFreq(void) const
void wxSlider::SetSelection(int minPos, int maxPos)
{
return 0;
};
// TODO
}
void wxSlider::ClearTicks(void)
void wxSlider::SetThumbLength(int len)
{
};
// TODO
}
void wxSlider::SetSelection( int WXUNUSED(minPos), int WXUNUSED(maxPos) )
int wxSlider::GetThumbLength() const
{
};
// TODO
return 0;
}
int wxSlider::GetSelEnd(void) const
void wxSlider::SetTick(int tickPos)
{
return 0;
};
// TODO
}
int wxSlider::GetSelStart(void) const
void wxSlider::Command (wxCommandEvent & event)
{
return 0;
};
SetValue (event.GetInt());
ProcessCommand (event);
}
void wxSlider::ClearSel(void)
bool wxSlider::Show(bool show)
{
};
// TODO
return TRUE;
}

63
src/qt/statbmp.cpp
View File

@@ -1,10 +1,11 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbmp.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticBitmap
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
@@ -14,31 +15,45 @@
#include "wx/statbmp.h"
//-----------------------------------------------------------------------------
// wxStaticBitmap
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap, wxControl)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxStaticBitmap,wxControl)
/*
* wxStaticBitmap
*/
wxStaticBitmap::wxStaticBitmap(void)
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);
wxStaticBitmap::wxStaticBitmap( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
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)
{
Create( parent, id, bitmap, pos, size, style, name );
};
// TODO
}
bool wxStaticBitmap::Create( wxWindow *parent, wxWindowID id, const wxBitmap &bitmap,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
void wxStaticBitmap::SetBitmap(const wxBitmap& bitmap)
{
return TRUE;
};
m_messageBitmap = bitmap;
void wxStaticBitmap::SetBitmap( const wxBitmap &bitmap )
{
};
// TODO: redraw bitmap
}

68
src/qt/statbox.cpp
View File

@@ -1,11 +1,12 @@
/////////////////////////////////////////////////////////////////////////////
// Name: statbox.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Purpose: wxStaticBox
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
@@ -14,25 +15,48 @@
#include "wx/statbox.h"
//-----------------------------------------------------------------------------
// wxStaticBox
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticBox, wxControl)
IMPLEMENT_DYNAMIC_CLASS(wxStaticBox,wxControl)
BEGIN_EVENT_TABLE(wxStaticBox, wxControl)
EVT_ERASE_BACKGROUND(wxStaticBox::OnEraseBackground)
END_EVENT_TABLE()
wxStaticBox::wxStaticBox(void)
#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);
wxStaticBox::wxStaticBox( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
if (parent) parent->AddChild(this);
bool wxStaticBox::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
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
}

220
src/qt/stattext.cpp
View File

@@ -1,49 +1,211 @@
/////////////////////////////////////////////////////////////////////////////
// Name: stattext.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Purpose: wxStaticText
// Author: AUTHOR
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "stattext.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/app.h"
#endif
#include "wx/stattext.h"
#include "wx/msw/private.h"
#include <stdio.h>
//-----------------------------------------------------------------------------
// wxStaticText
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxStaticText, wxControl)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxStaticText,wxControl)
wxStaticText::wxStaticText(void)
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);
wxStaticText::wxStaticText( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
Create( parent, id, label, pos, size, style, name );
};
SetBackgroundColour(parent->GetDefaultBackgroundColour()) ;
SetForegroundColour(parent->GetDefaultForegroundColour()) ;
bool wxStaticText::Create( wxWindow *parent, wxWindowID id, const wxString &label,
const wxPoint &pos, const wxSize &size,
long style, const wxString &name )
{
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
long msStyle = WS_CHILD|WS_VISIBLE;
if (m_windowStyle & wxALIGN_CENTRE)
msStyle |= SS_CENTER;
else if (m_windowStyle & wxALIGN_RIGHT)
msStyle |= SS_RIGHT;
else
msStyle |= SS_LEFT;
// Even with extended styles, need to combine with WS_BORDER
// for them to look right.
if ((m_windowStyle & wxSIMPLE_BORDER) || (m_windowStyle & wxRAISED_BORDER) ||
(m_windowStyle & wxSUNKEN_BORDER) || (m_windowStyle & wxDOUBLE_BORDER))
msStyle |= WS_BORDER;
HWND static_item = CreateWindowEx(MakeExtendedStyle(m_windowStyle), "STATIC", (const char *)label,
msStyle,
0, 0, 0, 0, (HWND) parent->GetHWND(), (HMENU)m_windowId,
wxGetInstance(), NULL);
#if CTL3D
/*
if (!(GetParent()->GetWindowStyleFlag() & wxUSER_COLOURS))
Ctl3dSubclassCtl(static_item);
*/
#endif
m_hWnd = (WXHWND)static_item;
SubclassWin((WXHWND)static_item);
SetFont(* parent->GetFont());
SetSize(x, y, width, height);
return TRUE;
};
}
wxString wxStaticText::GetLabel(void) const
void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
int currentX, currentY;
GetPosition(&currentX, &currentY);
int x1 = x;
int y1 = y;
void wxStaticText::SetLabel( const wxString &label )
if (x == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
x1 = currentX;
if (y == -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
y1 = currentY;
AdjustForParentClientOrigin(x1, y1, sizeFlags);
int actualWidth = width;
int actualHeight = height;
char buf[300];
int current_width;
int cyf;
::GetWindowText((HWND) GetHWND(), buf, 300);
GetTextExtent(buf, &current_width, &cyf, NULL, NULL,GetFont());
int ww, hh;
GetSize(&ww, &hh);
// If we're prepared to use the existing width, then...
if (width == -1 && ((sizeFlags & wxSIZE_AUTO_WIDTH) != wxSIZE_AUTO_WIDTH))
actualWidth = ww;
else if (width == -1)
{
int cx;
int cy;
wxGetCharSize(GetHWND(), &cx, &cy,GetFont());
actualWidth = (int)(current_width + cx) ;
}
// If we're prepared to use the existing height, then...
if (height == -1 && ((sizeFlags & wxSIZE_AUTO_HEIGHT) != wxSIZE_AUTO_HEIGHT))
actualHeight = hh;
else if (height == -1)
{
actualHeight = (int)(cyf) ;
}
MoveWindow((HWND) GetHWND(), x1, y1, actualWidth, actualHeight, TRUE);
}
void wxStaticText::SetLabel(const wxString& label)
{
wxControl::SetLabel(label);
};
int w, h;
RECT rect;
wxWindow *parent = GetParent();
GetWindowRect((HWND) GetHWND(), &rect);
// Since we now have the absolute screen coords,
// if there's a parent we must subtract its top left corner
POINT point;
point.x = rect.left;
point.y = rect.top;
if (parent)
{
::ScreenToClient((HWND) parent->GetHWND(), &point);
}
GetTextExtent(label, &w, &h, NULL, NULL, GetFont());
MoveWindow((HWND) GetHWND(), point.x, point.y, (int)(w + 10), (int)h,
TRUE);
SetWindowText((HWND) GetHWND(), (const char *)label);
}
WXHBRUSH wxStaticText::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
/*
#if CTL3D
if ( m_useCtl3D )
{
HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
if (hbrush != (HBRUSH) 0)
return hbrush;
else
return (HBRUSH)MSWDefWindowProc(message, wParam, lParam);
}
#endif
*/
if (GetParent()->GetTransparentBackground())
SetBkMode((HDC) pDC, TRANSPARENT);
else
SetBkMode((HDC) pDC, OPAQUE);
::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
// Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush
// has a zero usage count.
// backgroundBrush->RealizeResource();
return (WXHBRUSH) backgroundBrush->GetResourceHandle();
}
long wxStaticText::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
// Ensure that static items get messages. Some controls don't like this
// message to be intercepted (e.g. RichEdit), hence the tests.
if (nMsg == WM_NCHITTEST)
return (long)HTCLIENT;
return wxWindow::MSWWindowProc(nMsg, wParam, lParam);
}

502
src/qt/textctrl.cpp
View File

@@ -1,173 +1,374 @@
/////////////////////////////////////////////////////////////////////////////
// Name: textctrl.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// Licence: wxWindows licence
// Purpose: wxTextCtrl
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "textctrl.h"
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <fstream.h>
#include "wx/textctrl.h"
#include "wx/utils.h"
#include "wx/settings.h"
//-----------------------------------------------------------------------------
// wxTextCtrl
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl,wxControl)
#if defined(__BORLANDC__) && !defined(__WIN32__)
#include <alloc.h>
#else
#ifndef __GNUWIN32__
#include <malloc.h>
#endif
#endif
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
// EVT_CHAR(wxTextCtrl::OnChar)
EVT_CHAR(wxTextCtrl::OnChar)
EVT_DROP_FILES(wxTextCtrl::OnDropFiles)
EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
END_EVENT_TABLE()
#endif
wxTextCtrl::wxTextCtrl(void) : streambuf()
// Text item
wxTextCtrl::wxTextCtrl()
#ifndef NO_TEXT_WINDOW_STREAM
:streambuf()
#endif
{
if( allocate() )
setp(base(),ebuf());
m_fileName = "";
}
m_modified = FALSE;
};
wxTextCtrl::wxTextCtrl( wxWindow *parent, wxWindowID id, const wxString &value,
const wxPoint &pos, const wxSize &size,
int style, const wxString &name ) : streambuf()
bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& validator,
const wxString& name)
{
if( allocate() )
setp(base(),ebuf());
m_fileName = "";
SetName(name);
SetValidator(validator);
if (parent) parent->AddChild(this);
m_modified = FALSE;
Create( parent, id, value, pos, size, style, name );
};
m_windowStyle = style;
bool wxTextCtrl::Create( wxWindow *parent, wxWindowID id, const wxString &value,
const wxPoint &pos, const wxSize &size,
int style, const wxString &name )
if ( id == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = id;
return TRUE;
}
wxString wxTextCtrl::GetValue() const
{
return TRUE;
};
// TODO
return wxString("");
}
wxString wxTextCtrl::GetValue(void) const
void wxTextCtrl::SetValue(const wxString& value)
{
return tmp;
};
// TODO
}
void wxTextCtrl::SetValue( const wxString &value )
void wxTextCtrl::SetSize(int x, int y, int width, int height, int sizeFlags)
{
};
// TODO
}
void wxTextCtrl::WriteText( const wxString &text )
// Clipboard operations
void wxTextCtrl::Copy()
{
};
// TODO
}
bool wxTextCtrl::LoadFile( const wxString &WXUNUSED(file) )
void wxTextCtrl::Cut()
{
return FALSE;
};
// TODO
}
bool wxTextCtrl::SaveFile( const wxString &WXUNUSED(file) )
void wxTextCtrl::Paste()
{
return FALSE;
};
// TODO
}
void wxTextCtrl::SetEditable(bool editable)
{
// TODO
}
void wxTextCtrl::SetInsertionPoint(long pos)
{
// TODO
}
void wxTextCtrl::SetInsertionPointEnd()
{
long pos = GetLastPosition();
SetInsertionPoint(pos);
}
long wxTextCtrl::GetInsertionPoint() const
{
// TODO
return 0;
}
long wxTextCtrl::GetLastPosition() const
{
// TODO
return 0;
}
void wxTextCtrl::Replace(long from, long to, const wxString& value)
{
// TODO
return 0;
}
void wxTextCtrl::Remove(long from, long to)
{
// TODO
}
void wxTextCtrl::SetSelection(long from, long to)
{
// TODO
}
bool wxTextCtrl::LoadFile(const wxString& file)
{
if (!wxFileExists(file))
return FALSE;
m_fileName = file;
Clear();
ifstream input((char*) (const char*) file, ios::nocreate | ios::in);
if (!input.bad())
{
struct stat stat_buf;
if (stat(file, &stat_buf) < 0)
return FALSE;
// This may need to be a bigger buffer than the file size suggests,
// if it's a UNIX file. Give it an extra 1000 just in case.
char *tmp_buffer = (char*)malloc((size_t)(stat_buf.st_size+1+1000));
long no_lines = 0;
long pos = 0;
while (!input.eof() && input.peek() != EOF)
{
input.getline(wxBuffer, 500);
int len = strlen(wxBuffer);
wxBuffer[len] = 13;
wxBuffer[len+1] = 10;
wxBuffer[len+2] = 0;
strcpy(tmp_buffer+pos, wxBuffer);
pos += strlen(wxBuffer);
no_lines++;
}
// TODO add line
free(tmp_buffer);
return TRUE;
}
return FALSE;
}
// If file is null, try saved file name first
// Returns TRUE if succeeds.
bool wxTextCtrl::SaveFile(const wxString& file)
{
wxString theFile(file);
if (theFile == "")
theFile = m_fileName;
if (theFile == "")
return FALSE;
m_fileName = theFile;
ofstream output((char*) (const char*) theFile);
if (output.bad())
return FALSE;
// TODO get and save text
return FALSE;
}
void wxTextCtrl::WriteText(const wxString& text)
{
// TODO write text to control
}
void wxTextCtrl::Clear()
{
// TODO
}
bool wxTextCtrl::IsModified() const
{
// TODO
return FALSE;
}
// Makes 'unmodified'
void wxTextCtrl::DiscardEdits()
{
// TODO
}
int wxTextCtrl::GetNumberOfLines() const
{
// TODO
return 0;
}
long wxTextCtrl::XYToPosition(long x, long y) const
{
// TODO
return 0;
}
void wxTextCtrl::PositionToXY(long pos, long *x, long *y) const
{
// TODO
}
void wxTextCtrl::ShowPosition(long pos)
{
// TODO
}
int wxTextCtrl::GetLineLength(long lineNo) const
{
// TODO
return 0;
}
wxString wxTextCtrl::GetLineText(long lineNo) const
{
// TODO
return wxString("");
}
/*
wxString wxTextCtrl::GetLineText( long lineNo ) const
* Text item
*/
void wxTextCtrl::Command(wxCommandEvent & event)
{
};
SetValue (event.GetString());
ProcessCommand (event);
}
void wxTextCtrl::OnDropFiles( wxDropFilesEvent &event )
void wxTextCtrl::OnDropFiles(wxDropFilesEvent& event)
{
};
// By default, load the first file into the text window.
if (event.GetNumberOfFiles() > 0)
{
LoadFile(event.GetFiles()[0]);
}
}
long wxTextCtrl::PositionToXY( long pos, long *x, long *y ) const
{
};
// 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
long wxTextCtrl::XYToPosition( long x, long y )
//=========================================================================
// 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;
}
int wxTextCtrl::GetNumberOfLines(void)
{
};
// Reset get area
setg(0,0,0);
*/
void wxTextCtrl::SetInsertionPoint( long pos )
{
};
// 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() );
}
void wxTextCtrl::SetInsertionPointEnd(void)
{
};
// Determine how many characters have been inserted but no consumed
int plen = pptr() - pbase();
void wxTextCtrl::SetEditable( bool editable )
{
};
// 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.
void wxTextCtrl::SetSelection( long from, long to )
{
};
// If c!=EOF, it is a character that must also be comsumed
int xtra = c==EOF? 0 : 1;
void wxTextCtrl::ShowPosition( long WXUNUSED(pos) )
{
};
// 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;
}
long wxTextCtrl::GetInsertionPoint(void) const
{
};
long wxTextCtrl::GetLastPosition(void) const
{
};
void wxTextCtrl::Remove( long from, long to )
{
};
void wxTextCtrl::Replace( long from, long to, const wxString &value )
{
};
void wxTextCtrl::Cut(void)
{
};
void wxTextCtrl::Copy(void)
{
};
void wxTextCtrl::Paste(void)
{
};
void wxTextCtrl::Delete(void)
{
};
void wxTextCtrl::OnChar( wxKeyEvent &WXUNUSED(event) )
{
};
int wxTextCtrl::overflow( int WXUNUSED(c) )
{
int len = pptr() - pbase();
char *txt = new char[len+1];
strncpy(txt, pbase(), len);
txt[len] = '\0';
(*this) << txt;
// Reset put area
setp(pbase(), epptr());
delete[] txt;
return EOF;
};
int wxTextCtrl::sync(void)
#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);
@@ -176,60 +377,63 @@ int wxTextCtrl::sync(void)
setp(pbase(), epptr());
delete[] txt;
return 0;
};
*/
}
int wxTextCtrl::underflow(void)
//=========================================================================
// 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;
WriteText(s);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(float f)
{
static char buf[100];
sprintf(buf, "%.2f", f);
WriteText(buf);
return *this;
wxString str;
str.Printf("%.2f", f);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(double d)
{
static char buf[100];
sprintf(buf, "%.2f", d);
WriteText(buf);
return *this;
wxString str;
str.Printf("%.2f", d);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(int i)
{
static char buf[100];
sprintf(buf, "%i", i);
WriteText(buf);
return *this;
wxString str;
str.Printf("%d", i);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(long i)
{
static char buf[100];
sprintf(buf, "%ld", i);
WriteText(buf);
return *this;
wxString str;
str.Printf("%ld", i);
WriteText(str);
return *this;
}
wxTextCtrl& wxTextCtrl::operator<<(const char c)
{
char buf[2];
char buf[2];
buf[0] = c;
buf[1] = 0;
WriteText(buf);
return *this;
buf[0] = c;
buf[1] = 0;
WriteText(buf);
return *this;
}

80
src/qt/timer.cpp
View File

@@ -1,66 +1,56 @@
/////////////////////////////////////////////////////////////////////////////
// Name: timer.cpp
// Purpose:
// Author: Robert Roebling
// Created: 01/02/97
// Id:
// Copyright: (c) 1998 Robert Roebling, Julian Smart and Markus Holzem
// 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"
//-----------------------------------------------------------------------------
// wxTimer
//-----------------------------------------------------------------------------
#if !USE_SHARED_LIBRARY
IMPLEMENT_ABSTRACT_CLASS(wxTimer, wxObject)
#endif
IMPLEMENT_DYNAMIC_CLASS(wxTimer,wxObject)
gint timeout_callback( gpointer data )
wxTimer::wxTimer()
{
wxTimer *timer = (wxTimer*)data;
timer->Notify();
if (timer->OneShot()) timer->Stop();
return TRUE;
};
m_milli = 0 ;
m_lastMilli = -1 ;
m_id = 0;
m_oneShot = FALSE;
}
wxTimer::wxTimer(void)
wxTimer::~wxTimer()
{
m_time = 1000;
m_oneShot = FALSE;
};
Stop();
}
wxTimer::~wxTimer(void)
bool wxTimer::Start(int milliseconds,bool mode)
{
Stop();
};
m_oneShot = mode ;
if (m_milliseconds < 0)
m_milliseconds = lastMilli;
int wxTimer::Interval(void)
if (m_milliseconds <= 0)
return FALSE;
m_lastMilli = m_milli = m_milliseconds;
// TODO: set the timer going.
return FALSE;
}
void wxTimer::Stop()
{
return m_time;
};
m_id = 0 ;
m_milli = 0 ;
}
bool wxTimer::OneShot(void)
{
return m_oneShot;
};
void wxTimer::Notify(void)
{
};
void wxTimer::Start( int millisecs, bool oneShot )
{
if (millisecs != -1) m_time = millisecs;
m_oneShot = oneShot;
};
void wxTimer::Stop(void)
{
};

1431
src/qt/window.cpp
View File

File diff suppressed because it is too large Load Diff