← Back to branch summary

~brian-sidebotham/wxwidgets-cmake/wxpython-2.9.4

« back to all changes in this revision

Viewing changes to include/wx/propgrid/manager.h

  • Committer: Brian Sidebotham
  • Date: 2013-08-03 14:30:08 UTC
  • Revision ID: brian.sidebotham@gmail.com-20130803143008-c7806tkych1tp6fc
Initial import into Bazaar

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/wx/propgrid/manager.h
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        wx/propgrid/manager.h
 
3
// Purpose:     wxPropertyGridManager
 
4
// Author:      Jaakko Salli
 
5
// Modified by:
 
6
// Created:     2005-01-14
 
7
// RCS-ID:      $Id: manager.h 70937 2012-03-18 20:35:01Z JS $
 
8
// Copyright:   (c) Jaakko Salli
 
9
// Licence:     wxWindows licence
 
10
/////////////////////////////////////////////////////////////////////////////
 
11
 
 
12
#ifndef _WX_PROPGRID_MANAGER_H_
 
13
#define _WX_PROPGRID_MANAGER_H_
 
14
 
 
15
#include "wx/defs.h"
 
16
 
 
17
#if wxUSE_PROPGRID
 
18
 
 
19
#include "wx/propgrid/propgrid.h"
 
20
 
 
21
#include "wx/dcclient.h"
 
22
#include "wx/scrolwin.h"
 
23
#include "wx/toolbar.h"
 
24
#include "wx/stattext.h"
 
25
#include "wx/button.h"
 
26
#include "wx/textctrl.h"
 
27
#include "wx/dialog.h"
 
28
#include "wx/headerctrl.h"
 
29
 
 
30
// -----------------------------------------------------------------------
 
31
 
 
32
#ifndef SWIG
 
33
extern WXDLLIMPEXP_DATA_PROPGRID(const char) wxPropertyGridManagerNameStr[];
 
34
#endif
 
35
 
 
36
/** @class wxPropertyGridPage
 
37
 
 
38
    Holder of property grid page information. You can subclass this and
 
39
    give instance in wxPropertyGridManager::AddPage. It inherits from
 
40
    wxEvtHandler and can be used to process events specific to this
 
41
    page (id of events will still be same as manager's). If you don't
 
42
    want to use it to process all events of the page, you need to
 
43
    return false in the derived wxPropertyGridPage::IsHandlingAllEvents.
 
44
 
 
45
    Please note that wxPropertyGridPage lacks many non-const property
 
46
    manipulation functions found in wxPropertyGridManager. Please use
 
47
    parent manager (m_manager member variable) when needed.
 
48
 
 
49
    Please note that most member functions are inherited and as such not
 
50
    documented on this page. This means you will probably also want to read
 
51
    wxPropertyGridInterface class reference.
 
52
 
 
53
    @section propgridpage_event_handling Event Handling
 
54
 
 
55
    wxPropertyGridPage receives events emitted by its wxPropertyGridManager, but
 
56
    only those events that are specific to that page. If
 
57
    wxPropertyGridPage::IsHandlingAllEvents returns false, then unhandled
 
58
    events are sent to the manager's parent, as usual.
 
59
 
 
60
    See @ref propgrid_event_handling "wxPropertyGrid Event Handling"
 
61
    for more information.
 
62
 
 
63
    @library{wxpropgrid}
 
64
    @category{propgrid}
 
65
*/
 
66
class WXDLLIMPEXP_PROPGRID wxPropertyGridPage : public wxEvtHandler,
 
67
                                                public wxPropertyGridInterface,
 
68
                                                public wxPropertyGridPageState
 
