AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Dialog Editor corrections for latest wxWin changes; removed wxProp files

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1167 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Julian Smart 1998-12-10 22:44:09 +00:00
parent 650368d057
commit c030b70fc6
20 changed files with 238 additions and 5063 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
distrib/msw/generic.rsp
View File

@ -478,6 +478,19 @@ samples/docvwmdi/*.txt
samples/docvwmdi/*.ico
samples/docvwmdi/*.bmp
samples/minifram/*.h
samples/minifram/*.cpp
samples/minifram/*.def
samples/minifram/*.rc
samples/minifram/makefile*
samples/minifram/*.xbm
samples/minifram/*.xpm
samples/minifram/*.txt
samples/minifram/*.ico
samples/minifram/*.bmp
samples/minifram/bitmaps/*.bmp
samples/minifram/bitmaps/*.xpm
samples/memcheck/*.h
samples/memcheck/*.cpp
samples/memcheck/*.def

3
distrib/msw/vc.rsp
View File

@ -64,6 +64,9 @@ samples/mfc/MfcVC.dsw
samples/minimal/MinimalVC.dsp
samples/minimal/MinimalVC.dsw
samples/minimal/MiniframVC.dsp
samples/minimal/MiniframVC.dsw
samples/nativdlg/NativdlgVC.dsp
samples/nativdlg/NativdlgVC.dsw

2
docs/latex/wx/wave.tex
View File

@ -35,7 +35,7 @@ Destroys the wxWave object.
\membersection{wxWave::Create}\label{wxwavecreate}
\func{bool}{wxWave}{\param{const wxString\&}{ fileName}, \param{bool}{ isResource = FALSE}}
\func{bool}{Create}{\param{const wxString\&}{ fileName}, \param{bool}{ isResource = FALSE}}
Constructs a wave object from a file or resource.

5
include/wx/utils.h
View File

@ -272,6 +272,11 @@ void WXDLLEXPORT wxGetMousePosition( int* x, int* y );
#ifdef __WXMSW__
WXDLLEXPORT extern const char* wxUserResourceStr;
WXDLLEXPORT char* wxLoadUserResource(const wxString& resourceName, const wxString& resourceType = wxUserResourceStr);
// Implemented in utils.cpp: VC++, Win95 only. Sets up a console for standard
// input/output
WXDLLEXPORT void wxRedirectIOToConsole();
#endif
// X only

4
samples/makefile.nt
View File

@ -72,6 +72,8 @@ all:
nmake -f makefile.nt DEBUG_FLAGS=$(DEBUG_FLAGS) LINK_DEBUG_FLAGS=$(LINK_DEBUG_FLAGS)
cd $(WXDIR)\samples\checklst
nmake -f makefile.nt DEBUG_FLAGS=$(DEBUG_FLAGS) LINK_DEBUG_FLAGS=$(LINK_DEBUG_FLAGS)
cd $(WXDIR)\samples\minifram
nmake -f makefile.nt DEBUG_FLAGS=$(DEBUG_FLAGS) LINK_DEBUG_FLAGS=$(LINK_DEBUG_FLAGS)
# cd $(WXDIR)\samples\regtest
# nmake -f makefile.nt DEBUG_FLAGS=$(DEBUG_FLAGS) LINK_DEBUG_FLAGS=$(LINK_DEBUG_FLAGS)
# cd $(WXDIR)\samples\hello
@ -146,6 +148,8 @@ clean:
nmake -f makefile.nt clean
cd $(WXDIR)\samples\memcheck
nmake -f makefile.nt clean
cd $(WXDIR)\samples\minifram
nmake -f makefile.nt clean
# cd $(WXDIR)\samples\hello
# nmake -f makefile.nt clean
# cd $(WXDIR)\samples\fractal

10
samples/png/pngdemo.cpp
View File

@ -168,7 +168,7 @@ MyCanvas::~MyCanvas(void)
void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
dc.SetPen(wxRED_PEN);
dc.SetPen(* wxRED_PEN);
int i;
for ( i = 0; i < 500; i += 10)
@ -180,10 +180,10 @@ void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
wxMemoryDC memDC;
if ( g_TestBitmap->GetColourMap() )
{
memDC.SetColourMap(g_TestBitmap->GetColourMap());
dc.SetColourMap(g_TestBitmap->GetColourMap());
memDC.SetPalette(* g_TestBitmap->GetColourMap());
dc.SetPalette(* g_TestBitmap->GetColourMap());
}
memDC.SelectObject(g_TestBitmap);
memDC.SelectObject(* g_TestBitmap);
// Normal, non-transparent blitting
dc.Blit(20, 20, g_TestBitmap->GetWidth(), g_TestBitmap->GetHeight(), & memDC, 0, 0, wxCOPY, FALSE);
@ -194,7 +194,7 @@ void MyCanvas::OnPaint(wxPaintEvent& WXUNUSED(event))
if ( g_TestBitmap && g_TestBitmap->Ok() )
{
wxMemoryDC memDC;
memDC.SelectObject(g_TestBitmap);
memDC.SelectObject(* g_TestBitmap);
// Transparent blitting if there's a mask in the bitmap
dc.Blit(20 + g_TestBitmap->GetWidth() + 20, 20, g_TestBitmap->GetWidth(), g_TestBitmap->GetHeight(), & memDC,

2
src/generic/fontdlgg.cpp
View File

@ -226,7 +226,7 @@ void wxGenericFontDialog::CreateWidgets(void)
weightChoice = new wxChoice(this, wxID_FONT_WEIGHT, wxPoint(310, 10), wxSize(120, -1), 3, weights);
colourChoice = new wxChoice(this, wxID_FONT_COLOUR, wxPoint(10, 40), wxSize(190, -1), NUM_COLS, wxColourDialogNames);
#ifdef __MOTIF__
#if 0 // def __WXMOTIF__ // TODO: This necessary now?
// We want the pointSizeText to line up on the y axis with the colourChoice
colourChoice->GetPosition(&fontRect.x, &y); //NL mod
y+=3; //NL mod

16
src/msw/app.cpp
View File

@ -64,7 +64,17 @@
#define _DEBUG
#endif
/* Need to undef new if including crtdbg.h */
#ifdef new
#undef new
#endif
#include <crtdbg.h>
#if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
#define new new(__FILE__,__LINE__)
#endif
#endif
extern char *wxBuffer;
@ -117,6 +127,12 @@ long wxApp::sm_lastMessageTime = 0;
bool wxApp::Initialize()
{
// Some people may wish to use this, but
// probably it shouldn't be here by default.
#ifdef __WXDEBUG__
// wxRedirectIOToConsole();
#endif
wxBuffer = new char[1500];
#ifdef wxUSE_VC_CRTDBG

115
src/msw/utils.cpp
View File

@ -30,6 +30,8 @@
#include "wx/msw/private.h"
#include "wx/timer.h"
#include <windows.h>
#include <ctype.h>
#ifndef __GNUWIN32__
@ -68,6 +70,52 @@
#endif
#include <stdarg.h>
//// BEGIN for console support: VC++ only
#if defined(__WXDEBUG__) && defined(_MSC_VER) && !defined(__NO_VC_CRTDBG__)
#define wxUSE_VC_CRTDBG
#else
#undef wxUSE_VC_CRTDBG
#endif
#ifdef wxUSE_VC_CRTDBG
// VC++ uses this macro as debug/release mode indicator
#ifndef _DEBUG
#define _DEBUG
#endif
#include <fcntl.h>
#if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h>
# include <io.h>
# include <fstream.h>
#else
# include <istream>
# include <ostream>
# include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
/* Need to undef new if including crtdbg.h */
# ifdef new
# undef new
# endif
# include <crtdbg.h>
# if defined(__WXDEBUG__) && wxUSE_GLOBAL_MEMORY_OPERATORS && wxUSE_DEBUG_NEW_ALWAYS
# define new new(__FILE__,__LINE__)
# endif
#endif
/// END for console support
// In the WIN.INI file
static const char WX_SECTION[] = "wxWindows";
static const char eHOSTNAME[] = "HostName";
@ -1023,3 +1071,70 @@ void OutputDebugStringW95(const char* lpOutputString, ...)
#endif
#ifdef wxUSE_VC_CRTDBG
// maximum mumber of lines the output console should have
static const WORD MAX_CONSOLE_LINES = 500;
BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) { // control signal type
FreeConsole();
return TRUE;
}
void wxRedirectIOToConsole()
{
int hConHandle;
long lStdHandle;
CONSOLE_SCREEN_BUFFER_INFO coninfo;
FILE *fp;
// allocate a console for this app
AllocConsole();
// set the screen buffer to be big enough to let us scroll text
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
&coninfo);
coninfo.dwSize.Y = MAX_CONSOLE_LINES;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),
coninfo.dwSize);
// redirect unbuffered STDOUT to the console
lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
if(hConHandle <= 0) return;
fp = _fdopen( hConHandle, "w" );
*stdout = *fp;
setvbuf( stdout, NULL, _IONBF, 0 );
// redirect unbuffered STDIN to the console
lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
if(hConHandle <= 0) return;
fp = _fdopen( hConHandle, "r" );
*stdin = *fp;
setvbuf( stdin, NULL, _IONBF, 0 );
// redirect unbuffered STDERR to the console
lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
if(hConHandle <= 0) return;
fp = _fdopen( hConHandle, "w" );
*stderr = *fp;
setvbuf( stderr, NULL, _IONBF, 0 );
// make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
// point to console as well
ios::sync_with_stdio();
SetConsoleCtrlHandler(MyConsoleHandler, TRUE);
}
#else
// Not supported
void wxRedirectIOToConsole()
{
}
#endif

30
utils/dialoged/src/dlghndlr.cpp
View File

