]> git.saurik.com Git - wxWidgets.git/blob - src/propgrid/editors.cpp
projects / wxWidgets.git / blob
? search:


8394e5caad9f07a110bf72209c1fc553b56ff30b
[wxWidgets.git] / src / propgrid / editors.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/propgrid/editors.cpp
3 // Purpose: wxPropertyGrid editors
4 // Author: Jaakko Salli
5 // Modified by:
6 // Created: 2007-04-14
7 // RCS-ID: $Id:
8 // Copyright: (c) Jaakko Salli
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // For compilers that support precompilation, includes "wx/wx.h".
13 #include "wx/wxprec.h"
14
15 #ifdef __BORLANDC__
16 #pragma hdrstop
17 #endif
18
19 #ifndef WX_PRECOMP
20 #include "wx/defs.h"
21 #include "wx/object.h"
22 #include "wx/hash.h"
23 #include "wx/string.h"
24 #include "wx/log.h"
25 #include "wx/event.h"
26 #include "wx/window.h"
27 #include "wx/panel.h"
28 #include "wx/dc.h"
29 #include "wx/dcclient.h"
30 #include "wx/dcmemory.h"
31 #include "wx/button.h"
32 #include "wx/pen.h"
33 #include "wx/brush.h"
34 #include "wx/cursor.h"
35 #include "wx/dialog.h"
36 #include "wx/settings.h"
37 #include "wx/msgdlg.h"
38 #include "wx/choice.h"
39 #include "wx/stattext.h"
40 #include "wx/scrolwin.h"
41 #include "wx/dirdlg.h"
42 #include "wx/layout.h"
43 #include "wx/sizer.h"
44 #include "wx/textdlg.h"
45 #include "wx/filedlg.h"
46 #include "wx/statusbr.h"
47 #include "wx/intl.h"
48 #include "wx/frame.h"
49 #endif
50
51
52 #include "wx/timer.h"
53 #include "wx/dcbuffer.h"
54 #include "wx/bmpbuttn.h"
55
56
57 // This define is necessary to prevent macro clearing
58 #define __wxPG_SOURCE_FILE__
59
60 #include <wx/propgrid/propgrid.h>
61 #include <wx/propgrid/editors.h>
62 #include <wx/propgrid/props.h>
63
64 #if wxPG_USE_RENDERER_NATIVE
65 #include <wx/renderer.h>
66 #endif
67
68 // How many pixels between textctrl and button
69 #ifdef __WXMAC__
70 #define wxPG_TEXTCTRL_AND_BUTTON_SPACING 8
71 #else
72 #define wxPG_TEXTCTRL_AND_BUTTON_SPACING 2
73 #endif
74
75 #define wxPG_BUTTON_SIZEDEC 0
76
77 #include <wx/odcombo.h>
78
79 #ifdef __WXMSW__
80 #include <wx/msw/private.h>
81 #endif
82
83 // -----------------------------------------------------------------------
84
85 #if defined(__WXMSW__)
86 // tested
87 #define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
88 #define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
89
90 #define wxPG_NAT_BUTTON_BORDER_ANY 1
91 #define wxPG_NAT_BUTTON_BORDER_X 1
92 #define wxPG_NAT_BUTTON_BORDER_Y 1
93
94 #define wxPG_CHECKMARK_XADJ 1
95 #define wxPG_CHECKMARK_YADJ (-1)
96 #define wxPG_CHECKMARK_WADJ 0
97 #define wxPG_CHECKMARK_HADJ 0
98 #define wxPG_CHECKMARK_DEFLATE 0
99
100 #define wxPG_TEXTCTRLYADJUST (m_spacingy+0)
101
102 #elif defined(__WXGTK__)
103 // tested
104 #define wxPG_CHECKMARK_XADJ 0
105 #define wxPG_CHECKMARK_YADJ 0
106 #define wxPG_CHECKMARK_WADJ (-1)
107 #define wxPG_CHECKMARK_HADJ (-1)
108 #define wxPG_CHECKMARK_DEFLATE 3
109
110 #define wxPG_NAT_TEXTCTRL_BORDER_X 3 // Unremovable border of native textctrl.
111 #define wxPG_NAT_TEXTCTRL_BORDER_Y 3 // Unremovable border of native textctrl.
112
113 #define wxPG_NAT_BUTTON_BORDER_ANY 1
114 #define wxPG_NAT_BUTTON_BORDER_X 1
115 #define wxPG_NAT_BUTTON_BORDER_Y 1
116
117 #define wxPG_TEXTCTRLYADJUST 0
118
119 #elif defined(__WXMAC__)
120 // *not* tested
121 #define wxPG_CHECKMARK_XADJ 0
122 #define wxPG_CHECKMARK_YADJ 0
123 #define wxPG_CHECKMARK_WADJ 0
124 #define wxPG_CHECKMARK_HADJ 0
125 #define wxPG_CHECKMARK_DEFLATE 0
126
127 #define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
128 #define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
129
130 #define wxPG_NAT_BUTTON_BORDER_ANY 0
131 #define wxPG_NAT_BUTTON_BORDER_X 0
132 #define wxPG_NAT_BUTTON_BORDER_Y 0
133
134 #define wxPG_TEXTCTRLYADJUST 3
135
136 #else
137 // defaults
138 #define wxPG_CHECKMARK_XADJ 0
139 #define wxPG_CHECKMARK_YADJ 0
140 #define wxPG_CHECKMARK_WADJ 0
141 #define wxPG_CHECKMARK_HADJ 0
142 #define wxPG_CHECKMARK_DEFLATE 0
143
144 #define wxPG_NAT_TEXTCTRL_BORDER_X 0 // Unremovable border of native textctrl.
145 #define wxPG_NAT_TEXTCTRL_BORDER_Y 0 // Unremovable border of native textctrl.
146
147 #define wxPG_NAT_BUTTON_BORDER_ANY 0
148 #define wxPG_NAT_BUTTON_BORDER_X 0
149 #define wxPG_NAT_BUTTON_BORDER_Y 0
150
151 #define wxPG_TEXTCTRLYADJUST 0
152
153 #endif
154
155 #if (!wxPG_NAT_TEXTCTRL_BORDER_X && !wxPG_NAT_TEXTCTRL_BORDER_Y)
156 #define wxPG_ENABLE_CLIPPER_WINDOW 0
157 #else
158 #define wxPG_ENABLE_CLIPPER_WINDOW 1
159 #endif
160
161
162 // for odcombo
163 #define wxPG_CHOICEXADJUST 0
164 #define wxPG_CHOICEYADJUST 0
165
166 #define ODCB_CUST_PAINT_MARGIN 6 // Number added to image width for SetCustomPaintWidth
167
168 // Milliseconds to wait for two mouse-ups after focus inorder
169 // to trigger a double-click.
170 #define DOUBLE_CLICK_CONVERSION_TRESHOLD 500
171
172 // -----------------------------------------------------------------------
173 // wxPGEditor
174 // -----------------------------------------------------------------------
175
176 IMPLEMENT_ABSTRACT_CLASS(wxPGEditor, wxObject)
177
178
179 wxPGEditor::~wxPGEditor()
180 {
181 }
182
183 void wxPGEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& text ) const
184 {
185 if ( !property->IsValueUnspecified() )
186 dc.DrawText( text, rect.x+wxPG_XBEFORETEXT, rect.y );
187 }
188
189 bool wxPGEditor::GetValueFromControl( wxVariant&, wxPGProperty*, wxWindow* ) const
190 {
191 return false;
192 }
193
194 void wxPGEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow*, const wxString& ) const
195 {
196 }
197
198
199 void wxPGEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow*, int ) const
200 {
201 }
202
203
204 int wxPGEditor::InsertItem( wxWindow*, const wxString&, int ) const
205 {
206 return -1;
207 }
208
209
210 void wxPGEditor::DeleteItem( wxWindow*, int ) const
211 {
212 return;
213 }
214
215
216 void wxPGEditor::OnFocus( wxPGProperty*, wxWindow* ) const
217 {
218 }
219
220
221 bool wxPGEditor::CanContainCustomImage() const
222 {
223 return false;
224 }
225
226 // -----------------------------------------------------------------------
227 // wxPGClipperWindow
228 // -----------------------------------------------------------------------
229
230
231 #if wxPG_ENABLE_CLIPPER_WINDOW
232
233 //
234 // Clipper window is used to "remove" borders from controls
235 // which otherwise insist on having them despite of supplied
236 // wxNO_BORDER window style.
237 //
238 class wxPGClipperWindow : public wxWindow
239 {
240 DECLARE_CLASS(wxPGClipperWindow)
241 public:
242
243 wxPGClipperWindow()
244 : wxWindow()
245 {
246 wxPGClipperWindow::Init();
247 }
248
249 wxPGClipperWindow(wxWindow* parent,
250 wxWindowID id,
251 const wxPoint& pos = wxDefaultPosition,
252 const wxSize& size = wxDefaultSize)
253 {
254 Init();
255 Create(parent,id,pos,size);
256 }
257
258 void Create(wxWindow* parent,
259 wxWindowID id,
260 const wxPoint& pos = wxDefaultPosition,
261 const wxSize& size = wxDefaultSize);
262
263 virtual ~wxPGClipperWindow();
264
265 virtual bool ProcessEvent(wxEvent& event);
266
267 inline wxWindow* GetControl() const { return m_ctrl; }
268
269 // This is called before wxControl is constructed.
270 void GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz );
271
272 // This is caleed after wxControl has been constructed.
273 void SetControl( wxWindow* ctrl );
274
275 virtual void Refresh( bool eraseBackground = true,
276 const wxRect *rect = (const wxRect *) NULL );
277 virtual void SetFocus();
278
279 virtual bool SetFont(const wxFont& font);
280
281 inline int GetXClip() const { return m_xadj; }
282
283 inline int GetYClip() const { return m_yadj; }
284
285 protected:
286 wxWindow* m_ctrl;
287
288 int m_xadj; // Horizontal border clip.
289
290 int m_yadj; // Vertical border clip.
291
292 private:
293 void Init ()
294 {
295 m_ctrl = (wxWindow*) NULL;
296 }
297 };
298
299
300 IMPLEMENT_CLASS(wxPGClipperWindow,wxWindow)
301
302
303 // This is called before wxControl is constructed.
304 void wxPGClipperWindow::GetControlRect( int xadj, int yadj, wxPoint& pt, wxSize& sz )
305 {
306 m_xadj = xadj;
307 m_yadj = yadj;
308 pt.x = -xadj;
309 pt.y = -yadj;
310 wxSize own_size = GetSize();
311 sz.x = own_size.x+(xadj*2);
312 sz.y = own_size.y+(yadj*2);
313 }
314
315
316 // This is caleed after wxControl has been constructed.
317 void wxPGClipperWindow::SetControl( wxWindow* ctrl )
318 {
319 m_ctrl = ctrl;
320
321 // GTK requires this.
322 ctrl->SetSizeHints(3,3);
323
324 // Correct size of this window to match the child.
325 wxSize sz = GetSize();
326 wxSize chsz = ctrl->GetSize();
327
328 int hei_adj = chsz.y - (sz.y+(m_yadj*2));
329 if ( hei_adj )
330 SetSize(sz.x,chsz.y-(m_yadj*2));
331
332 }
333
334
335 void wxPGClipperWindow::Refresh( bool eraseBackground, const wxRect *rect )
336 {
337 wxWindow::Refresh(false,rect);
338 if ( m_ctrl )
339 m_ctrl->Refresh(eraseBackground);
340 }
341
342
343 // Pass focus to control
344 void wxPGClipperWindow::SetFocus()
345 {
346 if ( m_ctrl )
347 m_ctrl->SetFocus();
348 else
349 wxWindow::SetFocus();
350 }
351
352
353 bool wxPGClipperWindow::SetFont(const wxFont& font)
354 {
355 bool res = wxWindow::SetFont(font);
356 if ( m_ctrl )
357 return m_ctrl->SetFont(font);
358 return res;
359 }
360
361
362 void wxPGClipperWindow::Create(wxWindow* parent,
363 wxWindowID id,
364 const wxPoint& pos,
365 const wxSize& size )
366 {
367 wxWindow::Create(parent,id,pos,size);
368 }
369
370
371 wxPGClipperWindow::~wxPGClipperWindow()
372 {
373 }
374
375
376 bool wxPGClipperWindow::ProcessEvent(wxEvent& event)
377 {
378 if ( event.GetEventType() == wxEVT_SIZE )
379 {
380 if ( m_ctrl )
381 {
382 // Maintain correct size relationship.
383 wxSize sz = GetSize();
384 m_ctrl->SetSize(sz.x+(m_xadj*2),sz.y+(m_yadj*2));
385 event.Skip();
386 return false;
387 }
388 }
389 return wxWindow::ProcessEvent(event);
390 }
391
392 #endif // wxPG_ENABLE_CLIPPER_WINDOW
393
394 /*wxWindow* wxPropertyGrid::GetActualEditorControl( wxWindow* ctrl )
395 {
396 #if wxPG_ENABLE_CLIPPER_WINDOW
397 // Pass real control instead of clipper window
398 if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
399 {
400 return ((wxPGClipperWindow*)ctrl)->GetControl();
401 }
402 #else
403 return ctrl;
404 #endif
405 }*/
406
407 // -----------------------------------------------------------------------
408 // wxPGTextCtrlEditor
409 // -----------------------------------------------------------------------
410
411 // Clipper window support macro (depending on whether it is used
412 // for this editor or not)
413 #if wxPG_NAT_TEXTCTRL_BORDER_X || wxPG_NAT_TEXTCTRL_BORDER_Y
414 #define wxPG_NAT_TEXTCTRL_BORDER_ANY 1
415 #else
416 #define wxPG_NAT_TEXTCTRL_BORDER_ANY 0
417 #endif
418
419 WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrl,wxPGTextCtrlEditor,wxPGEditor)
420
421
422 wxPGWindowList wxPGTextCtrlEditor::CreateControls( wxPropertyGrid* propGrid,
423 wxPGProperty* property,
424 const wxPoint& pos,
425 const wxSize& sz ) const
426 {
427 wxString text;
428
429 //
430 // If has children, and limited editing is specified, then don't create.
431 if ( (property->GetFlags() & wxPG_PROP_NOEDITOR) &&
432 property->GetChildCount() )
433 return (wxWindow*) NULL;
434
435 if ( !property->IsValueUnspecified() )
436 text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
437
438 int flags = 0;
439 if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
440 property->IsKindOf(CLASSINFO(wxStringProperty)) )
441 flags |= wxTE_PASSWORD;
442
443 wxWindow* wnd = propGrid->GenerateEditorTextCtrl(pos,sz,text,(wxWindow*)NULL,flags,
444 property->GetMaxLength());
445
446 return wnd;
447 }
448
449 #if 0
450 void wxPGTextCtrlEditor::DrawValue( wxDC& dc, wxPGProperty* property, const wxRect& rect ) const
451 {
452 if ( !property->IsValueUnspecified() )
453 {
454 wxString drawStr = property->GetDisplayedString();
455
456 // Code below should no longer be needed, as the obfuscation
457 // is now done in GetValueAsString.
458 /*if ( (property->GetFlags() & wxPG_PROP_PASSWORD) &&
459 property->IsKindOf(WX_PG_CLASSINFO(wxStringProperty)) )
460 {
461 size_t a = drawStr.length();
462 drawStr.Empty();
463 drawStr.Append(wxS('*'),a);
464 }*/
465 dc.DrawText( drawStr, rect.x+wxPG_XBEFORETEXT, rect.y );
466 }
467 }
468 #endif
469
470 void wxPGTextCtrlEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
471 {
472 wxTextCtrl* tc = wxDynamicCast(ctrl, wxTextCtrl);
473 if (!tc) return;
474
475 wxString s;
476
477 if ( tc->HasFlag(wxTE_PASSWORD) )
478 s = property->GetValueAsString(wxPG_FULL_VALUE);
479 else
480 s = property->GetDisplayedString();
481
482 tc->SetValue(s);
483 }
484
485
486 // Provided so that, for example, ComboBox editor can use the same code
487 // (multiple inheritance would get way too messy).
488 bool wxPGTextCtrlEditor::OnTextCtrlEvent( wxPropertyGrid* propGrid,
489 wxPGProperty* WXUNUSED(property),
490 wxWindow* ctrl,
491 wxEvent& event )
492 {
493 if ( !ctrl )
494 return false;
495
496 if ( event.GetEventType() == wxEVT_COMMAND_TEXT_ENTER )
497 {
498 if ( propGrid->IsEditorsValueModified() )
499 {
500 return true;
501 }
502 }
503 else if ( event.GetEventType() == wxEVT_COMMAND_TEXT_UPDATED )
504 {
505 //
506 // Pass this event outside wxPropertyGrid so that,
507 // if necessary, program can tell when user is editing
508 // a textctrl.
509 // FIXME: Is it safe to change event id in the middle of event
510 // processing (seems to work, but...)?
511 event.Skip();
512 event.SetId(propGrid->GetId());
513
514 propGrid->EditorsValueWasModified();
515 }
516 return false;
517 }
518
519
520 bool wxPGTextCtrlEditor::OnEvent( wxPropertyGrid* propGrid,
521 wxPGProperty* property,
522 wxWindow* ctrl,
523 wxEvent& event ) const
524 {
525 return wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,ctrl,event);
526 }
527
528
529 bool wxPGTextCtrlEditor::GetTextCtrlValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl )
530 {
531 wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
532 wxString textVal = tc->GetValue();
533
534 if ( property->UsesAutoUnspecified() && !textVal.length() )
535 {
536 variant.MakeNull();
537 return true;
538 }
539
540 bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE);
541
542 // Changing unspecified always causes event (returning
543 // true here should be enough to trigger it).
544 // TODO: Move to propgrid.cpp
545 if ( !res && variant.IsNull() )
546 res = true;
547
548 return res;
549 }
550
551
552 bool wxPGTextCtrlEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
553 {
554 return wxPGTextCtrlEditor::GetTextCtrlValueFromControl(variant, property, ctrl);
555 }
556
557
558 void wxPGTextCtrlEditor::SetValueToUnspecified( wxPGProperty* property, wxWindow* ctrl ) const
559 {
560 wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
561
562 wxPropertyGrid* pg = property->GetGrid();
563 wxASSERT(pg); // Really, property grid should exist if editor does
564 if ( pg )
565 tc->SetValue(wxEmptyString);
566 }
567
568
569 void wxPGTextCtrlEditor::SetControlStringValue( wxPGProperty* property, wxWindow* ctrl, const wxString& txt ) const
570 {
571 wxTextCtrl* tc = wxStaticCast(ctrl, wxTextCtrl);
572
573 wxPropertyGrid* pg = property->GetGrid();
574 wxASSERT(pg); // Really, property grid should exist if editor does
575 if ( pg )
576 tc->SetValue(txt);
577 }
578
579
580 void wxPGTextCtrlEditor::OnFocus( wxPGProperty*, wxWindow* wnd ) const
581 {
582 wxTextCtrl* tc = wxStaticCast(wnd, wxTextCtrl);
583
584 tc->SetSelection(-1,-1);
585 }
586
587
588 wxPGTextCtrlEditor::~wxPGTextCtrlEditor() { }
589
590
591 // -----------------------------------------------------------------------
592 // wxPGChoiceEditor
593 // -----------------------------------------------------------------------
594
595
596 WX_PG_IMPLEMENT_EDITOR_CLASS(Choice,wxPGChoiceEditor,wxPGEditor)
597
598
599 // This is a special enhanced double-click processor class.
600 // In essence, it allows for double-clicks for which the
601 // first click "created" the control.
602 class wxPGDoubleClickProcessor : public wxEvtHandler
603 {
604 public:
605
606 wxPGDoubleClickProcessor( wxOwnerDrawnComboBox* combo, wxPGProperty* property )
607 : wxEvtHandler()
608 {
609 m_timeLastMouseUp = 0;
610 m_combo = combo;
611 m_property = property;
612 m_downReceived = false;
613 }
614
615 protected:
616
617 void OnMouseEvent( wxMouseEvent& event )
618 {
619 wxLongLong t = ::wxGetLocalTimeMillis();
620 int evtType = event.GetEventType();
621
622 if ( m_property->HasFlag(wxPG_PROP_USE_DCC) &&
623 m_property->IsKindOf(CLASSINFO(wxBoolProperty)) &&
624 !m_combo->IsPopupShown() )
625 {
626 // Just check that it is in the text area
627 wxPoint pt = event.GetPosition();
628 if ( m_combo->GetTextRect().Contains(pt) )
629 {
630 if ( evtType == wxEVT_LEFT_DOWN )
631 {
632 // Set value to avoid up-events without corresponding downs
633 m_downReceived = true;
634 }
635 else if ( evtType == wxEVT_LEFT_DCLICK )
636 {
637 // We'll make our own double-clicks
638 event.SetEventType(0);
639 return;
640 }
641 else if ( evtType == wxEVT_LEFT_UP )
642 {
643 if ( m_downReceived || m_timeLastMouseUp == 1 )
644 {
645 wxLongLong timeFromLastUp = (t-m_timeLastMouseUp);
646
647 if ( timeFromLastUp < DOUBLE_CLICK_CONVERSION_TRESHOLD )
648 {
649 event.SetEventType(wxEVT_LEFT_DCLICK);
650 m_timeLastMouseUp = 1;
651 }
652 else
653 {
654 m_timeLastMouseUp = t;
655 }
656 }
657 }
658 }
659 }
660
661 event.Skip();
662 }
663
664 void OnSetFocus( wxFocusEvent& event )
665 {
666 m_timeLastMouseUp = ::wxGetLocalTimeMillis();
667 event.Skip();
668 }
669
670 private:
671 wxLongLong m_timeLastMouseUp;
672 wxOwnerDrawnComboBox* m_combo;
673 wxPGProperty* m_property; // Selected property
674 bool m_downReceived;
675
676 DECLARE_EVENT_TABLE()
677 };
678
679 BEGIN_EVENT_TABLE(wxPGDoubleClickProcessor, wxEvtHandler)
680 EVT_MOUSE_EVENTS(wxPGDoubleClickProcessor::OnMouseEvent)
681 EVT_SET_FOCUS(wxPGDoubleClickProcessor::OnSetFocus)
682 END_EVENT_TABLE()
683
684
685
686 class wxPGComboBox : public wxOwnerDrawnComboBox
687 {
688 public:
689
690 wxPGComboBox()
691 : wxOwnerDrawnComboBox()
692 {
693 m_dclickProcessor = (wxPGDoubleClickProcessor*) NULL;
694 m_sizeEventCalled = false;
695 }
696
697 ~wxPGComboBox()
698 {
699 if ( m_dclickProcessor )
700 {
701 RemoveEventHandler(m_dclickProcessor);
702 delete m_dclickProcessor;
703 }
704 }
705
706 bool Create(wxWindow *parent,
707 wxWindowID id,
708 const wxString& value,
709 const wxPoint& pos,
710 const wxSize& size,
711 const wxArrayString& choices,
712 long style = 0,
713 const wxValidator& validator = wxDefaultValidator,
714 const wxString& name = wxS("wxOwnerDrawnComboBox"))
715 {
716 if ( !wxOwnerDrawnComboBox::Create( parent,
717 id,
718 value,
719 pos,
720 size,
721 choices,
722 style,
723 validator,
724 name ) )
725 return false;
726
727 m_dclickProcessor = new wxPGDoubleClickProcessor(this, GetGrid()->GetSelection() );
728
729 PushEventHandler(m_dclickProcessor);
730
731 return true;
732 }
733
734 virtual void OnDrawItem( wxDC& dc, const wxRect& rect, int item, int flags ) const
735 {
736 wxPropertyGrid* pg = GetGrid();
737 pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,dc,(wxRect&)rect,flags);
738 }
739 virtual wxCoord OnMeasureItem( size_t item ) const
740 {
741 wxPropertyGrid* pg = GetGrid();
742 wxRect rect;
743 rect.x = -1;
744 rect.width = 0;
745 pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
746 return rect.height;
747 }
748
749 wxPropertyGrid* GetGrid() const
750 {
751 wxPropertyGrid* pg = wxDynamicCast(GetParent()->GetParent(),wxPropertyGrid);
752 wxASSERT(pg);
753 return pg;
754 }
755
756 virtual wxCoord OnMeasureItemWidth( size_t item ) const
757 {
758 wxPropertyGrid* pg = GetGrid();
759 wxRect rect;
760 rect.x = -1;
761 rect.width = -1;
762 pg->OnComboItemPaint((wxPGCustomComboControl*)this,item,*((wxDC*)NULL),rect,0);
763 return rect.width;
764 }
765
766 virtual void PositionTextCtrl( int WXUNUSED(textCtrlXAdjust), int WXUNUSED(textCtrlYAdjust) )
767 {
768 wxPropertyGrid* pg = GetGrid();
769 wxOwnerDrawnComboBox::PositionTextCtrl(
770 wxPG_TEXTCTRLXADJUST - (wxPG_XBEFOREWIDGET+wxPG_CONTROL_MARGIN+1) - 1,
771 pg->GetSpacingY() + 2
772 );
773 }
774
775 private:
776 wxPGDoubleClickProcessor* m_dclickProcessor;
777 bool m_sizeEventCalled;
778 };
779
780
781 void wxPropertyGrid::OnComboItemPaint( wxPGCustomComboControl* pCc,
782 int item,
783 wxDC& dc,
784 wxRect& rect,
785 int flags )
786 {
787 wxPGComboBox* pCb = (wxPGComboBox*)pCc;
788
789 // Sanity check
790 wxASSERT( IsKindOf(CLASSINFO(wxPropertyGrid)) );
791
792 wxPGProperty* p = m_selected;
793 wxString text;
794
795 const wxPGChoices* pChoices = &p->GetChoices();
796 const wxPGCommonValue* comVal = NULL;
797 int choiceCount = p->GetChoiceCount();
798 int comVals = p->GetDisplayedCommonValueCount();
799 int comValIndex = -1;
800 if ( item >= choiceCount && comVals > 0 )
801 {
802 comValIndex = item - choiceCount;
803 comVal = GetCommonValue(comValIndex);
804 if ( !p->IsValueUnspecified() )
805 text = comVal->GetLabel();
806 }
807 else
808 {
809 if ( !(flags & wxODCB_PAINTING_CONTROL) )
810 {
811 text = pCb->GetString(item);
812 }
813 else
814 {
815 if ( !p->IsValueUnspecified() )
816 text = p->GetValueString(0);
817 }
818 }
819
820 if ( item < 0 )
821 return;
822
823 wxSize cis;
824
825 const wxBitmap* itemBitmap = NULL;
826
827 if ( item >= 0 && pChoices && pChoices->Item(item).GetBitmap().Ok() && comValIndex == -1 )
828 itemBitmap = &pChoices->Item(item).GetBitmap();
829
830 //
831 // Decide what custom image size to use
832 if ( itemBitmap )
833 {
834 cis.x = itemBitmap->GetWidth();
835 cis.y = itemBitmap->GetHeight();
836 }
837 else
838 {
839 cis = GetImageSize(p, item);
840 }
841
842 if ( rect.x < 0 )
843 {
844 // Default measure behaviour (no flexible, custom paint image only)
845 if ( rect.width < 0 )
846 {
847 wxCoord x, y;
848 GetTextExtent(text, &x, &y, 0, 0, &m_font);
849 rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9 + x;
850 }
851
852 rect.height = cis.y + 2;
853 return;
854 }
855
856 wxPGPaintData paintdata;
857 paintdata.m_parent = NULL;
858 paintdata.m_choiceItem = item;
859
860 // This is by the current (1.0.0b) spec - if painting control, item is -1
861 if ( (flags & wxODCB_PAINTING_CONTROL) )
862 paintdata.m_choiceItem = -1;
863
864 if ( &dc )
865 dc.SetBrush(*wxWHITE_BRUSH);
866
867 if ( rect.x >= 0 )
868 {
869 //
870 // DrawItem call
871
872 wxPoint pt(rect.x + wxPG_CONTROL_MARGIN - wxPG_CHOICEXADJUST - 1,
873 rect.y + 1);
874
875 int renderFlags = 0;
876
877 if ( flags & wxODCB_PAINTING_CONTROL )
878 renderFlags |= wxPGCellRenderer::Control;
879
880 if ( flags & wxODCB_PAINTING_SELECTED )
881 renderFlags |= wxPGCellRenderer::Selected;
882
883 if ( cis.x > 0 && (p->HasFlag(wxPG_PROP_CUSTOMIMAGE) || !(flags & wxODCB_PAINTING_CONTROL)) &&
884 ( !p->m_valueBitmap || item == pCb->GetSelection() ) &&
885 ( item >= 0 || (flags & wxODCB_PAINTING_CONTROL) ) &&
886 !itemBitmap
887 )
888 {
889 pt.x += wxCC_CUSTOM_IMAGE_MARGIN1;
890 wxRect r(pt.x,pt.y,cis.x,cis.y);
891
892 if ( flags & wxODCB_PAINTING_CONTROL )
893 {
894 //r.width = cis.x;
895 r.height = wxPG_STD_CUST_IMAGE_HEIGHT(m_lineHeight);
896 }
897
898 paintdata.m_drawnWidth = r.width;
899
900 dc.SetPen(m_colPropFore);
901 if ( comValIndex >= 0 )
902 {
903 const wxPGCommonValue* cv = GetCommonValue(comValIndex);
904 wxPGCellRenderer* renderer = cv->GetRenderer();
905 r.width = rect.width;
906 renderer->Render( dc, r, this, p, m_selColumn, comValIndex, renderFlags );
907 return;
908 }
909 else if ( item >= 0 )
910 {
911 p->OnCustomPaint( dc, r, paintdata );
912 }
913 else
914 {
915 dc.DrawRectangle( r );
916 }
917
918 pt.x += paintdata.m_drawnWidth + wxCC_CUSTOM_IMAGE_MARGIN2 - 1;
919 }
920 else
921 {
922 // TODO: This aligns text so that it seems to be horizontally
923 // on the same line as property values. Not really
924 // sure if its needed, but seems to not cause any harm.
925 pt.x -= 1;
926
927 if ( item < 0 && (flags & wxODCB_PAINTING_CONTROL) )
928 item = pCb->GetSelection();
929
930 if ( pChoices && item >= 0 && comValIndex < 0 )
931 {
932 const wxPGChoiceEntry& cell = pChoices->Item(item);
933 wxPGCellRenderer* renderer = wxPGGlobalVars->m_defaultRenderer;
934 int imageOffset = renderer->PreDrawCell( dc, rect, cell, renderFlags );
935 if ( imageOffset )
936 imageOffset += wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2;
937 pt.x += imageOffset;
938 }
939 }
940
941 //
942 // Draw text
943 //
944
945 pt.y += (rect.height-m_fontHeight)/2 - 1;
946
947 pt.x += 1;
948
949 dc.DrawText( text, pt.x + wxPG_XBEFORETEXT, pt.y );
950 }
951 else
952 {
953 //
954 // MeasureItem call
955
956 p->OnCustomPaint( dc, rect, paintdata );
957 rect.height = paintdata.m_drawnHeight + 2;
958 rect.width = cis.x + wxCC_CUSTOM_IMAGE_MARGIN1 + wxCC_CUSTOM_IMAGE_MARGIN2 + 9;
959 }
960 }
961
962 bool wxPGChoiceEditor_SetCustomPaintWidth( wxPropertyGrid* propGrid, wxPGComboBox* cb, int cmnVal )
963 {
964 wxPGProperty* property = propGrid->GetSelectedProperty();
965 wxASSERT( property );
966
967 if ( cmnVal >= 0 )
968 {
969 // Yes, a common value is being selected
970 property->SetCommonValue( cmnVal );
971 wxSize imageSize = propGrid->GetCommonValue(cmnVal)->
972 GetRenderer()->GetImageSize(property, 1, cmnVal);
973 if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
974 cb->SetCustomPaintWidth( imageSize.x );
975 return false;
976 }
977 else
978 {
979 wxSize imageSize = propGrid->GetImageSize(property, -1);
980 if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
981 cb->SetCustomPaintWidth( imageSize.x );
982 return true;
983 }
984 }
985
986 // CreateControls calls this with CB_READONLY in extraStyle
987 wxWindow* wxPGChoiceEditor::CreateControlsBase( wxPropertyGrid* propGrid,
988 wxPGProperty* property,
989 const wxPoint& pos,
990 const wxSize& sz,
991 long extraStyle ) const
992 {
993 wxString defString;
994
995 // Get choices.
996 int index = property->GetChoiceInfo( NULL );
997
998 bool isUnspecified = property->IsValueUnspecified();
999
1000 if ( isUnspecified )
1001 index = -1;
1002 else
1003 defString = property->GetDisplayedString();
1004
1005 const wxPGChoices& choices = property->GetChoices();
1006
1007 wxArrayString labels = choices.GetLabels();
1008
1009 wxPGComboBox* cb;
1010
1011 wxPoint po(pos);
1012 wxSize si(sz);
1013 po.y += wxPG_CHOICEYADJUST;
1014 si.y -= (wxPG_CHOICEYADJUST*2);
1015
1016 po.x += wxPG_CHOICEXADJUST;
1017 si.x -= wxPG_CHOICEXADJUST;
1018 wxWindow* ctrlParent = propGrid->GetPanel();
1019
1020 int odcbFlags = extraStyle | wxNO_BORDER | wxTE_PROCESS_ENTER;
1021
1022 //
1023 // If common value specified, use appropriate index
1024 unsigned int cmnVals = property->GetDisplayedCommonValueCount();
1025 if ( cmnVals )
1026 {
1027 if ( !isUnspecified )
1028 {
1029 int cmnVal = property->GetCommonValue();
1030 if ( cmnVal >= 0 )
1031 {
1032 index = labels.size() + cmnVal;
1033 }
1034 }
1035
1036 unsigned int i;
1037 for ( i=0; i<cmnVals; i++ )
1038 labels.Add(propGrid->GetCommonValueLabel(i));
1039 }
1040
1041 cb = new wxPGComboBox();
1042 #ifdef __WXMSW__
1043 cb->Hide();
1044 #endif
1045 cb->Create(ctrlParent,
1046 wxPG_SUBID1,
1047 wxString(),
1048 po,
1049 si,
1050 labels,
1051 odcbFlags);
1052
1053 //int extRight = propGrid->GetClientSize().x - (po.x+si.x);
1054 //int extRight = - (po.x+si.x);
1055
1056 cb->SetButtonPosition(si.y,0,wxRIGHT);
1057 //cb->SetPopupExtents( 1, extRight );
1058 cb->SetTextIndent(wxPG_XBEFORETEXT-1);
1059
1060 wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, property->GetCommonValue() );
1061 /*if ( property->GetFlags() & wxPG_PROP_CUSTOMIMAGE )
1062 {
1063 wxSize imageSize = propGrid->GetImageSize(property, index);
1064 if ( imageSize.x ) imageSize.x += ODCB_CUST_PAINT_MARGIN;
1065 cb->SetCustomPaintWidth( imageSize.x );
1066 }*/
1067
1068 if ( index >= 0 && index < (int)cb->GetCount() )
1069 {
1070 cb->SetSelection( index );
1071 if ( defString.length() )
1072 cb->SetText( defString );
1073 }
1074 else if ( !(extraStyle & wxCB_READONLY) && defString.length() )
1075 cb->SetValue( defString );
1076 else
1077 cb->SetSelection( -1 );
1078
1079 #ifdef __WXMSW__
1080 cb->Show();
1081 #endif
1082
1083 return (wxWindow*) cb;
1084 }
1085
1086
1087 void wxPGChoiceEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1088 {
1089 wxASSERT( ctrl );
1090 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1091 wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1092 int ind = property->GetChoiceInfo( (wxPGChoiceInfo*)NULL );
1093 cb->SetSelection(ind);
1094 }
1095
1096 wxPGWindowList wxPGChoiceEditor::CreateControls( wxPropertyGrid* propGrid, wxPGProperty* property,
1097 const wxPoint& pos, const wxSize& sz ) const
1098 {
1099 return CreateControlsBase(propGrid,property,pos,sz,wxCB_READONLY);
1100 }
1101
1102
1103 int wxPGChoiceEditor::InsertItem( wxWindow* ctrl, const wxString& label, int index ) const
1104 {
1105 wxASSERT( ctrl );
1106 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1107 wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1108
1109 if (index < 0)
1110 index = cb->GetCount();
1111
1112 return cb->Insert(label,index);
1113 }
1114
1115
1116 void wxPGChoiceEditor::DeleteItem( wxWindow* ctrl, int index ) const
1117 {
1118 wxASSERT( ctrl );
1119 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1120 wxASSERT( cb->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)));
1121
1122 cb->Delete(index);
1123 }
1124
1125 bool wxPGChoiceEditor::OnEvent( wxPropertyGrid* propGrid, wxPGProperty* property,
1126 wxWindow* ctrl, wxEvent& event ) const
1127 {
1128 if ( event.GetEventType() == wxEVT_COMMAND_COMBOBOX_SELECTED )
1129 {
1130 wxPGComboBox* cb = (wxPGComboBox*)ctrl;
1131 int index = cb->GetSelection();
1132 int cmnValIndex = -1;
1133 int cmnVals = property->GetDisplayedCommonValueCount();
1134 int items = cb->GetCount();
1135
1136 if ( index >= (items-cmnVals) )
1137 {
1138 // Yes, a common value is being selected
1139 cmnValIndex = index - (items-cmnVals);
1140 property->SetCommonValue( cmnValIndex );
1141
1142 // Truly set value to unspecified?
1143 if ( propGrid->GetUnspecifiedCommonValue() == cmnValIndex )
1144 {
1145 if ( !property->IsValueUnspecified() )
1146 propGrid->SetInternalFlag(wxPG_FL_VALUE_CHANGE_IN_EVENT);
1147 property->SetValueToUnspecified();
1148 if ( !cb->HasFlag(wxCB_READONLY) )
1149 cb->GetTextCtrl()->SetValue(wxEmptyString);
1150 return false;
1151 }
1152 }
1153 return wxPGChoiceEditor_SetCustomPaintWidth( propGrid, cb, cmnValIndex );
1154 }
1155 return false;
1156 }
1157
1158
1159 bool wxPGChoiceEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1160 {
1161 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1162
1163 int index = cb->GetSelection();
1164
1165 if ( index != property->GetChoiceInfo( (wxPGChoiceInfo*) NULL ) ||
1166 // Changing unspecified always causes event (returning
1167 // true here should be enough to trigger it).
1168 property->IsValueUnspecified()
1169 )
1170 {
1171 return property->IntToValue( variant, index, 0 );
1172 }
1173 return false;
1174 }
1175
1176
1177 void wxPGChoiceEditor::SetControlStringValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, const wxString& txt ) const
1178 {
1179 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1180 wxASSERT( cb );
1181 cb->SetValue(txt);
1182 }
1183
1184
1185 void wxPGChoiceEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, int value ) const
1186 {
1187 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1188 wxASSERT( cb );
1189 cb->SetSelection(value);
1190 }
1191
1192
1193 void wxPGChoiceEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
1194 {
1195 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1196 cb->SetSelection(-1);
1197 }
1198
1199
1200 bool wxPGChoiceEditor::CanContainCustomImage() const
1201 {
1202 return true;
1203 }
1204
1205
1206 wxPGChoiceEditor::~wxPGChoiceEditor() { }
1207
1208
1209 // -----------------------------------------------------------------------
1210 // wxPGComboBoxEditor
1211 // -----------------------------------------------------------------------
1212
1213
1214 WX_PG_IMPLEMENT_EDITOR_CLASS(ComboBox,wxPGComboBoxEditor,wxPGChoiceEditor)
1215
1216
1217 void wxPGComboBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1218 {
1219 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1220 cb->SetValue(property->GetValueString(wxPG_EDITABLE_VALUE));
1221
1222 // TODO: If string matches any selection, then select that.
1223 }
1224
1225
1226 wxPGWindowList wxPGComboBoxEditor::CreateControls( wxPropertyGrid* propGrid,
1227 wxPGProperty* property,
1228 const wxPoint& pos,
1229 const wxSize& sz ) const
1230 {
1231 return CreateControlsBase(propGrid,property,pos,sz,0);
1232 }
1233
1234
1235 bool wxPGComboBoxEditor::OnEvent( wxPropertyGrid* propGrid,
1236 wxPGProperty* property,
1237 wxWindow* ctrl,
1238 wxEvent& event ) const
1239 {
1240 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*) NULL;
1241 wxWindow* textCtrl = (wxWindow*) NULL;
1242
1243 if ( ctrl )
1244 {
1245 cb = (wxOwnerDrawnComboBox*)ctrl;
1246 textCtrl = cb->GetTextCtrl();
1247 }
1248
1249 if ( wxPGTextCtrlEditor::OnTextCtrlEvent(propGrid,property,textCtrl,event) )
1250 return true;
1251
1252 return wxPGChoiceEditor::OnEvent(propGrid,property,ctrl,event);
1253 }
1254
1255
1256 bool wxPGComboBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1257 {
1258 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1259 wxString textVal = cb->GetValue();
1260
1261 if ( property->UsesAutoUnspecified() && !textVal.length() )
1262 {
1263 variant.MakeNull();
1264 return true;
1265 }
1266
1267 bool res = property->StringToValue(variant, textVal, wxPG_EDITABLE_VALUE);
1268
1269 // Changing unspecified always causes event (returning
1270 // true here should be enough to trigger it).
1271 if ( !res && variant.IsNull() )
1272 res = true;
1273
1274 return res;
1275 }
1276
1277
1278 void wxPGComboBoxEditor::OnFocus( wxPGProperty*, wxWindow* ctrl ) const
1279 {
1280 wxOwnerDrawnComboBox* cb = (wxOwnerDrawnComboBox*)ctrl;
1281 cb->GetTextCtrl()->SetSelection(-1,-1);
1282 }
1283
1284
1285 wxPGComboBoxEditor::~wxPGComboBoxEditor() { }
1286
1287
1288 // -----------------------------------------------------------------------
1289 // wxPGChoiceAndButtonEditor
1290 // -----------------------------------------------------------------------
1291
1292
1293 // This simpler implement_editor macro doesn't define class body.
1294 WX_PG_IMPLEMENT_EDITOR_CLASS(ChoiceAndButton,wxPGChoiceAndButtonEditor,wxPGChoiceEditor)
1295
1296
1297 wxPGWindowList wxPGChoiceAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
1298 wxPGProperty* property,
1299 const wxPoint& pos,
1300 const wxSize& sz ) const
1301 {
1302 // Use one two units smaller to match size of the combo's dropbutton.
1303 // (normally a bigger button is used because it looks better)
1304 int bt_wid = sz.y;
1305 bt_wid -= 2;
1306 wxSize bt_sz(bt_wid,bt_wid);
1307
1308 // Position of button.
1309 wxPoint bt_pos(pos.x+sz.x-bt_sz.x,pos.y);
1310 #ifdef __WXMAC__
1311 bt_pos.y -= 1;
1312 #else
1313 bt_pos.y += 1;
1314 #endif
1315
1316 wxWindow* bt = propGrid->GenerateEditorButton( bt_pos, bt_sz );
1317
1318 // Size of choice.
1319 wxSize ch_sz(sz.x-bt->GetSize().x,sz.y);
1320
1321 #ifdef __WXMAC__
1322 ch_sz.x -= wxPG_TEXTCTRL_AND_BUTTON_SPACING;
1323 #endif
1324
1325 wxWindow* ch = wxPG_EDITOR(Choice)->CreateControls(propGrid,property,
1326 pos,ch_sz).m_primary;
1327
1328 #ifdef __WXMSW__
1329 bt->Show();
1330 #endif
1331
1332 return wxPGWindowList(ch, bt);
1333 }
1334
1335
1336 wxPGChoiceAndButtonEditor::~wxPGChoiceAndButtonEditor() { }
1337
1338
1339 // -----------------------------------------------------------------------
1340 // wxPGTextCtrlAndButtonEditor
1341 // -----------------------------------------------------------------------
1342
1343
1344 // This simpler implement_editor macro doesn't define class body.
1345 WX_PG_IMPLEMENT_EDITOR_CLASS(TextCtrlAndButton,wxPGTextCtrlAndButtonEditor,wxPGTextCtrlEditor)
1346
1347
1348 wxPGWindowList wxPGTextCtrlAndButtonEditor::CreateControls( wxPropertyGrid* propGrid,
1349 wxPGProperty* property,
1350 const wxPoint& pos,
1351 const wxSize& sz ) const
1352 {
1353 wxWindow* wnd2;
1354 wxWindow* wnd = propGrid->GenerateEditorTextCtrlAndButton( pos, sz, &wnd2,
1355 property->GetFlags() & wxPG_PROP_NOEDITOR, property);
1356
1357 return wxPGWindowList(wnd, wnd2);
1358 }
1359
1360
1361 wxPGTextCtrlAndButtonEditor::~wxPGTextCtrlAndButtonEditor() { }
1362
1363
1364 // -----------------------------------------------------------------------
1365 // wxPGCheckBoxEditor
1366 // -----------------------------------------------------------------------
1367
1368 #if wxPG_INCLUDE_CHECKBOX
1369
1370 WX_PG_IMPLEMENT_EDITOR_CLASS(CheckBox,wxPGCheckBoxEditor,wxPGEditor)
1371
1372
1373 // state argument: 0x01 = set if checked
1374 // 0x02 = set if rectangle should be bold
1375 static void DrawSimpleCheckBox( wxDC& dc, const wxRect& rect, int box_hei, int state, const wxColour& linecol )
1376 {
1377
1378 // Box rectangle.
1379 wxRect r(rect.x+wxPG_XBEFORETEXT,rect.y+((rect.height-box_hei)/2),box_hei,box_hei);
1380
1381 // Draw check mark first because it is likely to overdraw the
1382 // surrounding rectangle.
1383 if ( state & 1 )
1384 {
1385 wxRect r2(r.x+wxPG_CHECKMARK_XADJ,
1386 r.y+wxPG_CHECKMARK_YADJ,
1387 r.width+wxPG_CHECKMARK_WADJ,
1388 r.height+wxPG_CHECKMARK_HADJ);
1389 #if wxPG_CHECKMARK_DEFLATE
1390 r2.Deflate(wxPG_CHECKMARK_DEFLATE);
1391 #endif
1392 dc.DrawCheckMark(r2);
1393
1394 // This would draw a simple cross check mark.
1395 // dc.DrawLine(r.x,r.y,r.x+r.width-1,r.y+r.height-1);
1396 // dc.DrawLine(r.x,r.y+r.height-1,r.x+r.width-1,r.y);
1397
1398 }
1399
1400 if ( !(state & 2) )
1401 {
1402 // Pen for thin rectangle.
1403 dc.SetPen(linecol);
1404 }
1405 else
1406 {
1407 // Pen for bold rectangle.
1408 wxPen linepen(linecol,2,wxSOLID);
1409 linepen.SetJoin(wxJOIN_MITER); // This prevents round edges.
1410 dc.SetPen(linepen);
1411 r.x++;
1412 r.y++;
1413 r.width--;
1414 r.height--;
1415 }
1416
1417 dc.SetBrush(*wxTRANSPARENT_BRUSH);
1418
1419 dc.DrawRectangle(r);
1420 dc.SetPen(*wxTRANSPARENT_PEN);
1421 }
1422
1423 //
1424 // Real simple custom-drawn checkbox-without-label class.
1425 //
1426 class wxSimpleCheckBox : public wxControl
1427 {
1428 public:
1429
1430 void SetValue( int value );
1431
1432 wxSimpleCheckBox( wxWindow* parent,
1433 wxWindowID id,
1434 const wxPoint& pos = wxDefaultPosition,
1435 const wxSize& size = wxDefaultSize )
1436 : wxControl(parent,id,pos,size,wxNO_BORDER|wxWANTS_CHARS)
1437 {
1438 // Due to SetOwnFont stuff necessary for GTK+ 1.2, we need to have this
1439 SetFont( parent->GetFont() );
1440
1441 m_state = 0;
1442 wxPropertyGrid* pg = (wxPropertyGrid*) parent->GetParent();
1443 wxASSERT( pg->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1444 m_boxHeight = pg->GetFontHeight();
1445 SetBackgroundStyle( wxBG_STYLE_COLOUR );
1446 }
1447
1448 virtual ~wxSimpleCheckBox();
1449
1450 virtual bool ProcessEvent(wxEvent& event);
1451
1452 int m_state;
1453 int m_boxHeight;
1454
1455 static wxBitmap* ms_doubleBuffer;
1456
1457 };
1458
1459 wxSimpleCheckBox::~wxSimpleCheckBox()
1460 {
1461 delete ms_doubleBuffer;
1462 ms_doubleBuffer = NULL;
1463 }
1464
1465
1466 wxBitmap* wxSimpleCheckBox::ms_doubleBuffer = (wxBitmap*) NULL;
1467
1468 // value = 2 means toggle (sorry, too lazy to do constants)
1469 void wxSimpleCheckBox::SetValue( int value )
1470 {
1471 if ( value > 1 )
1472 {
1473 m_state++;
1474 if ( m_state > 1 ) m_state = 0;
1475 }
1476 else
1477 {
1478 m_state = value;
1479 }
1480 Refresh();
1481
1482 wxCommandEvent evt(wxEVT_COMMAND_CHECKBOX_CLICKED,GetParent()->GetId());
1483
1484 wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
1485 wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1486 propGrid->OnCustomEditorEvent(evt);
1487 }
1488
1489
1490 bool wxSimpleCheckBox::ProcessEvent(wxEvent& event)
1491 {
1492 wxPropertyGrid* propGrid = (wxPropertyGrid*) GetParent()->GetParent();
1493 wxASSERT( propGrid->IsKindOf(CLASSINFO(wxPropertyGrid)) );
1494
1495 if ( event.GetEventType() == wxEVT_NAVIGATION_KEY )
1496 {
1497 //wxLogDebug(wxT("wxEVT_NAVIGATION_KEY"));
1498 //SetFocusFromKbd();
1499 //event.Skip();
1500 //return wxControl::ProcessEvent(event);
1501 }
1502 else
1503 if ( ( (event.GetEventType() == wxEVT_LEFT_DOWN || event.GetEventType() == wxEVT_LEFT_DCLICK)
1504 && ((wxMouseEvent&)event).m_x > (wxPG_XBEFORETEXT-2)
1505 && ((wxMouseEvent&)event).m_x <= (wxPG_XBEFORETEXT-2+m_boxHeight) )
1506 )
1507 {
1508 SetValue(2);
1509 return true;
1510 }
1511 else if ( event.GetEventType() == wxEVT_PAINT )
1512 {
1513 wxSize clientSize = GetClientSize();
1514 wxPaintDC dc(this);
1515
1516 /*
1517 // Buffered paint DC doesn't seem to do much good
1518 if ( !ms_doubleBuffer ||
1519 clientSize.x > ms_doubleBuffer->GetWidth() ||
1520 clientSize.y > ms_doubleBuffer->GetHeight() )
1521 {
1522 delete ms_doubleBuffer;
1523 ms_doubleBuffer = new wxBitmap(clientSize.x+25,clientSize.y+25);
1524 }
1525
1526 wxBufferedPaintDC dc(this,*ms_doubleBuffer);
1527 */
1528
1529 wxRect rect(0,0,clientSize.x,clientSize.y);
1530 //rect.x -= 1;
1531 rect.y += 1;
1532 rect.width += 1;
1533
1534 m_boxHeight = propGrid->GetFontHeight();
1535
1536 wxColour bgcol = GetBackgroundColour();
1537 dc.SetBrush( bgcol );
1538 dc.SetPen( bgcol );
1539 dc.DrawRectangle( rect );
1540
1541 wxColour txcol = GetForegroundColour();
1542
1543 int state = m_state;
1544 if ( m_font.GetWeight() == wxBOLD )
1545 state |= 2;
1546
1547 DrawSimpleCheckBox(dc,rect,m_boxHeight,state,txcol);
1548
1549 // If focused, indicate it somehow.
1550 /*
1551 if ( wxWindow::FindFocus() == this )
1552 {
1553 rect.x += 1;
1554 rect.width -= 1;
1555
1556 wxPGDrawFocusRect(dc,rect);
1557 }
1558 */
1559
1560 return true;
1561 }
1562 else if ( event.GetEventType() == wxEVT_SIZE ||
1563 event.GetEventType() == wxEVT_SET_FOCUS ||
1564 event.GetEventType() == wxEVT_KILL_FOCUS
1565 )
1566 {
1567 Refresh();
1568 }
1569 else if ( event.GetEventType() == wxEVT_KEY_DOWN )
1570 {
1571 wxKeyEvent& keyEv = (wxKeyEvent&) event;
1572
1573 if ( keyEv.GetKeyCode() == WXK_TAB )
1574 {
1575 propGrid->SendNavigationKeyEvent( keyEv.ShiftDown()?0:1 );
1576 return true;
1577 }
1578 else
1579 if ( keyEv.GetKeyCode() == WXK_SPACE )
1580 {
1581 SetValue(2);
1582 return true;
1583 }
1584 }
1585 return wxControl::ProcessEvent(event);
1586 }
1587
1588
1589 wxPGWindowList wxPGCheckBoxEditor::CreateControls( wxPropertyGrid* propGrid,
1590 wxPGProperty* property,
1591 const wxPoint& pos,
1592 const wxSize& size ) const
1593 {
1594 wxPoint pt = pos;
1595 pt.x -= wxPG_XBEFOREWIDGET;
1596 wxSize sz = size;
1597 sz.x = propGrid->GetFontHeight() + (wxPG_XBEFOREWIDGET*2) + 4;
1598
1599 wxSimpleCheckBox* cb = new wxSimpleCheckBox(propGrid->GetPanel(),wxPG_SUBID1,pt,sz);
1600
1601 cb->SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));
1602
1603 cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DOWN,
1604 (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
1605 &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
1606
1607 cb->Connect( wxPG_SUBID1, wxEVT_LEFT_DCLICK,
1608 (wxObjectEventFunction) (wxEventFunction) (wxCommandEventFunction)
1609 &wxPropertyGrid::OnCustomEditorEvent, NULL, propGrid );
1610
1611 if ( property->GetChoiceInfo((wxPGChoiceInfo*)NULL) &&
1612 !property->IsValueUnspecified() )
1613 cb->m_state = 1;
1614
1615 // If mouse cursor was on the item, toggle the value now.
1616 if ( propGrid->GetInternalFlags() & wxPG_FL_ACTIVATION_BY_CLICK )
1617 {
1618 wxPoint pt = cb->ScreenToClient(::wxGetMousePosition());
1619 if ( pt.x <= (wxPG_XBEFORETEXT-2+cb->m_boxHeight) )
1620 {
1621 cb->m_state++;
1622
1623 if ( cb->m_state > 1 )
1624 cb->m_state = 0;
1625
1626 // Makes sure wxPG_EVT_CHANGING etc. is sent for this initial click
1627 propGrid->ChangePropertyValue(property, wxPGVariant_Bool(cb->m_state));
1628 }
1629 }
1630
1631 propGrid->SetInternalFlag( wxPG_FL_FIXED_WIDTH_EDITOR );
1632
1633 return cb;
1634 }
1635
1636 /*
1637 class wxPGCheckBoxRenderer : public wxPGDefaultRenderer
1638 {
1639 public:
1640
1641 virtual void Render( wxDC& dc, const wxRect& rect,
1642 const wxPropertyGrid* WXUNUSED(propertyGrid), wxPGProperty* property,
1643 int WXUNUSED(column), int WXUNUSED(item), int WXUNUSED(flags) ) const
1644 {
1645 int state = 0;
1646 if ( !(property->GetFlags() & wxPG_PROP_UNSPECIFIED) )
1647 {
1648 state = ((wxPGProperty*)property)->GetChoiceInfo((wxPGChoiceInfo*)NULL);
1649 if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
1650 }
1651 DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
1652 }
1653
1654 protected:
1655 };
1656
1657 wxPGCheckBoxRenderer g_wxPGCheckBoxRenderer;
1658
1659 wxPGCellRenderer* wxPGCheckBoxEditor::GetCellRenderer() const
1660 {
1661 return &g_wxPGCheckBoxRenderer;
1662 }
1663 */
1664
1665 void wxPGCheckBoxEditor::DrawValue( wxDC& dc, const wxRect& rect, wxPGProperty* property, const wxString& WXUNUSED(text) ) const
1666 {
1667 int state = 0;
1668 if ( !property->IsValueUnspecified() )
1669 {
1670 state = property->GetChoiceInfo((wxPGChoiceInfo*)NULL);
1671 if ( dc.GetFont().GetWeight() == wxBOLD ) state |= 2;
1672 }
1673 DrawSimpleCheckBox(dc,rect,dc.GetCharHeight(),state,dc.GetTextForeground());
1674 }
1675
1676 void wxPGCheckBoxEditor::UpdateControl( wxPGProperty* property, wxWindow* ctrl ) const
1677 {
1678 wxASSERT( ctrl );
1679 ((wxSimpleCheckBox*)ctrl)->m_state = property->GetChoiceInfo((wxPGChoiceInfo*)NULL);
1680 ctrl->Refresh();
1681 }
1682
1683
1684 bool wxPGCheckBoxEditor::OnEvent( wxPropertyGrid* WXUNUSED(propGrid), wxPGProperty* WXUNUSED(property),
1685 wxWindow* WXUNUSED(ctrl), wxEvent& event ) const
1686 {
1687 if ( event.GetEventType() == wxEVT_COMMAND_CHECKBOX_CLICKED )
1688 {
1689 return true;
1690 }
1691 return false;
1692 }
1693
1694
1695 bool wxPGCheckBoxEditor::GetValueFromControl( wxVariant& variant, wxPGProperty* property, wxWindow* ctrl ) const
1696 {
1697 wxSimpleCheckBox* cb = (wxSimpleCheckBox*)ctrl;
1698
1699 int index = cb->m_state;
1700
1701 if ( index != property->GetChoiceInfo( (wxPGChoiceInfo*) NULL ) ||
1702 // Changing unspecified always causes event (returning
1703 // true here should be enough to trigger it).
1704 property->IsValueUnspecified()
1705 )
1706 {
1707 return property->IntToValue(variant, index, 0);
1708 }
1709 return false;
1710 }
1711
1712
1713 void wxPGCheckBoxEditor::SetControlIntValue( wxPGProperty* WXUNUSED(property), wxWindow* ctrl, int value ) const
1714 {
1715 if ( value != 0 ) value = 1;
1716 ((wxSimpleCheckBox*)ctrl)->m_state = value;
1717 ctrl->Refresh();
1718 }
1719
1720
1721 void wxPGCheckBoxEditor::SetValueToUnspecified( wxPGProperty* WXUNUSED(property), wxWindow* ctrl ) const
1722 {
1723 ((wxSimpleCheckBox*)ctrl)->m_state = 0;
1724 ctrl->Refresh();
1725 }
1726
1727
1728 wxPGCheckBoxEditor::~wxPGCheckBoxEditor() { }
1729
1730
1731 #endif // wxPG_INCLUDE_CHECKBOX
1732
1733 // -----------------------------------------------------------------------
1734
1735 wxWindow* wxPropertyGrid::GetEditorControl() const
1736 {
1737 wxWindow* ctrl = m_wndEditor;
1738
1739 if ( !ctrl )
1740 return ctrl;
1741
1742 // If it's clipper window, return its child instead
1743 #if wxPG_ENABLE_CLIPPER_WINDOW
1744 if ( ctrl->IsKindOf(CLASSINFO(wxPGClipperWindow)) )
1745 {
1746 return ((wxPGClipperWindow*)ctrl)->GetControl();
1747 }
1748 #endif
1749
1750 return ctrl;
1751 }
1752
1753 // -----------------------------------------------------------------------
1754
1755 void wxPropertyGrid::CorrectEditorWidgetSizeX()
1756 {
1757 if ( m_selColumn == -1 )
1758 return;
1759
1760 int secWid = 0;
1761 int newSplitterx = m_pState->DoGetSplitterPosition(m_selColumn-1);
1762 int newWidth = newSplitterx + m_pState->m_colWidths[m_selColumn];
1763
1764 if ( m_wndEditor2 )
1765 {
1766 // if width change occurred, move secondary wnd by that amount
1767 wxRect r = m_wndEditor2->GetRect();
1768 secWid = r.width;
1769 r.x = newWidth - secWid;
1770
1771 m_wndEditor2->SetSize( r );
1772
1773 // if primary is textctrl, then we have to add some extra space
1774 #ifdef __WXMAC__
1775 if ( m_wndEditor )
1776 #else
1777 if ( m_wndEditor && m_wndEditor->IsKindOf(CLASSINFO(wxTextCtrl)) )
1778 #endif
1779 secWid += wxPG_TEXTCTRL_AND_BUTTON_SPACING;
1780 }
1781
1782 if ( m_wndEditor )
1783 {
1784 wxRect r = m_wndEditor->GetRect();
1785
1786 r.x = newSplitterx+m_ctrlXAdjust;
1787
1788 if ( !(m_iFlags & wxPG_FL_FIXED_WIDTH_EDITOR) )
1789 r.width = newWidth - r.x - secWid;
1790
1791 m_wndEditor->SetSize(r);
1792 }
1793
1794 if ( m_wndEditor2 )
1795 m_wndEditor2->Refresh();
1796 }
1797
1798 // -----------------------------------------------------------------------
1799
1800 void wxPropertyGrid::CorrectEditorWidgetPosY()
1801 {
1802 if ( m_selected && (m_wndEditor || m_wndEditor2) )
1803 {
1804 wxRect r = GetEditorWidgetRect(m_selected, m_selColumn);
1805
1806 if ( m_wndEditor )
1807 {
1808 wxPoint pos = m_wndEditor->GetPosition();
1809
1810 // Calculate y offset
1811 int offset = pos.y % m_lineHeight;
1812
1813 m_wndEditor->Move(pos.x, r.y + offset);
1814 }
1815
1816 if ( m_wndEditor2 )
1817 {
1818 wxPoint pos = m_wndEditor2->GetPosition();
1819
1820 m_wndEditor2->Move(pos.x, r.y);
1821 }
1822 }
1823 }
1824
1825 // -----------------------------------------------------------------------
1826
1827 bool wxPropertyGrid::AdjustPosForClipperWindow( wxWindow* topCtrlWnd, int* x, int* y )
1828 {
1829 #if wxPG_ENABLE_CLIPPER_WINDOW
1830 // Take clipper window into account
1831 if (topCtrlWnd->GetPosition().x < 1 &&
1832 !topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)))
1833 {
1834 topCtrlWnd = topCtrlWnd->GetParent();
1835 wxASSERT( topCtrlWnd->IsKindOf(CLASSINFO(wxPGClipperWindow)) );
1836 *x -= ((wxPGClipperWindow*)topCtrlWnd)->GetXClip();
1837 *y -= ((wxPGClipperWindow*)topCtrlWnd)->GetYClip();
1838 return true;
1839 }
1840 #else
1841 wxUnusedVar(topCtrlWnd);
1842 wxUnusedVar(x);
1843 wxUnusedVar(y);
1844 #endif
1845 return false;
1846 }
1847
1848 // -----------------------------------------------------------------------
1849
1850 // Fixes position of wxTextCtrl-like control (wxSpinCtrl usually
1851 // fits into that category as well).
1852 void wxPropertyGrid::FixPosForTextCtrl( wxWindow* ctrl, const wxPoint& offset )
1853 {
1854 // Center the control vertically
1855 wxRect finalPos = ctrl->GetRect();
1856 int y_adj = (m_lineHeight - finalPos.height)/2 + wxPG_TEXTCTRLYADJUST;
1857
1858 // Prevent over-sized control
1859 int sz_dec = (y_adj + finalPos.height) - m_lineHeight;
1860 if ( sz_dec < 0 ) sz_dec = 0;
1861
1862 finalPos.y += y_adj;
1863 finalPos.height -= (y_adj+sz_dec);
1864
1865 const int textCtrlXAdjust = wxPG_TEXTCTRLXADJUST;
1866
1867 finalPos.x += textCtrlXAdjust;
1868 finalPos.width -= textCtrlXAdjust;
1869
1870 finalPos.x += offset.x;
1871 finalPos.y += offset.y;
1872
1873 ctrl->SetSize(finalPos);
1874 }
1875
1876 // -----------------------------------------------------------------------
1877
1878 wxWindow* wxPropertyGrid::GenerateEditorTextCtrl( const wxPoint& pos,
1879 const wxSize& sz,
1880 const wxString& value,
1881 wxWindow* secondary,
1882 int extraStyle,
1883 int maxLen )
1884 {
1885 wxPGProperty* selected = m_selected;
1886 wxASSERT(selected);
1887
1888 int tcFlags = wxTE_PROCESS_ENTER | extraStyle;
1889
1890 if ( selected->HasFlag(wxPG_PROP_READONLY) )
1891 tcFlags |= wxTE_READONLY;
1892
1893 wxPoint p(pos.x,pos.y);
1894 wxSize s(sz.x,sz.y);
1895
1896 // Need to reduce width of text control on Mac
1897 #if defined(__WXMAC__)
1898 s.x -= 8;
1899 #endif
1900
1901 // Take button into acccount
1902 if ( secondary )
1903 {
1904 s.x -= (secondary->GetSize().x + wxPG_TEXTCTRL_AND_BUTTON_SPACING);
1905 m_iFlags &= ~(wxPG_FL_PRIMARY_FILLS_ENTIRE);
1906 }
1907
1908 // If the height is significantly higher, then use border, and fill the rect exactly.
1909 bool hasSpecialSize = false;
1910
1911 if ( (sz.y - m_lineHeight) > 5 )
1912 hasSpecialSize = true;
1913
1914 #if wxPG_NAT_TEXTCTRL_BORDER_ANY
1915
1916 // Create clipper window
1917 wxPGClipperWindow* wnd = new wxPGClipperWindow();
1918 #if defined(__WXMSW__)
1919 wnd->Hide();
1920 #endif
1921 wnd->Create(GetPanel(),wxPG_SUBID1,p,s);
1922
1923 // This generates rect of the control inside the clipper window
1924 if ( !hasSpecialSize )
1925 wnd->GetControlRect(wxPG_NAT_TEXTCTRL_BORDER_X, wxPG_NAT_TEXTCTRL_BORDER_Y, p, s);
1926 else
1927 wnd->GetControlRect(0, 0, p, s);
1928
1929 wxWindow* ctrlParent = wnd;
1930
1931 #else
1932
1933 wxWindow* ctrlParent = GetPanel();
1934
1935 if ( !hasSpecialSize )
1936 tcFlags |= wxNO_BORDER;
1937
1938 #endif
1939
1940 wxTextCtrl* tc = new wxTextCtrl();
1941
1942 #if defined(__WXMSW__) && !wxPG_NAT_TEXTCTRL_BORDER_ANY
1943 tc->Hide();
1944 #endif
1945 SetupTextCtrlValue(value);
1946 tc->Create(ctrlParent,wxPG_SUBID1,value, p, s,tcFlags);
1947
1948 #if wxPG_NAT_TEXTCTRL_BORDER_ANY
1949 wxWindow* ed = wnd;
1950 wnd->SetControl(tc);
1951 #else
1952 wxWindow* ed = tc;
1953 #endif
1954
1955 // Center the control vertically
1956 if ( !hasSpecialSize )
1957 FixPosForTextCtrl(ed);
1958
1959 #ifdef __WXMSW__
1960 ed->Show();
1961 if ( secondary )
1962 secondary->Show();
1963 #endif
1964
1965 // Set maximum length
1966 if ( maxLen > 0 )
1967 tc->SetMaxLength( maxLen );
1968
1969 return (wxWindow*) ed;
1970 }
1971
1972 // -----------------------------------------------------------------------
1973
1974 wxWindow* wxPropertyGrid::GenerateEditorButton( const wxPoint& pos, const wxSize& sz )
1975 {
1976 wxPGProperty* selected = m_selected;
1977 wxASSERT(selected);
1978
1979 #ifdef __WXMAC__
1980 // Decorations are chunky on Mac, and we can't make the button square, so
1981 // do things a bit differently on this platform.
1982
1983 wxPoint p(pos.x+sz.x,
1984 pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
1985 wxSize s(25, -1);
1986
1987 wxButton* but = new wxButton();
1988 but->Create(GetPanel(),wxPG_SUBID2,wxS("..."),p,s,wxWANTS_CHARS);
1989
1990 // Now that we know the size, move to the correct position
1991 p.x = pos.x + sz.x - but->GetSize().x - 2;
1992 but->Move(p);
1993
1994 #else
1995 wxSize s(sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2),
1996 sz.y-(wxPG_BUTTON_SIZEDEC*2)+(wxPG_NAT_BUTTON_BORDER_Y*2));
1997
1998 // Reduce button width to lineheight
1999 if ( s.x > m_lineHeight )
2000 s.x = m_lineHeight;
2001
2002 #ifdef __WXGTK__
2003 // On wxGTK, take fixed button margins into account
2004 if ( s.x < 25 )
2005 s.x = 25;
2006 #endif
2007
2008 wxPoint p(pos.x+sz.x-s.x,
2009 pos.y+wxPG_BUTTON_SIZEDEC-wxPG_NAT_BUTTON_BORDER_Y);
2010
2011 wxButton* but = new wxButton();
2012 #ifdef __WXMSW__
2013 but->Hide();
2014 #endif
2015 but->Create(GetPanel(),wxPG_SUBID2,wxS("..."),p,s,wxWANTS_CHARS);
2016
2017 #ifdef __WXGTK__
2018 wxFont font = GetFont();
2019 font.SetPointSize(font.GetPointSize()-2);
2020 but->SetFont(font);
2021 #else
2022 but->SetFont(GetFont());
2023 #endif
2024 #endif
2025
2026 if ( selected->HasFlag(wxPG_PROP_READONLY) )
2027 but->Disable();
2028
2029 return but;
2030 }
2031
2032 // -----------------------------------------------------------------------
2033
2034 wxWindow* wxPropertyGrid::GenerateEditorTextCtrlAndButton( const wxPoint& pos,
2035 const wxSize& sz,
2036 wxWindow** psecondary,
2037 int limitedEditing,
2038 wxPGProperty* property )
2039 {
2040 wxButton* but = (wxButton*)GenerateEditorButton(pos,sz);
2041 *psecondary = (wxWindow*)but;
2042
2043 if ( limitedEditing )
2044 {
2045 #ifdef __WXMSW__
2046 // There is button Show in GenerateEditorTextCtrl as well
2047 but->Show();
2048 #endif
2049 return (wxWindow*) NULL;
2050 }
2051
2052 wxString text;
2053
2054 if ( !property->IsValueUnspecified() )
2055 text = property->GetValueString(property->HasFlag(wxPG_PROP_READONLY)?0:wxPG_EDITABLE_VALUE);
2056
2057 return GenerateEditorTextCtrl(pos,sz,text,but,property->m_maxLen);
2058 }
2059
2060 // -----------------------------------------------------------------------
2061
2062 wxTextCtrl* wxPropertyGrid::GetEditorTextCtrl() const
2063 {
2064 wxWindow* wnd = GetEditorControl();
2065
2066 if ( !wnd )
2067 return NULL;
2068
2069 if ( wnd->IsKindOf(CLASSINFO(wxTextCtrl)) )
2070 return wxStaticCast(wnd, wxTextCtrl);
2071
2072 if ( wnd->IsKindOf(CLASSINFO(wxOwnerDrawnComboBox)) )
2073 {
2074 wxOwnerDrawnComboBox* cb = wxStaticCast(wnd, wxOwnerDrawnComboBox);
2075 return cb->GetTextCtrl();
2076 }
2077
2078 return NULL;
2079 }
2080
2081 // -----------------------------------------------------------------------
2082
2083 wxPGEditor* wxPropertyGridInterface::GetEditorByName( const wxString& editorName )
2084 {
2085 wxPGHashMapS2P::const_iterator it;
2086
2087 it = wxPGGlobalVars->m_mapEditorClasses.find(editorName);
2088 if ( it == wxPGGlobalVars->m_mapEditorClasses.end() )
2089 return NULL;
2090 return (wxPGEditor*) it->second;
2091 }
2092
2093 // -----------------------------------------------------------------------
2094 // wxPGEditorDialogAdapter
2095 // -----------------------------------------------------------------------
2096
2097 IMPLEMENT_ABSTRACT_CLASS(wxPGEditorDialogAdapter, wxObject)
2098
2099 bool wxPGEditorDialogAdapter::ShowDialog( wxPropertyGrid* propGrid, wxPGProperty* property )
2100 {
2101 if ( !propGrid->EditorValidate() )
2102 return false;
2103
2104 bool res = DoShowDialog( propGrid, property );
2105
2106 if ( res )
2107 {
2108 propGrid->ValueChangeInEvent( m_value );
2109 return true;
2110 }
2111
2112 return false;
2113 }
2114
2115 // -----------------------------------------------------------------------
2116 // wxPGMultiButton
2117 // -----------------------------------------------------------------------
2118
2119 wxPGMultiButton::wxPGMultiButton( wxPropertyGrid* pg, const wxSize& sz )
2120 : wxWindow( pg->GetPanel(), wxPG_SUBID2, wxPoint(-100,-100), wxSize(0, sz.y) ),
2121 m_fullEditorSize(sz), m_buttonsWidth(0)
2122 {
2123 SetBackgroundColour(pg->GetCellBackgroundColour());
2124 }
2125
2126 int wxPGMultiButton::GenId( int id ) const
2127 {
2128 if ( id < -1 )
2129 {
2130 if ( m_buttons.size() )
2131 id = GetButton(m_buttons.size()-1)->GetId() + 1;
2132 else
2133 id = wxPG_SUBID2;
2134 }
2135 return id;
2136 }
2137
2138 #if wxUSE_BMPBUTTON
2139 void wxPGMultiButton::Add( const wxBitmap& bitmap, int id )
2140 {
2141 id = GenId(id);
2142 wxSize sz = GetSize();
2143 wxButton* button = new wxBitmapButton( this, id, bitmap, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
2144 m_buttons.push_back(button);
2145 int bw = button->GetSize().x;
2146 SetSize(wxSize(sz.x+bw,sz.y));
2147 m_buttonsWidth += bw;
2148 }
2149 #endif
2150
2151 void wxPGMultiButton::Add( const wxString& label, int id )
2152 {
2153 id = GenId(id);
2154 wxSize sz = GetSize();
2155 wxButton* button = new wxButton( this, id, label, wxPoint(sz.x, 0), wxSize(sz.y, sz.y) );
2156 m_buttons.push_back(button);
2157 int bw = button->GetSize().x;
2158 SetSize(wxSize(sz.x+bw,sz.y));
2159 m_buttonsWidth += bw;
2160 }
2161
2162 // -----------------------------------------------------------------------
wxWidgets (Impactor)