interface/wx/xrc/xmlres.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        xrc/xmlres.h
   3 // Purpose:     interface of wxXmlResource
   4 // Author:      wxWidgets team
   5 // Licence:     wxWindows licence
   6 /////////////////////////////////////////////////////////////////////////////
   7
   8 /**
   9     Flags which can be used with wxXmlResource::wxXmlResource.
  10 */
  11 enum wxXmlResourceFlags
  12 {
  13     /** Translatable strings will be translated via _(). */
  14     wxXRC_USE_LOCALE     = 1,
  15
  16     /** Subclass property of object nodes will be ignored (useful for previews in XRC editors). */
  17     wxXRC_NO_SUBCLASSING = 2,
  18
  19     /** Prevent the XRC files from being reloaded from disk in case they have been modified there
  20         since being last loaded (may slightly speed up loading them). */
  21     wxXRC_NO_RELOADING   = 4
  22 };
  23
  24
  25 /**
  26     @class wxXmlResource
  27
  28     This is the main class for interacting with the XML-based resource system.
  29
  30     The class holds XML resources from one or more .xml files, binary files or zip
  31     archive files.
  32
  33     Note that this is a singleton class and you'll never allocate/deallocate it.
  34     Just use the static wxXmlResource::Get() getter.
  35
  36     @see @ref overview_xrc, @ref overview_xrcformat
  37
  38     @library{wxxrc}
  39     @category{xrc}
  40 */
  41 class wxXmlResource : public wxObject
  42 {
  43 public:
  44     /**
  45         Constructor.
  46
  47         @param filemask
  48             The XRC file, archive file, or wildcard specification that will be
  49             used to load all resource files inside a zip archive.
  50         @param flags
  51             One or more value of the ::wxXmlResourceFlags enumeration.
  52         @param domain
  53             The name of the gettext catalog to search for translatable strings.
  54             By default all loaded catalogs will be searched.
  55             This provides a way to allow the strings to only come from a specific catalog.
  56     */
  57     wxXmlResource(const wxString& filemask,
  58                   int flags = wxXRC_USE_LOCALE,
  59                   const wxString& domain = wxEmptyString);
  60
  61     /**
  62         Constructor.
  63
  64         @param flags
  65             One or more value of the ::wxXmlResourceFlags enumeration.
  66         @param domain
  67             The name of the gettext catalog to search for translatable strings.
  68             By default all loaded catalogs will be searched.
  69             This provides a way to allow the strings to only come from a specific catalog.
  70     */
  71     wxXmlResource(int flags = wxXRC_USE_LOCALE,
  72                   const wxString& domain = wxEmptyString);
  73
  74     /**
  75         Destructor.
  76     */
  77     virtual ~wxXmlResource();
  78
  79     /**
  80         Initializes only a specific handler (or custom handler).
  81         Convention says that the handler name is equal to the control's name plus
  82         'XmlHandler', for example wxTextCtrlXmlHandler, wxHtmlWindowXmlHandler.
  83
  84         The XML resource compiler (wxxrc) can create include file that contains
  85         initialization code for all controls used within the resource.
  86         Note that this handler must be allocated on the heap, since it will be
  87         deleted by ClearHandlers() later.
  88     */
  89     void AddHandler(wxXmlResourceHandler* handler);
  90
  91     /**
  92        Add a new handler at the begining of the handler list.
  93      */
  94     void InsertHandler(wxXmlResourceHandler *handler);
  95
  96
  97     /**
  98         Attaches an unknown control to the given panel/window/dialog.
  99         Unknown controls are used in conjunction with \<object class="unknown"\>.
 100     */
 101     bool AttachUnknownControl(const wxString& name,
 102                               wxWindow* control,
 103                               wxWindow* parent = NULL);
 104
 105     /**
 106         Removes all handlers and deletes them (this means that any handlers
 107         added using AddHandler() must be allocated on the heap).
 108     */
 109     void ClearHandlers();
 110
 111     /**
 112        Registers subclasses factory for use in XRC.  This is useful only for
 113        language bindings developers who need a way to implement subclassing in
 114        wxWidgets ports that don't support wxRTTI (e.g. wxPython).
 115     */
 116     static void AddSubclassFactory(wxXmlSubclassFactory *factory);
 117
 118
 119     /**
 120         Compares the XRC version to the argument.
 121
 122         Returns -1 if the XRC version is less than the argument,
 123         +1 if greater, and 0 if they are equal.
 124     */
 125     int CompareVersion(int major, int minor, int release, int revision) const;
 126
 127     /**
 128         Returns a string ID corresponding to the given numeric ID.
 129
 130         The string returned is such that calling GetXRCID() with it as
 131         parameter yields @a numId. If there is no string identifier
 132         corresponding to the given numeric one, an empty string is returned.
 133
 134         Notice that, unlike GetXRCID(), this function is slow as it checks all
 135         of the identifiers used in XRC.
 136
 137         @since 2.9.0
 138      */
 139     static wxString FindXRCIDById(int numId);
 140
 141     /**
 142         Gets the global resources object or creates one if none exists.
 143     */
 144     static wxXmlResource* Get();
 145
 146     /**
 147         Returns the domain (message catalog) that will be used to load
 148         translatable strings in the XRC.
 149     */
 150     const wxString& GetDomain() const;
 151
 152     /**
 153         Returns flags, which may be a bitlist of ::wxXmlResourceFlags
 154         enumeration values.
 155     */
 156     int GetFlags() const;
 157
 158     /**
 159         Returns the wxXmlNode containing the definition of the object with the
 160         given name or @NULL.
 161
 162         This function recursively searches all the loaded XRC files for an
 163         object with the specified @a name. If the object is found, the
 164         wxXmlNode corresponding to it is returned, so this function can be used
 165         to access additional information defined in the XRC file and not used
 166         by wxXmlResource itself, e.g. contents of application-specific XML
 167         tags.
 168
 169         @param name
 170             The name of the resource which must be unique for this function to
 171             work correctly, if there is more than one resource with the given
 172             name the choice of the one returned by this function is undefined.
 173         @return
 174             The node corresponding to the resource with the given name or @NULL.
 175     */
 176     const wxXmlNode *GetResourceNode(const wxString& name) const;
 177
 178     /**
 179         Returns version information (a.b.c.d = d + 256*c + 2562*b + 2563*a).
 180     */
 181     long GetVersion() const;
 182
 183     /**
 184         Returns a numeric ID that is equivalent to the string ID used in an XML resource.
 185
 186         If an unknown @a str_id is requested (i.e. other than wxID_XXX or integer),
 187         a new record is created which associates the given string with a number.
 188
 189         If @a value_if_not_found is @c wxID_NONE, the number is obtained via
 190         wxNewId(). Otherwise @a value_if_not_found is used.
 191
 192         Macro @c XRCID(name) is provided for convenient use in event tables.
 193
 194         @note IDs returned by XRCID() cannot be used with the <tt>EVT_*_RANGE</tt>
 195               macros, because the order in which they are assigned to symbolic @a name
 196               values is not guaranteed.
 197     */
 198     static int GetXRCID(const wxString& str_id, int value_if_not_found = wxID_NONE);
 199
 200     /**
 201         Initializes handlers for all supported controls/windows.
 202
 203         This will make the executable quite big because it forces linking against
 204         most of the wxWidgets library.
 205     */
 206     void InitAllHandlers();
 207
 208     /**
 209         Loads resources from XML files that match given filemask.
 210
 211         Example:
 212         @code
 213             if (!wxXmlResource::Get()->Load("rc/*.xrc"))
 214                 wxLogError("Couldn't load resources!");
 215         @endcode
 216
 217         @note
 218         If wxUSE_FILESYS is enabled, this method understands wxFileSystem URLs
 219         (see wxFileSystem::FindFirst()).
 220
 221         @note
 222         If you are sure that the argument is name of single XRC file (rather
 223         than an URL or a wildcard), use LoadFile() instead.
 224
 225         @see LoadFile(), LoadAllFiles()
 226     */
 227     bool Load(const wxString& filemask);
 228
 229     /**
 230         Simpler form of Load() for loading a single XRC file.
 231
 232         @since 2.9.0
 233
 234         @see Load(), LoadAllFiles()
 235     */
 236     bool LoadFile(const wxFileName& file);
 237
 238     /**
 239         Loads all .xrc files from directory @a dirname.
 240
 241         Tries to load as many files as possible; if there's an error while
 242         loading one file, it still attempts to load other files.
 243
 244         @since 2.9.0
 245
 246         @see LoadFile(), Load()
 247     */
 248     bool LoadAllFiles(const wxString& dirname);
 249
 250     /**
 251         Loads a bitmap resource from a file.
 252     */
 253     wxBitmap LoadBitmap(const wxString& name);
 254
 255     /**
 256         Loads a dialog. @a parent points to parent window (if any).
 257     */
 258     wxDialog* LoadDialog(wxWindow* parent, const wxString& name);
 259
 260     /**
 261         Loads a dialog. @a parent points to parent window (if any).
 262
 263         This form is used to finish creation of an already existing instance (the main
 264         reason for this is that you may want to use derived class with a new event table).
 265         Example:
 266
 267         @code
 268           MyDialog dlg;
 269           wxXmlResource::Get()->LoadDialog(&dlg, mainFrame, "my_dialog");
 270           dlg.ShowModal();
 271         @endcode
 272     */
 273     bool LoadDialog(wxDialog* dlg, wxWindow* parent, const wxString& name);
 274
 275     /**
 276        Loads a frame from the resource. @a parent points to parent window (if any).
 277     */
 278     wxFrame *LoadFrame(wxWindow* parent, const wxString& name);
 279
 280     /**
 281         Loads the contents of a frame onto an existing wxFrame.
 282
 283         This form is used to finish creation of an already existing instance
 284         (the main reason for this is that you may want to use derived class
 285         with a new event table).
 286     */
 287     bool LoadFrame(wxFrame* frame, wxWindow* parent,
 288                    const wxString& name);
 289
 290     /**
 291         Loads an icon resource from a file.
 292     */
 293     wxIcon LoadIcon(const wxString& name);
 294
 295     /**
 296         Loads menu from resource. Returns @NULL on failure.
 297     */
 298     wxMenu* LoadMenu(const wxString& name);
 299
 300     //@{
 301     /**
 302         Loads a menubar from resource. Returns @NULL on failure.
 303     */
 304     wxMenuBar* LoadMenuBar(wxWindow* parent, const wxString& name);
 305     wxMenuBar* LoadMenuBar(const wxString& name);
 306     //@}
 307
 308     //@{
 309     /**
 310         Load an object from the resource specifying both the resource name and the
 311         class name.
 312
 313         The first overload lets you load nonstandard container windows and returns
 314         @NULL on failure. The second one lets you finish the creation of an existing
 315         instance and returns @false on failure.
 316
 317         In either case, only the resources defined at the top level of XRC
 318         files can be loaded by this function, use LoadObjectRecursively() if
 319         you need to load an object defined deeper in the hierarchy.
 320     */
 321     wxObject* LoadObject(wxWindow* parent, const wxString& name,
 322                          const wxString& classname);
 323     bool LoadObject(wxObject* instance, wxWindow* parent,
 324                     const wxString& name,
 325                     const wxString& classname);
 326     //@}
 327
 328     //@{
 329     /**
 330         Load an object from anywhere in the resource tree.
 331
 332         These methods are similar to LoadObject() but may be used to load an
 333         object from anywhere in the resource tree and not only the top level.
 334         Note that you will very rarely need to do this as in normal use the
 335         entire container window (defined at the top level) is loaded and not
 336         its individual children but this method can be useful in some
 337         particular situations.
 338
 339         @since 2.9.1
 340     */
 341     wxObject* LoadObjectRecursively(wxWindow* parent,
 342                                     const wxString& name,
 343                                     const wxString& classname);
 344     bool LoadObjectRecursively(wxObject* instance, wxWindow* parent,
 345                     const wxString& name,
 346                     const wxString& classname);
 347     //@}
 348
 349     /**
 350         Loads a panel. @a parent points to the parent window.
 351     */
 352     wxPanel* LoadPanel(wxWindow* parent, const wxString& name);
 353
 354     /**
 355         Loads a panel. @a parent points to the parent window.
 356         This form is used to finish creation of an already existing instance.
 357     */
 358     bool LoadPanel(wxPanel* panel, wxWindow* parent, const wxString& name);
 359
 360     /**
 361         Loads a toolbar.
 362     */
 363     wxToolBar* LoadToolBar(wxWindow* parent, const wxString& name);
 364
 365     /**
 366         Sets the global resources object and returns a pointer to the previous one
 367         (may be @NULL).
 368     */
 369     static wxXmlResource* Set(wxXmlResource* res);
 370
 371     /**
 372         Sets the domain (message catalog) that will be used to load
 373         translatable strings in the XRC.
 374     */
 375     void SetDomain(const wxString& domain);
 376
 377     /**
 378         Sets flags (bitlist of ::wxXmlResourceFlags enumeration values).
 379     */
 380     void SetFlags(int flags);
 381
 382     /**
 383         This function unloads a resource previously loaded by Load().
 384
 385         Returns @true if the resource was successfully unloaded and @false if it
 386         hasn't been found in the list of loaded resources.
 387     */
 388     bool Unload(const wxString& filename);
 389
 390 protected:
 391     /**
 392         Reports error in XRC resources to the user.
 393
 394         Any errors in XRC input files should be reported using this method
 395         (or its wxXmlResourceHandler::ReportError() equivalent). Unlike
 396         wxLogError(), this method presents the error to the user in a more
 397         usable form. In particular, the output is compiler-like and contains
 398         information about the exact location of the error.
 399
 400         @param context XML node the error occurred in or relates to. This can
 401                        be @NULL, but should be the most specific node possible,
 402                        as its line number is what is reported to the user.
 403         @param message Text of the error message. This string should always
 404                        be in English (i.e. not wrapped in _()). It shouldn't
 405                        be a sentence -- it should start with lower-case letter
 406                        and shouldn't have a trailing period or exclamation
 407                        point.
 408
 409         @since 2.9.0
 410
 411         @see wxXmlResourceHandler::ReportError(), DoReportError()
 412      */
 413     void ReportError(const wxXmlNode *context, const wxString& message);
 414
 415     /**
 416         Implementation of XRC resources errors reporting.
 417
 418         This method is called by ReportError() and shouldn't be called
 419         directly; use ReportError() or wxXmlResourceHandler::ReportError()
 420         to log errors.
 421
 422         Default implementation uses wxLogError().
 423
 424         @param xrcFile  File the error occurred in or empty string if it
 425                         couldn't be determined.
 426         @param position XML node where the error occurred or @NULL if it
 427                         couldn't be determined.
 428         @param message  Text of the error message. See ReportError()
 429                         documentation for details of the string's format.
 430
 431         @note
 432         You may override this method in a derived class to customize errors
 433         reporting. If you do so, you'll need to either use the derived class
 434         in all your code or call wxXmlResource::Set() to change the global
 435         wxXmlResource instance to your class.
 436
 437         @since 2.9.0
 438
 439         @see ReportError()
 440     */
 441     virtual void DoReportError(const wxString& xrcFile, const wxXmlNode *position,
 442                                const wxString& message);
 443 };
 444
 445
 446
 447 /**
 448     @class wxXmlResourceHandler
 449
 450     wxXmlResourceHandler is an abstract base class for resource handlers
 451     capable of creating a control from an XML node.
 452
 453     See @ref overview_xrc for details.
 454
 455     @library{wxxrc}
 456     @category{xrc}
 457 */
 458 class wxXmlResourceHandler : public wxObject
 459 {
 460 public:
 461     /**
 462         Default constructor.
 463     */
 464     wxXmlResourceHandler();
 465
 466     /**
 467         Destructor.
 468     */
 469     virtual ~wxXmlResourceHandler();
 470
 471     /**
 472         Creates an object (menu, dialog, control, ...) from an XML node.
 473         Should check for validity. @a parent is a higher-level object
 474         (usually window, dialog or panel) that is often necessary to
 475         create the resource.
 476
 477         If @b instance is non-@NULL it should not create a new instance via
 478         'new' but should rather use this one, and call its Create method.
 479     */
 480     wxObject* CreateResource(wxXmlNode* node, wxObject* parent,
 481                              wxObject* instance);
 482
 483     /**
 484         Called from CreateResource after variables were filled.
 485     */
 486     virtual wxObject* DoCreateResource() = 0;
 487
 488     /**
 489         Returns @true if it understands this node and can create
 490         a resource from it, @false otherwise.
 491
 492         @note
 493         You must not call any wxXmlResourceHandler methods except IsOfClass()
 494         from this method! The instance is not yet initialized with node data
 495         at the time CanHandle() is called and it is only safe to operate on
 496         node directly or to call IsOfClass().
 497     */
 498     virtual bool CanHandle(wxXmlNode* node) = 0;
 499
 500     /**
 501         Sets the parent resource.
 502     */
 503     void SetParentResource(wxXmlResource* res);
 504
 505
 506 protected:
 507
 508     /**
 509         Add a style flag (e.g. @c wxMB_DOCKABLE) to the list of flags
 510         understood by this handler.
 511     */
 512     void AddStyle(const wxString& name, int value);
 513
 514     /**
 515         Add styles common to all wxWindow-derived classes.
 516     */
 517     void AddWindowStyles();
 518
 519     /**
 520         Creates children.
 521     */
 522     void CreateChildren(wxObject* parent, bool this_hnd_only = false);
 523
 524     /**
 525         Helper function.
 526     */
 527     void CreateChildrenPrivately(wxObject* parent,
 528                                  wxXmlNode* rootnode = NULL);
 529
 530     /**
 531         Creates a resource from a node.
 532     */
 533     wxObject* CreateResFromNode(wxXmlNode* node, wxObject* parent,
 534                                 wxObject* instance = NULL);
 535
 536     /**
 537         Creates an animation (see wxAnimation) from the filename specified in @a param.
 538     */
 539     wxAnimation* GetAnimation(const wxString& param = "animation");
 540
 541     /**
 542         Gets a bitmap.
 543     */
 544     wxBitmap GetBitmap(const wxString& param = "bitmap",
 545                        const wxArtClient& defaultArtClient = wxART_OTHER,
 546                        wxSize size = wxDefaultSize);
 547     /**
 548         Gets a bitmap from an XmlNode.
 549
 550         @since 2.9.1
 551     */
 552     wxBitmap GetBitmap(const wxXmlNode* node,
 553                        const wxArtClient& defaultArtClient = wxART_OTHER,
 554                        wxSize size = wxDefaultSize);
 555
 556     /**
 557         Gets a bool flag (1, t, yes, on, true are @true, everything else is @false).
 558     */
 559     bool GetBool(const wxString& param, bool defaultv = false);
 560
 561     /**
 562         Gets colour in HTML syntax (\#RRGGBB).
 563     */
 564     wxColour GetColour(const wxString& param,
 565                        const wxColour& defaultColour = wxNullColour);
 566
 567     /**
 568         Returns the current file system.
 569     */
 570     wxFileSystem& GetCurFileSystem();
 571
 572     /**
 573         Gets a dimension (may be in dialog units).
 574     */
 575     wxCoord GetDimension(const wxString& param, wxCoord defaultv = 0,
 576                          wxWindow* windowToUse = 0);
 577
 578     /**
 579         Gets a direction.
 580
 581         If the given @a param is not present or has empty value, @a dirDefault is
 582         returned by default. Otherwise the value of the parameter is parsed and
 583         a warning is generated if it's not one of @c wxLEFT, @c wxTOP, @c
 584         wxRIGHT or @c wxBOTTOM.
 585
 586         @since 2.9.3
 587      */
 588     wxDirection GetDirection(const wxString& param, wxDirection dirDefault = wxLEFT);
 589
 590     /**
 591         Gets a font.
 592     */
 593     wxFont GetFont(const wxString& param = "font");
 594
 595     /**
 596         Returns the XRCID.
 597     */
 598     int GetID();
 599
 600     /**
 601         Returns an icon.
 602     */
 603     wxIcon GetIcon(const wxString& param = "icon",
 604                    const wxArtClient& defaultArtClient = wxART_OTHER,
 605                    wxSize size = wxDefaultSize);
 606
 607     /**
 608         Gets an icon from an XmlNode.
 609
 610         @since 2.9.1
 611     */
 612     wxIcon GetIcon(const wxXmlNode* node,
 613                    const wxArtClient& defaultArtClient = wxART_OTHER,
 614                    wxSize size = wxDefaultSize);
 615
 616     /**
 617         Returns an icon bundle.
 618
 619         @note
 620         Bundles can be loaded either with stock IDs or from files that contain
 621         more than one image (e.g. Windows icon files). If a file contains only
 622         single image, a bundle with only one icon will be created.
 623
 624         @since 2.9.0
 625      */
 626     wxIconBundle GetIconBundle(const wxString& param,
 627                                const wxArtClient& defaultArtClient = wxART_OTHER);
 628
 629     /**
 630         Creates an image list from the @a param markup data.
 631
 632         @return
 633             The new instance of wxImageList or @NULL if no data is found.
 634
 635         @since 2.9.1
 636     */
 637     wxImageList *GetImageList(const wxString& param = "imagelist");
 638
 639     /**
 640         Gets the integer value from the parameter.
 641     */
 642     long GetLong(const wxString& param, long defaultv = 0);
 643
 644     /**
 645         Gets a float value from the parameter.
 646     */
 647     float GetFloat(const wxString& param, float defaultv = 0);
 648
 649     /**
 650         Returns the resource name.
 651     */
 652     wxString GetName();
 653
 654     /**
 655         Gets node content from wxXML_ENTITY_NODE.
 656     */
 657     wxString GetNodeContent(wxXmlNode* node);
 658
 659     /**
 660         Finds the node or returns @NULL.
 661     */
 662     wxXmlNode* GetParamNode(const wxString& param);
 663
 664     /**
 665         Finds the parameter value or returns the empty string.
 666     */
 667     wxString GetParamValue(const wxString& param);
 668
 669     /**
 670         Returns the node parameter value.
 671
 672         @since 2.9.1
 673     */
 674     wxString GetParamValue(const wxXmlNode* node);
 675
 676     /**
 677         Gets the position (may be in dialog units).
 678     */
 679     wxPoint GetPosition(const wxString& param = "pos");
 680
 681     /**
 682         Gets the size (may be in dialog units).
 683     */
 684     wxSize GetSize(const wxString& param = "size", wxWindow* windowToUse = 0);
 685
 686     /**
 687         Gets style flags from text in form "flag | flag2| flag3 |..."
 688         Only understands flags added with AddStyle().
 689     */
 690     int GetStyle(const wxString& param = "style", int defaults = 0);
 691
 692     /**
 693         Gets text from param and does some conversions:
 694         - replaces \\n, \\r, \\t by respective characters (according to C syntax)
 695         - replaces @c $ by @c  and @c $$ by @c $ (needed for @c _File to @c File
 696           translation because of XML syntax)
 697         - calls wxGetTranslations (unless disabled in wxXmlResource)
 698     */
 699     wxString GetText(const wxString& param, bool translate = true);
 700
 701     /**
 702         Check to see if a parameter exists.
 703     */
 704     bool HasParam(const wxString& param);
 705
 706     /**
 707         Convenience function.
 708         Returns @true if the node has a property class equal to classname,
 709         e.g. object class="wxDialog".
 710     */
 711     bool IsOfClass(wxXmlNode* node, const wxString& classname);
 712
 713     /**
 714         Sets common window options.
 715     */
 716     void SetupWindow(wxWindow* wnd);
 717
 718     /**
 719         Reports error in XRC resources to the user.
 720
 721         See wxXmlResource::ReportError() for more information.
 722
 723         @since 2.9.0
 724      */
 725     void ReportError(wxXmlNode *context, const wxString& message);
 726
 727     /**
 728         Like ReportError(wxXmlNode*, const wxString&), but uses the node
 729         of currently processed object (m_node) as the context.
 730
 731         @since 2.9.0
 732      */
 733     void ReportError(const wxString& message);
 734
 735     /**
 736         Like ReportError(wxXmlNode*, const wxString&), but uses the node
 737         of parameter @a param of the currently processed object as the context.
 738         This is convenience function for reporting errors in particular
 739         parameters.
 740
 741         @since 2.9.0
 742      */
 743     void ReportParamError(const wxString& param, const wxString& message);
 744
 745
 746     /**
 747        After CreateResource has been called this will return the current
 748        wxXmlResource object.
 749
 750        @since 2.9.5
 751     */
 752     wxXmlResource* GetResource() const;
 753
 754     /**
 755        After CreateResource has been called this will return the XML node
 756        being processed.
 757
 758        @since 2.9.5
 759     */
 760     wxXmlNode* GetNode() const;
 761
 762     /**
 763        After CreateResource has been called this will return the class name of
 764        the XML resource node being processed.
 765
 766        @since 2.9.5
 767     */
 768     wxString GetClass() const;
 769
 770     /**
 771        After CreateResource has been called this will return the current
 772        item's parent, if any.
 773
 774        @since 2.9.5
 775     */
 776     wxObject* GetParent() const;
 777
 778     /**
 779        After CreateResource has been called this will return the instance that
 780        the XML resource content should be created upon, if it has already been
 781        created.  If @NULL then the handler should create the object itself.
 782
 783        @since 2.9.5
 784     */
 785     wxObject* GetInstance() const;
 786
 787     /**
 788        After CreateResource has been called this will return the item's parent
 789        as a wxWindow.
 790
 791        @since 2.9.5
 792     */
 793     wxWindow* GetParentAsWindow() const;
 794 };
 795