@ -104,7 +104,7 @@ void wxResourceEditorDialogHandler::OnPaint(wxPaintEvent& WXUNUSED(event))
// Add event handlers for all children
void wxResourceEditorDialogHandler::AddChildHandlers(void)
{
wxNode *node = handlerDialog->GetChildren()->First();
wxNode *node = handlerDialog->GetChildren().First();
while ( node )
{
wxControl *child = (wxControl *)node->Data();
@ -127,7 +127,7 @@ void wxResourceEditorDialogHandler::OnLeftClick(int x, int y, int keys)
if (wxResourceManager::GetCurrentResourceManager()->GetEditorControlList()->GetSelection() == RESED_POINTER)
{
int needsRefresh = 0;
wxNode *node = handlerDialog->GetChildren()->First();
wxNode *node = handlerDialog->GetChildren().First();
while (node)
{
wxControl *item = (wxControl *)node->Data();
@ -256,7 +256,7 @@ void wxResourceEditorDialogHandler::OnItemLeftClick(wxControl *item, int WXUNUSE
int needsRefresh = 0;
if (!(keys & wxKEY_SHIFT))
{
wxNode *node = item->GetParent()->GetChildren()->First();
wxNode *node = item->GetParent()->GetChildren().First();
while (node)
{
wxControl *child = (wxControl *)node->Data();
@ -331,7 +331,7 @@ void wxResourceEditorDialogHandler::OnMouseEvent(wxMouseEvent& event)
event.Position(&x, &y);
// Find which selection handle we're on, if any
wxNode *node = handlerDialog->GetChildren()->First();
wxNode *node = handlerDialog->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
@ -601,7 +601,7 @@ void wxResourceEditorDialogHandler::PaintSelectionHandles(wxDC& dc)
dc.BeginDrawing();
wxNode *node = handlerDialog->GetChildren()->First();
wxNode *node = handlerDialog->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
@ -730,8 +730,8 @@ void wxResourceEditorControlHandler::DrawSelectionHandles(wxDC& dc, bool WXUNUSE
dc.SetOptimization(FALSE);
dc.SetLogicalFunction(wxCOPY);
dc.SetPen(wxBLACK_PEN);
dc.SetBrush(wxBLACK_BRUSH);
dc.SetPen(* wxBLACK_PEN);
dc.SetBrush(* wxBLACK_BRUSH);
dc.SetOptimization(TRUE);
@ -774,7 +774,7 @@ void wxResourceEditorControlHandler::OnDragBegin(int x, int y, int WXUNUSED(keys
wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
dc.SetOptimization(TRUE);
@ -794,7 +794,7 @@ void wxResourceEditorControlHandler::OnDragBegin(int x, int y, int WXUNUSED(keys
DrawBoundingBox(dc, xpos, ypos, width, height);
// Also draw bounding boxes for other selected items
wxNode *node = panel->GetChildren()->First();
wxNode *node = panel->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
@ -891,7 +891,7 @@ void wxResourceEditorControlHandler::OnDragContinue(bool WXUNUSED(paintIt), int
dc.SetLogicalFunction(wxXOR);
wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
DrawBoundingBox(dc, x1, y1, width1, height1);
@ -903,12 +903,12 @@ void wxResourceEditorControlHandler::OnDragContinue(bool WXUNUSED(paintIt), int
dc.SetLogicalFunction(wxXOR);
wxPen pen(wxColour(0, 0, 0), 1, wxDOT);
dc.SetPen(pen);
dc.SetBrush(wxTRANSPARENT_BRUSH);
dc.SetBrush(* wxTRANSPARENT_BRUSH);
DrawBoundingBox(dc, (int)(x - dragOffsetX), (int)(y - dragOffsetY), width, height);
// Also draw bounding boxes for other selected items
wxNode *node = panel->GetChildren()->First();
wxNode *node = panel->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
@ -1030,7 +1030,7 @@ void wxResourceEditorControlHandler::OnDragEnd(int x, int y, int WXUNUSED(keys),
resource->SetSize(newX, newY, resource->GetWidth(), resource->GetHeight());
// Also move other selected items
wxNode *node = panel->GetChildren()->First();
wxNode *node = panel->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
@ -1065,8 +1065,8 @@ void wxResourceEditorControlHandler::OnDragEnd(int x, int y, int WXUNUSED(keys),
dc.SetOptimization(FALSE);
dc.SetLogicalFunction(wxCOPY);
dc.SetPen(wxBLACK_PEN);
dc.SetBrush(wxBLACK_BRUSH);
dc.SetPen(* wxBLACK_PEN);
dc.SetBrush(* wxBLACK_BRUSH);
dc.SetOptimization(TRUE);

1119
utils/dialoged/src/prop.cpp
View File

File diff suppressed because it is too large Load Diff

325
utils/dialoged/src/prop.h
View File

@ -1,325 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: prop.h
// Purpose: Property sheet classes
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _PROP_H_
#define _PROP_H_
#ifdef __GNUG__
#pragma interface "prop.h"
#endif
#include "wx/defs.h"
#include "wx/string.h"
#include "wx/hash.h"
#include "wx/dialog.h"
#include "wx/frame.h"
#include "wx/button.h"
#include "wx/listbox.h"
#include "wx/textctrl.h"
#include "wx/gdicmn.h"
#include "wx/layout.h"
class wxWindow;
class wxProperty;
class wxPropertyValue;
class wxPropertySheet;
class wxPropertyView;
class wxPropertyValidator;
class wxPropertyValidatorRegistry;
#define wxPROPERTY_VERSION 2.0
// A storable sheet of values
class wxPropertySheet: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxPropertySheet)
public:
wxPropertySheet(void);
~wxPropertySheet(void);
// Add a property
virtual void AddProperty(wxProperty *property);
// Get property by name
virtual wxProperty *GetProperty(wxString name);
// Clear all properties
virtual void Clear(void);
virtual bool Save(ostream& str);
virtual bool Load(ostream& str);
virtual void UpdateAllViews(wxPropertyView *thisView = NULL);
inline virtual wxList& GetProperties(void) const { return (wxList&) m_properties; }
// Sets/clears the modified flag for each property value
virtual void SetAllModified(bool flag = TRUE);
protected:
wxObject* m_viewedObject;
wxList m_properties;
wxPropertyView* m_propertyView;
};
// Base class for property sheet views. There are currently two directly derived
// classes: wxPropertyListView, and wxPropertyFormView.
class wxPropertyView: public wxEvtHandler
{
DECLARE_DYNAMIC_CLASS(wxPropertyView)
public:
wxPropertyView(long flags = 0);
~wxPropertyView(void);
// Associates and shows the view
virtual void ShowView(wxPropertySheet *WXUNUSED(propertySheet), wxWindow *WXUNUSED(panel)) {}
// Update this view of the viewed object, called e.g. by
// the object itself.
virtual bool OnUpdateView(void) {return FALSE;};
// Override this to do something as soon as the property changed,
// if the view and validators support it.
virtual void OnPropertyChanged(wxProperty *WXUNUSED(property)) {}
virtual void AddRegistry(wxPropertyValidatorRegistry *registry);
inline virtual wxList& GetRegistryList(void) const
{ return (wxList&) m_validatorRegistryList; }
virtual wxPropertyValidator *FindPropertyValidator(wxProperty *property);
inline virtual void SetPropertySheet(wxPropertySheet *sheet) { m_propertySheet = sheet; }
inline virtual wxPropertySheet *GetPropertySheet(void) const { return m_propertySheet; }
virtual void OnOk(void) {};
virtual void OnCancel(void) {};
virtual void OnHelp(void) {};
inline virtual bool OnClose(void) { return FALSE; }
inline long GetFlags(void) { return m_buttonFlags; }
protected:
long m_buttonFlags;
wxPropertySheet* m_propertySheet;
wxProperty* m_currentProperty;
wxList m_validatorRegistryList;
wxPropertyValidator* m_currentValidator;
};
class wxPropertyValidator: public wxEvtHandler
{
DECLARE_DYNAMIC_CLASS(wxPropertyValidator)
public:
wxPropertyValidator(long flags = 0);
~wxPropertyValidator(void);
inline long GetFlags(void) const { return m_validatorFlags; }
inline void SetValidatorProperty(wxProperty *prop) { m_validatorProperty = prop; }
inline wxProperty *GetValidatorProperty(void) const { return m_validatorProperty; }
virtual bool StringToFloat (char *s, float *number);
virtual bool StringToDouble (char *s, double *number);
virtual bool StringToInt (char *s, int *number);
virtual bool StringToLong (char *s, long *number);
virtual char *FloatToString (float number);
virtual char *DoubleToString (double number);
virtual char *IntToString (int number);
virtual char *LongToString (long number);
protected:
long m_validatorFlags;
wxProperty* m_validatorProperty;
};
// extern wxPropertyValidator *wxDefaultPropertyValidator;
class wxPropertyValidatorRegistry: public wxHashTable
{
DECLARE_DYNAMIC_CLASS(wxPropertyValidatorRegistry)
public:
wxPropertyValidatorRegistry(void);
~wxPropertyValidatorRegistry(void);
virtual void RegisterValidator(wxString& roleName, wxPropertyValidator *validator);
virtual wxPropertyValidator *GetValidator(wxString& roleName);
void ClearRegistry(void);
};
/*
* Property value class
*/
typedef enum {
wxPropertyValueNull,
wxPropertyValueInteger,
wxPropertyValueReal,
wxPropertyValuebool,
wxPropertyValueString,
wxPropertyValueList,
wxPropertyValueIntegerPtr,
wxPropertyValueRealPtr,
wxPropertyValueboolPtr,
wxPropertyValueStringPtr
} wxPropertyValueType;
class wxPropertyValue: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxPropertyValue)
wxPropertyValue(void); // Unknown type
wxPropertyValue(const wxPropertyValue& copyFrom); // Copy constructor
wxPropertyValue(const char *val);
wxPropertyValue(const wxString& val);
wxPropertyValue(long val);
wxPropertyValue(bool val);
wxPropertyValue(float val);
wxPropertyValue(double the_real);
wxPropertyValue(wxList *val);
wxPropertyValue(wxStringList *val);
// Pointer versions
wxPropertyValue(char **val);
wxPropertyValue(long *val);
wxPropertyValue(bool *val);
wxPropertyValue(float *val);
~wxPropertyValue(void);
virtual inline wxPropertyValueType Type(void) const { return m_type; }
virtual inline void SetType(wxPropertyValueType typ) { m_type = typ; }
virtual long IntegerValue(void) const;
virtual float RealValue(void) const;
virtual bool BoolValue(void) const;
virtual char *StringValue(void) const;
virtual long *IntegerValuePtr(void) const;
virtual float *RealValuePtr(void) const;
virtual bool *BoolValuePtr(void) const;
virtual char **StringValuePtr(void) const;
// Get nth arg of clause (starting from 1)
virtual wxPropertyValue *Arg(wxPropertyValueType type, int arg) const;
// Return nth argument of a list expression (starting from zero)
virtual wxPropertyValue *Nth(int arg) const;
// Returns the number of elements in a list expression
virtual int Number(void) const;
virtual wxPropertyValue *NewCopy(void) const;
virtual void Copy(wxPropertyValue& copyFrom);
virtual void WritePropertyClause(ostream& stream); // Write this expression as a top-level clause
virtual void WritePropertyType(ostream& stream); // Write as any other subexpression
// Append an expression to a list
virtual void Append(wxPropertyValue *expr);
// Insert at beginning of list
virtual void Insert(wxPropertyValue *expr);
// Get first expr in list
virtual inline wxPropertyValue *GetFirst(void) const
{ return ((m_type == wxPropertyValueList) ? m_value.first : (wxPropertyValue*)NULL); }
// Get next expr if this is a node in a list
virtual inline wxPropertyValue *GetNext(void) const
{ return m_next; }
// Get last expr in list
virtual inline wxPropertyValue *GetLast(void) const
{ return ((m_type == wxPropertyValueList) ? m_last : (wxPropertyValue*)NULL); }
// Delete this node from the list
virtual void Delete(wxPropertyValue *node);
// Clear list
virtual void ClearList(void);
virtual inline void SetClientData(wxObject *data) { m_clientData = data; }
virtual inline wxObject *GetClientData(void) { return m_clientData; }
virtual wxString GetStringRepresentation(void);
inline void SetModified(bool flag = TRUE) { m_modifiedFlag = flag; }
inline bool GetModified(void) { return m_modifiedFlag; }
// Operators
void operator=(const wxPropertyValue& val);
// void operator=(const char *val);
void operator=(const wxString& val);
void operator=(const long val);
void operator=(const bool val);
void operator=(const float val);
void operator=(const char **val);
void operator=(const long *val);
void operator=(const bool *val);
void operator=(const float *val);
public:
wxObject* m_clientData;
wxPropertyValueType m_type;
bool m_modifiedFlag;
union {
long integer; // Also doubles as bool
char *string;
float real;
long *integerPtr;
bool *boolPtr;
char **stringPtr;
float *realPtr;
wxPropertyValue *first; // If is a list expr, points to the first node
} m_value;
wxPropertyValue* m_next; // If this is a node in a list, points to the next node
wxPropertyValue* m_last; // If is a list expr, points to the last node
};
/*
* Property class: contains a name and a value.
*/
class wxProperty: public wxObject
{
DECLARE_DYNAMIC_CLASS(wxProperty)
protected:
bool m_enabled;
public:
wxPropertyValue m_value;
wxString m_name;
wxString m_propertyRole;
wxPropertyValidator* m_propertyValidator;
wxWindow* m_propertyWindow; // Usually a panel item, if anything
wxProperty(void);
wxProperty(wxProperty& copyFrom);
wxProperty(wxString name, wxString role, wxPropertyValidator *ed = NULL);
wxProperty(wxString name, const wxPropertyValue& val, wxString role, wxPropertyValidator *ed = NULL);
~wxProperty(void);
virtual wxPropertyValue& GetValue(void) const;
virtual wxPropertyValidator *GetValidator(void) const;
virtual wxString& GetName(void) const;
virtual wxString& GetRole(void) const;
virtual void SetValue(const wxPropertyValue& val);
virtual void SetValidator(wxPropertyValidator *v);
virtual void SetName(wxString& nm);
virtual void SetRole(wxString& role);
void operator=(const wxPropertyValue& val);
virtual inline void SetWindow(wxWindow *win) { m_propertyWindow = win; }
virtual inline wxWindow *GetWindow(void) const { return m_propertyWindow; }
inline void Enable(bool en) { m_enabled = en; }
inline bool IsEnabled(void) const { return m_enabled; }
};
#endif

741
utils/dialoged/src/propform.cpp
View File

@ -1,741 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: propform.cpp
// Purpose: Property form classes
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "propform.h"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
#include <ctype.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#if wxUSE_IOSTREAMH
#if defined(__WXMSW__) && !defined(__GNUWIN32__)
#include <strstrea.h>
#else
#include <strstream.h>
#endif
#else
#include <strstream>
#endif
#include "wx/window.h"
#include "wx/utils.h"
#include "wx/list.h"
#include "propform.h"
/*
* Property view
*/
IMPLEMENT_DYNAMIC_CLASS(wxPropertyFormView, wxPropertyView)
BEGIN_EVENT_TABLE(wxPropertyFormView, wxPropertyView)
EVT_BUTTON(wxID_OK, wxPropertyFormView::OnOk)
EVT_BUTTON(wxID_CANCEL, wxPropertyFormView::OnCancel)
EVT_BUTTON(wxID_HELP, wxPropertyFormView::OnHelp)
EVT_BUTTON(wxID_PROP_REVERT, wxPropertyFormView::OnRevert)
EVT_BUTTON(wxID_PROP_UPDATE, wxPropertyFormView::OnUpdate)
END_EVENT_TABLE()
bool wxPropertyFormView::sm_dialogCancelled = FALSE;
wxPropertyFormView::wxPropertyFormView(wxWindow *propPanel, long flags):wxPropertyView(flags)
{
m_propertyWindow = propPanel;
m_managedWindow = NULL;
m_windowCloseButton = NULL;
m_windowCancelButton = NULL;
m_windowHelpButton = NULL;
m_detailedEditing = FALSE;
}
wxPropertyFormView::~wxPropertyFormView(void)
{
}
void wxPropertyFormView::ShowView(wxPropertySheet *ps, wxWindow *panel)
{
m_propertySheet = ps;
AssociatePanel(panel);
// CreateControls();
// UpdatePropertyList();
}
// Update this view of the viewed object, called e.g. by
// the object itself.
bool wxPropertyFormView::OnUpdateView(void)
{
return TRUE;
}
bool wxPropertyFormView::Check(void)
{
if (!m_propertySheet)
return FALSE;
wxNode *node = m_propertySheet->GetProperties().First();
while (node)
{
wxProperty *prop = (wxProperty *)node->Data();
wxPropertyValidator *validator = FindPropertyValidator(prop);
if (validator && validator->IsKindOf(CLASSINFO(wxPropertyFormValidator)))
{
wxPropertyFormValidator *formValidator = (wxPropertyFormValidator *)validator;
if (!formValidator->OnCheckValue(prop, this, m_propertyWindow))
return FALSE;
}
node = node->Next();
}
return TRUE;
}
bool wxPropertyFormView::TransferToPropertySheet(void)
{
if (!m_propertySheet)
return FALSE;
wxNode *node = m_propertySheet->GetProperties().First();
while (node)
{
wxProperty *prop = (wxProperty *)node->Data();
wxPropertyValidator *validator = FindPropertyValidator(prop);
if (validator && validator->IsKindOf(CLASSINFO(wxPropertyFormValidator)))
{
wxPropertyFormValidator *formValidator = (wxPropertyFormValidator *)validator;
formValidator->OnRetrieveValue(prop, this, m_propertyWindow);
}
node = node->Next();
}
return TRUE;
}
bool wxPropertyFormView::TransferToDialog(void)
{
if (!m_propertySheet)
return FALSE;
wxNode *node = m_propertySheet->GetProperties().First();
while (node)
{
wxProperty *prop = (wxProperty *)node->Data();
wxPropertyValidator *validator = FindPropertyValidator(prop);
if (validator && validator->IsKindOf(CLASSINFO(wxPropertyFormValidator)))
{
wxPropertyFormValidator *formValidator = (wxPropertyFormValidator *)validator;
formValidator->OnDisplayValue(prop, this, m_propertyWindow);
}
node = node->Next();
}
return TRUE;
}
bool wxPropertyFormView::AssociateNames(void)
{
if (!m_propertySheet || !m_propertyWindow)
return FALSE;
wxNode *node = m_propertyWindow->GetChildren()->First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();
if (win->GetName() != "")
{
wxProperty *prop = m_propertySheet->GetProperty(win->GetName());
if (prop)
prop->SetWindow(win);
}
node = node->Next();
}
return TRUE;
}
bool wxPropertyFormView::OnClose(void)
{
delete this;
return TRUE;
}
void wxPropertyFormView::OnOk(wxCommandEvent& WXUNUSED(event))
{
// Retrieve the value if any
if (!Check())
return;
sm_dialogCancelled = FALSE;
m_managedWindow->Close(TRUE);
}
void wxPropertyFormView::OnCancel(wxCommandEvent& WXUNUSED(event))
{
sm_dialogCancelled = TRUE;
m_managedWindow->Close(TRUE);
}
void wxPropertyFormView::OnHelp(wxCommandEvent& WXUNUSED(event))
{
}
void wxPropertyFormView::OnUpdate(wxCommandEvent& WXUNUSED(event))
{
TransferToPropertySheet();
}
void wxPropertyFormView::OnRevert(wxCommandEvent& WXUNUSED(event))
{
TransferToDialog();
}
void wxPropertyFormView::OnCommand(wxWindow& win, wxCommandEvent& event)
{
if (!m_propertySheet)
return;
if (win.GetName() == "")
return;
if (strcmp(win.GetName(), "ok") == 0)
OnOk(event);
else if (strcmp(win.GetName(), "cancel") == 0)
OnCancel(event);
else if (strcmp(win.GetName(), "help") == 0)
OnHelp(event);
else if (strcmp(win.GetName(), "update") == 0)
OnUpdate(event);
else if (strcmp(win.GetName(), "revert") == 0)
OnRevert(event);
else
{
// Find a validator to route the command to.
wxNode *node = m_propertySheet->GetProperties().First();
while (node)
{
wxProperty *prop = (wxProperty *)node->Data();
if (prop->GetWindow() && (prop->GetWindow() == &win))
{
wxPropertyValidator *validator = FindPropertyValidator(prop);
if (validator && validator->IsKindOf(CLASSINFO(wxPropertyFormValidator)))
{
wxPropertyFormValidator *formValidator = (wxPropertyFormValidator *)validator;
formValidator->OnCommand(prop, this, m_propertyWindow, event);
return;
}
}
node = node->Next();
}
}
}
void wxPropertyFormView::OnDoubleClick(wxControl *item)
{
if (!m_propertySheet)
return;
// Find a validator to route the command to.
wxNode *node = m_propertySheet->GetProperties().First();
while (node)
{
wxProperty *prop = (wxProperty *)node->Data();
if (prop->GetWindow() && ((wxControl *)prop->GetWindow() == item))
{
wxPropertyValidator *validator = FindPropertyValidator(prop);
if (validator && validator->IsKindOf(CLASSINFO(wxPropertyFormValidator)))
{
wxPropertyFormValidator *formValidator = (wxPropertyFormValidator *)validator;
formValidator->OnDoubleClick(prop, this, m_propertyWindow);
return;
}
}
node = node->Next();
}
}
/*
* Property form dialog box
*/
IMPLEMENT_CLASS(wxPropertyFormDialog, wxDialog)
wxPropertyFormDialog::wxPropertyFormDialog(wxPropertyFormView *v, wxWindow *parent, const wxString& title,
const wxPoint& pos, const wxSize& size, long style, const wxString& name):
wxDialog(parent, -1, title, pos, size, style, name)
{
m_view = v;
m_view->AssociatePanel(this);
m_view->SetManagedWindow(this);
// SetAutoLayout(TRUE);
}
bool wxPropertyFormDialog::OnClose(void)
{
if (m_view)
{
m_view->OnClose();
m_view = NULL;
return TRUE;
}
else
return FALSE;
}
void wxPropertyFormDialog::OnDefaultAction(wxControl *item)
{
m_view->OnDoubleClick(item);
}
void wxPropertyFormDialog::OnCommand(wxWindow& win, wxCommandEvent& event)
{
if ( m_view )
m_view->OnCommand(win, event);
}
// Extend event processing to search the view's event table
bool wxPropertyFormDialog::ProcessEvent(wxEvent& event)
{
if ( !m_view || ! m_view->ProcessEvent(event) )
return wxEvtHandler::ProcessEvent(event);
else
return TRUE;
}
/*
* Property form panel
*/
IMPLEMENT_CLASS(wxPropertyFormPanel, wxPanel)
void wxPropertyFormPanel::OnDefaultAction(wxControl *item)
{
m_view->OnDoubleClick(item);
}
void wxPropertyFormPanel::OnCommand(wxWindow& win, wxCommandEvent& event)
{
m_view->OnCommand(win, event);
}
// Extend event processing to search the view's event table
bool wxPropertyFormPanel::ProcessEvent(wxEvent& event)
{
if ( !m_view || ! m_view->ProcessEvent(event) )
return wxEvtHandler::ProcessEvent(event);
else
return TRUE;
}
/*
* Property frame
*/
IMPLEMENT_CLASS(wxPropertyFormFrame, wxFrame)
bool wxPropertyFormFrame::OnClose(void)
{
if (m_view)
return m_view->OnClose();
else
return FALSE;
}
wxPanel *wxPropertyFormFrame::OnCreatePanel(wxFrame *parent, wxPropertyFormView *v)
{
return new wxPropertyFormPanel(v, parent);
}
bool wxPropertyFormFrame::Initialize(void)
{
m_propertyPanel = OnCreatePanel(this, m_view);
if (m_propertyPanel)
{
m_view->AssociatePanel(m_propertyPanel);
m_view->SetManagedWindow(this);
return TRUE;
}
else
return FALSE;
}
/*
* Property form specific validator
*/
IMPLEMENT_ABSTRACT_CLASS(wxPropertyFormValidator, wxPropertyValidator)
/*
* Default validators
*/
IMPLEMENT_DYNAMIC_CLASS(wxRealFormValidator, wxPropertyFormValidator)
///
/// Real number form validator
///
bool wxRealFormValidator::OnCheckValue( wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *parentWindow)
{
if (m_realMin == 0.0 && m_realMax == 0.0)
return TRUE;
// The item used for viewing the real number: should be a text item.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
return FALSE;
wxString value(((wxTextCtrl *)m_propertyWindow)->GetValue());
float val = 0.0;
if (!StringToFloat(WXSTRINGCAST value, &val))
{
char buf[200];
sprintf(buf, "Value %s is not a valid real number!", (const char *)value);
wxMessageBox(buf, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
return FALSE;
}
if (val < m_realMin || val > m_realMax)
{
char buf[200];
sprintf(buf, "Value must be a real number between %.2f and %.2f!", m_realMin, m_realMax);
wxMessageBox(buf, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
return FALSE;
}
return TRUE;
}
bool wxRealFormValidator::OnRetrieveValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the real number: should be a text item.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
return FALSE;
wxString value(((wxTextCtrl *)m_propertyWindow)->GetValue());
if (value.Length() == 0)
return FALSE;
float f = (float)atof((const char *)value);
property->GetValue() = f;
return TRUE;
}
bool wxRealFormValidator::OnDisplayValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the real number: should be a text item.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
return FALSE;
wxTextCtrl *textItem = (wxTextCtrl *)m_propertyWindow;
textItem->SetValue(FloatToString(property->GetValue().RealValue()));
return TRUE;
}
///
/// Integer validator
///
IMPLEMENT_DYNAMIC_CLASS(wxIntegerFormValidator, wxPropertyFormValidator)
bool wxIntegerFormValidator::OnCheckValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *parentWindow)
{
if (m_integerMin == 0.0 && m_integerMax == 0.0)
return TRUE;
// The item used for viewing the real number: should be a text item or a slider
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
long val = 0;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxString value(((wxTextCtrl *)m_propertyWindow)->GetValue());
if (!StringToLong(WXSTRINGCAST value, &val))
{
char buf[200];
sprintf(buf, "Value %s is not a valid integer!", (const char *)value);
wxMessageBox(buf, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
return FALSE;
}
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxSlider)))
{
val = (long)((wxSlider *)m_propertyWindow)->GetValue();
}
else
return FALSE;
if (val < m_integerMin || val > m_integerMax)
{
char buf[200];
sprintf(buf, "Value must be an integer between %ld and %ld!", m_integerMin, m_integerMax);
wxMessageBox(buf, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
return FALSE;
}
return TRUE;
}
bool wxIntegerFormValidator::OnRetrieveValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow))
{
// The item used for viewing the real number: should be a text item or a slider
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxString value(((wxTextCtrl *)m_propertyWindow)->GetValue());
if (value.Length() == 0)
return FALSE;
long i = atol((const char *)value);
property->GetValue() = i;
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxSlider)))
{
property->GetValue() = (long)((wxSlider *)m_propertyWindow)->GetValue();
}
else
return FALSE;
return TRUE;
}
bool wxIntegerFormValidator::OnDisplayValue( wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow))
{
// The item used for viewing the real number: should be a text item or a slider
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxTextCtrl *textItem = (wxTextCtrl *)m_propertyWindow;
textItem->SetValue(LongToString(property->GetValue().IntegerValue()));
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxSlider)))
{
((wxSlider *)m_propertyWindow)->SetValue((int)property->GetValue().IntegerValue());
}
else
return FALSE;
return TRUE;
}
///
/// Boolean validator
///
IMPLEMENT_DYNAMIC_CLASS(wxBoolFormValidator, wxPropertyFormValidator)
bool wxBoolFormValidator::OnCheckValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow))
{
// The item used for viewing the boolean: should be a checkbox
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxCheckBox)))
return FALSE;
return TRUE;
}
bool wxBoolFormValidator::OnRetrieveValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the boolean: should be a checkbox.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxCheckBox)))
return FALSE;
wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
property->GetValue() = (bool)checkBox->GetValue();
return TRUE;
}
bool wxBoolFormValidator::OnDisplayValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow))
{
// The item used for viewing the boolean: should be a checkbox.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow || !m_propertyWindow->IsKindOf(CLASSINFO(wxCheckBox)))
return FALSE;
wxCheckBox *checkBox = (wxCheckBox *)m_propertyWindow;
checkBox->SetValue((bool)property->GetValue().BoolValue());
return TRUE;
}
///
/// String validator
///
IMPLEMENT_DYNAMIC_CLASS(wxStringFormValidator, wxPropertyFormValidator)
wxStringFormValidator::wxStringFormValidator(wxStringList *list, long flags):
wxPropertyFormValidator(flags)
{
m_strings = list;
}
bool wxStringFormValidator::OnCheckValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *parentWindow )
{
if (!m_strings)
return TRUE;
// The item used for viewing the string: should be a text item, choice item or listbox.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
if (!m_strings->Member(text->GetValue()))
{
wxString s("Value ");
s += text->GetValue();
s += " is not valid.";
wxMessageBox(s, "Property value error", wxOK | wxICON_EXCLAMATION, parentWindow);
return FALSE;
}
}
else
{
// Any other item constrains the string value,
// so we don't have to check it.
}
return TRUE;
}
bool wxStringFormValidator::OnRetrieveValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the string: should be a text item, choice item or listbox.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
property->GetValue() = text->GetValue();
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxListBox)))
{
wxListBox *lbox = (wxListBox *)m_propertyWindow;
if (lbox->GetSelection() > -1)
property->GetValue() = lbox->GetStringSelection();
}
/*
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxRadioBox)))
{
wxRadioBox *rbox = (wxRadioBox *)m_propertyWindow;
int n = 0;
if ((n = rbox->GetSelection()) > -1)
property->GetValue() = rbox->GetString(n);
}
*/
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxChoice)))
{
wxChoice *choice = (wxChoice *)m_propertyWindow;
if (choice->GetSelection() > -1)
property->GetValue() = choice->GetStringSelection();
}
else
return FALSE;
return TRUE;
}
bool wxStringFormValidator::OnDisplayValue(wxProperty *property, wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) )
{
// The item used for viewing the string: should be a text item, choice item or listbox.
wxWindow *m_propertyWindow = property->GetWindow();
if (!m_propertyWindow)
return FALSE;
if (m_propertyWindow->IsKindOf(CLASSINFO(wxTextCtrl)))
{
wxTextCtrl *text = (wxTextCtrl *)m_propertyWindow;
text->SetValue(property->GetValue().StringValue());
}
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxListBox)))
{
wxListBox *lbox = (wxListBox *)m_propertyWindow;
if (lbox->Number() == 0 && m_strings)
{
// Try to initialize the listbox from 'strings'
wxNode *node = m_strings->First();
while (node)
{
char *s = (char *)node->Data();
lbox->Append(s);
node = node->Next();
}
}
lbox->SetStringSelection(property->GetValue().StringValue());
}
/*
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxRadioBox)))
{
wxRadioBox *rbox = (wxRadioBox *)m_propertyWindow;
rbox->SetStringSelection(property->GetValue().StringValue());
}
*/
else if (m_propertyWindow->IsKindOf(CLASSINFO(wxChoice)))
{
wxChoice *choice = (wxChoice *)m_propertyWindow;
#ifndef __XVIEW__
if (choice->Number() == 0 && m_strings)
{
// Try to initialize the choice item from 'strings'
// XView doesn't allow this kind of thing.
wxNode *node = m_strings->First();
while (node)
{
char *s = (char *)node->Data();
choice->Append(s);
node = node->Next();
}
}
#endif
choice->SetStringSelection(property->GetValue().StringValue());
}
else
return FALSE;
return TRUE;
}