69
{
 
70
    friend class wxPropertyGridManager;
 
71
    DECLARE_CLASS(wxPropertyGridPage)
 
72
public:
 
73
 
 
74
    wxPropertyGridPage();
 
75
    virtual ~wxPropertyGridPage();
 
76
 
 
77
    /** Deletes all properties on page.
 
78
    */
 
79
    virtual void Clear();
 
80
 
 
81
    /**
 
82
        Reduces column sizes to minimum possible that contents are still
 
83
        visibly (naturally some margin space will be applied as well).
 
84
 
 
85
        @return
 
86
        Minimum size for the page to still display everything.
 
87
 
 
88
        @remarks
 
89
        This function only works properly if size of containing grid was
 
90
        already fairly large.
 
91
 
 
92
        Note that you can also get calculated column widths by calling
 
93
        GetColumnWidth() immediately after this function returns.
 
94
    */
 
95
    wxSize FitColumns();
 
96
 
 
97
    /** Returns page index in manager;
 
98
    */
 
99
    inline int GetIndex() const;
 
100
 
 
101
    /** Returns x-coordinate position of splitter on a page.
 
102
    */
 
103
    int GetSplitterPosition( int col = 0 ) const
 
104
        { return GetStatePtr()->DoGetSplitterPosition(col); }
 
105
 
 
106
    /** Returns "root property". It does not have name, etc. and it is not
 
107
        visible. It is only useful for accessing its children.
 
108
    */
 
109
    wxPGProperty* GetRoot() const { return GetStatePtr()->DoGetRoot(); }
 
110
 
 
111
    /** Return pointer to contained property grid state.
 
112
    */
 
113
    wxPropertyGridPageState* GetStatePtr()
 
114
    {
 
115
        return this;
 
116
    }
 
117
 
 
118
    /** Return pointer to contained property grid state.
 
119
    */
 
120
    const wxPropertyGridPageState* GetStatePtr() const
 
121
    {
 
122
        return this;
 
123
    }
 
124
 
 
125
    /**
 
126
        Returns id of the tool bar item that represents this page on
 
127
        wxPropertyGridManager's wxToolBar.
 
128
    */
 
129
    int GetToolId() const
 
130
    {
 
131
        return m_toolId;
 
132
    }
 
133
 
 
134
    /** Do any member initialization in this method.
 
135
        @remarks
 
136
        - Called every time the page is added into a manager.
 
137
        - You can add properties to the page here.
 
138
    */
 
139
    virtual void Init() {}
 
140
 
 
141
    /** Return false here to indicate unhandled events should be
 
142
        propagated to manager's parent, as normal.
 
143
    */
 
144
    virtual bool IsHandlingAllEvents() const { return true; }
 
145
 
 
146
    /** Called every time page is about to be shown.
 
147
        Useful, for instance, creating properties just-in-time.
 
148
    */
 
149
    virtual void OnShow();
 
150
 
 
151
    virtual void RefreshProperty( wxPGProperty* p );
 
152
 
 
153
    /** Sets splitter position on page.
 
154
        @remarks
 
155
        Splitter position cannot exceed grid size, and therefore setting it
 
156
        during form creation may fail as initial grid size is often smaller
 
157
        than desired splitter position, especially when sizers are being used.
 
158
    */
 
159
    void SetSplitterPosition( int splitterPos, int col = 0 );
 
160
 
 
161
protected:
 
162
 
 
163
    /** Propagate to other pages.
 
164
    */
 
165
    virtual void DoSetSplitterPosition( int pos,
 
166
                                        int splitterColumn = 0,
 
167
                                        int flags = wxPG_SPLITTER_REFRESH );
 
168
 
 
169
    /** Page label (may be referred as name in some parts of documentation).
 
170
        Can be set in constructor, or passed in
 
171
        wxPropertyGridManager::AddPage(), but *not* in both.
 
172
    */
 
173
    wxString                m_label;
 
174
 
 
175
    //virtual bool ProcessEvent( wxEvent& event );
 
176
 
 
177
    wxPropertyGridManager*  m_manager;
 
178
 
 
179
    // Toolbar tool id. Note that this is only valid when the tool bar
 
180
    // exists.
 
181
    int                     m_toolId;
 
182
 
 
183
private:
 
184
    bool                    m_isDefault; // is this base page object?
 
185
 
 
186
    DECLARE_EVENT_TABLE()
 
187
};
 
