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

wxArrayEditorDialog now uses wxEditableListBox. It has also been renamed to wxPGArrayEditorDialog.

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@64867 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Jaakko Salli 2010-07-10 15:30:35 +00:00
parent 380dc46f78
commit 2906967c4a
5 changed files with 178 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/changes.txt
View File

@ -499,6 +499,7 @@ All (GUI):
- wxPropertyGrid: many fixes to property validation failure behavior. Added
new flags: wxPG_VFB_SHOW_MESSAGEBOX and wxPG_VFB_SHOW_MESSAGE_ON_STATUSBAR.
- wxPropertyGrid: Added wxPropertyGrid::DedicateKey().
- wxPropertyGrid: wxArrayStringProperty now uses wxEditableListBox.
- wxPropertyGridManager: added wxPG_NO_INTERNAL_BORDER,
wxPG_EX_NO_TOOLBAR_DIVIDER and wxPG_EX_TOOLBAR_SEPARATOR styles for finer
control over borders. Borders around property grid are now native for

4
docs/doxygen/overviews/propgrid.h
View File

@ -995,6 +995,10 @@ without warnings or errors.
- Various wxPropertyGridManager page-related functions now return pointer
to the page object instead of index.
- wxArrayEditorDialog used by wxArrayStringProperty and some sample
properties has been renamed to wxPGArrayEditorDialog. Also, it now uses
wxEditableListBox for editing.
- Instead of calling wxPropertyGrid::SetButtonShortcut(), use
wxPropertyGrid::SetActionTrigger(wxPG_ACTION_PRESS_BUTTON).

58
include/wx/propgrid/props.h
View File