297
utils/dialoged/src/propform.h
View File

@ -1,297 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: propform.h
// Purpose: Property form classes
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
#ifndef _PROPFORM_H_
#define _PROPFORM_H_
#ifdef __GNUG__
#pragma interface "propform.h"
#endif
#include "prop.h"
////
//// Property form classes: for using an existing dialog or panel
////
#define wxID_PROP_REVERT 3100
#define wxID_PROP_UPDATE 3101
// Mediates between a physical panel and the property sheet
class wxPropertyFormView: public wxPropertyView
{
DECLARE_DYNAMIC_CLASS(wxPropertyFormView)
public:
wxPropertyFormView(wxWindow *propPanel = NULL, long flags = 0);
~wxPropertyFormView(void);
// Associates and shows the view
virtual void ShowView(wxPropertySheet *propertySheet, wxWindow *panel);
// Update this view of the viewed object, called e.g. by
// the object itself.
virtual bool OnUpdateView(void);
// Transfer values from property sheet to dialog
virtual bool TransferToDialog(void);
// Transfer values from dialog to property sheet
virtual bool TransferToPropertySheet(void);
// Check that all the values are valid
virtual bool Check(void);
// Give each property in the sheet a panel item, by matching
// the name of the property to the name of the panel item.
// The user doesn't always want to call this; sometimes, it
// will have been done explicitly (e.g., no matching names).
virtual bool AssociateNames(void);
void OnOk(wxCommandEvent& event);
void OnCancel(wxCommandEvent& event);
void OnHelp(wxCommandEvent& event);
void OnUpdate(wxCommandEvent& event);
void OnRevert(wxCommandEvent& event);
virtual bool OnClose(void);
virtual void OnDoubleClick(wxControl *item);
// TODO: does OnCommand still get called...???
virtual void OnCommand(wxWindow& win, wxCommandEvent& event);
inline virtual void AssociatePanel(wxWindow *win) { m_propertyWindow = win; }
inline virtual wxWindow *GetPanel(void) const { return m_propertyWindow; }
inline virtual void SetManagedWindow(wxWindow *win) { m_managedWindow = win; }
inline virtual wxWindow *GetManagedWindow(void) const { return m_managedWindow; }
inline virtual wxButton *GetWindowCloseButton() const { return m_windowCloseButton; }
inline virtual wxButton *GetWindowCancelButton() const { return m_windowCancelButton; }
inline virtual wxButton *GetHelpButton() const { return m_windowHelpButton; }
public:
static bool sm_dialogCancelled;
protected:
bool m_detailedEditing; // E.g. using listbox for choices
wxWindow* m_propertyWindow; // Panel that the controls will appear on
wxWindow* m_managedWindow; // Frame or dialog
wxButton* m_windowCloseButton; // Or OK
wxButton* m_windowCancelButton;
wxButton* m_windowHelpButton;
DECLARE_EVENT_TABLE()
};
/*
* The type of validator used for forms (wxForm style but using an existing panel
* or dialog box).
* Classes derived from this know how to map from whatever widget they
* find themselves paired with, to the wxProperty and vice versa.
* Should the widget pointer be stored with the validator, or
* the wxProperty? If with the property, we don't have to supply
* a validator for every property. Otherwise, there ALWAYS needs
* to be a validator. On the other hand, not storing a wxWindow pointer
* in the wxProperty is more elegant. Perhaps.
* I think on balance, should put wxWindow pointer into wxProperty.
* After all, wxProperty will often be used to represent the data
* assocated with a window. It's that kinda thing.
*/
class wxPropertyFormValidator: public wxPropertyValidator
{
DECLARE_DYNAMIC_CLASS(wxPropertyFormValidator)
protected:
public:
wxPropertyFormValidator(long flags = 0): wxPropertyValidator(flags) { }
~wxPropertyFormValidator(void) {}
// Called to check value is OK (e.g. when OK is pressed)
// Return FALSE if value didn't check out; signal to restore old value.
virtual bool OnCheckValue( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) ) { return TRUE; }
// Does the transferance from the property editing area to the property itself.
// Called by the view, e.g. when closing the window.
virtual bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow) = 0;
// Called by the view to transfer the property to the window.
virtual bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow) = 0;
virtual void OnDoubleClick( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) ) { }
virtual void OnSetFocus( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) ) { }
virtual void OnKillFocus( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow) ) { }
virtual void OnCommand( wxProperty *WXUNUSED(property), wxPropertyFormView *WXUNUSED(view),
wxWindow *WXUNUSED(parentWindow), wxCommandEvent& WXUNUSED(event) ) {}
};
/*
* Some default validators
*/
class wxRealFormValidator: public wxPropertyFormValidator
{
DECLARE_DYNAMIC_CLASS(wxRealFormValidator)
public:
// 0.0, 0.0 means no range
wxRealFormValidator(float min = 0.0, float max = 0.0, long flags = 0):wxPropertyFormValidator(flags)
{
m_realMin = min; m_realMax = max;
}
~wxRealFormValidator(void) {}
bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
// Called by the view to transfer the property to the window.
bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
protected:
float m_realMin;
float m_realMax;
};
class wxIntegerFormValidator: public wxPropertyFormValidator
{
DECLARE_DYNAMIC_CLASS(wxIntegerFormValidator)
public:
// 0, 0 means no range
wxIntegerFormValidator(long min = 0, long max = 0, long flags = 0):wxPropertyFormValidator(flags)
{
m_integerMin = min; m_integerMax = max;
}
~wxIntegerFormValidator(void) {}
bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
protected:
long m_integerMin;
long m_integerMax;
};
class wxBoolFormValidator: public wxPropertyFormValidator
{
DECLARE_DYNAMIC_CLASS(wxBoolFormValidator)
protected:
public:
wxBoolFormValidator(long flags = 0):wxPropertyFormValidator(flags)
{
}
~wxBoolFormValidator(void) {}
bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
};
class wxStringFormValidator: public wxPropertyFormValidator
{
DECLARE_DYNAMIC_CLASS(wxStringFormValidator)
public:
wxStringFormValidator(wxStringList *list = NULL, long flags = 0);
~wxStringFormValidator(void)
{
if (m_strings)
delete m_strings;
}
bool OnCheckValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnRetrieveValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyFormView *view, wxWindow *parentWindow);
protected:
wxStringList* m_strings;
};
/*
* A default dialog box class to use.
*/
class wxPropertyFormDialog: public wxDialog
{
DECLARE_CLASS(wxPropertyFormDialog)
public:
wxPropertyFormDialog(wxPropertyFormView *v, wxWindow *parent, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "dialogBox");
bool OnClose(void);
void OnDefaultAction(wxControl *item);
void OnCommand(wxWindow& win, wxCommandEvent& event);
// Extend event processing to search the view's event table
virtual bool ProcessEvent(wxEvent& event);
private:
wxPropertyFormView* m_view;
};
/*
* A default panel class to use.
*/
class wxPropertyFormPanel: public wxPanel
{
DECLARE_CLASS(wxPropertyFormPanel)
public:
wxPropertyFormPanel(wxPropertyFormView *v, wxWindow *parent, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "panel"):
wxPanel(parent, -1, pos, size, style, name)
{
m_view = v;
}
void OnDefaultAction(wxControl *item);
void OnCommand(wxWindow& win, wxCommandEvent& event);
// Extend event processing to search the view's event table
virtual bool ProcessEvent(wxEvent& event);
private:
wxPropertyFormView* m_view;
};
/*
* A default frame class to use.
*/
class wxPropertyFormFrame: public wxFrame
{
DECLARE_CLASS(wxPropertyFormFrame)
public:
wxPropertyFormFrame(wxPropertyFormView *v, wxFrame *parent, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME, const wxString& name = "frame"):
wxFrame(parent, -1, title, pos, size, style, name)
{
m_view = v;
m_propertyPanel = NULL;
}
bool OnClose(void);
// Must call this to create panel and associate view
virtual bool Initialize(void);
virtual wxPanel *OnCreatePanel(wxFrame *parent, wxPropertyFormView *v);
inline virtual wxPanel *GetPropertyPanel(void) const { return m_propertyPanel; }
private:
wxPropertyFormView* m_view;
wxPanel* m_propertyPanel;
};
#endif

