mirror of https://github.com/odrling/Aegisub
13299 lines
376 KiB
C++
13299 lines
376 KiB
C++
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
// Name: propgrid.cpp
|
||
|
// Purpose: wxPropertyGrid
|
||
|
// Author: Jaakko Salli
|
||
|
// Modified by:
|
||
|
// Created: Sep-25-2004
|
||
|
// RCS-ID: $Id:
|
||
|
// Copyright: (c) Jaakko Salli
|
||
|
// Licence: wxWindows license
|
||
|
/////////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
|
||
|
#pragma implementation "propgrid.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/defs.h"
|
||
|
#include "wx/object.h"
|
||
|
#include "wx/hash.h"
|
||
|
#include "wx/string.h"
|
||
|
#include "wx/log.h"
|
||
|
#include "wx/event.h"
|
||
|
#include "wx/window.h"
|
||
|
#include "wx/panel.h"
|
||
|
#include "wx/dc.h"
|
||
|
#include "wx/dcclient.h"
|
||
|
#include "wx/dcmemory.h"
|
||
|
#include "wx/button.h"
|
||
|
#include "wx/pen.h"
|
||
|
#include "wx/brush.h"
|
||
|
#include "wx/cursor.h"
|
||
|
#include "wx/dialog.h"
|
||
|
#include "wx/settings.h"
|
||
|
#include "wx/msgdlg.h"
|
||
|
#include "wx/choice.h"
|
||
|
#include "wx/stattext.h"
|
||
|
#include "wx/scrolwin.h"
|
||
|
#include "wx/dirdlg.h"
|
||
|
#include "wx/combobox.h"
|
||
|
#include "wx/layout.h"
|
||
|
#include "wx/sizer.h"
|
||
|
#include "wx/textdlg.h"
|
||
|
#include "wx/filedlg.h"
|
||
|
#include "wx/statusbr.h"
|
||
|
#include "wx/intl.h"
|
||
|
#include "wx/frame.h"
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#include "wx/timer.h"
|
||
|
#include "wx/dcbuffer.h"
|
||
|
|
||
|
|
||
|
// This define is necessary to prevent macro clearing
|
||
|
#define __wxPG_SOURCE_FILE__
|
||
|
|
||
|
#include <wx/propgrid/propgrid.h>
|
||
|
|
||
|
#include <wx/propgrid/propdev.h>
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
#include <wx/propgrid/advprops.h>
|
||
|
#include <wx/propgrid/extras.h>
|
||
|
#endif
|
||
|
|
||
|
#if wxPG_USE_RENDERER_NATIVE
|
||
|
#include <wx/renderer.h>
|
||
|
#endif
|
||
|
|
||
|
#include <wx/propgrid/odcombo.h>
|
||
|
|
||
|
#ifdef __WXMSW__
|
||
|
#include <wx/msw/private.h>
|
||
|
#endif
|
||
|
|
||
|
|
||
|
// Two pics for the expand / collapse buttons.
|
||
|
// Files are not supplied with this project (since it is
|
||
|
// recommended to use either custom or native rendering).
|
||
|
// If you want them, get wxTreeMultiCtrl by Jorgen Bodde,
|
||
|
// and copy xpm files from archive to wxPropertyGrid src directory
|
||
|
// (and also comment/undef wxPG_ICON_WIDTH in propGrid.h
|
||
|
// and set wxPG_USE_RENDERER_NATIVE to 0).
|
||
|
#ifndef wxPG_ICON_WIDTH
|
||
|
#if defined(__WXMAC__)
|
||
|
#include "mac_collapse.xpm"
|
||
|
#include "mac_expand.xpm"
|
||
|
#elif defined(__WXGTK__)
|
||
|
#include "linux_collapse.xpm"
|
||
|
#include "linux_expand.xpm"
|
||
|
#else
|
||
|
#include "default_collapse.xpm"
|
||
|
#include "default_expand.xpm"
|
||
|
#endif
|
||
|
#endif
|
||
|
|
||
|
|
||
|
//#define wxPG_TEXT_INDENT 4 // For the wxComboControl
|
||
|
#define wxPG_ALLOW_CLIPPING 1 // If 1, GetUpdateRegion() in OnPaint event handler is not ignored
|
||
|
#define wxPG_GUTTER_DIV 3 // gutter is max(iconwidth/gutter_div,gutter_min)
|
||
|
#define wxPG_GUTTER_MIN 3 // gutter before and after image of [+] or [-]
|
||
|
#define wxPG_YSPACING_MIN 1
|
||
|
#define wxPG_BUTTON_SIZEDEC 0
|
||
|
#define wxPG_DEFAULT_VSPACING 2 // This matches .NET propertygrid's value,
|
||
|
// but causes normal combobox to spill out under MSW
|
||
|
|
||
|
#define wxPG_OPTIMAL_WIDTH 200 // Arbitrary
|
||
|
|
||
|
#define wxPG_CAPRECTXMARGIN 2 // space between caption and selection rectangle,
|
||
|
#define wxPG_CAPRECTYMARGIN 1 // horizontally and vertically
|
||
|
|
||
|
#define PWC_CHILD_SUMMARY_LIMIT 16 // Maximum number of children summarized in a parent property's
|
||
|
// value field.
|
||
|
|
||
|
#define PWC_CHILD_SUMMARY_CHAR_LIMIT 64 // Character limit of summary field when not editing
|
||
|
|
||
|
|
||
|
#define wxPG_MIN_SCROLLBAR_WIDTH 10 // Smallest scrollbar width on any platform
|
||
|
// Must be larger than largest control border
|
||
|
// width * 2.
|
||
|
|
||
|
|
||
|
#define wxPG_DEFAULT_CURSOR wxNullCursor
|
||
|
#define RedrawAllVisible Refresh
|
||
|
|
||
|
|
||
|
//
|
||
|
// Here are some extra platform dependent defines.
|
||
|
//
|
||
|
|
||
|
#if defined(__WXMSW__)
|
||
|
// tested
|
||
|
|
||
|
#define wxPG_DEFAULT_SPLITTERX 110 // default splitter position
|
||
|
|
||
|
#define wxPG_CREATE_CONTROLS_HIDDEN 0 // 1 to create controls out of sight, hide them, and then move them into correct position
|
||
|
|
||
|
#define wxPG_NO_CHILD_EVT_MOTION 0 // 1 if splitter drag detect margin and control cannot overlap
|
||
|
|
||
|
#define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
|
||
|
|
||
|
#define wxPG_ALLOW_EMPTY_TOOLTIPS 1 // If 1, then setting empty tooltip actually hides it
|
||
|
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
|
||
|
|
||
|
#define wxPG_NAT_BUTTON_BORDER_ANY 1
|
||
|
#define wxPG_NAT_BUTTON_BORDER_X 1
|
||
|
#define wxPG_NAT_BUTTON_BORDER_Y 1
|
||
|
|
||
|
#define wxPG_TEXTCTRLYADJUST (m_spacingy+0)
|
||
|
|
||
|
#define wxPG_CHOICEXADJUST (-1) // Extra pixels next to wxChoice/ComboBox.
|
||
|
#define wxPG_CHOICEYADJUST 0 // Extra pixels above wxChoice/ComboBox.
|
||
|
|
||
|
#define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 0 // If 1 then controls are refreshed after selected was drawn.
|
||
|
|
||
|
#define wxPG_CHECKMARK_XADJ 1
|
||
|
#define wxPG_CHECKMARK_YADJ (-1)
|
||
|
#define wxPG_CHECKMARK_WADJ 0
|
||
|
#define wxPG_CHECKMARK_HADJ 0
|
||
|
#define wxPG_CHECKMARK_DEFLATE 0
|
||
|
|
||
|
#elif defined(__WXGTK__)
|
||
|
// tested
|
||
|
|
||
|
#define wxPG_DEFAULT_SPLITTERX 110
|
||
|
|
||
|
#define wxPG_CREATE_CONTROLS_HIDDEN 0 // 1 to create controls out of sight, hide them, and then move them into correct position
|
||
|
|
||
|
#define wxPG_NO_CHILD_EVT_MOTION 1 // 1 if splitter drag detect margin and control cannot overlap
|
||
|
|
||
|
#define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
|
||
|
|
||
|
#define wxPG_ALLOW_EMPTY_TOOLTIPS 0 // If 1, then setting empty tooltip actually hides it
|
||
|
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_X 3 // Unremovable border of native textctrl.
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_Y 3 // Unremovable border of native textctrl.
|
||
|
|
||
|
#define wxPG_NAT_BUTTON_BORDER_ANY 1
|
||
|
#define wxPG_NAT_BUTTON_BORDER_X 1
|
||
|
#define wxPG_NAT_BUTTON_BORDER_Y 1
|
||
|
|
||
|
#define wxPG_TEXTCTRLYADJUST 0
|
||
|
|
||
|
#define wxPG_CHOICEXADJUST 2 // Extra pixels next to wxChoice/ComboBox.
|
||
|
#define wxPG_CHOICEYADJUST 0
|
||
|
|
||
|
#define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 1 // If 1 then controls are refreshed after selected was drawn.
|
||
|
|
||
|
#define wxPG_CHECKMARK_XADJ 0
|
||
|
#define wxPG_CHECKMARK_YADJ 0
|
||
|
#define wxPG_CHECKMARK_WADJ (-1)
|
||
|
#define wxPG_CHECKMARK_HADJ (-1)
|
||
|
#define wxPG_CHECKMARK_DEFLATE 3
|
||
|
|
||
|
#elif defined(__WXMAC__)
|
||
|
// *not* tested
|
||
|
|
||
|
#define wxPG_DEFAULT_SPLITTERX 110
|
||
|
|
||
|
#define wxPG_CREATE_CONTROLS_HIDDEN 0 // 1 to create controls out of sight, hide them, and then move them into correct position
|
||
|
|
||
|
#define wxPG_NO_CHILD_EVT_MOTION 0 // 1 if splitter drag detect margin and control cannot overlap
|
||
|
|
||
|
#define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
|
||
|
|
||
|
#define wxPG_ALLOW_EMPTY_TOOLTIPS 1 // If 1, then setting empty tooltip actually hides it
|
||
|
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
|
||
|
|
||
|
#define wxPG_NAT_BUTTON_BORDER_ANY 0
|
||
|
#define wxPG_NAT_BUTTON_BORDER_X 0
|
||
|
#define wxPG_NAT_BUTTON_BORDER_Y 0
|
||
|
|
||
|
#define wxPG_TEXTCTRLYADJUST 3
|
||
|
|
||
|
#define wxPG_CHOICEXADJUST 0 // Extra pixels next to wxChoice/ComboBox.
|
||
|
#define wxPG_CHOICEYADJUST 0
|
||
|
|
||
|
#define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 0 // If 1 then controls are refreshed after selected was drawn.
|
||
|
|
||
|
#define wxPG_CHECKMARK_XADJ 0
|
||
|
#define wxPG_CHECKMARK_YADJ 0
|
||
|
#define wxPG_CHECKMARK_WADJ 0
|
||
|
#define wxPG_CHECKMARK_HADJ 0
|
||
|
#define wxPG_CHECKMARK_DEFLATE 0
|
||
|
|
||
|
#else
|
||
|
// defaults
|
||
|
|
||
|
#define wxPG_DEFAULT_SPLITTERX 110
|
||
|
|
||
|
#define wxPG_CREATE_CONTROLS_HIDDEN 0 // 1 to create controls out of sight, hide them, and then move them into correct position
|
||
|
|
||
|
#define wxPG_NO_CHILD_EVT_MOTION 1 // 1 if splitter drag detect margin and control cannot overlap
|
||
|
|
||
|
#define wxPG_CUSTOM_IMAGE_WIDTH 20 // for wxColourProperty etc.
|
||
|
|
||
|
#define wxPG_ALLOW_EMPTY_TOOLTIPS 0 // If 1, then setting empty tooltip actually hides it
|
||
|
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
|
||
|
|
||
|
#define wxPG_NAT_BUTTON_BORDER_ANY 0
|
||
|
#define wxPG_NAT_BUTTON_BORDER_X 0
|
||
|
#define wxPG_NAT_BUTTON_BORDER_Y 0
|
||
|
|
||
|
#define wxPG_TEXTCTRLYADJUST 0
|
||
|
|
||
|
#define wxPG_CHOICEXADJUST 0 // Extra pixels next to wxChoice/ComboBox.
|
||
|
#define wxPG_CHOICEYADJUST 0
|
||
|
|
||
|
#define wxPG_REFRESH_CONTROLS_AFTER_REPAINT 1 // If 1 then controls are refreshed after selected was drawn.
|
||
|
|
||
|
#define wxPG_CHECKMARK_XADJ 0
|
||
|
#define wxPG_CHECKMARK_YADJ 0
|
||
|
#define wxPG_CHECKMARK_WADJ 0
|
||
|
#define wxPG_CHECKMARK_HADJ 0
|
||
|
#define wxPG_CHECKMARK_DEFLATE 0
|
||
|
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#if wxPG_NO_CHILD_EVT_MOTION
|
||
|
|
||
|
#define wxPG_SPLITTERX_DETECTMARGIN1 3 // this much on left
|
||
|
#define wxPG_SPLITTERX_DETECTMARGIN2 2 // this much on right
|
||
|
#define wxPG_CONTROL_MARGIN 0 // space between splitter and control
|
||
|
|
||
|
#else
|
||
|
|
||
|
#define wxPG_SPLITTERX_DETECTMARGIN1 3 // this much on left
|
||
|
#define wxPG_SPLITTERX_DETECTMARGIN2 2 // this much on right
|
||
|
#define wxPG_CONTROL_MARGIN 0 // space between splitter and control
|
||
|
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#define wxCC_CUSTOM_IMAGE_MARGIN1 4 // before image
|
||
|
#define wxCC_CUSTOM_IMAGE_MARGIN2 5 // after image
|
||
|
|
||
|
|
||
|
#if (!wxPG_NAT_TEXTCTRL_BORDER_X && !wxPG_NAT_TEXTCTRL_BORDER_Y)
|
||
|
#define wxPG_ENABLE_CLIPPER_WINDOW 0
|
||
|
#else
|
||
|
#define wxPG_ENABLE_CLIPPER_WINDOW 1
|
||
|
#endif
|
||
|
|
||
|
|
||
|
//#define wxPG_NAT_CHOICE_BORDER_ANY 0
|
||
|
|
||
|
|
||
|
// for odcombo
|
||
|
#undef wxPG_CHOICEXADJUST
|
||
|
#define wxPG_CHOICEXADJUST 0
|
||
|
#undef wxPG_CHOICEYADJUST
|
||
|
#define wxPG_CHOICEYADJUST 0
|
||
|
|
||
|
#define wxPG_DRAG_MARGIN 30
|
||
|
|
||
|
#define wxPG_CUSTOM_IMAGE_SPACINGY 1 // space between vertical sides of a custom image
|
||
|
|
||
|
// Use this macro to generate standard custom image height from
|
||
|
#define wxPG_STD_CUST_IMAGE_HEIGHT(LINEHEIGHT) (LINEHEIGHT-3)
|
||
|
|
||
|
// How many pixels between textctrl and button
|
||
|
#ifdef __WXMAC__
|
||
|
#define wxPG_TEXTCTRL_AND_BUTTON_SPACING 8
|
||
|
#else
|
||
|
#define wxPG_TEXTCTRL_AND_BUTTON_SPACING 2
|
||
|
#endif
|
||
|
|
||
|
#define wxPG_HIDER_BUTTON_HEIGHT 25
|
||
|
|
||
|
// m_expanded of wxPGPropertyWithChildren is set to this code if children should
|
||
|
// not be deleted in destructor.
|
||
|
#define wxPG_EXP_OF_COPYARRAY 127
|
||
|
|
||
|
#define wxPG_PIXELS_PER_UNIT m_lineHeight
|
||
|
|
||
|
#ifdef wxPG_ICON_WIDTH
|
||
|
#define m_iconHeight m_iconWidth
|
||
|
#endif
|
||
|
|
||
|
#define wxPG_TOOLTIP_DELAY 1000
|
||
|
|
||
|
// Colour for the empty but visible space below last property.
|
||
|
#define wxPG_SLACK_BACKROUND m_colPropBack
|
||
|
|
||
|
// Milliseconds to wait for two mouse-ups after focus inorder
|
||
|
// to trigger a double-click.
|
||
|
#define DOUBLE_CLICK_CONVERSION_TRESHOLD 500
|
||
|
|
||
|
|
||
|
//
|
||
|
// Parenting types
|
||
|
enum
|
||
|
{
|
||
|
PT_CUSTOMPROPERTY = -2,
|
||
|
PT_FIXEDCHILDREN = -1,
|
||
|
PT_NONE = 0,
|
||
|
PT_CAPTION = 1,
|
||
|
PT_ROOT = 2
|
||
|
};
|
||
|
|
||
|
|
||
|
// Helper to decide which way is better (ie. first macro clears
|
||
|
// "unspecified" state of siblings of child properties as well, while the latter is
|
||
|
// more precise).
|
||
|
//#define CLEAR_PROPERTY_UNSPECIFIED_FLAG(p) wxPropertyGridState::ClearPropertyAndChildrenFlags(p,wxPG_PROP_UNSPECIFIED)
|
||
|
#define CLEAR_PROPERTY_UNSPECIFIED_FLAG(p) p->ClearFlag(wxPG_PROP_UNSPECIFIED)
|
||
|
|
||
|
#define __INTENSE_DEBUGGING__ 0
|
||
|
#define __PAINT_DEBUGGING__ 0
|
||
|
#define __MOUSE_DEBUGGING__ 0
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxUSE_INTL
|
||
|
void wxPropertyGrid::AutoGetTranslation ( bool enable )
|
||
|
{
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
wxPGGlobalVars->m_autoGetTranslation = enable;
|
||
|
}
|
||
|
#else
|
||
|
void wxPropertyGrid::AutoGetTranslation ( bool ) { }
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// This was needed to make quicker progress towards wxPropertyGridState
|
||
|
#define FROM_STATE(X) m_pState->X
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if !wxCHECK_VERSION(2, 7, 1)
|
||
|
|
||
|
#if defined(__WXMSW__)
|
||
|
|
||
|
#ifndef WS_EX_COMPOSITED
|
||
|
#define WS_EX_COMPOSITED 0x02000000L
|
||
|
#endif
|
||
|
static bool wxPGIsWindowBuffered( const wxWindow* wnd )
|
||
|
{
|
||
|
while ( wnd )
|
||
|
{
|
||
|
if ( GetWindowLong((HWND)wnd->GetHWND(), GWL_EXSTYLE) & WS_EX_COMPOSITED )
|
||
|
return true;
|
||
|
if ( wnd->IsTopLevel() )
|
||
|
break;
|
||
|
wnd = wnd->GetParent();
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
#elif defined(__WXGTK20__)
|
||
|
|
||
|
#include <gtk/gtk.h>
|
||
|
static bool wxPGIsWindowBuffered( const wxWindow* wnd )
|
||
|
{
|
||
|
return GTK_WIDGET_DOUBLE_BUFFERED(wnd->GetHandle());
|
||
|
}
|
||
|
|
||
|
#elif defined(__WXMAC_OSX__) || defined(__WXCOCOA__) || defined(__WXDFB__)
|
||
|
|
||
|
static bool wxPGIsWindowBuffered( const wxWindow* WXUNUSED(wnd) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
#else
|
||
|
|
||
|
static bool wxPGIsWindowBuffered( const wxWindow* WXUNUSED(wnd) )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#else
|
||
|
|
||
|
static bool wxPGIsWindowBuffered( const wxWindow* wnd )
|
||
|
{
|
||
|
return wnd->IsDoubleBuffered();
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// DeviceContext Init Macros.
|
||
|
|
||
|
#define wxPG_CLIENT_DC_INIT() \
|
||
|
wxClientDC dc(this); \
|
||
|
PrepareDC(dc);
|
||
|
|
||
|
#define wxPG_CLIENT_DC_INIT_R(RETVAL) \
|
||
|
wxClientDC dc(this); \
|
||
|
PrepareDC(dc);
|
||
|
|
||
|
#define wxPG_PAINT_DC_INIT() \
|
||
|
wxPaintDC dc(this); \
|
||
|
PrepareDC(dc);
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// For wxMSW cursor consistency, we must do mouse capturing even
|
||
|
// when using custom controls.
|
||
|
|
||
|
#define BEGIN_MOUSE_CAPTURE \
|
||
|
if ( !(m_iFlags & wxPG_FL_MOUSE_CAPTURED) ) \
|
||
|
{ \
|
||
|
CaptureMouse(); \
|
||
|
m_iFlags |= wxPG_FL_MOUSE_CAPTURED; \
|
||
|
}
|
||
|
|
||
|
#define END_MOUSE_CAPTURE \
|
||
|
if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED ) \
|
||
|
{ \
|
||
|
ReleaseMouse(); \
|
||
|
m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED); \
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// NOTES
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
//
|
||
|
// -----------------------------------------------------------------------
|
||
|
// TODO
|
||
|
// -----------------------------------------------------------------------
|
||
|
//
|
||
|
|
||
|
//
|
||
|
// For Next Release:
|
||
|
// * Fix NULL(?) focus after odcombo closed.
|
||
|
//
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
const wxChar *wxPropertyGridNameStr = wxT("wxPropertyGrid");
|
||
|
|
||
|
const wxChar *wxPGTypeName_long = wxT("long");
|
||
|
const wxChar *wxPGTypeName_bool = wxT("bool");
|
||
|
const wxChar *wxPGTypeName_double = wxT("double");
|
||
|
const wxChar *wxPGTypeName_wxString = wxT("string");
|
||
|
const wxChar *wxPGTypeName_void = wxT("void*");
|
||
|
const wxChar *wxPGTypeName_wxArrayString = wxT("arrstring");
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
const wxChar *wxPGTypeName_PyObject = wxT("PyObject");
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
static void wxPGDrawFocusRect( wxDC& dc, const wxRect& rect )
|
||
|
{
|
||
|
#if defined(__WXMSW__) && !defined(__WXWINCE__)
|
||
|
/*
|
||
|
RECT mswRect;
|
||
|
mswRect.left = rect.x;
|
||
|
mswRect.top = rect.y;
|
||
|
mswRect.right = rect.x + rect.width;
|
||
|
mswRect.bottom = rect.y + rect.height;
|
||
|
HDC hdc = (HDC) dc.GetHDC();
|
||
|
SetMapMode(hdc,MM_TEXT); // Just in case...
|
||
|
DrawFocusRect(hdc,&mswRect);
|
||
|
*/
|
||
|
// FIXME: Use DrawFocusRect code above (currently it draws solid line
|
||
|
// for caption focus but works ok for other stuff).
|
||
|
// Also, it seems that this code may not work in future wx versions.
|
||
|
dc.SetLogicalFunction(wxINVERT);
|
||
|
|
||
|
wxPen pen(*wxBLACK,1,wxDOT);
|
||
|
pen.SetCap(wxCAP_BUTT);
|
||
|
dc.SetPen(pen);
|
||
|
dc.SetBrush(*wxTRANSPARENT_BRUSH);
|
||
|
|
||
|
dc.DrawRectangle(rect);
|
||
|
|
||
|
dc.SetLogicalFunction(wxCOPY);
|
||
|
#else
|
||
|
dc.SetLogicalFunction(wxINVERT);
|
||
|
|
||
|
dc.SetPen(wxPen(*wxBLACK,1,wxDOT));
|
||
|
dc.SetBrush(*wxTRANSPARENT_BRUSH);
|
||
|
|
||
|
dc.DrawRectangle(rect);
|
||
|
|
||
|
dc.SetLogicalFunction(wxCOPY);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Choice related methods from various classes
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::AddPropertyChoice( wxPGId id,
|
||
|
const wxString& label,
|
||
|
int value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
p->InsertChoice(label,-1,value);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPropertyContainerMethods::InsertPropertyChoice( wxPGId id,
|
||
|
const wxString& label,
|
||
|
int index,
|
||
|
int value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
p->InsertChoice(label,index,value);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPropertyContainerMethods::DeletePropertyChoice( wxPGId id,
|
||
|
int index )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
p->DeleteChoice(index);
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Statics in one class for easy destruction.
|
||
|
// NB: We prefer to use wxModule, as it offers more consistent behaviour
|
||
|
// across platforms. However, for those rare problem situations, we
|
||
|
// also need to offer option to use simpler approach.
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#ifndef wxPG_USE_WXMODULE
|
||
|
#define wxPG_USE_WXMODULE 1
|
||
|
#endif
|
||
|
|
||
|
#if wxPG_USE_WXMODULE
|
||
|
|
||
|
#include <wx/module.h>
|
||
|
|
||
|
class wxPGGlobalVarsClassManager : public wxModule
|
||
|
{
|
||
|
DECLARE_DYNAMIC_CLASS(wxPGGlobalVarsClassManager)
|
||
|
public:
|
||
|
wxPGGlobalVarsClassManager() {}
|
||
|
virtual bool OnInit() { wxPGGlobalVars = new wxPGGlobalVarsClass(); return true; }
|
||
|
virtual void OnExit() { delete wxPGGlobalVars; wxPGGlobalVars = NULL; }
|
||
|
};
|
||
|
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGGlobalVarsClassManager, wxModule)
|
||
|
|
||
|
#else // !wxPG_USE_WXMODULE
|
||
|
|
||
|
class wxPGGlobalVarsClassManager
|
||
|
{
|
||
|
public:
|
||
|
wxPGGlobalVarsClassManager() {}
|
||
|
~wxPGGlobalVarsClassManager() { delete wxPGGlobalVars; }
|
||
|
};
|
||
|
|
||
|
static wxPGGlobalVarsClassManager gs_pgGlobalVarsClassManager;
|
||
|
|
||
|
#endif
|
||
|
|
||
|
|
||
|
wxPGGlobalVarsClass* wxPGGlobalVars = (wxPGGlobalVarsClass*) NULL;
|
||
|
|
||
|
|
||
|
wxPGGlobalVarsClass::wxPGGlobalVarsClass()
|
||
|
{
|
||
|
m_boolChoices[0] = _("False");
|
||
|
m_boolChoices[1] = _("True");
|
||
|
m_boolChoices[2] = _("Unspecified");
|
||
|
m_numBoolChoices = 2;
|
||
|
|
||
|
m_fontFamilyChoices = (wxPGChoices*) NULL;
|
||
|
|
||
|
m_autoGetTranslation = false;
|
||
|
|
||
|
m_offline = 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGGlobalVarsClass::~wxPGGlobalVarsClass()
|
||
|
{
|
||
|
size_t i;
|
||
|
|
||
|
// This will always have one ref
|
||
|
delete m_fontFamilyChoices;
|
||
|
|
||
|
#if wxUSE_VALIDATORS
|
||
|
for ( i=0; i<m_arrValidators.GetCount(); i++ )
|
||
|
delete ((wxValidator*)m_arrValidators[i]);
|
||
|
#endif
|
||
|
|
||
|
//
|
||
|
// Destroy value type class instances.
|
||
|
wxPGHashMapS2P::iterator vt_it;
|
||
|
|
||
|
for( vt_it = m_dictValueType.begin(); vt_it != m_dictValueType.end(); ++vt_it )
|
||
|
{
|
||
|
wxPGValueType* pcls = (wxPGValueType*) vt_it->second;
|
||
|
wxASSERT( pcls );
|
||
|
delete pcls;
|
||
|
}
|
||
|
|
||
|
// Destroy editor class instances.
|
||
|
// iterate over all the elements in the class
|
||
|
for( vt_it = m_mapEditorClasses.begin(); vt_it != m_mapEditorClasses.end(); ++vt_it )
|
||
|
{
|
||
|
delete ((wxPGEditor*)vt_it->second);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGProperty
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGPropertyClassInfo wxBasePropertyClassInfo = {wxT("wxBaseProperty"),
|
||
|
(const wxPGPropertyClassInfo*) NULL,
|
||
|
(wxPGPropertyConstructor) NULL};
|
||
|
|
||
|
void wxPGProperty::Init()
|
||
|
{
|
||
|
#ifdef __WXPYTHON__
|
||
|
m_scriptObject = NULL;
|
||
|
#endif
|
||
|
|
||
|
m_y = -3;
|
||
|
m_arrIndex = 0xFFFF;
|
||
|
m_parent = (wxPGPropertyWithChildren*) NULL;
|
||
|
|
||
|
#if wxPG_USE_CLIENT_DATA
|
||
|
m_clientData = NULL;
|
||
|
#endif
|
||
|
|
||
|
m_dataExt = (wxPGPropertyDataExt*) NULL;
|
||
|
|
||
|
m_maxLen = 0; // infinite maximum length
|
||
|
|
||
|
m_flags = 0;
|
||
|
|
||
|
m_depth = 1;
|
||
|
m_parentingType = 0;
|
||
|
m_bgColIndex = 0;
|
||
|
m_fgColIndex = 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::Init( const wxString& label, const wxString& name )
|
||
|
{
|
||
|
m_label = label;
|
||
|
#ifndef __WXPYTHON__
|
||
|
if ( &name != ((wxString*)NULL) )
|
||
|
#else
|
||
|
if ( (&name != ((wxString*)NULL)) && name != wxT("_LABEL_AS_NAME") )
|
||
|
#endif
|
||
|
DoSetName( name );
|
||
|
else
|
||
|
DoSetName( label );
|
||
|
|
||
|
Init();
|
||
|
}
|
||
|
|
||
|
wxPGProperty::wxPGProperty()
|
||
|
#if wxPG_INCLUDE_WXOBJECT
|
||
|
: wxObject()
|
||
|
#endif
|
||
|
{
|
||
|
Init();
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGProperty::wxPGProperty( const wxString& label, const wxString& name )
|
||
|
#if wxPG_INCLUDE_WXOBJECT
|
||
|
: wxObject()
|
||
|
#endif
|
||
|
{
|
||
|
Init( label, name );
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGProperty::~wxPGProperty()
|
||
|
{
|
||
|
#ifdef __WXPYTHON__
|
||
|
#if wxPG_USE_CLIENT_DATA
|
||
|
if ( m_clientData )
|
||
|
Py_DECREF( m_clientData );
|
||
|
#endif
|
||
|
#endif
|
||
|
|
||
|
delete m_dataExt;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::IsSomeParent( wxPGProperty* candidate ) const
|
||
|
{
|
||
|
wxPGPropertyWithChildren* parent = m_parent;
|
||
|
do
|
||
|
{
|
||
|
if ( parent == (wxPGPropertyWithChildren*)candidate )
|
||
|
return true;
|
||
|
parent = parent->m_parent;
|
||
|
} while ( parent );
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPropertyGridState* wxPGProperty::GetParentState() const
|
||
|
{
|
||
|
wxASSERT( m_parent );
|
||
|
return m_parent->GetParentState();
|
||
|
}
|
||
|
|
||
|
|
||
|
size_t wxPGProperty::GetChildCount() const
|
||
|
{
|
||
|
int cc = GetParentingType();
|
||
|
if ( cc == 0 ) return 0;
|
||
|
return ((wxPGPropertyWithChildren*)this)->GetCount();
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::ShowError( const wxString& msg )
|
||
|
{
|
||
|
if ( !msg.length() )
|
||
|
return;
|
||
|
|
||
|
#if wxUSE_STATUSBAR
|
||
|
if ( !wxPGGlobalVars->m_offline )
|
||
|
{
|
||
|
wxPropertyGrid* pg = GetParentState()->m_pPropGrid;
|
||
|
wxASSERT(pg);
|
||
|
wxWindow* topWnd = ::wxGetTopLevelParent(pg);
|
||
|
if ( topWnd )
|
||
|
{
|
||
|
wxFrame* pFrame = wxDynamicCast(topWnd,wxFrame);
|
||
|
if ( pFrame )
|
||
|
{
|
||
|
wxStatusBar* pStatusBar = pFrame->GetStatusBar();
|
||
|
if ( pStatusBar )
|
||
|
{
|
||
|
pStatusBar->SetStatusText(msg);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
::wxLogError(msg);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPropertyGrid* wxPGProperty::GetGrid() const
|
||
|
{
|
||
|
return GetParentState()->GetGrid();
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::UpdateControl( wxWindow* primary )
|
||
|
{
|
||
|
if ( primary )
|
||
|
GetEditorClass()->UpdateControl(this,primary);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::DoSetValue( wxPGVariant )
|
||
|
{
|
||
|
// Actually, this should never get called
|
||
|
wxFAIL_MSG( wxT("must be overridden") );
|
||
|
}
|
||
|
|
||
|
|
||
|
// wxPGRootPropertyClass, at least, should make use of this.
|
||
|
wxPGVariant wxPGProperty::DoGetValue() const
|
||
|
{
|
||
|
return wxPGVariant((long)0);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxString wxPGProperty::GetValueAsString( int ) const
|
||
|
{
|
||
|
wxFAIL_MSG( wxT("must be overridden") );
|
||
|
return m_name;
|
||
|
}
|
||
|
|
||
|
wxVariant wxPGProperty::GetValueAsVariant() const
|
||
|
{
|
||
|
// Return NULL variant for unspecified value
|
||
|
//if ( HasFlag(wxPG_PROP_UNSPECIFIED) )
|
||
|
// return wxVariant();
|
||
|
|
||
|
wxPGVariant value = DoGetValue();
|
||
|
const wxPGValueType* typeClass = GetValueTypePtr();
|
||
|
wxASSERT_MSG( typeClass, wxT("Did you forgot to use wxPG_INIT_REQUIRED_TYPE(T) in constructor?") );
|
||
|
return typeClass->GenerateVariant(value,m_name);
|
||
|
}
|
||
|
|
||
|
bool wxPGProperty::SetValueFromString( const wxString&, int )
|
||
|
{
|
||
|
wxFAIL_MSG( wxT("must be overridden") );
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::SetValueFromInt( long, int )
|
||
|
{
|
||
|
wxFAIL_MSG ( wxT("must be overridden") );
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxSize wxPGProperty::GetImageSize() const
|
||
|
{
|
||
|
if ( m_dataExt && m_dataExt->m_valueBitmap )
|
||
|
return wxSize(m_dataExt->m_valueBitmap->GetWidth(),-1);
|
||
|
|
||
|
return wxSize(0,0);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::OnCustomPaint( wxDC& dc,
|
||
|
const wxRect& rect,
|
||
|
wxPGPaintData& )
|
||
|
{
|
||
|
wxCHECK_RET( m_dataExt, wxT("m_dataExt is mandatory") );
|
||
|
|
||
|
wxBitmap* bmp = m_dataExt->m_valueBitmap;
|
||
|
|
||
|
wxCHECK_RET( bmp && bmp->Ok(), wxT("invalid bitmap") );
|
||
|
|
||
|
wxCHECK_RET( rect.x >= 0, wxT("unexpected measure call") );
|
||
|
|
||
|
dc.DrawBitmap(*bmp,rect.x,rect.y);
|
||
|
}
|
||
|
|
||
|
const wxPGEditor* wxPGProperty::DoGetEditorClass() const
|
||
|
{
|
||
|
return wxPG_EDITOR(TextCtrl);
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
wxString wxPGProperty::GetEditor() const
|
||
|
{
|
||
|
return wxEmptyString;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
wxString wxPGProperty::GetType() const
|
||
|
{
|
||
|
return wxString();
|
||
|
}
|
||
|
|
||
|
const wxPGValueType* wxPGProperty::GetValueType() const
|
||
|
{
|
||
|
wxString s = GetType();
|
||
|
|
||
|
const wxPGValueType* p = wxPropertyContainerMethods::GetValueType(s);
|
||
|
|
||
|
wxCHECK_MSG( p, wxPG_VALUETYPE(none),
|
||
|
wxT("GetType must return string that identifies a valid type") );
|
||
|
|
||
|
return p;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#if wxPG_VALUETYPE_IS_STRING
|
||
|
const wxPGValueType* wxPGProperty::GetValueTypePtr() const
|
||
|
{
|
||
|
return wxPropertyContainerMethods::GetValueTypeByName(GetValueType());
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
|
||
|
// Default extra property event handling - that is, none at all.
|
||
|
bool wxPGProperty::OnEvent( wxPropertyGrid*, wxWindow*, wxEvent& )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::SetChoiceSelection( int newValue, const wxPGChoiceInfo& choiceInfo )
|
||
|
{
|
||
|
// Changes value of a property with choices, but only
|
||
|
// works if the value type is long or string.
|
||
|
const wxPGValueType* vt = GetValueTypePtr();
|
||
|
|
||
|
wxCHECK_RET( choiceInfo.m_choices, wxT("invalid choiceinfo") );
|
||
|
|
||
|
if ( vt == wxPG_VALUETYPE_PTR(long) )
|
||
|
{
|
||
|
DoSetValue( (long) newValue );
|
||
|
}
|
||
|
else if ( vt == wxPG_VALUETYPE_PTR(wxString) )
|
||
|
{
|
||
|
DoSetValue( choiceInfo.m_choices->GetLabel(newValue) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
int wxPGProperty::InsertChoice( const wxString& label, int index, int value )
|
||
|
{
|
||
|
wxPropertyGrid* pg = GetGrid();
|
||
|
|
||
|
wxPGChoiceInfo ci;
|
||
|
ci.m_choices = (wxPGChoices*) NULL;
|
||
|
int sel = GetChoiceInfo(&ci);
|
||
|
|
||
|
if ( ci.m_choices )
|
||
|
{
|
||
|
int newSel = sel;
|
||
|
|
||
|
if ( index < 0 )
|
||
|
index = ci.m_choices->GetCount();
|
||
|
|
||
|
if ( index <= sel )
|
||
|
newSel++;
|
||
|
|
||
|
ci.m_choices->Insert(label, index, value);
|
||
|
|
||
|
if ( sel != newSel )
|
||
|
SetChoiceSelection(newSel, ci);
|
||
|
|
||
|
if ( this == wxPGIdToPtr(pg->GetSelection()) )
|
||
|
GetEditorClass()->InsertItem(pg->GetPrimaryEditor(),label,index);
|
||
|
|
||
|
return index;
|
||
|
}
|
||
|
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::DeleteChoice( int index )
|
||
|
{
|
||
|
wxPropertyGrid* pg = GetGrid();
|
||
|
|
||
|
wxPGChoiceInfo ci;
|
||
|
ci.m_choices = (wxPGChoices*) NULL;
|
||
|
int sel = GetChoiceInfo(&ci);
|
||
|
|
||
|
if ( ci.m_choices )
|
||
|
{
|
||
|
int newSel = sel;
|
||
|
|
||
|
// Adjust current value
|
||
|
if ( sel == index )
|
||
|
{
|
||
|
SetFlag( wxPG_PROP_UNSPECIFIED );
|
||
|
newSel = 0;
|
||
|
}
|
||
|
else if ( index < sel )
|
||
|
{
|
||
|
newSel--;
|
||
|
}
|
||
|
|
||
|
ci.m_choices->RemoveAt(index);
|
||
|
|
||
|
if ( sel != newSel )
|
||
|
SetChoiceSelection(newSel, ci);
|
||
|
|
||
|
if ( this == wxPGIdToPtr(pg->GetSelection()) )
|
||
|
GetEditorClass()->DeleteItem(pg->GetPrimaryEditor(), index);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
int wxPGProperty::GetChoiceInfo( wxPGChoiceInfo* )
|
||
|
{
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::SetAttribute( int, wxVariant& )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
#if wxUSE_VALIDATORS
|
||
|
wxValidator* wxPGProperty::DoGetValidator() const
|
||
|
{
|
||
|
return (wxValidator*) NULL;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
|
||
|
bool wxPGProperty::SetChoices( wxPGChoices& choices )
|
||
|
{
|
||
|
wxPGChoiceInfo ci;
|
||
|
ci.m_choices = (wxPGChoices*) NULL;
|
||
|
|
||
|
// Unref existing
|
||
|
GetChoiceInfo(&ci);
|
||
|
if ( ci.m_choices )
|
||
|
{
|
||
|
ci.m_choices->Assign(choices);
|
||
|
|
||
|
// This may be needed to trigger some initialization
|
||
|
// (but don't do it if property is somewhat uninitialized)
|
||
|
if ( m_parent )
|
||
|
DoSetValue(GetValueTypePtr()->GetDefaultValue());
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
const wxPGEditor* wxPGProperty::GetEditorClass() const
|
||
|
{
|
||
|
const wxPGEditor* editor;
|
||
|
|
||
|
if ( !m_dataExt || !m_dataExt->m_customEditor )
|
||
|
{
|
||
|
#ifdef __WXPYTHON__
|
||
|
wxString editorName = GetEditor();
|
||
|
if ( editorName.length() )
|
||
|
editor = wxPropertyContainerMethods::GetEditorByName(editorName);
|
||
|
else
|
||
|
#endif
|
||
|
editor = DoGetEditorClass();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
editor = m_dataExt->m_customEditor;
|
||
|
}
|
||
|
|
||
|
return editor;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::IsKindOf( wxPGPropertyClassInfo& info )
|
||
|
{
|
||
|
const wxPGPropertyClassInfo* ownInfo = GetClassInfo();
|
||
|
|
||
|
do
|
||
|
{
|
||
|
if ( ownInfo == &info )
|
||
|
return true;
|
||
|
|
||
|
ownInfo = ownInfo->m_baseInfo;
|
||
|
} while ( ownInfo );
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Privatizes set of choices
|
||
|
void wxPGProperty::SetChoicesExclusive()
|
||
|
{
|
||
|
wxPGChoiceInfo ci;
|
||
|
ci.m_choices = (wxPGChoices*) NULL;
|
||
|
|
||
|
GetChoiceInfo(&ci);
|
||
|
if ( ci.m_choices )
|
||
|
ci.m_choices->SetExclusive();
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::PrepareValueForDialogEditing( wxPropertyGrid* propGrid )
|
||
|
{
|
||
|
wxWindow* primary = propGrid->GetEditorControl();
|
||
|
if ( primary && propGrid->IsEditorsValueModified() )
|
||
|
{
|
||
|
GetEditorClass()->CopyValueFromControl( this, primary );
|
||
|
return true;
|
||
|
}
|
||
|
else if ( m_flags & wxPG_PROP_UNSPECIFIED )
|
||
|
{
|
||
|
// Set default value in case it was unspecified
|
||
|
DoSetValue(GetValueTypePtr()->GetDefaultValue());
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::RecreateEditor()
|
||
|
{
|
||
|
wxPropertyGrid* pg = GetGrid();
|
||
|
wxASSERT(pg);
|
||
|
|
||
|
wxPGProperty* selected = pg->GetSelection();
|
||
|
if ( this == selected )
|
||
|
{
|
||
|
pg->DoSelectProperty(this, wxPG_SEL_FORCE);
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::EnsureDataExt()
|
||
|
{
|
||
|
if ( !m_dataExt )
|
||
|
{
|
||
|
m_dataExt = new wxPGPropertyDataExt();
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGProperty::SetValueImage( wxBitmap& bmp )
|
||
|
{
|
||
|
EnsureDataExt();
|
||
|
|
||
|
delete m_dataExt->m_valueBitmap;
|
||
|
|
||
|
if ( &bmp && bmp.Ok() )
|
||
|
{
|
||
|
// Resize the image
|
||
|
wxSize maxSz = GetGrid()->GetImageSize();
|
||
|
wxSize imSz(bmp.GetWidth(),bmp.GetHeight());
|
||
|
|
||
|
if ( imSz.x != maxSz.x || imSz.y != maxSz.y )
|
||
|
{
|
||
|
// Create a memory DC
|
||
|
wxBitmap* bmpNew = new wxBitmap(maxSz.x,maxSz.y,bmp.GetDepth());
|
||
|
|
||
|
wxMemoryDC dc;
|
||
|
dc.SelectObject(*bmpNew);
|
||
|
|
||
|
// Scale
|
||
|
// FIXME: This is ugly - use image or wait for scaling patch.
|
||
|
double scaleX = (double)maxSz.x / (double)imSz.x;
|
||
|
double scaleY = (double)maxSz.y / (double)imSz.y;
|
||
|
|
||
|
dc.SetUserScale(scaleX,scaleY);
|
||
|
|
||
|
dc.DrawBitmap( bmp, 0, 0 );
|
||
|
|
||
|
m_dataExt->m_valueBitmap = bmpNew;
|
||
|
}
|
||
|
else
|
||
|
m_dataExt->m_valueBitmap = new wxBitmap(bmp);
|
||
|
|
||
|
m_flags |= wxPG_PROP_CUSTOMIMAGE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_dataExt->m_valueBitmap = (wxBitmap*) NULL;
|
||
|
m_flags &= ~(wxPG_PROP_CUSTOMIMAGE);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGProperty* wxPGProperty::GetMainParent() const
|
||
|
{
|
||
|
const wxPGProperty* curChild = this;
|
||
|
const wxPGPropertyWithChildren* curParent = m_parent;
|
||
|
|
||
|
while ( curParent->m_parentingType < 0 )
|
||
|
{
|
||
|
curChild = curParent;
|
||
|
curParent = curParent->m_parent;
|
||
|
}
|
||
|
|
||
|
return (wxPGProperty*) curChild;
|
||
|
}
|
||
|
|
||
|
|
||
|
const wxPGProperty* wxPGProperty::GetLastVisibleSubItem() const
|
||
|
{
|
||
|
//
|
||
|
// Returns last visible sub-item, recursively.
|
||
|
|
||
|
if ( GetParentingType() == PT_NONE )
|
||
|
return this;
|
||
|
|
||
|
const wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*) this;
|
||
|
|
||
|
unsigned int count = pwc->GetCount();
|
||
|
|
||
|
if ( !pwc->IsExpanded() || !count )
|
||
|
return this;
|
||
|
|
||
|
return pwc->Last()->GetLastVisibleSubItem();
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGProperty::UsesAutoUnspecified() const
|
||
|
{
|
||
|
if ( GetGrid()->GetExtraStyle() & wxPG_EX_AUTO_UNSPECIFIED_VALUES )
|
||
|
return true;
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGPropertyWithChildren
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
wxPGPropertyClassInfo wxBaseParentPropertyClassInfo = {wxT("wxBaseParentProperty"),
|
||
|
&wxBasePropertyClassInfo,
|
||
|
(wxPGPropertyConstructor) NULL};
|
||
|
|
||
|
|
||
|
wxPGPropertyWithChildren::wxPGPropertyWithChildren()
|
||
|
: wxPGProperty()
|
||
|
{
|
||
|
m_expanded = 1;
|
||
|
m_y = -2;
|
||
|
m_parentingType = -1;
|
||
|
}
|
||
|
|
||
|
wxPGPropertyWithChildren::wxPGPropertyWithChildren( const wxString &label, const wxString& name )
|
||
|
: wxPGProperty(label,name)
|
||
|
{
|
||
|
m_expanded = 1;
|
||
|
m_y = -2;
|
||
|
m_parentingType = -1;
|
||
|
m_parentState = (wxPropertyGridState*) NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGPropertyWithChildren::~wxPGPropertyWithChildren()
|
||
|
{
|
||
|
Empty(); // this deletes items
|
||
|
}
|
||
|
|
||
|
|
||
|
// This is used by Insert etc.
|
||
|
void wxPGPropertyWithChildren::AddChild2( wxPGProperty* prop, int index, bool correct_mode )
|
||
|
{
|
||
|
if ( index < 0 || (size_t)index >= m_children.GetCount() )
|
||
|
{
|
||
|
if ( correct_mode ) prop->m_arrIndex = m_children.GetCount();
|
||
|
m_children.Add( (void*)prop );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_children.Insert( (void*)prop, index );
|
||
|
if ( correct_mode ) FixIndexesOfChildren( index );
|
||
|
}
|
||
|
|
||
|
prop->m_parent = this;
|
||
|
}
|
||
|
|
||
|
// This is used by properties that have fixed sub-properties
|
||
|
void wxPGPropertyWithChildren::AddChild( wxPGProperty* prop )
|
||
|
{
|
||
|
prop->m_arrIndex = m_children.GetCount();
|
||
|
m_children.Add( (void*)prop );
|
||
|
|
||
|
int custImgHeight = prop->GetImageSize().y;
|
||
|
if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
|
||
|
prop->m_flags |= wxPG_PROP_CUSTOMIMAGE;
|
||
|
|
||
|
prop->m_parent = this;
|
||
|
|
||
|
prop->m_y = -1; // Collapsed
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGPropertyWithChildren::FixIndexesOfChildren( size_t starthere )
|
||
|
{
|
||
|
size_t i;
|
||
|
for ( i=starthere;i<GetCount();i++)
|
||
|
Item(i)->m_arrIndex = i;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Returns (direct) child property with given name (or NULL if not found)
|
||
|
wxPGProperty* wxPGPropertyWithChildren::GetPropertyByName( const wxString& name ) const
|
||
|
{
|
||
|
size_t i;
|
||
|
|
||
|
for ( i=0; i<GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = Item(i);
|
||
|
if ( p->m_name == name )
|
||
|
return p;
|
||
|
}
|
||
|
|
||
|
// Does it have point, then?
|
||
|
int pos = name.Find(wxT('.'));
|
||
|
if ( pos <= 0 )
|
||
|
return (wxPGProperty*) NULL;
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc =
|
||
|
(wxPGPropertyWithChildren*) GetPropertyByName(name.substr(0,pos));
|
||
|
|
||
|
if ( !pwc || !pwc->GetParentingType() )
|
||
|
return (wxPGProperty*) NULL;
|
||
|
|
||
|
return pwc->GetPropertyByName(name.substr(pos+1,name.length()-pos-1));
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGProperty* wxPGPropertyWithChildren::GetItemAtY( unsigned int y, unsigned int lh )
|
||
|
{
|
||
|
// Linear search.
|
||
|
unsigned int i = 0;
|
||
|
unsigned int iMax = GetCount();
|
||
|
unsigned long py = 0xFFFFFFFF;
|
||
|
wxPGProperty* p = (wxPGProperty*) NULL;
|
||
|
|
||
|
while ( i < iMax )
|
||
|
{
|
||
|
p = Item(i);
|
||
|
if ( p->m_y >= 0 )
|
||
|
{
|
||
|
py = (unsigned long)p->m_y;
|
||
|
if ( (py+lh) > y )
|
||
|
break;
|
||
|
}
|
||
|
i++;
|
||
|
}
|
||
|
if ( py <= y && i < iMax )
|
||
|
{
|
||
|
// perfectly this item
|
||
|
wxASSERT_MSG( p, wxT("invalid property id") );
|
||
|
return p;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
// If no visible children, we must retract our steps
|
||
|
// (should not really happen, so right now we check that it
|
||
|
// really doesn't).
|
||
|
if ( py == 0xFFFFFFFF )
|
||
|
{
|
||
|
wxLogDebug(wxT("wxPropertyGrid: \"%s\" (y=%i) did not have visible children (it should)."),m_label.c_str(),(int)m_y);
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
// We are about to return a child of previous' visible item.
|
||
|
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( i < 1 )
|
||
|
{
|
||
|
wxLogDebug( wxT("WARNING: \"%s\"->GetItemAtY: (i <= 0)"), m_label.c_str() );
|
||
|
wxLogDebug( wxT(" \\--> y = %i, py = %i"), (int)y, (int)py );
|
||
|
if ( p )
|
||
|
wxLogDebug( wxT(" \\--> p = \"%s\""), p->GetLabel().c_str() );
|
||
|
else
|
||
|
wxLogDebug( wxT(" \\--> p = None") );
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// Get previous *visible* parent.
|
||
|
wxPGPropertyWithChildren* pwc;
|
||
|
do
|
||
|
{
|
||
|
wxASSERT( i > 0 );
|
||
|
i--;
|
||
|
pwc = (wxPGPropertyWithChildren*)Item(i);
|
||
|
} while ( pwc->m_y < 0 );
|
||
|
|
||
|
if ( pwc->GetParentingType() != 0 )
|
||
|
{
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( !pwc->m_expanded || pwc->m_y < 0 )
|
||
|
{
|
||
|
wxLogDebug(wxT("WARNING: wxPGPropertyWithChildren::GetItemAtY: Item %s should have been visible and expanded."),pwc->m_label.c_str());
|
||
|
wxLogDebug(wxT(" (%s[%i]: %s)"),pwc->m_parent->m_label.c_str(),pwc->m_arrIndex,pwc->m_label.c_str());
|
||
|
//wxLogDebug(wxT(" py=%i"),(int)py);
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
#endif
|
||
|
return pwc->GetItemAtY(y,lh);
|
||
|
}
|
||
|
}
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGPropertyWithChildren::Empty()
|
||
|
{
|
||
|
size_t i;
|
||
|
if ( m_expanded != wxPG_EXP_OF_COPYARRAY )
|
||
|
{
|
||
|
for ( i=0; i<GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = (wxPGProperty*) Item(i);
|
||
|
delete p;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
m_children.Empty();
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGPropertyWithChildren::ChildChanged( wxPGProperty* WXUNUSED(p) )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
wxString wxPGPropertyWithChildren::GetValueAsString( int argFlags ) const
|
||
|
{
|
||
|
wxCHECK_MSG( GetCount() > 0,
|
||
|
wxString(),
|
||
|
wxT("If user property does not have any children, it must override GetValueAsString.") );
|
||
|
|
||
|
wxString text;
|
||
|
|
||
|
int i;
|
||
|
int iMax = m_children.GetCount();
|
||
|
|
||
|
if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
|
||
|
!(argFlags & wxPG_FULL_VALUE) )
|
||
|
iMax = PWC_CHILD_SUMMARY_LIMIT;
|
||
|
|
||
|
int iMaxMinusOne = iMax-1;
|
||
|
|
||
|
wxPGProperty* curChild = (wxPGProperty*) m_children.Item(0);
|
||
|
|
||
|
for ( i = 0; i < iMax; i++ )
|
||
|
{
|
||
|
wxString s;
|
||
|
if ( !(curChild->m_flags & wxPG_PROP_UNSPECIFIED) )
|
||
|
s = curChild->GetValueAsString(argFlags);
|
||
|
|
||
|
if ( curChild->GetParentingType() == 0 )
|
||
|
text += s;
|
||
|
else
|
||
|
text += wxT("[") + s + wxT("]");
|
||
|
|
||
|
if ( i < iMaxMinusOne )
|
||
|
{
|
||
|
if ( text.length() > PWC_CHILD_SUMMARY_CHAR_LIMIT &&
|
||
|
!(argFlags & wxPG_EDITABLE_VALUE) &&
|
||
|
!(argFlags & wxPG_FULL_VALUE) )
|
||
|
break;
|
||
|
|
||
|
curChild = (wxPGProperty*) m_children.Item(i+1);
|
||
|
|
||
|
if ( curChild->GetParentingType() == 0 )
|
||
|
text += wxT("; ");
|
||
|
else
|
||
|
text += wxT(" ");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( (unsigned int)i < m_children.GetCount() )
|
||
|
text += wxT("; ...");
|
||
|
|
||
|
return text;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Convert semicolon delimited tokens into child values.
|
||
|
bool wxPGPropertyWithChildren::SetValueFromString( const wxString& text, int argFlags )
|
||
|
{
|
||
|
if ( !GetCount() )
|
||
|
return false;
|
||
|
|
||
|
unsigned int curChild = 0;
|
||
|
|
||
|
unsigned int iMax = m_children.GetCount();
|
||
|
|
||
|
if ( iMax > PWC_CHILD_SUMMARY_LIMIT &&
|
||
|
!(argFlags & wxPG_FULL_VALUE) )
|
||
|
iMax = PWC_CHILD_SUMMARY_LIMIT;
|
||
|
|
||
|
bool changed = false;
|
||
|
|
||
|
wxString token;
|
||
|
size_t pos = 0;
|
||
|
|
||
|
// Its best only to add non-empty group items
|
||
|
bool addOnlyIfNotEmpty = false;
|
||
|
const wxChar delimeter = wxT(';');
|
||
|
wxChar a;
|
||
|
|
||
|
size_t lastPos = text.length();
|
||
|
size_t tokenStart = 0xFFFFFF;
|
||
|
|
||
|
do
|
||
|
{
|
||
|
a = text[pos];
|
||
|
|
||
|
if ( tokenStart != 0xFFFFFF )
|
||
|
{
|
||
|
// Token is running
|
||
|
if ( a == delimeter || a == 0 )
|
||
|
{
|
||
|
token = text.substr(tokenStart,pos-tokenStart);
|
||
|
token.Trim(true);
|
||
|
size_t len = token.length();
|
||
|
|
||
|
if ( !addOnlyIfNotEmpty || len > 0 )
|
||
|
{
|
||
|
wxPGProperty* child = Item(curChild);
|
||
|
|
||
|
if ( len > 0 )
|
||
|
{
|
||
|
bool wasUnspecified = child->IsValueUnspecified();
|
||
|
if ( child->SetValueFromString( token, wxPG_REPORT_ERROR ) )
|
||
|
{
|
||
|
// If modified, set mod flag and store value back to parent
|
||
|
child->SetFlag( wxPG_PROP_MODIFIED );
|
||
|
|
||
|
// Clear unspecified flag only if SetValueFromString didn't
|
||
|
// affect it.
|
||
|
if ( child->IsValueUnspecified() &&
|
||
|
(wasUnspecified || !UsesAutoUnspecified()) )
|
||
|
child->ClearFlag( wxPG_PROP_UNSPECIFIED );
|
||
|
|
||
|
ChildChanged( child );
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
child->SetFlag( wxPG_PROP_UNSPECIFIED );
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
curChild++;
|
||
|
if ( curChild >= iMax )
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
tokenStart = 0xFFFFFF;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Token is not running
|
||
|
if ( a != wxT(' ') )
|
||
|
{
|
||
|
|
||
|
addOnlyIfNotEmpty = false;
|
||
|
|
||
|
// Is this a group of tokens?
|
||
|
if ( a == wxT('[') )
|
||
|
{
|
||
|
int depth = 1;
|
||
|
|
||
|
pos++;
|
||
|
size_t startPos = pos;
|
||
|
|
||
|
// Group item - find end
|
||
|
do
|
||
|
{
|
||
|
a = text[pos];
|
||
|
pos++;
|
||
|
|
||
|
if ( a == wxT(']') )
|
||
|
depth--;
|
||
|
else if ( a == wxT('[') )
|
||
|
depth++;
|
||
|
|
||
|
} while ( depth > 0 && a );
|
||
|
|
||
|
token = text.substr(startPos,pos-startPos-1);
|
||
|
|
||
|
if ( !token.length() )
|
||
|
break;
|
||
|
|
||
|
wxPGProperty* child = Item(curChild);
|
||
|
|
||
|
//wxLogDebug(wxT("child(1) %i: %s"),curChild,token.c_str());
|
||
|
|
||
|
if ( child->SetValueFromString( token, wxPG_REPORT_ERROR ) )
|
||
|
{
|
||
|
// If modified, set mod flag and store value back to parent
|
||
|
child->SetFlag( wxPG_PROP_MODIFIED );
|
||
|
ChildChanged( child );
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
curChild++;
|
||
|
if ( curChild >= iMax )
|
||
|
break;
|
||
|
|
||
|
addOnlyIfNotEmpty = true;
|
||
|
|
||
|
tokenStart = 0xFFFFFF;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
tokenStart = pos;
|
||
|
|
||
|
if ( a == delimeter )
|
||
|
{
|
||
|
pos--;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
pos++;
|
||
|
|
||
|
}
|
||
|
while ( pos <= lastPos );
|
||
|
|
||
|
// This ensures that the last item is set unspecified even
|
||
|
// if the blank had no terminating delimiter.
|
||
|
if ( curChild < iMax )
|
||
|
{
|
||
|
wxPGProperty* child = Item(curChild);
|
||
|
|
||
|
child->SetFlag( wxPG_PROP_UNSPECIFIED );
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
return changed;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGPropertyWithChildren::RefreshChildren ()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxParentProperty
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGProperty* wxParentProperty( const wxString& label, const wxString& name )
|
||
|
{
|
||
|
return new wxParentPropertyClass(label,name);
|
||
|
}
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxParentProperty,none,TextCtrl)
|
||
|
WX_PG_IMPLEMENT_CLASSINFO(wxParentProperty,wxBaseParentPropertyClass)
|
||
|
|
||
|
|
||
|
wxParentPropertyClass::wxParentPropertyClass( const wxString& label, const wxString& name )
|
||
|
: wxPGPropertyWithChildren(label,name)
|
||
|
{
|
||
|
m_parentingType = PT_CUSTOMPROPERTY;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxParentPropertyClass::~wxParentPropertyClass() { }
|
||
|
|
||
|
|
||
|
void wxParentPropertyClass::DoSetValue( wxPGVariant value )
|
||
|
{
|
||
|
const wxString& str = wxPGVariantToString(value);
|
||
|
m_string = str;
|
||
|
SetValueFromString(str,wxPG_REPORT_ERROR);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGVariant wxParentPropertyClass::DoGetValue() const
|
||
|
{
|
||
|
return wxPGVariant();
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxParentPropertyClass::ChildChanged( wxPGProperty* WXUNUSED(p) )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
wxString wxParentPropertyClass::GetValueAsString( int argFlags ) const
|
||
|
{
|
||
|
if ( !GetCount() )
|
||
|
return wxEmptyString;
|
||
|
|
||
|
return wxPGPropertyWithChildren::GetValueAsString(argFlags);
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGRootPropertyClass
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPGRootProperty,none,TextCtrl)
|
||
|
const wxPGPropertyClassInfo* wxPGRootPropertyClass::GetClassInfo() const
|
||
|
{
|
||
|
return (const wxPGPropertyClassInfo*) NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGRootPropertyClass::wxPGRootPropertyClass()
|
||
|
: wxPGPropertyWithChildren()
|
||
|
{
|
||
|
m_parentingType = PT_ROOT; // this was PT_CAPTION in <= 1.1.6, but changed
|
||
|
// so the depth calculations can become
|
||
|
// more consistent.
|
||
|
m_depth = 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGRootPropertyClass::~wxPGRootPropertyClass()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyCategoryClass
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGProperty* wxPropertyCategory( const wxString& label, const wxString& name )
|
||
|
{
|
||
|
return new wxPropertyCategoryClass(label,name);
|
||
|
}
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_CLASSINFO(wxPropertyCategory,wxBaseParentPropertyClass)
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(wxPropertyCategory,none,TextCtrl)
|
||
|
|
||
|
|
||
|
wxPropertyCategoryClass::wxPropertyCategoryClass()
|
||
|
: wxPGPropertyWithChildren()
|
||
|
{
|
||
|
// don't set colour - prepareadditem method should do this
|
||
|
m_parentingType = 1;
|
||
|
m_capFgColIndex = 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPropertyCategoryClass::wxPropertyCategoryClass( const wxString &label, const wxString& name )
|
||
|
: wxPGPropertyWithChildren(label,name)
|
||
|
{
|
||
|
// don't set colour - prepareadditem method should do this
|
||
|
m_parentingType = 1;
|
||
|
m_capFgColIndex = 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPropertyCategoryClass::~wxPropertyCategoryClass()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
wxString wxPropertyCategoryClass::GetValueAsString( int ) const
|
||
|
{
|
||
|
return wxEmptyString;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPropertyCategoryClass::CalculateTextExtent( wxWindow* wnd, wxFont& font )
|
||
|
{
|
||
|
int x = 0, y = 0;
|
||
|
wnd->GetTextExtent( m_label, &x, &y, 0, 0, &font );
|
||
|
m_textExtent = x;
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGEditor::~wxPGEditor()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGEditor::DrawValue( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const
|
||
|
{
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
dc.DrawText( property->GetDisplayedString(), rect.x+wxPG_XBEFORETEXT, rect.y );
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGEditor::SetControlStringValue( wxWindow*, const wxString& ) const
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGEditor::SetControlIntValue( wxWindow*, int ) const
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
int wxPGEditor::InsertItem( wxWindow*, const wxString&, int ) const
|
||
|
{
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGEditor::DeleteItem( wxWindow*, int ) const
|
||
|
{
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGEditor::OnFocus( wxPGProperty*, wxWindow* ) const
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGEditor::CanContainCustomImage() const
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGClipperWindow
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
|
||
|
//
|
||
|
// Clipper window is used to "remove" borders from controls
|
||
|
// which otherwise insist on having them despite of supplied
|
||
|
// wxNO_BORDER window style.
|
||
|
//
|
||
|
class wxPGClipperWindow : public wxWindow
|
||
|
{
|
||
|
DECLARE_CLASS(wxPGClipperWindow)
|
||
|
public:
|
||
|
|
||
|
wxPGClipperWindow()
|
||
|
: wxWindow()
|
||
|
{
|
||
|
wxPGClipperWindow::Init();
|
||
|
}
|
||
|
|
||
|
wxPGClipperWindow(wxWindow* parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos = wxDefaultPosition,
|
||
|
const wxSize& size = wxDefaultSize)
|
||
|
{
|
||
|
Init();
|
||
|
Create(parent,id,pos,size);
|
||
|
}
|
||
|
|
||
|
void Create(wxWindow* parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos = wxDefaultPosition,
|
||
|
const wxSize& size = wxDefaultSize);
|
||
|
|
||
|
virtual ~wxPGClipperWindow();
|
||
|
|
||
|
virtual bool ProcessEvent(wxEvent& event);
|
||
|
|
||
|
inline wxWindow* GetControl() const { return m_ctrl; }
|
||
|
|
||
|
// This is called before wxControl is constructed.
|
||
|
void GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz );
|
||
|
|
||
|
// This is caleed after wxControl has been constructed.
|
||
|
void SetControl( wxWindow* ctrl );
|
||
|
|
||
|
virtual void Refresh( bool eraseBackground = true,
|
||
|
const wxRect *rect = (const wxRect *) NULL );
|
||
|
virtual void SetFocus();
|
||
|
|
||
|
virtual bool SetFont(const wxFont& font);
|
||
|
|
||
|
inline int GetXClip() const { return m_xadj; }
|
||
|
|
||
|
inline int GetYClip() const { return m_yadj; }
|
||
|
|
||
|
protected:
|
||
|
wxWindow* m_ctrl;
|
||
|
|
||
|
int m_xadj; // Horizontal border clip.
|
||
|
|
||
|
int m_yadj; // Vertical border clip.
|
||
|
|
||
|
private:
|
||
|
void Init ()
|
||
|
{
|
||
|
m_ctrl = (wxWindow*) NULL;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
|
||
|
IMPLEMENT_CLASS(wxPGClipperWindow,wxWindow)
|
||
|
|
||
|
|
||
|
// This is called before wxControl is constructed.
|
||
|
void wxPGClipperWindow::GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz )
|
||
|
{
|
||
|
m_xadj = xadj;
|
||
|
m_yadj = yadj;
|
||
|
pt.x = -xadj;
|
||
|
pt.y = -yadj;
|
||
|
wxSize own_size = GetSize();
|
||
|
sz.x = own_size.x+(xadj*2);
|
||
|
sz.y = own_size.y+(yadj*2);
|
||
|
}
|
||
|
|
||
|
|
||
|
// This is caleed after wxControl has been constructed.
|
||
|
void wxPGClipperWindow::SetControl( wxWindow* ctrl )
|
||
|
{
|
||
|
m_ctrl = ctrl;
|
||
|
|
||
|
// GTK requires this.
|
||
|
ctrl->SetSizeHints(3,3);
|
||
|
|
||
|
// Correct size of this window to match the child.
|
||
|
wxSize sz = GetSize();
|
||
|
wxSize chsz = ctrl->GetSize();
|
||
|
|
||
|
int hei_adj = chsz.y - (sz.y+(m_yadj*2));
|
||
|
if ( hei_adj )
|
||
|
SetSize(sz.x,chsz.y-(m_yadj*2));
|
||
|
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGClipperWindow::Refresh( bool eraseBackground, const wxRect *rect )
|
||
|
{
|
||
|
wxWindow::Refresh(false,rect);
|
||
|
if ( m_ctrl )
|
||
|
// FIXME: Rect to sub-ctrl refresh too
|
||
|
m_ctrl->Refresh(eraseBackground);
|
||
|
}
|
||
|
|
||
|
|
||
|
// Pass focus to control
|
||
|
void wxPGClipperWindow::SetFocus()
|
||
|
{
|
||
|
if ( m_ctrl )
|
||
|
m_ctrl->SetFocus();
|
||
|
else
|
||
|
wxWindow::SetFocus();
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGClipperWindow::SetFont(const wxFont& font)
|
||
|
{
|
||
|
bool res = wxWindow::SetFont(font);
|
||
|
if ( m_ctrl )
|
||
|
return m_ctrl->SetFont(font);
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGClipperWindow::Create(wxWindow* parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& size )
|
||
|
{
|
||
|
wxWindow::Create(parent,id,pos,size);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGClipperWindow::~wxPGClipperWindow()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGClipperWindow::ProcessEvent(wxEvent& event)
|
||
|
{
|
||
|
if ( event.GetEventType() == wxEVT_SIZE )
|
||
|
{
|
||
|
if ( m_ctrl )
|
||
|
{
|
||
|
// Maintain correct size relationship.
|
||
|
wxSize sz = GetSize();
|
||
|
m_ctrl->SetSize(sz.x+(m_xadj*2),sz.y+(m_yadj*2));
|
||
|
event.Skip();
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
return wxWindow::ProcessEvent(event);
|
||
|
}
|
||
|
|
||
|
#endif // wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
|
||
|
/*wxWindow* wxPropertyGrid::GetActualEditorControl( wxWindow* ctrl )
|
||
|
{
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
// Pass real control instead of clipper window
|
||
|
if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
|
||
|
{
|
||
|
return ((wxPGClipperWindow*)ctrl)->GetControl();
|
||
|
}
|
||
|
#else
|
||
|
return ctrl;
|
||
|
#endif
|
||
|
}*/
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGTextCtrlEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Clipper window support macro (depending on whether it is used
|
||
|
// for this editor or not)
|
||
|
#if wxPG_NAT_TEXTCTRL_BORDER_X || wxPG_NAT_TEXTCTRL_BORDER_Y
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_ANY 1
|
||
|
#define wxPGDeclareRealTextCtrl(WND) \
|
||
|
wxASSERT( WND ); \
|
||
|
wxTextCtrl* tc = (wxTextCtrl*)((wxPGClipperWindow*)WND)->GetControl()
|
||
|
#else
|
||
|
#define wxPG_NAT_TEXTCTRL_BORDER_ANY 0
|
||
|
#define wxPGDeclareRealTextCtrl(WND) \
|
||
|
wxASSERT( WND ); \
|
||
|
wxTextCtrl* tc = (wxTextCtrl*)WND
|
||
|
#endif
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrl,wxPGTextCtrlEditor,wxPGEditor)
|
||
|
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
wxWindow** ) const
|
||
|
#else
|
||
|
wxPGWindowPair wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz ) const
|
||
|
#endif
|
||
|
{
|
||
|
wxString text;
|
||
|
|
||
|
// If has children and limited editing, then don't create.
|
||
|
if ((property->GetFlags() & wxPG_PROP_NOEDITOR) &&
|
||
|
property->GetParentingType() < 0 &&
|
||
|
!property->IsKindOf(WX_PG_CLASSINFO(wxCustomProperty)))
|
||
|
return (wxWindow*) NULL;
|
||
|
|
||
|
int flags = 0;
|
||
|
if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
|
||
|
property->IsKindOf(WX_PG_CLASSINFO(wxStringProperty)) )
|
||
|
flags |= wxTE_PASSWORD;
|
||
|
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
text = property->GetValueAsString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
|
||
|
|
||
|
wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,(wxWindow*)NULL,flags,
|
||
|
property->GetMaxLength());
|
||
|
|
||
|
return wnd;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGTextCtrlEditor::DrawValue( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const
|
||
|
{
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
{
|
||
|
wxString drawStr = property->GetDisplayedString();
|
||
|
|
||
|
// Code below should no longer be needed, as the obfuscation
|
||
|
// is now done in GetValueAsString.
|
||
|
/*if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
|
||
|
property->IsKindOf(WX_PG_CLASSINFO(wxStringProperty)) )
|
||
|
{
|
||
|
size_t a = drawStr.length();
|
||
|
drawStr.Empty();
|
||
|
drawStr.Append(wxT('*'),a);
|
||
|
}*/
|
||
|
dc.DrawText( drawStr, rect.x+wxPG_XBEFORETEXT, rect.y );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGTextCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGDeclareRealTextCtrl(ctrl);
|
||
|
tc->SetValue(property->GetDisplayedString());
|
||
|
}
|
||
|
|
||
|
|
||
|
// Provided so that, for example, ComboBox editor can use the same code
|
||
|
// (multiple inheritance would get way too messy).
|
||
|
bool wxPGTextCtrlEditor::OnTextCtrlEvent( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
wxWindow* ctrl,
|
||
|
wxEvent& event )
|
||
|
{
|
||
|
if ( !ctrl )
|
||
|
return false;
|
||
|
|
||
|
if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
|
||
|
{
|
||
|
if ( propGrid->IsEditorsValueModified() )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
else if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED )
|
||
|
{
|
||
|
wxPGDeclareRealTextCtrl(ctrl);
|
||
|
|
||
|
// If value is unspecified and character count is zero,
|
||
|
// then do not set as modified.
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) ||
|
||
|
!tc ||
|
||
|
(tc->IsKindOf(CLASSINFO(wxTextCtrl)) &&
|
||
|
(tc->GetLastPosition() > 0)) )
|
||
|
{
|
||
|
|
||
|
// We must check this since an 'empty' text event
|
||
|
// may be triggered when creating the property.
|
||
|
if ( !(propGrid->GetInternalFlags() & wxPG_FL_IN_SELECT_PROPERTY) )
|
||
|
{
|
||
|
//
|
||
|
// Pass this event outside wxPropertyGrid so that,
|
||
|
// if necessary, program can tell when user is editing
|
||
|
// a textctrl.
|
||
|
// FIXME: Is it safe to change event id in the middle of event
|
||
|
// processing (seems to work, but...)?
|
||
|
event.Skip();
|
||
|
event.SetId(propGrid->GetId());
|
||
|
}
|
||
|
|
||
|
propGrid->EditorsValueWasModified();
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGTextCtrlEditor::OnEvent( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
wxWindow* ctrl,
|
||
|
wxEvent& event ) const
|
||
|
{
|
||
|
return wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,ctrl,event);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGTextCtrlEditor::CopyTextCtrlValueFromControl( wxPGProperty* property, wxWindow* ctrl )
|
||
|
{
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
// Pass real control instead of clipper window
|
||
|
if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
|
||
|
{
|
||
|
ctrl = ((wxPGClipperWindow*)ctrl)->GetControl();
|
||
|
}
|
||
|
#endif
|
||
|
wxTextCtrl* tc = (wxTextCtrl*)ctrl;
|
||
|
|
||
|
bool res = property->SetValueFromString(tc->GetValue(),0);
|
||
|
|
||
|
// Changing unspecified always causes event (returning
|
||
|
// true here should be enough to trigger it).
|
||
|
if ( !res && property->IsFlagSet(wxPG_PROP_UNSPECIFIED) )
|
||
|
res = true;
|
||
|
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGTextCtrlEditor::CopyValueFromControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
return wxPGTextCtrlEditor::CopyTextCtrlValueFromControl(property,ctrl);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGTextCtrlEditor::SetValueToUnspecified( wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGDeclareRealTextCtrl(ctrl);
|
||
|
|
||
|
tc->Remove(0,tc->GetValue().length());
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGTextCtrlEditor::SetControlStringValue( wxWindow* ctrl, const wxString& txt ) const
|
||
|
{
|
||
|
wxPGDeclareRealTextCtrl(ctrl);
|
||
|
|
||
|
tc->SetValue(txt);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGTextCtrlEditor::OnFocus( wxPGProperty*, wxWindow* wnd ) const
|
||
|
{
|
||
|
wxPGDeclareRealTextCtrl(wnd);
|
||
|
|
||
|
tc->SetSelection(-1,-1);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGChoiceEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
extern const wxChar* wxPG_ClassName_wxBoolProperty; // in props.cpp
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(Choice,wxPGChoiceEditor,wxPGEditor)
|
||
|
|
||
|
|
||
|
// This is a special enhanced double-click processor class.
|
||
|
// In essence, it allows for double-clicks for which the
|
||
|
// first click "created" the control.
|
||
|
class wxPGDoubleClickProcessor : public wxEvtHandler
|
||
|
{
|
||
|
public:
|
||
|
|
||
|
wxPGDoubleClickProcessor( wxPGOwnerDrawnComboBox* combo )
|
||
|
: wxEvtHandler()
|
||
|
{
|
||
|
m_timeLastMouseUp = 0;
|
||
|
m_combo = combo;
|
||
|
m_downReceived = false;
|
||
|
}
|
||
|
|
||
|
protected:
|
||
|
|
||
|
void OnMouseEvent( wxMouseEvent& event )
|
||
|
{
|
||
|
wxLongLong t = ::wxGetLocalTimeMillis();
|
||
|
int evtType = event.GetEventType();
|
||
|
|
||
|
if ( m_combo->HasFlag(wxPGCC_DCLICK_CYCLES) &&
|
||
|
!m_combo->IsPopupShown() )
|
||
|
{
|
||
|
// Just check that it is in the text area
|
||
|
wxPoint pt = event.GetPosition();
|
||
|
if ( m_combo->GetTextRect().wxPGRectContains(pt) )
|
||
|
{
|
||
|
if ( evtType == wxEVT_LEFT_DOWN )
|
||
|
{
|
||
|
// Set value to avoid up-events without corresponding downs
|
||
|
m_downReceived = true;
|
||
|
}
|
||
|
else if ( evtType == wxEVT_LEFT_DCLICK )
|
||
|
{
|
||
|
// We'll make our own double-clicks
|
||
|
event.SetEventType(0);
|
||
|
return;
|
||
|
}
|
||
|
else if ( evtType == wxEVT_LEFT_UP )
|
||
|
{
|
||
|
if ( m_downReceived || m_timeLastMouseUp == 1 )
|
||
|
{
|
||
|
wxLongLong timeFromLastUp = (t-m_timeLastMouseUp);
|
||
|
|
||
|
if ( timeFromLastUp < DOUBLE_CLICK_CONVERSION_TRESHOLD )
|
||
|
{
|
||
|
event.SetEventType(wxEVT_LEFT_DCLICK);
|
||
|
m_timeLastMouseUp = 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_timeLastMouseUp = t;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
void OnSetFocus( wxFocusEvent& event )
|
||
|
{
|
||
|
m_timeLastMouseUp = ::wxGetLocalTimeMillis();
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
wxLongLong m_timeLastMouseUp;
|
||
|
wxPGOwnerDrawnComboBox* m_combo;
|
||
|
bool m_downReceived;
|
||
|
|
||
|
DECLARE_EVENT_TABLE()
|
||
|
};
|
||
|
|
||
|
BEGIN_EVENT_TABLE(wxPGDoubleClickProcessor, wxEvtHandler)
|
||
|
EVT_MOUSE_EVENTS(wxPGDoubleClickProcessor::OnMouseEvent)
|
||
|
EVT_SET_FOCUS(wxPGDoubleClickProcessor::OnSetFocus)
|
||
|
END_EVENT_TABLE()
|
||
|
|
||
|
|
||
|
|
||
|
class wxPGComboBox : public wxPGOwnerDrawnComboBox
|
||
|
{
|
||
|
public:
|
||
|
|
||
|
wxPGComboBox()
|
||
|
: wxPGOwnerDrawnComboBox()
|
||
|
{
|
||
|
m_dclickProcessor = (wxPGDoubleClickProcessor*) NULL;
|
||
|
}
|
||
|
|
||
|
~wxPGComboBox()
|
||
|
{
|
||
|
if ( m_dclickProcessor )
|
||
|
{
|
||
|
RemoveEventHandler(m_dclickProcessor);
|
||
|
delete m_dclickProcessor;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
bool Create(wxWindow *parent,
|
||
|
wxWindowID id,
|
||
|
const wxString& value = wxEmptyString,
|
||
|
const wxPoint& pos = wxDefaultPosition,
|
||
|
const wxSize& size = wxDefaultSize,
|
||
|
int n = 0,
|
||
|
const wxString choices[] = (const wxString *) NULL,
|
||
|
long style = 0,
|
||
|
const wxValidator& validator = wxDefaultValidator,
|
||
|
const wxString& name = wxComboBoxNameStr)
|
||
|
{
|
||
|
if ( !wxPGOwnerDrawnComboBox::Create( parent,
|
||
|
id,
|
||
|
value,
|
||
|
pos,
|
||
|
size,
|
||
|
n,
|
||
|
choices,
|
||
|
style,
|
||
|
validator,
|
||
|
name ) )
|
||
|
return false;
|
||
|
|
||
|
m_dclickProcessor = new wxPGDoubleClickProcessor(this);
|
||
|
|
||
|
PushEventHandler(m_dclickProcessor);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
virtual bool OnDrawListItem( wxDC& dc, const wxRect& rect, int item, int flags )
|
||
|
{
|
||
|
wxPropertyGrid* pg = wxDynamicCast(GetParent(),wxPropertyGrid);
|
||
|
wxASSERT(pg);
|
||
|
pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,dc,(wxRect&)rect,flags);
|
||
|
return true;
|
||
|
}
|
||
|
virtual wxCoord OnMeasureListItem( int item )
|
||
|
{
|
||
|
wxPropertyGrid* pg = wxDynamicCast(GetParent(),wxPropertyGrid);
|
||
|
wxASSERT(pg);
|
||
|
wxRect rect;
|
||
|
rect.x = -1;
|
||
|
rect.width = 0;
|
||
|
pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
|
||
|
return rect.height;
|
||
|
}
|
||
|
virtual wxCoord OnMeasureListItemWidth( int item )
|
||
|
{
|
||
|
wxPropertyGrid* pg = wxDynamicCast(GetParent(),wxPropertyGrid);
|
||
|
wxASSERT(pg);
|
||
|
wxRect rect;
|
||
|
rect.x = -1;
|
||
|
rect.width = -1;
|
||
|
pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
|
||
|
return rect.width;
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
wxPGDoubleClickProcessor* m_dclickProcessor;
|
||
|
};
|
||
|
|
||
|
|
||
|
void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
|
||
|
int item,
|
||
|
wxDC& dc,
|
||
|
wxRect& rect,
|
||
|
int flags )
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* pCb = (wxPGOwnerDrawnComboBox*)pCc;
|
||
|
|
||
|
// Sanity check
|
||
|
wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
|
||
|
|
||
|
wxPGProperty* p = m_selected;
|
||
|
|
||
|
//
|
||
|
// Decide what custom image size to use
|
||
|
wxSize cis = GetImageSize(p);
|
||
|
|
||
|
if ( rect.x < 0 &&
|
||
|
!(m_iFlags & wxPG_FL_SELECTED_IS_PAINT_FLEXIBLE) )
|
||
|
{
|
||
|
// Default measure behaviour (no flexible, custom paint image only)
|
||
|
if ( rect.width < 0 )
|
||
|
{
|
||
|
wxCoord x, y;
|
||
|
GetTextExtent(pCb->GetString(item), &x, &y, 0, 0, &m_font);
|
||
|
rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9 + x;
|
||
|
}
|
||
|
|
||
|
rect.height = cis.y + 2;
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
wxPGPaintData paintdata;
|
||
|
paintdata.m_parent = NULL;
|
||
|
paintdata.m_choiceItem = item;
|
||
|
|
||
|
// This is by the current (1.0.0b) spec - if painting control, item is -1
|
||
|
if ( (flags & wxPGCC_PAINTING_CONTROL) )
|
||
|
paintdata.m_choiceItem = -1;
|
||
|
|
||
|
if ( &dc )
|
||
|
dc.SetBrush(*wxWHITE_BRUSH);
|
||
|
|
||
|
if ( rect.x >= 0 )
|
||
|
{
|
||
|
//
|
||
|
// DrawItem call
|
||
|
|
||
|
wxPoint pt(rect.x + wxPG_CONTROL_MARGIN - wxPG_CHOICEXADJUST - 1,
|
||
|
rect.y + 1);
|
||
|
|
||
|
if ( cis.x > 0 &&
|
||
|
( !p->m_dataExt || !p->m_dataExt->m_valueBitmap || item == pCb->GetSelection() ) &&
|
||
|
( item >= 0 || (flags & wxPGCC_PAINTING_CONTROL) )
|
||
|
)
|
||
|
{
|
||
|
pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
|
||
|
wxRect r(pt.x,pt.y,cis.x,cis.y);
|
||
|
|
||
|
if ( flags & wxPGCC_PAINTING_CONTROL )
|
||
|
{
|
||
|
//r.width = cis.x;
|
||
|
r.height = wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight);
|
||
|
}
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_SELECTED_IS_FULL_PAINT )
|
||
|
r.width = rect.width;
|
||
|
|
||
|
paintdata.m_drawnWidth = r.width;
|
||
|
|
||
|
dc.SetPen(m_colPropFore);
|
||
|
if ( item >= 0 )
|
||
|
p->OnCustomPaint( dc, r, paintdata );
|
||
|
else
|
||
|
dc.DrawRectangle( r );
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_SELECTED_IS_FULL_PAINT) )
|
||
|
{
|
||
|
if ( paintdata.m_drawnWidth > 0 )
|
||
|
return;
|
||
|
|
||
|
// Revert pt.x
|
||
|
pt.x -= (wxCC_CUSTOM_IMAGE_MARGIN1+1);
|
||
|
}
|
||
|
else
|
||
|
pt.x += paintdata.m_drawnWidth + wxCC_CUSTOM_IMAGE_MARGIN2 - 1;
|
||
|
}
|
||
|
else
|
||
|
// TODO: This aligns text so that it seems to be horizontally
|
||
|
// on the same line as property values. Not really
|
||
|
// sure if its needed, but seems to not cause any harm.
|
||
|
pt.x -= 1;
|
||
|
|
||
|
//
|
||
|
// Draw text
|
||
|
//
|
||
|
|
||
|
pt.y += (rect.height-m_fontHeight)/2 - 1;
|
||
|
|
||
|
wxString text;
|
||
|
if ( !(flags & wxPGCC_PAINTING_CONTROL) )
|
||
|
{
|
||
|
text = pCb->GetString(item);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( !p->IsValueUnspecified() )
|
||
|
text = p->GetValueAsString(0);
|
||
|
}
|
||
|
|
||
|
dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//
|
||
|
// MeasureItem call
|
||
|
|
||
|
p->OnCustomPaint( dc, rect, paintdata );
|
||
|
rect.height = paintdata.m_drawnHeight + 2;
|
||
|
rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// CreateControls calls this with CB_READONLY in extraStyle
|
||
|
wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
long extraStyle ) const
|
||
|
{
|
||
|
wxString defString;
|
||
|
wxPGChoiceInfo choiceInfo;
|
||
|
|
||
|
// Get choices.
|
||
|
choiceInfo.m_arrWxString = (wxString*) NULL;
|
||
|
choiceInfo.m_arrWxChars = (const wxChar**) NULL;
|
||
|
choiceInfo.m_itemCount = 0;
|
||
|
|
||
|
int index = property->GetChoiceInfo( &choiceInfo );
|
||
|
|
||
|
if ( property->GetFlags() & wxPG_PROP_UNSPECIFIED )
|
||
|
{
|
||
|
index = -1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
defString = property->GetDisplayedString();
|
||
|
}
|
||
|
|
||
|
// SLAlloc allows fast conversion using potentially pre-allocated wxStrings
|
||
|
// (and appending is out of question due to performance problems on some platforms).
|
||
|
|
||
|
// If itemcount is < 0, fill wxArrayString using GetEntry
|
||
|
if ( choiceInfo.m_itemCount < 0 )
|
||
|
{
|
||
|
wxBaseEnumPropertyClass* ep = (wxBaseEnumPropertyClass*) property;
|
||
|
size_t i = 0;
|
||
|
const wxString* entryLabel;
|
||
|
int entryValue;
|
||
|
|
||
|
wxArrayString& sl = propGrid->SLGet();
|
||
|
|
||
|
entryLabel = ep->GetEntry(i,&entryValue);
|
||
|
while ( entryLabel )
|
||
|
{
|
||
|
if ( sl.GetCount() > i )
|
||
|
sl[i] = *entryLabel;
|
||
|
else
|
||
|
sl.Add(*entryLabel);
|
||
|
i++;
|
||
|
entryLabel = ep->GetEntry(i,&entryValue);
|
||
|
}
|
||
|
choiceInfo.m_itemCount = ((int)i) - 1;
|
||
|
}
|
||
|
else if ( !choiceInfo.m_arrWxString )
|
||
|
{
|
||
|
wxASSERT( choiceInfo.m_arrWxChars || !choiceInfo.m_itemCount );
|
||
|
propGrid->SLAlloc( choiceInfo.m_itemCount, choiceInfo.m_arrWxChars );
|
||
|
if ( choiceInfo.m_itemCount )
|
||
|
choiceInfo.m_arrWxString = &propGrid->SLGet().Item(0);
|
||
|
}
|
||
|
|
||
|
//wxPGOwnerDrawnComboBox* cb;
|
||
|
wxPGComboBox* cb;
|
||
|
|
||
|
wxPoint po(pos);
|
||
|
wxSize si(sz);
|
||
|
po.y += wxPG_CHOICEYADJUST;
|
||
|
si.y -= (wxPG_CHOICEYADJUST*2);
|
||
|
|
||
|
/*#if wxPG_NAT_CHOICE_BORDER_ANY
|
||
|
po.x += (wxPG_CHOICEXADJUST+wxPG_NAT_CHOICE_BORDER_X);
|
||
|
si.x -= (wxPG_CHOICEXADJUST+wxPG_NAT_CHOICE_BORDER_X);
|
||
|
wxPGClipperWindow* wnd = new wxPGClipperWindow(propGrid,wxPG_SUBID1,po,si);
|
||
|
wxWindow* ctrlParent = wnd;
|
||
|
wnd->GetControlRect(wxPG_NAT_CHOICE_BORDER_X,wxPG_NAT_CHOICE_BORDER_Y,po,si);
|
||
|
#else*/
|
||
|
po.x += wxPG_CHOICEXADJUST;
|
||
|
si.x -= wxPG_CHOICEXADJUST;
|
||
|
wxWindow* ctrlParent = propGrid;
|
||
|
//#endif
|
||
|
|
||
|
// NB: Using wxWidgets wxOwnerDrawnComboBox needs adding wxTE_PROCESS_ENTER
|
||
|
// into the flags.
|
||
|
int odcbFlags = extraStyle | wxNO_BORDER | wxPGCC_PROCESS_ENTER | wxPGCC_ALT_KEYS;
|
||
|
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_CUSTOMIMAGE) )
|
||
|
odcbFlags |= wxODCB_STD_CONTROL_PAINT;
|
||
|
|
||
|
if ( (property->GetFlags() & wxPG_PROP_USE_DCC) &&
|
||
|
(property->GetClassName()==wxPG_ClassName_wxBoolProperty) )
|
||
|
odcbFlags |= wxPGCC_DCLICK_CYCLES;
|
||
|
|
||
|
cb = new wxPGComboBox();
|
||
|
#ifdef __WXMSW__
|
||
|
cb->Hide();
|
||
|
#endif
|
||
|
cb->Create(ctrlParent,
|
||
|
wxPG_SUBID1,
|
||
|
wxString(),
|
||
|
po,
|
||
|
si,
|
||
|
choiceInfo.m_itemCount,choiceInfo.m_arrWxString,
|
||
|
//(wxComboPaintCallback) &wxPropertyGrid::OnComboItemPaint,
|
||
|
odcbFlags);
|
||
|
|
||
|
int extRight = propGrid->GetClientSize().x - (po.x+si.x);
|
||
|
|
||
|
cb->SetButtonPosition(si.y,0,wxRIGHT);
|
||
|
cb->SetPopupExtents( 1, extRight );
|
||
|
cb->SetTextIndent(wxPG_XBEFORETEXT-2);
|
||
|
|
||
|
if ( (property->GetFlags() & wxPG_PROP_CUSTOMIMAGE) &&
|
||
|
!(propGrid->GetInternalFlags() & wxPG_FL_SELECTED_IS_FULL_PAINT) )
|
||
|
{
|
||
|
wxSize imageSize = propGrid->GetImageSize(property);
|
||
|
cb->SetCustomPaintWidth( imageSize.x+6 );
|
||
|
}
|
||
|
|
||
|
if ( index >= 0 && index < (int)cb->GetCount() )
|
||
|
{
|
||
|
cb->SetSelection( index );
|
||
|
if ( defString.length() )
|
||
|
cb->SetValue( defString );
|
||
|
}
|
||
|
else if ( !(extraStyle & wxCB_READONLY) && defString.length() )
|
||
|
cb->SetValue( defString );
|
||
|
else
|
||
|
cb->SetSelection( -1 );
|
||
|
|
||
|
if ( property->HasFlag(wxPG_PROP_READONLY) )
|
||
|
cb->Disable();
|
||
|
|
||
|
#ifdef __WXMSW__
|
||
|
cb->Show();
|
||
|
#endif
|
||
|
|
||
|
return (wxWindow*) cb;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGChoiceEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxASSERT( ctrl );
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
wxASSERT( cb->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)));
|
||
|
int ind = property->GetChoiceInfo( (wxPGChoiceInfo*)NULL );
|
||
|
cb->SetSelection(ind);
|
||
|
}
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGChoiceEditor::CreateControls( wxPropertyGrid* propGrid, wxPGProperty* property,
|
||
|
const wxPoint& pos, const wxSize& sz, wxWindow** ) const
|
||
|
#else
|
||
|
wxPGWindowPair wxPGChoiceEditor::CreateControls( wxPropertyGrid* propGrid, wxPGProperty* property,
|
||
|
const wxPoint& pos, const wxSize& sz ) const
|
||
|
#endif
|
||
|
{
|
||
|
return CreateControlsBase(propGrid,property,pos,sz,wxCB_READONLY);
|
||
|
}
|
||
|
|
||
|
|
||
|
int wxPGChoiceEditor::InsertItem( wxWindow* ctrl, const wxString& label, int index ) const
|
||
|
{
|
||
|
wxASSERT( ctrl );
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
wxASSERT( cb->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)));
|
||
|
|
||
|
if (index < 0)
|
||
|
index = cb->GetCount();
|
||
|
|
||
|
return cb->Insert(label,index);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGChoiceEditor::DeleteItem( wxWindow* ctrl, int index ) const
|
||
|
{
|
||
|
wxASSERT( ctrl );
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
wxASSERT( cb->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)));
|
||
|
|
||
|
cb->Delete(index);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGChoiceEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
|
||
|
wxWindow* WXUNUSED(ctrl), wxEvent& event ) const
|
||
|
{
|
||
|
if ( event.GetEventType() == wxEVT_COMMAND_COMBOBOX_SELECTED )
|
||
|
{
|
||
|
/*if ( CopyValueFromControl( property, ctrl ) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
propGrid->EditorsValueWasNotModified();
|
||
|
|
||
|
//wxPropertyGridState::ClearPropertyAndChildrenFlags(property,wxPG_PROP_UNSPECIFIED);
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(property);*/
|
||
|
|
||
|
return true;
|
||
|
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGChoiceEditor::CopyValueFromControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
|
||
|
int index = cb->GetSelection();
|
||
|
|
||
|
if ( index != property->GetChoiceInfo( (wxPGChoiceInfo*) NULL ) ||
|
||
|
// Changing unspecified always causes event (returning
|
||
|
// true here should be enough to trigger it).
|
||
|
property->IsFlagSet(wxPG_PROP_UNSPECIFIED)
|
||
|
)
|
||
|
{
|
||
|
property->SetValueFromInt(index,0);
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGChoiceEditor::SetControlStringValue( wxWindow* ctrl, const wxString& txt ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
wxASSERT( cb );
|
||
|
cb->SetValue(txt);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGChoiceEditor::SetControlIntValue( wxWindow* ctrl, int value ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
wxASSERT( cb );
|
||
|
cb->SetSelection(value);
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGChoiceEditor::SetValueToUnspecified( wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
cb->SetSelection(-1);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGChoiceEditor::CanContainCustomImage() const
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGChoiceEditor::~wxPGChoiceEditor() { }
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGComboBoxEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(ComboBox,wxPGComboBoxEditor,wxPGChoiceEditor)
|
||
|
|
||
|
|
||
|
void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
cb->SetValue(property->GetDisplayedString());
|
||
|
|
||
|
// TODO: If string matches any selection, then select that.
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGComboBoxEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
wxWindow** ) const
|
||
|
#else
|
||
|
wxPGWindowPair wxPGComboBoxEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz ) const
|
||
|
#endif
|
||
|
{
|
||
|
return CreateControlsBase(propGrid,property,pos,sz,0);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGComboBoxEditor::OnEvent( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
wxWindow* ctrl,
|
||
|
wxEvent& event ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*) NULL;
|
||
|
wxWindow* textCtrl = (wxWindow*) NULL;
|
||
|
|
||
|
if ( ctrl )
|
||
|
{
|
||
|
cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
textCtrl = cb->GetTextCtrl();
|
||
|
}
|
||
|
|
||
|
if ( wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,textCtrl,event) )
|
||
|
return true;
|
||
|
|
||
|
return wxPGChoiceEditor::OnEvent(propGrid,property,ctrl,event);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGComboBoxEditor::CopyValueFromControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
|
||
|
bool res = property->SetValueFromString(cb->GetValue(),0);
|
||
|
|
||
|
// Changing unspecified always causes event (returning
|
||
|
// true here should be enough to trigger it).
|
||
|
if ( !res && property->IsFlagSet(wxPG_PROP_UNSPECIFIED) )
|
||
|
res = true;
|
||
|
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGComboBoxEditor::OnFocus( wxPGProperty*, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxPGOwnerDrawnComboBox* cb = (wxPGOwnerDrawnComboBox*)ctrl;
|
||
|
cb->GetTextCtrl()->SetSelection(-1,-1);
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGChoiceAndButtonEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
// This simpler implement_editor macro doesn't define class body.
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(ChoiceAndButton,wxPGChoiceAndButtonEditor,wxPGChoiceEditor)
|
||
|
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
wxWindow** psecondary ) const
|
||
|
#else
|
||
|
wxPGWindowPair wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz ) const
|
||
|
#endif
|
||
|
{
|
||
|
// Use one two units smaller to match size of the combo's dropbutton.
|
||
|
// (normally a bigger button is used because it looks better)
|
||
|
int bt_wid = sz.y;
|
||
|
bt_wid -= 2;
|
||
|
wxSize bt_sz(bt_wid,bt_wid);
|
||
|
|
||
|
// Position of button.
|
||
|
wxPoint bt_pos(pos.x+sz.x-bt_sz.x,pos.y);
|
||
|
#ifdef __WXMAC__
|
||
|
bt_pos.y -= 1;
|
||
|
#else
|
||
|
bt_pos.y += 1;
|
||
|
#endif
|
||
|
|
||
|
wxWindow* bt = propGrid->GenerateEditorButton( bt_pos, bt_sz );
|
||
|
|
||
|
// Size of choice.
|
||
|
wxSize ch_sz(sz.x-bt->GetSize().x,sz.y);
|
||
|
|
||
|
#ifdef __WXMAC__
|
||
|
ch_sz.x -= wxPG_TEXTCTRL_AND_BUTTON_SPACING;
|
||
|
#endif
|
||
|
|
||
|
wxWindow* ch = wxPG_EDITOR(Choice)->CreateControls(propGrid,property,
|
||
|
pos,ch_sz
|
||
|
#ifndef __WXPYTHON__
|
||
|
, (wxWindow**)NULL);
|
||
|
#else
|
||
|
).m_primary;
|
||
|
#endif
|
||
|
|
||
|
|
||
|
#ifdef __WXMSW__
|
||
|
bt->Show();
|
||
|
#endif
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
*psecondary = bt;
|
||
|
return ch;
|
||
|
#else
|
||
|
return wxPGWindowPair(ch, bt);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor() { }
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGTextCtrlAndButtonEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
|
||
|
// This simpler implement_editor macro doesn't define class body.
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrlAndButton,wxPGTextCtrlAndButtonEditor,wxPGTextCtrlEditor)
|
||
|
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
wxWindow** psecondary ) const
|
||
|
{
|
||
|
wxWindow* wnd = propGrid->GenerateEditorTextCtrlAndButton( pos, sz, psecondary,
|
||
|
property->GetFlags() & wxPG_PROP_NOEDITOR, property);
|
||
|
|
||
|
return wnd;
|
||
|
}
|
||
|
#else
|
||
|
wxPGWindowPair wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& sz ) const
|
||
|
{
|
||
|
wxWindow* wnd2;
|
||
|
wxWindow* wnd = propGrid->GenerateEditorTextCtrlAndButton( pos, sz, &wnd2,
|
||
|
property->GetFlags() & wxPG_PROP_NOEDITOR, property);
|
||
|
|
||
|
return wxPGWindowPair(wnd, wnd2);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
|
||
|
wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGCheckBoxEditor
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxPG_INCLUDE_CHECKBOX
|
||
|
|
||
|
WX_PG_IMPLEMENT_EDITOR_CLASS(CheckBox,wxPGCheckBoxEditor,wxPGEditor)
|
||
|
|
||
|
|
||
|
// state argument: 0x01 = set if checked
|
||
|
// 0x02 = set if rectangle should be bold
|
||
|
static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei, int state, const wxColour& linecol )
|
||
|
{
|
||
|
|
||
|
// Box rectangle.
|
||
|
wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),box_hei,box_hei);
|
||
|
|
||
|
// Draw check mark first because it is likely to overdraw the
|
||
|
// surrounding rectangle.
|
||
|
if ( state & 1 )
|
||
|
{
|
||
|
wxRect r2(r.x+wxPG_CHECKMARK_XADJ,
|
||
|
r.y+wxPG_CHECKMARK_YADJ,
|
||
|
r.width+wxPG_CHECKMARK_WADJ,
|
||
|
r.height+wxPG_CHECKMARK_HADJ);
|
||
|
#if wxPG_CHECKMARK_DEFLATE
|
||
|
r2.Deflate(wxPG_CHECKMARK_DEFLATE);
|
||
|
#endif
|
||
|
dc.DrawCheckMark(r2);
|
||
|
|
||
|
// This would draw a simple cross check mark.
|
||
|
// dc.DrawLine(r.x,r.y,r.x+r.width-1,r.y+r.height-1);
|
||
|
// dc.DrawLine(r.x,r.y+r.height-1,r.x+r.width-1,r.y);
|
||
|
|
||
|
}
|
||
|
|
||
|
if ( !(state & 2) )
|
||
|
{
|
||
|
// Pen for thin rectangle.
|
||
|
dc.SetPen(linecol);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Pen for bold rectangle.
|
||
|
wxPen linepen(linecol,2,wxSOLID);
|
||
|
linepen.SetJoin(wxJOIN_MITER); // This prevents round edges.
|
||
|
dc.SetPen(linepen);
|
||
|
r.x++;
|
||
|
r.y++;
|
||
|
r.width--;
|
||
|
r.height--;
|
||
|
}
|
||
|
|
||
|
dc.SetBrush(*wxTRANSPARENT_BRUSH);
|
||
|
|
||
|
dc.DrawRectangle(r);
|
||
|
dc.SetPen(*wxTRANSPARENT_PEN);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// Real simple custom-drawn checkbox-without-label class.
|
||
|
//
|
||
|
class wxSimpleCheckBox : public wxControl
|
||
|
{
|
||
|
public:
|
||
|
|
||
|
void SetValue( int value );
|
||
|
|
||
|
wxSimpleCheckBox( wxWindow* parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos = wxDefaultPosition,
|
||
|
const wxSize& size = wxDefaultSize )
|
||
|
: wxControl(parent,id,pos,size,wxNO_BORDER|wxWANTS_CHARS)
|
||
|
{
|
||
|
// Due to SetOwnFont stuff necessary for GTK+ 1.2, we need to have this
|
||
|
SetFont( parent->GetFont() );
|
||
|
|
||
|
m_state = 0;
|
||
|
m_boxHeight = ((wxPropertyGrid*)parent)->GetFontHeight();
|
||
|
SetBackgroundStyle( wxBG_STYLE_COLOUR );
|
||
|
}
|
||
|
|
||
|
virtual ~wxSimpleCheckBox();
|
||
|
|
||
|
virtual bool ProcessEvent(wxEvent& event);
|
||
|
|
||
|
int m_state;
|
||
|
int m_boxHeight;
|
||
|
|
||
|
static wxBitmap* ms_doubleBuffer;
|
||
|
|
||
|
};
|
||
|
|
||
|
wxSimpleCheckBox::~wxSimpleCheckBox()
|
||
|
{
|
||
|
delete ms_doubleBuffer;
|
||
|
ms_doubleBuffer = NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = (wxBitmap*) NULL;
|
||
|
|
||
|
// value = 2 means toggle (sorry, too lazy to do constants)
|
||
|
void wxSimpleCheckBox::SetValue( int value )
|
||
|
{
|
||
|
if ( value > 1 )
|
||
|
{
|
||
|
m_state++;
|
||
|
if ( m_state > 1 ) m_state = 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_state = value;
|
||
|
}
|
||
|
Refresh();
|
||
|
|
||
|
wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());
|
||
|
((wxPropertyGrid*)GetParent())->OnCustomEditorEvent(evt);
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxSimpleCheckBox::ProcessEvent(wxEvent& event)
|
||
|
{
|
||
|
wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent();
|
||
|
|
||
|
if ( event.GetEventType() == wxEVT_NAVIGATION_KEY )
|
||
|
{
|
||
|
//wxLogDebug(wxT("wxEVT_NAVIGATION_KEY"));
|
||
|
//SetFocusFromKbd();
|
||
|
//event.Skip();
|
||
|
//return wxControl::ProcessEvent(event);
|
||
|
}
|
||
|
else
|
||
|
if ( ( (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK)
|
||
|
&& ((wxMouseEvent&)event).m_x > (wxPG_XBEFORETEXT-2)
|
||
|
&& ((wxMouseEvent&)event).m_x <= (wxPG_XBEFORETEXT-2+m_boxHeight) )
|
||
|
)
|
||
|
{
|
||
|
SetValue(2);
|
||
|
return true;
|
||
|
}
|
||
|
else if ( event.GetEventType() == wxEVT_PAINT )
|
||
|
{
|
||
|
wxSize clientSize = GetClientSize();
|
||
|
wxPaintDC dc(this);
|
||
|
|
||
|
/*
|
||
|
// Buffered paint DC doesn't seem to do much good
|
||
|
if ( !ms_doubleBuffer ||
|
||
|
clientSize.x > ms_doubleBuffer->GetWidth() ||
|
||
|
clientSize.y > ms_doubleBuffer->GetHeight() )
|
||
|
{
|
||
|
delete ms_doubleBuffer;
|
||
|
ms_doubleBuffer = new wxBitmap(clientSize.x+25,clientSize.y+25);
|
||
|
}
|
||
|
|
||
|
wxBufferedPaintDC dc(this,*ms_doubleBuffer);
|
||
|
*/
|
||
|
|
||
|
wxRect rect(0,0,clientSize.x,clientSize.y);
|
||
|
rect.x -= 1;
|
||
|
rect.width += 1;
|
||
|
|
||
|
m_boxHeight = propGrid->GetFontHeight();
|
||
|
|
||
|
wxColour bgcol = GetBackgroundColour();
|
||
|
dc.SetBrush( bgcol );
|
||
|
dc.SetPen( bgcol );
|
||
|
dc.DrawRectangle( rect );
|
||
|
|
||
|
wxColour txcol = GetForegroundColour();
|
||
|
|
||
|
int state = m_state;
|
||
|
if ( m_font.GetWeight() == wxBOLD )
|
||
|
state |= 2;
|
||
|
|
||
|
DrawSimpleCheckBox(dc,rect,m_boxHeight,state,txcol);
|
||
|
|
||
|
// If focused, indicate it somehow.
|
||
|
/*
|
||
|
if ( wxWindow::FindFocus() == this )
|
||
|
{
|
||
|
rect.x += 1;
|
||
|
rect.width -= 1;
|
||
|
|
||
|
wxPGDrawFocusRect(dc,rect);
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
else if ( event.GetEventType() == wxEVT_SIZE ||
|
||
|
event.GetEventType() == wxEVT_SET_FOCUS ||
|
||
|
event.GetEventType() == wxEVT_KILL_FOCUS
|
||
|
)
|
||
|
{
|
||
|
Refresh();
|
||
|
}
|
||
|
else if ( event.GetEventType() == wxEVT_KEY_DOWN )
|
||
|
{
|
||
|
wxKeyEvent& keyEv = (wxKeyEvent&) event;
|
||
|
|
||
|
if ( keyEv.GetKeyCode() == WXK_TAB )
|
||
|
{
|
||
|
propGrid->SendNavigationKeyEvent( keyEv.ShiftDown()?0:1 );
|
||
|
return true;
|
||
|
}
|
||
|
else
|
||
|
if ( keyEv.GetKeyCode() == WXK_SPACE )
|
||
|
{
|
||
|
SetValue(2);
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return wxControl::ProcessEvent(event);
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
wxWindow* wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& size,
|
||
|
wxWindow** ) const
|
||
|
#else
|
||
|
wxPGWindowPair wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
|
||
|
wxPGProperty* property,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& size ) const
|
||
|
#endif
|
||
|
{
|
||
|
wxPoint pt = pos;
|
||
|
pt.x -= wxPG_XBEFOREWIDGET;
|
||
|
wxSize sz = size;
|
||
|
sz.x += wxPG_XBEFOREWIDGET;
|
||
|
|
||
|
wxSimpleCheckBox* cb = new wxSimpleCheckBox(propGrid,wxPG_SUBID1,pt,sz);
|
||
|
|
||
|
cb->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
|
||
|
|
||
|
cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DOWN,
|
||
|
(wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
|
||
|
&wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
|
||
|
|
||
|
cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DCLICK,
|
||
|
(wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
|
||
|
&wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
|
||
|
|
||
|
if ( property->GetChoiceInfo((wxPGChoiceInfo*)NULL) &&
|
||
|
!(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
cb->m_state = 1;
|
||
|
|
||
|
// If mouse cursor was on the item, toggle the value now.
|
||
|
if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )
|
||
|
{
|
||
|
wxPoint pt = propGrid->ScreenToClient(::wxGetMousePosition());
|
||
|
if ( pt.x <= (cb->GetPosition().x+wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
|
||
|
{
|
||
|
cb->m_state++;
|
||
|
|
||
|
if ( cb->m_state > 1 )
|
||
|
cb->m_state = 0;
|
||
|
|
||
|
property->ClearFlag(wxPG_PROP_UNSPECIFIED);
|
||
|
property->SetValueFromInt(cb->m_state,0);
|
||
|
propGrid->PropertyWasModified(property);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return cb;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGCheckBoxEditor::DrawValue( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const
|
||
|
{
|
||
|
int state = 0;
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
{
|
||
|
state = property->GetChoiceInfo((wxPGChoiceInfo*)NULL);
|
||
|
if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
|
||
|
}
|
||
|
DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxASSERT( ctrl );
|
||
|
((wxSimpleCheckBox*)ctrl)->m_state = property->GetChoiceInfo((wxPGChoiceInfo*)NULL);
|
||
|
ctrl->Refresh();
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGCheckBoxEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
|
||
|
wxWindow* WXUNUSED(ctrl), wxEvent& event ) const
|
||
|
{
|
||
|
if ( event.GetEventType() == wxEVT_COMMAND_CHECKBOX_CLICKED )
|
||
|
{
|
||
|
/*if ( CopyValueFromControl( property, ctrl ) )
|
||
|
return true;
|
||
|
|
||
|
propGrid->EditorsValueWasNotModified();
|
||
|
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(property);*/
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
bool wxPGCheckBoxEditor::CopyValueFromControl( wxPGProperty* property, wxWindow* ctrl ) const
|
||
|
{
|
||
|
wxSimpleCheckBox* cb = (wxSimpleCheckBox*)ctrl;
|
||
|
|
||
|
int index = cb->m_state;
|
||
|
|
||
|
if ( index != property->GetChoiceInfo( (wxPGChoiceInfo*) NULL ) ||
|
||
|
// Changing unspecified always causes event (returning
|
||
|
// true here should be enough to trigger it).
|
||
|
property->IsFlagSet(wxPG_PROP_UNSPECIFIED)
|
||
|
)
|
||
|
{
|
||
|
property->SetValueFromInt(index,0);
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGCheckBoxEditor::SetControlIntValue( wxWindow* ctrl, int value ) const
|
||
|
{
|
||
|
if ( value != 0 ) value = 1;
|
||
|
((wxSimpleCheckBox*)ctrl)->m_state = value;
|
||
|
ctrl->Refresh();
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPGCheckBoxEditor::SetValueToUnspecified( wxWindow* ctrl ) const
|
||
|
{
|
||
|
((wxSimpleCheckBox*)ctrl)->m_state = 0;
|
||
|
ctrl->Refresh();
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGCheckBoxEditor::~wxPGCheckBoxEditor() { }
|
||
|
|
||
|
|
||
|
#endif // wxPG_INCLUDE_CHECKBOX
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGBrush
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
//
|
||
|
// This class is a wxBrush derivative used in the background colour
|
||
|
// brush cache. It adds wxPG-type colour-in-long to the class.
|
||
|
// JMS: Yes I know wxBrush doesn't actually hold the value (refcounted
|
||
|
// object does), but this is simpler implementation and equally
|
||
|
// effective.
|
||
|
//
|
||
|
|
||
|
class wxPGBrush : public wxBrush
|
||
|
{
|
||
|
public:
|
||
|
wxPGBrush( const wxColour& colour );
|
||
|
wxPGBrush();
|
||
|
virtual ~wxPGBrush() { }
|
||
|
void SetColour2( const wxColour& colour );
|
||
|
inline long GetColourAsLong() const { return m_colAsLong; }
|
||
|
private:
|
||
|
long m_colAsLong;
|
||
|
};
|
||
|
|
||
|
|
||
|
void wxPGBrush::SetColour2( const wxColour& colour )
|
||
|
{
|
||
|
wxBrush::SetColour(colour);
|
||
|
m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGBrush::wxPGBrush() : wxBrush()
|
||
|
{
|
||
|
m_colAsLong = 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGBrush::wxPGBrush( const wxColour& colour ) : wxBrush(colour)
|
||
|
{
|
||
|
m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGColour
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
//
|
||
|
// Same as wxPGBrush, but for wxColour instead.
|
||
|
//
|
||
|
|
||
|
class wxPGColour : public wxColour
|
||
|
{
|
||
|
public:
|
||
|
wxPGColour( const wxColour& colour );
|
||
|
wxPGColour();
|
||
|
virtual ~wxPGColour() { }
|
||
|
void SetColour2( const wxColour& colour );
|
||
|
inline long GetColourAsLong() const { return m_colAsLong; }
|
||
|
private:
|
||
|
long m_colAsLong;
|
||
|
};
|
||
|
|
||
|
|
||
|
void wxPGColour::SetColour2( const wxColour& colour )
|
||
|
{
|
||
|
*this = colour;
|
||
|
m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGColour::wxPGColour() : wxColour()
|
||
|
{
|
||
|
m_colAsLong = 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
wxPGColour::wxPGColour( const wxColour& colour ) : wxColour(colour)
|
||
|
{
|
||
|
m_colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGTLWHandler
|
||
|
// Intercepts Close-events sent to wxPropertyGrid's top-level parent,
|
||
|
// and tries to commit property value.
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
class wxPGTLWHandler : public wxEvtHandler
|
||
|
{
|
||
|
public:
|
||
|
|
||
|
wxPGTLWHandler( wxPropertyGrid* pg )
|
||
|
: wxEvtHandler()
|
||
|
{
|
||
|
m_pg = pg;
|
||
|
}
|
||
|
|
||
|
protected:
|
||
|
|
||
|
void OnClose( wxCloseEvent& event )
|
||
|
{
|
||
|
// ClearSelection forces value validation/commit.
|
||
|
if ( event.CanVeto() && !m_pg->ClearSelection() )
|
||
|
{
|
||
|
event.Veto();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
private:
|
||
|
wxPropertyGrid* m_pg;
|
||
|
|
||
|
DECLARE_EVENT_TABLE()
|
||
|
};
|
||
|
|
||
|
BEGIN_EVENT_TABLE(wxPGTLWHandler, wxEvtHandler)
|
||
|
EVT_CLOSE(wxPGTLWHandler::OnClose)
|
||
|
END_EVENT_TABLE()
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
IMPLEMENT_CLASS(wxPropertyGrid, wxScrolledWindow)
|
||
|
|
||
|
BEGIN_EVENT_TABLE(wxPropertyGrid, wxScrolledWindow)
|
||
|
EVT_MOTION(wxPropertyGrid::OnMouseMove)
|
||
|
EVT_IDLE(wxPropertyGrid::OnIdle)
|
||
|
EVT_LEFT_DOWN(wxPropertyGrid::OnMouseClick)
|
||
|
EVT_LEFT_UP(wxPropertyGrid::OnMouseUp)
|
||
|
EVT_RIGHT_UP(wxPropertyGrid::OnMouseRightClick)
|
||
|
EVT_LEFT_DCLICK(wxPropertyGrid::OnMouseDoubleClick)
|
||
|
EVT_PAINT(wxPropertyGrid::OnPaint)
|
||
|
EVT_SIZE(wxPropertyGrid::OnResize)
|
||
|
EVT_KEY_DOWN(wxPropertyGrid::OnKey)
|
||
|
EVT_KEY_UP(wxPropertyGrid::OnKeyUp)
|
||
|
EVT_CHAR(wxPropertyGrid::OnKey)
|
||
|
EVT_ENTER_WINDOW(wxPropertyGrid::OnMouseEntry)
|
||
|
EVT_LEAVE_WINDOW(wxPropertyGrid::OnMouseEntry)
|
||
|
EVT_MOUSE_CAPTURE_CHANGED(wxPropertyGrid::OnCaptureChange)
|
||
|
EVT_SCROLLWIN(wxPropertyGrid::OnScrollEvent)
|
||
|
EVT_NAVIGATION_KEY(wxPropertyGrid::OnNavigationKey)
|
||
|
EVT_TEXT(wxPG_SUBID1,wxPropertyGrid::OnCustomEditorEvent)
|
||
|
EVT_COMBOBOX(wxPG_SUBID1,wxPropertyGrid::OnCustomEditorEvent)
|
||
|
EVT_BUTTON(wxPG_SUBID2,wxPropertyGrid::OnCustomEditorEvent)
|
||
|
EVT_CHILD_FOCUS(wxPropertyGrid::OnChildFocusEvent)
|
||
|
EVT_SET_FOCUS(wxPropertyGrid::OnFocusEvent)
|
||
|
EVT_KILL_FOCUS(wxPropertyGrid::OnFocusEvent)
|
||
|
EVT_TEXT_ENTER(wxPG_SUBID1,wxPropertyGrid::OnCustomEditorEvent)
|
||
|
EVT_SYS_COLOUR_CHANGED(wxPropertyGrid::OnSysColourChanged)
|
||
|
END_EVENT_TABLE()
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGrid::wxPropertyGrid()
|
||
|
: wxScrolledWindow()
|
||
|
{
|
||
|
Init1();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGrid::wxPropertyGrid( wxWindow *parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& size,
|
||
|
long style,
|
||
|
const wxChar* name )
|
||
|
: wxScrolledWindow()
|
||
|
{
|
||
|
Init1();
|
||
|
Create(parent,id,pos,size,style,name);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::Create( wxWindow *parent,
|
||
|
wxWindowID id,
|
||
|
const wxPoint& pos,
|
||
|
const wxSize& size,
|
||
|
long style,
|
||
|
const wxChar* name )
|
||
|
{
|
||
|
|
||
|
if ( !(style&wxBORDER_MASK) )
|
||
|
style |= wxSIMPLE_BORDER;
|
||
|
|
||
|
style |= wxVSCROLL;
|
||
|
|
||
|
#ifdef __WXMSW__
|
||
|
// This prevents crash under Win2K, but still
|
||
|
// enables keyboard navigation
|
||
|
if ( style & wxTAB_TRAVERSAL )
|
||
|
{
|
||
|
style &= ~(wxTAB_TRAVERSAL);
|
||
|
style |= wxWANTS_CHARS;
|
||
|
}
|
||
|
#else
|
||
|
if ( style & wxTAB_TRAVERSAL )
|
||
|
style |= wxWANTS_CHARS;
|
||
|
#endif
|
||
|
|
||
|
wxScrolledWindow::Create(parent,id,pos,size,style,name);
|
||
|
|
||
|
Init2();
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
static void wxPGRegisterStandardPropertyClasses();
|
||
|
|
||
|
//
|
||
|
// Initialize values to defaults
|
||
|
//
|
||
|
void wxPropertyGrid::Init1()
|
||
|
{
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
#if !wxPG_USE_WXMODULE
|
||
|
if ( !wxPGGlobalVars )
|
||
|
wxPGGlobalVars = new wxPGGlobalVarsClass();
|
||
|
#endif
|
||
|
|
||
|
// Register type classes, if necessary.
|
||
|
if ( wxPGGlobalVars->m_dictValueType.empty() )
|
||
|
RegisterDefaultValues();
|
||
|
|
||
|
// Register editor classes, if necessary.
|
||
|
if ( wxPGGlobalVars->m_mapEditorClasses.empty() )
|
||
|
RegisterDefaultEditors();
|
||
|
|
||
|
// Register property classes, if necessary
|
||
|
if ( wxPGGlobalVars->m_dictPropertyClassInfo.empty() )
|
||
|
wxPGRegisterStandardPropertyClasses();
|
||
|
|
||
|
m_iFlags = 0;
|
||
|
m_pState = (wxPropertyGridState*) NULL;
|
||
|
m_wndPrimary = m_wndSecondary = (wxWindow*) NULL;
|
||
|
m_selected = (wxPGProperty*) NULL;
|
||
|
m_propHover = (wxPGProperty*) NULL;
|
||
|
m_eventObject = this;
|
||
|
m_curFocused = (wxWindow*) NULL;
|
||
|
m_tlwHandler = NULL;
|
||
|
m_processingEvent = 0;
|
||
|
m_dragStatus = 0;
|
||
|
m_mouseSide = 16;
|
||
|
m_editorFocused = 0;
|
||
|
m_coloursCustomized = 0;
|
||
|
m_frozen = 0;
|
||
|
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
m_doubleBuffer = (wxBitmap*) NULL;
|
||
|
#endif
|
||
|
|
||
|
m_windowsToDelete = NULL;
|
||
|
|
||
|
#ifndef wxPG_ICON_WIDTH
|
||
|
m_expandbmp = NULL;
|
||
|
m_collbmp = NULL;
|
||
|
m_iconWidth = 11;
|
||
|
m_iconHeight = 11;
|
||
|
#else
|
||
|
m_iconWidth = wxPG_ICON_WIDTH;
|
||
|
#endif
|
||
|
|
||
|
m_prevVY = -1;
|
||
|
|
||
|
m_calcVisHeight = 0;
|
||
|
|
||
|
m_gutterWidth = wxPG_GUTTER_MIN;
|
||
|
m_subgroup_extramargin = 10;
|
||
|
|
||
|
m_lineHeight = 0;
|
||
|
|
||
|
m_width = m_height = m_fWidth = 0;
|
||
|
|
||
|
m_bottomy = 0;
|
||
|
|
||
|
m_splitterx = wxPG_DEFAULT_SPLITTERX;
|
||
|
m_fSplitterX = (float) wxPG_DEFAULT_SPLITTERX;
|
||
|
|
||
|
#if !wxPG_HEAVY_GFX
|
||
|
m_splitterpen.SetColour( *wxBLACK );
|
||
|
m_splitterpen.SetWidth( 4 );
|
||
|
|
||
|
m_splitterprevdrawnx = -1;
|
||
|
#endif
|
||
|
|
||
|
SetButtonShortcut(0);
|
||
|
|
||
|
m_keyComboConsumed = 0;
|
||
|
|
||
|
m_ignoredEvents = 0;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
//
|
||
|
// Initialize after parent etc. set
|
||
|
//
|
||
|
void wxPropertyGrid::Init2()
|
||
|
{
|
||
|
wxASSERT( !(m_iFlags & wxPG_FL_INITIALIZED ) );
|
||
|
|
||
|
#ifdef __WXMAC__
|
||
|
// Smaller controls on Mac
|
||
|
SetWindowVariant(wxWINDOW_VARIANT_SMALL);
|
||
|
#endif
|
||
|
|
||
|
// Now create state, if one didn't exist already
|
||
|
// (wxPropertyGridManager might have created it for us).
|
||
|
if ( !m_pState )
|
||
|
{
|
||
|
m_pState = CreateState();
|
||
|
m_pState->m_pPropGrid = this;
|
||
|
m_iFlags |= wxPG_FL_CREATEDSTATE;
|
||
|
}
|
||
|
|
||
|
if ( !(m_windowStyle & wxPG_SPLITTER_AUTO_CENTER) )
|
||
|
m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
|
||
|
if ( m_windowStyle & wxPG_HIDE_CATEGORIES )
|
||
|
{
|
||
|
m_pState->InitNonCatMode();
|
||
|
|
||
|
FROM_STATE(m_properties) = FROM_STATE(m_abcArray);
|
||
|
}
|
||
|
|
||
|
GetClientSize(&m_width,&m_height);
|
||
|
|
||
|
#if !wxPG_HEAVY_GFX
|
||
|
m_splitterpen.SetColour( *wxBLACK );
|
||
|
m_splitterpen.SetWidth( 4 );
|
||
|
#endif
|
||
|
|
||
|
#ifndef wxPG_ICON_WIDTH
|
||
|
// create two bitmap nodes for drawing
|
||
|
m_expandbmp = new wxBitmap(expand_xpm);
|
||
|
m_collbmp = new wxBitmap(collapse_xpm);
|
||
|
|
||
|
// calculate average font height for bitmap centering
|
||
|
|
||
|
m_iconWidth = m_expandbmp->GetWidth();
|
||
|
m_iconHeight = m_expandbmp->GetHeight();
|
||
|
#endif
|
||
|
|
||
|
m_curcursor = wxCURSOR_ARROW;
|
||
|
m_cursorSizeWE = new wxCursor( wxCURSOR_SIZEWE );
|
||
|
|
||
|
// adjust bitmap icon y position so they are centered
|
||
|
m_vspacing = wxPG_DEFAULT_VSPACING;
|
||
|
|
||
|
if ( !m_font.Ok() )
|
||
|
{
|
||
|
wxFont useFont = wxScrolledWindow::GetFont();
|
||
|
wxScrolledWindow::SetOwnFont( useFont );
|
||
|
}
|
||
|
else
|
||
|
// This should be otherwise called by SetOwnFont
|
||
|
CalculateFontAndBitmapStuff( wxPG_DEFAULT_VSPACING );
|
||
|
|
||
|
// Add base brush item
|
||
|
m_arrBgBrushes.Add((void*)new wxPGBrush());
|
||
|
|
||
|
// Add base colour items
|
||
|
m_arrFgCols.Add((void*)new wxPGColour());
|
||
|
m_arrFgCols.Add((void*)new wxPGColour());
|
||
|
|
||
|
RegainColours();
|
||
|
|
||
|
// This helps with flicker
|
||
|
SetBackgroundStyle( wxBG_STYLE_CUSTOM );
|
||
|
|
||
|
// Hook the TLW
|
||
|
wxPGTLWHandler* handler = new wxPGTLWHandler(this);
|
||
|
m_tlp = ::wxGetTopLevelParent(this);
|
||
|
m_tlwHandler = handler;
|
||
|
m_tlp->PushEventHandler(handler);
|
||
|
|
||
|
// set virtual size to this window size
|
||
|
wxSize wndsize = GetSize();
|
||
|
SetVirtualSize(wndsize.GetWidth(), wndsize.GetWidth());
|
||
|
|
||
|
m_timeCreated = ::wxGetLocalTimeMillis();
|
||
|
|
||
|
m_iFlags |= wxPG_FL_INITIALIZED;
|
||
|
|
||
|
// Need to call OnResize handler or size given in constructor/Create
|
||
|
// will never work.
|
||
|
wxSizeEvent sizeEvent(wndsize,0);
|
||
|
OnResize(sizeEvent);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGrid::~wxPropertyGrid()
|
||
|
{
|
||
|
size_t i;
|
||
|
|
||
|
DoSelectProperty(NULL);
|
||
|
|
||
|
// This should do prevent things from going too badly wrong
|
||
|
m_iFlags &= ~(wxPG_FL_INITIALIZED);
|
||
|
|
||
|
END_MOUSE_CAPTURE
|
||
|
|
||
|
wxPGTLWHandler* handler = (wxPGTLWHandler*) m_tlwHandler;
|
||
|
m_tlp->RemoveEventHandler(handler);
|
||
|
delete handler;
|
||
|
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( IsEditorsValueModified() )
|
||
|
::wxMessageBox(wxT("Most recent change in property editor was lost!!!\n\n(if you don't want this to happen, close your frames and dialogs using Close(false).)"),
|
||
|
wxT("wxPropertyGrid Debug Warning") );
|
||
|
#endif
|
||
|
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
if ( m_doubleBuffer )
|
||
|
delete m_doubleBuffer;
|
||
|
#endif
|
||
|
|
||
|
delete m_windowsToDelete;
|
||
|
|
||
|
m_selected = (wxPGProperty*) NULL;
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_CREATEDSTATE )
|
||
|
delete m_pState;
|
||
|
|
||
|
delete m_cursorSizeWE;
|
||
|
|
||
|
#ifndef wxPG_ICON_WIDTH
|
||
|
delete m_expandbmp;
|
||
|
delete m_collbmp;
|
||
|
#endif
|
||
|
|
||
|
// Delete cached text colours.
|
||
|
for ( i=0; i<m_arrFgCols.GetCount(); i++ )
|
||
|
{
|
||
|
delete (wxPGColour*)m_arrFgCols.Item(i);
|
||
|
}
|
||
|
|
||
|
// Delete cached brushes.
|
||
|
for ( i=0; i<m_arrBgBrushes.GetCount(); i++ )
|
||
|
{
|
||
|
delete (wxPGBrush*)m_arrBgBrushes.Item(i);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::Destroy()
|
||
|
{
|
||
|
END_MOUSE_CAPTURE
|
||
|
return wxScrolledWindow::Destroy();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridState* wxPropertyGrid::CreateState() const
|
||
|
{
|
||
|
return new wxPropertyGridState();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid overridden wxWindow methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetWindowStyleFlag( long style )
|
||
|
{
|
||
|
long old_style = m_windowStyle;
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_INITIALIZED )
|
||
|
{
|
||
|
wxASSERT( m_pState );
|
||
|
|
||
|
if ( !(style & wxPG_HIDE_CATEGORIES) && (old_style & wxPG_HIDE_CATEGORIES) )
|
||
|
{
|
||
|
// Enable categories
|
||
|
EnableCategories( true );
|
||
|
}
|
||
|
else if ( (style & wxPG_HIDE_CATEGORIES) && !(old_style & wxPG_HIDE_CATEGORIES) )
|
||
|
{
|
||
|
// Disable categories
|
||
|
EnableCategories( false );
|
||
|
}
|
||
|
if ( !(old_style & wxPG_AUTO_SORT) && (style & wxPG_AUTO_SORT) )
|
||
|
{
|
||
|
//
|
||
|
// Autosort enabled
|
||
|
//
|
||
|
if ( !m_frozen )
|
||
|
PrepareAfterItemsAdded();
|
||
|
else
|
||
|
FROM_STATE(m_itemsAdded) = 1;
|
||
|
}
|
||
|
#if wxPG_SUPPORT_TOOLTIPS
|
||
|
if ( !(old_style & wxPG_TOOLTIPS) && (style & wxPG_TOOLTIPS) )
|
||
|
{
|
||
|
//
|
||
|
// Tooltips enabled
|
||
|
//
|
||
|
/*wxToolTip* tooltip = new wxToolTip ( wxEmptyString );
|
||
|
SetToolTip ( tooltip );
|
||
|
tooltip->SetDelay ( wxPG_TOOLTIP_DELAY );*/
|
||
|
}
|
||
|
else if ( (old_style & wxPG_TOOLTIPS) && !(style & wxPG_TOOLTIPS) )
|
||
|
{
|
||
|
//
|
||
|
// Tooltips disabled
|
||
|
//
|
||
|
wxScrolledWindow::SetToolTip ( (wxToolTip*) NULL );
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
wxScrolledWindow::SetWindowStyleFlag ( style );
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_INITIALIZED )
|
||
|
{
|
||
|
if ( (old_style & wxPG_HIDE_MARGIN) != (style & wxPG_HIDE_MARGIN) )
|
||
|
{
|
||
|
CalculateFontAndBitmapStuff( m_vspacing );
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Freeze()
|
||
|
{
|
||
|
m_frozen++;
|
||
|
wxScrolledWindow::Freeze();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Thaw()
|
||
|
{
|
||
|
m_frozen--;
|
||
|
wxScrolledWindow::Thaw();
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
Refresh();
|
||
|
#endif
|
||
|
|
||
|
// Force property re-selection
|
||
|
if ( m_selected )
|
||
|
DoSelectProperty(m_selected, wxPG_SEL_FORCE);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetExtraStyle( long exStyle )
|
||
|
{
|
||
|
if ( exStyle & wxPG_EX_NATIVE_DOUBLE_BUFFERING )
|
||
|
{
|
||
|
#if defined(__WXMSW__)
|
||
|
|
||
|
/*
|
||
|
// Don't use WS_EX_COMPOSITED just now.
|
||
|
HWND hWnd;
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_IN_MANAGER )
|
||
|
hWnd = (HWND)GetParent()->GetHWND();
|
||
|
else
|
||
|
hWnd = (HWND)GetHWND();
|
||
|
|
||
|
::SetWindowLong( hWnd, GWL_EXSTYLE,
|
||
|
::GetWindowLong(hWnd, GWL_EXSTYLE) | WS_EX_COMPOSITED );
|
||
|
*/
|
||
|
|
||
|
//#elif defined(__WXGTK20__)
|
||
|
#endif
|
||
|
// Only apply wxPG_EX_NATIVE_DOUBLE_BUFFERING if the window
|
||
|
// truly was double-buffered.
|
||
|
if ( !wxPGIsWindowBuffered(this) )
|
||
|
{
|
||
|
exStyle &= ~(wxPG_EX_NATIVE_DOUBLE_BUFFERING);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
delete m_doubleBuffer;
|
||
|
m_doubleBuffer = NULL;
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
wxScrolledWindow::SetExtraStyle( exStyle );
|
||
|
|
||
|
if ( exStyle & wxPG_EX_INIT_NOCAT )
|
||
|
m_pState->InitNonCatMode ();
|
||
|
|
||
|
if ( exStyle & wxPG_EX_HELP_AS_TOOLTIPS )
|
||
|
m_windowStyle |= wxPG_TOOLTIPS;
|
||
|
|
||
|
if ( exStyle & wxPG_EX_AUTO_UNSPECIFIED_VALUES )
|
||
|
{
|
||
|
wxPGGlobalVars->m_numBoolChoices = 3;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
wxPGGlobalVars->m_numBoolChoices = 2;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// returns the best acceptable minimal size
|
||
|
wxSize wxPropertyGrid::DoGetBestSize() const
|
||
|
{
|
||
|
int hei = 15;
|
||
|
if ( m_lineHeight > hei )
|
||
|
hei = m_lineHeight;
|
||
|
wxSize sz = wxSize( 60, hei+40 );
|
||
|
|
||
|
CacheBestSize(sz);
|
||
|
return sz;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid Font and Colour Methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::CalculateFontAndBitmapStuff( int vspacing )
|
||
|
{
|
||
|
int x = 0, y = 0;
|
||
|
|
||
|
m_captionFont = GetFont();
|
||
|
|
||
|
GetTextExtent(wxT("jG"), &x, &y, 0, 0, &m_captionFont);
|
||
|
m_subgroup_extramargin = x + (x/2);
|
||
|
m_fontHeight = y;
|
||
|
|
||
|
#if wxPG_USE_RENDERER_NATIVE
|
||
|
m_iconWidth = wxPG_ICON_WIDTH;
|
||
|
#elif wxPG_ICON_WIDTH
|
||
|
// scale icon
|
||
|
m_iconWidth = (m_fontHeight * wxPG_ICON_WIDTH) / 13;
|
||
|
if ( m_iconWidth < 5 ) m_iconWidth = 5;
|
||
|
else if ( !(m_iconWidth & 0x01) ) m_iconWidth++; // must be odd
|
||
|
|
||
|
#endif
|
||
|
|
||
|
m_gutterWidth = m_iconWidth / wxPG_GUTTER_DIV;
|
||
|
if ( m_gutterWidth < wxPG_GUTTER_MIN )
|
||
|
m_gutterWidth = wxPG_GUTTER_MIN;
|
||
|
|
||
|
int vdiv = 6;
|
||
|
if ( vspacing <= 1 ) vdiv = 12;
|
||
|
else if ( vspacing >= 3 ) vdiv = 3;
|
||
|
|
||
|
m_spacingy = m_fontHeight / vdiv;
|
||
|
if ( m_spacingy < wxPG_YSPACING_MIN )
|
||
|
m_spacingy = wxPG_YSPACING_MIN;
|
||
|
|
||
|
m_marginWidth = 0;
|
||
|
if ( !(m_windowStyle & wxPG_HIDE_MARGIN) )
|
||
|
m_marginWidth = m_gutterWidth*2 + m_iconWidth;
|
||
|
|
||
|
m_captionFont.SetWeight(wxBOLD);
|
||
|
GetTextExtent(wxT("jG"), &x, &y, 0, 0, &m_captionFont);
|
||
|
|
||
|
m_lineHeight = m_fontHeight+(2*m_spacingy)+1;
|
||
|
|
||
|
// button spacing
|
||
|
m_buttonSpacingY = (m_lineHeight - m_iconHeight) / 2;
|
||
|
if ( m_buttonSpacingY < 0 ) m_buttonSpacingY = 0;
|
||
|
|
||
|
InvalidateBestSize();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnSysColourChanged( wxSysColourChangedEvent &WXUNUSED(event) )
|
||
|
{
|
||
|
RegainColours();
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
static wxColour wxPGAdjustColour(const wxColour& src, int ra,
|
||
|
int ga = 1000, int ba = 1000,
|
||
|
bool forceDifferent = false)
|
||
|
{
|
||
|
if ( ga >= 1000 )
|
||
|
ga = ra;
|
||
|
if ( ba >= 1000 )
|
||
|
ba = ra;
|
||
|
|
||
|
// Recursion guard (allow 2 max)
|
||
|
static int isinside = 0;
|
||
|
isinside++;
|
||
|
wxCHECK_MSG( isinside < 3,
|
||
|
*wxBLACK,
|
||
|
wxT("wxPGAdjustColour should not be recursively called more than once") );
|
||
|
|
||
|
wxColour dst;
|
||
|
|
||
|
int r = src.Red();
|
||
|
int g = src.Green();
|
||
|
int b = src.Blue();
|
||
|
int r2 = r + ra;
|
||
|
if ( r2>255 ) r2 = 255;
|
||
|
else if ( r2<0) r2 = 0;
|
||
|
int g2 = g + ga;
|
||
|
if ( g2>255 ) g2 = 255;
|
||
|
else if ( g2<0) g2 = 0;
|
||
|
int b2 = b + ba;
|
||
|
if ( b2>255 ) b2 = 255;
|
||
|
else if ( b2<0) b2 = 0;
|
||
|
|
||
|
// Make sure they are somewhat different
|
||
|
if ( forceDifferent && (abs((r+g+b)-(r2+g2+b2)) < abs(ra/2)) )
|
||
|
dst = wxPGAdjustColour(src,-(ra*2));
|
||
|
else
|
||
|
dst = wxColour(r2,g2,b2);
|
||
|
|
||
|
// Recursion guard (allow 2 max)
|
||
|
isinside--;
|
||
|
|
||
|
return dst;
|
||
|
}
|
||
|
|
||
|
|
||
|
static int wxPGGetColAvg( const wxColour& col )
|
||
|
{
|
||
|
return (col.Red() + col.Green() + col.Blue()) / 3;
|
||
|
}
|
||
|
|
||
|
|
||
|
void wxPropertyGrid::RegainColours()
|
||
|
{
|
||
|
wxColour def_bgcol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0002) )
|
||
|
{
|
||
|
wxColour col = wxSystemSettings::GetColour( wxSYS_COLOUR_BTNFACE );
|
||
|
|
||
|
// Make sure colour is dark enough
|
||
|
#ifdef __WXGTK__
|
||
|
int colDec = wxPGGetColAvg(col) - 230;
|
||
|
#else
|
||
|
int colDec = wxPGGetColAvg(col) - 200;
|
||
|
#endif
|
||
|
if ( colDec > 0 )
|
||
|
m_colCapBack = wxPGAdjustColour(col,-colDec);
|
||
|
else
|
||
|
m_colCapBack = col;
|
||
|
}
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0001) )
|
||
|
m_colMargin = m_colCapBack;
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0004) )
|
||
|
{
|
||
|
#ifdef __WXGTK__
|
||
|
int colDec = -90;
|
||
|
#else
|
||
|
int colDec = -72;
|
||
|
#endif
|
||
|
wxColour capForeCol = wxPGAdjustColour(m_colCapBack,colDec,5000,5000,true);
|
||
|
m_colCapFore = capForeCol;
|
||
|
|
||
|
// Set the cached colour as well.
|
||
|
((wxPGColour*)m_arrFgCols.Item(1))->SetColour2(capForeCol);
|
||
|
}
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0008) )
|
||
|
{
|
||
|
wxColour bgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW );
|
||
|
m_colPropBack = bgCol;
|
||
|
|
||
|
// Set the cached brush as well.
|
||
|
((wxPGBrush*)m_arrBgBrushes.Item(0))->SetColour2(bgCol);
|
||
|
}
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0010) )
|
||
|
{
|
||
|
wxColour fgCol = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
|
||
|
m_colPropFore = fgCol;
|
||
|
|
||
|
// Set the cached colour as well.
|
||
|
((wxPGColour*)m_arrFgCols.Item(0))->SetColour2(fgCol);
|
||
|
}
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0020) )
|
||
|
m_colSelBack = wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHT );
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0040) )
|
||
|
m_colSelFore = wxSystemSettings::GetColour( wxSYS_COLOUR_HIGHLIGHTTEXT );
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0080) )
|
||
|
m_colLine = m_colCapBack;
|
||
|
|
||
|
if ( !(m_coloursCustomized & 0x0100) )
|
||
|
m_colDisPropFore = m_colCapFore;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::ResetColours()
|
||
|
{
|
||
|
m_coloursCustomized = 0;
|
||
|
|
||
|
RegainColours();
|
||
|
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::SetFont( const wxFont& font )
|
||
|
{
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::SetFont") );
|
||
|
#endif
|
||
|
|
||
|
// Must disable active editor.
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
bool selRes = ClearSelection();
|
||
|
wxPG_CHECK_MSG_DBG( selRes,
|
||
|
false,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
// TODO: Following code is disabled with wxMac because
|
||
|
// it is reported to fail. I (JMS) cannot debug it
|
||
|
// personally right now.
|
||
|
#if !defined(__WXMAC__)
|
||
|
bool res = wxScrolledWindow::SetFont( font );
|
||
|
if ( res )
|
||
|
{
|
||
|
|
||
|
CalculateFontAndBitmapStuff( m_vspacing );
|
||
|
|
||
|
if ( m_pState )
|
||
|
{
|
||
|
// Recalculate caption text extents.
|
||
|
// TODO: This should also be done to other pages of manager
|
||
|
// (so add wxPropertyGridManager::SetFont), but since font
|
||
|
// is usually set before categories are added, this is
|
||
|
// quite low priority.
|
||
|
size_t i;
|
||
|
|
||
|
for ( i=0;i<FROM_STATE(m_regularArray).GetCount();i++ )
|
||
|
{
|
||
|
wxPGProperty* p = FROM_STATE(m_regularArray).Item(i);
|
||
|
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
((wxPropertyCategoryClass*)p)->CalculateTextExtent(this,m_captionFont);
|
||
|
}
|
||
|
|
||
|
CalculateYs(NULL,-1);
|
||
|
}
|
||
|
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
return res;
|
||
|
#else
|
||
|
// ** wxMAC Only **
|
||
|
// TODO: Remove after SetFont crash fixed.
|
||
|
if ( m_iFlags & wxPG_FL_INITIALIZED )
|
||
|
{
|
||
|
wxLogDebug(wxT("WARNING: propGrid.cpp: wxPropertyGrid::SetFont has been disabled on wxMac since there has been crash reported in it. If you are willing to debug the cause, replace line '#if !defined(__WXMAC__)' with line '#if 1' in wxPropertyGrid::SetFont."));
|
||
|
}
|
||
|
return false;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetLineColour( const wxColour& col )
|
||
|
{
|
||
|
m_colLine = col;
|
||
|
m_coloursCustomized |= 0x80;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetMarginColour( const wxColour& col )
|
||
|
{
|
||
|
m_colMargin = col;
|
||
|
m_coloursCustomized |= 0x01;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCellBackgroundColour( const wxColour& col )
|
||
|
{
|
||
|
m_colPropBack = col;
|
||
|
m_coloursCustomized |= 0x08;
|
||
|
|
||
|
// Set the cached brush as well.
|
||
|
((wxPGBrush*)m_arrBgBrushes.Item(0))->SetColour2(col);
|
||
|
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCellTextColour( const wxColour& col )
|
||
|
{
|
||
|
m_colPropFore = col;
|
||
|
m_coloursCustomized |= 0x10;
|
||
|
|
||
|
// Set the cached colour as well.
|
||
|
((wxPGColour*)m_arrFgCols.Item(0))->SetColour2(col);
|
||
|
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCellDisabledTextColour( const wxColour& col )
|
||
|
{
|
||
|
m_colDisPropFore = col;
|
||
|
m_coloursCustomized |= 0x100;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetSelectionBackground( const wxColour& col )
|
||
|
{
|
||
|
m_colSelBack = col;
|
||
|
m_coloursCustomized |= 0x20;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetSelectionForeground( const wxColour& col )
|
||
|
{
|
||
|
m_colSelFore = col;
|
||
|
m_coloursCustomized |= 0x40;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCaptionBackgroundColour( const wxColour& col )
|
||
|
{
|
||
|
m_colCapBack = col;
|
||
|
m_coloursCustomized |= 0x02;
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCaptionForegroundColour( const wxColour& col )
|
||
|
{
|
||
|
m_colCapFore = col;
|
||
|
m_coloursCustomized |= 0x04;
|
||
|
|
||
|
// Set the cached colour as well.
|
||
|
((wxPGColour*)m_arrFgCols.Item(1))->SetColour2(col);
|
||
|
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetBackgroundColourIndex( wxPGProperty* p, int index, int flags )
|
||
|
{
|
||
|
unsigned char ind = index;
|
||
|
|
||
|
if ( (p->m_bgColIndex == 0) || (flags & (wxPG_RECURSE_STARTS|wxPG_FORCE)) )
|
||
|
p->m_bgColIndex = ind;
|
||
|
|
||
|
if ( p->GetParentingType() != 0 && (flags & wxPG_RECURSE) )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
unsigned int i;
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
SetBackgroundColourIndex(pwc->Item(i), index, flags & ~(wxPG_RECURSE_STARTS));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyBackgroundColour( wxPGId id, const wxColour& colour )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
size_t i;
|
||
|
int colInd = -1;
|
||
|
|
||
|
long colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
|
||
|
// As it is most likely that the previous colour is used, start comparison
|
||
|
// from the end.
|
||
|
for ( i=(m_arrBgBrushes.GetCount()-1); i>0; i-- )
|
||
|
{
|
||
|
if ( ((wxPGBrush*)m_arrBgBrushes.Item(i))->GetColourAsLong() == colAsLong )
|
||
|
{
|
||
|
colInd = i;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( colInd < 0 )
|
||
|
{
|
||
|
colInd = m_arrBgBrushes.GetCount();
|
||
|
wxCHECK_RET( colInd < 256, wxT("wxPropertyGrid: Warning - Only 255 different property background colours allowed.") );
|
||
|
m_arrBgBrushes.Add( (void*)new wxPGBrush(colour) );
|
||
|
}
|
||
|
|
||
|
// Set indexes
|
||
|
SetBackgroundColourIndex(p, colInd, wxPG_RECURSE|wxPG_RECURSE_STARTS);
|
||
|
|
||
|
// If this was on a visible grid, then draw it.
|
||
|
DrawItemAndChildren(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxColour wxPropertyGrid::GetPropertyBackgroundColour( wxPGId id ) const
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxColour())
|
||
|
|
||
|
return ((wxPGBrush*)m_arrBgBrushes.Item(p->m_bgColIndex))->GetColour();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetTextColourIndex( wxPGProperty* p, int index, int flags )
|
||
|
{
|
||
|
unsigned char ind = index;
|
||
|
|
||
|
if ( (p->m_fgColIndex == 0) || (flags & (wxPG_RECURSE_STARTS|wxPG_FORCE)) )
|
||
|
p->m_fgColIndex = ind;
|
||
|
|
||
|
if ( p->GetParentingType() != 0 && (flags & wxPG_RECURSE) )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
unsigned int i;
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
SetTextColourIndex( pwc->Item(i), index, flags&~(wxPG_RECURSE_STARTS) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
int wxPropertyGrid::CacheColour( const wxColour& colour )
|
||
|
{
|
||
|
unsigned int i;
|
||
|
int colInd = -1;
|
||
|
|
||
|
long colAsLong = wxPG_COLOUR(colour.Red(),colour.Green(),colour.Blue());
|
||
|
|
||
|
// As it is most likely that the previous colour is used, start comparison
|
||
|
// from the end.
|
||
|
for ( i=(m_arrFgCols.GetCount()-1); i>0; i-- )
|
||
|
{
|
||
|
if ( ((wxPGColour*)m_arrFgCols.Item(i))->GetColourAsLong() == colAsLong )
|
||
|
{
|
||
|
colInd = i;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( colInd < 0 )
|
||
|
{
|
||
|
colInd = m_arrFgCols.GetCount();
|
||
|
wxCHECK_MSG( colInd < 256, 0, wxT("wxPropertyGrid: Warning - Only 255 different property foreground colours allowed.") );
|
||
|
m_arrFgCols.Add( (void*)new wxPGColour(colour) );
|
||
|
}
|
||
|
|
||
|
return colInd;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyTextColour( wxPGId id, const wxColour& colour )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
// Set indexes
|
||
|
SetTextColourIndex(p, CacheColour(colour), wxPG_RECURSE|wxPG_RECURSE_STARTS );
|
||
|
|
||
|
// If this was on a visible grid, then draw it.
|
||
|
DrawItemAndChildren(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetCaptionTextColour( wxPGId id, const wxColour& colour )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
wxCHECK_RET( p->GetParentingType() == PT_CAPTION,
|
||
|
wxT("Only call SetCaptionTextColour for caption properties") );
|
||
|
|
||
|
// Set indexes
|
||
|
wxPropertyCategoryClass* cat = (wxPropertyCategoryClass*) p;
|
||
|
cat->SetTextColIndex(CacheColour(colour));
|
||
|
|
||
|
// If this was on a visible grid, then draw it.
|
||
|
DrawItemAndChildren(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxColour wxPropertyGrid::GetPropertyTextColour( wxPGId id ) const
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxColour())
|
||
|
|
||
|
return wxColour(*((wxPGColour*)m_arrFgCols.Item(p->m_fgColIndex)));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyColourToDefault( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
SetBackgroundColourIndex( p, 0, wxPG_RECURSE|wxPG_FORCE );
|
||
|
SetTextColourIndex( p, 0, wxPG_RECURSE|wxPG_FORCE );
|
||
|
|
||
|
if ( p->GetParentingType() == PT_CAPTION )
|
||
|
{
|
||
|
wxPropertyCategoryClass* cat = (wxPropertyCategoryClass*) p;
|
||
|
cat->SetTextColIndex(1);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid property adding and removal
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGrid::Append( wxPGProperty* property )
|
||
|
{
|
||
|
return FROM_STATE(Append(property));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGrid::_Insert( wxPGProperty* priorthis, wxPGProperty* property )
|
||
|
{
|
||
|
wxASSERT( priorthis );
|
||
|
return FROM_STATE(DoInsert(priorthis->GetParent(), priorthis->GetArrIndex(), property));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::Delete( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
wxPropertyGridState* state = p->GetParentState();
|
||
|
wxPropertyGrid* grid = state->GetGrid();
|
||
|
|
||
|
if ( grid->GetState() == state )
|
||
|
{
|
||
|
bool selRes = grid->DoSelectProperty(wxPGIdGen(NULL), wxPG_SEL_DELETING);
|
||
|
wxPG_CHECK_RET_DBG( selRes,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
state->DoDelete( p );
|
||
|
|
||
|
if ( grid->GetState() == state && !grid->IsFrozen() )
|
||
|
{
|
||
|
// This should be enough to resolve even the worst
|
||
|
// graphics glitch imaginable.
|
||
|
grid->Update();
|
||
|
grid->Refresh();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyContainerMethods::ReplaceProperty( wxPGId id, wxPGProperty* property )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
wxPGProperty* replaced = wxPGIdToPtr(id);
|
||
|
wxCHECK_MSG( replaced && property,
|
||
|
wxNullProperty,
|
||
|
wxT("NULL property") );
|
||
|
wxCHECK_MSG( replaced->GetParentingType() == 0 || replaced->GetParentingType() == -1,
|
||
|
wxNullProperty,
|
||
|
wxT("cannot replace this type of property") );
|
||
|
wxCHECK_MSG( !m_pState->IsInNonCatMode(),
|
||
|
wxNullProperty,
|
||
|
wxT("cannot replace properties in alphabetic mode") );
|
||
|
|
||
|
// Get address to the slot
|
||
|
wxPGPropertyWithChildren* parent = replaced->GetParent();
|
||
|
int ind = replaced->GetIndexInParent();
|
||
|
|
||
|
wxPropertyGridState* state = replaced->GetParentState();
|
||
|
Delete(replaced); // Must use generic Delete
|
||
|
state->DoInsert(parent,ind,property);
|
||
|
|
||
|
return wxPGIdGen(property);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::PrepareAfterItemsAdded()
|
||
|
{
|
||
|
|
||
|
if ( !FROM_STATE(m_itemsAdded) ) return;
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("PrepareAfterItemsAdded( in thread 0x%lX )"),
|
||
|
(unsigned long)wxThread::GetCurrentId());
|
||
|
#endif
|
||
|
|
||
|
FROM_STATE(m_itemsAdded) = 0;
|
||
|
|
||
|
if ( m_windowStyle & wxPG_AUTO_SORT )
|
||
|
{
|
||
|
Sort ();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_bottomy < 1 )
|
||
|
CalculateYs( NULL, -1 );
|
||
|
else
|
||
|
{
|
||
|
RecalculateVirtualSize();
|
||
|
// Update visibles array (maybe not necessary here, but just in case)
|
||
|
CalculateVisibles ( -1, true );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid property value setting and getting
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGGetFailed( const wxPGProperty* p, const wxChar* typestr )
|
||
|
{
|
||
|
wxPGTypeOperationFailed(p,typestr,wxT("Get"));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGTypeOperationFailed( const wxPGProperty* p, const wxChar* typestr,
|
||
|
const wxChar* op )
|
||
|
{
|
||
|
wxASSERT( p != NULL );
|
||
|
wxLogError( _("Type operation \"%s\" failed: Property labeled \"%s\" is of type \"%s\", NOT \"%s\"."),
|
||
|
op,p->GetLabel().c_str(),wxPG_TO_WXCHAR_PTR(p->GetValueTypePtr()->GetCustomTypeName()),typestr );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyValue( wxPGId id, const wxPGValueType* typeclass, const wxPGVariant& value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
if ( p && m_pState->SetPropertyValue(p,typeclass,value) )
|
||
|
DrawItemAndValueRelated( p );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyValue( wxPGId id, const wxChar* typestring, const wxPGVariant& value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
if ( p && m_pState->SetPropertyValue(p,typestring,value) )
|
||
|
DrawItemAndValueRelated( p );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyValueString( wxPGId id, const wxString& value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
if ( m_pState->SetPropertyValueString(p,value) )
|
||
|
DrawItemAndValueRelated( p );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyValueWxObjectPtr( wxPGId id, wxObject* value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
if ( m_pState->SetPropertyValueWxObjectPtr(p,value) )
|
||
|
DrawItemAndValueRelated( p );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
void wxPropertyGrid::SetPropertyValue( wxPGId id, wxVariant& value )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
if ( m_pState->SetPropertyValue(p,value) )
|
||
|
DrawItemAndValueRelated( p );
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::ClearPropertyValue( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
|
||
|
if ( m_pState->ClearPropertyValue(p) )
|
||
|
{
|
||
|
DrawItemAndChildren( p );
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyUnspecified( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
m_pState->SetPropertyUnspecified(p);
|
||
|
DrawItemAndChildren(p);
|
||
|
|
||
|
wxPGPropertyWithChildren* parent = p->GetParent();
|
||
|
while ( parent->GetParentingType() <= PT_FIXEDCHILDREN )
|
||
|
{
|
||
|
DrawItem(parent);
|
||
|
parent = parent->GetParent();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid miscellaneous GetPropertyXXX methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyCategoryClass* wxPropertyGrid::_GetPropertyCategory( wxPGProperty* p )
|
||
|
{
|
||
|
wxPGProperty* parent = (wxPGPropertyWithChildren*)p;
|
||
|
wxPGProperty* grandparent = (wxPGProperty*)parent->GetParent();
|
||
|
do
|
||
|
{
|
||
|
parent = grandparent;
|
||
|
grandparent = (wxPGProperty*)parent->GetParent();
|
||
|
if ( parent->GetParentingType() >= PT_CAPTION && grandparent )
|
||
|
return (wxPropertyCategoryClass*)parent;
|
||
|
} while ( grandparent );
|
||
|
return (wxPropertyCategoryClass*) NULL;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid property operations
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::EnableProperty( wxPGId id, bool enable )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
|
||
|
if ( enable )
|
||
|
{
|
||
|
if ( !(p->m_flags & wxPG_PROP_DISABLED) )
|
||
|
return false;
|
||
|
|
||
|
// If active, Set active Editor.
|
||
|
if ( p == m_selected )
|
||
|
DoSelectProperty( p, wxPG_SEL_FORCE );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( p->m_flags & wxPG_PROP_DISABLED )
|
||
|
return false;
|
||
|
|
||
|
// If active, Disable as active Editor.
|
||
|
if ( p == m_selected )
|
||
|
DoSelectProperty( p, wxPG_SEL_FORCE );
|
||
|
}
|
||
|
|
||
|
m_pState->EnableProperty(p,enable);
|
||
|
|
||
|
DrawItemAndChildren( p );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::LimitPropertyEditing( wxPGId id, bool limit )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
m_pState->LimitPropertyEditing(p,limit);
|
||
|
if ( p == m_selected )
|
||
|
DoSelectProperty( p, wxPG_SEL_FORCE );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::_SetPropertyLabel( wxPGProperty* p, const wxString& newproplabel )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
|
||
|
p->m_label = newproplabel;
|
||
|
if ( m_windowStyle & wxPG_AUTO_SORT )
|
||
|
{
|
||
|
Sort(p->GetParent());
|
||
|
Refresh();
|
||
|
}
|
||
|
else
|
||
|
DrawItem ( p );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::DoSetPropertyName( wxPGProperty* p, const wxString& newname )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::SetPropertyName( %s -> %s )"),
|
||
|
p->GetName().c_str(), newname.c_str() );
|
||
|
#endif
|
||
|
|
||
|
if ( p->GetName().Len() ) FROM_STATE(m_dictName).erase ( wxPGNameConv(p->GetName()) );
|
||
|
if ( newname.Len() ) FROM_STATE(m_dictName)[newname] = (void*) p;
|
||
|
|
||
|
p->DoSetName(newname);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::EnsureVisible( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
|
||
|
Update();
|
||
|
|
||
|
bool changed = false;
|
||
|
|
||
|
// Is it inside collapsed section?
|
||
|
if ( p->m_y < 0 )
|
||
|
{
|
||
|
// expand parents
|
||
|
wxPGProperty* parent = p->GetParent();
|
||
|
wxPGProperty* grandparent = parent->GetParent();
|
||
|
|
||
|
if ( grandparent && grandparent != FROM_STATE(m_properties) )
|
||
|
Expand ( grandparent );
|
||
|
|
||
|
Expand ( parent );
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
// Need to scroll?
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
if ( p->m_y < vy )
|
||
|
{
|
||
|
Scroll (vx, p->m_y/wxPG_PIXELS_PER_UNIT );
|
||
|
m_iFlags |= wxPG_FL_SCROLLED;
|
||
|
changed = true;
|
||
|
}
|
||
|
else if ( (p->m_y+m_lineHeight) > (vy+m_height) )
|
||
|
{
|
||
|
Scroll (vx, (p->m_y-m_height+(m_lineHeight*2))/wxPG_PIXELS_PER_UNIT );
|
||
|
m_iFlags |= wxPG_FL_SCROLLED;
|
||
|
changed = true;
|
||
|
}
|
||
|
|
||
|
if ( changed )
|
||
|
DrawItems ( p, p );
|
||
|
|
||
|
return changed;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid helper methods called by properties
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
|
||
|
// fits into that category as well).
|
||
|
void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl )
|
||
|
{
|
||
|
// Center the control vertically
|
||
|
wxRect finalPos = ctrl->GetRect();
|
||
|
int y_adj = (m_lineHeight - finalPos.height)/2 + wxPG_TEXTCTRLYADJUST;
|
||
|
|
||
|
// Prevent over-sized control
|
||
|
int sz_dec = (y_adj + finalPos.height) - m_lineHeight;
|
||
|
if ( sz_dec < 0 ) sz_dec = 0;
|
||
|
|
||
|
finalPos.y += y_adj;
|
||
|
finalPos.height -= (y_adj+sz_dec);
|
||
|
|
||
|
// STUPID HACK: wxTextCtrl has different indentation with different
|
||
|
// fonts, so this is to solve most common case (ie. using MS Shell Dlg 2
|
||
|
// or Tahoma - which are usually the same).
|
||
|
/*#ifdef __WXMSW__
|
||
|
wxString faceName = m_font.GetFaceName();
|
||
|
int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
|
||
|
if ( (faceName == wxT("MS Shell Dlg 2") ||
|
||
|
faceName == wxT("Tahoma")) &&
|
||
|
m_font.GetWeight() != wxFONTWEIGHT_BOLD )
|
||
|
textCtrlXAdjust = 0;
|
||
|
#else*/
|
||
|
const int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
|
||
|
//#endif
|
||
|
|
||
|
finalPos.x += textCtrlXAdjust;
|
||
|
finalPos.width -= textCtrlXAdjust;
|
||
|
|
||
|
ctrl->SetSize(finalPos);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Control font changer helper.
|
||
|
void wxPropertyGrid::SetCurControlBoldFont()
|
||
|
{
|
||
|
wxASSERT( m_wndPrimary );
|
||
|
m_wndPrimary->SetFont( m_captionFont );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
const wxString& value,
|
||
|
wxWindow* secondary,
|
||
|
int extraStyle,
|
||
|
int maxLen )
|
||
|
{
|
||
|
int tcFlags = wxTE_PROCESS_ENTER | extraStyle;
|
||
|
|
||
|
if ( m_selected->HasFlag(wxPG_PROP_READONLY) )
|
||
|
tcFlags |= wxTE_READONLY;
|
||
|
|
||
|
wxPoint p(pos.x,pos.y);
|
||
|
wxSize s(sz.x,sz.y);
|
||
|
|
||
|
// Need to reduce width of text control on Mac
|
||
|
#if defined(__WXMAC__)
|
||
|
s.x -= 8;
|
||
|
#endif
|
||
|
|
||
|
// Take button into acccount
|
||
|
if ( secondary )
|
||
|
{
|
||
|
s.x -= (secondary->GetSize().x + wxPG_TEXTCTRL_AND_BUTTON_SPACING);
|
||
|
m_iFlags &= ~(wxPG_FL_PRIMARY_FILLS_ENTIRE);
|
||
|
}
|
||
|
|
||
|
// If the height is significantly higher, then use border, and fill the rect exactly.
|
||
|
bool hasSpecialSize = false;
|
||
|
|
||
|
if ( (sz.y - m_lineHeight) > 5 )
|
||
|
hasSpecialSize = true;
|
||
|
|
||
|
#if wxPG_NAT_TEXTCTRL_BORDER_ANY
|
||
|
|
||
|
// Create clipper window
|
||
|
wxPGClipperWindow* wnd = new wxPGClipperWindow();
|
||
|
#if defined(__WXMSW__)
|
||
|
wnd->Hide();
|
||
|
#endif
|
||
|
wnd->Create(this,wxPG_SUBID1,p,s);
|
||
|
|
||
|
// This generates rect of the control inside the clipper window
|
||
|
if ( !hasSpecialSize )
|
||
|
wnd->GetControlRect(wxPG_NAT_TEXTCTRL_BORDER_X, wxPG_NAT_TEXTCTRL_BORDER_Y, p, s);
|
||
|
else
|
||
|
wnd->GetControlRect(0, 0, p, s);
|
||
|
|
||
|
wxWindow* ctrlParent = wnd;
|
||
|
|
||
|
#else
|
||
|
|
||
|
wxWindow* ctrlParent = this;
|
||
|
|
||
|
if ( !hasSpecialSize )
|
||
|
tcFlags |= wxNO_BORDER;
|
||
|
|
||
|
#endif
|
||
|
|
||
|
wxTextCtrl* tc = new wxTextCtrl();
|
||
|
|
||
|
#if defined(__WXMSW__) && !wxPG_NAT_TEXTCTRL_BORDER_ANY
|
||
|
tc->Hide();
|
||
|
#endif
|
||
|
tc->Create(ctrlParent,wxPG_SUBID1,value, p, s,tcFlags);
|
||
|
|
||
|
#if wxPG_NAT_TEXTCTRL_BORDER_ANY
|
||
|
wxWindow* ed = wnd;
|
||
|
wnd->SetControl(tc);
|
||
|
#else
|
||
|
wxWindow* ed = tc;
|
||
|
#endif
|
||
|
|
||
|
// Center the control vertically
|
||
|
if ( !hasSpecialSize )
|
||
|
FixPosForTextCtrl(ed);
|
||
|
|
||
|
#ifdef __WXMSW__
|
||
|
ed->Show();
|
||
|
if ( secondary )
|
||
|
secondary->Show();
|
||
|
#endif
|
||
|
|
||
|
// Set maximum length
|
||
|
if ( maxLen > 0 )
|
||
|
tc->SetMaxLength( maxLen );
|
||
|
|
||
|
return (wxWindow*) ed;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize& sz )
|
||
|
{
|
||
|
#ifdef __WXMAC__
|
||
|
// Decorations are chunky on Mac, and we can't make the button square, so
|
||
|
// do things a bit differently on this platform.
|
||
|
|
||
|
wxPoint p(pos.x+sz.x,
|
||
|
pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
|
||
|
wxSize s(25, -1);
|
||
|
|
||
|
wxButton* but = new wxButton();
|
||
|
but->Create(this,wxPG_SUBID2,wxT("..."),p,s,wxWANTS_CHARS);
|
||
|
|
||
|
// Now that we know the size, move to the correct position
|
||
|
p.x = pos.x + sz.x - but->GetSize().x - 2;
|
||
|
but->Move(p);
|
||
|
|
||
|
#else
|
||
|
wxSize s(sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2),
|
||
|
sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2));
|
||
|
|
||
|
// Reduce button width to lineheight
|
||
|
if ( s.x > m_lineHeight )
|
||
|
s.x = m_lineHeight;
|
||
|
|
||
|
wxPoint p(pos.x+sz.x-s.x,
|
||
|
pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
|
||
|
|
||
|
wxButton* but = new wxButton();
|
||
|
#ifdef __WXMSW__
|
||
|
but->Hide();
|
||
|
#endif
|
||
|
but->Create(this,wxPG_SUBID2,wxT("..."),p,s,wxWANTS_CHARS);
|
||
|
|
||
|
but->SetFont( m_captionFont );
|
||
|
#endif
|
||
|
|
||
|
if ( m_selected->HasFlag(wxPG_PROP_READONLY) )
|
||
|
but->Disable();
|
||
|
|
||
|
return but;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxWindow* wxPropertyGrid::GenerateEditorTextCtrlAndButton( const wxPoint& pos,
|
||
|
const wxSize& sz,
|
||
|
wxWindow** psecondary,
|
||
|
int limitedEditing,
|
||
|
wxPGProperty* property )
|
||
|
{
|
||
|
wxButton* but = (wxButton*)GenerateEditorButton(pos,sz);
|
||
|
*psecondary = (wxWindow*)but;
|
||
|
|
||
|
if ( limitedEditing )
|
||
|
{
|
||
|
#ifdef __WXMSW__
|
||
|
// There is button Show in GenerateEditorTextCtrl as well
|
||
|
but->Show();
|
||
|
#endif
|
||
|
return (wxWindow*) NULL;
|
||
|
}
|
||
|
|
||
|
wxString text;
|
||
|
|
||
|
if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
|
||
|
text = property->GetValueAsString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
|
||
|
|
||
|
return GenerateEditorTextCtrl(pos,sz,text,but,property->m_maxLen);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPoint wxPropertyGrid::GetGoodEditorDialogPosition( wxPGProperty* p,
|
||
|
const wxSize& sz )
|
||
|
{
|
||
|
#if wxPG_SMALL_SCREEN
|
||
|
// On small-screen devices, always show dialogs with default position and size.
|
||
|
return wxDefaultPosition;
|
||
|
#else
|
||
|
int x = m_splitterx;
|
||
|
int y = p->m_y;
|
||
|
|
||
|
wxCHECK_MSG( y >= 0, wxPoint(-1,-1), wxT("invalid y?") );
|
||
|
wxCHECK_MSG( y < (int)m_bottomy, wxPoint(-1,-1), wxT("invalid y?") );
|
||
|
|
||
|
ImprovedClientToScreen( &x, &y );
|
||
|
|
||
|
int sw = wxSystemSettings::GetMetric( ::wxSYS_SCREEN_X );
|
||
|
int sh = wxSystemSettings::GetMetric( ::wxSYS_SCREEN_Y );
|
||
|
|
||
|
int new_x;
|
||
|
int new_y;
|
||
|
|
||
|
if ( x > (sw/2) )
|
||
|
// left
|
||
|
new_x = x + (m_width-m_splitterx) - sz.x;
|
||
|
else
|
||
|
// right
|
||
|
new_x = x;
|
||
|
|
||
|
if ( y > (sh/2) )
|
||
|
// above
|
||
|
new_y = y - sz.y;
|
||
|
else
|
||
|
// below
|
||
|
new_y = y + m_lineHeight;
|
||
|
|
||
|
return wxPoint(new_x,new_y);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SLAlloc( unsigned int itemcount, const wxChar** items )
|
||
|
{
|
||
|
wxArrayString& sl = m_sl;
|
||
|
unsigned int i;
|
||
|
unsigned int sl_oldcount = sl.GetCount();
|
||
|
if ( sl_oldcount > itemcount ) sl_oldcount = itemcount;
|
||
|
#if wxUSE_INTL
|
||
|
if ( !wxPGGlobalVars->m_autoGetTranslation )
|
||
|
{
|
||
|
#endif
|
||
|
for ( i=0; i<sl_oldcount; i++ )
|
||
|
sl.Item(i) = items[i];
|
||
|
for ( i=sl_oldcount; i<itemcount; i++ )
|
||
|
sl.Add ( items[i] );
|
||
|
#if wxUSE_INTL
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
for ( i=0; i<sl_oldcount; i++ )
|
||
|
sl.Item(i) = ::wxGetTranslation ( items[i] );
|
||
|
for ( i=sl_oldcount; i<itemcount; i++ )
|
||
|
sl.Add ( ::wxGetTranslation ( items[i] ) );
|
||
|
}
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
wxString& wxPropertyGrid::ExpandEscapeSequences( wxString& dst_str, wxString& src_str )
|
||
|
{
|
||
|
if ( src_str.length() == 0 )
|
||
|
{
|
||
|
dst_str = src_str;
|
||
|
return src_str;
|
||
|
}
|
||
|
|
||
|
bool prev_is_slash = false;
|
||
|
|
||
|
wxString::const_iterator i = src_str.begin();
|
||
|
|
||
|
dst_str.clear();
|
||
|
|
||
|
for ( ; i != src_str.end(); i++ )
|
||
|
{
|
||
|
wxUniChar a = wxPGGetIterChar(src_str, i);
|
||
|
|
||
|
if ( a != wxT('\\') )
|
||
|
{
|
||
|
if ( !prev_is_slash )
|
||
|
{
|
||
|
dst_str << a;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( a == wxT('n') )
|
||
|
{
|
||
|
#ifdef __WXMSW__
|
||
|
dst_str << wxT('\n');
|
||
|
//dst_str << wxT('\10');
|
||
|
#else
|
||
|
dst_str << wxT('\n');
|
||
|
//dst_str << 10;
|
||
|
#endif
|
||
|
}
|
||
|
else if ( a == wxT('t') )
|
||
|
dst_str << wxT('\t');
|
||
|
else
|
||
|
dst_str << a;
|
||
|
}
|
||
|
prev_is_slash = false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( prev_is_slash )
|
||
|
{
|
||
|
dst_str << wxT('\\');
|
||
|
prev_is_slash = false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
prev_is_slash = true;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return dst_str;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxString& wxPropertyGrid::CreateEscapeSequences( wxString& dst_str, wxString& src_str )
|
||
|
{
|
||
|
if ( src_str.length() == 0 )
|
||
|
{
|
||
|
dst_str = src_str;
|
||
|
return src_str;
|
||
|
}
|
||
|
|
||
|
wxString::const_iterator i = src_str.begin();
|
||
|
wxChar prev_a = wxT('\0');
|
||
|
|
||
|
dst_str.clear();
|
||
|
|
||
|
for ( ; i != src_str.end(); i++ )
|
||
|
{
|
||
|
wxChar a = wxPGGetIterChar(src_str, i);
|
||
|
|
||
|
if ( a >= wxT(' ')
|
||
|
#if !wxUSE_UNICODE
|
||
|
|| a < 0
|
||
|
#endif
|
||
|
)
|
||
|
{
|
||
|
// This surely is not something that requires an escape sequence.
|
||
|
dst_str << a;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// This might need...
|
||
|
if ( a == wxT('\r') )
|
||
|
{
|
||
|
// DOS style line end.
|
||
|
// Already taken care below
|
||
|
//dst_str = wxT("\\n");
|
||
|
//src++;
|
||
|
}
|
||
|
else if ( a == wxT('\n') )
|
||
|
// UNIX style line end.
|
||
|
dst_str << wxT("\\n");
|
||
|
else if ( a == wxT('\t') )
|
||
|
// Tab.
|
||
|
dst_str << wxT('\t');
|
||
|
else
|
||
|
{
|
||
|
//wxLogDebug(wxT("WARNING: Could not create escape sequence for character #%i"),(int)a);
|
||
|
dst_str << a;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
prev_a = a;
|
||
|
}
|
||
|
return dst_str;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Item iteration macros
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#define II_INVALID_I 0x00FFFFFF
|
||
|
|
||
|
#define ITEM_ITERATION_VARIABLES \
|
||
|
wxPGPropertyWithChildren* parent; \
|
||
|
unsigned int i; \
|
||
|
unsigned int iMax;
|
||
|
|
||
|
#define ITEM_ITERATION_DCAE_VARIABLES \
|
||
|
wxPGPropertyWithChildren* parent; \
|
||
|
unsigned int i; \
|
||
|
unsigned int iMax;
|
||
|
|
||
|
#define ITEM_ITERATION_INIT_FROM_THE_TOP \
|
||
|
parent = FROM_STATE(m_properties); \
|
||
|
i = 0;
|
||
|
|
||
|
#define ITEM_ITERATION_INIT(startparent,startindex) \
|
||
|
parent = startparent; \
|
||
|
i = (unsigned int)startindex; \
|
||
|
if ( parent == (wxPGPropertyWithChildren*) NULL ) \
|
||
|
{ \
|
||
|
parent = FROM_STATE(m_properties); \
|
||
|
i = 0; \
|
||
|
}
|
||
|
|
||
|
#define ITEM_ITERATION_LOOP_BEGIN \
|
||
|
unsigned char parent_expanded; \
|
||
|
do \
|
||
|
{ \
|
||
|
parent_expanded = (unsigned char)parent->m_expanded; \
|
||
|
if ( parent->m_parent && !parent->m_parent->m_expanded ) \
|
||
|
parent_expanded = 0; \
|
||
|
iMax = parent->GetCount(); \
|
||
|
while ( i < iMax ) \
|
||
|
{ \
|
||
|
wxPGProperty* p = parent->Item(i); \
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
#define ITEM_ITERATION_LOOP_END \
|
||
|
if ( parenting ) \
|
||
|
{ \
|
||
|
i = 0; \
|
||
|
parent = (wxPGPropertyWithChildren*)p; \
|
||
|
if ( parent_expanded ) \
|
||
|
parent_expanded = (unsigned char)parent->m_expanded; \
|
||
|
else \
|
||
|
parent_expanded = 0; \
|
||
|
iMax = parent->GetCount(); \
|
||
|
} \
|
||
|
else \
|
||
|
i++; \
|
||
|
} \
|
||
|
i = parent->m_arrIndex + 1; \
|
||
|
parent = parent->m_parent; \
|
||
|
} \
|
||
|
while ( parent != NULL );
|
||
|
|
||
|
// DCAE = Don't care about parent_expanded (this is the least space hungry method).
|
||
|
#define ITEM_ITERATION_DCAE_LOOP_BEGIN \
|
||
|
do \
|
||
|
{ \
|
||
|
iMax = parent->GetCount(); \
|
||
|
while ( i < iMax ) \
|
||
|
{ \
|
||
|
wxPGProperty* p = parent->Item(i); \
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
#define ITEM_ITERATION_DCAE_LOOP_END \
|
||
|
if ( parenting ) \
|
||
|
{ \
|
||
|
i = 0; \
|
||
|
parent = (wxPGPropertyWithChildren*)p; \
|
||
|
iMax = parent->GetCount(); \
|
||
|
} \
|
||
|
else \
|
||
|
i++; \
|
||
|
} \
|
||
|
i = parent->m_arrIndex + 1; \
|
||
|
parent = parent->m_parent; \
|
||
|
} \
|
||
|
while ( parent != NULL );
|
||
|
|
||
|
// DCAE_ISP = Don't care about parent_expanded, Ignore sub-properties.
|
||
|
// Note that this treats fixed sub-properties same as sub-properties
|
||
|
// of wxParentProperty. Mode conversion requires this behaviour.
|
||
|
#define ITEM_ITERATION_DCAE_ISP_LOOP_BEGIN \
|
||
|
do \
|
||
|
{ \
|
||
|
iMax = parent->GetCount(); \
|
||
|
while ( i < iMax ) \
|
||
|
{ \
|
||
|
wxPGProperty* p = parent->Item(i); \
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
#define ITEM_ITERATION_DCAE_ISP_LOOP_END \
|
||
|
if ( parenting > 0 ) \
|
||
|
{ \
|
||
|
i = 0; \
|
||
|
parent = (wxPGPropertyWithChildren*)p; \
|
||
|
iMax = parent->GetCount(); \
|
||
|
} \
|
||
|
else \
|
||
|
i++; \
|
||
|
} \
|
||
|
i = parent->m_arrIndex + 1; \
|
||
|
parent = parent->m_parent; \
|
||
|
} \
|
||
|
while ( parent != (wxPGPropertyWithChildren*) NULL );
|
||
|
|
||
|
|
||
|
// VO = Visible only (including those outside the scrolled section).
|
||
|
#define ITEM_ITERATION_VO_LOOP_BEGIN \
|
||
|
if ( (parent == FROM_STATE(m_properties) || parent->m_y >= 0) && parent->m_expanded ) \
|
||
|
{ \
|
||
|
do \
|
||
|
{ \
|
||
|
iMax = parent->GetCount(); \
|
||
|
while ( i < iMax ) \
|
||
|
{ \
|
||
|
wxPGProperty* p = parent->Item(i); \
|
||
|
if ( p->m_y >= 0 ) \
|
||
|
{ \
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
#define ITEM_ITERATION_VO_LOOP_END \
|
||
|
if ( parenting && ((wxPGPropertyWithChildren*)p)->m_expanded ) \
|
||
|
{ \
|
||
|
parent = (wxPGPropertyWithChildren*)p; \
|
||
|
i = 0; \
|
||
|
break; \
|
||
|
} \
|
||
|
} \
|
||
|
i++; \
|
||
|
} \
|
||
|
if ( i >= iMax ) \
|
||
|
{ \
|
||
|
i = parent->m_arrIndex + 1; \
|
||
|
parent = parent->m_parent; \
|
||
|
} \
|
||
|
} \
|
||
|
while ( parent != (wxPGPropertyWithChildren*) NULL ); \
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid visibility related methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::CalculateYs( wxPGPropertyWithChildren* startparent,
|
||
|
int startindex )
|
||
|
{
|
||
|
// Selection must be temporarily cleared during y-recalc
|
||
|
wxPGProperty* prevSelected = m_selected;
|
||
|
if ( prevSelected )
|
||
|
{
|
||
|
bool selRes = ClearSelection();
|
||
|
wxPG_CHECK_RET_DBG( selRes,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
ITEM_ITERATION_VARIABLES
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("CalculateYs(startsfrom: %s[%i] ) "),
|
||
|
startparent?startparent->m_label.c_str():wxT("NULL"),
|
||
|
startindex);
|
||
|
#endif
|
||
|
|
||
|
ITEM_ITERATION_INIT(startparent,startindex)
|
||
|
|
||
|
wxASSERT( !m_frozen );
|
||
|
|
||
|
int cury = 0;
|
||
|
int lh = m_lineHeight;
|
||
|
|
||
|
if ( startparent != NULL )
|
||
|
cury = parent->Item(i)->m_y;
|
||
|
|
||
|
wxASSERT_MSG( cury >= 0, wxT("CalculateYs first item was not visible!!!") );
|
||
|
|
||
|
long hide_state = m_iFlags & wxPG_FL_HIDE_STATE;
|
||
|
bool inside_hidden_part = false;
|
||
|
//parent_expanded = (unsigned char)parent->m_expanded;
|
||
|
wxPGPropertyWithChildren* nearest_expanded = (wxPGPropertyWithChildren*) NULL;
|
||
|
|
||
|
// Find first visible and expanded parent.
|
||
|
while ( !parent->IsExpanded() ||
|
||
|
( (parent->m_flags & wxPG_PROP_HIDEABLE) && hide_state )
|
||
|
)
|
||
|
{
|
||
|
parent = parent->GetParent();
|
||
|
i = 0;
|
||
|
}
|
||
|
|
||
|
wxASSERT( parent );
|
||
|
|
||
|
//parent = nearest_expanded;
|
||
|
|
||
|
do
|
||
|
{
|
||
|
iMax = parent->GetCount();
|
||
|
|
||
|
if ( !inside_hidden_part )
|
||
|
{
|
||
|
while ( i < iMax )
|
||
|
{
|
||
|
wxPGProperty* p = parent->Item(i);
|
||
|
|
||
|
int parenting = p->GetParentingType();
|
||
|
if ( !(p->m_flags & wxPG_PROP_HIDEABLE) || (!hide_state) )
|
||
|
{
|
||
|
// item is visible (all parents are expanded, non-hideable or not in hide state)
|
||
|
p->m_y = (int)cury;
|
||
|
cury += lh;
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
p->m_y = -1;
|
||
|
}
|
||
|
|
||
|
if ( parenting )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* p2 = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
if ( !p2->m_expanded ||
|
||
|
( (p2->m_flags & wxPG_PROP_HIDEABLE) && hide_state )
|
||
|
)
|
||
|
{
|
||
|
inside_hidden_part = true;
|
||
|
nearest_expanded = parent;
|
||
|
}
|
||
|
|
||
|
parent = p2;
|
||
|
i = 0;
|
||
|
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
i++;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
while ( i < iMax )
|
||
|
{
|
||
|
wxPGProperty* p = parent->Item(i);
|
||
|
int parenting = p->GetParentingType();
|
||
|
p->m_y = -1;
|
||
|
if ( parenting )
|
||
|
{
|
||
|
parent = (wxPGPropertyWithChildren*)p;
|
||
|
i = 0;
|
||
|
break;
|
||
|
}
|
||
|
i++;
|
||
|
}
|
||
|
}
|
||
|
if ( i >= iMax )
|
||
|
{
|
||
|
i = parent->m_arrIndex + 1;
|
||
|
parent = parent->m_parent;
|
||
|
if ( inside_hidden_part && parent == nearest_expanded )
|
||
|
{
|
||
|
inside_hidden_part = false;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
while ( parent != (wxPGPropertyWithChildren*) NULL );
|
||
|
|
||
|
m_bottomy = cury;
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT(" \\-> m_bottomy = %i"),(int)m_bottomy);
|
||
|
#endif
|
||
|
|
||
|
// Forces a new DoGetBestSize() call.
|
||
|
wxScrolledWindow::InvalidateBestSize();
|
||
|
|
||
|
// Visibles need to be recalculated *always* after y recalculation
|
||
|
// (but make sure it stays here, above RecalculateVirtualSize).
|
||
|
CalculateVisibles( -1, true );
|
||
|
|
||
|
RecalculateVirtualSize();
|
||
|
|
||
|
// Reselect
|
||
|
if ( prevSelected )
|
||
|
DoSelectProperty( prevSelected, wxPG_SEL_NONVISIBLE );
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Call when scroll position changes. Do not pre-fill m_prevVY.
|
||
|
void wxPropertyGrid::CalculateVisibles( int vy, bool full_recalc )
|
||
|
{
|
||
|
if ( vy < 0 )
|
||
|
{
|
||
|
int vx;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
if ( full_recalc )
|
||
|
m_prevVY = -1;
|
||
|
}
|
||
|
|
||
|
// Control not yet properly built.
|
||
|
if ( vy >= (int)m_bottomy )
|
||
|
return;
|
||
|
|
||
|
if ( m_height < 0 )
|
||
|
return;
|
||
|
|
||
|
// Hide popup
|
||
|
// FIXME: Delete after transient popup support fully added
|
||
|
if ( m_wndPrimary && m_wndPrimary->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)) )
|
||
|
((wxPGOwnerDrawnComboBox*)m_wndPrimary)->HidePopup();
|
||
|
|
||
|
int vy2 = vy + m_height;
|
||
|
|
||
|
if ( vy2 > (int)m_bottomy )
|
||
|
vy2 = m_bottomy;
|
||
|
|
||
|
unsigned int arr_index = 0;
|
||
|
unsigned int vis_height = vy2-vy;
|
||
|
unsigned int new_item_count = vis_height/m_lineHeight;
|
||
|
if ( vis_height % m_lineHeight )
|
||
|
new_item_count++;
|
||
|
|
||
|
wxPGArrayProperty& arr = m_arrVisible;
|
||
|
|
||
|
arr.SetCount ( new_item_count );
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::CalculateVisibles ( vy=%i, vy2=%i, m_height=%i, newitemcount=%i, lineheight=%i )"),
|
||
|
(int)vy, (int)vy2, (int)m_height, (int)new_item_count, (int)m_lineHeight );
|
||
|
#endif
|
||
|
|
||
|
//wxASSERT( vy != m_prevVY );
|
||
|
wxASSERT( vy >= 0 );
|
||
|
|
||
|
if ( !new_item_count )
|
||
|
{
|
||
|
arr.Empty();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
ITEM_ITERATION_VARIABLES
|
||
|
|
||
|
wxPGProperty* base = NULL;
|
||
|
|
||
|
// Will simpler operation be enough?
|
||
|
if ( m_prevVY >= 0 )
|
||
|
{
|
||
|
if ( m_calcVisHeight == m_height )
|
||
|
{
|
||
|
if ( m_iFlags & wxPG_FL_SCROLLED )
|
||
|
{
|
||
|
int diff = vy - m_prevVY;
|
||
|
if ( diff == m_lineHeight )
|
||
|
{
|
||
|
// Scrolled one down
|
||
|
base = DoGetItemAtY_Full( vy2 - 1 );
|
||
|
wxASSERT( base );
|
||
|
arr_index = new_item_count - 1;
|
||
|
for ( i=0; i<arr_index; i++ )
|
||
|
arr.Item(i) = arr.Item(i+1);
|
||
|
arr.Item(arr_index) = base;
|
||
|
base = (wxPGProperty*) NULL;
|
||
|
}
|
||
|
else if ( diff == -m_lineHeight )
|
||
|
{
|
||
|
// Scrolled one up
|
||
|
base = DoGetItemAtY_Full( vy );
|
||
|
wxASSERT( base );
|
||
|
vy2 = vy + m_lineHeight; // update visibility
|
||
|
for ( i=(new_item_count-1); i>arr_index; i-- )
|
||
|
arr.Item(i) = arr.Item(i-1);
|
||
|
arr.Item(arr_index) = base;
|
||
|
base = (wxPGProperty*) NULL;
|
||
|
}
|
||
|
else
|
||
|
base = DoGetItemAtY_Full( vy );
|
||
|
}
|
||
|
else
|
||
|
base = DoGetItemAtY_Full( vy );
|
||
|
}
|
||
|
else
|
||
|
if ( m_prevVY == vy && !(m_iFlags & wxPG_FL_SCROLLED) )
|
||
|
{
|
||
|
if ( m_height > m_calcVisHeight )
|
||
|
{
|
||
|
// Increased height - add missing items
|
||
|
arr_index = (m_calcVisHeight-1)/m_lineHeight;
|
||
|
if ( arr_index >= new_item_count )
|
||
|
{
|
||
|
// Now, were probably below last item here
|
||
|
//if ( (vy+m_calcVisHeight) >= (int)m_bottomy )
|
||
|
base = NULL;
|
||
|
/*else
|
||
|
arr_index = arr.GetCount()-1;*/
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
base = (wxPGProperty*) arr.Item( arr_index );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Decreased height - do nothing
|
||
|
//base = NULL;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
base = DoGetItemAtY_Full( vy );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
base = DoGetItemAtY_Full( vy );
|
||
|
}
|
||
|
|
||
|
if ( base )
|
||
|
{
|
||
|
ITEM_ITERATION_INIT(base->m_parent,base->m_arrIndex)
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT(" Starting at index %i"), (int)arr_index );
|
||
|
#endif
|
||
|
|
||
|
ITEM_ITERATION_VO_LOOP_BEGIN
|
||
|
|
||
|
//wxASSERT( p->m_y >= 0 );
|
||
|
|
||
|
// update visibility limit reached?
|
||
|
if ( p->m_y >= vy2 ) { parent = NULL; break; }
|
||
|
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( arr_index >= arr.GetCount() )
|
||
|
{
|
||
|
wxLogDebug(wxT(" wxPropertyGrid::CalculateVisibles Loop overflow (index=%i,vy+vis_height=%i,p->m_y=%i)"),
|
||
|
(int)arr_index,(int)(vy+vis_height),(int)p->m_y);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
arr.Item(arr_index) = (void*)p;
|
||
|
arr_index++;
|
||
|
|
||
|
ITEM_ITERATION_VO_LOOP_END
|
||
|
}
|
||
|
|
||
|
// Adjust controls
|
||
|
/*if ( m_selected )
|
||
|
{
|
||
|
int adjust = prevVY - vy;
|
||
|
if ( adjust )
|
||
|
{
|
||
|
wxPoint cp(0,adjust);
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
m_wndPrimary->Move ( m_wndPrimary->GetPosition() + cp );
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
m_wndSecondary->Move ( m_wndSecondary->GetPosition() + cp );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_SCROLLED);
|
||
|
|
||
|
m_prevVY = vy;
|
||
|
|
||
|
m_calcVisHeight = m_height;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// This version uses the visible item cache.
|
||
|
wxPGProperty* wxPropertyGrid::DoGetItemAtY( int y )
|
||
|
{
|
||
|
|
||
|
//wxASSERT( m_prevVY >= 0 );
|
||
|
|
||
|
// Outside(check 1)?
|
||
|
if ( y >= (int)m_bottomy || y < 0 )
|
||
|
{
|
||
|
/*
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT("WARNING: DoGetItemAtY(a): y = %i"),y);
|
||
|
#endif
|
||
|
*/
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
// Need to recalculate visibility cache
|
||
|
// Note: need to check for y < m_prevVY is a hack.
|
||
|
if ( m_prevVY != vy ||y < m_prevVY ) //m_iFlags & wxPG_FL_SCROLLED ||
|
||
|
CalculateVisibles( vy, true );
|
||
|
|
||
|
// Outside(check 2)?
|
||
|
if ( y >= (vy+m_height) )
|
||
|
{
|
||
|
/*
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT("WARNING: DoGetItemAtY(b): y = %i"),y);
|
||
|
#endif
|
||
|
*/
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
unsigned int index = (unsigned int)((y - vy) / m_lineHeight);
|
||
|
|
||
|
// Consistency checks
|
||
|
if ( !m_arrVisible.GetCount() )
|
||
|
return (wxPGProperty*) NULL;
|
||
|
|
||
|
if ( index >= m_arrVisible.GetCount() )
|
||
|
{
|
||
|
#ifdef __WXDEBUG__
|
||
|
wxLogDebug(wxT(" index = %i"),(int)index);
|
||
|
wxLogDebug(wxT(" (height/lineheight+1) = %i"),(int)((m_height/m_lineHeight)+1));
|
||
|
wxLogDebug(wxT(" m_arrVisible.GetCount() = %i"),(int)m_arrVisible.GetCount());
|
||
|
|
||
|
// This was wxCHECK_MSG, but I don't want it to show, since it can happen from
|
||
|
// time to time, and I probably won't fix in the current version of wxPropertyGrid.
|
||
|
wxLogDebug( wxT("Not enough entries in m_arrVisible (y was < m_bottomy).") );
|
||
|
#endif
|
||
|
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
if ( index >= m_arrVisible.GetCount() )
|
||
|
{
|
||
|
index = m_arrVisible.GetCount()-1;
|
||
|
}
|
||
|
|
||
|
return (wxPGProperty*)m_arrVisible.Item(index);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid graphics related methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnPaint( wxPaintEvent& WXUNUSED(event) )
|
||
|
{
|
||
|
|
||
|
wxPG_PAINT_DC_INIT()
|
||
|
|
||
|
// Don't paint after destruction has begun
|
||
|
if ( !(m_iFlags & wxPG_FL_INITIALIZED) )
|
||
|
return;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::OnPaint()") );
|
||
|
#endif
|
||
|
|
||
|
// Find out where the window is scrolled to
|
||
|
int vx,vy; // Top left corner of client
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
// Update everything inside the box
|
||
|
wxRect r = GetUpdateRegion().GetBox();
|
||
|
|
||
|
r.y += vy;
|
||
|
|
||
|
// Repaint this rectangle
|
||
|
//if ( r.height > 0 )
|
||
|
DrawItems ( dc, r.y, r.y + r.height,
|
||
|
#if wxPG_ALLOW_CLIPPING
|
||
|
NULL //&r
|
||
|
#else
|
||
|
NULL
|
||
|
#endif
|
||
|
);
|
||
|
|
||
|
// We assume that the size set when grid is shown
|
||
|
// is what is desired.
|
||
|
m_iFlags |= wxPG_FL_GOOD_SIZE_SET;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
//
|
||
|
// This is the one called by OnPaint event handler and others.
|
||
|
// topy and bottomy are already unscrolled
|
||
|
// Clears any area in coordinates that doesn't have items.
|
||
|
//
|
||
|
void wxPropertyGrid::DrawItems( wxDC& dc,
|
||
|
unsigned int topy,
|
||
|
unsigned int bottomy,
|
||
|
const wxRect* clipRect )
|
||
|
{
|
||
|
if ( m_frozen || m_height < 1 || bottomy < topy || !m_pState ) return;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT("wxPropertyGrid::DrawItems ( %i -> %i, clipRect = 0x%X )"),topy,bottomy,
|
||
|
(unsigned int)clipRect);
|
||
|
#endif
|
||
|
|
||
|
// items added check
|
||
|
if ( FROM_STATE(m_itemsAdded) ) PrepareAfterItemsAdded();
|
||
|
|
||
|
unsigned int vx, vy; // Top left corner of client
|
||
|
GetViewStart((int*)&vx,(int*)&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
unsigned int client_bottom = (unsigned int)m_height + vy;
|
||
|
|
||
|
// Clip topy and bottomy
|
||
|
if ( bottomy > client_bottom )
|
||
|
bottomy = client_bottom;
|
||
|
if ( topy < vy )
|
||
|
topy = vy;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT(" \\--> ( final area %i -> %i )"),topy,bottomy);
|
||
|
#endif
|
||
|
|
||
|
//
|
||
|
// Determine first and last item to draw
|
||
|
// (don't draw if already over the top)
|
||
|
//
|
||
|
|
||
|
if ( topy < client_bottom && topy < m_bottomy && FROM_STATE(m_properties)->GetCount() > 0 )
|
||
|
{
|
||
|
|
||
|
wxPGProperty* firstItem = DoGetItemAtY(topy);
|
||
|
|
||
|
if ( firstItem == (wxPGProperty*) NULL )
|
||
|
{
|
||
|
#ifdef __WXDEBUG__
|
||
|
wxString msg;
|
||
|
msg.Printf(wxT("WARNING: wxPropertyGrid::DrawItems(): firstItem == NULL!"));
|
||
|
wxMessageBox(msg);
|
||
|
wxLogDebug(msg);
|
||
|
wxLogDebug(wxT(" More info: y: %i -> %i visible_window: %i -> %i"),
|
||
|
(int)topy,(int)bottomy,(int)vy,(int)client_bottom);
|
||
|
// This is here for debugging purposes.
|
||
|
DoGetItemAtY(topy);
|
||
|
#endif
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
wxPGProperty* lastItem = (wxPGProperty*) NULL;
|
||
|
|
||
|
// lastItem may be NULL on call to DoDrawItems
|
||
|
// in this case lastItem will truly become the last item
|
||
|
|
||
|
if ( bottomy > topy && bottomy < m_bottomy )
|
||
|
{
|
||
|
lastItem = DoGetItemAtY(bottomy-1);
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug( wxT(" \\--> WARNING: lastItem acquisition failed (should not)!"));
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
DoDrawItems( dc, firstItem, lastItem, clipRect );
|
||
|
}
|
||
|
|
||
|
// Clear area beyond m_bottomy?
|
||
|
if ( bottomy > m_bottomy )
|
||
|
{
|
||
|
wxColour& bgc = wxPG_SLACK_BACKROUND;
|
||
|
//wxColour& bgc = wxColour(255,0,255);
|
||
|
dc.SetPen ( wxPen(bgc) );
|
||
|
dc.SetBrush ( wxBrush(bgc) );
|
||
|
unsigned int clear_top = m_bottomy;
|
||
|
if ( topy > clear_top ) clear_top = topy;
|
||
|
dc.DrawRectangle ( 0, clear_top, m_width, m_height-(clear_top-vy) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#define DECLARE_ITEM_ITERATION_UVC_VARIABLES \
|
||
|
unsigned int ind; \
|
||
|
wxPGProperty* p;
|
||
|
|
||
|
// UVC = Use Visibility Cache
|
||
|
// VISTART = index to first item from visibility cache to use.
|
||
|
// BOTTOMY = Logical y coordinate of last item to draw.
|
||
|
#define ITEM_ITERATION_UVC_LOOP_BEGIN(VISTART,BOTTOMY) \
|
||
|
ind = VISTART; \
|
||
|
do \
|
||
|
{ \
|
||
|
p = (wxPGProperty*)m_arrVisible.Item(ind); \
|
||
|
ind++; \
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
#define ITEM_ITERATION_UVC_LOOP_END(BOTTOMY) \
|
||
|
} while ( p->m_y < BOTTOMY ); \
|
||
|
|
||
|
|
||
|
void wxPropertyGrid::DoDrawItems( wxDC& dcMain,
|
||
|
const wxPGProperty* firstItem,
|
||
|
const wxPGProperty* lastItem,
|
||
|
const wxRect* clipRect )
|
||
|
{
|
||
|
if ( m_frozen || m_height < 1 )
|
||
|
return;
|
||
|
|
||
|
//wxCHECK_RET( !FROM_STATE(m_itemsAdded), wxT("m_itemsAdded must be zero at this point") );
|
||
|
|
||
|
// items added check
|
||
|
if ( FROM_STATE(m_itemsAdded) ) PrepareAfterItemsAdded();
|
||
|
|
||
|
wxCHECK_RET( firstItem != NULL, wxT("invalid first item") );
|
||
|
wxASSERT( FROM_STATE(m_properties->GetCount()) );
|
||
|
|
||
|
// Make sure visibility cache is up-to-date
|
||
|
int vy;
|
||
|
int vx;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
if ( vy != m_prevVY )
|
||
|
CalculateVisibles(vy,true);
|
||
|
|
||
|
if ( vy != m_prevVY )
|
||
|
return;
|
||
|
|
||
|
// Determine last item, if not given (but requires clipRect).
|
||
|
if ( lastItem == NULL )
|
||
|
{
|
||
|
if ( clipRect != NULL )
|
||
|
{
|
||
|
unsigned int bottomy = clipRect->y + clipRect->height;
|
||
|
|
||
|
if ( bottomy <= (unsigned int)firstItem->m_y )
|
||
|
lastItem = firstItem;
|
||
|
}
|
||
|
|
||
|
if ( lastItem == NULL )
|
||
|
{
|
||
|
lastItem = DoGetItemAtY(vy+m_height-1);
|
||
|
if ( lastItem == NULL )
|
||
|
lastItem = GetLastItem(true);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
DoDrawItems2(dcMain, firstItem, lastItem, clipRect);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// Uses three pass approach, so it is optimized for drawing
|
||
|
// multiple items at once.
|
||
|
//
|
||
|
// IMPORTANT NOTES:
|
||
|
// - Clipping rectangle must be of physical coordinates.
|
||
|
//
|
||
|
//
|
||
|
void wxPropertyGrid::DoDrawItems2( wxDC& dcMain,
|
||
|
const wxPGProperty* firstItem,
|
||
|
const wxPGProperty* lastItem,
|
||
|
const wxRect* clipRect ) const
|
||
|
{
|
||
|
int lh = m_lineHeight;
|
||
|
|
||
|
int vy;
|
||
|
int vx;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
int firstItemTopY = firstItem->m_y;
|
||
|
int lastItemBottomY = lastItem->m_y+lh-1;
|
||
|
|
||
|
int yRelMod = 0;
|
||
|
|
||
|
// Entire range outside scrolled, visible area?
|
||
|
if ( firstItemTopY >= (vy+m_height) || lastItemBottomY <= vy )
|
||
|
return;
|
||
|
|
||
|
wxCHECK_RET( firstItemTopY < lastItemBottomY, wxT("invalid y values") );
|
||
|
|
||
|
wxDC* dcPtr;
|
||
|
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
wxMemoryDC* bufferDC = NULL;
|
||
|
const wxRect* blitClipRect = NULL;
|
||
|
int renderHeight = lastItem->m_y - firstItemTopY + m_lineHeight;
|
||
|
|
||
|
if ( !(GetExtraStyle() & wxPG_EX_NATIVE_DOUBLE_BUFFERING) )
|
||
|
{
|
||
|
if ( !m_doubleBuffer )
|
||
|
return;
|
||
|
|
||
|
// Must fit to double-buffer
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( (lastItemBottomY - firstItemTopY) > m_doubleBuffer->GetHeight() )
|
||
|
{
|
||
|
wxString msg;
|
||
|
msg.Printf( wxT("wxPropertyGrid: DOUBLE-BUFFER TOO SMALL ( drawn %i vs db height %i vs client_height %i)!"),
|
||
|
(int)(lastItemBottomY - firstItemTopY),
|
||
|
(int)(m_doubleBuffer->GetHeight()),
|
||
|
(int)m_height );
|
||
|
wxLogError(msg);
|
||
|
wxLogDebug(msg);
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
bufferDC = new wxMemoryDC();
|
||
|
bufferDC->SelectObject( *m_doubleBuffer );
|
||
|
dcPtr = bufferDC;
|
||
|
|
||
|
blitClipRect = clipRect;
|
||
|
|
||
|
//if ( m_iFlags & wxPG_FL_CHANGED ||
|
||
|
// !(m_iFlags & wxPG_FL_HANDLING_PAINT_EVENT) )
|
||
|
//{
|
||
|
}
|
||
|
else
|
||
|
#endif
|
||
|
{
|
||
|
dcPtr = &dcMain;
|
||
|
}
|
||
|
|
||
|
wxDC& dc = *dcPtr;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT(" -> DoDrawItems ( \"%s\" -> \"%s\", height=%i (ch=%i), clipRect = 0x%lX )"),
|
||
|
firstItem->GetLabel().c_str(),
|
||
|
lastItem->GetLabel().c_str(),
|
||
|
(int)(lastItemBottomY - firstItemTopY),
|
||
|
(int)m_height,
|
||
|
(unsigned long)clipRect );
|
||
|
#endif
|
||
|
|
||
|
wxPGPaintData paintdata;
|
||
|
wxRect r;
|
||
|
|
||
|
DECLARE_ITEM_ITERATION_UVC_VARIABLES
|
||
|
|
||
|
// Get first and last indexes to visibility cache
|
||
|
unsigned int viStart = (firstItemTopY - vy) / lh;
|
||
|
int vi_end_y = lastItem->m_y;
|
||
|
|
||
|
if ( viStart >= m_arrVisible.GetCount() )
|
||
|
{
|
||
|
wxLogDebug(wxT("WARNING: viStart >= m_arrVisible.GetCount() ( %i >= %i )"),
|
||
|
(int)viStart, (int)m_arrVisible.GetCount() );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
#ifdef __WXDEBUG__
|
||
|
unsigned int viEnd = (lastItem->m_y - vy) / lh;
|
||
|
if ( viEnd >= m_arrVisible.GetCount() )
|
||
|
{
|
||
|
wxLogDebug(wxT("WARNING: viEnd >= m_arrVisible.GetCount() ( %i >= %i )"),
|
||
|
(int)viEnd, (int)m_arrVisible.GetCount() );
|
||
|
return;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
int x = m_marginWidth;
|
||
|
int y;
|
||
|
|
||
|
long window_style = m_windowStyle;
|
||
|
int extraStyle = GetExtraStyle();
|
||
|
|
||
|
//
|
||
|
// With wxPG_DOUBLE_BUFFER, do double buffering
|
||
|
// - buffer's y = 0, so align cliprect and coordinates to that
|
||
|
//
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
if ( bufferDC )
|
||
|
{
|
||
|
wxRect cr2;
|
||
|
|
||
|
//yRelMod = firstItemTopY;
|
||
|
yRelMod = vy;
|
||
|
|
||
|
//
|
||
|
// clipRect conversion
|
||
|
if ( clipRect )
|
||
|
{
|
||
|
cr2 = *clipRect;
|
||
|
cr2.y -= yRelMod;
|
||
|
clipRect = &cr2;
|
||
|
}
|
||
|
//int renderHeight = lastItem->m_y - firstItemTopY + m_lineHeight;
|
||
|
//lastItemBottomY -= firstItemTopY;
|
||
|
//firstItemTopY = 0;
|
||
|
firstItemTopY -= vy;
|
||
|
lastItemBottomY -= vy;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
const wxFont& normalfont = m_font;
|
||
|
|
||
|
bool reallyFocused = (m_iFlags & wxPG_FL_FOCUSED) ? true : false;
|
||
|
|
||
|
bool isEnabled = IsEnabled();
|
||
|
|
||
|
//
|
||
|
// Prepare some pens and brushes that are often changed to.
|
||
|
//
|
||
|
|
||
|
wxBrush marginBrush(m_colMargin);
|
||
|
wxPen marginPen(m_colMargin);
|
||
|
wxBrush capbgbrush(m_colCapBack,wxSOLID);
|
||
|
wxPen linepen(m_colLine,1,wxSOLID);
|
||
|
|
||
|
// pen that has same colour as text
|
||
|
wxPen outlinepen(m_colPropFore,1,wxSOLID);
|
||
|
|
||
|
if ( clipRect )
|
||
|
dc.SetClippingRegion( *clipRect );
|
||
|
|
||
|
//
|
||
|
// Clear margin with background colour
|
||
|
//
|
||
|
dc.SetBrush( marginBrush );
|
||
|
if ( !(window_style & wxPG_HIDE_MARGIN) )
|
||
|
{
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
dc.DrawRectangle(-1,firstItemTopY-1,m_marginWidth+2,lastItemBottomY-firstItemTopY+3);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
// This colorizer helps to debug painting.
|
||
|
bool small_draw = false;
|
||
|
if ( renderHeight < (m_height-(lh*3)) )
|
||
|
{
|
||
|
if ( firstItem == lastItem )
|
||
|
{
|
||
|
bgbrush = wxBrush(wxColour(255,128,128));
|
||
|
linepen = wxPen(wxColour(128,0,255));
|
||
|
//boxbrush = wxBrush(wxColour(192,192,192));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
bgbrush = wxBrush(wxColour(128,255,128));
|
||
|
linepen = wxPen(wxColour(0,0,255));
|
||
|
//boxbrush = wxBrush(wxColour(230,230,230));
|
||
|
}
|
||
|
small_draw = true;
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
//dc.SetPen ( *wxTRANSPARENT_PEN );
|
||
|
//dc.SetFont(normalfont);
|
||
|
|
||
|
wxPGProperty* selected = m_selected;
|
||
|
|
||
|
/*#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
bool selected_painted = false;
|
||
|
#endif*/
|
||
|
|
||
|
// NOTE: Clipping and pen/brush switching are main reasons for multi-pass approach.
|
||
|
|
||
|
//
|
||
|
// zero'th pass: Wireframes.
|
||
|
// (this could be embedded in another loop)
|
||
|
|
||
|
dc.SetBrush( marginBrush );
|
||
|
|
||
|
unsigned long cur_first_ind = viStart;
|
||
|
unsigned long next_cur_first_ind = 0xFFFFFFFF;
|
||
|
wxPGPropertyWithChildren* cur_category = (wxPGPropertyWithChildren*) NULL;
|
||
|
int vcache_last_item_y = vy + m_height;
|
||
|
if ( vcache_last_item_y > (int)m_bottomy ) vcache_last_item_y = m_bottomy;
|
||
|
vcache_last_item_y -= lh;
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_BEGIN(viStart,vi_end_y)
|
||
|
|
||
|
wxPGPropertyWithChildren* parent = p->GetParent();
|
||
|
|
||
|
// Should not happen (but this is better than a crash)...
|
||
|
wxCHECK_RET( parent, wxT("NULL parent") );
|
||
|
|
||
|
// Does this wireframe end?
|
||
|
// Conditions:
|
||
|
// A) This is last item within its parent, and parent is category.
|
||
|
// B) Next is category.
|
||
|
// C) This is collapsed category.
|
||
|
// D) This is the last item drawn.
|
||
|
|
||
|
if ( p->m_y >= vi_end_y )
|
||
|
{
|
||
|
// This is the last item.
|
||
|
//wxLogDebug(wxT("--> last item"));
|
||
|
next_cur_first_ind = ind;
|
||
|
}
|
||
|
else if ( p->m_arrIndex >= (parent->GetCount()-1) && parent->GetParentingType() >= PT_CAPTION &&
|
||
|
( parenting <= 0 /*|| ((wxPGPropertyWithChildren*)p)->GetCount() < 1*/ )
|
||
|
)
|
||
|
{
|
||
|
// This is last item within its parent, and parent is category, but this isn't
|
||
|
// an non-empty category.
|
||
|
//wxLogDebug(wxT("--> category ends"));
|
||
|
cur_category = (wxPropertyCategoryClass*)parent;
|
||
|
next_cur_first_ind = ind;
|
||
|
}
|
||
|
else if ( ((wxPGProperty*)m_arrVisible.Item(ind))->GetParentingType() >= PT_CAPTION )
|
||
|
{
|
||
|
// Next item is a category.
|
||
|
//wxLogDebug(wxT("--> next item is category"));
|
||
|
next_cur_first_ind = ind;
|
||
|
}
|
||
|
else if ( parenting > 0 &&
|
||
|
(!((wxPGPropertyWithChildren*)p)->IsExpanded() ||
|
||
|
!((wxPGPropertyWithChildren*)p)->GetCount()) )
|
||
|
{
|
||
|
// This is collapsed category.
|
||
|
//wxLogDebug(wxT("--> collapsed category"));
|
||
|
cur_category = (wxPropertyCategoryClass*)p;
|
||
|
next_cur_first_ind = ind;
|
||
|
}
|
||
|
|
||
|
// When new category begins or old ends, draw wireframe for items in-between
|
||
|
if ( next_cur_first_ind < 0xFFFFFF )
|
||
|
{
|
||
|
|
||
|
wxPGProperty* cur_first = (wxPGProperty*)m_arrVisible.Item(cur_first_ind);
|
||
|
wxPGPropertyWithChildren* cur_last_item = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
if ( !cur_category )
|
||
|
{
|
||
|
if ( cur_first->GetParentingType() >= PT_CAPTION )
|
||
|
{
|
||
|
cur_category = (wxPropertyCategoryClass*)cur_first;
|
||
|
}
|
||
|
else if ( !(m_windowStyle & wxPG_HIDE_CATEGORIES) )
|
||
|
{
|
||
|
cur_category = _GetPropertyCategory(cur_first);
|
||
|
/*if ( !cur_category )
|
||
|
cur_category = (wxPropertyCategoryClass*)FROM_STATE(m_properties);*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int draw_top = cur_first->m_y - yRelMod;
|
||
|
int draw_bottom = cur_last_item->m_y + lh - yRelMod;
|
||
|
int frame_top = draw_top;
|
||
|
int frame_bottom = draw_bottom;
|
||
|
int margin_top = draw_top;
|
||
|
int margin_bottom = draw_bottom;
|
||
|
|
||
|
int ly = frame_top + lh - 1;
|
||
|
|
||
|
if ( cur_first->GetParentingType() >= PT_CAPTION )
|
||
|
{
|
||
|
wxPropertyCategoryClass* pc = ((wxPropertyCategoryClass*)cur_first);
|
||
|
frame_top += lh;
|
||
|
if ( !pc->IsExpanded() )
|
||
|
{
|
||
|
// Category collapsed.
|
||
|
frame_top = frame_bottom + 1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int grey_x = x;
|
||
|
if ( cur_category /*!(window_style & wxPG_HIDE_CATEGORIES)*/ )
|
||
|
grey_x += ((unsigned int)((cur_category->GetDepth()-1)*m_subgroup_extramargin));
|
||
|
|
||
|
//wxLogDebug( wxT("wireframe: %s -> %s (grey_x:%i)"), cur_first->GetLabel().c_str(),
|
||
|
// cur_last_item->GetLabel().c_str(),((int)grey_x-x));
|
||
|
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
|
||
|
// Clear extra margin area.
|
||
|
dc.DrawRectangle( x-1, margin_top, grey_x - x + 1, margin_bottom-margin_top );
|
||
|
|
||
|
dc.SetPen( linepen );
|
||
|
|
||
|
if ( frame_bottom > frame_top )
|
||
|
{
|
||
|
|
||
|
//if ( cat_top < firstItemTopY )
|
||
|
// cat_top = firstItemTopY;
|
||
|
|
||
|
|
||
|
// Margin Edge
|
||
|
dc.DrawLine ( grey_x, frame_top, grey_x, frame_bottom );
|
||
|
|
||
|
// Splitter
|
||
|
dc.DrawLine ( m_splitterx, frame_top, m_splitterx, frame_bottom );
|
||
|
|
||
|
// Horizontal Lines
|
||
|
while ( ly < (frame_bottom-1) )
|
||
|
{
|
||
|
dc.DrawLine ( grey_x, ly, m_width, ly );
|
||
|
ly += lh;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
int use_depth = grey_x; // Default is to simply tidy up this wireframe.
|
||
|
|
||
|
// Properly draw top line of next wireframe, if adjacent.
|
||
|
|
||
|
// Get next item.
|
||
|
wxPGProperty* next_item;
|
||
|
//if ( ind < m_arrVisible.GetCount() )
|
||
|
if ( cur_last_item->m_y < vcache_last_item_y )
|
||
|
{
|
||
|
next_item = (wxPGProperty*)m_arrVisible.Item(ind);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Was not in visibility cache, so use clumsier method.
|
||
|
next_item = GetNeighbourItem(cur_last_item,true,1);
|
||
|
if (!next_item)
|
||
|
next_item = cur_last_item; // This will serve our purpose.
|
||
|
}
|
||
|
//wxLogDebug(wxT("next_item: %s"),next_item->GetLabel().c_str());
|
||
|
|
||
|
// Just take the depth and is-it-category out of it.
|
||
|
int next_parenting = next_item->GetParentingType();
|
||
|
int last_parenting = cur_last_item->GetParentingType();
|
||
|
|
||
|
// A) If both are categories, draw line with background colour.
|
||
|
// B) If only next is category, use its category's depth.
|
||
|
// C) If only last is category, use grey_x as depth.
|
||
|
// D) If neither is a category, use smaller.
|
||
|
if ( next_parenting > 0 )
|
||
|
{
|
||
|
// Next is category.
|
||
|
|
||
|
if ( last_parenting > 0 )
|
||
|
{
|
||
|
// Last is a category too - draw complete line with background colour.
|
||
|
dc.SetPen ( marginPen );
|
||
|
use_depth = x;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Next is not a category.
|
||
|
wxPropertyCategoryClass* next_cat = _GetPropertyCategory(next_item);
|
||
|
int depth_next = x;
|
||
|
if ( next_cat && /*cur_category*/ !(window_style & wxPG_HIDE_CATEGORIES) )
|
||
|
{
|
||
|
//wxLogDebug(wxT("next_item_cat: %s"),next_cat->GetLabel().c_str());
|
||
|
depth_next += ((unsigned int)((next_cat->GetDepth()-1)*m_subgroup_extramargin));
|
||
|
}
|
||
|
|
||
|
if ( last_parenting <= 0 )
|
||
|
{
|
||
|
// Last is not a category - use lesser depth
|
||
|
if ( depth_next < grey_x )
|
||
|
use_depth = depth_next;
|
||
|
//wxLogDebug(wxT("- neither is category"));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Last is a category
|
||
|
use_depth = depth_next;
|
||
|
//wxLogDebug(wxT("last only is category"));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//wxLogDebug(wxT("last_line_use_depth: %i"),(int)use_depth);
|
||
|
dc.DrawLine( use_depth, ly, m_width, ly );
|
||
|
|
||
|
cur_first_ind = next_cur_first_ind;
|
||
|
next_cur_first_ind = 0xFFFFFFFF;
|
||
|
//cur_first = (wxPGPropertyWithChildren*)p;
|
||
|
cur_category = (wxPGPropertyWithChildren*) NULL;
|
||
|
}
|
||
|
|
||
|
//cur_last_item = p;
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_END(vi_end_y)
|
||
|
|
||
|
//
|
||
|
// First pass: Category background and text, Images, Label+value background.
|
||
|
//
|
||
|
|
||
|
//wxLogDebug(wxT(" \\--> first pass..."));
|
||
|
y = firstItemTopY;
|
||
|
|
||
|
dc.SetFont( m_captionFont );
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_BEGIN(viStart,vi_end_y)
|
||
|
|
||
|
y += m_spacingy;
|
||
|
|
||
|
int text_x = x + ((unsigned int)((p->GetDepth()-1)*m_subgroup_extramargin));
|
||
|
|
||
|
if ( parenting > 0 )
|
||
|
{
|
||
|
|
||
|
dc.SetBrush( capbgbrush ); // Category label background colour.
|
||
|
|
||
|
// Category - draw background, text and possibly selection rectangle.
|
||
|
wxPropertyCategoryClass* pc = (wxPropertyCategoryClass*)p;
|
||
|
|
||
|
// Note how next separator line is overdrawn if next item is category .
|
||
|
int useLh = lh;
|
||
|
if ( ind < (m_arrVisible.GetCount()) &&
|
||
|
( ((wxPGProperty*)m_arrVisible[ind])->GetParentingType() <= 0 ) )
|
||
|
useLh -= 1;
|
||
|
|
||
|
if ( isEnabled && p->IsEnabled() )
|
||
|
dc.SetTextForeground( *(wxPGColour*)m_arrFgCols[pc->GetTextColIndex()] );
|
||
|
else
|
||
|
dc.SetTextForeground( m_colDisPropFore );
|
||
|
|
||
|
dc.DrawRectangle( text_x, y-m_spacingy, m_width-text_x, useLh );
|
||
|
dc.DrawText( pc->GetLabel(), text_x+wxPG_XBEFORETEXT, y );
|
||
|
|
||
|
// active caption gets nice dotted rectangle
|
||
|
if ( p == selected )
|
||
|
{
|
||
|
wxRect focusRect(text_x+wxPG_XBEFORETEXT-wxPG_CAPRECTXMARGIN,
|
||
|
y-wxPG_CAPRECTYMARGIN,
|
||
|
pc->GetTextExtent()+(wxPG_CAPRECTXMARGIN*2),
|
||
|
m_fontHeight+(wxPG_CAPRECTYMARGIN*2));
|
||
|
wxPGDrawFocusRect(dc,focusRect);
|
||
|
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
// Basic background colour.
|
||
|
dc.SetBrush( *(wxPGBrush*)m_arrBgBrushes[p->m_bgColIndex] );
|
||
|
|
||
|
//wxLogDebug(wxT("%s: %i"),p->m_label.c_str(),(int)p->m_depthBgCol);
|
||
|
|
||
|
int greyDepth = 0;
|
||
|
if ( !(window_style & wxPG_HIDE_CATEGORIES) )
|
||
|
greyDepth = (((int)p->m_depthBgCol)-1) * m_subgroup_extramargin;
|
||
|
|
||
|
// In two parts to retain splitter
|
||
|
|
||
|
if ( p == m_selected )
|
||
|
{
|
||
|
// Selected get different label background.
|
||
|
if ( reallyFocused )
|
||
|
dc.SetBrush( m_colSelBack );
|
||
|
else
|
||
|
dc.SetBrush( m_colLine );
|
||
|
|
||
|
dc.DrawRectangle( x+greyDepth+1, y-m_spacingy, m_splitterx-greyDepth-x-1, lh-1 );
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dc.DrawRectangle( x+greyDepth+1, y-m_spacingy, m_splitterx-greyDepth-x-1, lh-1 );
|
||
|
}
|
||
|
|
||
|
dc.DrawRectangle( m_splitterx+1, y-m_spacingy, m_width-m_splitterx, lh-1 );
|
||
|
|
||
|
}
|
||
|
|
||
|
y += m_fontHeight+m_spacingy+1;
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_END(vi_end_y)
|
||
|
|
||
|
dc.SetFont( normalfont );
|
||
|
|
||
|
//
|
||
|
// Second pass: Expander Buttons, Labels.
|
||
|
//
|
||
|
// Second pass happens entirely on the left side, so sometimes
|
||
|
// we can just skip it.
|
||
|
|
||
|
if ( clipRect == NULL || clipRect->x < m_splitterx )
|
||
|
{
|
||
|
//wxLogDebug(wxT(" \\--> second pass..."));
|
||
|
|
||
|
y = firstItemTopY;
|
||
|
|
||
|
r = wxRect(0,y,m_splitterx,lastItemBottomY);
|
||
|
dc.SetClippingRegion ( r );
|
||
|
|
||
|
dc.SetFont(normalfont);
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_BEGIN(viStart,vi_end_y)
|
||
|
|
||
|
if ( isEnabled && (p->IsEnabled() || !(extraStyle & wxPG_EX_GREY_LABEL_WHEN_DISABLED)) )
|
||
|
dc.SetTextForeground( *(wxPGColour*)m_arrFgCols[p->m_fgColIndex] );
|
||
|
else
|
||
|
dc.SetTextForeground( m_colDisPropFore );
|
||
|
|
||
|
//
|
||
|
// Expand/collapse button image.
|
||
|
if ( parenting != 0 &&
|
||
|
!(window_style & wxPG_HIDE_MARGIN) &&
|
||
|
((wxPGPropertyWithChildren*)p)->GetChildCount() )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
int depth = p->m_depth - 1;
|
||
|
|
||
|
#ifdef wxPG_ICON_WIDTH
|
||
|
int imageX = m_gutterWidth + ( depth * m_subgroup_extramargin );
|
||
|
#endif
|
||
|
|
||
|
y += m_buttonSpacingY;
|
||
|
|
||
|
#if (wxPG_USE_RENDERER_NATIVE)
|
||
|
// Prepare rectangle to be used
|
||
|
r.x = imageX; r.y = y;
|
||
|
r.width = m_iconWidth; r.height = m_iconHeight;
|
||
|
#elif wxPG_ICON_WIDTH
|
||
|
// Drawing expand/collapse button manually
|
||
|
dc.SetPen(m_colPropFore);
|
||
|
if ( parenting > 0 )
|
||
|
{
|
||
|
dc.SetBrush(*wxTRANSPARENT_BRUSH);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dc.SetBrush(m_colPropBack);
|
||
|
}
|
||
|
dc.DrawRectangle( imageX, y, m_iconWidth, m_iconWidth );
|
||
|
int _y = y+(m_iconWidth/2);
|
||
|
dc.DrawLine(imageX+2,_y,imageX+m_iconWidth-2,_y);
|
||
|
#else
|
||
|
wxBitmap* bmp;
|
||
|
#endif
|
||
|
|
||
|
if ( pwc->m_expanded )
|
||
|
{
|
||
|
// wxRenderer functions are non-mutating in nature, so it
|
||
|
// should be safe to cast "const wxPropertyGrid*" to "wxWindow*".
|
||
|
// Hopefully this does not cause problems.
|
||
|
#if (wxPG_USE_RENDERER_NATIVE)
|
||
|
wxRendererNative::Get().DrawTreeItemButton(
|
||
|
(wxWindow*)this,
|
||
|
dc,
|
||
|
r,
|
||
|
wxCONTROL_EXPANDED
|
||
|
);
|
||
|
#elif wxPG_ICON_WIDTH
|
||
|
//
|
||
|
#else
|
||
|
bmp = m_collbmp;
|
||
|
#endif
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#if (wxPG_USE_RENDERER_NATIVE)
|
||
|
wxRendererNative::Get().DrawTreeItemButton(
|
||
|
(wxWindow*)this,
|
||
|
dc,
|
||
|
r,
|
||
|
0
|
||
|
);
|
||
|
#elif wxPG_ICON_WIDTH
|
||
|
int _x = imageX+(m_iconWidth/2);
|
||
|
dc.DrawLine(_x,y+2,_x,y+m_iconWidth-2);
|
||
|
#else
|
||
|
bmp = m_expandbmp;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
#if (wxPG_USE_RENDERER_NATIVE)
|
||
|
//
|
||
|
#elif wxPG_ICON_WIDTH
|
||
|
//
|
||
|
#else
|
||
|
dc.DrawBitmap( *bmp, m_gutterWidth, y, true );
|
||
|
#endif
|
||
|
|
||
|
y -= m_buttonSpacingY;
|
||
|
}
|
||
|
|
||
|
y += m_spacingy;
|
||
|
|
||
|
if ( parenting <= 0 )
|
||
|
{
|
||
|
// Non-categories.
|
||
|
|
||
|
int text_x = x;
|
||
|
// Use basic depth if in non-categoric mode and parent is base array.
|
||
|
if ( !(window_style & wxPG_HIDE_CATEGORIES) || p->GetParent() != FROM_STATE(m_properties) )
|
||
|
{
|
||
|
text_x += ((unsigned int)((p->m_depth-1)*m_subgroup_extramargin));
|
||
|
}
|
||
|
/*
|
||
|
else
|
||
|
{
|
||
|
wxLogDebug( wxT("%s"), p->GetLabel().c_str() );
|
||
|
text_x = x;
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
if ( p != selected )
|
||
|
{
|
||
|
dc.DrawText( p->m_label, text_x+wxPG_XBEFORETEXT, y );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Selected gets different colour.
|
||
|
if ( reallyFocused )
|
||
|
dc.SetTextForeground( m_colSelFore );
|
||
|
|
||
|
dc.DrawText( p->m_label, text_x+wxPG_XBEFORETEXT, y );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*// switch background colour
|
||
|
bgbrush.SetColour ( ((wxPropertyCategoryClass*)p)->m_colCellBg );
|
||
|
dc.SetBrush ( bgbrush );*/
|
||
|
}
|
||
|
|
||
|
y += m_fontHeight+m_spacingy+1;
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_END(vi_end_y)
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
// Third pass: Values
|
||
|
//
|
||
|
dc.DestroyClippingRegion();
|
||
|
|
||
|
if ( clipRect )
|
||
|
{
|
||
|
// third pass happens entirely on the right side, so sometimes
|
||
|
// we can just skip it
|
||
|
if ( (clipRect->x + clipRect->width) < m_splitterx )
|
||
|
x = -1;
|
||
|
dc.SetClippingRegion ( *clipRect );
|
||
|
}
|
||
|
|
||
|
// This used with value drawer method.
|
||
|
wxRect valueRect(0,0,
|
||
|
m_width-(m_splitterx+wxPG_CONTROL_MARGIN),
|
||
|
m_fontHeight);
|
||
|
|
||
|
wxSize imageSize;
|
||
|
|
||
|
if ( x != -1 )
|
||
|
{
|
||
|
|
||
|
r.x = m_splitterx+1+wxPG_CONTROL_MARGIN;
|
||
|
r.width = m_width-m_splitterx-wxPG_CONTROL_MARGIN;
|
||
|
//r.x = m_splitterx+wxPG_DIST_SPLITTER_TO_IMAGE;
|
||
|
//r.width = m_width-m_splitterx-wxPG_DIST_SPLITTER_TO_IMAGE-1;
|
||
|
r.height = lh-1;
|
||
|
|
||
|
/*#if wxCC_CORRECT_CONTROL_POSITION
|
||
|
const int vy2 = vy;
|
||
|
#endif*/
|
||
|
|
||
|
//wxLogDebug(wxT(" \\--> third pass..."));
|
||
|
|
||
|
// Altough this line may seem unnecessary, it isn't
|
||
|
dc.SetFont(normalfont);
|
||
|
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
|
||
|
// Prepare paintdata.
|
||
|
paintdata.m_parent = this;
|
||
|
paintdata.m_choiceItem = -1; // Not drawing list item at this time.
|
||
|
|
||
|
y = firstItemTopY;
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_BEGIN(viStart,vi_end_y)
|
||
|
|
||
|
if ( parenting <= 0 )
|
||
|
{
|
||
|
r.y = y;
|
||
|
y += m_spacingy;
|
||
|
|
||
|
// background
|
||
|
dc.SetBrush( *(wxPGBrush*)m_arrBgBrushes[p->m_bgColIndex] );
|
||
|
|
||
|
if ( isEnabled && p->IsEnabled() )
|
||
|
dc.SetTextForeground( *(wxPGColour*)m_arrFgCols[p->m_fgColIndex] );
|
||
|
else
|
||
|
dc.SetTextForeground( m_colDisPropFore );
|
||
|
|
||
|
// draw value string only if editor widget not open
|
||
|
// (exception: no primary editor widget or it is hidden)
|
||
|
if ( p != selected || !m_wndPrimary
|
||
|
// "if not primary shown" is required because
|
||
|
// primary is not usually shown during splitter
|
||
|
// movement.
|
||
|
|| m_dragStatus > 0
|
||
|
)
|
||
|
{
|
||
|
|
||
|
valueRect.x = m_splitterx+wxPG_CONTROL_MARGIN;
|
||
|
valueRect.y = y;
|
||
|
|
||
|
// Draw background
|
||
|
if ( p != selected )
|
||
|
{
|
||
|
dc.DrawRectangle( r );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_wndPrimary )
|
||
|
dc.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW ) );
|
||
|
else
|
||
|
dc.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW ) );
|
||
|
|
||
|
dc.DrawRectangle( r );
|
||
|
}
|
||
|
|
||
|
// Set bold font?
|
||
|
if ( p->m_flags & wxPG_PROP_MODIFIED && (window_style & wxPG_BOLD_MODIFIED) )
|
||
|
dc.SetFont( m_captionFont );
|
||
|
|
||
|
const wxPGEditor* editor = p->GetEditorClass();
|
||
|
bool fullPaint = false;
|
||
|
|
||
|
if ( p->m_flags & wxPG_PROP_CUSTOMIMAGE )
|
||
|
{
|
||
|
imageSize = p->GetImageSize();
|
||
|
|
||
|
wxRect imageRect(r.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
|
||
|
r.y+wxPG_CUSTOM_IMAGE_SPACINGY,
|
||
|
wxPG_CUSTOM_IMAGE_WIDTH,
|
||
|
r.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
|
||
|
|
||
|
if ( imageSize.x == wxPG_FULL_CUSTOM_PAINT_WIDTH )
|
||
|
{
|
||
|
fullPaint = true;
|
||
|
imageRect.width = m_width - imageRect.x;
|
||
|
}
|
||
|
|
||
|
dc.SetPen( outlinepen );
|
||
|
|
||
|
paintdata.m_drawnWidth = imageRect.width;
|
||
|
|
||
|
if ( !(p->m_flags & wxPG_PROP_UNSPECIFIED) )
|
||
|
{
|
||
|
p->OnCustomPaint( dc, imageRect, paintdata );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dc.SetBrush(*wxWHITE_BRUSH);
|
||
|
dc.DrawRectangle(imageRect);
|
||
|
}
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
}
|
||
|
else
|
||
|
paintdata.m_drawnWidth = 0;
|
||
|
|
||
|
if ( paintdata.m_drawnWidth > 0 )
|
||
|
valueRect.x += paintdata.m_drawnWidth + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
|
||
|
else
|
||
|
fullPaint = false;
|
||
|
|
||
|
if ( !fullPaint )
|
||
|
editor->DrawValue(dc,p,valueRect);
|
||
|
|
||
|
// Return original font?
|
||
|
if ( p->m_flags & wxPG_PROP_MODIFIED && (window_style & wxPG_BOLD_MODIFIED) )
|
||
|
dc.SetFont(normalfont);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
if ( !(m_iFlags & wxPG_FL_PRIMARY_FILLS_ENTIRE) ||
|
||
|
m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE )
|
||
|
{
|
||
|
//wxLogDebug(wxT("Primary doesn't fill entire"));
|
||
|
dc.SetBrush( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW ) );
|
||
|
dc.DrawRectangle( r );
|
||
|
}
|
||
|
if ( m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE )
|
||
|
{
|
||
|
wxRect imagerect(r.x + wxPG_CONTROL_MARGIN + wxCC_CUSTOM_IMAGE_MARGIN1,
|
||
|
r.y+wxPG_CUSTOM_IMAGE_SPACINGY,wxPG_CUSTOM_IMAGE_WIDTH,
|
||
|
r.height-(wxPG_CUSTOM_IMAGE_SPACINGY*2));
|
||
|
|
||
|
dc.SetPen ( outlinepen );
|
||
|
if ( !(p->m_flags & wxPG_PROP_UNSPECIFIED) )
|
||
|
{
|
||
|
p->OnCustomPaint( dc, imagerect, paintdata );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
dc.SetBrush(*wxWHITE_BRUSH);
|
||
|
dc.DrawRectangle(imagerect);
|
||
|
}
|
||
|
}
|
||
|
dc.SetPen( *wxTRANSPARENT_PEN );
|
||
|
}
|
||
|
|
||
|
y += m_fontHeight+m_spacingy + 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// caption item
|
||
|
y += lh;
|
||
|
}
|
||
|
|
||
|
//if ( y > lastItemBottomY ) { parent = NULL; break; }
|
||
|
|
||
|
ITEM_ITERATION_UVC_LOOP_END(vi_end_y)
|
||
|
|
||
|
}
|
||
|
|
||
|
dc.DestroyClippingRegion(); // Is this really necessary?
|
||
|
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
//}
|
||
|
//else wxLogDebug(wxT("Used Cache"));
|
||
|
|
||
|
if ( bufferDC )
|
||
|
{
|
||
|
if ( blitClipRect )
|
||
|
dcMain.SetClippingRegion( *blitClipRect );
|
||
|
//wxLogDebug(wxT(" \\--> (0,%i)"),(int)final_y);
|
||
|
dcMain.Blit ( 0, firstItem->m_y, m_width, renderHeight,
|
||
|
&dc, 0, firstItem->m_y-vy, wxCOPY );
|
||
|
//dcMain.Blit ( 0, 0, m_width, m_height,
|
||
|
// &dc, 0, 0, wxCOPY );
|
||
|
dcMain.DestroyClippingRegion(); // Is this really necessary?
|
||
|
delete bufferDC;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT(" \\--> ends..."));
|
||
|
#endif
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxRect wxPropertyGrid::GetPropertyRect( const wxPGProperty* p1, const wxPGProperty* p2 ) const
|
||
|
{
|
||
|
wxRect r;
|
||
|
|
||
|
if ( m_width < 10 || m_height < 10 ||
|
||
|
!FROM_STATE(m_properties)->GetCount() ||
|
||
|
p1 == (wxPGProperty*) NULL )
|
||
|
return wxRect(0,0,0,0);
|
||
|
|
||
|
int vx,vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
//
|
||
|
// Return rect which encloses the given property range
|
||
|
|
||
|
int visTop = p1->m_y;
|
||
|
int visBottom = m_bottomy;
|
||
|
if ( p2 )
|
||
|
visBottom = p2->m_y + m_lineHeight;
|
||
|
|
||
|
// If seleced property is inside the range, we'll extend the range to include
|
||
|
// control's size.
|
||
|
wxPGProperty* selected = m_selected;
|
||
|
if ( selected && selected->m_y >= visTop && selected->m_y < visBottom )
|
||
|
{
|
||
|
wxWindow* editor = GetEditorControl();
|
||
|
if ( editor )
|
||
|
{
|
||
|
int visBottom2 = selected->m_y + editor->GetSize().y;
|
||
|
if ( visBottom2 > visBottom )
|
||
|
visBottom = visBottom2;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return wxRect(0,visTop-vy,m_width,visBottom-visTop);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::DrawItems( const wxPGProperty* p1, const wxPGProperty* p2 )
|
||
|
{
|
||
|
if ( m_frozen )
|
||
|
return;
|
||
|
|
||
|
if ( FROM_STATE(m_itemsAdded) )
|
||
|
PrepareAfterItemsAdded();
|
||
|
|
||
|
wxRect r = GetPropertyRect(p1, p2);
|
||
|
if ( r.width > 0 )
|
||
|
RefreshRect(r);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// In addition to calling DoDrawItems directly, this is the
|
||
|
// only alternative for using wxClientDC - others just call
|
||
|
// RefreshRect.
|
||
|
void wxPropertyGrid::DrawItem( wxDC& dc, wxPGProperty* p )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
|
||
|
// do not draw a single item if multiple pending
|
||
|
if ( FROM_STATE(m_itemsAdded) )
|
||
|
return;
|
||
|
|
||
|
if ( p->m_y < 0 )
|
||
|
return;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT("wxPropertyGrid::DrawItem( %s )"), p->GetLabel().c_str() );
|
||
|
#endif
|
||
|
|
||
|
DoDrawItems( dc, p, p, NULL );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::RefreshProperty( wxPGProperty* p )
|
||
|
{
|
||
|
if ( p == m_selected )
|
||
|
DoSelectProperty(p, wxPG_SEL_FORCE);
|
||
|
|
||
|
DrawItemAndChildren(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::DrawItemAndValueRelated( wxPGProperty* p )
|
||
|
{
|
||
|
if ( m_frozen )
|
||
|
return;
|
||
|
|
||
|
// Draw item, children, and parent too, if it is not category
|
||
|
wxPGProperty* parent = p->GetParent();
|
||
|
|
||
|
while ( parent &&
|
||
|
parent->GetParentingType() < PT_NONE )
|
||
|
{
|
||
|
DrawItem(parent);
|
||
|
parent = parent->GetParent();
|
||
|
}
|
||
|
|
||
|
DrawItemAndChildren(p);
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::DrawItemAndChildren( wxPGProperty* p )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
|
||
|
// Do not draw if in non-visible page
|
||
|
if ( p->GetParentState() != m_pState )
|
||
|
return;
|
||
|
|
||
|
// do not draw a single item if multiple pending
|
||
|
if ( FROM_STATE(m_itemsAdded) || p->m_y < 0 || m_frozen )
|
||
|
return;
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug(wxT("wxPropertyGrid::DrawItemAndChildren( %s )"), p->GetLabel().c_str() );
|
||
|
#endif
|
||
|
|
||
|
// Update child control.
|
||
|
if ( m_selected && m_selected->GetParent() == p )
|
||
|
m_selected->UpdateControl(m_wndPrimary);
|
||
|
|
||
|
const wxPGProperty* lastDrawn = p->GetLastVisibleSubItem();
|
||
|
|
||
|
DrawItems(p, lastDrawn);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Refresh( bool WXUNUSED(eraseBackground),
|
||
|
const wxRect *rect )
|
||
|
{
|
||
|
// Refresh implies forced redraw
|
||
|
//m_iFlags |= wxPG_FL_CHANGED;
|
||
|
|
||
|
wxWindow::Refresh(false,rect);
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
// I think this really helps only GTK+1.2
|
||
|
if ( m_wndPrimary ) m_wndPrimary->Refresh();
|
||
|
if ( m_wndSecondary ) m_wndSecondary->Refresh();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
/*
|
||
|
void wxPropertyGrid::RedrawAllVisible ()
|
||
|
{
|
||
|
// TODO: Is this safe?
|
||
|
//Update();
|
||
|
|
||
|
if ( m_frozen || !IsShown() )
|
||
|
return;
|
||
|
|
||
|
wxPG_CLIENT_DC_INIT()
|
||
|
|
||
|
#if __PAINT_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::RedrawAllVisible()") );
|
||
|
#endif
|
||
|
|
||
|
int vx,vy; // Top left corner of client
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
int y1 = vy;
|
||
|
int y2 = y1 + m_height;
|
||
|
|
||
|
// Repaint this rectangle
|
||
|
DrawItems ( dc, y1, y2, (wxRect*) NULL );
|
||
|
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
void wxPropertyGrid::DrawSplitterDragColumn( wxDC&, int ) { }
|
||
|
#else
|
||
|
void wxPropertyGrid::DrawSplitterDragColumn( wxDC& dc, int x )
|
||
|
{
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
dc.SetLogicalFunction(wxINVERT);
|
||
|
dc.DestroyClippingRegion();
|
||
|
|
||
|
dc.SetPen( m_splitterpen );
|
||
|
dc.DrawLine(x,vy,x,vy+m_height);
|
||
|
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid global operations
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Clear()
|
||
|
{
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
bool selRes = DoSelectProperty(wxPGIdGen(NULL), wxPG_SEL_DELETING); // This must be before state clear
|
||
|
wxPG_CHECK_RET_DBG( selRes,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
FROM_STATE(Clear());
|
||
|
|
||
|
m_propHover = NULL;
|
||
|
m_bottomy = 0;
|
||
|
|
||
|
m_prevVY = 0;
|
||
|
m_arrVisible.Empty();
|
||
|
|
||
|
RecalculateVirtualSize();
|
||
|
|
||
|
// Need to clear some area at the end
|
||
|
if ( !m_frozen )
|
||
|
RefreshRect(wxRect(0, 0, m_width, m_height));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::EnableCategories( bool enable )
|
||
|
{
|
||
|
if ( !ClearSelection() )
|
||
|
return false;
|
||
|
|
||
|
if ( enable )
|
||
|
{
|
||
|
//
|
||
|
// Enable categories
|
||
|
//
|
||
|
|
||
|
m_windowStyle &= ~(wxPG_HIDE_CATEGORIES);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//
|
||
|
// Disable categories
|
||
|
//
|
||
|
m_windowStyle |= wxPG_HIDE_CATEGORIES;
|
||
|
}
|
||
|
|
||
|
if ( !m_pState->EnableCategories(enable) )
|
||
|
return false;
|
||
|
|
||
|
if ( !m_frozen )
|
||
|
{
|
||
|
if ( m_windowStyle & wxPG_AUTO_SORT )
|
||
|
{
|
||
|
FROM_STATE(m_itemsAdded) = 1; // force
|
||
|
PrepareAfterItemsAdded();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CalculateYs(NULL,-1);
|
||
|
//CalculateVisibles( -1 );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
FROM_STATE(m_itemsAdded) = 1;
|
||
|
|
||
|
Refresh();
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SwitchState( wxPropertyGridState* pNewState )
|
||
|
{
|
||
|
wxASSERT( pNewState );
|
||
|
|
||
|
wxPGProperty* oldSelection = m_selected;
|
||
|
|
||
|
// Deselect
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
bool selRes = ClearSelection();
|
||
|
wxPG_CHECK_RET_DBG( selRes,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
m_pState->m_selected = oldSelection;
|
||
|
|
||
|
bool orig_mode = m_pState->IsInNonCatMode();
|
||
|
bool new_state_mode = pNewState->IsInNonCatMode();
|
||
|
|
||
|
m_pState = pNewState;
|
||
|
|
||
|
m_bottomy = 0; // This is necessary or y's won't get updated.
|
||
|
m_propHover = (wxPGProperty*) NULL;
|
||
|
|
||
|
// If necessary, convert state to correct mode.
|
||
|
if ( orig_mode != new_state_mode )
|
||
|
{
|
||
|
// This should refresh as well.
|
||
|
EnableCategories ( orig_mode?false:true );
|
||
|
}
|
||
|
else if ( !m_frozen )
|
||
|
{
|
||
|
// Refresh, if not frozen.
|
||
|
if ( FROM_STATE(m_itemsAdded) )
|
||
|
PrepareAfterItemsAdded();
|
||
|
else
|
||
|
CalculateYs(NULL,-1);
|
||
|
|
||
|
// Reselect
|
||
|
if ( FROM_STATE(m_selected) )
|
||
|
DoSelectProperty( FROM_STATE(m_selected) );
|
||
|
|
||
|
//RedrawAllVisible();
|
||
|
Refresh();
|
||
|
}
|
||
|
else
|
||
|
m_pState->m_itemsAdded = 1;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Sort( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
m_pState->Sort( p );
|
||
|
|
||
|
// Because order changed, Y's need to be changed as well
|
||
|
if ( p->GetParentState() == m_pState )
|
||
|
CalculateYs ( p->m_parent, p->m_arrIndex );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::Sort()
|
||
|
{
|
||
|
bool selRes = ClearSelection(); // This must be before state clear
|
||
|
wxPG_CHECK_RET_DBG( selRes,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
|
||
|
m_pState->Sort();
|
||
|
|
||
|
CalculateYs( NULL, -1 );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Call to SetSplitterPosition will always disable splitter auto-centering
|
||
|
// if parent window is shown.
|
||
|
void wxPropertyGrid::DoSetSplitterPosition( int newxpos, bool refresh )
|
||
|
{
|
||
|
if ( ( newxpos < wxPG_DRAG_MARGIN ) )
|
||
|
return;
|
||
|
// ( m_width > wxPG_DRAG_MARGIN && newxpos > (m_width-wxPG_DRAG_MARGIN) )
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::DoSetSplitterPosition ( %i )"), newxpos );
|
||
|
#endif
|
||
|
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
m_splitterx = newxpos;
|
||
|
m_fSplitterX = (float) newxpos;
|
||
|
|
||
|
if ( refresh )
|
||
|
{
|
||
|
if ( m_selected )
|
||
|
CorrectEditorWidgetSizeX( m_splitterx, m_width );
|
||
|
|
||
|
Refresh();
|
||
|
//RedrawAllVisible(); // no flicker
|
||
|
}
|
||
|
#else
|
||
|
if ( !m_dragStatus )
|
||
|
{
|
||
|
// Only do this if this was not a call from HandleMouseUp
|
||
|
m_startingSplitterX = m_splitterx;
|
||
|
m_splitterx = newxpos;
|
||
|
m_fSplitterX = (float) newxpos;
|
||
|
}
|
||
|
|
||
|
// Clear old
|
||
|
if ( m_splitterprevdrawnx != -1 )
|
||
|
{
|
||
|
wxPG_CLIENT_DC_INIT()
|
||
|
|
||
|
DrawSplitterDragColumn( dc, m_splitterprevdrawnx );
|
||
|
m_splitterprevdrawnx = -1;
|
||
|
}
|
||
|
|
||
|
// Redraw only if drag really moved
|
||
|
if ( m_splitterx != m_startingSplitterX && refresh )
|
||
|
{
|
||
|
if ( m_selected)
|
||
|
CorrectEditorWidgetSizeX( m_splitterx, m_width );
|
||
|
|
||
|
Update(); // This fixes a graphics-mess in wxMSW
|
||
|
|
||
|
Refresh();
|
||
|
//RedrawAllVisible(); // no flicker
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// Don't allow initial splitter auto-positioning after this.
|
||
|
m_iFlags |= wxPG_FL_SPLITTER_PRE_SET;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::CenterSplitter( bool enable_auto_centering )
|
||
|
{
|
||
|
SetSplitterPosition ( m_width/2, true );
|
||
|
if ( enable_auto_centering && ( m_windowStyle & wxPG_SPLITTER_AUTO_CENTER ) )
|
||
|
m_iFlags &= ~(wxPG_FL_DONT_CENTER_SPLITTER);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Moves splitter so that all labels are visible, but just.
|
||
|
void wxPropertyGrid::SetSplitterLeft( bool subProps )
|
||
|
{
|
||
|
wxClientDC dc(this);
|
||
|
dc.SetFont(m_font);
|
||
|
|
||
|
int maxW = m_pState->GetLeftSplitterPos(dc, m_pState->m_properties, subProps );
|
||
|
|
||
|
if ( maxW > 0 )
|
||
|
SetSplitterPosition( maxW );
|
||
|
|
||
|
m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid item iteration (GetNextProperty etc.) methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Returns nearest paint visible property (such that will be painted unless
|
||
|
// window is scrolled or resized). If given property is paint visible, then
|
||
|
// it itself will be returned
|
||
|
wxPGProperty* wxPropertyGrid::GetNearestPaintVisible( wxPGProperty* p )
|
||
|
{
|
||
|
int vx,vy1;// Top left corner of client
|
||
|
GetViewStart(&vx,&vy1);
|
||
|
vy1 *= wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
int vy2 = vy1 + m_height;
|
||
|
|
||
|
if ( (p->m_y + m_lineHeight) < vy1 )
|
||
|
{
|
||
|
// Too high
|
||
|
return DoGetItemAtY( vy1 );
|
||
|
}
|
||
|
else if ( p->m_y > vy2 )
|
||
|
{
|
||
|
// Too low
|
||
|
return DoGetItemAtY( vy2 );
|
||
|
}
|
||
|
|
||
|
// Itself paint visible
|
||
|
return p;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGProperty* wxPropertyGrid::GetNeighbourItem( wxPGProperty* item,
|
||
|
bool need_visible,
|
||
|
int dir ) const
|
||
|
{
|
||
|
wxPGPropertyWithChildren* parent = item->m_parent;
|
||
|
unsigned int indinparent = item->GetIndexInParent();
|
||
|
|
||
|
if ( dir > 0 )
|
||
|
{
|
||
|
if ( item->GetChildCount() == 0 ||
|
||
|
(!((wxPGPropertyWithChildren*)item)->m_expanded && need_visible) )
|
||
|
{
|
||
|
// current item did not have any expanded children
|
||
|
if ( indinparent < (parent->GetCount()-1) )
|
||
|
{
|
||
|
// take next in parent's array
|
||
|
item = parent->Item(indinparent+1);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// no more in parent's array; move up until found;
|
||
|
wxPGPropertyWithChildren* p2 = parent;
|
||
|
parent = parent->m_parent;
|
||
|
item = (wxPGProperty*) NULL;
|
||
|
while ( parent )
|
||
|
{
|
||
|
if ( p2->m_arrIndex < (parent->GetCount()-1) )
|
||
|
{
|
||
|
item = parent->Item(p2->m_arrIndex+1);
|
||
|
break;
|
||
|
}
|
||
|
p2 = parent;
|
||
|
parent = parent->m_parent;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// take first of current item's children
|
||
|
wxPGPropertyWithChildren* p2 = (wxPGPropertyWithChildren*)item;
|
||
|
item = p2->Item(0);
|
||
|
//indinparent = 0;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
// items in array left?
|
||
|
if ( indinparent > 0 )
|
||
|
{
|
||
|
// take prev in parent's array
|
||
|
item = parent->Item(indinparent-1);
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)item;
|
||
|
|
||
|
// Recurse to it's last child
|
||
|
while ( item->GetParentingType() != 0 && pwc->GetCount() &&
|
||
|
( pwc->m_expanded || !need_visible )
|
||
|
)
|
||
|
{
|
||
|
item = pwc->Last();
|
||
|
pwc = (wxPGPropertyWithChildren*)item;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// If we were at first, go to parent
|
||
|
item = parent;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( item == FROM_STATE(m_properties) )
|
||
|
return (wxPGProperty*) NULL;
|
||
|
|
||
|
// If item was hidden and need_visible, get next.
|
||
|
if ( (m_iFlags & wxPG_FL_HIDE_STATE) && need_visible && item )
|
||
|
{
|
||
|
if ( item->m_flags & wxPG_PROP_HIDEABLE )
|
||
|
{
|
||
|
// Speed-up: If parent is hidden as well, then skip to last child or to itself
|
||
|
if ( parent->m_flags & wxPG_PROP_HIDEABLE )
|
||
|
{
|
||
|
item = parent; // if dir up
|
||
|
if ( dir > 0 )
|
||
|
item = parent->Last(); // if dir down
|
||
|
}
|
||
|
|
||
|
return GetNeighbourItem ( item, need_visible, dir );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return item;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// This is used in DoDrawItems.
|
||
|
wxPGProperty* wxPropertyGrid::GetLastItem ( bool need_visible, bool allowSubprops )
|
||
|
{
|
||
|
if ( FROM_STATE(m_properties)->GetCount() < 1 )
|
||
|
return (wxPGProperty*) NULL;
|
||
|
|
||
|
wxPGProperty* p = FROM_STATE(m_properties)->Last();
|
||
|
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
while ( parenting != 0 && ( allowSubprops || parenting >= PT_CAPTION ) )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
parenting = 0;
|
||
|
if ( pwc->GetCount() )
|
||
|
{
|
||
|
|
||
|
if ( (!need_visible || pwc->m_expanded) )
|
||
|
{
|
||
|
p = pwc->Last();
|
||
|
parenting = p->GetParentingType();
|
||
|
}
|
||
|
else
|
||
|
parenting = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// If item was hidden and need_visible, get previous.
|
||
|
if ( (m_iFlags & wxPG_FL_HIDE_STATE) &&
|
||
|
need_visible &&
|
||
|
p && ( p->m_flags & wxPG_PROP_HIDEABLE )
|
||
|
)
|
||
|
return GetNeighbourItem( p, need_visible, -1 );
|
||
|
|
||
|
return p;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetButtonShortcut( int keycode, bool ctrlDown, bool altDown )
|
||
|
{
|
||
|
if ( keycode )
|
||
|
{
|
||
|
m_pushButKeyCode = keycode;
|
||
|
m_pushButKeyCodeNeedsCtrl = ctrlDown ? 1 : 0;
|
||
|
m_pushButKeyCodeNeedsAlt = altDown ? 1 : 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_pushButKeyCode = WXK_DOWN;
|
||
|
m_pushButKeyCodeNeedsCtrl = 0;
|
||
|
m_pushButKeyCodeNeedsAlt = 1;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Methods related to change in value, value modification and sending events
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// commits any changes in editor of selected property
|
||
|
// return true if validation did not fail
|
||
|
// flags are same as with DoSelectProperty
|
||
|
bool wxPropertyGrid::CommitChangesFromEditor( wxUint32 flags )
|
||
|
{
|
||
|
if ( m_wndPrimary && IsEditorsValueModified() &&
|
||
|
(m_iFlags & wxPG_FL_INITIALIZED) )
|
||
|
{
|
||
|
wxCHECK_MSG( m_selected, false, wxT("no selection") );
|
||
|
|
||
|
bool wasUnspecified = m_selected->IsValueUnspecified();
|
||
|
|
||
|
// JACS - necessary to avoid new focus being found spuriously within OnIdle
|
||
|
// due to another window getting focus
|
||
|
wxWindow* oldFocus = m_curFocused;
|
||
|
|
||
|
if ( !(flags & (wxPG_SEL_NOVALIDATE|wxPG_SEL_FORCE)) &&
|
||
|
!DoEditorValidate() )
|
||
|
{
|
||
|
if (oldFocus)
|
||
|
{
|
||
|
oldFocus->SetFocus();
|
||
|
m_curFocused = oldFocus;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Save value (only if truly modified).
|
||
|
if ( !m_selected->GetEditorClass()->CopyValueFromControl( m_selected, m_wndPrimary ) )
|
||
|
EditorsValueWasNotModified();
|
||
|
|
||
|
if ( m_selected->IsValueUnspecified() && !wasUnspecified && UsesAutoUnspecified() )
|
||
|
flags |= wxPG_SEL_SETUNSPEC;
|
||
|
|
||
|
DoPropertyChanged( m_selected, flags );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// flags are same as with DoSelectProperty
|
||
|
void wxPropertyGrid::DoPropertyChanged( wxPGProperty* p, unsigned int selFlags )
|
||
|
{
|
||
|
if ( m_processingEvent )
|
||
|
return;
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("wxPropertyGrid::DoPropertyChanged( %s )"),p->GetLabel().c_str());
|
||
|
#endif
|
||
|
|
||
|
m_pState->m_anyModified = 1;
|
||
|
|
||
|
m_processingEvent = 1;
|
||
|
|
||
|
// No longer unspecified (but not if the value was set to unspecified by
|
||
|
// user modification)
|
||
|
if ( !(selFlags & wxPG_SEL_SETUNSPEC) )
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(p);
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_VALUE_MODIFIED )
|
||
|
{
|
||
|
m_iFlags &= ~(wxPG_FL_VALUE_MODIFIED);
|
||
|
|
||
|
// Set as Modified (not if dragging just began)
|
||
|
if ( !(p->m_flags & wxPG_PROP_MODIFIED) )
|
||
|
{
|
||
|
p->m_flags |= wxPG_PROP_MODIFIED;
|
||
|
if ( p == m_selected && (m_windowStyle & wxPG_BOLD_MODIFIED) )
|
||
|
{
|
||
|
if ( m_wndPrimary )
|
||
|
SetCurControlBoldFont();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
wxPGProperty* curChild = p;
|
||
|
wxPGPropertyWithChildren* curParent = p->m_parent;
|
||
|
|
||
|
// Also update parent(s), if any
|
||
|
// (but not if its wxCustomProperty)
|
||
|
|
||
|
while ( curParent &&
|
||
|
curParent->GetParentingType() < 0 /*&&
|
||
|
wxStrcmp(curParent->GetClassName(),wxT("wxCustomProperty")) != 0*/ )
|
||
|
{
|
||
|
// Set as Modified
|
||
|
if ( !(curParent->m_flags & wxPG_PROP_MODIFIED) )
|
||
|
{
|
||
|
curParent->m_flags |= wxPG_PROP_MODIFIED;
|
||
|
if ( curParent == m_selected && (m_windowStyle & wxPG_BOLD_MODIFIED) )
|
||
|
{
|
||
|
if ( m_wndPrimary )
|
||
|
SetCurControlBoldFont();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
curParent->ChildChanged( curChild );
|
||
|
|
||
|
DrawItem( curParent );
|
||
|
|
||
|
curChild = curParent;
|
||
|
curParent = curParent->GetParent();
|
||
|
}
|
||
|
|
||
|
// Draw the actual property
|
||
|
if ( ( p != m_selected ) || !m_wndPrimary ||
|
||
|
( p->GetParentingType() < 0 ) ||
|
||
|
( p->m_flags & wxPG_PROP_CUSTOMIMAGE ) )
|
||
|
{
|
||
|
DrawItemAndChildren( p );
|
||
|
}
|
||
|
|
||
|
if ( curChild != p && !(selFlags & wxPG_SEL_SETUNSPEC) )
|
||
|
//m_pState->ClearPropertyAndChildrenFlags(curChild,wxPG_PROP_UNSPECIFIED);
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(curChild);
|
||
|
|
||
|
wxPGProperty* changedProperty;
|
||
|
|
||
|
// Call wx event handler for property (or its topmost parent, but only
|
||
|
// when dealing with legitemate sub-properties - see above).
|
||
|
if ( curChild->GetParentingType() != PT_CUSTOMPROPERTY )
|
||
|
changedProperty = curChild;
|
||
|
else
|
||
|
changedProperty = p;
|
||
|
|
||
|
// Maybe need to update control
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
if ( m_wndPrimary ) m_wndPrimary->Refresh();
|
||
|
if ( m_wndSecondary ) m_wndSecondary->Refresh();
|
||
|
#endif
|
||
|
|
||
|
SendEvent( wxEVT_PG_CHANGED, changedProperty, selFlags );
|
||
|
}
|
||
|
|
||
|
m_processingEvent = 0;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Runs wxValidator for the selected property
|
||
|
bool wxPropertyGrid::DoEditorValidate()
|
||
|
{
|
||
|
#if wxUSE_VALIDATORS
|
||
|
if ( m_iFlags & wxPG_FL_VALIDATION_FAILED )
|
||
|
{
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
wxWindow* wnd = GetEditorControl();
|
||
|
|
||
|
wxValidator* validator = m_selected->GetValidator();
|
||
|
if ( validator && wnd )
|
||
|
{
|
||
|
// Use TextCtrl of ODComboBox instead
|
||
|
if ( wnd->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)) )
|
||
|
{
|
||
|
wnd = ((wxPGOwnerDrawnComboBox*)wnd)->GetTextCtrl();
|
||
|
|
||
|
if ( !wnd )
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
validator->SetWindow(wnd);
|
||
|
|
||
|
// Instead setting the flag after the failure, we set
|
||
|
// it before checking and then clear afterwards if things
|
||
|
// went fine. This trick is necessary since focus events
|
||
|
// may be triggered while in Validate.
|
||
|
m_iFlags |= wxPG_FL_VALIDATION_FAILED;
|
||
|
if ( !validator->Validate(this) )
|
||
|
{
|
||
|
// If you dpm't want to display message multiple times per change,
|
||
|
// comment the following line.
|
||
|
m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
|
||
|
return false;
|
||
|
}
|
||
|
m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
|
||
|
}
|
||
|
#endif
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxUSE_VALIDATORS
|
||
|
bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* propGrid,
|
||
|
wxValidator* validator,
|
||
|
const wxString& value )
|
||
|
{
|
||
|
if ( !validator )
|
||
|
return true;
|
||
|
|
||
|
wxTextCtrl* tc = m_textCtrl;
|
||
|
|
||
|
if ( !tc )
|
||
|
{
|
||
|
{
|
||
|
tc = new wxTextCtrl( propGrid, wxPG_SUBID_TEMP1, wxEmptyString,
|
||
|
wxPoint(30000,30000));
|
||
|
tc->Hide();
|
||
|
}
|
||
|
|
||
|
m_textCtrl = tc;
|
||
|
}
|
||
|
|
||
|
//wxString oldValue = tc->GetValue();
|
||
|
tc->SetValue(value);
|
||
|
|
||
|
validator->SetWindow(tc);
|
||
|
bool res = validator->Validate(propGrid);
|
||
|
|
||
|
//tc->SetValue(oldValue);
|
||
|
return res;
|
||
|
}
|
||
|
#else
|
||
|
bool wxPGInDialogValidator::DoValidate( wxPropertyGrid* WXUNUSED(propGrid),
|
||
|
wxValidator* WXUNUSED(validator),
|
||
|
const wxString& WXUNUSED(value) )
|
||
|
{
|
||
|
return true;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// NB: It may really not be wxCommandEvent - must check if necessary
|
||
|
// (usually not).
|
||
|
void wxPropertyGrid::OnCustomEditorEvent( wxCommandEvent &event )
|
||
|
{
|
||
|
wxPGProperty* selected = m_selected;
|
||
|
|
||
|
//
|
||
|
// Somehow, event is handled after property has been deselected.
|
||
|
// Possibly, but very rare.
|
||
|
if ( !selected )
|
||
|
return;
|
||
|
|
||
|
bool wasUnspecified = selected->IsValueUnspecified();
|
||
|
bool usesAutoUnspecified = UsesAutoUnspecified();
|
||
|
wxWindow* wnd = m_wndPrimary;
|
||
|
bool res1, res2;
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
|
||
|
|
||
|
// First call editor class' event handler.
|
||
|
const wxPGEditor* editor = selected->GetEditorClass();
|
||
|
res1 = editor->OnEvent( this, selected, wnd, event );
|
||
|
|
||
|
if ( res1 )
|
||
|
{
|
||
|
// If changes, validate them
|
||
|
if ( DoEditorValidate() )
|
||
|
{
|
||
|
if ( editor->CopyValueFromControl( selected, wnd ) )
|
||
|
{
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// False alarm
|
||
|
res1 = false;
|
||
|
|
||
|
EditorsValueWasNotModified();
|
||
|
|
||
|
// However, even moot editing will clear the unspecified status
|
||
|
if ( wasUnspecified || !usesAutoUnspecified )
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(selected);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
res1 = false;
|
||
|
EditorsValueWasNotModified();
|
||
|
if ( wasUnspecified || !usesAutoUnspecified )
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(selected);
|
||
|
return;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Then the property's custom handler (must be always called).
|
||
|
res2 = selected->OnEvent( this, wnd, event );
|
||
|
|
||
|
if ( res1 || res2 )
|
||
|
{
|
||
|
// Setting this is not required if res was true, so we do it now.
|
||
|
m_iFlags |= wxPG_FL_VALUE_MODIFIED;
|
||
|
|
||
|
int selFlags = ( !wasUnspecified && selected->IsValueUnspecified() && usesAutoUnspecified ) ? wxPG_SEL_SETUNSPEC : 0;
|
||
|
|
||
|
DoPropertyChanged(selected, selFlags);
|
||
|
}
|
||
|
else
|
||
|
// Let unhandled button click events go to the parent
|
||
|
if ( event.GetEventType() == wxEVT_COMMAND_BUTTON_CLICKED )
|
||
|
{
|
||
|
wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED,GetId());
|
||
|
GetEventHandler()->AddPendingEvent(evt);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// When a property's value was modified internally (using SetValueFromString
|
||
|
// or SetValueFromInt, for example), then this should be called afterwards.
|
||
|
// NB: Avoid using this method, if possible.
|
||
|
void wxPropertyGrid::PropertyWasModified( wxPGProperty* p, int selFlags )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
EditorsValueWasModified();
|
||
|
DoPropertyChanged(p, selFlags);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid editor control helper methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxWindow* wxPropertyGrid::GetEditorControl() const
|
||
|
{
|
||
|
wxWindow* ctrl = m_wndPrimary;
|
||
|
|
||
|
if ( !ctrl )
|
||
|
return ctrl;
|
||
|
|
||
|
// If it's clipper window, return its child instead
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
|
||
|
{
|
||
|
return ((wxPGClipperWindow*)ctrl)->GetControl();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
return ctrl;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// inline because it is used exactly once in the code
|
||
|
inline wxRect wxPropertyGrid::GetEditorWidgetRect( wxPGProperty* p )
|
||
|
{
|
||
|
//wxASSERT( p->m_y >= 0 ); // item is not visible
|
||
|
|
||
|
int itemy = p->m_y;
|
||
|
int vx,vy;// Top left corner of client
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy *= wxPG_PIXELS_PER_UNIT;
|
||
|
int cust_img_space = 0;
|
||
|
|
||
|
//m_iFlags &= ~(wxPG_FL_CUR_USES_CUSTOM_IMAGE);
|
||
|
|
||
|
// TODO: If custom image detection changes from current, change this.
|
||
|
if ( m_iFlags & wxPG_FL_CUR_USES_CUSTOM_IMAGE /*p->m_flags & wxPG_PROP_CUSTOMIMAGE*/ )
|
||
|
{
|
||
|
//m_iFlags |= wxPG_FL_CUR_USES_CUSTOM_IMAGE;
|
||
|
int imwid = p->GetImageSize().x;
|
||
|
if ( imwid < 1 ) imwid = wxPG_CUSTOM_IMAGE_WIDTH;
|
||
|
cust_img_space = imwid + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
|
||
|
}
|
||
|
|
||
|
return wxRect
|
||
|
(
|
||
|
m_splitterx+cust_img_space+wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1,
|
||
|
itemy-vy,
|
||
|
m_width-m_splitterx-wxPG_XBEFOREWIDGET-wxPG_CONTROL_MARGIN-cust_img_space-1,
|
||
|
m_lineHeight-1
|
||
|
);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// return size of custom paint image
|
||
|
wxSize wxPropertyGrid::GetImageSize( wxPGId id ) const
|
||
|
{
|
||
|
if ( wxPGIdIsOk(id) )
|
||
|
{
|
||
|
wxSize cis = wxPGIdToPtr(id)->GetImageSize();
|
||
|
|
||
|
if ( cis.x < 0 )
|
||
|
{
|
||
|
if ( cis.x <= -1 )
|
||
|
cis.x = wxPG_CUSTOM_IMAGE_WIDTH;
|
||
|
}
|
||
|
if ( cis.y <= 0 )
|
||
|
{
|
||
|
if ( cis.y >= -1 )
|
||
|
cis.y = wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight);
|
||
|
else
|
||
|
cis.y = -cis.y;
|
||
|
}
|
||
|
return cis;
|
||
|
}
|
||
|
// If called with NULL property, then return default image
|
||
|
// size for properties that use image.
|
||
|
return wxSize(wxPG_CUSTOM_IMAGE_WIDTH,wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::CorrectEditorWidgetSizeX( int newSplitterx, int newWidth )
|
||
|
{
|
||
|
wxASSERT( m_selected );
|
||
|
|
||
|
int secWid = 0;
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
{
|
||
|
// if width change occurred, move secondary wnd by that amount
|
||
|
wxRect r = m_wndSecondary->GetRect();
|
||
|
secWid = r.width;
|
||
|
r.x = newWidth - secWid;
|
||
|
//r.y += yAdj;
|
||
|
|
||
|
m_wndSecondary->SetSize ( r );
|
||
|
|
||
|
// if primary is textctrl, then we have to add some extra space
|
||
|
#ifdef __WXMAC__
|
||
|
if ( m_wndPrimary )
|
||
|
#else
|
||
|
if ( m_wndPrimary && m_wndPrimary->IsKindOf(CLASSINFO(wxTextCtrl)) )
|
||
|
#endif
|
||
|
secWid += wxPG_TEXTCTRL_AND_BUTTON_SPACING;
|
||
|
}
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
wxRect r = m_wndPrimary->GetRect();
|
||
|
|
||
|
r.x = newSplitterx+m_ctrlXAdjust;
|
||
|
//r.y += yAdj;
|
||
|
r.width = newWidth - r.x - secWid;
|
||
|
|
||
|
m_wndPrimary->SetSize(r);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
int sec_wid = 0;
|
||
|
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
int propY = m_selected->m_y - vy;
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
{
|
||
|
// if width change occurred, move secondary wnd by that amount
|
||
|
wxRect r = m_wndSecondary->GetRect();
|
||
|
int adjust = r.y % wxPG_PIXELS_PER_UNIT;
|
||
|
if ( adjust > (wxPG_PIXELS_PER_UNIT/2) )
|
||
|
adjust = adjust - wxPG_PIXELS_PER_UNIT;
|
||
|
int y = propY + adjust;
|
||
|
sec_wid = r.width;
|
||
|
|
||
|
m_wndSecondary->Move ( new_width-r.width,y );
|
||
|
|
||
|
// if primary is textctrl, then we have to add some extra space
|
||
|
if ( m_wndPrimary && m_wndPrimary->IsKindOf(CLASSINFO(wxTextCtrl)) )
|
||
|
sec_wid += wxPG_TEXTCTRL_AND_BUTTON_SPACING;
|
||
|
}
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
wxRect r = m_wndPrimary->GetRect();
|
||
|
int adjust = r.y % wxPG_PIXELS_PER_UNIT;
|
||
|
if ( adjust > (wxPG_PIXELS_PER_UNIT/2) )
|
||
|
adjust = adjust - wxPG_PIXELS_PER_UNIT;
|
||
|
wxLogDebug(wxT("adjust: %i"),adjust);
|
||
|
int y = propY + adjust;
|
||
|
|
||
|
m_wndPrimary->SetSize(
|
||
|
new_splitterx+m_ctrlXAdjust,
|
||
|
y,
|
||
|
new_width-(new_splitterx+m_ctrlXAdjust)-sec_wid,
|
||
|
r.height
|
||
|
);
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
m_wndSecondary->Refresh();
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
/*void wxPropertyGrid::CorrectEditorWidgetSizeY( int cy )
|
||
|
{
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
wxPoint cp(0,cy);
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
m_wndPrimary->Move ( m_wndPrimary->GetPosition() + cp );
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
m_wndSecondary->Move ( m_wndSecondary->GetPosition() + cp );
|
||
|
}
|
||
|
}*/
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// takes scrolling into account
|
||
|
void wxPropertyGrid::ImprovedClientToScreen( int* px, int* py )
|
||
|
{
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
vx*=wxPG_PIXELS_PER_UNIT;
|
||
|
*px -= vx;
|
||
|
*py -= vy;
|
||
|
ClientToScreen ( px, py );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// custom set cursor
|
||
|
void wxPropertyGrid::CustomSetCursor( int type, bool override )
|
||
|
{
|
||
|
if ( type == m_curcursor && !override ) return;
|
||
|
|
||
|
wxCursor* cursor = &wxPG_DEFAULT_CURSOR;
|
||
|
|
||
|
if ( type == wxCURSOR_SIZEWE )
|
||
|
cursor = m_cursorSizeWE;
|
||
|
|
||
|
SetCursor ( *cursor );
|
||
|
|
||
|
//if ( m_wndPrimary ) m_wndPrimary->SetCursor(wxNullCursor);
|
||
|
|
||
|
m_curcursor = type;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid property selection
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#define CONNECT_CHILD(EVT,FUNCTYPE,FUNC) \
|
||
|
wnd->Connect(id, EVT, \
|
||
|
(wxObjectEventFunction) (wxEventFunction) \
|
||
|
FUNCTYPE (&wxPropertyGrid::FUNC), \
|
||
|
NULL, this );
|
||
|
|
||
|
/*
|
||
|
class MyEvtHandler : public wxEvtHandler
|
||
|
{
|
||
|
public:
|
||
|
virtual bool ProcessEvent( wxEvent& event )
|
||
|
{
|
||
|
if ( event.GetEventType() == wxEVT_NAVIGATION_KEY )
|
||
|
wxLogDebug(wxT("wxEVT_NAVIGATION_KEY(id=%i)"),event.GetId());
|
||
|
else if ( event.GetEventType() == wxEVT_KEY_DOWN )
|
||
|
wxLogDebug(wxT("wxEVT_KEY_DOWN"));
|
||
|
event.Skip();
|
||
|
return wxEvtHandler::ProcessEvent(event);
|
||
|
}
|
||
|
};
|
||
|
*/
|
||
|
|
||
|
// Setups event handling for child control
|
||
|
void wxPropertyGrid::SetupEventHandling( wxWindow* argWnd, int id )
|
||
|
{
|
||
|
wxWindow* wnd = argWnd;
|
||
|
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
// Pass real control instead of clipper window
|
||
|
if ( wnd->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
|
||
|
{
|
||
|
wnd = ((wxPGClipperWindow*)argWnd)->GetControl();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
if ( argWnd == m_wndPrimary )
|
||
|
{
|
||
|
CONNECT_CHILD(wxEVT_MOTION,(wxMouseEventFunction),OnMouseMoveChild)
|
||
|
CONNECT_CHILD(wxEVT_LEFT_UP,(wxMouseEventFunction),OnMouseUpChild)
|
||
|
CONNECT_CHILD(wxEVT_LEFT_DOWN,(wxMouseEventFunction),OnMouseClickChild)
|
||
|
//CONNECT_CHILD(wxEVT_LEFT_DCLICK,(wxMouseEventFunction),OnMouseClickChild)
|
||
|
CONNECT_CHILD(wxEVT_RIGHT_UP,(wxMouseEventFunction),OnMouseRightClickChild)
|
||
|
CONNECT_CHILD(wxEVT_ENTER_WINDOW,(wxMouseEventFunction),OnMouseEntry)
|
||
|
CONNECT_CHILD(wxEVT_LEAVE_WINDOW,(wxMouseEventFunction),OnMouseEntry)
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CONNECT_CHILD(wxEVT_NAVIGATION_KEY,(wxNavigationKeyEventFunction),OnNavigationKey)
|
||
|
}
|
||
|
CONNECT_CHILD(wxEVT_KEY_DOWN,(wxCharEventFunction),OnChildKeyDown)
|
||
|
CONNECT_CHILD(wxEVT_KEY_UP,(wxCharEventFunction),OnChildKeyUp)
|
||
|
CONNECT_CHILD(wxEVT_KILL_FOCUS,(wxFocusEventFunction),OnFocusEvent)
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::FreeEditors()
|
||
|
{
|
||
|
// Do not free editors immediately if processing events
|
||
|
if ( !m_windowsToDelete )
|
||
|
m_windowsToDelete = new wxArrayPtrVoid;
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
{
|
||
|
m_windowsToDelete->push_back(m_wndSecondary);
|
||
|
m_wndSecondary->Hide();
|
||
|
m_wndSecondary = (wxWindow*) NULL;
|
||
|
}
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
m_windowsToDelete->push_back(m_wndPrimary);
|
||
|
m_wndPrimary->Hide();
|
||
|
m_wndPrimary = (wxWindow*) NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Call with NULL to de-select property
|
||
|
bool wxPropertyGrid::DoSelectProperty( wxPGProperty* p, unsigned int flags )
|
||
|
{
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
if (p)
|
||
|
wxLogDebug(wxT("SelectProperty( %s (%s[%i]) )"),p->m_label.c_str(),
|
||
|
p->m_parent->m_label.c_str(),p->GetIndexInParent());
|
||
|
else
|
||
|
wxLogDebug(wxT("SelectProperty( NULL, -1 )"));
|
||
|
#endif
|
||
|
|
||
|
//
|
||
|
// Delete windows pending for deletion
|
||
|
if ( m_windowsToDelete && !m_processingEvent && m_windowsToDelete->size() )
|
||
|
{
|
||
|
unsigned int i;
|
||
|
|
||
|
for ( i=0; i<m_windowsToDelete->size(); i++ )
|
||
|
delete ((wxWindow*)((*m_windowsToDelete)[i]));
|
||
|
|
||
|
m_windowsToDelete->clear();
|
||
|
}
|
||
|
|
||
|
wxPGProperty* prev = m_selected;
|
||
|
|
||
|
//
|
||
|
// If we are frozen, then just set the values.
|
||
|
if ( m_frozen )
|
||
|
{
|
||
|
m_iFlags &= ~(wxPG_FL_ABNORMAL_EDITOR);
|
||
|
m_editorFocused = 0;
|
||
|
m_selected = p;
|
||
|
FROM_STATE(m_selected) = p;
|
||
|
|
||
|
// If frozen, always free controls. But don't worry, as Thaw will
|
||
|
// recall SelectProperty to recreate them.
|
||
|
FreeEditors();
|
||
|
|
||
|
// Prevent any further selection measures in this call
|
||
|
p = (wxPGProperty*) NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Is it the same?
|
||
|
if ( m_selected == p && !(flags & wxPG_SEL_FORCE) )
|
||
|
{
|
||
|
// Only set focus if not deselecting
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( flags & wxPG_SEL_FOCUS )
|
||
|
{
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
m_wndPrimary->SetFocus();
|
||
|
m_editorFocused = 1;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
wxScrolledWindow::SetFocus();
|
||
|
m_editorFocused = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
wxClientDC dc(this);
|
||
|
PrepareDC(dc);
|
||
|
|
||
|
// Don't put this earlier, due to return statements
|
||
|
m_iFlags |= wxPG_FL_IN_SELECT_PROPERTY;
|
||
|
|
||
|
//
|
||
|
// First, deactivate previous
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT(" (closing previous (%s))"), m_selected->m_label.c_str() );
|
||
|
#endif
|
||
|
|
||
|
// Must double-check if this is an selected in case of forceswitch
|
||
|
if ( p != prev )
|
||
|
{
|
||
|
if ( !CommitChangesFromEditor(flags) )
|
||
|
{
|
||
|
// Validation has failed, so we can't exit the previous editor
|
||
|
//::wxMessageBox(_("Please correct the value or press ESC to cancel the edit."),
|
||
|
// _("Invalid Value"),wxOK|wxICON_ERROR);
|
||
|
return false;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
FreeEditors();
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_SELECTED_IS_PAINT_FLEXIBLE|wxPG_FL_SELECTED_IS_FULL_PAINT);
|
||
|
m_selected = (wxPGProperty*) NULL;
|
||
|
FROM_STATE(m_selected) = (wxPGProperty*) NULL;
|
||
|
|
||
|
// Make sure the previous selection is refreshed
|
||
|
|
||
|
// JACS: must use paint handler whenever possible
|
||
|
Refresh(false);
|
||
|
|
||
|
/*if ( m_iFlags & wxPG_FL_ABNORMAL_EDITOR )
|
||
|
Refresh(false);
|
||
|
else if ( prev->m_y < (int)m_bottomy )
|
||
|
DoDrawItems( dc, prev, prev, NULL );
|
||
|
*/
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_VALUE_MODIFIED|wxPG_FL_ABNORMAL_EDITOR);
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// Then, activate the one given.
|
||
|
if ( p )
|
||
|
{
|
||
|
|
||
|
m_editorFocused = 0;
|
||
|
m_selected = p;
|
||
|
FROM_STATE(m_selected) = p;
|
||
|
m_iFlags |= wxPG_FL_PRIMARY_FILLS_ENTIRE;
|
||
|
if ( p != prev )
|
||
|
m_iFlags &= ~(wxPG_FL_VALIDATION_FAILED);
|
||
|
|
||
|
//m_wndPrimary = (wxWindow*) NULL;
|
||
|
wxASSERT( m_wndPrimary == (wxWindow*) NULL );
|
||
|
|
||
|
|
||
|
// Do we need OnMeasureCalls?
|
||
|
wxSize imsz = p->GetImageSize();
|
||
|
if ( imsz.y < -1 )
|
||
|
m_iFlags |= wxPG_FL_SELECTED_IS_PAINT_FLEXIBLE;
|
||
|
|
||
|
// Is the entire cell/row custom painted?
|
||
|
if ( imsz.x == wxPG_FULL_CUSTOM_PAINT_WIDTH )
|
||
|
m_iFlags |= wxPG_FL_SELECTED_IS_FULL_PAINT;
|
||
|
|
||
|
|
||
|
//
|
||
|
// Only create editor for non-disabled non-caption
|
||
|
if ( p->GetParentingType() <= 0 && !(p->m_flags & wxPG_PROP_DISABLED) )
|
||
|
{
|
||
|
// do this for non-caption items
|
||
|
|
||
|
// Do we need to paint the custom image, if any?
|
||
|
m_iFlags &= ~(wxPG_FL_CUR_USES_CUSTOM_IMAGE);
|
||
|
if ( (p->m_flags & wxPG_PROP_CUSTOMIMAGE) &&
|
||
|
!p->GetEditorClass()->CanContainCustomImage()
|
||
|
)
|
||
|
m_iFlags |= wxPG_FL_CUR_USES_CUSTOM_IMAGE;
|
||
|
|
||
|
wxRect grect = GetEditorWidgetRect(p);
|
||
|
wxPoint good_pos = grect.GetPosition();
|
||
|
#if wxPG_CREATE_CONTROLS_HIDDEN
|
||
|
int coord_adjust = m_height - good_pos.y;
|
||
|
good_pos.y += coord_adjust;
|
||
|
#endif
|
||
|
|
||
|
const wxPGEditor* editor = p->GetEditorClass();
|
||
|
wxCHECK_MSG(editor, false,
|
||
|
wxT("NULL editor class not allowed"));
|
||
|
|
||
|
#ifndef __WXPYTHON__
|
||
|
m_wndPrimary = editor->CreateControls(this,
|
||
|
p,
|
||
|
good_pos,
|
||
|
grect.GetSize(),
|
||
|
&m_wndSecondary);
|
||
|
#else
|
||
|
wxPGWindowPair wndPair = editor->CreateControls(this,
|
||
|
p,
|
||
|
good_pos,
|
||
|
grect.GetSize());
|
||
|
m_wndPrimary = wndPair.m_primary;
|
||
|
m_wndSecondary = wndPair.m_secondary;
|
||
|
#endif
|
||
|
|
||
|
// NOTE: It is allowed for m_wndPrimary to be NULL - in this case
|
||
|
// value is drawn as normal, and m_wndSecondary is assumed
|
||
|
// to be a right-aligned button that triggers a separate editor
|
||
|
// window.
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
//wxLogDebug(wxT("%s Editor created for %s"),editor->GetName(),p->GetName().c_str());
|
||
|
|
||
|
// Set validator, if any
|
||
|
/*#if wxUSE_VALIDATORS
|
||
|
if ( validator ) m_wndPrimary->SetValidator(*validator);
|
||
|
#endif*/
|
||
|
|
||
|
if ( m_wndPrimary->GetSize().y > (m_lineHeight+6) )
|
||
|
m_iFlags |= wxPG_FL_ABNORMAL_EDITOR;
|
||
|
|
||
|
// If it has modified status, use bold font
|
||
|
// (must be done before capturing m_ctrlXAdjust)
|
||
|
if ( (p->m_flags & wxPG_PROP_MODIFIED) && (m_windowStyle & wxPG_BOLD_MODIFIED) )
|
||
|
SetCurControlBoldFont();
|
||
|
|
||
|
//
|
||
|
// Fix TextCtrl indentation
|
||
|
#if defined(__WXMSW__) && !defined(__WXWINCE__)
|
||
|
wxTextCtrl* tc = wxDynamicCast(m_wndPrimary, wxTextCtrl);
|
||
|
if ( tc )
|
||
|
::SendMessage(GetHwndOf(tc), EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(0, 0));
|
||
|
#endif
|
||
|
|
||
|
// Store x relative to splitter (we'll need it).
|
||
|
m_ctrlXAdjust = m_wndPrimary->GetPosition().x - m_splitterx;
|
||
|
|
||
|
// Check if background clear is not necessary
|
||
|
wxPoint pos = m_wndPrimary->GetPosition();
|
||
|
if ( pos.x > (m_splitterx+1) || pos.y > p->m_y )
|
||
|
{
|
||
|
m_iFlags &= ~(wxPG_FL_PRIMARY_FILLS_ENTIRE);
|
||
|
}
|
||
|
|
||
|
m_wndPrimary->SetSizeHints(3,3);
|
||
|
|
||
|
#if wxPG_CREATE_CONTROLS_HIDDEN
|
||
|
m_wndPrimary->Show(false);
|
||
|
m_wndPrimary->Freeze();
|
||
|
|
||
|
good_pos = m_wndPrimary->GetPosition();
|
||
|
good_pos.y -= coord_adjust;
|
||
|
m_wndPrimary->Move( good_pos );
|
||
|
#endif
|
||
|
|
||
|
SetupEventHandling(m_wndPrimary, wxPG_SUBID1);
|
||
|
|
||
|
// Focus and select all (wxTextCtrl, wxComboBox etc)
|
||
|
if ( flags & wxPG_SEL_FOCUS )
|
||
|
{
|
||
|
wxWindow* ctrl = m_wndPrimary;
|
||
|
ctrl->SetFocus();
|
||
|
|
||
|
#if wxPG_NAT_TEXTCTRL_BORDER_ANY
|
||
|
// Take into account textctrl in clipper window
|
||
|
if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
|
||
|
ctrl = ((wxPGClipperWindow*)ctrl)->GetControl();
|
||
|
#endif
|
||
|
|
||
|
p->GetEditorClass()->OnFocus(p,m_wndPrimary);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_wndSecondary )
|
||
|
{
|
||
|
|
||
|
m_wndSecondary->SetSizeHints(3,3);
|
||
|
|
||
|
#if wxPG_CREATE_CONTROLS_HIDDEN
|
||
|
wxRect sec_rect = m_wndSecondary->GetRect();
|
||
|
sec_rect.y -= coord_adjust;
|
||
|
|
||
|
// Fine tuning required to fix "oversized"
|
||
|
// button disappearance bug.
|
||
|
if ( sec_rect.y < 0 )
|
||
|
{
|
||
|
sec_rect.height += sec_rect.y;
|
||
|
sec_rect.y = 0;
|
||
|
}
|
||
|
m_wndSecondary->SetSize( sec_rect );
|
||
|
#endif
|
||
|
m_wndSecondary->Show();
|
||
|
|
||
|
SetupEventHandling(m_wndSecondary,wxPG_SUBID2);
|
||
|
|
||
|
// If no primary editor, focus to button to allow
|
||
|
// it to interprete ENTER etc.
|
||
|
// NOTE: Due to problems focusing away from it, this
|
||
|
// has been disabled.
|
||
|
/*
|
||
|
if ( (flags & wxPG_SEL_FOCUS) && !m_wndPrimary )
|
||
|
m_wndSecondary->SetFocus();
|
||
|
*/
|
||
|
|
||
|
}
|
||
|
|
||
|
if ( flags & wxPG_SEL_FOCUS )
|
||
|
m_editorFocused = 1;
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// wxGTK atleast seems to need this (wxMSW not)
|
||
|
SetFocus();
|
||
|
}
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_VALUE_MODIFIED);
|
||
|
|
||
|
//Update();
|
||
|
|
||
|
// If it's inside collapsed section, expand parent, scroll, etc.
|
||
|
// Also, if it was partially visible, scroll it into view.
|
||
|
int vx, vy;
|
||
|
GetViewStart(&vx,&vy);
|
||
|
vy*=wxPG_PIXELS_PER_UNIT;
|
||
|
int vy2 = vy + m_height;
|
||
|
|
||
|
if ( (p->m_y < vy ||
|
||
|
(p->m_y <= vy2 &&
|
||
|
(p->m_y+m_lineHeight) > vy2)) &&
|
||
|
!(flags & wxPG_SEL_NONVISIBLE) )
|
||
|
EnsureVisible( wxPGIdGen(p) );
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
// Clear its background
|
||
|
// (why can't this be optimized by some other drawing?)
|
||
|
if ( !(m_iFlags & wxPG_FL_PRIMARY_FILLS_ENTIRE) )
|
||
|
{
|
||
|
dc.SetPen(*wxTRANSPARENT_PEN);
|
||
|
dc.SetBrush( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) );
|
||
|
dc.DrawRectangle(m_splitterx+1,p->m_y,
|
||
|
m_width-m_splitterx,m_lineHeight-1);
|
||
|
}
|
||
|
|
||
|
#if wxPG_CREATE_CONTROLS_HIDDEN
|
||
|
m_wndPrimary->Thaw();
|
||
|
#endif
|
||
|
m_wndPrimary->Show(true);
|
||
|
}
|
||
|
|
||
|
DoDrawItems( dc, p, p, (const wxRect*) NULL );
|
||
|
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#if wxUSE_STATUSBAR
|
||
|
|
||
|
//
|
||
|
// Show help text in status bar.
|
||
|
// (if found and grid not embedded in manager with help box and
|
||
|
// style wxPG_EX_HELP_AS_TOOLTIPS is not used).
|
||
|
//
|
||
|
|
||
|
if ( !(GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS) )
|
||
|
{
|
||
|
wxStatusBar* statusbar = (wxStatusBar*) NULL;
|
||
|
if ( !(m_iFlags & wxPG_FL_NOSTATUSBARHELP) )
|
||
|
{
|
||
|
wxFrame* frame = wxDynamicCast(::wxGetTopLevelParent(this),wxFrame);
|
||
|
if ( frame )
|
||
|
statusbar = frame->GetStatusBar();
|
||
|
}
|
||
|
|
||
|
if ( statusbar )
|
||
|
{
|
||
|
const wxString* pHelpString = (const wxString*) NULL;
|
||
|
|
||
|
if ( p && p->m_dataExt )
|
||
|
{
|
||
|
pHelpString = &p->m_dataExt->m_helpString;
|
||
|
if ( pHelpString->length() )
|
||
|
{
|
||
|
// Set help box text.
|
||
|
statusbar->SetStatusText( *pHelpString );
|
||
|
m_iFlags |= wxPG_FL_STRING_IN_STATUSBAR;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( (!pHelpString || !pHelpString->length()) &&
|
||
|
(m_iFlags & wxPG_FL_STRING_IN_STATUSBAR) )
|
||
|
{
|
||
|
// Clear help box - but only if it was written
|
||
|
// by us at previous time.
|
||
|
statusbar->SetStatusText( m_emptyString );
|
||
|
m_iFlags &= ~(wxPG_FL_STRING_IN_STATUSBAR);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_IN_SELECT_PROPERTY);
|
||
|
|
||
|
// call wx event handler (here so that it also occurs on deselection)
|
||
|
SendEvent( wxEVT_PG_SELECTED, m_selected, flags );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// This method is not inline because it called dozens of times
|
||
|
// (i.e. two-arg function calls create smaller code size).
|
||
|
bool wxPropertyGrid::ClearSelection()
|
||
|
{
|
||
|
return DoSelectProperty((wxPGProperty*)NULL);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid expand/collapse state and priority (compact mode) related
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::_Collapse( wxPGProperty* p, bool sendEvents )
|
||
|
{
|
||
|
wxCHECK_MSG( p, false, wxT("invalid property id") );
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->GetParentingType() == 0 ) return false;
|
||
|
|
||
|
if ( !pwc->m_expanded ) return false;
|
||
|
|
||
|
// If active editor was inside collapsed section, then disable it
|
||
|
if ( m_selected && m_selected->IsSomeParent (p) )
|
||
|
{
|
||
|
if ( !ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Store dont-center-splitter flag 'cause we need to temporarily set it
|
||
|
wxUint32 old_flag = m_iFlags & wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
|
||
|
// m_expanded must be set just before call to CalculateYs
|
||
|
pwc->m_expanded = 0;
|
||
|
|
||
|
// Redraw etc. only if collapsed was visible.
|
||
|
if (pwc->m_y >= 0 &&
|
||
|
!m_frozen &&
|
||
|
( pwc->GetParentingType() != 1 || !(m_windowStyle & wxPG_HIDE_CATEGORIES) ) )
|
||
|
{
|
||
|
/*int y_adjust = 0;
|
||
|
|
||
|
if ( m_selected && m_selected->m_y > pwc->m_y )
|
||
|
{
|
||
|
wxPGProperty* next_vis = GetNeighbourItem(pwc,true,1);
|
||
|
wxASSERT( next_vis );
|
||
|
|
||
|
y_adjust = next_vis->m_y - pwc->m_y - m_lineHeight;
|
||
|
}*/
|
||
|
|
||
|
CalculateYs( pwc->m_parent, pwc->m_arrIndex );
|
||
|
|
||
|
// Fix control position.
|
||
|
/*if ( y_adjust )
|
||
|
CorrectEditorWidgetSizeY ( -y_adjust );*/
|
||
|
|
||
|
// When item is collapsed so that scrollbar would move,
|
||
|
// graphics mess is about (unless we redraw everything).
|
||
|
Refresh();
|
||
|
}
|
||
|
|
||
|
// Clear dont-center-splitter flag if it wasn't set
|
||
|
m_iFlags = m_iFlags & ~(wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
|
||
|
|
||
|
if ( sendEvents )
|
||
|
SendEvent( wxEVT_PG_ITEM_COLLAPSED, p );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::_Expand( wxPGProperty* p, bool sendEvents )
|
||
|
{
|
||
|
wxCHECK_MSG( p, false, wxT("invalid property id") );
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->GetParentingType() == 0 ) return false;
|
||
|
|
||
|
if ( pwc->m_expanded ) return false;
|
||
|
|
||
|
// Store dont-center-splitter flag 'cause we need to temporarily set it
|
||
|
wxUint32 old_flag = m_iFlags & wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
|
||
|
// m_expanded must be set just before call to CalculateYs
|
||
|
pwc->m_expanded = 1;
|
||
|
|
||
|
// Redraw etc. only if expanded was visible.
|
||
|
if ( pwc->m_y >= 0 && !m_frozen &&
|
||
|
( pwc->GetParentingType() != 1 || !(m_windowStyle & wxPG_HIDE_CATEGORIES) )
|
||
|
)
|
||
|
{
|
||
|
CalculateYs( pwc->m_parent, pwc->m_arrIndex );
|
||
|
|
||
|
/*int y_adjust = pwc->GetCount()*m_lineHeight;
|
||
|
|
||
|
// Fix widget position as well
|
||
|
if ( m_selected && m_selected->m_y > pwc->m_y )
|
||
|
CorrectEditorWidgetSizeY ( y_adjust );*/
|
||
|
|
||
|
// Redraw
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
Refresh();
|
||
|
#else
|
||
|
//wxPG_CLIENT_DC_INIT_R(true)
|
||
|
//DrawItems( dc, pwc->m_y, m_bottomy );
|
||
|
DrawItems(pwc,(wxPGProperty*) NULL);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// Clear dont-center-splitter flag if it wasn't set
|
||
|
m_iFlags = m_iFlags & ~(wxPG_FL_DONT_CENTER_SPLITTER) | old_flag;
|
||
|
|
||
|
if ( sendEvents )
|
||
|
SendEvent( wxEVT_PG_ITEM_EXPANDED, p );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::Compact( bool compact )
|
||
|
{
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::Compact()") );
|
||
|
#endif
|
||
|
if ( compact )
|
||
|
{
|
||
|
if ( !(m_iFlags & wxPG_FL_HIDE_STATE) )
|
||
|
{
|
||
|
// Deselect selected if it was hideable
|
||
|
if ( m_selected && ( m_selected->m_flags & wxPG_PROP_HIDEABLE ) )
|
||
|
{
|
||
|
if ( !ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
m_iFlags |= wxPG_FL_HIDE_STATE;
|
||
|
|
||
|
if ( !m_frozen )
|
||
|
{
|
||
|
CalculateYs( NULL, -1 );
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_iFlags & wxPG_FL_HIDE_STATE )
|
||
|
{
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_HIDE_STATE);
|
||
|
|
||
|
if ( !m_frozen )
|
||
|
{
|
||
|
CalculateYs( NULL, -1 );
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Used by HideProperty as well
|
||
|
bool wxPropertyGrid::SetPropertyPriority( wxPGProperty* p, int priority )
|
||
|
{
|
||
|
/*
|
||
|
// Old code (Commented Aug-09-2007)
|
||
|
if ( m_frozen )
|
||
|
return m_pState->SetPropertyPriority(p,priority);
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_HIDE_STATE) && m_selected &&
|
||
|
( m_selected == p || m_selected->IsSomeParent(p) )
|
||
|
)
|
||
|
{
|
||
|
if ( !ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
m_pState->SetPropertyPriority(p,priority);
|
||
|
|
||
|
if ( m_iFlags & wxPG_FL_HIDE_STATE )
|
||
|
{
|
||
|
CalculateYs(NULL,-1);
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
*/
|
||
|
// Stefan Battmer:
|
||
|
// Changed in a way that this update is only forced when the
|
||
|
// properties new priority actually differs from the current
|
||
|
// priority to improve update speed
|
||
|
if ( p )
|
||
|
{
|
||
|
int oldPriority = ( p->IsFlagSet(wxPG_PROP_HIDEABLE) ) ? wxPG_LOW : wxPG_HIGH;
|
||
|
if( oldPriority != priority )
|
||
|
{
|
||
|
if ( m_frozen )
|
||
|
return m_pState->SetPropertyPriority(p,priority);
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_HIDE_STATE) && m_selected &&
|
||
|
( m_selected == p || m_selected->IsSomeParent(p) )
|
||
|
)
|
||
|
{
|
||
|
if ( !ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
m_pState->SetPropertyPriority(p,priority);
|
||
|
if ( m_iFlags & wxPG_FL_HIDE_STATE )
|
||
|
{
|
||
|
CalculateYs(NULL,-1);
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid size related methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// This is called by CalculateYs (so those calling it won't need to call this)
|
||
|
void wxPropertyGrid::RecalculateVirtualSize()
|
||
|
{
|
||
|
|
||
|
int x = m_width;
|
||
|
int y = m_bottomy;
|
||
|
|
||
|
//SetClientSize(x,y);
|
||
|
|
||
|
// Now adjust virtual size.
|
||
|
SetVirtualSize(x, y);
|
||
|
|
||
|
PGAdjustScrollbars(y);
|
||
|
|
||
|
//
|
||
|
// FIXME: Is this really needed? I mean, can't OnResize handle this?
|
||
|
int width, height;
|
||
|
GetClientSize(&width,&height);
|
||
|
|
||
|
if ( m_selected && width != m_width )
|
||
|
{
|
||
|
CorrectEditorWidgetSizeX( m_splitterx, width );
|
||
|
}
|
||
|
|
||
|
m_width = width;
|
||
|
m_height = height;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::PGAdjustScrollbars( int y )
|
||
|
{
|
||
|
// Adjust scrollbars.
|
||
|
|
||
|
y += wxPG_PIXELS_PER_UNIT+2; // One more scrollbar unit + 2 pixels.
|
||
|
int y_amount = y/wxPG_PIXELS_PER_UNIT;
|
||
|
|
||
|
int y_pos = GetScrollPos( wxVERTICAL );
|
||
|
SetScrollbars( 0, wxPG_PIXELS_PER_UNIT, 0,
|
||
|
y_amount, 0, y_pos, true );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
/*
|
||
|
bool wxPropertyGrid::DetectScrollbar()
|
||
|
{
|
||
|
// Call at every time scrollbar may have appeared/disappeared
|
||
|
// Returns true if scrollbar was toggled
|
||
|
|
||
|
bool toggled = false;
|
||
|
|
||
|
// Use functions instead of m_width for total independence
|
||
|
wxCoord width = GetSize().x;
|
||
|
wxCoord cwidth = GetClientSize().x;
|
||
|
|
||
|
if ( abs(width-cwidth) >= wxPG_MIN_SCROLLBAR_WIDTH )
|
||
|
{
|
||
|
// There is a scrollbar.
|
||
|
if ( !(m_iFlags & wxPG_FL_SCROLLBAR_DETECTED) )
|
||
|
{
|
||
|
//wxLogDebug(wxT("Scrollbar Appeared"));
|
||
|
toggled = true;
|
||
|
m_iFlags |= wxPG_FL_SCROLLBAR_DETECTED;
|
||
|
}
|
||
|
}
|
||
|
else if ( m_iFlags & wxPG_FL_SCROLLBAR_DETECTED )
|
||
|
{
|
||
|
//wxLogDebug(wxT("Scrollbar Disappeared"));
|
||
|
toggled = true;
|
||
|
m_iFlags &= ~(wxPG_FL_SCROLLBAR_DETECTED);
|
||
|
}
|
||
|
|
||
|
return toggled;
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
void wxPropertyGrid::OnResize( wxSizeEvent& event )
|
||
|
{
|
||
|
|
||
|
if ( !(m_iFlags & wxPG_FL_INITIALIZED) )
|
||
|
return;
|
||
|
|
||
|
if ( FROM_STATE(m_itemsAdded) && !m_frozen )
|
||
|
PrepareAfterItemsAdded();
|
||
|
|
||
|
int width, height;
|
||
|
GetClientSize(&width,&height);
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("wxPropertyGrid::OnResize ( %i, %i )"),width,height);
|
||
|
#endif
|
||
|
|
||
|
//int old_width = m_width;
|
||
|
//int old_height = m_height;
|
||
|
int old_fwidth = m_fWidth; // non-client width
|
||
|
int old_splitterx = m_splitterx;
|
||
|
|
||
|
int fwidth = event.GetSize().x;
|
||
|
m_fWidth = fwidth;
|
||
|
m_width = width;
|
||
|
m_height = height;
|
||
|
|
||
|
int widthDiff = fwidth - old_fwidth;
|
||
|
|
||
|
#if wxPG_DOUBLE_BUFFER
|
||
|
if ( !(GetExtraStyle() & wxPG_EX_NATIVE_DOUBLE_BUFFERING) )
|
||
|
{
|
||
|
int dblh = (m_lineHeight*2);
|
||
|
if ( !m_doubleBuffer )
|
||
|
{
|
||
|
// Create double buffer bitmap to draw on, if none
|
||
|
int w = (width>250)?width:250;
|
||
|
int h = height + dblh;
|
||
|
h = (h>400)?h:400;
|
||
|
m_doubleBuffer = new wxBitmap ( w, h );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
int w = m_doubleBuffer->GetWidth();
|
||
|
int h = m_doubleBuffer->GetHeight();
|
||
|
|
||
|
// Double buffer must be large enough
|
||
|
if ( w < width || h < (height+dblh) )
|
||
|
{
|
||
|
if ( w < width ) w = width;
|
||
|
if ( h < (height+dblh) ) h = height + dblh;
|
||
|
delete m_doubleBuffer;
|
||
|
m_doubleBuffer = new wxBitmap ( w, h );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Consider full update on every resize
|
||
|
//m_iFlags |= wxPG_FL_CHANGED;
|
||
|
|
||
|
#endif
|
||
|
|
||
|
//
|
||
|
// Center splitter when...
|
||
|
// * always when propGrid not shown yet or its full size is not realized yet
|
||
|
// and then only if splitter's position was not pre-set
|
||
|
// * auto-centering is enabled and scrollbar was not toggled
|
||
|
//
|
||
|
|
||
|
// Need to center splitter?
|
||
|
//if ( width!=old_width )
|
||
|
{
|
||
|
bool needSplitterCheck = true;
|
||
|
|
||
|
//if ( !sb_vis_toggled )
|
||
|
{
|
||
|
if ( m_windowStyle & wxPG_SPLITTER_AUTO_CENTER )
|
||
|
{
|
||
|
float centerX = float(width) * 0.5;
|
||
|
|
||
|
float splitterX = m_fSplitterX + (float(widthDiff) * 0.5);
|
||
|
|
||
|
float deviation = fabs(centerX - splitterX);
|
||
|
//wxLogDebug(wxT("deviation: %.1f"),deviation);
|
||
|
|
||
|
// If deviated too far from the center, reset it
|
||
|
if ( deviation > 30.0 )
|
||
|
splitterX = centerX;
|
||
|
|
||
|
DoSetSplitterPosition( (int)splitterX, false );
|
||
|
|
||
|
m_fSplitterX = splitterX; // needed to retain accuracy
|
||
|
|
||
|
needSplitterCheck = false;
|
||
|
}
|
||
|
else if ( !(m_iFlags & wxPG_FL_SPLITTER_PRE_SET) )
|
||
|
{
|
||
|
long timeSinceCreation = (::wxGetLocalTimeMillis() - m_timeCreated).ToLong();
|
||
|
|
||
|
if ( m_pState->m_properties->GetCount() || timeSinceCreation > 750 )
|
||
|
{
|
||
|
SetSplitterLeft( false );
|
||
|
needSplitterCheck = false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DoSetSplitterPosition( width / 2, false );
|
||
|
m_iFlags &= ~(wxPG_FL_SPLITTER_PRE_SET);
|
||
|
needSplitterCheck = false;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( needSplitterCheck && (m_splitterx + wxPG_DRAG_MARGIN) > width )
|
||
|
{
|
||
|
long timeSinceCreation = (::wxGetLocalTimeMillis() - m_timeCreated).ToLong();
|
||
|
|
||
|
if ( timeSinceCreation >= 750 )
|
||
|
{
|
||
|
DoSetSplitterPosition( width - wxPG_DRAG_MARGIN - 1, false );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Need to correct widget position?
|
||
|
if ( m_selected /*&& (width != old_width || sb_vis_toggled)*/ )
|
||
|
{
|
||
|
// Take splitter position change into account
|
||
|
CorrectEditorWidgetSizeX( m_splitterx, width );
|
||
|
}
|
||
|
|
||
|
if ( !m_frozen )
|
||
|
{
|
||
|
|
||
|
// Need to recalculate visibles array?
|
||
|
//if ( height != old_height )
|
||
|
if ( height > m_calcVisHeight )
|
||
|
CalculateVisibles( -1, false );
|
||
|
|
||
|
/*if ( sb_vis_toggled )
|
||
|
{
|
||
|
Refresh();
|
||
|
}
|
||
|
else*/
|
||
|
if ( m_splitterx != old_splitterx )
|
||
|
{
|
||
|
Refresh();
|
||
|
/*if ( abs(height-old_height) < 100 )
|
||
|
{
|
||
|
Update(); // Necessary, atleast on wxMSW
|
||
|
RedrawAllVisible();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Refresh();
|
||
|
}*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Without this, virtual size (atleast under wxGTK) will be skewed
|
||
|
RecalculateVirtualSize();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid mouse event handling
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// selFlags uses same values DoSelectProperty's flags
|
||
|
void wxPropertyGrid::SendEvent( int eventType, wxPGProperty* p, unsigned int selFlags )
|
||
|
{
|
||
|
// Send property grid event of specific type and with specific property
|
||
|
wxPropertyGridEvent evt( eventType, GetId() );
|
||
|
evt.SetPropertyGrid(this);
|
||
|
evt.SetEventObject(m_eventObject);
|
||
|
evt.SetProperty(p);
|
||
|
wxEvtHandler* evtHandler = GetEventHandler();
|
||
|
|
||
|
// Always need to process event immediately if the property in question is
|
||
|
// about to be deleted.
|
||
|
if ( (selFlags & wxPG_SEL_DELETING) ||
|
||
|
(GetExtraStyle() & wxPG_EX_PROCESS_EVENTS_IMMEDIATELY) )
|
||
|
{
|
||
|
evtHandler->ProcessEvent(evt);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
evt.SetPending(true);
|
||
|
evtHandler->AddPendingEvent(evt);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Return false if should be skipped
|
||
|
bool wxPropertyGrid::HandleMouseClick( int x, unsigned int y, wxMouseEvent &event )
|
||
|
{
|
||
|
bool res = true;
|
||
|
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug( wxT(" \\--> HandleMouseClick") );
|
||
|
#endif
|
||
|
|
||
|
// Need to set focus?
|
||
|
if ( !(m_iFlags & wxPG_FL_FOCUSED) )
|
||
|
{
|
||
|
SetFocus();
|
||
|
}
|
||
|
|
||
|
if ( y < m_bottomy )
|
||
|
{
|
||
|
|
||
|
wxPGProperty* p = DoGetItemAtY(y);
|
||
|
|
||
|
if ( p )
|
||
|
{
|
||
|
int parenting = p->GetParentingType();
|
||
|
int depth = (int)p->GetDepth() - 1;
|
||
|
|
||
|
int marginEnds = m_marginWidth + ( depth * m_subgroup_extramargin );
|
||
|
|
||
|
if ( x >= marginEnds )
|
||
|
{
|
||
|
// Outside margin.
|
||
|
|
||
|
if ( parenting > 0 )
|
||
|
{
|
||
|
// This is category.
|
||
|
wxPropertyCategoryClass* pwc = (wxPropertyCategoryClass*)p;
|
||
|
|
||
|
int text_x = m_marginWidth + ((unsigned int)((pwc->m_depth-1)*m_subgroup_extramargin));
|
||
|
|
||
|
// Expand, collapse, activate etc. if click on text or left of splitter.
|
||
|
if ( x >= text_x
|
||
|
&&
|
||
|
( x < (text_x+pwc->GetTextExtent()+(wxPG_CAPRECTXMARGIN*2))
|
||
|
||
|
||
|
x < m_splitterx
|
||
|
)
|
||
|
)
|
||
|
{
|
||
|
if ( !DoSelectProperty( p ) )
|
||
|
return res;
|
||
|
|
||
|
// On double-click, expand/collapse.
|
||
|
if ( event.ButtonDClick() && !(m_windowStyle & wxPG_HIDE_MARGIN) )
|
||
|
{
|
||
|
if ( pwc->m_expanded ) _Collapse ( p, true );
|
||
|
else _Expand ( p, true );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else if ( x > (m_splitterx + wxPG_SPLITTERX_DETECTMARGIN2) ||
|
||
|
x < (m_splitterx - wxPG_SPLITTERX_DETECTMARGIN1) )
|
||
|
{
|
||
|
// Click on value.
|
||
|
unsigned int selFlag = 0;
|
||
|
if ( x > m_splitterx )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_ACTIVATION_BY_CLICK;
|
||
|
selFlag = wxPG_SEL_FOCUS;
|
||
|
}
|
||
|
if ( !DoSelectProperty( p, selFlag ) )
|
||
|
return res;
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_ACTIVATION_BY_CLICK);
|
||
|
|
||
|
if ( p->GetParentingType() < 0 )
|
||
|
// On double-click, expand/collapse.
|
||
|
if ( event.ButtonDClick() && !(m_windowStyle & wxPG_HIDE_MARGIN) )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->m_expanded ) _Collapse ( p, true );
|
||
|
else _Expand ( p, true );
|
||
|
}
|
||
|
|
||
|
res = false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// click on splitter
|
||
|
if ( !(m_windowStyle & wxPG_STATIC_SPLITTER) )
|
||
|
{
|
||
|
|
||
|
if ( event.GetEventType() == wxEVT_LEFT_DCLICK )
|
||
|
{
|
||
|
// Double-clicking the splitter causes auto-centering
|
||
|
CenterSplitter( true );
|
||
|
// TODO: Would this be more natural?
|
||
|
// .NET grid doesn't do it but maybe we should.
|
||
|
//CustomSetCursor ( wxCURSOR_ARROW );
|
||
|
}
|
||
|
else if ( m_dragStatus == 0 )
|
||
|
{
|
||
|
//
|
||
|
// Begin draggin the splitter
|
||
|
//
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug( wxT(" dragging begins at splitter + %i"),
|
||
|
(int)(x - m_splitterx) );
|
||
|
#endif
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
// Changes must be committed here or the
|
||
|
// value won't be drawn correctly
|
||
|
if ( !CommitChangesFromEditor() )
|
||
|
return res;
|
||
|
|
||
|
m_wndPrimary->Show ( false );
|
||
|
}
|
||
|
|
||
|
BEGIN_MOUSE_CAPTURE
|
||
|
|
||
|
m_dragStatus = 1;
|
||
|
|
||
|
m_dragOffset = x - m_splitterx;
|
||
|
|
||
|
wxPG_CLIENT_DC_INIT()
|
||
|
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
// Fixes button disappearance bug
|
||
|
if ( m_wndSecondary )
|
||
|
m_wndSecondary->Show ( false );
|
||
|
#endif
|
||
|
|
||
|
m_startingSplitterX = m_splitterx;
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
#else
|
||
|
Update(); // clear graphics mess
|
||
|
DrawSplitterDragColumn( dc, m_splitterx );
|
||
|
m_splitterprevdrawnx = m_splitterx;
|
||
|
#endif
|
||
|
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Click on margin.
|
||
|
if ( parenting != 0 )
|
||
|
{
|
||
|
int nx = x + m_marginWidth - marginEnds; // Normalize x.
|
||
|
|
||
|
if ( (nx >= m_gutterWidth && nx < (m_gutterWidth+m_iconWidth)) )
|
||
|
{
|
||
|
int y2 = y - p->m_y;
|
||
|
if ( (y2 >= m_buttonSpacingY && y2 < (m_buttonSpacingY+m_iconHeight)) )
|
||
|
{
|
||
|
// On click on expander button, expand/collapse
|
||
|
if ( ((wxPGPropertyWithChildren*)p)->m_expanded )
|
||
|
_Collapse ( p, true );
|
||
|
else
|
||
|
_Expand ( p, true );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::HandleMouseRightClick( int WXUNUSED(x), unsigned int y,
|
||
|
wxMouseEvent& WXUNUSED(event) )
|
||
|
{
|
||
|
if ( y < m_bottomy )
|
||
|
{
|
||
|
// Select property here as well
|
||
|
wxPGProperty* p = m_propHover;
|
||
|
if ( p != m_selected )
|
||
|
DoSelectProperty( p );
|
||
|
|
||
|
// Send right click event.
|
||
|
SendEvent( wxEVT_PG_RIGHT_CLICK, p );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::HandleMouseDoubleClick( int WXUNUSED(x), unsigned int y,
|
||
|
wxMouseEvent& WXUNUSED(event) )
|
||
|
{
|
||
|
if ( y < m_bottomy )
|
||
|
{
|
||
|
// Select property here as well
|
||
|
wxPGProperty* p = m_propHover;
|
||
|
|
||
|
if ( p != m_selected )
|
||
|
DoSelectProperty( p );
|
||
|
|
||
|
// Send double-click event.
|
||
|
SendEvent( wxEVT_PG_DOUBLE_CLICK, m_propHover );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
/*
|
||
|
// Splits text into lines so that each will have width less than arg maxWidth.
|
||
|
// * Returns string with line breaks inserted into appropriate positions.
|
||
|
// * Keeps words together.
|
||
|
// * Useful in conjunction with wxWindow::SetToolTip and wxDC::DrawLabel.
|
||
|
static wxString SplitTextByPixelWidth(wxDC& dc, const wxString& text, int lineWidth)
|
||
|
{
|
||
|
if ( !text.length() )
|
||
|
return text;
|
||
|
|
||
|
wxString resultLine;
|
||
|
wxArrayInt extents;
|
||
|
|
||
|
unsigned int index = 0;
|
||
|
unsigned int maxIndex = text.length() - 1;
|
||
|
unsigned int prevSplitIndex = 0;
|
||
|
unsigned int prevCanSplitIndex = 0;
|
||
|
int lineCheckWidth = lineWidth;
|
||
|
wxChar prevA = wxT('\0');
|
||
|
|
||
|
dc.GetPartialTextExtents(text,extents);
|
||
|
|
||
|
wxASSERT( text.length() == extents.GetCount() );
|
||
|
|
||
|
while ( index <= maxIndex )
|
||
|
{
|
||
|
const wxChar A = text[index];
|
||
|
|
||
|
if ( !wxIsalnum(prevA) )
|
||
|
{
|
||
|
// Can split here
|
||
|
prevCanSplitIndex = index;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Can't split here
|
||
|
}
|
||
|
|
||
|
if ( ( (extents[index] >= lineCheckWidth || A == wxT('\n')) &&
|
||
|
index > prevCanSplitIndex ) ||
|
||
|
index == maxIndex )
|
||
|
{
|
||
|
// Need to split now
|
||
|
|
||
|
unsigned int useSplit = prevCanSplitIndex;
|
||
|
if ( useSplit <= prevSplitIndex ||
|
||
|
index >= maxIndex )
|
||
|
useSplit = index;
|
||
|
|
||
|
resultLine << text.Mid(prevSplitIndex,useSplit-prevSplitIndex);
|
||
|
|
||
|
if ( index >= maxIndex )
|
||
|
break;
|
||
|
else
|
||
|
if ( A != wxT('\n') )
|
||
|
{
|
||
|
resultLine.Append(_T("\n"));
|
||
|
//resultLine.Append(text.Mid(useSplit,text.length()-useSplit));
|
||
|
//break;
|
||
|
}
|
||
|
prevSplitIndex = useSplit;
|
||
|
lineCheckWidth = extents[useSplit] + lineWidth;
|
||
|
//widSum = 0;
|
||
|
index = useSplit;
|
||
|
prevA = wxT('\0');
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
index++;
|
||
|
prevA = A;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return resultLine;
|
||
|
}
|
||
|
*/
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxPG_SUPPORT_TOOLTIPS
|
||
|
|
||
|
void wxPropertyGrid::SetToolTip( const wxString& tipString )
|
||
|
{
|
||
|
if ( tipString.length() )
|
||
|
{
|
||
|
//wxClientDC dc(this);
|
||
|
//wxString finalString = SplitTextByPixelWidth(dc,tipString,350);
|
||
|
//wxScrolledWindow::SetToolTip(finalString);
|
||
|
wxScrolledWindow::SetToolTip(tipString);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#if wxPG_ALLOW_EMPTY_TOOLTIPS
|
||
|
wxScrolledWindow::SetToolTip( m_emptyString );
|
||
|
#else
|
||
|
wxScrolledWindow::SetToolTip( NULL );
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#endif // #if wxPG_SUPPORT_TOOLTIPS
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Return false if should be skipped
|
||
|
bool wxPropertyGrid::HandleMouseMove( int x, unsigned int y, wxMouseEvent &event )
|
||
|
{
|
||
|
// Safety check (needed because mouse capturing may
|
||
|
// otherwise freeze the control)
|
||
|
if ( m_dragStatus > 0 && !event.Dragging() )
|
||
|
{
|
||
|
//wxLogDebug(wxT("MOUSE CAPTURE SAFETY RELEASE TRIGGERED"));
|
||
|
HandleMouseUp(x,y,event);
|
||
|
}
|
||
|
|
||
|
if ( m_dragStatus > 0 )
|
||
|
{
|
||
|
|
||
|
if ( x > (m_marginWidth + wxPG_DRAG_MARGIN) &&
|
||
|
x < (m_width - wxPG_DRAG_MARGIN) )
|
||
|
{
|
||
|
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
|
||
|
int new_splitterx = x - m_dragOffset;
|
||
|
|
||
|
// Splitter redraw required?
|
||
|
if ( new_splitterx != m_splitterx )
|
||
|
{
|
||
|
|
||
|
if ( m_selected )
|
||
|
CorrectEditorWidgetSizeX( new_splitterx, m_width );
|
||
|
|
||
|
// Move everything
|
||
|
m_splitterx = new_splitterx;
|
||
|
m_fSplitterX = (float) new_splitterx;
|
||
|
|
||
|
Update();
|
||
|
RedrawAllVisible();
|
||
|
|
||
|
}
|
||
|
|
||
|
#else
|
||
|
|
||
|
if ( x != m_splitterx )
|
||
|
{
|
||
|
wxPG_CLIENT_DC_INIT_R(false)
|
||
|
|
||
|
if ( m_splitterprevdrawnx != -1 )
|
||
|
DrawSplitterDragColumn( dc, m_splitterprevdrawnx );
|
||
|
|
||
|
m_splitterx = x;
|
||
|
m_fSplitterX = (float) x;
|
||
|
|
||
|
DrawSplitterDragColumn( dc, x );
|
||
|
|
||
|
m_splitterprevdrawnx = x;
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
m_dragStatus = 2;
|
||
|
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
|
||
|
int ih = m_lineHeight;
|
||
|
int sy = y;
|
||
|
|
||
|
#if wxPG_SUPPORT_TOOLTIPS
|
||
|
wxPGProperty* prevHover = m_propHover;
|
||
|
unsigned char prevSide = m_mouseSide;
|
||
|
#endif
|
||
|
|
||
|
// On which item it hovers
|
||
|
if ( ( !m_propHover && y < m_bottomy)
|
||
|
||
|
||
|
( m_propHover && ( sy < m_propHover->m_y || sy >= (m_propHover->m_y+ih) ) )
|
||
|
)
|
||
|
{
|
||
|
// Mouse moves on another property
|
||
|
|
||
|
m_propHover = DoGetItemAtY(y);
|
||
|
|
||
|
// Send hover event
|
||
|
SendEvent( wxEVT_PG_HIGHLIGHTED, m_propHover );
|
||
|
}
|
||
|
|
||
|
#if wxPG_SUPPORT_TOOLTIPS
|
||
|
// Store which side we are on
|
||
|
m_mouseSide = 0;
|
||
|
if ( x >= m_splitterx )
|
||
|
m_mouseSide = 2;
|
||
|
else if ( x >= m_marginWidth )
|
||
|
m_mouseSide = 1;
|
||
|
|
||
|
//
|
||
|
// If tooltips are enabled, show label or value as a tip
|
||
|
// in case it doesn't otherwise show in full length.
|
||
|
//
|
||
|
if ( m_windowStyle & wxPG_TOOLTIPS )
|
||
|
{
|
||
|
wxToolTip* tooltip = GetToolTip();
|
||
|
|
||
|
if ( m_propHover != prevHover || prevSide != m_mouseSide )
|
||
|
{
|
||
|
if ( m_propHover && m_propHover->GetParentingType() <= 0 )
|
||
|
{
|
||
|
|
||
|
if ( GetExtraStyle() & wxPG_EX_HELP_AS_TOOLTIPS )
|
||
|
{
|
||
|
// Show help string as a tooltip
|
||
|
wxString tipString = m_propHover->GetHelpString();
|
||
|
|
||
|
SetToolTip(tipString);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Show cropped value string as a tooltip
|
||
|
wxString tipString;
|
||
|
int space = 0;
|
||
|
|
||
|
if ( m_mouseSide == 1 )
|
||
|
{
|
||
|
tipString = m_propHover->m_label;
|
||
|
space = m_splitterx-m_marginWidth-3;
|
||
|
}
|
||
|
else if ( m_mouseSide == 2 )
|
||
|
{
|
||
|
tipString = m_propHover->GetDisplayedString();
|
||
|
|
||
|
space = m_width - m_splitterx;
|
||
|
if ( m_propHover->m_flags & wxPG_PROP_CUSTOMIMAGE )
|
||
|
space -= wxPG_CUSTOM_IMAGE_WIDTH + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
|
||
|
}
|
||
|
|
||
|
if ( space )
|
||
|
{
|
||
|
int tw, th;
|
||
|
GetTextExtent( tipString, &tw, &th, 0, 0, &m_font );
|
||
|
if ( tw > space )
|
||
|
{
|
||
|
SetToolTip( tipString );
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( tooltip )
|
||
|
{
|
||
|
#if wxPG_ALLOW_EMPTY_TOOLTIPS
|
||
|
wxScrolledWindow::SetToolTip( m_emptyString );
|
||
|
#else
|
||
|
wxScrolledWindow::SetToolTip( NULL );
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( tooltip )
|
||
|
{
|
||
|
#if wxPG_ALLOW_EMPTY_TOOLTIPS
|
||
|
wxScrolledWindow::SetToolTip( m_emptyString );
|
||
|
#else
|
||
|
wxScrolledWindow::SetToolTip( NULL );
|
||
|
#endif
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
if ( x > (m_splitterx + wxPG_SPLITTERX_DETECTMARGIN2) ||
|
||
|
x < (m_splitterx - wxPG_SPLITTERX_DETECTMARGIN1) ||
|
||
|
y >= m_bottomy ||
|
||
|
(m_windowStyle & wxPG_STATIC_SPLITTER) )
|
||
|
{
|
||
|
// hovering on something else
|
||
|
if ( m_curcursor != wxCURSOR_ARROW )
|
||
|
CustomSetCursor( wxCURSOR_ARROW );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Do not allow splitter cursor on caption items.
|
||
|
// (also not if we were dragging and its started
|
||
|
// outside the splitter region)
|
||
|
|
||
|
if ( m_propHover &&
|
||
|
m_propHover->GetParentingType() <= 0 &&
|
||
|
!event.Dragging() )
|
||
|
{
|
||
|
|
||
|
// hovering on splitter
|
||
|
|
||
|
// NB: Condition disabled since MouseLeave event (from the editor control) cannot be
|
||
|
// reliably detected.
|
||
|
//if ( m_curcursor != wxCURSOR_SIZEWE )
|
||
|
CustomSetCursor( wxCURSOR_SIZEWE, true );
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// hovering on something else
|
||
|
if ( m_curcursor != wxCURSOR_ARROW )
|
||
|
CustomSetCursor( wxCURSOR_ARROW );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Also handles Leaving event
|
||
|
bool wxPropertyGrid::HandleMouseUp( int x, unsigned int y, wxMouseEvent &WXUNUSED(event) )
|
||
|
{
|
||
|
bool res = false;
|
||
|
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug( wxT(" \\--> HandleMouseUp") );
|
||
|
#endif
|
||
|
|
||
|
// No event type check - basicly calling this method should
|
||
|
// just stop dragging.
|
||
|
//if( event.LeftUp() || event.Leaving() )
|
||
|
//{
|
||
|
// Left up after dragged?
|
||
|
if ( m_dragStatus >= 1 )
|
||
|
{
|
||
|
//
|
||
|
// End Splitter Dragging
|
||
|
//
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug( wxT(" dragging ends") );
|
||
|
#endif
|
||
|
|
||
|
// DO NOT ENABLE FOLLOWING LINE!
|
||
|
// (it is only here as a reminder to not to do it)
|
||
|
//m_splitterx = x;
|
||
|
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
//Refresh();
|
||
|
#else
|
||
|
DoSetSplitterPosition( -1 ); // -1 tells not to make change
|
||
|
|
||
|
// Hack to clear-up editor graphics mess (on wxMSW, atleast)
|
||
|
if ( m_selected )
|
||
|
DrawItem ( m_selected );
|
||
|
|
||
|
#endif
|
||
|
// Disable splitter auto-centering
|
||
|
m_iFlags |= wxPG_FL_DONT_CENTER_SPLITTER;
|
||
|
|
||
|
// This is necessary to return cursor
|
||
|
END_MOUSE_CAPTURE
|
||
|
|
||
|
// Set back the default cursor, if necessary
|
||
|
if ( x > (m_splitterx + wxPG_SPLITTERX_DETECTMARGIN2) ||
|
||
|
x < (m_splitterx - wxPG_SPLITTERX_DETECTMARGIN1) ||
|
||
|
y >= m_bottomy )
|
||
|
{
|
||
|
CustomSetCursor( wxCURSOR_ARROW );
|
||
|
}
|
||
|
|
||
|
m_dragStatus = 0;
|
||
|
|
||
|
#if wxPG_HEAVY_GFX
|
||
|
// Control background needs to be cleared
|
||
|
if ( !(m_iFlags & wxPG_FL_PRIMARY_FILLS_ENTIRE) && m_selected )
|
||
|
DrawItem ( m_selected );
|
||
|
#endif
|
||
|
|
||
|
if ( m_wndPrimary )
|
||
|
{
|
||
|
m_wndPrimary->Show ( true );
|
||
|
}
|
||
|
|
||
|
#if wxPG_REFRESH_CONTROLS_AFTER_REPAINT
|
||
|
// Fixes button disappearance bug
|
||
|
if ( m_wndSecondary )
|
||
|
m_wndSecondary->Show ( true );
|
||
|
#endif
|
||
|
|
||
|
// This clears the focus.
|
||
|
m_editorFocused = 0;
|
||
|
|
||
|
}
|
||
|
//}
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::OnMouseCommon( wxMouseEvent& event, int* px, int* py )
|
||
|
{
|
||
|
int ux, uy;
|
||
|
CalcUnscrolledPosition( event.m_x, event.m_y, &ux, &uy );
|
||
|
|
||
|
// Hide popup on clicks
|
||
|
// FIXME: Not necessary after transient window implemented
|
||
|
if ( event.GetEventType() != wxEVT_MOTION )
|
||
|
if ( m_wndPrimary && m_wndPrimary->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)) )
|
||
|
{
|
||
|
((wxPGOwnerDrawnComboBox*)m_wndPrimary)->HidePopup();
|
||
|
}
|
||
|
|
||
|
//if (printmsg) wxLogDebug( wxT("On") wxT(#func) wxT("( %i, %i )"),(int)ux,(int)uy );
|
||
|
wxRect r;
|
||
|
wxWindow* wnd = m_wndPrimary;
|
||
|
if ( wnd )
|
||
|
r = wnd->GetRect();
|
||
|
if ( wnd == (wxWindow*) NULL || m_dragStatus ||
|
||
|
(
|
||
|
ux <= (m_splitterx + wxPG_SPLITTERX_DETECTMARGIN2) ||
|
||
|
event.m_y < r.y ||
|
||
|
event.m_y >= (r.y+r.height)
|
||
|
)
|
||
|
)
|
||
|
{
|
||
|
*px = ux;
|
||
|
*py = uy;
|
||
|
return true;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( m_curcursor != wxCURSOR_ARROW ) CustomSetCursor ( wxCURSOR_ARROW );
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseClick( wxMouseEvent &event )
|
||
|
{
|
||
|
int x, y;
|
||
|
if ( OnMouseCommon( event, &x, &y ) )
|
||
|
{
|
||
|
HandleMouseClick(x,y,event);
|
||
|
}
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseRightClick( wxMouseEvent &event )
|
||
|
{
|
||
|
int x, y;
|
||
|
CalcUnscrolledPosition( event.m_x, event.m_y, &x, &y );
|
||
|
HandleMouseRightClick(x,y,event);
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseDoubleClick( wxMouseEvent &event )
|
||
|
{
|
||
|
// Always run standard mouse-down handler as well
|
||
|
OnMouseClick(event);
|
||
|
|
||
|
int x, y;
|
||
|
CalcUnscrolledPosition( event.m_x, event.m_y, &x, &y );
|
||
|
HandleMouseDoubleClick(x,y,event);
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseMove( wxMouseEvent &event )
|
||
|
{
|
||
|
int x, y;
|
||
|
if ( OnMouseCommon ( event, &x, &y ) )
|
||
|
{
|
||
|
HandleMouseMove(x,y,event);
|
||
|
}
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseUp( wxMouseEvent &event )
|
||
|
{
|
||
|
int x, y;
|
||
|
if ( OnMouseCommon ( event, &x, &y ) )
|
||
|
{
|
||
|
HandleMouseUp(x,y,event);
|
||
|
}
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnMouseEntry( wxMouseEvent &event )
|
||
|
{
|
||
|
// This may get called from child control as well, so event's
|
||
|
// mouse position cannot be relied on.
|
||
|
//int x = event.m_x;
|
||
|
//int y = event.m_y;
|
||
|
|
||
|
if ( event.Entering() )
|
||
|
{
|
||
|
if ( !(m_iFlags & wxPG_FL_MOUSE_INSIDE) )
|
||
|
{
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("Mouse Enters Window"));
|
||
|
#endif
|
||
|
//SetCursor ( *wxSTANDARD_CURSOR );
|
||
|
// TODO: Fix this (detect parent and only do
|
||
|
// cursor trick if it is a manager).
|
||
|
wxASSERT( GetParent() );
|
||
|
GetParent()->SetCursor(wxNullCursor);
|
||
|
|
||
|
m_iFlags |= wxPG_FL_MOUSE_INSIDE;
|
||
|
//if ( m_wndPrimary ) m_wndPrimary->Show ( true );
|
||
|
}
|
||
|
else
|
||
|
GetParent()->SetCursor(wxNullCursor);
|
||
|
}
|
||
|
else if ( event.Leaving() )
|
||
|
{
|
||
|
// Without this, wxSpinCtrl editor will sometimes have wrong cursor
|
||
|
SetCursor( wxNullCursor );
|
||
|
|
||
|
// Get real cursor position
|
||
|
wxPoint pt = ScreenToClient(::wxGetMousePosition());
|
||
|
|
||
|
if ( ( pt.x <= 0 || pt.y <= 0 || pt.x >= m_width || pt.y >= m_height ) )
|
||
|
{
|
||
|
//if ( CommitChangesFromEditor() )
|
||
|
{
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_MOUSE_INSIDE) )
|
||
|
{
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug(wxT("Mouse Leaves Window"));
|
||
|
#endif
|
||
|
m_iFlags &= ~(wxPG_FL_MOUSE_INSIDE);
|
||
|
//if ( m_wndPrimary ) m_wndPrimary->Show ( false );
|
||
|
}
|
||
|
|
||
|
if ( m_dragStatus )
|
||
|
wxPropertyGrid::HandleMouseUp ( -1, 10000, event );
|
||
|
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*#if wxPG_NO_CHILD_EVT_MOTION
|
||
|
// cursor must be reset because EVT_MOTION handler is not there to do it
|
||
|
if ( m_curcursor != wxCURSOR_ARROW ) CustomSetCursor ( wxCURSOR_ARROW );
|
||
|
#endif*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// if (printmsg) wxLogDebug( wxT("On") wxT(#func) wxT("Child ( %i, %i )"),(int)event.m_x,(int)event.m_y );
|
||
|
|
||
|
// Common code used by various OnMouseXXXChild methods.
|
||
|
bool wxPropertyGrid::OnMouseChildCommon( wxMouseEvent &event, int* px, int *py )
|
||
|
{
|
||
|
wxWindow* topCtrlWnd = (wxWindow*)event.GetEventObject();
|
||
|
wxASSERT( topCtrlWnd );
|
||
|
int x, y;
|
||
|
event.GetPosition(&x,&y);
|
||
|
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
// Take clipper window into account
|
||
|
if (topCtrlWnd->GetPosition().x < 1 &&
|
||
|
!topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)))
|
||
|
{
|
||
|
topCtrlWnd = topCtrlWnd->GetParent();
|
||
|
wxASSERT( topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)) );
|
||
|
x -= ((wxPGClipperWindow*)topCtrlWnd)->GetXClip();
|
||
|
y -= ((wxPGClipperWindow*)topCtrlWnd)->GetYClip();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
wxRect r = topCtrlWnd->GetRect();
|
||
|
if ( !m_dragStatus &&
|
||
|
x > (m_splitterx-r.x+wxPG_SPLITTERX_DETECTMARGIN2) &&
|
||
|
y >= 0 && y < r.height \
|
||
|
)
|
||
|
{
|
||
|
if ( m_curcursor != wxCURSOR_ARROW ) CustomSetCursor ( wxCURSOR_ARROW );
|
||
|
event.Skip();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CalcUnscrolledPosition( event.m_x + r.x, event.m_y + r.y, \
|
||
|
px, py );
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
/*void wxPropertyGrid::OnMouseEntryChild ( wxMouseEvent &event )
|
||
|
{
|
||
|
wxLogDebug(wxT("Entering/Leaving Child..."));
|
||
|
event.Skip();
|
||
|
}*/
|
||
|
|
||
|
void wxPropertyGrid::OnMouseClickChild( wxMouseEvent &event )
|
||
|
{
|
||
|
int x,y;
|
||
|
if ( OnMouseChildCommon(event,&x,&y) )
|
||
|
{
|
||
|
bool res = HandleMouseClick(x,y,event);
|
||
|
if ( !res ) event.Skip();
|
||
|
|
||
|
/*if ( event.GetEventType() == wxEVT_LEFT_DCLICK )
|
||
|
{
|
||
|
HandleMouseDoubleClick( x, y, event );
|
||
|
event.Skip();
|
||
|
}*/
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnMouseRightClickChild( wxMouseEvent &event )
|
||
|
{
|
||
|
int x,y;
|
||
|
wxASSERT( m_wndPrimary );
|
||
|
// These coords may not be exact (about +-2),
|
||
|
// but that should not matter (right click is about item, not position).
|
||
|
wxPoint pt = m_wndPrimary->GetPosition();
|
||
|
CalcUnscrolledPosition( event.m_x + pt.x, event.m_y + pt.y, &x, &y );
|
||
|
wxASSERT( m_selected );
|
||
|
m_propHover = m_selected;
|
||
|
bool res = HandleMouseRightClick(x,y,event);
|
||
|
if ( !res ) event.Skip();
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnMouseMoveChild( wxMouseEvent &event )
|
||
|
{
|
||
|
int x,y;
|
||
|
if ( OnMouseChildCommon(event,&x,&y) )
|
||
|
{
|
||
|
bool res = HandleMouseMove(x,y,event);
|
||
|
if ( !res ) event.Skip();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnMouseUpChild( wxMouseEvent &event )
|
||
|
{
|
||
|
int x,y;
|
||
|
if ( OnMouseChildCommon(event,&x,&y) )
|
||
|
{
|
||
|
bool res = HandleMouseUp(x,y,event);
|
||
|
if ( !res ) event.Skip();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid keyboard event handling
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SendNavigationKeyEvent( int dir )
|
||
|
{
|
||
|
wxNavigationKeyEvent evt;
|
||
|
evt.SetFlags(wxNavigationKeyEvent::FromTab|
|
||
|
(dir?wxNavigationKeyEvent::IsForward:
|
||
|
wxNavigationKeyEvent::IsBackward));
|
||
|
evt.SetEventObject(this);
|
||
|
GetEventHandler()->AddPendingEvent(evt);
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::HandleKeyEvent(wxKeyEvent &event)
|
||
|
{
|
||
|
|
||
|
//
|
||
|
// Handles key event when editor control is not focused.
|
||
|
//
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::HandleKeyEvent(%i)"),(int)event.GetKeyCode() );
|
||
|
#endif
|
||
|
|
||
|
wxASSERT( !m_frozen );
|
||
|
if ( m_frozen )
|
||
|
return;
|
||
|
|
||
|
// Travelsal between items, collapsing/expanding, etc.
|
||
|
int keycode = event.GetKeyCode();
|
||
|
|
||
|
if ( keycode == WXK_TAB )
|
||
|
{
|
||
|
SendNavigationKeyEvent( event.ShiftDown()?0:1 );
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
// Ignore Alt and Control when they are down alone
|
||
|
if ( keycode == WXK_ALT ||
|
||
|
keycode == WXK_CONTROL )
|
||
|
{
|
||
|
event.Skip();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
|
||
|
// Show dialog?
|
||
|
if ( ButtonTriggerKeyTest(event) )
|
||
|
return;
|
||
|
|
||
|
wxPGProperty* p = m_selected;
|
||
|
|
||
|
int selectDir = -2;
|
||
|
|
||
|
if ( p->GetParentingType() != 0 &&
|
||
|
!(p->m_flags & wxPG_PROP_DISABLED)
|
||
|
)
|
||
|
{
|
||
|
//wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( keycode == WXK_LEFT )
|
||
|
{
|
||
|
if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Collapse ( p ) )
|
||
|
keycode = 0;
|
||
|
}
|
||
|
else if ( keycode == WXK_RIGHT )
|
||
|
{
|
||
|
if ( (m_windowStyle & wxPG_HIDE_MARGIN) || Expand ( p ) )
|
||
|
keycode = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( keycode )
|
||
|
{
|
||
|
if ( keycode == WXK_UP || keycode == WXK_LEFT )
|
||
|
{
|
||
|
selectDir = 0;
|
||
|
}
|
||
|
else if ( keycode == WXK_DOWN || keycode == WXK_RIGHT )
|
||
|
{
|
||
|
selectDir = 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
if ( selectDir >= -1 )
|
||
|
{
|
||
|
p = GetNeighbourItem( p, true, selectDir );
|
||
|
if ( p )
|
||
|
DoSelectProperty(p);
|
||
|
}
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// If nothing was selected, select the first item now
|
||
|
// (or navigate out of tab).
|
||
|
if ( keycode != WXK_ESCAPE )
|
||
|
{
|
||
|
wxPGProperty* p = GetFirst();
|
||
|
if ( p ) DoSelectProperty(p);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Potentially handles a keyboard event for editor controls.
|
||
|
// Returns false if event should *not* be skipped (on true it can
|
||
|
// be optionally skipped).
|
||
|
// Basicly, false means that SelectProperty was called (or was about
|
||
|
// to be called, if canDestroy was false).
|
||
|
bool wxPropertyGrid::HandleChildKey( wxKeyEvent& event, bool canDestroy )
|
||
|
{
|
||
|
int keycode = event.GetKeyCode();
|
||
|
bool res = true;
|
||
|
|
||
|
#if __INTENSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid::HandleChildKey(%i)"),(int)event.GetKeyCode() );
|
||
|
#endif
|
||
|
|
||
|
// Unfocus?
|
||
|
if ( keycode == WXK_ESCAPE )
|
||
|
{
|
||
|
// Esc cancels any changes
|
||
|
EditorsValueWasNotModified();
|
||
|
|
||
|
wxPGProperty* p = m_selected;
|
||
|
|
||
|
res = false;
|
||
|
|
||
|
if ( canDestroy )
|
||
|
{
|
||
|
DoSelectProperty( (wxPGProperty*)NULL, wxPG_SEL_NOVALIDATE );
|
||
|
DoSelectProperty( p );
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
return res;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnKey( wxKeyEvent &event )
|
||
|
{
|
||
|
|
||
|
//
|
||
|
// Events to editor controls should get relayed here.
|
||
|
//
|
||
|
wxWindow* focused = wxWindow::FindFocus();
|
||
|
//wxLogDebug(wxT("OnKey"));
|
||
|
|
||
|
if ( m_wndPrimary &&
|
||
|
(focused==m_wndPrimary
|
||
|
|| m_editorFocused
|
||
|
#if wxPG_ENABLE_CLIPPER_WINDOW
|
||
|
|| ((m_wndPrimary->IsKindOf(CLASSINFO(wxPGClipperWindow))) &&
|
||
|
((wxPGClipperWindow*)m_wndPrimary)->GetControl() == focused)
|
||
|
#endif
|
||
|
) )
|
||
|
{
|
||
|
// Child key must be processed here, since it can
|
||
|
// destroy the control which is referred by its own
|
||
|
// event handling.
|
||
|
HandleChildKey( event, true );
|
||
|
}
|
||
|
else
|
||
|
HandleKeyEvent( event );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnKeyUp(wxKeyEvent &event)
|
||
|
{
|
||
|
m_keyComboConsumed = 0;
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnNavigationKey( wxNavigationKeyEvent& event )
|
||
|
{
|
||
|
// Ignore events that occur very close to focus set
|
||
|
if ( m_iFlags & wxPG_FL_IGNORE_NEXT_NAVKEY )
|
||
|
{
|
||
|
m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);
|
||
|
event.Skip();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
wxPGProperty* next = (wxPGProperty*) NULL;
|
||
|
|
||
|
int dir = event.GetDirection()?1:0;
|
||
|
|
||
|
if ( m_selected )
|
||
|
{
|
||
|
if ( dir == 1 && (m_wndPrimary || m_wndSecondary) )
|
||
|
{
|
||
|
wxWindow* focused = wxWindow::FindFocus();
|
||
|
|
||
|
wxWindow* wndToCheck = GetEditorControl();
|
||
|
|
||
|
// ODComboBox focus goes to its text ctrl, so we need to use it instead
|
||
|
if ( wndToCheck && wndToCheck->IsKindOf(CLASSINFO(wxPGOwnerDrawnComboBox)) )
|
||
|
{
|
||
|
wxTextCtrl* comboTextCtrl = ((wxPGOwnerDrawnComboBox*)wndToCheck)->GetTextCtrl();
|
||
|
if ( comboTextCtrl )
|
||
|
wndToCheck = comboTextCtrl;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
// Because of problems navigating from wxButton, do not go to it.
|
||
|
if ( !wndToCheck )
|
||
|
{
|
||
|
// No primary, use secondary
|
||
|
wndToCheck = m_wndSecondary;
|
||
|
}
|
||
|
// If it has editor button, focus to it after the primary editor.
|
||
|
// NB: Doesn't work since wxButton on wxMSW doesn't seem to propagate
|
||
|
// key events (yes, I'm using wxWANTS_CHARS with it, and yes I
|
||
|
// have somewhat debugged in window.cpp itself).
|
||
|
else if ( focused == wndToCheck &&
|
||
|
m_wndSecondary &&
|
||
|
!(GetExtraStyle() & wxPG_EX_NO_TAB_TO_BUTTON) )
|
||
|
{
|
||
|
wndToCheck = m_wndSecondary;
|
||
|
wxLogDebug(wxT("Exp1"));
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
if ( focused != wndToCheck &&
|
||
|
wndToCheck )
|
||
|
{
|
||
|
wndToCheck->SetFocus();
|
||
|
|
||
|
// Select all text in wxTextCtrl etc.
|
||
|
if ( m_wndPrimary && wndToCheck == m_wndPrimary )
|
||
|
m_selected->GetEditorClass()->OnFocus(m_selected,wndToCheck);
|
||
|
|
||
|
m_editorFocused = 1;
|
||
|
next = m_selected;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !next )
|
||
|
{
|
||
|
next = GetNeighbourItem(m_selected,true,dir);
|
||
|
|
||
|
if ( next )
|
||
|
{
|
||
|
// This allows preventing NavigateOut to occur
|
||
|
DoSelectProperty( next, wxPG_SEL_FOCUS );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !next )
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGrid::ButtonTriggerKeyTest( wxKeyEvent &event )
|
||
|
{
|
||
|
int keycode = event.GetKeyCode();
|
||
|
|
||
|
// Does the keycode trigger button?
|
||
|
if ( keycode == m_pushButKeyCode &&
|
||
|
m_wndSecondary &&
|
||
|
(!m_pushButKeyCodeNeedsAlt || event.AltDown()) &&
|
||
|
(!m_pushButKeyCodeNeedsCtrl || event.ControlDown()) )
|
||
|
{
|
||
|
m_keyComboConsumed = 1;
|
||
|
|
||
|
wxCommandEvent evt(wxEVT_COMMAND_BUTTON_CLICKED,m_wndSecondary->GetId());
|
||
|
GetEventHandler()->AddPendingEvent(evt);
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnChildKeyDown( wxKeyEvent &event )
|
||
|
{
|
||
|
int keycode = event.GetKeyCode();
|
||
|
|
||
|
// Ignore Alt and Control when they are down alone
|
||
|
if ( keycode == WXK_ALT ||
|
||
|
keycode == WXK_CONTROL )
|
||
|
{
|
||
|
event.Skip();
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
if ( ButtonTriggerKeyTest(event) )
|
||
|
return;
|
||
|
|
||
|
// Since event handling may destroy the control which
|
||
|
// triggered this event, we need to send it separately
|
||
|
// to the wxPropertyGrid itself. Also, to allow pushed
|
||
|
// event handler to grab ENTER, ESC and such, this
|
||
|
// has been changed to add all keys as events.
|
||
|
if ( HandleChildKey(event,false) == true )
|
||
|
event.Skip();
|
||
|
|
||
|
GetEventHandler()->AddPendingEvent(event);
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnChildKeyUp( wxKeyEvent &event )
|
||
|
{
|
||
|
m_keyComboConsumed = 0;
|
||
|
|
||
|
GetEventHandler()->AddPendingEvent(event);
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGrid miscellaneous event handling
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnIdle( wxIdleEvent& WXUNUSED(event) )
|
||
|
{
|
||
|
//
|
||
|
// Check if the focus is in this control or one of its children
|
||
|
wxWindow* newFocused = wxWindow::FindFocus();
|
||
|
|
||
|
if ( newFocused != m_curFocused )
|
||
|
HandleFocusChange( newFocused );
|
||
|
}
|
||
|
|
||
|
// Called by focus event handlers. newFocused is the window that becomes focused.
|
||
|
void wxPropertyGrid::HandleFocusChange( wxWindow* newFocused )
|
||
|
{
|
||
|
unsigned int oldFlags = m_iFlags;
|
||
|
|
||
|
//wxLogDebug(wxT("HandleFocusChange: %s"),newFocused?newFocused->GetClassInfo()->GetClassName():wxT("NULL"));
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_FOCUSED);
|
||
|
|
||
|
wxWindow* parent = newFocused;
|
||
|
|
||
|
// This must be one of nextFocus' parents.
|
||
|
while ( parent )
|
||
|
{
|
||
|
// Use m_eventObject, which is either wxPropertyGrid or
|
||
|
// wxPropertyGridManager, as appropriate.
|
||
|
if ( parent == m_eventObject )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_FOCUSED;
|
||
|
break;
|
||
|
}
|
||
|
parent = parent->GetParent();
|
||
|
}
|
||
|
|
||
|
m_curFocused = newFocused;
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_FOCUSED) !=
|
||
|
(oldFlags & wxPG_FL_FOCUSED) )
|
||
|
{
|
||
|
// On each focus kill, mark the next nav key event
|
||
|
// to be ignored (can't do on set focus since the
|
||
|
// event would occur before it).
|
||
|
if ( !(m_iFlags & wxPG_FL_FOCUSED) )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_IGNORE_NEXT_NAVKEY;
|
||
|
|
||
|
// Need to store changed value
|
||
|
CommitChangesFromEditor();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*
|
||
|
//
|
||
|
// Preliminary code for tab-order respecting
|
||
|
// tab-traversal (but should be moved to
|
||
|
// OnNav handler)
|
||
|
//
|
||
|
wxWindow* prevFocus = event.GetWindow();
|
||
|
wxWindow* useThis = this;
|
||
|
if ( m_iFlags & wxPG_FL_IN_MANAGER )
|
||
|
useThis = GetParent();
|
||
|
|
||
|
if ( prevFocus &&
|
||
|
prevFocus->GetParent() == useThis->GetParent() )
|
||
|
{
|
||
|
wxList& children = useThis->GetParent()->GetChildren();
|
||
|
|
||
|
wxNode* node = children.Find(prevFocus);
|
||
|
|
||
|
if ( node->GetNext() &&
|
||
|
useThis == node->GetNext()->GetData() )
|
||
|
DoSelectProperty(GetFirst());
|
||
|
else if ( node->GetPrevious () &&
|
||
|
useThis == node->GetPrevious()->GetData() )
|
||
|
DoSelectProperty(GetLastProperty());
|
||
|
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);
|
||
|
}
|
||
|
|
||
|
// Redraw selected
|
||
|
if ( m_selected && (m_iFlags & wxPG_FL_INITIALIZED) )
|
||
|
DrawItem( m_selected );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnFocusEvent( wxFocusEvent& event )
|
||
|
{
|
||
|
#if 1
|
||
|
if ( event.GetEventType() == wxEVT_SET_FOCUS )
|
||
|
HandleFocusChange((wxWindow*)event.GetEventObject());
|
||
|
// Line changed to "else" when applying patch #1675902
|
||
|
//else if ( event.GetWindow() )
|
||
|
else
|
||
|
HandleFocusChange(event.GetWindow());
|
||
|
|
||
|
event.Skip();
|
||
|
#else
|
||
|
unsigned int oldFlags = m_iFlags;
|
||
|
|
||
|
//
|
||
|
// Determine the current focus state
|
||
|
if ( event.GetEventType() == wxEVT_SET_FOCUS ||
|
||
|
event.GetEventType() == wxEVT_CHILD_FOCUS )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_FOCUSED;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
wxWindow* nextFocus = event.GetWindow();
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_FOCUSED);
|
||
|
|
||
|
wxWindow* parent = nextFocus;
|
||
|
//wxLogDebug(wxT("KillFocus: %s"),parent->GetClassInfo()->GetClassName());
|
||
|
|
||
|
// This must be one of nextFocus' parents.
|
||
|
while ( parent )
|
||
|
{
|
||
|
if ( parent == this )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_FOCUSED;
|
||
|
break;
|
||
|
}
|
||
|
parent = parent->GetParent();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( (m_iFlags & wxPG_FL_FOCUSED) !=
|
||
|
(oldFlags & wxPG_FL_FOCUSED) )
|
||
|
{
|
||
|
// On each focus kill, mark the next nav key event
|
||
|
// to be ignored (can't do on set focus since the
|
||
|
// event would occur before it).
|
||
|
if ( !(m_iFlags & wxPG_FL_FOCUSED) )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_IGNORE_NEXT_NAVKEY;
|
||
|
|
||
|
// Need to store changed value
|
||
|
CommitChangesFromEditor();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*
|
||
|
//
|
||
|
// Preliminary code for tab-order respecting
|
||
|
// tab-traversal (but should be moved to
|
||
|
// OnNav handler)
|
||
|
//
|
||
|
wxWindow* prevFocus = event.GetWindow();
|
||
|
wxWindow* useThis = this;
|
||
|
if ( m_iFlags & wxPG_FL_IN_MANAGER )
|
||
|
useThis = GetParent();
|
||
|
|
||
|
if ( prevFocus &&
|
||
|
prevFocus->GetParent() == useThis->GetParent() )
|
||
|
{
|
||
|
wxList& children = useThis->GetParent()->GetChildren();
|
||
|
|
||
|
wxNode* node = children.Find(prevFocus);
|
||
|
|
||
|
if ( node->GetNext() &&
|
||
|
useThis == node->GetNext()->GetData() )
|
||
|
DoSelectProperty(GetFirst());
|
||
|
else if ( node->GetPrevious () &&
|
||
|
useThis == node->GetPrevious()->GetData() )
|
||
|
DoSelectProperty(GetLastProperty());
|
||
|
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
m_iFlags &= ~(wxPG_FL_IGNORE_NEXT_NAVKEY);
|
||
|
}
|
||
|
|
||
|
// Redraw selected
|
||
|
if ( m_selected && (m_iFlags & wxPG_FL_INITIALIZED) )
|
||
|
DrawItem( m_selected );
|
||
|
}
|
||
|
|
||
|
event.Skip();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
void wxPropertyGrid::OnChildFocusEvent( wxChildFocusEvent& event )
|
||
|
{
|
||
|
HandleFocusChange((wxWindow*)event.GetEventObject());
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnScrollEvent( wxScrollWinEvent &event )
|
||
|
{
|
||
|
m_iFlags |= wxPG_FL_SCROLLED;
|
||
|
|
||
|
event.Skip();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::OnCaptureChange( wxMouseCaptureChangedEvent& WXUNUSED(event) )
|
||
|
{
|
||
|
if ( m_iFlags & wxPG_FL_MOUSE_CAPTURED )
|
||
|
{
|
||
|
#if __MOUSE_DEBUGGING__
|
||
|
wxLogDebug( wxT("wxPropertyGrid: mouse capture lost") );
|
||
|
#endif
|
||
|
m_iFlags &= ~(wxPG_FL_MOUSE_CAPTURED);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Property text-based storage
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#define wxPG_PROPERTY_FLAGS_COUNT 8
|
||
|
|
||
|
// property-flag-to-text array
|
||
|
static const wxChar* gs_property_flag_to_string[wxPG_PROPERTY_FLAGS_COUNT] =
|
||
|
{
|
||
|
wxT("Modified"),
|
||
|
wxT("Disabled"),
|
||
|
wxT("LowPriority"),
|
||
|
(const wxChar*) NULL, // wxPG_PROP_CUSTOMIMAGE is auto-generated flag
|
||
|
wxT("LimitedEditing"),
|
||
|
wxT("Unspecified"),
|
||
|
(const wxChar*) NULL, // Special flags cannot be stored as-is
|
||
|
(const wxChar*) NULL //
|
||
|
};
|
||
|
|
||
|
|
||
|
wxString wxPGProperty::GetAttributes( unsigned int flagmask )
|
||
|
{
|
||
|
wxASSERT(this);
|
||
|
|
||
|
wxString s;
|
||
|
unsigned int i;
|
||
|
unsigned int flags = ((unsigned int)m_flags) &
|
||
|
flagmask &
|
||
|
~(wxPG_PROP_CUSTOMIMAGE |
|
||
|
wxPG_PROP_CLASS_SPECIFIC_1 |
|
||
|
wxPG_PROP_CLASS_SPECIFIC_2);
|
||
|
|
||
|
if ( !flags )
|
||
|
return wxEmptyString;
|
||
|
|
||
|
for ( i=0; i<wxPG_PROPERTY_FLAGS_COUNT; i++ )
|
||
|
{
|
||
|
if ( flags & (1<<i) )
|
||
|
{
|
||
|
s.append( gs_property_flag_to_string[i] );
|
||
|
flags &= ~(1<<i);
|
||
|
if ( !flags )
|
||
|
break;
|
||
|
s.append(wxT(", "));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return s;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGProperty::SetAttributes( const wxString& attributes )
|
||
|
{
|
||
|
wxASSERT(this);
|
||
|
size_t i;
|
||
|
|
||
|
WX_PG_TOKENIZER1_BEGIN(attributes,wxT(','))
|
||
|
|
||
|
for (i=0;i<wxPG_PROPERTY_FLAGS_COUNT;i++)
|
||
|
{
|
||
|
const wxChar* flagText = gs_property_flag_to_string[i];
|
||
|
if ( flagText && token == flagText )
|
||
|
{
|
||
|
m_flags |= ( 1<<i );
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
WX_PG_TOKENIZER1_END()
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Returns name of property without 'Property' at the end, and 'wx'
|
||
|
// in the beginning (if any).
|
||
|
wxString wxPropertyContainerMethods::GetPropertyShortClassName( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxEmptyString)
|
||
|
|
||
|
if ( p->GetParentingType() != 1 )
|
||
|
{
|
||
|
const wxChar* src = p->GetClassName();
|
||
|
wxString s;
|
||
|
if ( src[0] == wxT('w') && src[1] == wxT('x') )
|
||
|
s = &src[2];
|
||
|
else
|
||
|
s = src;
|
||
|
wxASSERT( (((int)s.length())-8) > 0 );
|
||
|
s.Truncate(s.length()-8);
|
||
|
//s.LowerCase();
|
||
|
return s;
|
||
|
}
|
||
|
return wxT("Category");
|
||
|
}
|
||
|
|
||
|
wxPGId wxPropertyContainerMethods::GetPropertyByNameA( wxPGPropNameStr name ) const
|
||
|
{
|
||
|
wxPGId id = GetPropertyByName(name);
|
||
|
wxASSERT_MSG(wxPGIdIsOk(id),wxString::Format(wxT("no property with name '%s'"),name.c_str()));
|
||
|
return id;
|
||
|
}
|
||
|
|
||
|
// ----------------------------------------------------------------------------
|
||
|
// VariantDatas
|
||
|
// ----------------------------------------------------------------------------
|
||
|
|
||
|
#if wxPG_PGVARIANT_IS_VARIANT
|
||
|
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataPoint, wxVariantData)
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataSize, wxVariantData)
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataArrayInt, wxVariantData)
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataLongLong, wxVariantData)
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataULongLong, wxVariantData)
|
||
|
#ifdef __WXPYTHON__
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataPyObject, wxVariantData)
|
||
|
#endif
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Value type related methods (should all be pretty much static).
|
||
|
|
||
|
wxPGValueType::~wxPGValueType()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
wxPG_CONST_WXCHAR_PTR wxPGValueType::GetCustomTypeName() const
|
||
|
{
|
||
|
return GetTypeName();
|
||
|
}
|
||
|
|
||
|
// Implement default types.
|
||
|
WX_PG_IMPLEMENT_VALUE_TYPE(wxString,wxStringProperty,wxPGTypeName_wxString,GetString,wxEmptyString)
|
||
|
WX_PG_IMPLEMENT_VALUE_TYPE(long,wxIntProperty,wxPGTypeName_long,GetLong,(long)0)
|
||
|
WX_PG_IMPLEMENT_VALUE_TYPE(double,wxFloatProperty,wxPGTypeName_double,GetDouble,0.0)
|
||
|
WX_PG_IMPLEMENT_VALUE_TYPE(wxArrayString,wxArrayStringProperty,wxPGTypeName_wxArrayString,GetArrayString,wxArrayString())
|
||
|
|
||
|
// Bool is a special case... thanks to the C++'s bool vs int vs long inconsistency issues.
|
||
|
const wxPGValueType *wxPGValueType_bool = (wxPGValueType *) NULL;
|
||
|
class wxPGValueTypeboolClass : public wxPGValueType
|
||
|
{
|
||
|
public:
|
||
|
virtual wxPG_CONST_WXCHAR_PTR GetTypeName() const { return wxPGTypeName_long; }
|
||
|
virtual wxPG_CONST_WXCHAR_PTR GetCustomTypeName() const { return wxPGTypeName_bool; }
|
||
|
virtual wxPGVariant GetDefaultValue() const { return wxPGVariant((long)0); }
|
||
|
virtual wxVariant GenerateVariant( wxPGVariant value, const wxString& name ) const
|
||
|
{ return wxVariant ( value.GetBool(), name ); }
|
||
|
virtual wxPGProperty* GenerateProperty( const wxString& label, const wxString& name ) const
|
||
|
{
|
||
|
return wxPG_NEWPROPERTY(Bool,label,name,false);
|
||
|
}
|
||
|
virtual void SetValueFromVariant( wxPGProperty* property, wxVariant& value ) const
|
||
|
{
|
||
|
#if defined(__WXDEBUG__) || defined(__WXPYTHON__)
|
||
|
wxCHECK_RET( wxStrcmp(wxPGTypeName_bool,value.GetType().c_str()) == 0,
|
||
|
wxT("SetValueFromVariant: wxVariant type mismatch.") );
|
||
|
#endif
|
||
|
property->DoSetValue(value.GetBool()?(long)1:(long)0);
|
||
|
}
|
||
|
};
|
||
|
|
||
|
// Implement nonetype.
|
||
|
const wxPGValueType *wxPGValueType_none = (wxPGValueType*) NULL;
|
||
|
class wxPGValueTypenoneClass : public wxPGValueType
|
||
|
{
|
||
|
public:
|
||
|
virtual wxPG_CONST_WXCHAR_PTR GetTypeName() const { return wxT("null"); }
|
||
|
virtual wxPGVariant GetDefaultValue() const { return wxPGVariant((long)0); }
|
||
|
virtual wxVariant GenerateVariant( wxPGVariant, const wxString& name ) const
|
||
|
{ return wxVariant( (long)0, name ); }
|
||
|
virtual wxPGProperty* GenerateProperty( const wxString&, const wxString& ) const
|
||
|
{ return (wxPGProperty*) NULL; }
|
||
|
virtual void SetValueFromVariant( wxPGProperty*, wxVariant& ) const
|
||
|
{ }
|
||
|
};
|
||
|
|
||
|
// Implement void* type.
|
||
|
const wxPGValueType *wxPGValueType_void = (wxPGValueType*) NULL;
|
||
|
class wxPGValueTypevoidClass : public wxPGValueType
|
||
|
{
|
||
|
public:
|
||
|
virtual wxPG_CONST_WXCHAR_PTR GetTypeName() const { return wxPGTypeName_void; }
|
||
|
virtual wxPGVariant GetDefaultValue() const { return wxPGVariant((void*)NULL); }
|
||
|
virtual wxVariant GenerateVariant( wxPGVariant value, const wxString& name ) const
|
||
|
{ return wxVariant( wxPGVariantToVoidPtr(value), name ); }
|
||
|
virtual wxPGProperty* GenerateProperty( const wxString&, const wxString& ) const
|
||
|
{ return (wxPGProperty*) NULL; }
|
||
|
virtual void SetValueFromVariant( wxPGProperty* property, wxVariant& value ) const
|
||
|
{
|
||
|
#if defined(__WXDEBUG__) || defined(__WXPYTHON__)
|
||
|
wxCHECK_RET( wxStrcmp(GetTypeName(),value.GetType().c_str()) == 0,
|
||
|
wxT("SetValueFromVariant: wxVariant type mismatch.") );
|
||
|
#endif
|
||
|
property->DoSetValue(value.GetVoidPtr());
|
||
|
}
|
||
|
};
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
// Implement PyObject* type.
|
||
|
const wxPGValueType *wxPGValueType_PyObject = (wxPGValueType*) NULL;
|
||
|
class wxPGValueTypePyObjectClass : public wxPGValueType
|
||
|
{
|
||
|
public:
|
||
|
virtual wxPG_CONST_WXCHAR_PTR GetTypeName() const { return wxT("PyObject"); }
|
||
|
virtual wxPGVariant GetDefaultValue() const
|
||
|
{
|
||
|
return wxVariant( new wxPGVariantDataPyObject(Py_None) );
|
||
|
}
|
||
|
virtual wxVariant GenerateVariant( wxPGVariant value, const wxString& name ) const
|
||
|
{
|
||
|
value.SetName( name );
|
||
|
return value; // Can be done since under wxPython, wxPGVariant is wxVariant
|
||
|
}
|
||
|
virtual wxPGProperty* GenerateProperty( const wxString&, const wxString& ) const
|
||
|
{
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
virtual void SetValueFromVariant( wxPGProperty* property, wxVariant& value ) const
|
||
|
{
|
||
|
#if defined(__WXDEBUG__) || defined(__WXPYTHON__)
|
||
|
wxCHECK_RET( wxStrcmp(GetTypeName(),value.GetType().c_str()) == 0,
|
||
|
wxT("SetValueFromVariant: wxVariant type mismatch.") );
|
||
|
#endif
|
||
|
property->DoSetValue(value);
|
||
|
}
|
||
|
};
|
||
|
#endif // __WXPYTHON__
|
||
|
|
||
|
// Registers all default value types
|
||
|
void wxPropertyGrid::RegisterDefaultValues()
|
||
|
{
|
||
|
wxPGRegisterDefaultValueType( none );
|
||
|
wxPGRegisterDefaultValueType( wxString );
|
||
|
wxPGRegisterDefaultValueType( long );
|
||
|
wxPGRegisterDefaultValueType( bool );
|
||
|
wxPGRegisterDefaultValueType( double );
|
||
|
wxPGRegisterDefaultValueType( void );
|
||
|
wxPGRegisterDefaultValueType( wxArrayString );
|
||
|
#ifdef __WXPYTHON__
|
||
|
wxPGRegisterDefaultValueType( PyObject );
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// noDefCheck = true prevents infinite recursion.
|
||
|
wxPGValueType* wxPropertyGrid::RegisterValueType( wxPGValueType* valueclass, bool noDefCheck, const wxString& className )
|
||
|
{
|
||
|
wxASSERT( valueclass );
|
||
|
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
if ( !noDefCheck && wxPGGlobalVars->m_dictValueType.empty() )
|
||
|
RegisterDefaultValues();
|
||
|
|
||
|
wxString temp_str;
|
||
|
wxPG_CONST_WXCHAR_PTR name_ = valueclass->GetType();
|
||
|
const wxChar* name = wxPG_TO_WXCHAR_PTR(name_);
|
||
|
|
||
|
wxPGValueType* p_at_slot = (wxPGValueType*) wxPGGlobalVars->m_dictValueType[name];
|
||
|
|
||
|
if ( !p_at_slot )
|
||
|
{
|
||
|
wxPGGlobalVars->m_dictValueType[name] = (void*) valueclass;
|
||
|
|
||
|
#if wxPG_VALUETYPE_IS_STRING
|
||
|
wxPGGlobalVars->m_dictValueTypeByClass[className] = (void*) valueclass;
|
||
|
#else
|
||
|
wxUnusedVar(className);
|
||
|
#endif
|
||
|
|
||
|
return valueclass;
|
||
|
}
|
||
|
|
||
|
// Delete given object instance, but only if it wasn't the same as in the hashmap.
|
||
|
if ( p_at_slot != valueclass )
|
||
|
{
|
||
|
delete valueclass;
|
||
|
}
|
||
|
|
||
|
return p_at_slot;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*
|
||
|
* wxPGVariantDataWxObj
|
||
|
*/
|
||
|
|
||
|
//IMPLEMENT_DYNAMIC_CLASS(wxPGVariantDataWxObj, wxVariantData)
|
||
|
|
||
|
wxPGVariantDataWxObj::wxPGVariantDataWxObj()
|
||
|
: wxVariantData()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
wxPGVariantDataWxObj::~wxPGVariantDataWxObj()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
#if wxUSE_STD_IOSTREAM
|
||
|
bool wxPGVariantDataWxObj::Write(wxSTD ostream&) const
|
||
|
{
|
||
|
// Not implemented
|
||
|
return true;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
bool wxPGVariantDataWxObj::Write(wxString&) const
|
||
|
{
|
||
|
// Not implemented
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
#if wxUSE_STD_IOSTREAM
|
||
|
bool wxPGVariantDataWxObj::Read(wxSTD istream& WXUNUSED(str))
|
||
|
{
|
||
|
// Not implemented
|
||
|
return false;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
bool wxPGVariantDataWxObj::Read(wxString& WXUNUSED(str))
|
||
|
{
|
||
|
// Not implemented
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// Editor class specific.
|
||
|
|
||
|
// noDefCheck = true prevents infinite recursion.
|
||
|
wxPGEditor* wxPropertyGrid::RegisterEditorClass( wxPGEditor* editorclass,
|
||
|
const wxString& name,
|
||
|
bool noDefCheck )
|
||
|
{
|
||
|
wxASSERT( editorclass );
|
||
|
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
if ( !noDefCheck && wxPGGlobalVars->m_mapEditorClasses.empty() )
|
||
|
RegisterDefaultEditors();
|
||
|
|
||
|
wxPGGlobalVars->m_mapEditorClasses[name] = (void*)editorclass;
|
||
|
|
||
|
return editorclass;
|
||
|
}
|
||
|
|
||
|
// Registers all default editor classes
|
||
|
void wxPropertyGrid::RegisterDefaultEditors()
|
||
|
{
|
||
|
wxPGRegisterDefaultEditorClass( TextCtrl );
|
||
|
wxPGRegisterDefaultEditorClass( Choice );
|
||
|
wxPGRegisterDefaultEditorClass( ComboBox );
|
||
|
wxPGRegisterDefaultEditorClass( TextCtrlAndButton );
|
||
|
#if wxPG_INCLUDE_CHECKBOX
|
||
|
wxPGRegisterDefaultEditorClass( CheckBox );
|
||
|
#endif
|
||
|
wxPGRegisterDefaultEditorClass( ChoiceAndButton );
|
||
|
|
||
|
// Register SpinCtrl etc. editors before use
|
||
|
RegisterAdditionalEditors();
|
||
|
}
|
||
|
|
||
|
wxPGEditor* wxPropertyContainerMethods::GetEditorByName( const wxString& editor_name )
|
||
|
{
|
||
|
wxPGEditor* editor = (wxPGEditor*) wxPGGlobalVars->m_mapEditorClasses[editor_name];
|
||
|
wxASSERT_MSG( editor,
|
||
|
wxT("unregistered editor name") );
|
||
|
return editor;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGStringTokenizer
|
||
|
// Needed to handle C-style string lists (e.g. "str1" "str2")
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGStringTokenizer::wxPGStringTokenizer( const wxString& str, wxChar delimeter )
|
||
|
: m_str(&str), m_curPos(str.begin()), m_delimeter(delimeter)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
wxPGStringTokenizer::~wxPGStringTokenizer()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
bool wxPGStringTokenizer::HasMoreTokens()
|
||
|
{
|
||
|
const wxString& str = *m_str;
|
||
|
|
||
|
//wxASSERT_MSG( m_curPos != str.end(), wxT("Do not call wxPGStringTokenizer methods after HasMoreTokens has returned false."));
|
||
|
|
||
|
wxString::const_iterator i = m_curPos;
|
||
|
|
||
|
wxUniChar delim = m_delimeter;
|
||
|
wxUniChar a;
|
||
|
wxUniChar prev_a = wxT('\0');
|
||
|
|
||
|
bool inToken = false;
|
||
|
|
||
|
while ( i != str.end() )
|
||
|
{
|
||
|
a = wxPGGetIterChar(str, i);
|
||
|
|
||
|
if ( !inToken )
|
||
|
{
|
||
|
if ( a == delim )
|
||
|
{
|
||
|
inToken = true;
|
||
|
m_readyToken.clear();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( prev_a != wxT('\\') )
|
||
|
{
|
||
|
if ( a != delim )
|
||
|
{
|
||
|
if ( a != wxT('\\') )
|
||
|
m_readyToken << a;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//wxLogDebug(m_readyToken);
|
||
|
i++;
|
||
|
m_curPos = i;
|
||
|
return true;
|
||
|
}
|
||
|
prev_a = a;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_readyToken << a;
|
||
|
prev_a = wxT('\0');
|
||
|
}
|
||
|
}
|
||
|
i++;
|
||
|
}
|
||
|
|
||
|
m_curPos = str.end();
|
||
|
|
||
|
if ( inToken )
|
||
|
return true;
|
||
|
|
||
|
return false;
|
||
|
|
||
|
/*
|
||
|
const wxChar* ptr = m_curPos;
|
||
|
const wxChar* ptr_end = &m_str->c_str()[m_str->length()];
|
||
|
|
||
|
size_t store_index = 0xFFFFFFFF;
|
||
|
|
||
|
#if !wxUSE_STL
|
||
|
wxChar* store_ptr_base = (wxChar*) NULL;
|
||
|
#endif
|
||
|
|
||
|
wxChar delim = m_delimeter;
|
||
|
wxChar a = *ptr;
|
||
|
wxChar prev_a = 0;
|
||
|
|
||
|
while ( a )
|
||
|
{
|
||
|
if ( store_index == 0xFFFFFFFF )
|
||
|
{
|
||
|
if ( a == delim )
|
||
|
{
|
||
|
size_t req_len = ptr_end-ptr+1;
|
||
|
#if wxUSE_STL
|
||
|
if ( m_readyToken.length() < req_len )
|
||
|
m_readyToken.resize( req_len, wxT(' ') );
|
||
|
#else
|
||
|
store_ptr_base = m_readyToken.GetWriteBuf( req_len );
|
||
|
#endif
|
||
|
store_index = 0;
|
||
|
prev_a = 0;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( prev_a != wxT('\\') )
|
||
|
{
|
||
|
if ( a != delim )
|
||
|
{
|
||
|
if ( a != wxT('\\') )
|
||
|
{
|
||
|
#if wxUSE_STL
|
||
|
m_readyToken[store_index] = a;
|
||
|
#else
|
||
|
store_ptr_base[store_index] = a;
|
||
|
#endif
|
||
|
store_index++;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#if wxUSE_STL
|
||
|
m_readyToken[store_index] = 0;
|
||
|
m_readyToken.resize(store_index,wxT(' '));
|
||
|
#else
|
||
|
store_ptr_base[store_index] = 0;
|
||
|
m_readyToken.UngetWriteBuf( store_index );
|
||
|
#endif
|
||
|
m_curPos = ptr+1;
|
||
|
return true;
|
||
|
}
|
||
|
prev_a = a;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#if wxUSE_STL
|
||
|
m_readyToken[store_index] = a;
|
||
|
#else
|
||
|
store_ptr_base[store_index] = a;
|
||
|
#endif
|
||
|
store_index++;
|
||
|
prev_a = 0;
|
||
|
}
|
||
|
}
|
||
|
ptr++;
|
||
|
a = *ptr;
|
||
|
}
|
||
|
#if !wxUSE_STL
|
||
|
if ( store_index != 0xFFFFFFFF )
|
||
|
m_readyToken.UngetWriteBuf( store_index );
|
||
|
#endif
|
||
|
m_curPos = (const wxChar*) NULL;
|
||
|
return false;
|
||
|
*/
|
||
|
}
|
||
|
|
||
|
wxString wxPGStringTokenizer::GetNextToken()
|
||
|
{
|
||
|
//wxASSERT_MSG( m_curPos != m_str->end(), wxT("Do not call wxPGStringTokenizer methods after HasMoreTokens has returned false."));
|
||
|
return m_readyToken;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGChoicesData
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGChoicesData::wxPGChoicesData()
|
||
|
{
|
||
|
m_refCount = 1;
|
||
|
}
|
||
|
|
||
|
wxPGChoicesData::~wxPGChoicesData()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPGChoices
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Add( const wxChar* label, int value )
|
||
|
{
|
||
|
EnsureData();
|
||
|
|
||
|
if ( value != wxPG_INVALID_VALUE && m_data->m_arrLabels.GetCount() == m_data->m_arrValues.GetCount() )
|
||
|
m_data->m_arrValues.Add( value );
|
||
|
else if ( m_data->m_arrValues.GetCount() > 0 )
|
||
|
m_data->m_arrValues.Add( 0 );
|
||
|
|
||
|
m_data->m_arrLabels.Add ( label );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxCHECK_VERSION(2,9,0)
|
||
|
void wxPGChoices::Insert( const wxString& label, int index, int value )
|
||
|
#else
|
||
|
void wxPGChoices::Insert( const wxChar* label, int index, int value )
|
||
|
#endif
|
||
|
{
|
||
|
EnsureData();
|
||
|
|
||
|
if ( value != wxPG_INVALID_VALUE && m_data->m_arrLabels.GetCount() == m_data->m_arrValues.GetCount() )
|
||
|
m_data->m_arrValues.Insert( value, index );
|
||
|
else if ( m_data->m_arrValues.GetCount() > 0 )
|
||
|
m_data->m_arrValues.Insert( 0, index );
|
||
|
|
||
|
m_data->m_arrLabels.Insert( label, index );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::AddAsSorted( const wxString& label, int value )
|
||
|
{
|
||
|
//wxASSERT_MSG( IsOk(),
|
||
|
// wxT("do not add items to invalid wxPGChoices") );
|
||
|
EnsureData();
|
||
|
|
||
|
size_t index = 0;
|
||
|
|
||
|
wxArrayString& labels = m_data->m_arrLabels;
|
||
|
wxArrayInt& values = m_data->m_arrValues;
|
||
|
|
||
|
while ( index < labels.GetCount() )
|
||
|
{
|
||
|
int cmpRes = labels[index].Cmp(label);
|
||
|
if ( cmpRes > 0 )
|
||
|
break;
|
||
|
index++;
|
||
|
}
|
||
|
|
||
|
if ( value != wxPG_INVALID_VALUE &&
|
||
|
labels.GetCount() == values.GetCount() )
|
||
|
values.Insert ( value, index );
|
||
|
|
||
|
labels.Insert ( label, index );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Add( const wxChar** labels, const long* values )
|
||
|
{
|
||
|
//wxASSERT_MSG( IsOk(),
|
||
|
// wxT("do not add items to invalid wxPGChoices") );
|
||
|
EnsureData();
|
||
|
|
||
|
unsigned int itemcount = 0;
|
||
|
const wxChar** p = &labels[0];
|
||
|
while ( *p ) { p++; itemcount++; }
|
||
|
|
||
|
wxArrayString& i_labels = m_data->m_arrLabels;
|
||
|
wxArrayInt& i_values = m_data->m_arrValues;
|
||
|
|
||
|
unsigned int i;
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
{
|
||
|
i_labels.Add ( labels[i] );
|
||
|
}
|
||
|
if ( values )
|
||
|
{
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
{
|
||
|
i_values.Add ( values[i] );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Add( const wxArrayString& arr, const long* values )
|
||
|
{
|
||
|
//wxASSERT_MSG( IsOk(),
|
||
|
// wxT("do not add items to invalid wxPGChoices") );
|
||
|
EnsureData();
|
||
|
|
||
|
wxArrayString& labels = m_data->m_arrLabels;
|
||
|
wxArrayInt& i_values = m_data->m_arrValues;
|
||
|
|
||
|
unsigned int i;
|
||
|
unsigned int itemcount = arr.GetCount();
|
||
|
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
{
|
||
|
labels.Add ( arr[i] );
|
||
|
}
|
||
|
if ( values )
|
||
|
{
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
i_values.Add ( values[i] );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Add( const wxArrayString& arr, const wxArrayInt& arrint )
|
||
|
{
|
||
|
//wxASSERT_MSG( IsOk(),
|
||
|
// wxT("do not add items to invalid wxPGChoices") );
|
||
|
EnsureData();
|
||
|
|
||
|
wxArrayString& labels = m_data->m_arrLabels;
|
||
|
wxArrayInt& values = m_data->m_arrValues;
|
||
|
|
||
|
unsigned int i;
|
||
|
unsigned int itemcount = arr.GetCount();
|
||
|
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
{
|
||
|
labels.Add ( arr[i] );
|
||
|
}
|
||
|
|
||
|
if ( &arrint && arrint.GetCount() )
|
||
|
for ( i = 0; i < itemcount; i++ )
|
||
|
{
|
||
|
values.Add ( arrint[i] );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::AssignData( wxPGChoicesData* data )
|
||
|
{
|
||
|
Free();
|
||
|
|
||
|
if ( data != wxPGChoicesEmptyData )
|
||
|
{
|
||
|
m_data = data;
|
||
|
data->m_refCount++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Init()
|
||
|
{
|
||
|
m_data = wxPGChoicesEmptyData;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPGChoices::Free()
|
||
|
{
|
||
|
if ( m_data != wxPGChoicesEmptyData )
|
||
|
{
|
||
|
m_data->m_refCount--;
|
||
|
if ( m_data->m_refCount < 1 )
|
||
|
delete m_data;
|
||
|
m_data = wxPGChoicesEmptyData;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridEvent
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
IMPLEMENT_DYNAMIC_CLASS(wxPropertyGridEvent, wxCommandEvent)
|
||
|
|
||
|
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_SELECTED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_CHANGED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_HIGHLIGHTED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_RIGHT_CLICK )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_PAGE_CHANGED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_EXPANDED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_ITEM_COLLAPSED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_DOUBLE_CLICK )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_COMPACT_MODE_ENTERED )
|
||
|
DEFINE_EVENT_TYPE( wxEVT_PG_EXPANDED_MODE_ENTERED )
|
||
|
|
||
|
|
||
|
wxPropertyGridEvent::wxPropertyGridEvent(wxEventType commandType, int id)
|
||
|
: wxCommandEvent(commandType,id)
|
||
|
{
|
||
|
m_property = NULL;
|
||
|
m_pending = false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridEvent::wxPropertyGridEvent(const wxPropertyGridEvent& event)
|
||
|
: wxCommandEvent(event)
|
||
|
{
|
||
|
m_eventType = event.GetEventType();
|
||
|
m_eventObject = event.m_eventObject;
|
||
|
m_pg = event.m_pg;
|
||
|
m_property = event.m_property;
|
||
|
m_pending = false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridEvent::~wxPropertyGridEvent()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxEvent* wxPropertyGridEvent::Clone() const
|
||
|
{
|
||
|
return new wxPropertyGridEvent( *this );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyContainerMethods
|
||
|
// - common methods for wxPropertyGrid and wxPropertyGridManager -
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::DoSetPropertyAttribute( wxPGId id, int attrid,
|
||
|
wxVariant& value, long argFlags )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG()
|
||
|
|
||
|
p->SetAttribute(attrid,value);
|
||
|
|
||
|
if ( ( argFlags & wxPG_RECURSE ) && p->GetParentingType() != 0 )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
DoSetPropertyAttribute(pwc->Item(i),attrid,value,argFlags);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGrid::SetPropertyAttributeAll( int attrid, wxVariant value )
|
||
|
{
|
||
|
DoSetPropertyAttribute(GetRoot(),attrid,value,wxPG_RECURSE);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::SetBoolChoices( const wxChar* true_choice,
|
||
|
const wxChar* false_choice )
|
||
|
{
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
wxPGGlobalVars->m_boolChoices[0] = false_choice;
|
||
|
wxPGGlobalVars->m_boolChoices[1] = true_choice;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGChoices gs_emptyChoices;
|
||
|
|
||
|
wxPGChoices& wxPropertyContainerMethods::GetPropertyChoices( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(gs_emptyChoices)
|
||
|
|
||
|
wxPGChoiceInfo ci;
|
||
|
ci.m_choices = (wxPGChoices*) NULL;
|
||
|
|
||
|
p->GetChoiceInfo(&ci);
|
||
|
|
||
|
if ( !ci.m_choices )
|
||
|
return gs_emptyChoices;
|
||
|
|
||
|
return *ci.m_choices;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGChoices& wxPropertyContainerMethods::GetPropertyChoices( wxPGPropNameStr name )
|
||
|
{
|
||
|
wxPG_PROP_NAME_CALL_PROLOG_RETVAL(gs_emptyChoices)
|
||
|
return GetPropertyChoices(wxPGIdGen(p));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyContainerMethods::DoGetPropertyByName( wxPGPropNameStr name ) const
|
||
|
{
|
||
|
return m_pState->BaseGetPropertyByName(name);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyContainerMethods::GetPropertyByName( wxPGPropNameStr name,
|
||
|
wxPGPropNameStr subname ) const
|
||
|
{
|
||
|
wxPGId id = DoGetPropertyByName(name);
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*) wxPGIdToPtr(id);
|
||
|
if ( !pwc || !pwc->GetParentingType() )
|
||
|
return wxNullProperty;
|
||
|
|
||
|
return wxPGIdGen(pwc->GetPropertyByName(subname));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Since GetPropertyByName is used *a lot*, this makes sense
|
||
|
// since non-virtual method can be called with less code.
|
||
|
wxPGId wxPropertyContainerMethods::GetPropertyByName( wxPGPropNameStr name ) const
|
||
|
{
|
||
|
wxPGId id = DoGetPropertyByName(name);
|
||
|
if ( wxPGIdIsOk(id) )
|
||
|
return id;
|
||
|
|
||
|
// Check if its "Property.SubProperty" format
|
||
|
int pos = name.Find(wxT('.'));
|
||
|
if ( pos <= 0 )
|
||
|
return id;
|
||
|
|
||
|
return GetPropertyByName(name.substr(0,pos),
|
||
|
name.substr(pos+1,name.length()-pos-1));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyContainerMethods::HideProperty( wxPGId id, bool hide )
|
||
|
{
|
||
|
// Hiding properties requires that we are always in the compact mode
|
||
|
m_pState->GetGrid()->Compact(true);
|
||
|
return SetPropertyPriority(id,hide?wxPG_LOW:wxPG_HIGH);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Used by HideProperty as well
|
||
|
bool wxPropertyContainerMethods::SetPropertyPriority( wxPGId id, int priority )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
|
||
|
wxPropertyGrid* pg = m_pState->GetGrid();
|
||
|
|
||
|
if ( pg == p->GetGrid() )
|
||
|
return pg->SetPropertyPriority(p,priority);
|
||
|
else
|
||
|
m_pState->SetPropertyPriority(p,priority);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyContainerMethods::SetPropertyMaxLength( wxPGId id, int maxLen )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
|
||
|
wxPropertyGrid* pg = m_pState->GetGrid();
|
||
|
|
||
|
p->m_maxLen = (short) maxLen;
|
||
|
|
||
|
// Adjust control if selected currently
|
||
|
if ( pg == p->GetGrid() && p == m_pState->GetSelection() )
|
||
|
{
|
||
|
wxWindow* wnd = pg->GetEditorControl();
|
||
|
wxTextCtrl* tc = wxDynamicCast(wnd,wxTextCtrl);
|
||
|
if ( tc )
|
||
|
tc->SetMaxLength( maxLen );
|
||
|
else
|
||
|
// Not a text ctrl
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// GetPropertyValueAsXXX methods
|
||
|
|
||
|
#define IMPLEMENT_GET_VALUE(T,TRET,BIGNAME,DEFRETVAL) \
|
||
|
TRET wxPropertyContainerMethods::GetPropertyValueAs##BIGNAME( wxPGId id ) wxPG_GETVALUE_CONST \
|
||
|
{ \
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(DEFRETVAL) \
|
||
|
if ( p->GetValueTypePtr()->GetTypeName() != wxPGTypeName_##T ) \
|
||
|
{ \
|
||
|
wxPGGetFailed(p,wxPGTypeName_##T); \
|
||
|
return (TRET)DEFRETVAL; \
|
||
|
} \
|
||
|
return (TRET)wxPGVariantTo##BIGNAME(p->DoGetValue()); \
|
||
|
}
|
||
|
|
||
|
// String is different than others.
|
||
|
wxString wxPropertyContainerMethods::GetPropertyValueAsString( wxPGId id ) wxPG_GETVALUE_CONST
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxEmptyString)
|
||
|
return p->GetValueAsString(wxPG_FULL_VALUE);
|
||
|
}
|
||
|
|
||
|
IMPLEMENT_GET_VALUE(long,long,Long,0)
|
||
|
IMPLEMENT_GET_VALUE(long,bool,Bool,false)
|
||
|
IMPLEMENT_GET_VALUE(double,double,Double,0.0)
|
||
|
IMPLEMENT_GET_VALUE(void,void*,VoidPtr,NULL)
|
||
|
#ifdef __WXPYTHON__
|
||
|
IMPLEMENT_GET_VALUE(PyObject,PyObject*,PyObject,Py_None)
|
||
|
#endif
|
||
|
|
||
|
#if !wxPG_PGVARIANT_IS_VARIANT
|
||
|
IMPLEMENT_GET_VALUE(wxArrayString,const wxArrayString&,ArrayString,*((wxArrayString*)NULL))
|
||
|
#endif
|
||
|
|
||
|
// wxObject is different than others.
|
||
|
const wxObject* wxPropertyContainerMethods::GetPropertyValueAsWxObjectPtr( wxPGId id ) wxPG_GETVALUE_CONST
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL((const wxObject*)NULL)
|
||
|
wxPG_CONST_WXCHAR_PTR typestr = p->GetValueTypePtr()->GetTypeName();
|
||
|
if ( typestr[0] != wxT('w') || typestr[1] != wxT('x') )
|
||
|
{
|
||
|
wxPGGetFailed(p,wxT("wxObject"));
|
||
|
return (const wxObject*) NULL;
|
||
|
}
|
||
|
return (const wxObject*)wxPGVariantGetWxObjectPtr(p->DoGetValue());
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyContainerMethods::IsPropertyExpanded( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(false)
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->GetParentingType() == 0 )
|
||
|
return false;
|
||
|
return pwc->IsExpanded();
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// returns value type class for type name
|
||
|
wxPGValueType* wxPropertyContainerMethods::GetValueType(const wxString &type)
|
||
|
{
|
||
|
wxPGHashMapS2P::iterator it;
|
||
|
|
||
|
it = wxPGGlobalVars->m_dictValueType.find(type);
|
||
|
|
||
|
if ( it != wxPGGlobalVars->m_dictValueType.end() )
|
||
|
return (wxPGValueType*) it->second;
|
||
|
|
||
|
return (wxPGValueType*) NULL;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
#if wxPG_VALUETYPE_IS_STRING
|
||
|
wxPGValueType* wxPropertyContainerMethods::GetValueTypeByName(const wxString &className)
|
||
|
{
|
||
|
wxPGHashMapS2P::iterator it;
|
||
|
|
||
|
it = wxPGGlobalVars->m_dictValueTypeByClass.find(className);
|
||
|
|
||
|
if ( it != wxPGGlobalVars->m_dictValueTypeByClass.end() )
|
||
|
return (wxPGValueType*) it->second;
|
||
|
|
||
|
return (wxPGValueType*) NULL;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGProperty* wxPropertyContainerMethods::CreatePropertyByType(const wxString &valuetype,
|
||
|
const wxString &label,
|
||
|
const wxString &name)
|
||
|
{
|
||
|
wxPGHashMapS2P::iterator it;
|
||
|
|
||
|
it = wxPGGlobalVars->m_dictValueType.find(valuetype);
|
||
|
|
||
|
if ( it != wxPGGlobalVars->m_dictValueType.end() )
|
||
|
{
|
||
|
wxPGValueType* vt = (wxPGValueType*) it->second;
|
||
|
wxPGProperty* p = vt->GenerateProperty(label,name);
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( !p )
|
||
|
{
|
||
|
wxLogDebug(wxT("WARNING: CreatePropertyByValueType generated NULL property for ValueType \"%s\""),valuetype.c_str());
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
#endif
|
||
|
return p;
|
||
|
}
|
||
|
|
||
|
wxLogDebug(wxT("WARNING: No value type registered with name \"%s\""),valuetype.c_str());
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGProperty* wxPropertyContainerMethods::CreatePropertyByClass(const wxString &classname,
|
||
|
const wxString &label,
|
||
|
const wxString &name)
|
||
|
{
|
||
|
wxPGHashMapS2P* cis =
|
||
|
(wxPGHashMapS2P*) &wxPGGlobalVars->m_dictPropertyClassInfo;
|
||
|
|
||
|
const wxString* pClassname = &classname;
|
||
|
wxString s;
|
||
|
|
||
|
// Translate to long name, if necessary
|
||
|
if ( (pClassname->GetChar(0) != wxT('w') || pClassname->GetChar(1) != wxT('x')) &&
|
||
|
pClassname->Find(wxT("Property")) < 0 )
|
||
|
{
|
||
|
if ( classname != wxT("Category") )
|
||
|
s.Printf(wxT("wx%sProperty"),pClassname->c_str());
|
||
|
else
|
||
|
s = wxT("wxPropertyCategory");
|
||
|
pClassname = &s;
|
||
|
}
|
||
|
|
||
|
wxPGHashMapS2P::iterator it;
|
||
|
it = cis->find(*pClassname);
|
||
|
|
||
|
if ( it != cis->end() )
|
||
|
{
|
||
|
wxPGPropertyClassInfo* pci = (wxPGPropertyClassInfo*) it->second;
|
||
|
wxPGProperty* p = pci->m_constructor(label,name);
|
||
|
return p;
|
||
|
}
|
||
|
wxLogError(wxT("No such property class: %s"),pClassname->c_str());
|
||
|
return (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// lazy way to prevent RegisterPropertyClass infinite recursion
|
||
|
static int gs_registering_standard_props = 0;
|
||
|
|
||
|
bool wxPropertyContainerMethods::RegisterPropertyClass( const wxChar* name,
|
||
|
wxPGPropertyClassInfo* classinfo )
|
||
|
{
|
||
|
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
// Standard classes must be registered first!
|
||
|
if ( !gs_registering_standard_props &&
|
||
|
wxPGGlobalVars->m_dictPropertyClassInfo.empty()
|
||
|
)
|
||
|
wxPGRegisterStandardPropertyClasses();
|
||
|
|
||
|
wxPGHashMapS2P::iterator it;
|
||
|
|
||
|
it = wxPGGlobalVars->m_dictPropertyClassInfo.find(name);
|
||
|
|
||
|
// only register if not registered already
|
||
|
if ( it == wxPGGlobalVars->m_dictPropertyClassInfo.end() )
|
||
|
{
|
||
|
wxPGGlobalVars->m_dictPropertyClassInfo[name] = classinfo;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
wxLogDebug(wxT("WARNING: Property class named \"%s\" was already registered."),name);
|
||
|
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
static void wxPGRegisterStandardPropertyClasses()
|
||
|
{
|
||
|
|
||
|
if ( gs_registering_standard_props )
|
||
|
return;
|
||
|
|
||
|
gs_registering_standard_props = 1; // no need to reset this
|
||
|
|
||
|
wxPGRegisterPropertyClass(wxStringProperty);
|
||
|
wxPGRegisterPropertyClass(wxIntProperty);
|
||
|
wxPGRegisterPropertyClass(wxUIntProperty);
|
||
|
wxPGRegisterPropertyClass(wxFloatProperty);
|
||
|
wxPGRegisterPropertyClass(wxBoolProperty);
|
||
|
wxPGRegisterPropertyClass(wxEnumProperty);
|
||
|
wxPGRegisterPropertyClass(wxFlagsProperty);
|
||
|
wxPGRegisterPropertyClass(wxLongStringProperty);
|
||
|
|
||
|
wxPGRegisterPropertyClass(wxPropertyCategory);
|
||
|
wxPGRegisterPropertyClass(wxParentProperty);
|
||
|
wxPGRegisterPropertyClass(wxCustomProperty);
|
||
|
|
||
|
// TODO: Are these really "standard" ?
|
||
|
wxPGRegisterPropertyClass(wxArrayStringProperty);
|
||
|
wxPGRegisterPropertyClass(wxFileProperty);
|
||
|
wxPGRegisterPropertyClass(wxDirProperty);
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
wxPropertyContainerMethods::RegisterAdvancedPropertyClasses();
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// reset helper macro
|
||
|
#undef FROM_STATE
|
||
|
#define FROM_STATE(A) A
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState item iteration methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Skips categories and sub-properties (unless in wxCustomProperty/wxParentProperty).
|
||
|
wxPGId wxPropertyGridState::GetFirstProperty() const
|
||
|
{
|
||
|
if ( !m_properties->GetCount() ) return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
wxPGProperty* p = m_properties->Item(0);
|
||
|
int parenting = p->GetParentingType();
|
||
|
if ( parenting > 0 )
|
||
|
return GetNextProperty ( wxPGIdGen(p) );
|
||
|
return wxPGIdGen(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Skips categories and sub-properties (unless in wxParentProperty).
|
||
|
wxPGId wxPropertyGridState::GetNextProperty( wxPGId id ) const
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
// Go with first child?
|
||
|
int parenting = pwc->GetParentingType();
|
||
|
if ( parenting == 0 || parenting == -1 || !pwc->GetCount() )
|
||
|
{
|
||
|
// No...
|
||
|
|
||
|
wxPGPropertyWithChildren* parent = pwc->m_parent;
|
||
|
|
||
|
// As long as last item, go up and get parent' sibling
|
||
|
while ( pwc->m_arrIndex >= (parent->GetCount()-1) )
|
||
|
{
|
||
|
pwc = parent;
|
||
|
if ( pwc == m_properties ) return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
parent = parent->m_parent;
|
||
|
}
|
||
|
|
||
|
pwc = (wxPGPropertyWithChildren*)parent->Item(pwc->m_arrIndex+1);
|
||
|
|
||
|
// Go with the next sibling of parent's parent?
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Yes...
|
||
|
pwc = (wxPGPropertyWithChildren*)pwc->Item(0);
|
||
|
}
|
||
|
|
||
|
// If it's category or parentproperty, then go recursive
|
||
|
parenting = pwc->GetParentingType();
|
||
|
if ( parenting > PT_NONE )
|
||
|
return GetNextProperty( wxPGIdGen(pwc) );
|
||
|
|
||
|
return wxPGIdGen(pwc);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::GetNextSibling( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
wxPGPropertyWithChildren* parent = p->m_parent;
|
||
|
size_t next_ind = p->m_arrIndex + 1;
|
||
|
if ( next_ind >= parent->GetCount() ) return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
return wxPGIdGen(parent->Item(next_ind));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::GetPrevSibling( wxPGId id )
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
size_t ind = p->m_arrIndex;
|
||
|
if ( ind < 1 ) return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
return wxPGIdGen(p->m_parent->Item(ind-1));
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Skips categories and sub-properties (unless in wxParentProperty).
|
||
|
wxPGId wxPropertyGridState::GetPrevProperty( wxPGId id ) const
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
wxPGPropertyWithChildren* p2 = (wxPGPropertyWithChildren*) p;
|
||
|
wxPGPropertyWithChildren* parent = p2->m_parent;
|
||
|
|
||
|
// Is there a previous sibling?
|
||
|
if ( p2->m_arrIndex > 0 )
|
||
|
{
|
||
|
// There is!
|
||
|
p2 = (wxPGPropertyWithChildren*)parent->Item ( p2->m_arrIndex-1 );
|
||
|
int parenting = p2->GetParentingType();
|
||
|
|
||
|
// Do we return it's last child?
|
||
|
while ( (parenting > 0 || parenting == PT_CUSTOMPROPERTY) && p2->GetCount() )
|
||
|
{
|
||
|
p2 = (wxPGPropertyWithChildren*)p2->Last();
|
||
|
parenting = p2->GetParentingType();
|
||
|
}
|
||
|
}
|
||
|
else if ( parent != m_properties )
|
||
|
// Return parent if it isnt' the root
|
||
|
p2 = parent;
|
||
|
else
|
||
|
return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
|
||
|
// Skip category and parentproperty.
|
||
|
int parenting = p2->GetParentingType();
|
||
|
if ( parenting > PT_NONE )
|
||
|
return GetPrevProperty ( wxPGIdGen(p2) );
|
||
|
|
||
|
return wxPGIdGen(p2);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::GetFirstCategory() const
|
||
|
{
|
||
|
//if ( IsInNonCatMode() )
|
||
|
// return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
|
||
|
wxPGProperty* found = (wxPGProperty*)NULL;
|
||
|
|
||
|
size_t i;
|
||
|
for ( i=0; i<m_regularArray.GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = m_regularArray.Item(i);
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
{
|
||
|
found = p;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
return wxPGIdGen(found);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::GetNextCategory( wxPGId id ) const
|
||
|
{
|
||
|
wxPG_PROP_ID_CALL_PROLOG_RETVAL(wxNullProperty)
|
||
|
|
||
|
wxPGPropertyWithChildren* current = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
wxCHECK_MSG( !IsInNonCatMode() || current->GetParentingType() == 1, wxPGIdGen((wxPGProperty*)NULL),
|
||
|
wxT("GetNextCategory should not be called with non-category argument in non-categoric mode.") );
|
||
|
|
||
|
wxPGPropertyWithChildren* parent = current->m_parent;
|
||
|
wxPGProperty* found = (wxPGProperty*) NULL;
|
||
|
size_t i;
|
||
|
|
||
|
// Find sub-category, if any.
|
||
|
if ( current->GetParentingType() > 0 )
|
||
|
{
|
||
|
// Find first sub-category in current's array.
|
||
|
for ( i = 0; i<current->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = current->Item(i);
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
{
|
||
|
found = p;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if ( found )
|
||
|
return wxPGIdGen(found);
|
||
|
}
|
||
|
|
||
|
// Find next category in parent's array.
|
||
|
// (and go up in hierarchy until one found or
|
||
|
// top is reached).
|
||
|
do
|
||
|
{
|
||
|
for ( i = current->m_arrIndex+1; i<parent->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = parent->Item(i);
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
{
|
||
|
found = p;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
current = parent;
|
||
|
parent = parent->m_parent;
|
||
|
} while ( !found && parent );
|
||
|
|
||
|
return wxPGIdGen(found);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState GetPropertyXXX methods
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::GetPropertyByLabel( const wxString& label,
|
||
|
wxPGPropertyWithChildren* parent ) const
|
||
|
{
|
||
|
|
||
|
size_t i;
|
||
|
|
||
|
if ( !parent ) parent = (wxPGPropertyWithChildren*) &m_regularArray;
|
||
|
|
||
|
for ( i=0; i<parent->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = parent->Item(i);
|
||
|
if ( p->m_label == label )
|
||
|
return wxPGIdGen(p);
|
||
|
// Check children recursively.
|
||
|
if ( p->GetParentingType() != 0 )
|
||
|
{
|
||
|
p = wxPGIdToPtr(GetPropertyByLabel(label,(wxPGPropertyWithChildren*)p));
|
||
|
if ( p )
|
||
|
return wxPGIdGen(p);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return wxPGIdGen((wxPGProperty*) NULL);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::BaseGetPropertyByName( wxPGPropNameStr name ) const
|
||
|
{
|
||
|
wxPGHashMapS2P::const_iterator it;
|
||
|
it = m_dictName.find(name);
|
||
|
if ( it != m_dictName.end() )
|
||
|
return wxPGIdGen( (wxPGProperty*) it->second );
|
||
|
return wxPGIdGen( (wxPGProperty*) NULL );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState global operations
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::EnableCategories( bool enable )
|
||
|
{
|
||
|
ITEM_ITERATION_VARIABLES
|
||
|
|
||
|
if ( enable )
|
||
|
{
|
||
|
//
|
||
|
// Enable categories
|
||
|
//
|
||
|
|
||
|
if ( !IsInNonCatMode() )
|
||
|
return false;
|
||
|
|
||
|
m_properties = &m_regularArray;
|
||
|
|
||
|
// fix parents, indexes, and depths
|
||
|
ITEM_ITERATION_INIT_FROM_THE_TOP
|
||
|
|
||
|
ITEM_ITERATION_LOOP_BEGIN
|
||
|
|
||
|
p->m_arrIndex = i;
|
||
|
|
||
|
p->m_parent = parent;
|
||
|
|
||
|
// If parent was category, and this is not,
|
||
|
// then the depth stays the same.
|
||
|
if ( parent->GetParentingType() == 1 &&
|
||
|
p->GetParentingType() <= 0 )
|
||
|
p->m_depth = parent->m_depth;
|
||
|
else
|
||
|
p->m_depth = parent->m_depth + 1;
|
||
|
|
||
|
ITEM_ITERATION_LOOP_END
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//
|
||
|
// Disable categories
|
||
|
//
|
||
|
|
||
|
if ( IsInNonCatMode() )
|
||
|
return false;
|
||
|
|
||
|
// Create array, if necessary.
|
||
|
if ( !m_abcArray )
|
||
|
InitNonCatMode();
|
||
|
|
||
|
m_properties = m_abcArray;
|
||
|
|
||
|
// fix parents, indexes, and depths
|
||
|
ITEM_ITERATION_INIT_FROM_THE_TOP
|
||
|
|
||
|
//ITEM_ITERATION_DCAE_ISP_LOOP_BEGIN
|
||
|
ITEM_ITERATION_DCAE_LOOP_BEGIN
|
||
|
|
||
|
p->m_arrIndex = i;
|
||
|
|
||
|
p->m_parent = parent;
|
||
|
|
||
|
p->m_depth = parent->m_depth + 1;
|
||
|
|
||
|
//ITEM_ITERATION_DCAE_ISP_LOOP_END
|
||
|
ITEM_ITERATION_DCAE_LOOP_END
|
||
|
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
static int wxPG_SortFunc(void **p1, void **p2)
|
||
|
{
|
||
|
wxPGProperty *pp1 = *((wxPGProperty**)p1);
|
||
|
wxPGProperty *pp2 = *((wxPGProperty**)p2);
|
||
|
return pp1->GetLabel().compare( pp2->GetLabel() );
|
||
|
}
|
||
|
|
||
|
void wxPropertyGridState::Sort( wxPGProperty* p )
|
||
|
{
|
||
|
if ( !p )
|
||
|
p = (wxPGProperty*)m_properties;
|
||
|
|
||
|
wxCHECK_RET( p->GetParentingType() != 0,
|
||
|
wxT("cannot sort non-parenting property") );
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
// Can only sort items with children
|
||
|
if ( pwc->m_children.GetCount() < 1 )
|
||
|
return;
|
||
|
|
||
|
pwc->m_children.Sort( wxPG_SortFunc );
|
||
|
|
||
|
// Fix indexes
|
||
|
pwc->FixIndexesOfChildren();
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::Sort()
|
||
|
{
|
||
|
Sort( m_properties );
|
||
|
|
||
|
// Sort categories as well
|
||
|
if ( !IsInNonCatMode() )
|
||
|
{
|
||
|
size_t i;
|
||
|
for ( i=0;i<m_properties->GetCount();i++)
|
||
|
{
|
||
|
wxPGProperty* p = m_properties->Item(i);
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
Sort ( p );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::ExpandAll( unsigned char doExpand )
|
||
|
{
|
||
|
ITEM_ITERATION_DCAE_VARIABLES
|
||
|
|
||
|
bool isGrid = m_pPropGrid->GetState() == this;
|
||
|
|
||
|
if ( isGrid &&
|
||
|
m_selected &&
|
||
|
m_selected->GetParent() != m_properties )
|
||
|
{
|
||
|
if ( !m_pPropGrid->ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
if ( !doExpand )
|
||
|
{
|
||
|
if ( isGrid )
|
||
|
{
|
||
|
if ( !m_pPropGrid->ClearSelection() )
|
||
|
return false;
|
||
|
}
|
||
|
else m_selected = (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
ITEM_ITERATION_INIT_FROM_THE_TOP
|
||
|
|
||
|
ITEM_ITERATION_DCAE_LOOP_BEGIN
|
||
|
|
||
|
if ( parenting != 0 )
|
||
|
((wxPGPropertyWithChildren*)p)->m_expanded = doExpand;
|
||
|
|
||
|
ITEM_ITERATION_DCAE_LOOP_END
|
||
|
|
||
|
if ( m_pPropGrid->GetState() == this )
|
||
|
{
|
||
|
m_pPropGrid->CalculateYs((wxPGPropertyWithChildren*)NULL,-1);
|
||
|
|
||
|
m_pPropGrid->RedrawAllVisible();
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Used by SetSplitterLeft
|
||
|
int wxPropertyGridState::GetLeftSplitterPos(wxClientDC& dc,
|
||
|
wxPGPropertyWithChildren* pwc,
|
||
|
bool subProps)
|
||
|
{
|
||
|
wxPropertyGrid* pg = m_pPropGrid;
|
||
|
size_t i;
|
||
|
int maxW = 0;
|
||
|
int w, h;
|
||
|
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = pwc->Item(i);
|
||
|
if ( p->GetParentingType() <= 0 )
|
||
|
{
|
||
|
dc.GetTextExtent( p->GetLabel(), &w, &h );
|
||
|
|
||
|
w += pg->m_marginWidth + ( ((int)p->m_depth-1) * pg->m_subgroup_extramargin ) + (wxPG_XBEFORETEXT*2);
|
||
|
|
||
|
if ( w > maxW )
|
||
|
maxW = w;
|
||
|
}
|
||
|
|
||
|
if ( p->GetParentingType() &&
|
||
|
( subProps || p->GetParentingType() > 0 ) )
|
||
|
{
|
||
|
w = GetLeftSplitterPos( dc, (wxPGPropertyWithChildren*) p, subProps );
|
||
|
|
||
|
if ( w > maxW )
|
||
|
maxW = w;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return maxW;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState property value setting and getting
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::SetPropVal( wxPGProperty* p, const wxPGVariant& value )
|
||
|
{
|
||
|
p->DoSetValue(value);
|
||
|
if ( m_selected==p && this==m_pPropGrid->GetState() )
|
||
|
p->UpdateControl(m_pPropGrid->m_wndPrimary);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::ClearPropertyValue( wxPGProperty* p )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
const wxPGValueType* valueclass = p->GetValueTypePtr();
|
||
|
|
||
|
if ( valueclass != wxPG_VALUETYPE_PTR(none) )
|
||
|
{
|
||
|
// wnd_primary has to be given so the editor control can be updated as well.
|
||
|
SetPropVal(p,valueclass->GetDefaultValue());
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyValue( wxPGProperty* p,
|
||
|
const wxPGValueType* typeclass,
|
||
|
const wxPGVariant& value )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( p->GetValueTypePtr()->GetTypeName() == typeclass->GetTypeName() )
|
||
|
{
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(p);
|
||
|
|
||
|
SetPropVal(p,value);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
wxPGTypeOperationFailed ( p, typeclass->GetTypeName(), wxT("Set") );
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyValue( wxPGProperty* p, const wxChar* typestring, const wxPGVariant& value )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( wxStrcmp(p->GetValueTypePtr()->GetCustomTypeName(),typestring) == 0 )
|
||
|
{
|
||
|
// wnd_primary has to be given so the control can be updated as well.
|
||
|
|
||
|
SetPropVal(p,value);
|
||
|
return true;
|
||
|
}
|
||
|
wxPGTypeOperationFailed ( p, typestring, wxT("Set") );
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyValueString( wxPGProperty* p, const wxString& value )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
int flags = wxPG_REPORT_ERROR|wxPG_FULL_VALUE;
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(p);
|
||
|
|
||
|
if ( p->GetMaxLength() <= 0 )
|
||
|
p->SetValueFromString( value, flags );
|
||
|
else
|
||
|
p->SetValueFromString( value.Mid(0,p->GetMaxLength()), flags );
|
||
|
|
||
|
if ( m_selected==p && this==m_pPropGrid->GetState() )
|
||
|
p->UpdateControl(m_pPropGrid->m_wndPrimary);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyValue( wxPGProperty* p, wxVariant& value )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(p);
|
||
|
p->GetValueTypePtr()->SetValueFromVariant(p,value);
|
||
|
if ( m_selected==p && this==m_pPropGrid->GetState() )
|
||
|
p->UpdateControl(m_pPropGrid->m_wndPrimary);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyValueWxObjectPtr( wxPGProperty* p, wxObject* value )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( wxStrcmp( p->GetValueTypePtr()->GetTypeName(),
|
||
|
value->GetClassInfo()->GetClassName()
|
||
|
) == 0
|
||
|
)
|
||
|
{
|
||
|
CLEAR_PROPERTY_UNSPECIFIED_FLAG(p);
|
||
|
// wnd_primary has to be given so the control can be updated as well.
|
||
|
SetPropVal(p,wxPGVariantFromWxObject(value));
|
||
|
return true;
|
||
|
}
|
||
|
wxPGTypeOperationFailed ( p, wxT("wxObject"), wxT("Set") );
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::SetPropertyUnspecified( wxPGProperty* p )
|
||
|
{
|
||
|
wxCHECK_RET( p, wxT("invalid property id") );
|
||
|
|
||
|
if ( !(p->m_flags & wxPG_PROP_UNSPECIFIED) )
|
||
|
{
|
||
|
// Flag should be set first - editor class methods may need it
|
||
|
p->m_flags |= wxPG_PROP_UNSPECIFIED;
|
||
|
|
||
|
wxASSERT( m_pPropGrid );
|
||
|
|
||
|
if ( m_pPropGrid->GetState() == this )
|
||
|
{
|
||
|
if ( m_pPropGrid->m_selected == p && m_pPropGrid->m_wndPrimary )
|
||
|
{
|
||
|
p->GetEditorClass()->SetValueToUnspecified(m_pPropGrid->m_wndPrimary);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( p->GetParentingType() != 0 )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
SetPropertyUnspecified( pwc->Item(i) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState property operations
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::LimitPropertyEditing( wxPGProperty* p, bool limit )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( limit )
|
||
|
p->m_flags |= wxPG_PROP_NOEDITOR;
|
||
|
else
|
||
|
p->m_flags &= ~(wxPG_PROP_NOEDITOR);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::ClearModifiedStatus( wxPGProperty* p )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
if ( p->m_flags & wxPG_PROP_MODIFIED )
|
||
|
{
|
||
|
p->m_flags &= ~(wxPG_PROP_MODIFIED);
|
||
|
|
||
|
if ( m_pPropGrid->GetState() == this )
|
||
|
{
|
||
|
// Clear active editor bold
|
||
|
if ( p == m_selected && m_pPropGrid->m_wndPrimary )
|
||
|
m_pPropGrid->m_wndPrimary->SetFont( m_pPropGrid->GetFont() );
|
||
|
|
||
|
m_pPropGrid->DrawItem( p );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( pwc->GetParentingType() != 0 )
|
||
|
{
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
ClearModifiedStatus( pwc->Item(i) );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::Collapse( wxPGProperty* p )
|
||
|
{
|
||
|
wxCHECK_MSG( p, false, wxT("invalid property id") );
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->GetParentingType() == 0 ) return false;
|
||
|
|
||
|
if ( !pwc->m_expanded ) return false;
|
||
|
|
||
|
// m_expanded must be set just before call to CalculateYs
|
||
|
pwc->m_expanded = 0;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::Expand( wxPGProperty* p )
|
||
|
{
|
||
|
wxCHECK_MSG( p, false, wxT("invalid property id") );
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
if ( pwc->GetParentingType() == 0 ) return false;
|
||
|
|
||
|
if ( pwc->m_expanded ) return false;
|
||
|
|
||
|
// m_expanded must be set just before call to CalculateYs
|
||
|
pwc->m_expanded = 1;
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::DoSelectProperty( wxPGProperty* p, unsigned int flags )
|
||
|
{
|
||
|
if ( this == m_pPropGrid->GetState() )
|
||
|
return m_pPropGrid->DoSelectProperty( p, flags );
|
||
|
|
||
|
m_selected = p;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::SetPropertyLabel( wxPGProperty* p, const wxString& newlabel )
|
||
|
{
|
||
|
wxCHECK_RET(p, wxT("invalid property id"));
|
||
|
p->SetLabel(newlabel);
|
||
|
if ( m_pPropGrid->GetWindowStyleFlag() & wxPG_AUTO_SORT )
|
||
|
Sort(p->GetParent());
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::SetPropertyPriority( wxPGProperty* p, int priority )
|
||
|
{
|
||
|
int parenting = p->GetParentingType();
|
||
|
|
||
|
if ( priority == wxPG_HIGH ) p->ClearFlag( wxPG_PROP_HIDEABLE );
|
||
|
else p->SetFlag( wxPG_PROP_HIDEABLE );
|
||
|
|
||
|
if ( parenting != 0 )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
SetPropertyPriority(pwc->Item(i),priority);
|
||
|
}
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::SetPropertyAndChildrenFlags( wxPGProperty* p, long flags )
|
||
|
{
|
||
|
p->m_flags |= flags;
|
||
|
|
||
|
if ( p->GetParentingType() != 0 )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
ClearPropertyAndChildrenFlags ( pwc->Item(i), flags );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::ClearPropertyAndChildrenFlags( wxPGProperty* p, long flags )
|
||
|
{
|
||
|
p->m_flags &= ~(flags);
|
||
|
|
||
|
if ( p->GetParentingType() != 0 )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
ClearPropertyAndChildrenFlags ( pwc->Item(i), flags );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridState::EnableProperty( wxPGProperty* p, bool enable )
|
||
|
{
|
||
|
if ( p )
|
||
|
{
|
||
|
if ( enable )
|
||
|
{
|
||
|
if ( !(p->m_flags & wxPG_PROP_DISABLED) )
|
||
|
return false;
|
||
|
|
||
|
// Enabling
|
||
|
|
||
|
p->m_flags &= ~(wxPG_PROP_DISABLED);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if ( p->m_flags & wxPG_PROP_DISABLED )
|
||
|
return false;
|
||
|
|
||
|
// Disabling
|
||
|
|
||
|
p->m_flags |= wxPG_PROP_DISABLED;
|
||
|
|
||
|
}
|
||
|
|
||
|
if ( p->GetParentingType() == 0 )
|
||
|
return true;
|
||
|
|
||
|
// Apply same to sub-properties as well
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)p;
|
||
|
|
||
|
size_t i;
|
||
|
for ( i = 0; i < pwc->GetCount(); i++ )
|
||
|
EnableProperty ( pwc->Item(i), enable );
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState wxVariant related routines
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Returns list of wxVariant objects (non-categories and non-sub-properties only).
|
||
|
// Never includes sub-properties (unless they are parented by wxParentProperty).
|
||
|
wxVariant wxPropertyGridState::GetPropertyValues( const wxString& listname,
|
||
|
wxPGId baseparent,
|
||
|
long flags ) const
|
||
|
{
|
||
|
ITEM_ITERATION_DCAE_VARIABLES
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)wxPGIdToPtr(baseparent);
|
||
|
|
||
|
// Root is the default base-parent.
|
||
|
if ( !pwc )
|
||
|
pwc = m_properties;
|
||
|
|
||
|
wxVariantList temp_list;
|
||
|
wxVariant v( temp_list, listname );
|
||
|
|
||
|
if ( flags & wxPG_KEEP_STRUCTURE )
|
||
|
{
|
||
|
wxASSERT( (pwc->GetParentingType() < -1) || (pwc->GetParentingType() > 0) );
|
||
|
|
||
|
size_t i;
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = pwc->Item(i);
|
||
|
int parenting = p->GetParentingType();
|
||
|
if ( parenting == 0 || parenting == -1 )
|
||
|
{
|
||
|
v.Append( p->GetValueAsVariant() );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
v.Append( GetPropertyValues(p->m_name,wxPGIdGen(p),wxPG_KEEP_STRUCTURE) );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
ITEM_ITERATION_INIT((wxPGPropertyWithChildren*)wxPGIdToPtr(baseparent),0)
|
||
|
ITEM_ITERATION_DCAE_ISP_LOOP_BEGIN
|
||
|
|
||
|
// Use a trick to ignore wxParentProperty itself, but not its sub-properties.
|
||
|
if ( parenting == PT_CUSTOMPROPERTY )
|
||
|
{
|
||
|
parenting = PT_CAPTION;
|
||
|
}
|
||
|
else if ( parenting <= 0 )
|
||
|
{
|
||
|
v.Append ( p->GetValueAsVariant() );
|
||
|
}
|
||
|
|
||
|
ITEM_ITERATION_DCAE_ISP_LOOP_END
|
||
|
}
|
||
|
|
||
|
return v;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::SetPropertyValues( const wxVariantList& list, wxPGId default_category )
|
||
|
{
|
||
|
|
||
|
unsigned char origFrozen = 1;
|
||
|
|
||
|
if ( m_pPropGrid->GetState() == this )
|
||
|
{
|
||
|
origFrozen = m_pPropGrid->m_frozen;
|
||
|
if ( !origFrozen ) m_pPropGrid->Freeze();
|
||
|
}
|
||
|
|
||
|
wxPropertyCategoryClass* use_category = (wxPropertyCategoryClass*)wxPGIdToPtr(default_category);
|
||
|
|
||
|
if ( !use_category )
|
||
|
use_category = (wxPropertyCategoryClass*)m_properties;
|
||
|
|
||
|
// Let's iterate over the list of variants.
|
||
|
wxVariantList::const_iterator node;
|
||
|
|
||
|
//for ( wxVariantList::Node *node = list.GetFirst(); node; node = node->GetNext() )
|
||
|
for ( node = list.begin(); node != list.end(); node++ )
|
||
|
{
|
||
|
wxVariant *current = (wxVariant*)*node;
|
||
|
|
||
|
// Make sure it is wxVariant.
|
||
|
wxASSERT( current );
|
||
|
wxASSERT( wxStrcmp(current->GetClassInfo()->GetClassName(),wxT("wxVariant")) == 0 );
|
||
|
|
||
|
if ( current->GetName().length() > 0 )
|
||
|
{
|
||
|
wxPGId foundProp = BaseGetPropertyByName(current->GetName());
|
||
|
if ( wxPGIdIsOk(foundProp) )
|
||
|
{
|
||
|
wxPGProperty* p = wxPGIdToPtr(foundProp);
|
||
|
|
||
|
const wxPGValueType* vtype = p->GetValueTypePtr();
|
||
|
|
||
|
// If it was a list, we still have to go through it.
|
||
|
if ( current->GetType() == wxT("list") )
|
||
|
{
|
||
|
SetPropertyValues( current->GetList(),
|
||
|
wxPGIdGen(
|
||
|
p->GetParentingType()>0?p:((wxPGProperty*)NULL)
|
||
|
) );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
#ifdef __WXDEBUG__
|
||
|
if ( current->GetType() != vtype->GetTypeName() &&
|
||
|
current->GetType() != vtype->GetCustomTypeName() )
|
||
|
{
|
||
|
wxLogDebug(wxT("wxPropertyGridState::SetPropertyValues Warning: Setting value of property \"%s\" from variant"),
|
||
|
p->m_name.c_str());
|
||
|
wxLogDebug(wxT(" but variant's type name (%s) doesn't match either base type name (%s) nor custom type name (%s)."),
|
||
|
#ifndef __WXPYTHON__
|
||
|
current->GetType().c_str(),vtype->GetTypeName(),vtype->GetCustomTypeName());
|
||
|
#else
|
||
|
current->GetType().c_str(),vtype->GetTypeName().c_str(),vtype->GetCustomTypeName().c_str());
|
||
|
#endif
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
vtype->SetValueFromVariant(p,*current);
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Is it list?
|
||
|
if ( current->GetType() != wxT("list") )
|
||
|
{
|
||
|
// Not.
|
||
|
AppendIn(use_category,current->GetName(),wxPG_LABEL,(wxVariant&)*current);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Yes, it is; create a sub category and append contents there.
|
||
|
wxPGId newCat = DoInsert(use_category,-1,new wxPropertyCategoryClass(current->GetName(),wxPG_LABEL));
|
||
|
SetPropertyValues( current->GetList(), newCat );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !origFrozen )
|
||
|
{
|
||
|
m_pPropGrid->Thaw();
|
||
|
|
||
|
if ( this == m_pPropGrid->GetState() )
|
||
|
{
|
||
|
m_selected->UpdateControl(m_pPropGrid->m_wndPrimary);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState property adding and removal
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Call for after sub-properties added with AddChild
|
||
|
void wxPGPropertyWithChildren::PrepareSubProperties()
|
||
|
{
|
||
|
// TODO: When in 1.0.5, move extra stuff from AddChild to here.
|
||
|
wxPropertyGridState* state = GetParentState();
|
||
|
|
||
|
wxASSERT(state);
|
||
|
|
||
|
if ( !GetCount() )
|
||
|
return;
|
||
|
|
||
|
wxByte depth = m_depth + 1;
|
||
|
wxByte depthBgCol = m_depthBgCol;
|
||
|
|
||
|
wxByte inheritFlags = m_flags & wxPG_INHERITED_PROPFLAGS;
|
||
|
|
||
|
wxByte bgColIndex = m_bgColIndex;
|
||
|
wxByte fgColIndex = m_fgColIndex;
|
||
|
|
||
|
//
|
||
|
// Set some values to the children
|
||
|
//
|
||
|
size_t i = 0;
|
||
|
wxPGPropertyWithChildren* nparent = this;
|
||
|
|
||
|
while ( i < nparent->GetCount() )
|
||
|
{
|
||
|
wxPGProperty* np = nparent->Item(i);
|
||
|
|
||
|
np->m_flags |= inheritFlags; // Hideable also if parent.
|
||
|
np->m_depth = depth;
|
||
|
np->m_depthBgCol = depthBgCol;
|
||
|
np->m_bgColIndex = bgColIndex;
|
||
|
np->m_fgColIndex = fgColIndex;
|
||
|
|
||
|
// Also handle children of children
|
||
|
if ( np->GetParentingType() != 0 &&
|
||
|
((wxPGPropertyWithChildren*)np)->GetCount() > 0 )
|
||
|
{
|
||
|
nparent = (wxPGPropertyWithChildren*) np;
|
||
|
i = 0;
|
||
|
|
||
|
// Init
|
||
|
nparent->m_expanded = 0;
|
||
|
nparent->m_parentState = state;
|
||
|
depth++;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Next sibling
|
||
|
i++;
|
||
|
}
|
||
|
|
||
|
// After reaching last sibling, go back to processing
|
||
|
// siblings of the parent
|
||
|
while ( i >= nparent->GetCount() )
|
||
|
{
|
||
|
// Exit the loop when top parent hit
|
||
|
if ( nparent == this )
|
||
|
break;
|
||
|
|
||
|
depth--;
|
||
|
|
||
|
i = nparent->GetArrIndex() + 1;
|
||
|
nparent = nparent->GetParent();
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
// Call after fixed sub-properties added/removed after creation.
|
||
|
// if oldSelInd >= 0 and < new max items, then selection is
|
||
|
// moved to it. Note: oldSelInd -2 indicates that this property
|
||
|
// should be selected.
|
||
|
void wxPGPropertyWithChildren::SubPropsChanged( int oldSelInd )
|
||
|
{
|
||
|
wxPropertyGridState* state = GetParentState();
|
||
|
wxPropertyGrid* grid = state->GetGrid();
|
||
|
|
||
|
PrepareSubProperties();
|
||
|
|
||
|
wxPGProperty* sel = (wxPGProperty*) NULL;
|
||
|
if ( oldSelInd >= (int)m_children.GetCount() )
|
||
|
oldSelInd = (int)m_children.GetCount() - 1;
|
||
|
|
||
|
if ( oldSelInd >= 0 )
|
||
|
sel = (wxPGProperty*) m_children[oldSelInd];
|
||
|
else if ( oldSelInd == -2 )
|
||
|
sel = this;
|
||
|
|
||
|
if ( sel )
|
||
|
state->DoSelectProperty(sel);
|
||
|
|
||
|
if ( state == grid->GetState() )
|
||
|
{
|
||
|
if ( m_expanded )
|
||
|
grid->CalculateYs( GetParent(), m_arrIndex );
|
||
|
grid->Refresh();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
int wxPropertyGridState::PrepareToAddItem( wxPGProperty* property,
|
||
|
wxPGPropertyWithChildren* scheduledParent )
|
||
|
{
|
||
|
wxPropertyGrid* propGrid = m_pPropGrid;
|
||
|
wxASSERT( propGrid );
|
||
|
|
||
|
int parenting = property->GetParentingType();
|
||
|
|
||
|
// This will allow better behaviour.
|
||
|
if ( scheduledParent == m_properties )
|
||
|
scheduledParent = (wxPGPropertyWithChildren*) NULL;
|
||
|
|
||
|
if ( parenting > 0 )
|
||
|
{
|
||
|
/*
|
||
|
if ( scheduledParent )
|
||
|
wxLogDebug(wxT("scheduledParent= %s, %i"),
|
||
|
scheduledParent->GetName().c_str(), (int)scheduledParent->GetParentingType());
|
||
|
*/
|
||
|
|
||
|
// Parent of a category must be either root or another category
|
||
|
// (otherwise Bad Things might happen).
|
||
|
wxASSERT_MSG( scheduledParent == (wxPGPropertyWithChildren*) NULL ||
|
||
|
scheduledParent == m_properties ||
|
||
|
scheduledParent->GetParentingType() > 0,
|
||
|
wxT("Parent of a category must be either root or another category."));
|
||
|
|
||
|
/*
|
||
|
wxASSERT_MSG( m_properties == &m_regularArray,
|
||
|
wxT("Do not add categories in non-categoric mode!"));
|
||
|
*/
|
||
|
|
||
|
// If we already have category with same name, delete given property
|
||
|
// and use it instead as most recent caption item.
|
||
|
wxPGId found_id = BaseGetPropertyByName( property->GetName() );
|
||
|
if ( wxPGIdIsOk(found_id) )
|
||
|
{
|
||
|
wxPropertyCategoryClass* pwc = (wxPropertyCategoryClass*)wxPGIdToPtr(found_id);
|
||
|
if ( pwc->GetParentingType() > 0 ) // Must be a category.
|
||
|
{
|
||
|
delete property;
|
||
|
m_currentCategory = pwc;
|
||
|
return 2; // Tells the caller what we did.
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#ifdef __WXDEBUG__
|
||
|
// Warn for identical names in debug mode.
|
||
|
if ( property->GetName().length() &&
|
||
|
wxPGIdIsOk(BaseGetPropertyByName(property->GetName())) &&
|
||
|
(!scheduledParent || scheduledParent->GetParentingType() >= 1) )
|
||
|
wxLogError(wxT("wxPropertyGrid: Warning - item with name \"%s\" already exists."),
|
||
|
property->GetName().c_str());
|
||
|
#endif
|
||
|
|
||
|
// Make sure nothing is selected.
|
||
|
if ( propGrid && propGrid->m_selected )
|
||
|
{
|
||
|
bool selRes = propGrid->ClearSelection();
|
||
|
wxPG_CHECK_MSG_DBG( selRes,
|
||
|
-1,
|
||
|
wxT("failed to deselect a property (editor probably had invalid value)") );
|
||
|
}
|
||
|
|
||
|
property->m_y = -1;
|
||
|
|
||
|
if ( scheduledParent )
|
||
|
{
|
||
|
// Use parent's colours.
|
||
|
property->m_bgColIndex = scheduledParent->m_bgColIndex;
|
||
|
property->m_fgColIndex = scheduledParent->m_fgColIndex;
|
||
|
}
|
||
|
|
||
|
// If in hideable adding mode, or if assigned parent is hideable, then
|
||
|
// make this one hideable.
|
||
|
if (
|
||
|
( scheduledParent && (scheduledParent->m_flags & wxPG_PROP_HIDEABLE) ) ||
|
||
|
( propGrid && (propGrid->m_iFlags & wxPG_FL_ADDING_HIDEABLES) )
|
||
|
)
|
||
|
property->SetFlag ( wxPG_PROP_HIDEABLE );
|
||
|
|
||
|
// Set custom image flag.
|
||
|
int custImgHeight = property->GetImageSize().y;
|
||
|
if ( custImgHeight < 0 /*|| custImgHeight > 1*/ )
|
||
|
{
|
||
|
property->m_flags |= wxPG_PROP_CUSTOMIMAGE;
|
||
|
}
|
||
|
|
||
|
if ( propGrid->GetWindowStyleFlag() & wxPG_LIMITED_EDITING )
|
||
|
property->m_flags |= wxPG_PROP_NOEDITOR;
|
||
|
|
||
|
if ( parenting < 1 )
|
||
|
{
|
||
|
// This is not a category.
|
||
|
|
||
|
wxASSERT_MSG( property->GetEditorClass(), wxT("Editor class not initialized!") );
|
||
|
|
||
|
// Depth.
|
||
|
//
|
||
|
unsigned char depth = 1;
|
||
|
if ( scheduledParent )
|
||
|
{
|
||
|
depth = scheduledParent->m_depth;
|
||
|
if ( scheduledParent->GetParentingType() != PT_CAPTION )
|
||
|
depth++;
|
||
|
}
|
||
|
property->m_depth = depth;
|
||
|
unsigned char greyDepth = depth;
|
||
|
|
||
|
if ( scheduledParent )
|
||
|
{
|
||
|
wxPropertyCategoryClass* pc;
|
||
|
|
||
|
if ( scheduledParent->GetParentingType() >= PT_CAPTION )
|
||
|
pc = (wxPropertyCategoryClass*)scheduledParent;
|
||
|
else
|
||
|
// This conditional compile is necessary to
|
||
|
// bypass some compiler bug.
|
||
|
pc = wxPropertyGrid::_GetPropertyCategory(scheduledParent);
|
||
|
|
||
|
if ( pc )
|
||
|
greyDepth = pc->GetDepth();
|
||
|
else
|
||
|
greyDepth = scheduledParent->m_depthBgCol;
|
||
|
}
|
||
|
|
||
|
property->m_depthBgCol = greyDepth;
|
||
|
|
||
|
// Add children to propertywithchildren.
|
||
|
if ( parenting < PT_NONE )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)property;
|
||
|
|
||
|
pwc->m_parentState = this;
|
||
|
|
||
|
pwc->m_expanded = 0; // Properties with children are not expanded by default.
|
||
|
if ( propGrid && propGrid->GetWindowStyleFlag() & wxPG_HIDE_MARGIN )
|
||
|
pwc->m_expanded = 1; // ...unless it cannot not be expanded.
|
||
|
|
||
|
if ( pwc->GetCount() )
|
||
|
{
|
||
|
pwc->PrepareSubProperties();
|
||
|
}
|
||
|
|
||
|
//
|
||
|
// If children were added prior to append, then this is considered
|
||
|
// a "fixed" parent (otherwise the PT_CUSTOMPROPERTY is set, see below,
|
||
|
// to mark it as customizable).
|
||
|
/*if ( pwc->GetCount() )
|
||
|
{
|
||
|
pwc->PrepareSubProperties();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pwc->m_parentingType = PT_CUSTOMPROPERTY;
|
||
|
}*/
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// This is a category.
|
||
|
|
||
|
// depth
|
||
|
unsigned char depth = 1;
|
||
|
if ( scheduledParent )
|
||
|
{
|
||
|
depth = scheduledParent->m_depth + 1;
|
||
|
}
|
||
|
property->m_depth = depth;
|
||
|
property->m_depthBgCol = depth;
|
||
|
|
||
|
m_currentCategory = (wxPropertyCategoryClass*)property;
|
||
|
|
||
|
wxPropertyCategoryClass* pc = (wxPropertyCategoryClass*)property;
|
||
|
pc->m_parentState = this;
|
||
|
|
||
|
// Calculate text extent for caption item.
|
||
|
pc->CalculateTextExtent(propGrid,propGrid->GetCaptionFont());
|
||
|
}
|
||
|
|
||
|
return parenting;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::BeginAddChildren( wxPGId id )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*) wxPGIdToPtr(id);
|
||
|
wxCHECK_RET( pwc, wxT("NULL property") );
|
||
|
wxCHECK_RET( pwc->GetParentingType() == PT_FIXEDCHILDREN, wxT("only call on properties with fixed children") );
|
||
|
pwc->m_parentingType = PT_CUSTOMPROPERTY;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyContainerMethods::EndAddChildren( wxPGId id )
|
||
|
{
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*) wxPGIdToPtr(id);
|
||
|
wxCHECK_RET( pwc, wxT("NULL property") );
|
||
|
wxCHECK_RET( pwc->GetParentingType() == PT_CUSTOMPROPERTY, wxT("only call on properties for which BeginAddChildren was called prior") );
|
||
|
pwc->m_parentingType = PT_FIXEDCHILDREN;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::Append( wxPGProperty* property )
|
||
|
{
|
||
|
wxPropertyCategoryClass* cur_cat = m_currentCategory;
|
||
|
if ( property->GetParentingType() > 0 )
|
||
|
cur_cat = (wxPropertyCategoryClass*) NULL;
|
||
|
|
||
|
return DoInsert( cur_cat, -1, property );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::DoInsert( wxPGPropertyWithChildren* parent, int index, wxPGProperty* property )
|
||
|
{
|
||
|
if ( !parent )
|
||
|
parent = m_properties;
|
||
|
|
||
|
wxPropertyGrid* propGrid = m_pPropGrid;
|
||
|
|
||
|
wxCHECK_MSG( parent->GetParentingType() != PT_NONE,
|
||
|
wxNullProperty,
|
||
|
wxT("this parent cannot accomodate children") );
|
||
|
|
||
|
wxCHECK_MSG( parent->GetParentingType() != PT_FIXEDCHILDREN,
|
||
|
wxNullProperty,
|
||
|
wxT("when adding properties to fixed parents, use BeginAddChildren and EndAddChildren.") );
|
||
|
|
||
|
int parenting = PrepareToAddItem( property, (wxPropertyCategoryClass*)parent );
|
||
|
|
||
|
// This type of invalid parenting value indicates we should exit now, returning
|
||
|
// id of most recent category.
|
||
|
if ( parenting > PT_CAPTION )
|
||
|
return wxPGIdGen(m_currentCategory);
|
||
|
|
||
|
// Note that item must be added into current mode later.
|
||
|
|
||
|
// If parent is wxParentProperty, just stick it in...
|
||
|
// If parent is root (m_properties), then...
|
||
|
// In categoric mode: Add as last item in m_abcArray (if not category).
|
||
|
// Add to given index in m_regularArray.
|
||
|
// In non-cat mode: Add as last item in m_regularArray.
|
||
|
// Add to given index in m_abcArray.
|
||
|
// If parent is category, then...
|
||
|
// 1) Add to given category in given index.
|
||
|
// 2) Add as last item in m_abcArray.
|
||
|
|
||
|
int parents_parenting = parent->GetParentingType();
|
||
|
if ( parents_parenting < 0 )
|
||
|
{
|
||
|
// Parent is wxParentingProperty: Just stick it in...
|
||
|
parent->AddChild2( property, index );
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Parent is Category or Root.
|
||
|
|
||
|
if ( m_properties == &m_regularArray )
|
||
|
{
|
||
|
// Categorized mode
|
||
|
|
||
|
// Only add non-categories to m_abcArray.
|
||
|
if ( m_abcArray && parenting <= 0 )
|
||
|
m_abcArray->AddChild2( property, -1, false );
|
||
|
|
||
|
// Add to current mode.
|
||
|
parent->AddChild2( property, index );
|
||
|
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// Non-categorized mode.
|
||
|
|
||
|
if ( parent != m_properties )
|
||
|
// Parent is category.
|
||
|
parent->AddChild2( property, index, false );
|
||
|
else
|
||
|
// Parent is root.
|
||
|
m_regularArray.AddChild2( property, -1, false );
|
||
|
|
||
|
// Add to current mode (no categories).
|
||
|
if ( parenting <= 0 )
|
||
|
m_abcArray->AddChild2( property, index );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// category stuff
|
||
|
if ( parenting > PT_NONE )
|
||
|
{
|
||
|
// This is a category caption item.
|
||
|
|
||
|
// Last caption is not the bottom one (this info required by append)
|
||
|
m_lastCaptionBottomnest = 0;
|
||
|
}
|
||
|
|
||
|
// Only add name to hashmap if parent is root or category
|
||
|
if ( parent->GetParentingType() >= PT_CAPTION && property->m_name.length() )
|
||
|
m_dictName[property->m_name] = (void*) property;
|
||
|
|
||
|
m_itemsAdded = 1;
|
||
|
|
||
|
if ( propGrid )
|
||
|
propGrid->m_bottomy = 0; // this signals y recalculation
|
||
|
|
||
|
return wxPGIdGen(property);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridState::AppendIn( wxPGPropertyWithChildren* pwc,
|
||
|
const wxString& label,
|
||
|
const wxString& propname,
|
||
|
wxVariant& value )
|
||
|
{
|
||
|
wxPGProperty* p = wxPropertyContainerMethods::
|
||
|
CreatePropertyByType(value.GetType(),label,propname);
|
||
|
|
||
|
if ( p )
|
||
|
{
|
||
|
p->GetValueTypePtr()->SetValueFromVariant(p,value);
|
||
|
return DoInsert(pwc,-1,p);
|
||
|
}
|
||
|
return wxPGIdGen((wxPGProperty*)NULL);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::DoDelete( wxPGProperty* item )
|
||
|
{
|
||
|
wxCHECK_RET( item != &m_regularArray && item != m_abcArray,
|
||
|
wxT("wxPropertyGrid: Do not attempt to remove the root item.") );
|
||
|
|
||
|
size_t i;
|
||
|
int parenting = item->GetParentingType();
|
||
|
unsigned int indinparent = item->GetIndexInParent();
|
||
|
|
||
|
wxPGPropertyWithChildren* pwc = (wxPGPropertyWithChildren*)item;
|
||
|
|
||
|
wxCHECK_RET( item->GetParent()->GetParentingType() != -1,
|
||
|
wxT("wxPropertyGrid: Do not attempt to remove sub-properties.") );
|
||
|
|
||
|
if ( parenting > 0 )
|
||
|
{
|
||
|
// deleting a category
|
||
|
|
||
|
// erase category entries from the hash table
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* sp = pwc->Item( i );
|
||
|
if ( sp->GetName().Len() ) m_dictName.erase( wxPGNameConv(sp->GetName()) );
|
||
|
}
|
||
|
|
||
|
if ( pwc == m_currentCategory )
|
||
|
m_currentCategory = (wxPropertyCategoryClass*) NULL;
|
||
|
|
||
|
if ( m_abcArray )
|
||
|
{
|
||
|
// Remove children from non-categorized array.
|
||
|
for ( i=0; i<pwc->GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty * p = pwc->Item( i );
|
||
|
wxASSERT( p != NULL );
|
||
|
if ( p->GetParentingType() <= PT_NONE )
|
||
|
m_abcArray->m_children.Remove( (void*)p );
|
||
|
}
|
||
|
|
||
|
if ( IsInNonCatMode() )
|
||
|
m_abcArray->FixIndexesOfChildren();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( !IsInNonCatMode() )
|
||
|
{
|
||
|
// categorized mode - non-categorized array
|
||
|
|
||
|
// Remove from non-cat array, but only if parent is in it
|
||
|
if ( parenting <= 0 && item->GetParent()->GetParentingType() == PT_CAPTION )
|
||
|
{
|
||
|
if ( m_abcArray )
|
||
|
{
|
||
|
m_abcArray->m_children.Remove( item );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// categorized mode - categorized array
|
||
|
item->m_parent->m_children.RemoveAt(indinparent);
|
||
|
item->m_parent->FixIndexesOfChildren(/*indinparent*/);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// non-categorized mode - categorized array
|
||
|
|
||
|
// We need to find location of item.
|
||
|
wxPGPropertyWithChildren* cat_parent = &m_regularArray;
|
||
|
int cat_index = m_regularArray.GetCount();
|
||
|
size_t i;
|
||
|
for ( i = 0; i < m_regularArray.GetCount(); i++ )
|
||
|
{
|
||
|
wxPGProperty* p = m_regularArray.Item(i);
|
||
|
if ( p == item ) { cat_index = i; break; }
|
||
|
if ( p->GetParentingType() > 0 )
|
||
|
{
|
||
|
int subind = ((wxPGPropertyWithChildren*)p)->Index(item);
|
||
|
if ( subind != wxNOT_FOUND )
|
||
|
{
|
||
|
cat_parent = ((wxPGPropertyWithChildren*)p);
|
||
|
cat_index = subind;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
cat_parent->m_children.RemoveAt(cat_index);
|
||
|
|
||
|
// non-categorized mode - non-categorized array
|
||
|
if ( parenting <= 0 )
|
||
|
{
|
||
|
wxASSERT( item->m_parent == m_abcArray );
|
||
|
item->m_parent->m_children.RemoveAt(indinparent);
|
||
|
item->m_parent->FixIndexesOfChildren(indinparent);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( item->GetName().Len() ) m_dictName.erase( wxPGNameConv(item->GetName()) );
|
||
|
|
||
|
#ifdef __WXPYTHON__
|
||
|
// For some reason, Py_DECREF always crashes, even though we make
|
||
|
// matching Py_INCREF call in propgrid_cbacks.cpp. Maybe refcount is decremented
|
||
|
// somewhere automatically? Unlikely though...
|
||
|
//if ( item->m_scriptObject )
|
||
|
// Py_DECREF( item->m_scriptObject );
|
||
|
#endif
|
||
|
|
||
|
// We can actually delete it now
|
||
|
delete item;
|
||
|
|
||
|
m_itemsAdded = 1; // Not a logical assignment (but required nonetheless).
|
||
|
|
||
|
if ( this == m_pPropGrid->GetState() )
|
||
|
{
|
||
|
//m_pPropGrid->m_clearThisMany = 1;
|
||
|
m_pPropGrid->m_bottomy = 0; // this signals y recalculation
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridState init etc.
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::InitNonCatMode()
|
||
|
{
|
||
|
ITEM_ITERATION_DCAE_VARIABLES
|
||
|
|
||
|
if ( !m_abcArray )
|
||
|
{
|
||
|
m_abcArray = new wxPGRootPropertyClass();
|
||
|
m_abcArray->SetParentState(this);
|
||
|
m_abcArray->m_expanded = wxPG_EXP_OF_COPYARRAY;
|
||
|
}
|
||
|
|
||
|
// Must be called when FROM_STATE(m_properties) still points to regularArray.
|
||
|
wxPGPropertyWithChildren* oldProperties = m_properties;
|
||
|
|
||
|
// Must use temp value in FROM_STATE(m_properties) for item iteration loop
|
||
|
// to run as expected.
|
||
|
m_properties = &m_regularArray;
|
||
|
|
||
|
// Copy items.
|
||
|
ITEM_ITERATION_INIT_FROM_THE_TOP
|
||
|
|
||
|
ITEM_ITERATION_DCAE_ISP_LOOP_BEGIN
|
||
|
|
||
|
if ( parenting < 1 &&
|
||
|
( parent == m_properties || parent->GetParentingType() > 0 ) )
|
||
|
{
|
||
|
|
||
|
m_abcArray->AddChild2 ( p );
|
||
|
p->m_parent = &FROM_STATE(m_regularArray);
|
||
|
}
|
||
|
//else wxLogDebug("OUT: %s",p->m_label.c_str());
|
||
|
|
||
|
ITEM_ITERATION_DCAE_ISP_LOOP_END
|
||
|
|
||
|
m_properties = oldProperties;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridState::Clear()
|
||
|
{
|
||
|
m_regularArray.Empty();
|
||
|
if ( m_abcArray )
|
||
|
m_abcArray->Empty();
|
||
|
|
||
|
m_dictName.clear();
|
||
|
|
||
|
m_currentCategory = (wxPropertyCategoryClass*) NULL;
|
||
|
m_lastCaptionBottomnest = 1;
|
||
|
m_itemsAdded = 0;
|
||
|
|
||
|
m_selected = (wxPGProperty*) NULL;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridState::wxPropertyGridState()
|
||
|
{
|
||
|
m_pPropGrid = (wxPropertyGrid*) NULL;
|
||
|
m_regularArray.SetParentState(this);
|
||
|
m_properties = &m_regularArray;
|
||
|
m_abcArray = (wxPGRootPropertyClass*) NULL;
|
||
|
m_currentCategory = (wxPropertyCategoryClass*) NULL;
|
||
|
m_selected = (wxPGProperty*) NULL;
|
||
|
m_lastCaptionBottomnest = 1;
|
||
|
m_itemsAdded = 0;
|
||
|
m_anyModified = 0;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridState::~wxPropertyGridState()
|
||
|
{
|
||
|
delete m_abcArray;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
// wxPropertyGridPopulator
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridPopulator::Init( wxPropertyGrid* pg, wxPGId popRoot )
|
||
|
{
|
||
|
WX_PG_GLOBALS_LOCKER()
|
||
|
|
||
|
m_propGrid = pg;
|
||
|
m_popRoot = popRoot;
|
||
|
wxPGGlobalVars->m_offline++;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPropertyGridPopulator::~wxPropertyGridPopulator()
|
||
|
{
|
||
|
|
||
|
//
|
||
|
// Free unused sets of choices
|
||
|
wxPGHashMapP2P::iterator it;
|
||
|
|
||
|
for( it = m_dictIdChoices.begin(); it != m_dictIdChoices.end(); ++it )
|
||
|
{
|
||
|
wxPGChoicesData* data = (wxPGChoicesData*) it->second;
|
||
|
data->m_refCount--;
|
||
|
if ( data->m_refCount < 1 )
|
||
|
delete data;
|
||
|
}
|
||
|
|
||
|
wxPGGlobalVars->m_offline--;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridPopulator::HasChoices( wxPGChoicesId id ) const
|
||
|
{
|
||
|
wxPGHashMapP2P::const_iterator it = m_dictIdChoices.find(id);
|
||
|
return ( it != m_dictIdChoices.end() );
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
bool wxPropertyGridPopulator::BeginChildren()
|
||
|
{
|
||
|
if ( wxPGIdIsOk(m_lastProperty) &&
|
||
|
wxPGIdToPtr(m_lastProperty)->CanHaveExtraChildren() )
|
||
|
{
|
||
|
wxLogDebug(wxT("New Parent: %s"),wxPGIdToPtr(m_lastProperty)->GetLabel().c_str());
|
||
|
m_curParent = m_lastProperty;
|
||
|
return true;
|
||
|
}
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
void wxPropertyGridPopulator::AddChoices(wxPGChoicesId choicesId,
|
||
|
const wxArrayString& choiceLabels,
|
||
|
const wxArrayInt& choiceValues)
|
||
|
{
|
||
|
#ifdef __WXDEBUG__
|
||
|
// Make sure the id is not used yet
|
||
|
wxPGHashMapP2P::iterator it = m_dictIdChoices.find(choicesId);
|
||
|
wxCHECK_RET( it == m_dictIdChoices.end(),
|
||
|
wxT("added set of choices to same id twice (use HasChoices if necessary)") );
|
||
|
#endif
|
||
|
|
||
|
wxCHECK_RET( choicesId != (wxPGChoicesId)0,
|
||
|
wxT("choicesId must not be 0/NULL"));
|
||
|
|
||
|
wxPGChoices chs(choiceLabels,choiceValues);
|
||
|
wxPGChoicesData* data = chs.ExtractData();
|
||
|
m_dictIdChoices[choicesId] = (void*) data;
|
||
|
|
||
|
// Artifically reduce refcount to 0 (since nothing uses it yet)
|
||
|
//data->m_refCount = 0;
|
||
|
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridPopulator::DoAppend(wxPGProperty* p,
|
||
|
const wxString& value,
|
||
|
const wxString& attributes,
|
||
|
wxPGChoicesId choicesId,
|
||
|
const wxArrayString& choiceLabels,
|
||
|
const wxArrayInt& choiceValues)
|
||
|
{
|
||
|
wxASSERT( m_propGrid );
|
||
|
|
||
|
// Make sure m_curParent is ok
|
||
|
if ( !wxPGIdIsOk(m_curParent) )
|
||
|
{
|
||
|
if ( !wxPGIdIsOk(m_popRoot) )
|
||
|
m_popRoot = m_propGrid->GetRoot();
|
||
|
m_curParent = m_popRoot;
|
||
|
}
|
||
|
|
||
|
if ( p )
|
||
|
{
|
||
|
|
||
|
// Set choices
|
||
|
if ( choicesId )
|
||
|
{
|
||
|
wxPGHashMapP2P::iterator it = m_dictIdChoices.find(choicesId);
|
||
|
|
||
|
wxPGChoices chs;
|
||
|
|
||
|
if ( it != m_dictIdChoices.end() )
|
||
|
{
|
||
|
// Already found
|
||
|
wxPGChoicesData* foundData = (wxPGChoicesData*) it->second;
|
||
|
chs.AssignData(foundData);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
chs.Set(choiceLabels,choiceValues);
|
||
|
m_dictIdChoices[choicesId] = (void*) chs.GetData();
|
||
|
}
|
||
|
|
||
|
p->SetChoices(chs);
|
||
|
|
||
|
}
|
||
|
|
||
|
// Value setter must be before append
|
||
|
if ( value.length() )
|
||
|
{
|
||
|
p->SetValueFromString(value,wxPG_FULL_VALUE);
|
||
|
}
|
||
|
|
||
|
// Set attributes
|
||
|
if ( attributes.length() )
|
||
|
wxPropertyGrid::SetPropertyAttributes(p,attributes);
|
||
|
|
||
|
// Append to grid
|
||
|
m_propGrid->AppendIn(m_curParent,p);
|
||
|
|
||
|
m_lastProperty = p;
|
||
|
}
|
||
|
return wxPGIdGen(p);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridPopulator::AppendByClass(const wxString& classname,
|
||
|
const wxString& label,
|
||
|
const wxString& name,
|
||
|
const wxString& value,
|
||
|
const wxString& attributes,
|
||
|
wxPGChoicesId choicesId,
|
||
|
const wxArrayString& choiceLabels,
|
||
|
const wxArrayInt& choiceValues)
|
||
|
{
|
||
|
wxPGProperty* p = m_propGrid->CreatePropertyByClass(classname,label,name);
|
||
|
return DoAppend(p,value,attributes,choicesId,choiceLabels,choiceValues);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|
||
|
|
||
|
wxPGId wxPropertyGridPopulator::AppendByType(const wxString& valuetype,
|
||
|
const wxString& label,
|
||
|
const wxString& name,
|
||
|
const wxString& value,
|
||
|
const wxString& attributes,
|
||
|
wxPGChoicesId choicesId,
|
||
|
const wxArrayString& choiceLabels,
|
||
|
const wxArrayInt& choiceValues)
|
||
|
{
|
||
|
wxPGProperty* p = m_propGrid->CreatePropertyByType(valuetype,label,name);
|
||
|
return DoAppend(p,value,attributes,choicesId,choiceLabels,choiceValues);
|
||
|
}
|
||
|
|
||
|
// -----------------------------------------------------------------------
|