@ -16,7 +16,7 @@
// -----------------------------------------------------------------------
class wxArrayEditorDialog;
class wxPGArrayEditorDialog;
#include "wx/propgrid/editors.h"
@ -742,8 +742,8 @@ public:
wxWindow* primary,
const wxChar* cbt );
// Creates wxArrayEditorDialog for string editing. Called in OnButtonClick.
virtual wxArrayEditorDialog* CreateEditorDialog();
// Creates wxPGArrayEditorDialog for string editing. Called in OnButtonClick.
virtual wxPGArrayEditorDialog* CreateEditorDialog();
protected:
wxString m_display; // Cache for displayed text.
@ -834,21 +834,26 @@ wxValidator* PROPNAME::DoGetValidator () const \
// -----------------------------------------------------------------------
// wxArrayEditorDialog
// wxPGArrayEditorDialog
// -----------------------------------------------------------------------
#if wxUSE_EDITABLELISTBOX
class WXDLLIMPEXP_FWD_ADV wxEditableListBox;
class WXDLLIMPEXP_FWD_CORE wxListEvent;
#define wxAEDIALOG_STYLE \
(wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER | wxOK | wxCANCEL | wxCENTRE)
class WXDLLIMPEXP_PROPGRID wxArrayEditorDialog : public wxDialog
class WXDLLIMPEXP_PROPGRID wxPGArrayEditorDialog : public wxDialog
{
public:
wxArrayEditorDialog();
virtual ~wxArrayEditorDialog() { }
wxPGArrayEditorDialog();
virtual ~wxPGArrayEditorDialog() { }
void Init();
wxArrayEditorDialog( wxWindow *parent,
wxPGArrayEditorDialog( wxWindow *parent,
const wxString& message,
const wxString& caption,
long style = wxAEDIALOG_STYLE,
@ -893,38 +898,37 @@ public:
// Returns true if array was actually modified
bool IsModified() const { return m_modified; }
// wxEditableListBox utilities
int GetSelection() const;
//const wxArrayString& GetStrings() const { return m_array; }
// implementation from now on
void OnUpdateClick(wxCommandEvent& event);
void OnAddClick(wxCommandEvent& event);
void OnDeleteClick(wxCommandEvent& event);
void OnListBoxClick(wxCommandEvent& event);
void OnUpClick(wxCommandEvent& event);
void OnDownClick(wxCommandEvent& event);
//void OnCustomEditClick(wxCommandEvent& event);
void OnEndLabelEdit(wxListEvent& event);
void OnIdle(wxIdleEvent& event);
protected:
wxTextCtrl* m_edValue;
wxListBox* m_lbStrings;
wxEditableListBox* m_elb;
wxButton* m_butCustom; // required for disabling/enabling changing.
wxButton* m_butUp;
wxButton* m_butDown;
wxButton* m_butAdd; // Button pointers
wxButton* m_butCustom; // required for disabling/enabling changing.
wxButton* m_butUpdate;
wxButton* m_butRemove;
wxButton* m_butUp;
wxButton* m_butDown;
//wxArrayString m_array;
// These are used for focus repair
wxWindow* m_elbSubPanel;
wxWindow* m_lastFocused;
const wxChar* m_custBtText;
//wxArrayStringPropertyClass* m_pCallingClass;
// A new item, edited by user, is pending at this index.
// It will be committed once list ctrl item editing is done.
int m_itemPendingAtIndex;
bool m_modified;
unsigned char m_curFocus;
// These must be overridden - must return true on success.
virtual wxString ArrayGet( size_t index ) = 0;
virtual size_t ArrayGetCount() = 0;
@ -934,16 +938,18 @@ protected:
virtual void ArraySwap( size_t first, size_t second ) = 0;
private:
DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayEditorDialog)
DECLARE_DYNAMIC_CLASS_NO_COPY(wxPGArrayEditorDialog)
DECLARE_EVENT_TABLE()
};
#endif // wxUSE_EDITABLELISTBOX
// -----------------------------------------------------------------------
// wxPGArrayStringEditorDialog
// -----------------------------------------------------------------------
class WXDLLIMPEXP_PROPGRID
wxPGArrayStringEditorDialog : public wxArrayEditorDialog
wxPGArrayStringEditorDialog : public wxPGArrayEditorDialog
{
public:
wxPGArrayStringEditorDialog();

12
samples/propgrid/sampleprops.cpp
View File

@ -314,7 +314,7 @@ bool wxDirsProperty::OnCustomStringEdit( wxWindow* parent, wxString& value )
// by replacing each ArrayDouble with ArrayXXX.
//
class wxArrayDoubleEditorDialog : public wxArrayEditorDialog
class wxArrayDoubleEditorDialog : public wxPGArrayEditorDialog
{
public:
wxArrayDoubleEditorDialog();
@ -368,7 +368,7 @@ private:
DECLARE_DYNAMIC_CLASS_NO_COPY(wxArrayDoubleEditorDialog)
};
IMPLEMENT_DYNAMIC_CLASS(wxArrayDoubleEditorDialog, wxArrayEditorDialog)
IMPLEMENT_DYNAMIC_CLASS(wxArrayDoubleEditorDialog, wxPGArrayEditorDialog)
//
// Array dialog array access and manipulation
@ -426,14 +426,14 @@ void wxArrayDoubleEditorDialog::ArraySwap( size_t first, size_t second )
//
wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog()
: wxArrayEditorDialog()
: wxPGArrayEditorDialog()
{
Init();
}
void wxArrayDoubleEditorDialog::Init()
{
wxArrayEditorDialog::Init();
wxPGArrayEditorDialog::Init();
SetPrecision(-1);
}
@ -444,7 +444,7 @@ wxArrayDoubleEditorDialog::wxArrayDoubleEditorDialog(wxWindow *parent,
long style,
const wxPoint& pos,
const wxSize& sz )
: wxArrayEditorDialog()
: wxPGArrayEditorDialog()
{
Init();
Create(parent,message,caption,array,style,pos,sz);
@ -461,7 +461,7 @@ bool wxArrayDoubleEditorDialog::Create(wxWindow *parent,
m_array = array;
return wxArrayEditorDialog::Create (parent,message,caption,style,pos,sz);
return wxPGArrayEditorDialog::Create (parent,message,caption,style,pos,sz);
}
// -----------------------------------------------------------------------

299
src/propgrid/props.cpp
View File

@ -2001,70 +2001,49 @@ bool wxLongStringProperty::StringToValue( wxVariant& variant, const wxString& te
return false;
}
#if wxUSE_EDITABLELISTBOX
// -----------------------------------------------------------------------
// wxArrayEditorDialog
// wxPGArrayEditorDialog
// -----------------------------------------------------------------------
BEGIN_EVENT_TABLE(wxArrayEditorDialog, wxDialog)
EVT_IDLE(wxArrayEditorDialog::OnIdle)
EVT_LISTBOX(24, wxArrayEditorDialog::OnListBoxClick)
EVT_TEXT_ENTER(21, wxArrayEditorDialog::OnAddClick)
EVT_BUTTON(22, wxArrayEditorDialog::OnAddClick)
EVT_BUTTON(23, wxArrayEditorDialog::OnDeleteClick)
EVT_BUTTON(25, wxArrayEditorDialog::OnUpClick)
EVT_BUTTON(26, wxArrayEditorDialog::OnDownClick)
EVT_BUTTON(27, wxArrayEditorDialog::OnUpdateClick)
//EVT_BUTTON(28, wxArrayEditorDialog::OnCustomEditClick)
BEGIN_EVENT_TABLE(wxPGArrayEditorDialog, wxDialog)
EVT_IDLE(wxPGArrayEditorDialog::OnIdle)
END_EVENT_TABLE()
IMPLEMENT_ABSTRACT_CLASS(wxArrayEditorDialog, wxDialog)
IMPLEMENT_ABSTRACT_CLASS(wxPGArrayEditorDialog, wxDialog)
#include "wx/statline.h"
#include "wx/editlbox.h"
#include "wx/listctrl.h"
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnIdle(wxIdleEvent& event)
void wxPGArrayEditorDialog::OnIdle(wxIdleEvent& event)
{
//
// Do control focus detection here.
//
// Repair focus - wxEditableListBox has bitmap buttons, which
// get focus, and lose focus (into the oblivion) when they
// become disabled due to change in control state.
wxWindow* focused = FindFocus();
wxWindow* lastFocused = m_lastFocused;
wxWindow* focus = ::wxWindow::FindFocus();
// This strange focus thing is a workaround for wxGTK wxListBox focus
// reporting bug.
if ( m_curFocus == 0 && focused != m_edValue &&
focused != m_butAdd && focused != m_butUpdate &&
m_lbStrings->GetSelection() >= 0 )
// If last focused control became disabled, set focus back to
// wxEditableListBox
if ( lastFocused && focus != lastFocused &&
lastFocused->GetParent() == m_elbSubPanel &&
!lastFocused->IsEnabled() )
{
// ListBox was just focused.
m_butAdd->Enable(false);
m_butUpdate->Enable(false);
m_butRemove->Enable(true);
m_butUp->Enable(true);
m_butDown->Enable(true);
m_curFocus = 1;
}
else if ( (m_curFocus == 1 && focused == m_edValue) /*|| m_curFocus == 2*/ )
{
// TextCtrl was just focused.
m_butAdd->Enable(true);
bool upd_enable = false;
if ( m_lbStrings->GetCount() && m_lbStrings->GetSelection() >= 0 )
upd_enable = true;
m_butUpdate->Enable(upd_enable);
m_butRemove->Enable(false);
m_butUp->Enable(false);
m_butDown->Enable(false);
m_curFocus = 0;
m_elb->GetListCtrl()->SetFocus();
}
m_lastFocused = focus;
event.Skip();
}
// -----------------------------------------------------------------------
wxArrayEditorDialog::wxArrayEditorDialog()
wxPGArrayEditorDialog::wxPGArrayEditorDialog()
: wxDialog()
{
Init();
@ -2072,14 +2051,16 @@ wxArrayEditorDialog::wxArrayEditorDialog()
// -----------------------------------------------------------------------
void wxArrayEditorDialog::Init()
void wxPGArrayEditorDialog::Init()
{
m_custBtText = (const wxChar*) NULL;
m_custBtText = NULL;
m_lastFocused = NULL;
m_itemPendingAtIndex = -1;
}
// -----------------------------------------------------------------------
wxArrayEditorDialog::wxArrayEditorDialog( wxWindow *parent,
wxPGArrayEditorDialog::wxPGArrayEditorDialog( wxWindow *parent,
const wxString& message,
const wxString& caption,
long style,
@ -2093,7 +2074,7 @@ wxArrayEditorDialog::wxArrayEditorDialog( wxWindow *parent,
// -----------------------------------------------------------------------
bool wxArrayEditorDialog::Create( wxWindow *parent,
bool wxPGArrayEditorDialog::Create( wxWindow *parent,
const wxString& message,
const wxString& caption,
long style,
@ -2121,8 +2102,6 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
m_modified = false;
m_curFocus = 1;
wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
// Message
@ -2130,69 +2109,49 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
topsizer->Add( new wxStaticText(this,-1,message),
0, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxALL, spacing );
// String editor
wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
m_edValue = new wxTextCtrl(this,21,wxEmptyString,
wxDefaultPosition,wxDefaultSize,wxTE_PROCESS_ENTER);
#if wxUSE_VALIDATORS
wxValidator* validator = GetTextCtrlValidator();
if ( validator )
{
m_edValue->SetValidator( *validator );
delete validator;
}
#endif
rowsizer->Add( m_edValue,
1, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxALL, spacing );
m_elb = new wxEditableListBox(this, wxID_ANY, message,
wxDefaultPosition,
wxDefaultSize,
wxEL_ALLOW_NEW |
wxEL_ALLOW_EDIT |
wxEL_ALLOW_DELETE);
// Add button
m_butAdd = new wxButton(this,22,_("Add"));
rowsizer->Add( m_butAdd,
0, wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, spacing );
topsizer->Add( rowsizer, 0, wxEXPAND, spacing );
// Populate the list box
wxArrayString arr;
for ( unsigned int i=0; i<ArrayGetCount(); i++ )
arr.push_back(ArrayGet(i));
m_elb->SetStrings(arr);
// Separator line
topsizer->Add( new wxStaticLine(this,-1),
0, wxEXPAND|wxBOTTOM|wxLEFT|wxRIGHT, spacing );
// Connect event handlers
wxButton* but;
wxListCtrl* lc = m_elb->GetListCtrl();
rowsizer = new wxBoxSizer( wxHORIZONTAL );
but = m_elb->GetNewButton();
m_elbSubPanel = but->GetParent();
but->Connect(but->GetId(), wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxPGArrayEditorDialog::OnAddClick),
NULL, this);
// list box
m_lbStrings = new wxListBox(this, 24, wxDefaultPosition, wxDefaultSize);
unsigned int i;
for ( i=0; i<ArrayGetCount(); i++ )
m_lbStrings->Append( ArrayGet(i) );
rowsizer->Add( m_lbStrings, 1, wxEXPAND|wxRIGHT, spacing );
but = m_elb->GetDelButton();
but->Connect(but->GetId(), wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxPGArrayEditorDialog::OnDeleteClick),
NULL, this);
// Manipulator buttons
wxBoxSizer* colsizer = new wxBoxSizer( wxVERTICAL );
m_butCustom = NULL;
if ( m_custBtText )
{
m_butCustom = new wxButton(this,28,::wxGetTranslation(m_custBtText));
colsizer->Add( m_butCustom,
0, wxALIGN_CENTER|wxTOP/*wxALIGN_LEFT|wxALIGN_CENTRE_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT*/,
spacing );
}
m_butUpdate = new wxButton(this,27,_("Update"));
colsizer->Add( m_butUpdate,
0, wxALIGN_CENTER|wxTOP, spacing );
m_butRemove = new wxButton(this,23,_("Remove"));
colsizer->Add( m_butRemove,
0, wxALIGN_CENTER|wxTOP, spacing );
m_butUp = new wxButton(this,25,_("Up"));
colsizer->Add( m_butUp,
0, wxALIGN_CENTER|wxTOP, spacing );
m_butDown = new wxButton(this,26,_("Down"));
colsizer->Add( m_butDown,
0, wxALIGN_CENTER|wxTOP, spacing );
rowsizer->Add( colsizer, 0, 0, spacing );
but = m_elb->GetUpButton();
but->Connect(but->GetId(), wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxPGArrayEditorDialog::OnUpClick),
NULL, this);
topsizer->Add( rowsizer, 1, wxLEFT|wxRIGHT|wxEXPAND, spacing );
but = m_elb->GetDownButton();
but->Connect(but->GetId(), wxEVT_COMMAND_BUTTON_CLICKED,
wxCommandEventHandler(wxPGArrayEditorDialog::OnDownClick),
NULL, this);
// Separator line
topsizer->Add( new wxStaticLine(this,-1),
0, wxEXPAND|wxTOP|wxLEFT|wxRIGHT, spacing );
lc->Connect(lc->GetId(), wxEVT_COMMAND_LIST_END_LABEL_EDIT,
wxListEventHandler(wxPGArrayEditorDialog::OnEndLabelEdit),
NULL, this);
topsizer->Add( m_elb, 1, wxEXPAND, spacing );
// Standard dialog buttons
wxStdDialogButtonSizer* buttonSizer = new wxStdDialogButtonSizer();
@ -2203,7 +2162,7 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL|wxALL,
spacing );
m_edValue->SetFocus();
m_elb->SetFocus();
SetSizer( topsizer );
topsizer->SetSizeHints( this );
@ -2221,107 +2180,119 @@ bool wxArrayEditorDialog::Create( wxWindow *parent,
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnAddClick(wxCommandEvent& )
int wxPGArrayEditorDialog::GetSelection() const
{
wxString text = m_edValue->GetValue();
if ( text.length() )
{
if ( ArrayInsert( text, -1 ) )
{
m_lbStrings->Append( text );
m_modified = true;
m_edValue->Clear();
}
}
wxListCtrl* lc = m_elb->GetListCtrl();
int index = lc->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if ( index == -1 )
return wxNOT_FOUND;
return index;
}
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnDeleteClick(wxCommandEvent& )
void wxPGArrayEditorDialog::OnAddClick(wxCommandEvent& event)
{
int index = m_lbStrings->GetSelection();
wxListCtrl* lc = m_elb->GetListCtrl();
m_itemPendingAtIndex = lc->GetItemCount() - 1;
event.Skip();
}
// -----------------------------------------------------------------------
void wxPGArrayEditorDialog::OnDeleteClick(wxCommandEvent& event)
{
int index = GetSelection();
if ( index >= 0 )
{
ArrayRemoveAt( index );
m_lbStrings->Delete ( index );
m_modified = true;
}
event.Skip();
}
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnUpClick(wxCommandEvent& )
void wxPGArrayEditorDialog::OnUpClick(wxCommandEvent& event)
{
int index = m_lbStrings->GetSelection();
int index = GetSelection();
if ( index > 0 )
{
ArraySwap(index-1,index);
/*wxString old_str = m_array[index-1];
wxString new_str = m_array[index];
m_array[index-1] = new_str;
m_array[index] = old_str;*/
m_lbStrings->SetString ( index-1, ArrayGet(index-1) );
m_lbStrings->SetString ( index, ArrayGet(index) );
m_lbStrings->SetSelection ( index-1 );
m_modified = true;
}
event.Skip();
}
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnDownClick(wxCommandEvent& )
void wxPGArrayEditorDialog::OnDownClick(wxCommandEvent& event)
{
int index = m_lbStrings->GetSelection();
int lastStringIndex = ((int) m_lbStrings->GetCount()) - 1;
wxListCtrl* lc = m_elb->GetListCtrl();
int index = GetSelection();
int lastStringIndex = lc->GetItemCount() - 1;
if ( index >= 0 && index < lastStringIndex )
{
ArraySwap(index,index+1);
/*wxString old_str = m_array[index+1];
wxString new_str = m_array[index];
m_array[index+1] = new_str;
m_array[index] = old_str;*/
m_lbStrings->SetString ( index+1, ArrayGet(index+1) );
m_lbStrings->SetString ( index, ArrayGet(index) );
m_lbStrings->SetSelection ( index+1 );
ArraySwap(index, index+1);
m_modified = true;
}
event.Skip();
}
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnUpdateClick(wxCommandEvent& )
void wxPGArrayEditorDialog::OnEndLabelEdit(wxListEvent& event)
{
int index = m_lbStrings->GetSelection();
if ( index >= 0 )
wxString str = event.GetLabel();
if ( m_itemPendingAtIndex >= 0 )
{
wxString str = m_edValue->GetValue();
if ( ArraySet(index,str) )
// Add a new item
if ( ArrayInsert(str, m_itemPendingAtIndex) )
{
m_lbStrings->SetString ( index, str );
//m_array[index] = str;
m_modified = true;
}
else
{
// Editable list box doesn't really respect Veto(), but
// it recognizes if no text was added, so we simulate
// Veto() using it.
event.m_item.SetText(wxEmptyString);
m_elb->GetListCtrl()->SetItemText(m_itemPendingAtIndex,
wxEmptyString);
event.Veto();
}
}
}
// -----------------------------------------------------------------------
void wxArrayEditorDialog::OnListBoxClick(wxCommandEvent& )
{
int index = m_lbStrings->GetSelection();
if ( index >= 0 )
else
{
m_edValue->SetValue( m_lbStrings->GetString(index) );
// Change an existing item
int index = GetSelection();
wxASSERT( index != wxNOT_FOUND );
if ( ArraySet(index, str) )
m_modified = true;
else
event.Veto();
}
event.Skip();
}
#endif // wxUSE_EDITABLELISTBOX
// -----------------------------------------------------------------------
// wxPGArrayStringEditorDialog
// -----------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog, wxArrayEditorDialog)
IMPLEMENT_DYNAMIC_CLASS(wxPGArrayStringEditorDialog, wxPGArrayEditorDialog)
BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog, wxArrayEditorDialog)
BEGIN_EVENT_TABLE(wxPGArrayStringEditorDialog, wxPGArrayEditorDialog)
EVT_BUTTON(28, wxPGArrayStringEditorDialog::OnCustomEditClick)
END_EVENT_TABLE()
@ -2366,7 +2337,7 @@ void wxPGArrayStringEditorDialog::ArraySwap( size_t first, size_t second )
}
wxPGArrayStringEditorDialog::wxPGArrayStringEditorDialog()
: wxArrayEditorDialog()
: wxPGArrayEditorDialog()
{
Init();
}
@ -2378,7 +2349,7 @@ void wxPGArrayStringEditorDialog::Init()
void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent& )
{
wxASSERT( m_pCallingClass );
/*wxASSERT( m_pCallingClass );
wxString str = m_edValue->GetValue();
if ( m_pCallingClass->OnCustomStringEdit(m_parent,str) )
{
@ -2386,7 +2357,7 @@ void wxPGArrayStringEditorDialog::OnCustomEditClick(wxCommandEvent& )
m_lbStrings->Append ( str );
m_array.Add ( str );
m_modified = true;
}
}*/
}
// -----------------------------------------------------------------------
@ -2502,7 +2473,7 @@ bool wxArrayStringProperty::OnCustomStringEdit( wxWindow*, wxString& )
return false;
}
wxArrayEditorDialog* wxArrayStringProperty::CreateEditorDialog()
wxPGArrayEditorDialog* wxArrayStringProperty::CreateEditorDialog()
{
return new wxPGArrayStringEditorDialog();
}
@ -2518,7 +2489,7 @@ bool wxArrayStringProperty::OnButtonClick( wxPropertyGrid* propGrid,
return false;
// Create editor dialog.
wxArrayEditorDialog* dlg = CreateEditorDialog();
wxPGArrayEditorDialog* dlg = CreateEditorDialog();
#if wxUSE_VALIDATORS
wxValidator* validator = GetValidator();
wxPGInDialogValidator dialogValidator;