1946
utils/dialoged/src/proplist.cpp
View File

File diff suppressed because it is too large Load Diff

557
utils/dialoged/src/proplist.h
View File

@ -1,557 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: proplist.h
// Purpose: Property list classes
// Author: Julian Smart
// Modified by:
// Created: 04/01/98
// RCS-ID: $Id$
// Copyright: (c) Julian Smart
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*
TO DO:
(1) Optional popup-help for each item, and an optional Help button
for dialog.
(2) Align Ok, Cancel, Help buttons properly.
(3) Consider retrieving the rectangle on the panel that can be
drawn into (where the value listbox is) and giving an example
of editing graphically. May be too fancy.
(4) Deriveable types for wxPropertyValue => may need to reorganise
wxPropertyValue to use inheritance rather than present all-types-in-one
scheme.
(5) Optional popup panel for value list, perhaps.
(6) Floating point checking routine still crashes with Floating
point error for zany input.
(7) Property sheet with choice (or listbox) to select alternative
sheets... multiple views per panel, only one active. For this
we really need a wxChoice that can be dynamically set: XView
may be a problem; Motif?
(8) More example validators, e.g. colour selector.
*/
#ifndef _PROPLIST_H_
#define _PROPLIST_H_
#ifdef __GNUG__
#pragma interface "proplist.h"
#endif
#include "prop.h"
#define wxPROP_BUTTON_CLOSE 1
#define wxPROP_BUTTON_OK 2
#define wxPROP_BUTTON_CANCEL 4
#define wxPROP_BUTTON_CHECK_CROSS 8
#define wxPROP_BUTTON_HELP 16
#define wxPROP_DYNAMIC_VALUE_FIELD 32
#define wxPROP_PULLDOWN 64
#define wxPROP_SHOWVALUES 128
#ifdef __XVIEW__
#define wxPROP_BUTTON_DEFAULT wxPROP_BUTTON_OK | wxPROP_BUTTON_CANCEL | wxPROP_BUTTON_CHECK_CROSS | wxPROP_PULLDOWN
#else
#define wxPROP_BUTTON_DEFAULT wxPROP_BUTTON_CHECK_CROSS | wxPROP_PULLDOWN | wxPROP_SHOWVALUES
#endif
#define wxID_PROP_CROSS 3000
#define wxID_PROP_CHECK 3001
#define wxID_PROP_EDIT 3002
#define wxID_PROP_TEXT 3003
#define wxID_PROP_SELECT 3004
#define wxID_PROP_VALUE_SELECT 3005
// Mediates between a physical panel and the property sheet
class wxPropertyListView: public wxPropertyView
{
DECLARE_DYNAMIC_CLASS(wxPropertyListView)
public:
wxPropertyListView(wxPanel *propPanel = NULL, long flags = wxPROP_BUTTON_DEFAULT);
~wxPropertyListView(void);
// Associates and shows the view
virtual void ShowView(wxPropertySheet *propertySheet, wxPanel *panel);
// Update this view of the viewed object, called e.g. by
// the object itself.
virtual bool OnUpdateView(void);
wxString MakeNameValueString(wxString name, wxString value);
// Update a single line in the list of properties
virtual bool UpdatePropertyDisplayInList(wxProperty *property);
// Update the whole list
virtual bool UpdatePropertyList(bool clearEditArea = TRUE);
// Find the wxListBox index corresponding to this property
virtual int FindListIndexForProperty(wxProperty *property);
// Select and show string representation in editor the given
// property. NULL resets to show no property.
virtual bool ShowProperty(wxProperty *property, bool select = TRUE);
virtual bool EditProperty(wxProperty *property);
// Update the display from the property
virtual bool DisplayProperty(wxProperty *property);
// Update the property from the display
virtual bool RetrieveProperty(wxProperty *property);
// Find appropriate validator and load property into value controls
virtual bool BeginShowingProperty(wxProperty *property);
// Find appropriate validator and unload property from value controls
virtual bool EndShowingProperty(wxProperty *property);
// Begin detailed editing (e.g. using value listbox)
virtual void BeginDetailedEditing(void);
// End detailed editing (e.g. using value listbox)
virtual void EndDetailedEditing(void);
// Called by the property listbox
void OnPropertySelect(wxCommandEvent& event);
// Called by the value listbox
void OnValueListSelect(wxCommandEvent& event);
virtual bool CreateControls(void);
virtual void ShowTextControl(bool show);
virtual void ShowListBoxControl(bool show);
virtual void EnableCheck(bool show);
virtual void EnableCross(bool show);
void OnOk(wxCommandEvent& event);
void OnCancel(wxCommandEvent& event);
void OnHelp(wxCommandEvent& event);
void OnPropertyDoubleClick(wxCommandEvent& event);
// virtual void OnDoubleClick(void);
void OnCheck(wxCommandEvent& event);
void OnCross(wxCommandEvent& event);
void OnEdit(wxCommandEvent& event);
void OnText(wxCommandEvent& event);
inline virtual wxListBox *GetPropertyScrollingList() const { return m_propertyScrollingList; }
inline virtual wxListBox *GetValueList() const { return m_valueList; }
inline virtual wxTextCtrl *GetValueText() const { return m_valueText; }
inline virtual wxButton *GetConfirmButton() const { return m_confirmButton; }
inline virtual wxButton *GetCancelButton() const { return m_cancelButton; }
inline virtual wxButton *GetEditButton() const { return m_editButton; }
inline virtual bool GetDetailedEditing(void) const { return m_detailedEditing; }
inline virtual void AssociatePanel(wxPanel *win) { m_propertyWindow = win; }
inline virtual wxPanel *GetPanel(void) const { return m_propertyWindow; }
inline virtual void SetManagedWindow(wxWindow *win) { m_managedWindow = win; }
inline virtual wxWindow *GetManagedWindow(void) const { return m_managedWindow; }
inline virtual wxButton *GetWindowCloseButton() const { return m_windowCloseButton; }
inline virtual wxButton *GetWindowCancelButton() const { return m_windowCancelButton; }
inline virtual wxButton *GetHelpButton() const { return m_windowHelpButton; }
bool OnClose(void);
public:
static bool sm_dialogCancelled;
protected:
wxListBox* m_propertyScrollingList;
wxListBox* m_valueList; // Should really be a combobox, but we don't have one.
wxTextCtrl* m_valueText;
wxButton* m_confirmButton; // A tick, as in VB
wxButton* m_cancelButton; // A cross, as in VB
wxButton* m_editButton; // Invokes the custom validator, if any
bool m_detailedEditing; // E.g. using listbox for choices
static wxBitmap* sm_tickBitmap;
static wxBitmap* sm_crossBitmap;
wxPanel* m_propertyWindow; // Panel that the controls will appear on
wxWindow* m_managedWindow; // Frame or dialog
wxButton* m_windowCloseButton; // Or OK
wxButton* m_windowCancelButton;
wxButton* m_windowHelpButton;
DECLARE_EVENT_TABLE()
};
class wxPropertyTextEdit: public wxTextCtrl
{
DECLARE_CLASS(wxPropertyTextEdit)
public:
wxPropertyTextEdit(wxPropertyListView *v, wxWindow *parent, const wxWindowID id,
const wxString& value, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "text");
void OnSetFocus(void);
void OnKillFocus(void);
wxPropertyListView* m_view;
};
#define wxPROP_ALLOW_TEXT_EDITING 1
/*
* The type of validator used for property lists (Visual Basic style)
*/
class wxPropertyListValidator: public wxPropertyValidator
{
DECLARE_DYNAMIC_CLASS(wxPropertyListValidator)
protected:
public:
wxPropertyListValidator(long flags = wxPROP_ALLOW_TEXT_EDITING): wxPropertyValidator(flags) { }
~wxPropertyListValidator(void) {}
// Called when the property is selected or deselected: typically displays the value
// in the edit control (having chosen a suitable control to display: (non)editable text or listbox)
virtual bool OnSelect(bool select, wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property is double clicked. Extra functionality can be provided, such as
// cycling through possible values.
inline virtual bool OnDoubleClick(
wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow) )
{ return TRUE; }
// Called when the value listbox is selected. Default behaviour is to copy
// string to text control, and retrieve the value into the property.
virtual bool OnValueListSelect(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property value is edited using standard text control
inline virtual bool OnPrepareControls(
wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow) )
{ return TRUE; }
virtual bool OnClearControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property is edited in detail
inline virtual bool OnPrepareDetailControls(
wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow) )
{ return TRUE; }
// Called if focus lost, IF we're in a modeless property editing situation.
inline virtual bool OnClearDetailControls(
wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow) )
{ return TRUE; }
// Called when the edit (...) button is pressed. The default implementation
// calls view->BeginDetailedEditing; the filename validator (for example) overrides
// this function to show the file selector.
virtual void OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
inline virtual bool OnCheckValue(
wxProperty *WXUNUSED(property), wxPropertyListView *WXUNUSED(view), wxWindow *WXUNUSED(parentWindow) )
{ return TRUE; }
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transferance from the property editing area to the property itself
virtual bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
virtual bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
};
/*
* A default dialog box class to use.
*/
class wxPropertyListDialog: public wxDialog
{
DECLARE_CLASS(wxPropertyListDialog)
public:
wxPropertyListDialog(wxPropertyListView *v, wxWindow *parent, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE, const wxString& name = "dialogBox");
bool OnClose(void);
void OnDefaultAction(wxControl *item);
void OnCancel(wxCommandEvent& event);
// Extend event processing to search the view's event table
virtual bool ProcessEvent(wxEvent& event);
private:
wxPropertyListView* m_view;
DECLARE_EVENT_TABLE()
};
/*
* A default panel class to use.
*/
class wxPropertyListPanel: public wxPanel
{
DECLARE_CLASS(wxPropertyListPanel)
public:
wxPropertyListPanel(wxPropertyListView *v, wxWindow *parent, const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0, const wxString& name = "panel"):
wxPanel(parent, -1, pos, size, style, name)
{
m_view = v;
}
~wxPropertyListPanel();
void OnDefaultAction(wxControl *item);
inline void SetView(wxPropertyListView* v) { m_view = v; }
inline wxPropertyListView* GetView() const { return m_view; }
// Extend event processing to search the view's event table
virtual bool ProcessEvent(wxEvent& event);
// Call Layout()
void OnSize(wxSizeEvent& event);
private:
wxPropertyListView* m_view;
DECLARE_EVENT_TABLE()
};
/*
* A default frame class to use.
*/
class wxPropertyListFrame: public wxFrame
{
DECLARE_CLASS(wxPropertyListFrame)
public:
wxPropertyListFrame(wxPropertyListView *v, wxFrame *parent, const wxString& title,
const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_FRAME, const wxString& name = "frame"):
wxFrame(parent, -1, title, pos, size, style, name)
{
m_view = v;
m_propertyPanel = NULL;
}
bool OnClose(void);
// Must call this to create panel and associate view
virtual bool Initialize(void);
virtual wxPropertyListPanel *OnCreatePanel(wxFrame *parent, wxPropertyListView *v);
inline virtual wxPropertyListPanel *GetPropertyPanel(void) const { return m_propertyPanel; }
private:
wxPropertyListView* m_view;
wxPropertyListPanel* m_propertyPanel;
};
/*
* Some default validators
*/
class wxRealListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxRealListValidator)
public:
// 0.0, 0.0 means no range
wxRealListValidator(float min = 0.0, float max = 0.0, long flags = wxPROP_ALLOW_TEXT_EDITING):wxPropertyListValidator(flags)
{
m_realMin = min; m_realMax = max;
}
~wxRealListValidator(void) {}
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transfer from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
protected:
float m_realMin;
float m_realMax;
};
class wxIntegerListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxIntegerListValidator)
public:
// 0, 0 means no range
wxIntegerListValidator(long min = 0, long max = 0, long flags = wxPROP_ALLOW_TEXT_EDITING):wxPropertyListValidator(flags)
{
m_integerMin = min; m_integerMax = max;
}
~wxIntegerListValidator(void) {}
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transfer from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
protected:
long m_integerMin;
long m_integerMax;
};
class wxBoolListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxBoolListValidator)
protected:
public:
wxBoolListValidator(long flags = 0):wxPropertyListValidator(flags)
{
}
~wxBoolListValidator(void) {}
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnPrepareDetailControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnClearDetailControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transfer from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property is double clicked. Extra functionality can be provided,
// cycling through possible values.
virtual bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
};
class wxStringListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxStringListValidator)
public:
wxStringListValidator(wxStringList *list = NULL, long flags = 0);
~wxStringListValidator(void)
{
if (m_strings)
delete m_strings;
}
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnPrepareDetailControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnClearDetailControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transfer from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property is double clicked. Extra functionality can be provided,
// cycling through possible values.
bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
protected:
wxStringList* m_strings;
};
class wxFilenameListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxFilenameListValidator)
public:
wxFilenameListValidator(wxString message = "Select a file", wxString wildcard = "*.*", long flags = 0);
~wxFilenameListValidator(void);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transferance from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the edit (...) button is pressed.
void OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
protected:
wxString m_filenameWildCard;
wxString m_filenameMessage;
};
class wxColourListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxColourListValidator)
protected:
public:
wxColourListValidator(long flags = 0);
~wxColourListValidator(void);
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the edit (...) button is pressed.
void OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
};
class wxListOfStringsListValidator: public wxPropertyListValidator
{
DECLARE_DYNAMIC_CLASS(wxListOfStringsListValidator)
protected:
public:
wxListOfStringsListValidator(long flags = 0);
~wxListOfStringsListValidator(void)
{
}
bool OnPrepareControls(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost.
// Return FALSE if value didn't check out; signal to restore old value.
bool OnCheckValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when TICK is pressed or focus is lost or view wants to update
// the property list.
// Does the transfer from the property editing area to the property itself
bool OnRetrieveValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool OnDisplayValue(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
// Called when the property is double clicked.
bool OnDoubleClick(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
bool EditStringList(wxWindow *parent, wxStringList *stringList, const char *title = "String List Editor");
// Called when the edit (...) button is pressed.
void OnEdit(wxProperty *property, wxPropertyListView *view, wxWindow *parentWindow);
};
#endif

59
utils/dialoged/src/reseditr.cpp
View File

@ -560,16 +560,13 @@ bool wxResourceManager::DisassociateResource(wxItemResource *resource)
return FALSE;
// Disassociate children of window
if (win->GetChildren())
wxNode *node = win->GetChildren().First();
while (node)
{
wxNode *node = win->GetChildren()->First();
while (node)
{
wxWindow *child = (wxWindow *)node->Data();
if (child->IsKindOf(CLASSINFO(wxControl)))
DisassociateResource(child);
node = node->Next();
}
wxWindow *child = (wxWindow *)node->Data();
if (child->IsKindOf(CLASSINFO(wxControl)))
DisassociateResource(child);
node = node->Next();
}
RemoveSelection(win);
@ -599,7 +596,7 @@ bool wxResourceManager::SaveInfoAndDeleteHandler(wxWindow* win)
win->PopEventHandler();
// Now reset all child event handlers
wxNode *node = win->GetChildren()->First();
wxNode *node = win->GetChildren().First();
while ( node )
{
wxWindow *child = (wxWindow *)node->Data();
@ -790,47 +787,47 @@ wxToolBar *wxResourceManager::OnCreateToolBar(wxFrame *parent)
#endif
int currentX = gap;
toolbar->AddSeparator();
toolbar->AddTool(TOOLBAR_NEW, ToolbarNewBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_NEW, ToolbarNewBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "New dialog");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_LOAD_FILE, ToolbarLoadBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_LOAD_FILE, ToolbarLoadBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Load");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_SAVE_FILE, ToolbarSaveBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_SAVE_FILE, ToolbarSaveBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Save");
currentX += width + dx + gap;
toolbar->AddSeparator();
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ, ToolbarVertBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ, ToolbarVertBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Horizontal align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_FORMAT_VERT_TOP_ALIGN, ToolbarAlignTBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_VERT_TOP_ALIGN, ToolbarAlignTBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Top align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_FORMAT_VERT_BOT_ALIGN, ToolbarAlignBBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_VERT_BOT_ALIGN, ToolbarAlignBBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Bottom align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_FORMAT_VERT, ToolbarHorizBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_VERT, ToolbarHorizBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Vertical align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN, ToolbarAlignLBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_LEFT_ALIGN, ToolbarAlignLBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Left align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN, ToolbarAlignRBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_FORMAT_HORIZ_RIGHT_ALIGN, ToolbarAlignRBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Right align");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_COPY_SIZE, ToolbarCopySizeBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_COPY_SIZE, ToolbarCopySizeBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Copy size");
currentX += width + dx + gap;
toolbar->AddSeparator();
toolbar->AddTool(TOOLBAR_TO_FRONT, ToolbarToFrontBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_TO_FRONT, ToolbarToFrontBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "To front");
currentX += width + dx;
toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_TO_BACK, ToolbarToBackBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "To back");
currentX += width + dx + gap;
toolbar->AddSeparator();
toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, (wxBitmap *)NULL,
toolbar->AddTool(TOOLBAR_HELP, ToolbarHelpBitmap, wxNullBitmap,
FALSE, (float)currentX, -1, NULL, "Help");
currentX += width + dx;
@ -1037,7 +1034,7 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
MakeUniqueName("button", buf);
res->SetName(buf);
if (isBitmap)
newItem = new wxBitmapButton(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
else
newItem = new wxButton(panel, -1, "Button", wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
}
@ -1046,7 +1043,7 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
prefix = "ID_BITMAPBUTTON";
MakeUniqueName("button", buf);
res->SetName(buf);
newItem = new wxBitmapButton(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
newItem = new wxBitmapButton(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, wxDefaultValidator, buf);
}
else if (itemType == "wxMessage" || itemType == "wxStaticText")
{
@ -1054,7 +1051,7 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
MakeUniqueName("statictext", buf);
res->SetName(buf);
if (isBitmap)
newItem = new wxStaticBitmap(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(0, 0), 0, buf);
newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(0, 0), 0, buf);
else
newItem = new wxStaticText(panel, -1, "Static", wxPoint(x, y), wxSize(-1, -1), 0, buf);
}
@ -1063,7 +1060,7 @@ bool wxResourceManager::CreatePanelItem(wxItemResource *panelResource, wxPanel *
prefix = "ID_STATICBITMAP";
MakeUniqueName("static", buf);
res->SetName(buf);
newItem = new wxStaticBitmap(panel, -1, m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, buf);
newItem = new wxStaticBitmap(panel, -1, * m_bitmapImage, wxPoint(x, y), wxSize(-1, -1), 0, buf);
}
else if (itemType == "wxCheckBox")
{
@ -1235,7 +1232,7 @@ wxWindow *wxResourceManager::FindParentOfSelection()
wxWindow *win = FindWindowForResource(res);
if (win)
{
wxNode *node1 = win->GetChildren()->First();
wxNode *node1 = win->GetChildren().First();
while (node1)
{
wxControl *item = (wxControl *)node1->Data();
@ -1374,18 +1371,18 @@ void wxResourceManager::ToBackOrFront(bool toBack)
wxItemResource *itemResource = FindResourceForWindow(item);
if (item->GetParent() == win)
{
win->GetChildren()->DeleteObject(item);
win->GetChildren().DeleteObject(item);
if (winResource)
winResource->GetChildren().DeleteObject(itemResource);
if (toBack)
{
win->GetChildren()->Insert(item);
win->GetChildren().Insert(item);
if (winResource)
winResource->GetChildren().Insert(itemResource);
}
else
{
win->GetChildren()->Append(item);
win->GetChildren().Append(item);
if (winResource)
winResource->GetChildren().Append(itemResource);
}

49
utils/dialoged/src/winprop.cpp
View File

@ -286,7 +286,7 @@ wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
{
wxItemResource* resource = wxResourceManager::GetCurrentResourceManager()->FindResourceForWindow(m_propertyWindow);
wxFont *font = m_propertyWindow->GetFont();
wxFont *font = & m_propertyWindow->GetFont();
if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
name == "fontUnderlined")
return GetFontProperty(name, font);
@ -353,12 +353,12 @@ wxProperty *wxWindowPropertyInfo::GetProperty(wxString& name)
bool wxWindowPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
wxFont *font = m_propertyWindow->GetFont();
wxFont *font = & m_propertyWindow->GetFont();
if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
{
wxFont *newFont = SetFontProperty(name, property, font);
if (newFont)
m_propertyWindow->SetFont(newFont);
m_propertyWindow->SetFont(* newFont);
return TRUE;
}
else if (name == "name")
@ -721,7 +721,7 @@ void wxWindowPropertyInfo::SetWindowStyle(wxWindow* win, long style, bool set)
wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
{
wxControl *itemWindow = (wxControl *)m_propertyWindow;
wxFont *font = itemWindow->GetFont();
wxFont *font = & itemWindow->GetFont();
if (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" ||
name == "fontUnderlined")
@ -735,13 +735,13 @@ wxProperty *wxItemPropertyInfo::GetProperty(wxString& name)
bool wxItemPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
wxControl *itemWindow = (wxControl *)m_propertyWindow;
wxFont *font = itemWindow->GetFont();
wxFont *font = & itemWindow->GetFont();
if (font && (name == "fontPoints" || name == "fontFamily" || name == "fontStyle" || name == "fontWeight" || name == "fontUnderlined" ))
{
wxFont *newFont = SetFontProperty(name, property, font);
if (newFont)
itemWindow->SetLabelFont(newFont);
itemWindow->SetLabelFont(* newFont);
return TRUE;
}
else if (name == "label")
@ -771,10 +771,10 @@ bool wxItemPropertyInfo::InstantiateResource(wxItemResource *resource)
wxControl *item = (wxControl *)m_propertyWindow;
wxString str(item->GetLabel());
resource->SetTitle(str);
if (item->GetFont() && item->GetFont()->Ok())
resource->SetFont(wxTheFontList->FindOrCreateFont(item->GetFont()->GetPointSize(),
item->GetFont()->GetFamily(), item->GetFont()->GetStyle(), item->GetFont()->GetWeight(),
item->GetFont()->GetUnderlined(), item->GetFont()->GetFaceName()));
if (item->GetFont().Ok())
resource->SetFont(* wxTheFontList->FindOrCreateFont(item->GetFont().GetPointSize(),
item->GetFont().GetFamily(), item->GetFont().GetStyle(), item->GetFont().GetWeight(),
item->GetFont().GetUnderlined(), item->GetFont().GetFaceName()));
return TRUE;
}
@ -854,7 +854,7 @@ bool wxBitmapButtonPropertyInfo::SetProperty(wxString& name, wxProperty *propert
wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
}
button->SetLabel(bitmap);
button->SetLabel(* bitmap);
delete[] s;
return TRUE;
}
@ -953,7 +953,7 @@ bool wxStaticBitmapPropertyInfo::SetProperty(wxString& name, wxProperty *propert
wxResourceManager::GetCurrentResourceManager()->PossiblyDeleteBitmapResource(oldResource);
}
message->SetBitmap(bitmap);
message->SetBitmap(* bitmap);
delete[] s;
return TRUE;
}
@ -1875,6 +1875,8 @@ bool wxScrollBarPropertyInfo::InstantiateResource(wxItemResource *resource)
wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
{
wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
/*
wxFont *labelFont = panelWindow->GetLabelFont();
wxFont *buttonFont = panelWindow->GetButtonFont();
@ -1884,7 +1886,9 @@ wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
else if (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" ||
name == "buttonFontUnderlined")
return GetFontProperty(name, buttonFont);
else if (name == "no3D")
*/
if (name == "no3D")
{
bool userColours;
if (panelWindow->GetWindowStyleFlag() & wxNO_3D)
@ -1946,6 +1950,7 @@ wxProperty *wxPanelPropertyInfo::GetProperty(wxString& name)
bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
wxPanel *panelWindow = (wxPanel *)m_propertyWindow;
/*
wxFont *labelFont = panelWindow->GetLabelFont();
wxFont *buttonFont = panelWindow->GetButtonFont();
@ -1953,17 +1958,19 @@ bool wxPanelPropertyInfo::SetProperty(wxString& name, wxProperty *property)
{
wxFont *newFont = SetFontProperty(name, property, labelFont);
if (newFont)
panelWindow->SetLabelFont(newFont);
panelWindow->SetLabelFont(* newFont);
return TRUE;
}
else if (buttonFont && (name == "buttonFontPoints" || name == "buttonFontFamily" || name == "buttonFontStyle" || name == "buttonFontWeight" || name == "buttonFontUnderlined" ))
{
wxFont *newFont = SetFontProperty(name, property, buttonFont);
if (newFont)
panelWindow->SetButtonFont(newFont);
panelWindow->SetButtonFont(* newFont);
return TRUE;
}
else if (name == "no3D")
*/
if (name == "no3D")
{
bool userColours = property->GetValue().BoolValue();
@ -2096,10 +2103,10 @@ void wxPanelPropertyInfo::GetPropertyNames(wxStringList& names)
bool wxPanelPropertyInfo::InstantiateResource(wxItemResource *resource)
{
wxPanel *panel = (wxPanel *)m_propertyWindow;
if (panel->GetFont() && panel->GetFont()->Ok())
resource->SetFont(wxTheFontList->FindOrCreateFont(panel->GetFont()->GetPointSize(),
panel->GetFont()->GetFamily(), panel->GetFont()->GetStyle(), panel->GetFont()->GetWeight(),
panel->GetFont()->GetUnderlined(), panel->GetFont()->GetFaceName()));
if (panel->GetFont().Ok())
resource->SetFont(* wxTheFontList->FindOrCreateFont(panel->GetFont().GetPointSize(),
panel->GetFont().GetFamily(), panel->GetFont().GetStyle(), panel->GetFont().GetWeight(),
panel->GetFont().GetUnderlined(), panel->GetFont().GetFaceName()));
resource->SetBackgroundColour(wxColour(panel->GetBackgroundColour()));
@ -2125,7 +2132,7 @@ void wxPanelPropertyInfo::ConvertDialogUnits(bool toDialogUnits)
}
resource->SetSize(pt.x, pt.y, sz.x, sz.y);
wxNode* node = m_propertyWindow->GetChildren()->First();
wxNode* node = m_propertyWindow->GetChildren().First();
while (node)
{
wxWindow* child = (wxWindow*) node->Data();

2
utils/wxprop/src/propform.cpp
View File

@ -158,7 +158,7 @@ bool wxPropertyFormView::AssociateNames(void)
if (!m_propertySheet || !m_propertyWindow)
return FALSE;
wxNode *node = m_propertyWindow->GetChildren()->First();
wxNode *node = m_propertyWindow->GetChildren().First();
while (node)
{
wxWindow *win = (wxWindow *)node->Data();

2
utils/wxprop/src/proplist.cpp
View File

@ -624,7 +624,7 @@ bool wxPropertyListView::CreateControls(void)
m_propertyScrollingList = new wxListBox(panel, wxID_PROP_SELECT,
wxPoint(-1, -1), wxSize(300, 300));
m_propertyScrollingList->SetFont(boringFont);
m_propertyScrollingList->SetFont(* boringFont);
c = new wxLayoutConstraints;