source: OGRE/trunk/ogre_dependencies/Dependencies/include/CEGUI/CEGUIWindowProperties.h @ 692

Revision 692, 50.2 KB checked in by mattausch, 19 years ago (diff)

adding ogre 1.2 and dependencies

Line 
1/************************************************************************
2        filename:       CEGUIWindowProperties.h
3        created:        5/7/2004
4        author:         Paul D Turner
5       
6        purpose:        Interface to available window base class properties
7*************************************************************************/
8/*************************************************************************
9    Crazy Eddie's GUI System (http://www.cegui.org.uk)
10    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
11
12    This library is free software; you can redistribute it and/or
13    modify it under the terms of the GNU Lesser General Public
14    License as published by the Free Software Foundation; either
15    version 2.1 of the License, or (at your option) any later version.
16
17    This library is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20    Lesser General Public License for more details.
21
22    You should have received a copy of the GNU Lesser General Public
23    License along with this library; if not, write to the Free Software
24    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25*************************************************************************/
26#ifndef _CEGUIWindowProperties_h_
27#define _CEGUIWindowProperties_h_
28
29#include "CEGUIProperty.h"
30
31
32// Start of CEGUI namespace section
33namespace CEGUI
34{
35
36// Start of WindowProperties namespace section
37/*!
38\brief
39        Namespace containing all classes that make up the properties interface for the Window base class
40*/
41namespace WindowProperties
42{
43/*!
44\brief
45        Property to access minimum window size.
46
47        This property offers access to the minimum size setting for the window, using screen relative metrics.
48
49        \par Usage:
50                - Name: RelativeMinSize
51                - Format: "w:[float] h:[float]".
52
53        \par Where:
54                - w:[float]     specifies the minimum width as a floating point number.
55                - h:[float] specifies the minimum height as a floating point number.
56*/
57class RelativeMinSize : public Property
58{
59public:
60        RelativeMinSize() : Property(
61                "RelativeMinSize",
62                "Property to get/set the minimum size for the Window.  Value is \"w:[float] h:[float]\" using relative metrics (this setting is relative to the display size).",
63                "w:0.000000 h:0.000000", false)
64        {}
65
66        String  get(const PropertyReceiver* receiver) const;
67        void    set(PropertyReceiver* receiver, const String& value);
68};
69
70
71/*!
72\brief
73        Property to access maximum window size.
74
75        This property offers access to the maximum size setting for the window, using screen relative metrics.
76
77        \par Usage:
78                - Name: RelativeMaxSize
79                - Format: "w:[float] h:[float]".
80
81        \par Where:
82                - w:[float]     specifies the maximum width as a floating point number.
83                - h:[float] specifies the maximum height as a floating point number.
84*/
85class RelativeMaxSize : public Property
86{
87public:
88        RelativeMaxSize() : Property(
89                "RelativeMaxSize",
90                "Property to get/set the maximum size for the Window.  Value is \"w:[float] h:[float]\" using relative metrics (this setting is relative to the display size).",
91                "w:1.000000 h:1.000000", false)
92        {}
93
94        String  get(const PropertyReceiver* receiver) const;
95        void    set(PropertyReceiver* receiver, const String& value);
96};
97
98
99/*!
100\brief
101        Property to access minimum window size.
102
103        This property offers access to the minimum size setting for the window, using absolute screen pixel metrics.
104
105        \par Usage:
106                - Name: AbsoluteMinSize
107                - Format: "w:[float] h:[float]".
108
109        \par Where:
110                - w:[float]     specifies the minimum width as a floating point number.
111                - h:[float] specifies the minimum height as a floating point number.
112*/
113class AbsoluteMinSize : public Property
114{
115public:
116        AbsoluteMinSize() : Property(
117                "AbsoluteMinSize",
118                "Property to get/set the minimum size for the Window.  Value is \"w:[float] h:[float]\" using absolute (pixel) metrics.",
119                "w:0.000000 h:0.000000", false)
120        {}
121
122        String  get(const PropertyReceiver* receiver) const;
123        void    set(PropertyReceiver* receiver, const String& value);
124};
125
126
127/*!
128\brief
129        Property to access maximum window size.
130
131        This property offers access to the maximum size setting for the window, using absolute screen pixel metrics.
132
133        \par Usage:
134                - Name: AbsoluteMaxSize
135                - Format: "w:[float] h:[float]".
136
137        \par Where:
138                - w:[float]     specifies the maximum width as a floating point number.
139                - h:[float] specifies the maximum height as a floating point number.
140*/
141class AbsoluteMaxSize : public Property
142{
143public:
144        AbsoluteMaxSize() : Property(
145                "AbsoluteMaxSize",
146                "Property to get/set the maximum size for the Window.  Value is \"w:[float] h:[float]\" using absolute (pixel) metrics.",
147                "", false)
148                {}
149
150        String  get(const PropertyReceiver* receiver) const;
151        void    set(PropertyReceiver* receiver, const String& value);
152
153        // default depends upon current size of display.
154        bool    isDefault(const PropertyReceiver* receiver) const;
155        String  getDefault(const PropertyReceiver* receiver) const;
156};
157
158
159/*!
160\brief
161        Property to access the metrics mode setting.
162
163        This property offers access to the metrics mode setting for the window.
164
165        \par Usage:
166                - Name: MetricsMode
167                - Format: "[text]".
168
169        \par Where [text] is:
170                - "Relative" for the relative metrics mode.
171                - "Absolute" for the absolute metrics mode.
172                - "Inherited" if metrics should be inherited from the parent (only used with set method).
173*/
174class MetricsMode : public Property
175{
176public:
177        MetricsMode() : Property(
178                "MetricsMode",
179                "Property to get/set the metrics mode for the Window.  Value is \"Relative\", \"Absolute\", or \"Inherited\".",
180                "Relative")
181        {}
182
183        String  get(const PropertyReceiver* receiver) const;
184        void    set(PropertyReceiver* receiver, const String& value);
185};
186
187
188/*!
189\brief
190        Property to access window ID field.
191
192        This property offers access to the client specified ID for the window.
193
194        \par Usage:
195                - Name: ID
196                - Format: "[uint]".
197
198        \par Where:
199                - [uint] is any unsigned integer value.
200*/
201class ID : public Property
202{
203public:
204        ID() : Property(
205                "ID",
206                "Property to get/set the ID value of the Window.  Value is an unsigned integer number.",
207                "0")
208        {}
209
210        String  get(const PropertyReceiver* receiver) const;
211        void    set(PropertyReceiver* receiver, const String& value);
212};
213
214
215/*!
216\brief
217        Property to access window alpha setting.
218
219        This property offers access to the alpha-blend setting for the window.
220
221        \par Usage:
222                - Name: Alpha
223                - Format: "[float]".
224
225        \par Where:
226                - [float] is a floating point number between 0.0 and 1.0.
227*/
228class Alpha : public Property
229{
230public:
231        Alpha() : Property(
232                "Alpha",
233                "Property to get/set the alpha value of the Window.  Value is floating point number.",
234                "1.000000")
235        {}
236
237        String  get(const PropertyReceiver* receiver) const;
238        void    set(PropertyReceiver* receiver, const String& value);
239};
240
241
242/*!
243\brief
244        Property to access window Font setting.
245
246        This property offers access to the current Font setting for the window.
247
248        \par Usage:
249                - Name: Font
250                - Format: "[text]".
251
252        \par Where:
253                - [text] is the name of the Font to assign for this window.  The Font specified must already be loaded.
254*/
255class Font : public Property
256{
257public:
258        Font() : Property(
259                "Font",
260                "Property to get/set the font for the Window.  Value is the name of the font to use (must be loaded already).",
261                "")
262        {}
263
264        String  get(const PropertyReceiver* receiver) const;
265        void    set(PropertyReceiver* receiver, const String& value);
266        bool    isDefault(const PropertyReceiver* receiver) const;
267};
268
269
270/*!
271\brief
272        Property to access window text setting.
273
274        This property offers access to the current text for the window.
275
276        \par Usage:
277                - Name: Text
278                - Format: "[text]".
279
280        \par Where:
281                - [text] is the name of the Font to assign for this window.  The Font specified must already be loaded.
282*/
283class Text : public Property
284{
285public:
286        Text() : Property(
287                "Text",
288                "Property to get/set the text / caption for the Window.  Value is the text string to use.",
289                "")
290        {}
291
292        String  get(const PropertyReceiver* receiver) const;
293        void    set(PropertyReceiver* receiver, const String& value);
294};
295
296
297/*!
298\brief
299        Property to access window mouse cursor setting.
300
301        This property offers access to the current mouse cursor image for the window.
302
303        \par Usage:
304                - Name: MouseCursorImage
305                - Format: "set:[text] image:[text]".
306
307        \par Where:
308                - set:[text] is the name of the Imageset containing the image.  The Imageset name should not contain spaces.  The Imageset specified must already be loaded.
309                - image:[text] is the name of the Image on the specified Imageset.  The Image name should not contain spaces.
310*/
311class MouseCursorImage : public Property
312{
313public:
314        MouseCursorImage() : Property(
315                "MouseCursorImage",
316                "Property to get/set the mouse cursor image for the Window.  Value should be \"set:<imageset name> image:<image name>\".",
317                "")
318        {}
319
320        String  get(const PropertyReceiver* receiver) const;
321        void    set(PropertyReceiver* receiver, const String& value);
322        bool    isDefault(const PropertyReceiver* receiver) const;
323};
324
325
326/*!
327\brief
328        Property to access window "clipped by parent" setting.
329
330        This property offers access to the clipped by parent setting for the window.
331
332        \par Usage:
333                - Name: ClippedByParent
334                - Format: "[text]".
335
336        \par Where [Text] is:
337                - "True" to indicate the Window is clipped by it's parent.
338                - "False" to indicate the Window is not clipped by it's parent.
339*/
340class ClippedByParent : public Property
341{
342public:
343        ClippedByParent() : Property(
344                "ClippedByParent",
345                "Property to get/set the 'clipped by parent' setting for the Window.  Value is either \"True\" or \"False\".",
346                "True")
347        {}
348
349        String  get(const PropertyReceiver* receiver) const;
350        void    set(PropertyReceiver* receiver, const String& value);
351};
352
353
354/*!
355\brief
356        Property to access window "Inherits Alpha" setting.
357
358        This property offers access to the inherits alpha setting for the window.
359
360        \par Usage:
361                - Name: InheritsAlpha
362                - Format: "[text]".
363
364        \par Where [Text] is:
365                - "True" to indicate the Window inherits alpha blend values from it's ancestors.
366                - "False" to indicate the Window does not inherit alpha blend values from it's ancestors.
367*/
368class InheritsAlpha : public Property
369{
370public:
371        InheritsAlpha() : Property(
372                "InheritsAlpha",
373                "Property to get/set the 'inherits alpha' setting for the Window.  Value is either \"True\" or \"False\".",
374                "True")
375        {}
376
377        String  get(const PropertyReceiver* receiver) const;
378        void    set(PropertyReceiver* receiver, const String& value);
379};
380
381
382/*!
383\brief
384        Property to access window "Always-On-Top" setting.
385
386        This property offers access to the always on top / topmost setting for the window.
387
388        \par Usage:
389                - Name: AlwaysOnTop
390                - Format: "[text]".
391
392        \par Where [Text] is:
393                - "True" to indicate the Window is always on top, and appears above all other non-always on top Windows.
394                - "False" to indicate the Window is not always on top, and will appear below all other always on top Windows.
395*/
396class AlwaysOnTop : public Property
397{
398public:
399        AlwaysOnTop() : Property(
400                "AlwaysOnTop",
401                "Property to get/set the 'always on top' setting for the Window.  Value is either \"True\" or \"False\".",
402                "False")
403        {}
404
405        String  get(const PropertyReceiver* receiver) const;
406        void    set(PropertyReceiver* receiver, const String& value);
407};
408
409
410/*!
411\brief
412        Property to access window Disabled setting.
413
414        This property offers access to the enabled / disabled setting for the window.
415
416        \par Usage:
417                - Name: Disabled
418                - Format: "[text]".
419
420        \par Where [Text] is:
421                - "True" to indicate the Window is disabled, and will normally receive no inputs from the user.
422                - "False" to indicate the Window is not disabled and will receive inputs from the user as normal.
423*/
424class Disabled : public Property
425{
426public:
427        Disabled() : Property(
428                "Disabled",
429                "Property to get/set the 'disabled state' setting for the Window.  Value is either \"True\" or \"False\".",
430                "False")
431        {}
432
433        String  get(const PropertyReceiver* receiver) const;
434        void    set(PropertyReceiver* receiver, const String& value);
435        bool    isDefault(const PropertyReceiver* receiver) const;
436};
437
438
439/*!
440\brief
441        Property to access window Visible setting.
442
443        This property offers access to the visible setting for the window.
444
445        \par Usage:
446                - Name: Visible
447                - Format: "[text]".
448
449        \par Where [Text] is:
450                - "True" to indicate the Window is visible.
451                - "False" to indicate the Window is not visible.
452*/
453class Visible : public Property
454{
455public:
456        Visible() : Property(
457                "Visible",
458                "Property to get/set the 'visible state' setting for the Window.  Value is either \"True\" or \"False\".",
459                "True")
460        {}
461
462        String  get(const PropertyReceiver* receiver) const;
463        void    set(PropertyReceiver* receiver, const String& value);
464        bool    isDefault(const PropertyReceiver* receiver) const;
465};
466
467
468/*!
469\brief
470        Property to access window Restore Old Capture setting.
471
472        This property offers access to the restore old capture setting for the window.  This setting is of generally limited use, it
473        is primary purpose is for certain operations required for compound widgets.
474
475        \par Usage:
476                - Name: RestoreOldCapture
477                - Format: "[text]".
478
479        \par Where [Text] is:
480                - "True" to indicate the Window should restore any previous capture Window when it loses input capture.
481                - "False" to indicate the Window should not restore the old capture Window.  This is the default behaviour.
482*/
483class RestoreOldCapture : public Property
484{
485public:
486        RestoreOldCapture() : Property(
487                "RestoreOldCapture",
488                "Property to get/set the 'restore old capture' setting for the Window.  Value is either \"True\" or \"False\".",
489                "False")
490        {}
491
492        String  get(const PropertyReceiver* receiver) const;
493        void    set(PropertyReceiver* receiver, const String& value);
494};
495
496
497/*!
498\brief
499        Property to access window Destroyed by Parent setting.
500
501        This property offers access to the destryed by parent setting for the window.
502
503        \par Usage:
504                - Name: DestroyedByParent
505                - Format: "[text]".
506
507        \par Where [Text] is:
508                - "True" to indicate the Window should be automatically destroyed when it's parent Window is destroyed.
509                - "False" to indicate the Window should not be destroyed when it's parent Window is destroyed.
510*/
511class DestroyedByParent : public Property
512{
513public:
514        DestroyedByParent() : Property(
515                "DestroyedByParent",
516                "Property to get/set the 'destroyed by parent' setting for the Window.  Value is either \"True\" or \"False\".",
517                "True")
518        {}
519
520        String  get(const PropertyReceiver* receiver) const;
521        void    set(PropertyReceiver* receiver, const String& value);
522};
523
524
525/*!
526\brief
527        Property to access window width.
528
529        This property offers access to the Width setting for the window, using the Windows active metrics mode.
530
531        \par Usage:
532                - Name: Width
533                - Format: "[float]".
534
535        \par Where:
536                - [float]       specifies the width as a floating point number, using the active metrics system for the Window.
537*/
538class Width : public Property
539{
540public:
541        Width() : Property(
542                "Width",
543                "Property to get/set the width of the Window.  Value is floating point using the active metrics mode.",
544                "0.000000", false) {}
545
546        String  get(const PropertyReceiver* receiver) const;
547        void    set(PropertyReceiver* receiver, const String& value);
548};
549
550
551/*!
552\brief
553        Property to access window width.
554
555        This property offers access to the Width setting for the window, using the relative metrics mode.
556
557        \par Usage:
558                - Name: RelativeWidth
559                - Format: "[float]".
560
561        \par Where:
562                - [float]       specifies the width as a floating point number, using the relative metrics system.
563*/
564class RelativeWidth : public Property
565{
566public:
567        RelativeWidth() : Property(
568                "RelativeWidth",
569                "Property to get/set the width of the Window.  Value is floating point using relative metrics.",
570                "0.000000", false)
571        {}
572
573        String  get(const PropertyReceiver* receiver) const;
574        void    set(PropertyReceiver* receiver, const String& value);
575};
576
577
578/*!
579\brief
580        Property to access window width.
581
582        This property offers access to the Width setting for the window, using the absolute metrics mode.
583
584        \par Usage:
585                - Name: AbsoluteWidth
586                - Format: "[float]".
587
588        \par Where:
589                - [float]       specifies the width as a floating point number, using the absolute metrics system.
590*/
591class AbsoluteWidth: public Property
592{
593public:
594        AbsoluteWidth() : Property(
595                "AbsoluteWidth",
596                "Property to get/set the width of the Window.  Value is floating point using absolute metrics.",
597                "0.000000", false)
598        {}
599
600        String  get(const PropertyReceiver* receiver) const;
601        void    set(PropertyReceiver* receiver, const String& value);
602};
603
604
605/*!
606\brief
607        Property to access window height.
608
609        This property offers access to the Height setting for the window, using the Windows active metrics mode.
610
611        \par Usage:
612                - Name: Height
613                - Format: "[float]".
614
615        \par Where:
616                - [float]       specifies the height as a floating point number, using the active metrics system for the Window.
617*/
618class Height : public Property
619{
620public:
621        Height() : Property(
622                "Height",
623                "Property to get/set the height of the Window.  Value is floating point using the active metrics mode.",
624                "0.000000", false)
625        {}
626
627        String  get(const PropertyReceiver* receiver) const;
628        void    set(PropertyReceiver* receiver, const String& value);
629};
630
631
632/*!
633\brief
634        Property to access window height.
635
636        This property offers access to the Height setting for the window, using the relative metrics mode.
637
638        \par Usage:
639                - Name: RelativeHeight
640                - Format: "[float]".
641
642        \par Where:
643                - [float]       specifies the height as a floating point number, using the relative metrics system.
644*/
645class RelativeHeight : public Property
646{
647public:
648        RelativeHeight() : Property(
649                "RelativeHeight",
650                "Property to get/set the height of the Window.  Value is floating point using relative metrics.",
651                "0.000000", false)
652        {}
653
654        String  get(const PropertyReceiver* receiver) const;
655        void    set(PropertyReceiver* receiver, const String& value);
656};
657
658
659/*!
660\brief
661        Property to access window height.
662
663        This property offers access to the Height setting for the window, using the absolute metrics mode.
664
665        \par Usage:
666                - Name: AbsoluteHeight
667                - Format: "[float]".
668
669        \par Where:
670                - [float]       specifies the height as a floating point number, using the absolute metrics system.
671*/
672class AbsoluteHeight : public Property
673{
674public:
675        AbsoluteHeight() : Property(
676                "AbsoluteHeight",
677                "Property to get/set the height of the Window.  Value is floating point using absolute metrics.",
678                "0.000000", false)
679        {}
680
681        String  get(const PropertyReceiver* receiver) const;
682        void    set(PropertyReceiver* receiver, const String& value);
683};
684
685
686/*!
687\brief
688        Property to access the window size.
689
690        This property offers access to the size setting for the window, using the Windows active metrics mode.
691
692        \par Usage:
693                - Name: Size
694                - Format: "w:[float] h:[float]".
695
696        \par Where:
697                - w:[float]     specifies the minimum width as a floating point number, using the active metrics system for the Window.
698                - h:[float] specifies the minimum height as a floating point number, using the active metrics system for the Window.
699*/
700class Size : public Property
701{
702public:
703        Size() : Property(
704                "Size",
705                "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using the active metrics mode.",
706                "w:0.000000 h:0.000000", false)
707        {}
708
709        String  get(const PropertyReceiver* receiver) const;
710        void    set(PropertyReceiver* receiver, const String& value);
711};
712
713
714/*!
715\brief
716        Property to access the window size.
717
718        This property offers access to the size setting for the window, using the relative metrics system.
719
720        \par Usage:
721                - Name: RelativeSize
722                - Format: "w:[float] h:[float]".
723
724        \par Where:
725                - w:[float]     specifies the minimum width as a floating point number, using the relative metrics system.
726                - h:[float] specifies the minimum height as a floating point number, using the relative metrics system.
727*/
728class RelativeSize : public Property
729{
730public:
731        RelativeSize() : Property(
732                "RelativeSize",
733                "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using relative metrics.",
734                "w:0.000000 h:0.000000", false)
735        {}
736
737        String  get(const PropertyReceiver* receiver) const;
738        void    set(PropertyReceiver* receiver, const String& value);
739};
740
741
742/*!
743\brief
744        Property to access the window size.
745
746        This property offers access to the size setting for the window, using the absolute metrics system.
747
748        \par Usage:
749                - Name: AbsoluteSize
750                - Format: "w:[float] h:[float]".
751
752        \par Where:
753                - w:[float]     specifies the minimum width as a floating point number, using the absolute metrics system.
754                - h:[float] specifies the minimum height as a floating point number, using the absolute metrics system.
755*/
756class AbsoluteSize : public Property
757{
758public:
759        AbsoluteSize() : Property(
760                "AbsoluteSize",
761                "Property to get/set the size of the Window.  Value is \"w:[float] h:[float]\" using absolute metrics.",
762                "w:0.000000 h:0.000000", false)
763        {}
764
765        String  get(const PropertyReceiver* receiver) const;
766        void    set(PropertyReceiver* receiver, const String& value);
767};
768
769
770/*!
771\brief
772        Property to access window X position.
773
774        This property offers access to the X position for the window, using the Windows active metrics mode.
775
776        \par Usage:
777                - Name: XPosition
778                - Format: "[float]".
779
780        \par Where:
781                - [float]       specifies the x position co-ordinate as a floating point number, using the active metrics system for the Window.
782*/
783class XPosition : public Property
784{
785public:
786        XPosition() : Property(
787                "XPosition",
788                "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using the active metrics mode.",
789                "0.000000", false)
790        {}
791
792        String  get(const PropertyReceiver* receiver) const;
793        void    set(PropertyReceiver* receiver, const String& value);
794};
795
796
797/*!
798\brief
799        Property to access window X position.
800
801        This property offers access to the X position for the window, using the relative metrics system.
802
803        \par Usage:
804                - Name: RelativeXPosition
805                - Format: "[float]".
806
807        \par Where:
808                - [float]       specifies the x position co-ordinate as a floating point number, using the relative metrics system.
809*/
810class RelativeXPosition : public Property
811{
812public:
813        RelativeXPosition() : Property(
814                "RelativeXPosition",
815                "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using relative metrics.",
816                "0.000000", false)
817        {}
818
819        String  get(const PropertyReceiver* receiver) const;
820        void    set(PropertyReceiver* receiver, const String& value);
821};
822
823
824/*!
825\brief
826        Property to access window X position.
827
828        This property offers access to the X position for the window, using the absolute metrics system.
829
830        \par Usage:
831                - Name: AbsoluteXPosition
832                - Format: "[float]".
833
834        \par Where:
835                - [float]       specifies the x position co-ordinate as a floating point number, using the absolute metrics system.
836*/
837class AbsoluteXPosition : public Property
838{
839public:
840        AbsoluteXPosition() : Property(
841                "AbsoluteXPosition",
842                "Property to get/set the x co-ordinate position of the Window.  Value is a floating point number using absolute metrics.",
843                "0.000000", false)
844        {}
845
846        String  get(const PropertyReceiver* receiver) const;
847        void    set(PropertyReceiver* receiver, const String& value);
848};
849
850
851/*!
852\brief
853        Property to access window Y position.
854
855        This property offers access to the Y position for the window, using the Windows active metrics mode.
856
857        \par Usage:
858                - Name: YPosition
859                - Format: "[float]".
860
861        \par Where:
862                - [float]       specifies the y position co-ordinate as a floating point number, using the active metrics system for the Window.
863*/
864class YPosition : public Property
865{
866public:
867        YPosition() : Property(
868                "YPosition",
869                "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using the active metrics mode.",
870                "0.000000", false)
871        {}
872
873        String  get(const PropertyReceiver* receiver) const;
874        void    set(PropertyReceiver* receiver, const String& value);
875};
876
877
878/*!
879\brief
880        Property to access window Y position.
881
882        This property offers access to the Y position for the window, using the relative metrics system.
883
884        \par Usage:
885                - Name: RelativeYPosition
886                - Format: "[float]".
887
888        \par Where:
889                - [float]       specifies the y position co-ordinate as a floating point number, using the relative metrics system.
890*/
891class RelativeYPosition : public Property
892{
893public:
894        RelativeYPosition() : Property(
895                "RelativeYPosition",
896                "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using relative metrics.",
897                "0.000000", false)
898        {}
899
900        String  get(const PropertyReceiver* receiver) const;
901        void    set(PropertyReceiver* receiver, const String& value);
902};
903
904
905/*!
906\brief
907        Property to access window Y position.
908
909        This property offers access to the Y position for the window, using the absolute metrics system.
910
911        \par Usage:
912                - Name: AbsoluteYPosition
913                - Format: "[float]".
914
915        \par Where:
916                - [float]       specifies the y position co-ordinate as a floating point number, using the absolute metrics system.
917*/
918class AbsoluteYPosition : public Property
919{
920public:
921        AbsoluteYPosition() : Property(
922                "AbsoluteYPosition",
923                "Property to get/set the y co-ordinate position of the Window.  Value is a floating point number using absolute metrics.",
924                "0.000000", false)
925        {}
926
927        String  get(const PropertyReceiver* receiver) const;
928        void    set(PropertyReceiver* receiver, const String& value);
929};
930
931
932/*!
933\brief
934        Property to access window position.
935
936        This property offers access to the position for the window, using the Windows active metrics mode.
937
938        \par Usage:
939                - Name: Position
940                - Format: "x:[float] y:[float]".
941
942        \par Where:
943                - x:[float]     specifies the x position co-ordinate as a floating point number, using the active metrics system for the Window.
944                - y:[float]     specifies the y position co-ordinate as a floating point number, using the active metrics system for the Window.
945*/
946class Position : public Property
947{
948public:
949        Position() : Property(
950                "Position",
951                "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using the active metrics mode.",
952                "x:0.000000 y:0.000000", false)
953        {}
954
955        String  get(const PropertyReceiver* receiver) const;
956        void    set(PropertyReceiver* receiver, const String& value);
957};
958
959
960/*!
961\brief
962        Property to access window position.
963
964        This property offers access to the position for the window, using the relative metrics system.
965
966        \par Usage:
967                - Name: RelativePosition
968                - Format: "x:[float] y:[float]".
969
970        \par Where:
971                - x:[float]     specifies the x position co-ordinate as a floating point number, using the relative metrics system.
972                - y:[float]     specifies the y position co-ordinate as a floating point number, using the relative metrics system.
973*/
974class RelativePosition : public Property
975{
976public:
977        RelativePosition() : Property(
978                "RelativePosition",
979                "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using relative metrics.",
980                "x:0.000000 y:0.000000", false)
981        {}
982
983        String  get(const PropertyReceiver* receiver) const;
984        void    set(PropertyReceiver* receiver, const String& value);
985};
986
987
988/*!
989\brief
990        Property to access window position.
991
992        This property offers access to the position for the window, using the absolute metrics system.
993
994        \par Usage:
995                - Name: AbsolutePosition
996                - Format: "x:[float] y:[float]".
997
998        \par Where:
999                - x:[float]     specifies the x position co-ordinate as a floating point number, using the absolute metrics system.
1000                - y:[float]     specifies the y position co-ordinate as a floating point number, using the absolute metrics system.
1001*/
1002class AbsolutePosition : public Property
1003{
1004public:
1005        AbsolutePosition() : Property(
1006                "AbsolutePosition",
1007                "Property to get/set the position of the Window.  Value is \"x:[float] y:[float]\" using absolute metrics.",
1008                "x:0.000000 y:0.000000", false)
1009        {}
1010
1011        String  get(const PropertyReceiver* receiver) const;
1012        void    set(PropertyReceiver* receiver, const String& value);
1013};
1014
1015
1016/*!
1017\brief
1018        Property to access window area rectangle.
1019
1020        This property offers access to the area rectangle (Rect) for the window, using the Windows active metrics mode.
1021
1022        \par Usage:
1023                - Name: Rect
1024                - Format: "l:[float] t:[float] r:[float] b:[float]".
1025
1026        \par Where:
1027                - l:[float]     specifies the position of the left edge of the area as a floating point number, using the active metrics system for the Window.
1028                - t:[float]     specifies the position of the top edge of the area as a floating point number, using the active metrics system for the Window.
1029                - r:[float]     specifies the position of the right edge of the area as a floating point number, using the active metrics system for the Window.
1030                - b:[float]     specifies the position of the bottom edge of the area as a floating point number, using the active metrics system for the Window.
1031*/
1032class Rect : public Property
1033{
1034public:
1035        Rect() : Property(
1036                "Rect",
1037                "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using the active metrics system.",
1038                "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false)
1039        {}
1040
1041        String  get(const PropertyReceiver* receiver) const;
1042        void    set(PropertyReceiver* receiver, const String& value);
1043};
1044
1045
1046/*!
1047\brief
1048        Property to access window area rectangle.
1049
1050        This property offers access to the area rectangle (Rect) for the window, using the relative metrics system.
1051
1052        \par Usage:
1053                - Name: RelativeRect
1054                - Format: "l:[float] t:[float] r:[float] b:[float]".
1055
1056        \par Where:
1057                - l:[float]     specifies the position of the left edge of the area as a floating point number, using the relative metrics system.
1058                - t:[float]     specifies the position of the top edge of the area as a floating point number, using the relative metrics system.
1059                - r:[float]     specifies the position of the right edge of the area as a floating point number, using the relative metrics system.
1060                - b:[float]     specifies the position of the bottom edge of the area as a floating point number, using the relative metrics system.
1061*/
1062class RelativeRect : public Property
1063{
1064public:
1065        RelativeRect() : Property(
1066                "RelativeRect",
1067                "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using relative metrics.",
1068                "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false)
1069        {}
1070
1071        String  get(const PropertyReceiver* receiver) const;
1072        void    set(PropertyReceiver* receiver, const String& value);
1073};
1074
1075
1076/*!
1077\brief
1078        Property to access window area rectangle.
1079
1080        This property offers access to the area rectangle (Rect) for the window, using the absolute metrics system.
1081
1082        \par Usage:
1083                - Name: AbsoluteRect
1084                - Format: "l:[float] t:[float] r:[float] b:[float]".
1085
1086        \par Where:
1087                - l:[float]     specifies the position of the left edge of the area as a floating point number, using the absolute metrics system.
1088                - t:[float]     specifies the position of the top edge of the area as a floating point number, using the absolute metrics system.
1089                - r:[float]     specifies the position of the right edge of the area as a floating point number, using the absolute metrics system.
1090                - b:[float]     specifies the position of the bottom edge of the area as a floating point number, using the absolute metrics system.
1091*/
1092class AbsoluteRect : public Property
1093{
1094public:
1095        AbsoluteRect() : Property(
1096                "AbsoluteRect",
1097                "Property to get/set the area rectangle of the Window.  Value is \"l:[float] t:[float] r:[float] b:[float]\" (where l is left, t is top, r is right, and b is bottom) using absolute metrics.",
1098                "l:0.000000 t:0.000000 r:0.000000 b:0.000000", false)
1099        {}
1100
1101        String  get(const PropertyReceiver* receiver) const;
1102        void    set(PropertyReceiver* receiver, const String& value);
1103};
1104
1105
1106/*!
1107\brief
1108        Property to access window Z-Order changing enabled setting.
1109
1110        This property offers access to the setting that controls whether z-order changes are enabled for the window.
1111
1112        \par Usage:
1113                - Name: ZOrderChangeEnabled
1114                - Format: "[text]".
1115
1116        \par Where [Text] is:
1117                - "True" to indicate the Window should respect requests to change z-order.
1118                - "False" to indicate the Window should not change it's z-order.
1119*/
1120class ZOrderChangeEnabled : public Property
1121{
1122public:
1123        ZOrderChangeEnabled() : Property(
1124                "ZOrderChangeEnabled",
1125                "Property to get/set the 'z-order changing enabled' setting for the Window.  Value is either \"True\" or \"False\".",
1126                "True")
1127        {}
1128
1129        String  get(const PropertyReceiver* receiver) const;
1130        void    set(PropertyReceiver* receiver, const String& value);
1131};
1132
1133
1134/*!
1135\brief
1136    Property to control whether the window will receive double/triple-click events.
1137
1138    This property offers access to the setting that controls whether a window will receive double-click and
1139    triple-click events, or whether the window will receive multiple single mouse button down events instead.
1140
1141    \par Usage:
1142        - Name: WantsMultiClickEvents
1143        - Format: "[text]".
1144
1145    \par Where [Text] is:
1146        - "True" to indicate the Window wants double-click and triple-click events.
1147        - "False" to indicate the Window wants multiple single mouse button down events.
1148*/
1149class WantsMultiClickEvents : public Property
1150{
1151public:
1152    WantsMultiClickEvents() : Property(
1153        "WantsMultiClickEvents",
1154        "Property to get/set whether the window will receive double-click and triple-click events.  Value is either \"True\" or \"False\".",
1155        "True")
1156    {}
1157
1158    String      get(const PropertyReceiver* receiver) const;
1159    void        set(PropertyReceiver* receiver, const String& value);
1160};
1161
1162
1163/*!
1164\brief
1165    Property to control whether the window will receive autorepeat mouse button down events.
1166
1167    This property offers access to the setting that controls whether a window will receive autorepeat
1168    mouse button down events.
1169
1170    \par Usage:
1171        - Name: MouseButtonDownAutoRepeat
1172        - Format: "[text]".
1173
1174    \par Where [Text] is:
1175        - "True" to indicate the Window will receive autorepeat mouse button down events.
1176        - "False" to indicate the Window will not receive autorepeat mouse button down events.
1177*/
1178class MouseButtonDownAutoRepeat : public Property
1179{
1180public:
1181    MouseButtonDownAutoRepeat() : Property(
1182        "MouseButtonDownAutoRepeat",
1183        "Property to get/set whether the window will receive autorepeat mouse button down events.  Value is either \"True\" or \"False\".",
1184        "False")
1185    {}
1186
1187    String  get(const PropertyReceiver* receiver) const;
1188    void    set(PropertyReceiver* receiver, const String& value);
1189};
1190
1191
1192/*!
1193\brief
1194    Property to access window autorepeat delay value.
1195
1196    This property offers access to the value that controls the initial delay for autorepeat mouse button down events.
1197
1198    \par Usage:
1199        - Name: AutoRepeatDelay
1200        - Format: "[float]".
1201
1202    \par Where:
1203        - [float]   specifies the delay in seconds.
1204*/
1205class AutoRepeatDelay : public Property
1206{
1207public:
1208    AutoRepeatDelay() : Property(
1209        "AutoRepeatDelay",
1210        "Property to get/set the autorepeat delay.  Value is a floating point number indicating the delay required in seconds.",
1211        "0.300000")
1212    {}
1213
1214    String  get(const PropertyReceiver* receiver) const;
1215    void    set(PropertyReceiver* receiver, const String& value);
1216};
1217
1218
1219/*!
1220\brief
1221    Property to access window autorepeat rate value.
1222
1223    This property offers access to the value that controls the generation rate for autorepeat mouse button down events.
1224
1225    \par Usage:
1226        - Name: AutoRepeatRate
1227        - Format: "[float]".
1228
1229    \par Where:
1230        - [float]   specifies the rate at which autorepeat events will be generated in seconds.
1231*/
1232class AutoRepeatRate : public Property
1233{
1234public:
1235    AutoRepeatRate() : Property(
1236        "AutoRepeatRate",
1237        "Property to get/set the autorepeat rate.  Value is a floating point number indicating the rate required in seconds.",
1238        "0.060000")
1239    {}
1240
1241    String  get(const PropertyReceiver* receiver) const;
1242    void    set(PropertyReceiver* receiver, const String& value);
1243};
1244
1245/*!
1246\brief
1247        Property to access whether inputs are passed to child windows when
1248    input is captured to this window.
1249
1250        \par Usage:
1251                - Name: DistributeCapturedInputs
1252                - Format: "[text]".
1253
1254        \par Where [Text] is:
1255                - "True" to indicate 'captured' inputs should be passed to attached child windows.
1256                - "False" to indicate 'captured' inputs should be passed to this window only.
1257*/
1258class DistributeCapturedInputs : public Property
1259{
1260public:
1261        DistributeCapturedInputs() : Property(
1262                "DistributeCapturedInputs",
1263                "Property to get/set whether captured inputs are passed to child windows.  Value is either \"True\" or \"False\".",
1264                "False")
1265        {}
1266
1267        String  get(const PropertyReceiver* receiver) const;
1268        void    set(PropertyReceiver* receiver, const String& value);
1269};
1270
1271/*!
1272\brief
1273    Property to access the custom tooltip for this Window.
1274
1275    \par Usage:
1276        - Name: CustomTooltipType
1277        - Format: "[text]".
1278
1279    \par Where:
1280        - [Text] is the typename of the custom tooltip for the Window.
1281 */
1282class CustomTooltipType : public Property
1283{
1284public:
1285    CustomTooltipType() : Property(
1286    "CustomTooltipType",
1287    "Property to get/set the custom tooltip for the window.  Value is the type name of the custom tooltip.",
1288    "")
1289    {}
1290
1291    String  get(const PropertyReceiver* receiver) const;
1292    void    set(PropertyReceiver* receiver, const String& value);
1293};
1294
1295/*!
1296\brief
1297    Property to access the tooltip text for this Window.
1298
1299    \par Usage:
1300        - Name: Tooltip
1301        - Format: "[text]".
1302
1303    \par Where:
1304        - [Text] is the tooltip text for this window.
1305 */
1306class Tooltip : public Property
1307{
1308public:
1309    Tooltip() : Property(
1310    "Tooltip",
1311    "Property to get/set the tooltip text for the window.  Value is the tooltip text for the window.",
1312    "")
1313    {}
1314
1315    String  get(const PropertyReceiver* receiver) const;
1316    void    set(PropertyReceiver* receiver, const String& value);
1317};
1318
1319/*!
1320\brief
1321    Property to access whether the window inherits its tooltip text from its parent whn it has no tooltip text of its own.
1322
1323    \par Usage:
1324        - Name: InheritsTooltipText
1325        - Format: "[text]".
1326
1327    \par Where [Text] is:
1328        - "True" to indicate the Window inherits its tooltip text from its parent.
1329        - "False" to indicate the Window does not inherit its tooltip text.
1330*/
1331class InheritsTooltipText : public Property
1332{
1333public:
1334    InheritsTooltipText() : Property(
1335        "InheritsTooltipText",
1336        "Property to get/set whether the window inherits its parents tooltip text when it has none of its own.  Value is either \"True\" or \"False\".",
1337        "False")
1338    {}
1339
1340    String  get(const PropertyReceiver* receiver) const;
1341    void    set(PropertyReceiver* receiver, const String& value);
1342};
1343
1344
1345/*!
1346\brief
1347        Property to access whether the window rises to the top of the z order when clicked.
1348
1349        \par Usage:
1350                - Name: RiseOnClick
1351                - Format: "[text]".
1352
1353        \par Where [Text] is:
1354                - "True" to indicate the Window will rise to the surface when clicked.
1355                - "False" to indicate the Window will not change z position when clicked.
1356*/
1357class RiseOnClick : public Property
1358{
1359public:
1360    RiseOnClick() : Property(
1361                "RiseOnClick",
1362                "Property to get/set whether the window will come tot he top of the z order hwn clicked.  Value is either \"True\" or \"False\".",
1363                "True")
1364        {}
1365
1366        String  get(const PropertyReceiver* receiver) const;
1367        void    set(PropertyReceiver* receiver, const String& value);
1368};
1369
1370
1371/*!
1372\brief
1373    Property to access the vertical alignment setting for the window.
1374
1375    \par Usage:
1376        - Name: VerticalAlignment
1377        - Format: "[text]".
1378
1379    \par Where [Text] is:
1380        - "Top" to indicate the windows position is an offset of its top edge from its parents top edge.
1381        - "Centre" to indicate the windows position is an offset of its centre point from its parents centre point.
1382        - "Bottom" to indicate the windows position is an offset of its bottom edge from its parents bottom edge.
1383*/
1384class VerticalAlignment : public Property
1385{
1386    public:
1387        VerticalAlignment() : Property(
1388        "VerticalAlignment",
1389        "Property to get/set the windows vertical alignment.  Value is one of \"Top\", \"Centre\" or \"Bottom\".",
1390        "Top")
1391        {}
1392
1393        String  get(const PropertyReceiver* receiver) const;
1394        void    set(PropertyReceiver* receiver, const String& value);
1395};
1396
1397
1398/*!
1399\brief
1400    Property to access the horizontal alignment setting for the window.
1401
1402    \par Usage:
1403        - Name: HorizontalAlignment
1404        - Format: "[text]".
1405
1406    \par Where [Text] is:
1407        - "Left" to indicate the windows position is an offset of its left edge from its parents left edge.
1408        - "Centre" to indicate the windows position is an offset of its centre point from its parents centre point.
1409        - "Right" to indicate the windows position is an offset of its right edge from its parents right edge.
1410*/
1411class HorizontalAlignment : public Property
1412{
1413    public:
1414        HorizontalAlignment() : Property(
1415        "HorizontalAlignment",
1416        "Property to get/set the windows horizontal alignment.  Value is one of \"Left\", \"Centre\" or \"Right\".",
1417        "Left")
1418        {}
1419
1420        String  get(const PropertyReceiver* receiver) const;
1421        void    set(PropertyReceiver* receiver, const String& value);
1422};
1423
1424
1425/*
1426\brief
1427        Property to access the unified area rectangle of the window.
1428
1429        \par Usage:
1430                - Name: UnifiedAreaRect
1431                - Format: "{{[ls],[lo]},{[ts],[to]},{[rs],[ro]},{[bs],[bo]}}"
1432
1433        \par Where:
1434                - [ls] is a floating point value describing the relative scale value for the left edge.
1435                - [lo] is a floating point value describing the absolute offset value for the left edge.
1436                - [ts] is a floating point value describing the relative scale value for the top edge.
1437                - [to] is a floating point value describing the absolute offset value for the top edge.
1438                - [rs] is a floating point value describing the relative scale value for the right edge.
1439                - [ro] is a floating point value describing the absolute offset value for the right edge.
1440                - [bs] is a floating point value describing the relative scale value for the bottom edge.
1441                - [bo] is a floating point value describing the absolute offset value for the bottom edge.
1442*/
1443class UnifiedAreaRect : public Property
1444{
1445        public:
1446                UnifiedAreaRect() : Property(
1447                "UnifiedAreaRect",
1448                "Property to get/set the windows unified area rectangle.  Value is a \"URect\".",
1449                "{{0.000000,0.000000},{0.000000,0.000000},{0.000000,0.000000},{0.000000,0.000000}}")
1450                {}
1451
1452                String  get(const PropertyReceiver* receiver) const;
1453                void    set(PropertyReceiver* receiver, const String& value);
1454};
1455
1456
1457/*
1458\brief
1459        Property to access the unified position of the window.
1460
1461        \par Usage:
1462                - Name: UnifiedPosition
1463                - Format: "{{[xs],[xo]},{[ys],[yo]}}"
1464
1465        \par Where:
1466                - [xs] is a floating point value describing the relative scale value for the position x-coordinate.
1467                - [xo] is a floating point value describing the absolute offset value for the position x-coordinate.
1468                - [ys] is a floating point value describing the relative scale value for the position y-coordinate.
1469                - [yo] is a floating point value describing the absolute offset value for the position y-coordinate.
1470*/
1471class UnifiedPosition : public Property
1472{
1473        public:
1474                UnifiedPosition() : Property(
1475                "UnifiedPosition",
1476                "Property to get/set the windows unified position.  Value is a \"UVector2\".",
1477                "{{0.000000,0.000000},{0.000000,0.000000}}", false)
1478                {}
1479
1480                String  get(const PropertyReceiver* receiver) const;
1481                void    set(PropertyReceiver* receiver, const String& value);
1482};
1483
1484
1485/*
1486\brief
1487        Property to access the unified position x-coordinate of the window.
1488
1489        \par Usage:
1490                - Name: UnifiedXPosition
1491                - Format: "{[s],[o]}"
1492
1493        \par Where:
1494                - [s] is a floating point value describing the relative scale value for the position x-coordinate.
1495                - [o] is a floating point value describing the absolute offset value for the position x-coordinate.
1496*/
1497class UnifiedXPosition : public Property
1498{
1499        public:
1500                UnifiedXPosition() : Property(
1501                "UnifiedXPosition",
1502                "Property to get/set the windows unified position x-coordinate.  Value is a \"UDim\".",
1503                "{0.000000,0.000000}", false)
1504                {}
1505
1506                String  get(const PropertyReceiver* receiver) const;
1507                void    set(PropertyReceiver* receiver, const String& value);
1508};
1509
1510
1511/*
1512\brief
1513        Property to access the unified position y-coordinate of the window.
1514
1515        \par Usage:
1516                - Name: UnifiedYPosition
1517                - Format: "{[s],[o]}"
1518
1519        \par Where:
1520                - [s] is a floating point value describing the relative scale value for the position y-coordinate.
1521                - [o] is a floating point value describing the absolute offset value for the position y-coordinate.
1522*/
1523class UnifiedYPosition : public Property
1524{
1525        public:
1526                UnifiedYPosition() : Property(
1527                "UnifiedYPosition",
1528                "Property to get/set the windows unified position y-coordinate.  Value is a \"UDim\".",
1529                "{0.000000,0.000000}", false)
1530                {}
1531
1532                String  get(const PropertyReceiver* receiver) const;
1533                void    set(PropertyReceiver* receiver, const String& value);
1534};
1535
1536
1537/*
1538\brief
1539        Property to access the unified position of the window.
1540
1541        \par Usage:
1542                - Name: UnifiedSize
1543                - Format: "{{[ws],[wo]},{[hs],[ho]}}"
1544
1545        \par Where:
1546                - [ws] is a floating point value describing the relative scale value for the width.
1547                - [wo] is a floating point value describing the absolute offset value for the width.
1548                - [hs] is a floating point value describing the relative scale value for the height.
1549                - [ho] is a floating point value describing the absolute offset value for the height.
1550*/
1551class UnifiedSize : public Property
1552{
1553        public:
1554                UnifiedSize() : Property(
1555                "UnifiedSize",
1556                "Property to get/set the windows unified size.  Value is a \"UVector2\".",
1557                "{{0.000000,0.000000},{0.000000,0.000000}}", false)
1558                {}
1559
1560                String  get(const PropertyReceiver* receiver) const;
1561                void    set(PropertyReceiver* receiver, const String& value);
1562};
1563
1564
1565/*
1566\brief
1567        Property to access the unified width of the window.
1568
1569        \par Usage:
1570                - Name: UnifiedWidth
1571                - Format: "{[s],[o]}"
1572
1573        \par Where:
1574                - [s] is a floating point value describing the relative scale value for the width.
1575                - [o] is a floating point value describing the absolute offset value for the width.
1576*/
1577class UnifiedWidth : public Property
1578{
1579        public:
1580                UnifiedWidth() : Property(
1581                "UnifiedWidth",
1582                "Property to get/set the windows unified width.  Value is a \"UDim\".",
1583                "{0.000000,0.000000}", false)
1584                {}
1585
1586                String  get(const PropertyReceiver* receiver) const;
1587                void    set(PropertyReceiver* receiver, const String& value);
1588};
1589
1590
1591/*
1592\brief
1593        Property to access the unified height of the window.
1594
1595        \par Usage:
1596                - Name: UnifiedHeight
1597                - Format: "{[s],[o]}"
1598
1599        \par Where:
1600                - [s] is a floating point value describing the relative scale value for the height.
1601                - [o] is a floating point value describing the absolute offset value for the height.
1602*/
1603class UnifiedHeight : public Property
1604{
1605        public:
1606                UnifiedHeight() : Property(
1607                "UnifiedHeight",
1608                "Property to get/set the windows unified height.  Value is a \"UDim\".",
1609                "{0.000000,0.000000}", false)
1610                {}
1611
1612                String  get(const PropertyReceiver* receiver) const;
1613                void    set(PropertyReceiver* receiver, const String& value);
1614};
1615
1616
1617/*
1618\brief
1619        Property to access the unified minimum size of the window.
1620
1621        \par Usage:
1622                - Name: UnifiedMinSize
1623                - Format: "{{[ws],[wo]},{[hs],[ho]}}"
1624
1625        \par Where:
1626                - [ws] is a floating point value describing the relative scale value for the minimum width.
1627                - [wo] is a floating point value describing the absolute offset value for the minimum width.
1628                - [hs] is a floating point value describing the relative scale value for the minimum height.
1629                - [ho] is a floating point value describing the absolute offset value for the minimum height.
1630*/
1631class UnifiedMinSize : public Property
1632{
1633        public:
1634                UnifiedMinSize() : Property(
1635                "UnifiedMinSize",
1636                "Property to get/set the windows unified minimum size.  Value is a \"UVector2\".",
1637                "{{0.000000,0.000000},{0.000000,0.000000}}")
1638                {}
1639
1640                String  get(const PropertyReceiver* receiver) const;
1641                void    set(PropertyReceiver* receiver, const String& value);
1642};
1643
1644
1645/*
1646\brief
1647        Property to access the unified maximum size of the window.
1648
1649        \par Usage:
1650                - Name: UnifiedMaxSize
1651                - Format: "{{[ws],[wo]},{[hs],[ho]}}"
1652
1653        \par Where:
1654                - [ws] is a floating point value describing the relative scale value for the maximum width.
1655                - [wo] is a floating point value describing the absolute offset value for the maximum width.
1656                - [hs] is a floating point value describing the relative scale value for the maximum height.
1657                - [ho] is a floating point value describing the absolute offset value for the maximum height.
1658*/
1659class UnifiedMaxSize : public Property
1660{
1661        public:
1662                UnifiedMaxSize() : Property(
1663                "UnifiedMaxSize",
1664                "Property to get/set the windows unified maximum size.  Value is a \"UVector2\".",
1665                "{{0.000000,0.000000},{0.000000,0.000000}}")
1666                {}
1667
1668                String  get(const PropertyReceiver* receiver) const;
1669                void    set(PropertyReceiver* receiver, const String& value);
1670};
1671
1672
1673/*!
1674\brief
1675    Property to access whether the window ignores mouse events and pass them through to any windows behind it.
1676
1677    \par Usage:
1678        - Name: MousePassThroughEnabled
1679        - Format: "[text]".
1680
1681    \par Where [Text] is:
1682        - "True" to indicate the Window will not respond to mouse events but pass them directly to any children behind it.
1683        - "False" to indicate the Window will respond to normally to all mouse events (Default).
1684*/
1685class MousePassThroughEnabled : public Property
1686{
1687public:
1688    MousePassThroughEnabled() : Property(
1689        "MousePassThroughEnabled",
1690        "Property to get/set whether the window ignores mouse events and pass them through to any windows behind it.  Value is either \"True\" or \"False\".",
1691        "False")
1692    {}
1693
1694    String  get(const PropertyReceiver* receiver) const;
1695    void    set(PropertyReceiver* receiver, const String& value);
1696};
1697
1698
1699} // End of  WindowProperties namespace section
1700
1701
1702} // End of  CEGUI namespace section
1703
1704#endif  // end of guard _CEGUIWindowProperties_h_
Note: See TracBrowser for help on using the repository browser.