188
 
 
189
// -----------------------------------------------------------------------
 
190
 
 
191
#if wxUSE_HEADERCTRL
 
192
class wxPGHeaderCtrl;
 
193
#endif
 
194
 
 
195
 
 
196
/** @class wxPropertyGridManager
 
197
 
 
198
    wxPropertyGridManager is an efficient multi-page version of wxPropertyGrid,
 
199
    which can optionally have toolbar for mode and page selection, and help
 
200
    text box.
 
201
    Use window flags to select components to include.
 
202
 
 
203
    @section propgridmanager_window_styles_ Window Styles
 
204
 
 
205
    See @ref propgrid_window_styles.
 
206
 
 
207
    @section propgridmanager_event_handling Event Handling
 
208
 
 
209
    See @ref propgrid_event_handling "wxPropertyGrid Event Handling"
 
210
    for more information.
 
211
 
 
212
    @library{wxpropgrid}
 
213
    @category{propgrid}
 
214
*/
 
215
class WXDLLIMPEXP_PROPGRID
 
216
    wxPropertyGridManager : public wxPanel, public wxPropertyGridInterface
 
217
{
 
218
    DECLARE_CLASS(wxPropertyGridManager)
 
219
    friend class wxPropertyGridPage;
 
220
public:
 
221
 
 
222
#ifndef SWIG
 
223
    /**
 
224
        Two step constructor.
 
225
        Call Create when this constructor is called to build up the
 
226
        wxPropertyGridManager.
 
227
      */
 
228
    wxPropertyGridManager();
 
229
#endif
 
230
 
 
231
    /** The default constructor. The styles to be used are styles valid for
 
232
        the wxWindow.
 
233
        @see @link wndflags Additional Window Styles@endlink
 
234
    */
 
235
    wxPropertyGridManager( wxWindow *parent, wxWindowID id = wxID_ANY,
 
236
                           const wxPoint& pos = wxDefaultPosition,
 
237
                           const wxSize& size = wxDefaultSize,
 
238
                           long style = wxPGMAN_DEFAULT_STYLE,
 
239
                           const wxString& name = wxPropertyGridManagerNameStr );
 
240
 
 
241
    /** Destructor */
 
242
    virtual ~wxPropertyGridManager();
 
243
 
 
244
    /** Creates new property page. Note that the first page is not created
 
245
        automatically.
 
246
        @param label
 
247
        A label for the page. This may be shown as a toolbar tooltip etc.
 
248
        @param bmp
 
249
        Bitmap image for toolbar. If wxNullBitmap is used, then a built-in
 
250
        default image is used.
 
251
        @param pageObj
 
252
        wxPropertyGridPage instance. Manager will take ownership of this object.
 
253
        NULL indicates that a default page instance should be created.
 
254
 
 
255
        @return
 
256
        Returns pointer to created page.
 
257
 
 
258
        @remarks
 
259
        If toolbar is used, it is highly recommended that the pages are
 
260
        added when the toolbar is not turned off using window style flag
 
261
        switching.
 
262
    */
 
263
    wxPropertyGridPage* AddPage( const wxString& label = wxEmptyString,
 
264
                                 const wxBitmap& bmp = wxPG_NULL_BITMAP,
 
265
                                 wxPropertyGridPage* pageObj = NULL )
 
266
    {
 
267
        return InsertPage(-1, label, bmp, pageObj);
 
268
    }
 
269
 
 
270
    /** Deletes all all properties and all pages.
 
271
    */
 
272
    virtual void Clear();
 
273
 
 
274
    /** Deletes all properties on given page.
 
275
    */
 
276
    void ClearPage( int page );
 
277
 
 
278
    /** Forces updating the value of property from the editor control.
 
279
        Returns true if DoPropertyChanged was actually called.
 
280
    */
 
281
    bool CommitChangesFromEditor( wxUint32 flags = 0 )
 
282
    {
 
283
        return m_pPropGrid->CommitChangesFromEditor(flags);
 
284
    }
 
285
 
 
286
    /**
 
287
        Two step creation.
 
288
        Whenever the control is created without any parameters, use Create to
 
289
        actually create it. Don't access the control's public methods before
 
290
        this is called.
 
291
        @see @link wndflags Additional Window Styles@endlink
 
292
    */
 
293
    bool Create( wxWindow *parent, wxWindowID id = wxID_ANY,
 
294
                 const wxPoint& pos = wxDefaultPosition,
 
295
                 const wxSize& size = wxDefaultSize,
 
296
                 long style = wxPGMAN_DEFAULT_STYLE,
 
297
                 const wxString& name = wxPropertyGridManagerNameStr );
 
298
 
 
299
    /**
 
300
        Enables or disables (shows/hides) categories according to parameter
 
301
        enable.
 
302
 
 
303
        WARNING: Not tested properly, use at your own risk.
 
304
    */
 
305
    bool EnableCategories( bool enable )
 
306
    {
 
307
        long fl = m_windowStyle | wxPG_HIDE_CATEGORIES;
 
308
        if ( enable ) fl = m_windowStyle & ~(wxPG_HIDE_CATEGORIES);
 
309
        SetWindowStyleFlag(fl);
 
310
        return true;
 
311
    }
 
312
 
 
313
    /** Selects page, scrolls and/or expands items to ensure that the
 
314
        given item is visible. Returns true if something was actually done.
 
315
    */
 
316
    bool EnsureVisible( wxPGPropArg id );
 
317
 
 
318
    /** Returns number of columns on given page. By the default,
 
319
        returns number of columns on current page. */
 
320
    int GetColumnCount( int page = -1 ) const;
 
321
 
 
322
    /** Returns height of the description text box. */
 
323
    int GetDescBoxHeight() const;
 
324
 
 
325
    /** Returns pointer to the contained wxPropertyGrid. This does not change
 
326
        after wxPropertyGridManager has been created, so you can safely obtain
 
327
        pointer once and use it for the entire lifetime of the instance.
 
328
    */
 
329
    wxPropertyGrid* GetGrid()
 
330
    {
 
331
        wxASSERT(m_pPropGrid);
 
332
        return m_pPropGrid;
 
333
    };
 
334
 
 
335
    const wxPropertyGrid* GetGrid() const
 
336
    {
 
337
        wxASSERT(m_pPropGrid);
 
338
        return (const wxPropertyGrid*)m_pPropGrid;
 
339
    };
 
340
 
 
341
    /** Returns iterator class instance.
 
342
        @remarks
 
343
        Calling this method in wxPropertyGridManager causes run-time assertion
 
344
        failure. Please only iterate through individual pages or use
 
345
        CreateVIterator().
 
346
    */
 
347
    wxPropertyGridIterator GetIterator( int flags = wxPG_ITERATE_DEFAULT,
 
348
                                        wxPGProperty* firstProp = NULL )
 
349
    {
 
350
        wxFAIL_MSG( "Please only iterate through individual pages "
 
351
                    "or use CreateVIterator()" );
 
352
        return wxPropertyGridInterface::GetIterator( flags, firstProp );
 
353
    }
 
354
 
 
355
    wxPropertyGridConstIterator
 
356
    GetIterator(int flags = wxPG_ITERATE_DEFAULT,
 
357
                wxPGProperty* firstProp = NULL) const
 
358
    {
 
359
        wxFAIL_MSG( "Please only iterate through individual pages "
 
360
                    " or use CreateVIterator()" );
 
361
        return wxPropertyGridInterface::GetIterator( flags, firstProp );
 
362
    }
 
363
 
 
364
    /** Returns iterator class instance.
 
365
        @remarks
 
366
        Calling this method in wxPropertyGridManager causes run-time assertion
 
367
        failure. Please only iterate through individual pages or use
 
368
        CreateVIterator().
 
369
    */
 
370
    wxPropertyGridIterator GetIterator( int flags, int startPos )
 
371
    {
 
372
        wxFAIL_MSG( "Please only iterate through individual pages "
 
373
                    "or use CreateVIterator()" );
 
374
 
 
375
        return wxPropertyGridInterface::GetIterator( flags, startPos );
 
376
    }
 
377
 
 
378
    wxPropertyGridConstIterator GetIterator( int flags, int startPos ) const
 
379
    {
 
380
        wxFAIL_MSG( "Please only iterate through individual pages "
 
381
                    "or use CreateVIterator()" );
 
382
        return wxPropertyGridInterface::GetIterator( flags, startPos );
 
383
    }
 
384
 
 
385
    /** Similar to GetIterator, but instead returns wxPGVIterator instance,
 
386
        which can be useful for forward-iterating through arbitrary property
 
387
        containers.
 
388
    */
 
389
    virtual wxPGVIterator GetVIterator( int flags ) const;
 
390
 
 
391
    /** Returns currently selected page.
 
392
    */
 
393
    wxPropertyGridPage* GetCurrentPage() const
 
394
    {
 
395
        return GetPage(m_selPage);
 
396
    }
 
397
 
 
398
    /** Returns page object for given page index.
 
399
    */
 
400
    wxPropertyGridPage* GetPage( unsigned int ind ) const
 
401
    {
 
402
        return m_arrPages[ind];
 
403
    }
 
404
 
 
405
    /** Returns page object for given page name.
 
406
    */
 
407
    wxPropertyGridPage* GetPage( const wxString& name ) const
 
408
    {
 
409
        return GetPage(GetPageByName(name));
 
410
    }
 
411
 
 
412
    /**
 
413
        Returns index for a page name.
 
414
 
 
415
        If no match is found, wxNOT_FOUND is returned.
 
416
     */
 
417
    int GetPageByName( const wxString& name ) const;
 
418
 
 
419
    /** Returns index for a relevant propertygrid state.
 
420
 
 
421
        If no match is found, wxNOT_FOUND is returned.
 
422
    */
 
423
    int GetPageByState( const wxPropertyGridPageState* pstate ) const;
 
424
 
 
425
protected:
 
426
    /** Returns wxPropertyGridPageState of given page, current page's for -1.
 
427
    */
 
428
    virtual wxPropertyGridPageState* GetPageState( int page ) const;
 
429
 
 
430
public:
 
431
    /** Returns number of managed pages. */
 
432
    size_t GetPageCount() const;
 
433
 
 
434
    /** Returns name of given page. */
 
435
    const wxString& GetPageName( int index ) const;
 
436
 
 
437
    /** Returns "root property" of the given page. It does not have name, etc.
 
438
        and it is not visible. It is only useful for accessing its children.
 
439
    */
 
440
    wxPGProperty* GetPageRoot( int index ) const;
 
441
 
 
442
    /** Returns index to currently selected page. */
 
443
    int GetSelectedPage() const { return m_selPage; }
 
444
 
 
445
    /** Alias for GetSelection(). */
 
446
    wxPGProperty* GetSelectedProperty() const
 
447
    {
 
448
        return GetSelection();
 
449
    }
 
450
 
 
451
    /** Shortcut for GetGrid()->GetSelection(). */
 
452
    wxPGProperty* GetSelection() const
 
453
    {
 
454
        return m_pPropGrid->GetSelection();
 
455
    }
 
456
 
 
457
    /** Returns a pointer to the toolbar currently associated with the
 
458
        wxPropertyGridManager (if any). */
 
459
    wxToolBar* GetToolBar() const { return m_pToolbar; }
 
460
 
 
461
    /** Creates new property page. Note that the first page is not created
 
462
        automatically.
 
463
        @param index
 
464
        Add to this position. -1 will add as the last item.
 
465
        @param label
 
466
        A label for the page. This may be shown as a toolbar tooltip etc.
 
467
        @param bmp
 
468
        Bitmap image for toolbar. If wxNullBitmap is used, then a built-in
 
469
        default image is used.
 
470
        @param pageObj
 
471
        wxPropertyGridPage instance. Manager will take ownership of this object.
 
472
        If NULL, default page object is constructed.
 
473
 
 
474
        @return
 
475
        Returns pointer to created page.
 
476
    */
 
477
    virtual wxPropertyGridPage* InsertPage( int index,
 
478
                                            const wxString& label,
 
479
                                            const wxBitmap& bmp = wxNullBitmap,
 
480
                                            wxPropertyGridPage* pageObj = NULL );
 
481
 
 
482
    /**
 
483
        Returns true if any property on any page has been modified by the user.
 
484
    */
 
485
    bool IsAnyModified() const;
 
486
 
 
487
    /**
 
488
        Returns true if updating is frozen (ie Freeze() called but not yet
 
489
        Thaw() ).
 
490
     */
 
491
    bool IsFrozen() const { return m_pPropGrid->m_frozen > 0; }
 
492
 
 
493
    /**
 
494
        Returns true if any property on given page has been modified by the
 
495
        user.
 
496
     */
 
497
    bool IsPageModified( size_t index ) const;
 
498
 
 
499
    /**
 
500
        Returns true if property is selected. Since selection is page
 
501
        based, this function checks every page in the manager.
 
502
    */
 
503
    virtual bool IsPropertySelected( wxPGPropArg id ) const;
 
504
 
 
505
    virtual void Refresh( bool eraseBackground = true,
 
506
                          const wxRect* rect = (const wxRect*) NULL );
 
507
 
 
508
    /** Removes a page.
 
509
        @return
 
510
        Returns false if it was not possible to remove page in question.
 
511
    */
 
512
    virtual bool RemovePage( int page );
 
513
 
 
514
    /** Select and displays a given page.
 
515
 
 
516
        @param index
 
517
            Index of page being seleced. Can be -1 to select nothing.
 
518
    */
 
519
    void SelectPage( int index );
 
520
 
 
521
    /** Select and displays a given page (by label). */
 
522
    void SelectPage( const wxString& label )
 
523
    {
 
524
        int index = GetPageByName(label);
 
525
        wxCHECK_RET( index >= 0, wxT("No page with such name") );
 
526
        SelectPage( index );
 
527
    }
 
528
 
 
529
    /** Select and displays a given page. */
 
530
    void SelectPage( wxPropertyGridPage* ptr )
 
531
    {
 
532
        SelectPage( GetPageByState(ptr) );
 
533
    }
 
534
 
 
535
    /** Select a property. */
 
536
    bool SelectProperty( wxPGPropArg id, bool focus = false )
 
537
    {
 
538
        wxPG_PROP_ARG_CALL_PROLOG_RETVAL(false)
 
539
        return p->GetParentState()->DoSelectProperty(p, focus);
 
540
    }
 
541
 
 
542
    /**
 
543
        Sets a column title. Default title for column 0 is "Property",
 
544
        and "Value" for column 1.
 
545
 
 
546
        @remarks If header is not shown yet, then calling this
 
547
                 member function will make it visible.
 
548
    */
 
549
    void SetColumnTitle( int idx, const wxString& title );
 
550
 
 
551
    /**
 
552
        Sets number of columns on given page (default is current page).
 
553
 
 
554
        @remarks If you use header, then you should always use this
 
555
                 member function to set the column count, instead of
 
556
                 ones present in wxPropertyGrid or wxPropertyGridPage.
 
557
    */
 
558
    void SetColumnCount( int colCount, int page = -1 );
 
559
 
 
560
    /** Sets label and text in description box.
 
561
    */
 
562
    void SetDescription( const wxString& label, const wxString& content );
 
563
 
 
564
    /** Sets y coordinate of the description box splitter. */
 
565
    void SetDescBoxHeight( int ht, bool refresh = true );
 
566
 
 
567
    /** Moves splitter as left as possible, while still allowing all
 
568
        labels to be shown in full.
 
569
        @param subProps
 
570
        If false, will still allow sub-properties (ie. properties which
 
571
        parent is not root or category) to be cropped.
 
572
        @param allPages
 
573
        If true, takes labels on all pages into account.
 
574
    */
 
575
    void SetSplitterLeft( bool subProps = false, bool allPages = true );
 
576
 
 
577
    /** Moves splitter as left as possible on an individual page, while still allowing all
 
578
        labels to be shown in full.
 
579
    */
 
580
    void SetPageSplitterLeft(int page, bool subProps = false);
 
581
 
 
582
    /**
 
583
        Sets splitter position on individual page.
 
584
 
 
585
        @remarks If you use header, then you should always use this
 
586
                 member function to set the splitter position, instead of
 
587
                 ones present in wxPropertyGrid or wxPropertyGridPage.
 
588
    */
 
589
    void SetPageSplitterPosition( int page, int pos, int column = 0 );
 
590
 
 
591
    /**
 
592
        Sets splitter position for all pages.
 
593
 
 
594
        @remarks Splitter position cannot exceed grid size, and therefore
 
595
                 setting it during form creation may fail as initial grid
 
596
                 size is often smaller than desired splitter position,
 
597
                 especially when sizers are being used.
 
598
 
 
599
                 If you use header, then you should always use this
 
600
                 member function to set the splitter position, instead of
 
601
                 ones present in wxPropertyGrid or wxPropertyGridPage.
 
602
    */
 
603
    void SetSplitterPosition( int pos, int column = 0 );
 
604
 
 
605
#if wxUSE_HEADERCTRL
 
606
    /**
 
607
        Show or hide the property grid header control. It is hidden
 
608
        by the default.
 
609
 
 
610
        @remarks Grid may look better if you use wxPG_NO_INTERNAL_BORDER
 
611
                 window style when showing a header.
 
612
    */
 
613
    void ShowHeader(bool show = true);
 
614
#endif
 
615
 
 
616
protected:
 
617
 
 
618
    //
 
619
    // Subclassing helpers
 
620
    //
 
621
 
 
622
    /**
 
623
        Creates property grid for the manager. Reimplement in derived class to
 
624
        use subclassed wxPropertyGrid. However, if you do this then you
 
625
        must also use the two-step construction (ie. default constructor and
 
626
        Create() instead of constructor with arguments) when creating the
 
627
        manager.
 
628
    */
 
629
    virtual wxPropertyGrid* CreatePropertyGrid() const;
 
630
 
 
631
public:
 
632
    virtual void RefreshProperty( wxPGProperty* p );
 
633
 
 
634
    //
 
635
    // Overridden functions - no documentation required.
 
636
    //
 
637
 
 
638
    void SetId( wxWindowID winid );
 
639
 
 
640
    virtual void Freeze();
 
641
    virtual void Thaw();
 
642
    virtual void SetExtraStyle ( long exStyle );
 
643
    virtual bool SetFont ( const wxFont& font );
 
644
    virtual void SetWindowStyleFlag ( long style );
 
645
    virtual bool Reparent( wxWindowBase *newParent );
 
646
 
 
647
protected:
 
648
    virtual wxSize DoGetBestSize() const;
 
649
 
 
650
    //
 
651
    // Event handlers
 
652
    //
 
653
    void OnMouseMove( wxMouseEvent &event );
 
654
    void OnMouseClick( wxMouseEvent &event );
 
655
    void OnMouseUp( wxMouseEvent &event );
 
656
    void OnMouseEntry( wxMouseEvent &event );
 
657
 
 
658
    void OnPaint( wxPaintEvent &event );
 
659
 
 
660
    void OnToolbarClick( wxCommandEvent &event );
 
661
    void OnResize( wxSizeEvent& event );
 
662
    void OnPropertyGridSelect( wxPropertyGridEvent& event );
 
663
    void OnPGColDrag( wxPropertyGridEvent& event );
 
664
 
 
665
 
 
666
    wxPropertyGrid* m_pPropGrid;
 
667
 
 
668
    wxVector<wxPropertyGridPage*>   m_arrPages;
 
669
 
 
670
#if wxUSE_TOOLBAR
 
671
    wxToolBar*      m_pToolbar;
 
672
#endif
 
673
#if wxUSE_HEADERCTRL
 
674
    wxPGHeaderCtrl* m_pHeaderCtrl;
 
675
#endif
 
676
    wxStaticText*   m_pTxtHelpCaption;
 
677
    wxStaticText*   m_pTxtHelpContent;
 
678
 
 
679
    wxPropertyGridPage*     m_emptyPage;
 
680
 
 
681
    wxArrayString   m_columnLabels;
 
682
 
 
683
    long            m_iFlags;
 
684
 
 
685
    // Selected page index.
 
686
    int             m_selPage;
 
687
 
 
688
    int             m_width;
 
689
 
 
690
    int             m_height;
 
691
 
 
692
    int             m_extraHeight;
 
693
 
 
694
    int             m_splitterY;
 
695
 
 
696
    int             m_splitterHeight;
 
697
 
 
698
    int             m_dragOffset;
 
699
 
 
700
    wxCursor        m_cursorSizeNS;
 
701
 
 
702
    int             m_nextDescBoxSize;
 
703
 
 
704
    // Toolbar tool ids for categorized and alphabetic mode selectors.
 
705
    int             m_categorizedModeToolId;
 
706
    int             m_alphabeticModeToolId;
 
707
 
 
708
    unsigned char   m_dragStatus;
 
709
 
 
710
    unsigned char   m_onSplitter;
 
711
 
 
712
    bool            m_showHeader;
 
713
 
 
714
    virtual wxPGProperty* DoGetPropertyByName( const wxString& name ) const;
 
715
 
 
716
    /** Select and displays a given page. */
 
717
    virtual bool DoSelectPage( int index );
 
718
 
 
719
    // Sets some members to defaults.
 
720
    void Init1();
 
721
 
 
722
    // Initializes some members.
 
723
    void Init2( int style );
 
724
 
 
725
/*#ifdef __WXMSW__
 
726
    virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const;
 
727
#endif*/
 
728
 
 
729
    virtual bool ProcessEvent( wxEvent& event );
 
730
 
 
731
    /** Recalculates new positions for components, according to the
 
732
        given size.
 
733
    */
 
734
    void RecalculatePositions( int width, int height );
 
735
 
 
736
    /** (Re)creates/destroys controls, according to the window style bits. */
 
737
    void RecreateControls();
 
738
 
 
739
    void UpdateDescriptionBox( int new_splittery, int new_width, int new_height );
 
740
 
 
741
    void RepaintDescBoxDecorations( wxDC& dc,
 
742
                                    int newSplitterY,
 
743
                                    int newWidth,
 
744
                                    int newHeight );
 
745
 
 
746
    void SetDescribedProperty( wxPGProperty* p );
 
747
 
 
748
    // Reimplement these to handle "descboxheight" state item
 
749
    virtual bool SetEditableStateItem( const wxString& name, wxVariant value );
 
750
    virtual wxVariant GetEditableStateItem( const wxString& name ) const;
 
751
 
 
752
private:
 
753
    DECLARE_EVENT_TABLE()
 
754
};
 
755
 
 
756
// -----------------------------------------------------------------------
 
757
 
 
758
inline int wxPropertyGridPage::GetIndex() const
 
759
{
 
760
    if ( !m_manager )
 
761
        return wxNOT_FOUND;
 
762
    return m_manager->GetPageByState(this);
 
763
}
 
764
 
 
765
// -----------------------------------------------------------------------
 
766
 
 
767
#endif // wxUSE_PROPGRID
 
768
 
 
769
#endif // _WX_PROPGRID_MANAGER_H_