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