1wxAuiPaneInfo(3)           Erlang Module Definition           wxAuiPaneInfo(3)
2
3
4

NAME

6       wxAuiPaneInfo - Functions for wxAuiPaneInfo class
7

DESCRIPTION

9       wxAuiPaneInfo  is  part  of  the  wxAUI class framework. See also over‐
10       view_aui.
11
12       wxAuiPaneInfo specifies all the parameters for a pane. These parameters
13       specify where the pane is on the screen, whether it is docked or float‐
14       ing, or hidden. In addition, these parameters specify the pane's docked
15       position, floating position, preferred size, minimum size, caption text
16       among many other parameters.
17
18       See: wxAuiManager, wxAuiDockArt
19
20       wxWidgets docs: wxAuiPaneInfo
21

DATA TYPES

23       wxAuiPaneInfo() = wx:wx_object()
24

EXPORTS

26       new() -> wxAuiPaneInfo()
27
28       new(C) -> wxAuiPaneInfo()
29
30              Types:
31
32                 C = wxAuiPaneInfo()
33
34              Copy constructor.
35
36       bestSize(This, Size) -> wxAuiPaneInfo()
37
38              Types:
39
40                 This = wxAuiPaneInfo()
41                 Size = {W :: integer(), H :: integer()}
42
43              bestSize/3 sets the ideal size for the pane.
44
45              The docking manager will attempt to use this  size  as  much  as
46              possible when docking or floating the pane.
47
48       bestSize(This, X, Y) -> wxAuiPaneInfo()
49
50              Types:
51
52                 This = wxAuiPaneInfo()
53                 X = Y = integer()
54
55       bottom(This) -> wxAuiPaneInfo()
56
57              Types:
58
59                 This = wxAuiPaneInfo()
60
61              bottom/1  sets  the pane dock position to the bottom side of the
62              frame.
63
64              This is the same thing as calling Direction(wxAUI_DOCK_BOTTOM).
65
66       bottomDockable(This) -> wxAuiPaneInfo()
67
68              Types:
69
70                 This = wxAuiPaneInfo()
71
72       bottomDockable(This, Options :: [Option]) -> wxAuiPaneInfo()
73
74              Types:
75
76                 This = wxAuiPaneInfo()
77                 Option = {b, boolean()}
78
79              bottomDockable/2 indicates whether a pane can be docked  at  the
80              bottom of the frame.
81
82       caption(This, C) -> wxAuiPaneInfo()
83
84              Types:
85
86                 This = wxAuiPaneInfo()
87                 C = unicode:chardata()
88
89              caption/2 sets the caption of the pane.
90
91       captionVisible(This) -> wxAuiPaneInfo()
92
93              Types:
94
95                 This = wxAuiPaneInfo()
96
97       captionVisible(This, Options :: [Option]) -> wxAuiPaneInfo()
98
99              Types:
100
101                 This = wxAuiPaneInfo()
102                 Option = {visible, boolean()}
103
104              CaptionVisible indicates that a pane caption should be visible.
105
106              If false, no pane caption is drawn.
107
108       centre(This) -> wxAuiPaneInfo()
109
110              Types:
111
112                 This = wxAuiPaneInfo()
113
114              Center()  (not implemented in wx) sets the pane dock position to
115              the left side of the frame.
116
117              The centre pane is the space in  the  middle  after  all  border
118              panes (left, top, right, bottom) are subtracted from the layout.
119              This is the same thing as calling Direction(wxAUI_DOCK_CENTRE).
120
121       centrePane(This) -> wxAuiPaneInfo()
122
123              Types:
124
125                 This = wxAuiPaneInfo()
126
127              centrePane/1 specifies that the pane should  adopt  the  default
128              center pane settings.
129
130              Centre  panes  usually  do  not have caption bars. This function
131              provides an easy way of preparing a pane to be displayed in  the
132              center dock position.
133
134       closeButton(This) -> wxAuiPaneInfo()
135
136              Types:
137
138                 This = wxAuiPaneInfo()
139
140       closeButton(This, Options :: [Option]) -> wxAuiPaneInfo()
141
142              Types:
143
144                 This = wxAuiPaneInfo()
145                 Option = {visible, boolean()}
146
147              closeButton/2  indicates that a close button should be drawn for
148              the pane.
149
150       defaultPane(This) -> wxAuiPaneInfo()
151
152              Types:
153
154                 This = wxAuiPaneInfo()
155
156              defaultPane/1 specifies that the pane should adopt  the  default
157              pane settings.
158
159       destroyOnClose(This) -> wxAuiPaneInfo()
160
161              Types:
162
163                 This = wxAuiPaneInfo()
164
165       destroyOnClose(This, Options :: [Option]) -> wxAuiPaneInfo()
166
167              Types:
168
169                 This = wxAuiPaneInfo()
170                 Option = {b, boolean()}
171
172              destroyOnClose/2  indicates  whether  a pane should be destroyed
173              when it is closed.
174
175              Normally a pane is  simply  hidden  when  the  close  button  is
176              clicked. Setting DestroyOnClose to true will cause the window to
177              be destroyed when the user clicks the pane's close button.
178
179       direction(This, Direction) -> wxAuiPaneInfo()
180
181              Types:
182
183                 This = wxAuiPaneInfo()
184                 Direction = integer()
185
186              direction/2 determines the direction of the docked pane.
187
188              It is functionally the same as calling left/1, right/1, top/1 or
189              bottom/1,  except  that  docking direction may be specified pro‐
190              grammatically via the parameter.
191
192       dock(This) -> wxAuiPaneInfo()
193
194              Types:
195
196                 This = wxAuiPaneInfo()
197
198              dock/1 indicates that a pane should be docked.
199
200              It is the opposite of float/1.
201
202       dockable(This) -> wxAuiPaneInfo()
203
204              Types:
205
206                 This = wxAuiPaneInfo()
207
208       dockable(This, Options :: [Option]) -> wxAuiPaneInfo()
209
210              Types:
211
212                 This = wxAuiPaneInfo()
213                 Option = {b, boolean()}
214
215              dockable/2 specifies whether a frame can be docked or not.
216
217              It  is  the  same   as   specifying   TopDockable(b).BottomDock‐
218              able(b).LeftDockable(b).RightDockable(b).
219
220       fixed(This) -> wxAuiPaneInfo()
221
222              Types:
223
224                 This = wxAuiPaneInfo()
225
226              fixed/1  forces a pane to be fixed size so that it cannot be re‐
227              sized.
228
229              After calling fixed/1, isFixed/1 will return true.
230
231       float(This) -> wxAuiPaneInfo()
232
233              Types:
234
235                 This = wxAuiPaneInfo()
236
237              float/1 indicates that a pane should be floated.
238
239              It is the opposite of dock/1.
240
241       floatable(This) -> wxAuiPaneInfo()
242
243              Types:
244
245                 This = wxAuiPaneInfo()
246
247       floatable(This, Options :: [Option]) -> wxAuiPaneInfo()
248
249              Types:
250
251                 This = wxAuiPaneInfo()
252                 Option = {b, boolean()}
253
254              floatable/2 sets whether the user will be able to undock a  pane
255              and turn it into a floating window.
256
257       floatingPosition(This, Pos) -> wxAuiPaneInfo()
258
259              Types:
260
261                 This = wxAuiPaneInfo()
262                 Pos = {X :: integer(), Y :: integer()}
263
264              floatingPosition/3 sets the position of the floating pane.
265
266       floatingPosition(This, X, Y) -> wxAuiPaneInfo()
267
268              Types:
269
270                 This = wxAuiPaneInfo()
271                 X = Y = integer()
272
273       floatingSize(This, Size) -> wxAuiPaneInfo()
274
275              Types:
276
277                 This = wxAuiPaneInfo()
278                 Size = {W :: integer(), H :: integer()}
279
280              floatingSize/3 sets the size of the floating pane.
281
282       floatingSize(This, X, Y) -> wxAuiPaneInfo()
283
284              Types:
285
286                 This = wxAuiPaneInfo()
287                 X = Y = integer()
288
289       gripper(This) -> wxAuiPaneInfo()
290
291              Types:
292
293                 This = wxAuiPaneInfo()
294
295       gripper(This, Options :: [Option]) -> wxAuiPaneInfo()
296
297              Types:
298
299                 This = wxAuiPaneInfo()
300                 Option = {visible, boolean()}
301
302              gripper/2 indicates that a gripper should be drawn for the pane.
303
304       gripperTop(This) -> wxAuiPaneInfo()
305
306              Types:
307
308                 This = wxAuiPaneInfo()
309
310       gripperTop(This, Options :: [Option]) -> wxAuiPaneInfo()
311
312              Types:
313
314                 This = wxAuiPaneInfo()
315                 Option = {attop, boolean()}
316
317              gripperTop/2 indicates that a gripper should be drawn at the top
318              of the pane.
319
320       hasBorder(This) -> boolean()
321
322              Types:
323
324                 This = wxAuiPaneInfo()
325
326              hasBorder/1 returns true if the pane displays a border.
327
328       hasCaption(This) -> boolean()
329
330              Types:
331
332                 This = wxAuiPaneInfo()
333
334              hasCaption/1 returns true if the pane displays a caption.
335
336       hasCloseButton(This) -> boolean()
337
338              Types:
339
340                 This = wxAuiPaneInfo()
341
342              hasCloseButton/1 returns true if the pane displays a  button  to
343              close the pane.
344
345       hasFlag(This, Flag) -> boolean()
346
347              Types:
348
349                 This = wxAuiPaneInfo()
350                 Flag = integer()
351
352              hasFlag/2  returns true if the property specified by flag is ac‐
353              tive for the pane.
354
355       hasGripper(This) -> boolean()
356
357              Types:
358
359                 This = wxAuiPaneInfo()
360
361              hasGripper/1 returns true if the pane displays a gripper.
362
363       hasGripperTop(This) -> boolean()
364
365              Types:
366
367                 This = wxAuiPaneInfo()
368
369              hasGripper/1 returns true if the pane displays a gripper at  the
370              top.
371
372       hasMaximizeButton(This) -> boolean()
373
374              Types:
375
376                 This = wxAuiPaneInfo()
377
378              hasMaximizeButton/1  returns  true if the pane displays a button
379              to maximize the pane.
380
381       hasMinimizeButton(This) -> boolean()
382
383              Types:
384
385                 This = wxAuiPaneInfo()
386
387              hasMinimizeButton/1 returns true if the pane displays  a  button
388              to minimize the pane.
389
390       hasPinButton(This) -> boolean()
391
392              Types:
393
394                 This = wxAuiPaneInfo()
395
396              hasPinButton/1  returns  true  if  the pane displays a button to
397              float the pane.
398
399       hide(This) -> wxAuiPaneInfo()
400
401              Types:
402
403                 This = wxAuiPaneInfo()
404
405              hide/1 indicates that a pane should be hidden.
406
407       isBottomDockable(This) -> boolean()
408
409              Types:
410
411                 This = wxAuiPaneInfo()
412
413              isBottomDockable/1 returns true if the pane can be docked at the
414              bottom of the managed frame.
415
416              See: IsDockable() (not implemented in wx)
417
418       isDocked(This) -> boolean()
419
420              Types:
421
422                 This = wxAuiPaneInfo()
423
424              isDocked/1 returns true if the pane is currently docked.
425
426       isFixed(This) -> boolean()
427
428              Types:
429
430                 This = wxAuiPaneInfo()
431
432              isFixed/1 returns true if the pane cannot be resized.
433
434       isFloatable(This) -> boolean()
435
436              Types:
437
438                 This = wxAuiPaneInfo()
439
440              isFloatable/1  returns true if the pane can be undocked and dis‐
441              played as a floating window.
442
443       isFloating(This) -> boolean()
444
445              Types:
446
447                 This = wxAuiPaneInfo()
448
449              isFloating/1 returns true if the pane is floating.
450
451       isLeftDockable(This) -> boolean()
452
453              Types:
454
455                 This = wxAuiPaneInfo()
456
457              isLeftDockable/1 returns true if the pane can be docked  on  the
458              left of the managed frame.
459
460              See: IsDockable() (not implemented in wx)
461
462       isMovable(This) -> boolean()
463
464              Types:
465
466                 This = wxAuiPaneInfo()
467
468              IsMoveable() returns true if the docked frame can be undocked or
469              moved to another dock position.
470
471       isOk(This) -> boolean()
472
473              Types:
474
475                 This = wxAuiPaneInfo()
476
477              isOk/1 returns true if the wxAuiPaneInfo structure is valid.
478
479              A pane structure is valid if it has an associated window.
480
481       isResizable(This) -> boolean()
482
483              Types:
484
485                 This = wxAuiPaneInfo()
486
487              isResizable/1 returns true if the pane can be resized.
488
489       isRightDockable(This) -> boolean()
490
491              Types:
492
493                 This = wxAuiPaneInfo()
494
495              isRightDockable/1 returns true if the pane can be docked on  the
496              right of the managed frame.
497
498              See: IsDockable() (not implemented in wx)
499
500       isShown(This) -> boolean()
501
502              Types:
503
504                 This = wxAuiPaneInfo()
505
506              isShown/1 returns true if the pane is currently shown.
507
508       isToolbar(This) -> boolean()
509
510              Types:
511
512                 This = wxAuiPaneInfo()
513
514              isToolbar/1 returns true if the pane contains a toolbar.
515
516       isTopDockable(This) -> boolean()
517
518              Types:
519
520                 This = wxAuiPaneInfo()
521
522              isTopDockable/1  returns  true  if the pane can be docked at the
523              top of the managed frame.
524
525              See: IsDockable() (not implemented in wx)
526
527       layer(This, Layer) -> wxAuiPaneInfo()
528
529              Types:
530
531                 This = wxAuiPaneInfo()
532                 Layer = integer()
533
534              layer/2 determines the layer of the docked pane.
535
536              The dock layer is similar to an onion, the inner-most layer  be‐
537              ing  layer  0.  Each shell moving in the outward direction has a
538              higher layer number. This allows for more complex docking layout
539              formation.
540
541       left(This) -> wxAuiPaneInfo()
542
543              Types:
544
545                 This = wxAuiPaneInfo()
546
547              left/1  sets  the  pane  dock  position  to the left side of the
548              frame.
549
550              This is the same thing as calling Direction(wxAUI_DOCK_LEFT).
551
552       leftDockable(This) -> wxAuiPaneInfo()
553
554              Types:
555
556                 This = wxAuiPaneInfo()
557
558       leftDockable(This, Options :: [Option]) -> wxAuiPaneInfo()
559
560              Types:
561
562                 This = wxAuiPaneInfo()
563                 Option = {b, boolean()}
564
565              leftDockable/2 indicates whether a pane can  be  docked  on  the
566              left of the frame.
567
568       maxSize(This, Size) -> wxAuiPaneInfo()
569
570              Types:
571
572                 This = wxAuiPaneInfo()
573                 Size = {W :: integer(), H :: integer()}
574
575              maxSize/3 sets the maximum size of the pane.
576
577       maxSize(This, X, Y) -> wxAuiPaneInfo()
578
579              Types:
580
581                 This = wxAuiPaneInfo()
582                 X = Y = integer()
583
584       maximizeButton(This) -> wxAuiPaneInfo()
585
586              Types:
587
588                 This = wxAuiPaneInfo()
589
590       maximizeButton(This, Options :: [Option]) -> wxAuiPaneInfo()
591
592              Types:
593
594                 This = wxAuiPaneInfo()
595                 Option = {visible, boolean()}
596
597              maximizeButton/2  indicates  that  a  maximize  button should be
598              drawn for the pane.
599
600       minSize(This, Size) -> wxAuiPaneInfo()
601
602              Types:
603
604                 This = wxAuiPaneInfo()
605                 Size = {W :: integer(), H :: integer()}
606
607              minSize/3 sets the minimum size of the pane.
608
609              Please note that this is only partially  supported  as  of  this
610              writing.
611
612       minSize(This, X, Y) -> wxAuiPaneInfo()
613
614              Types:
615
616                 This = wxAuiPaneInfo()
617                 X = Y = integer()
618
619       minimizeButton(This) -> wxAuiPaneInfo()
620
621              Types:
622
623                 This = wxAuiPaneInfo()
624
625       minimizeButton(This, Options :: [Option]) -> wxAuiPaneInfo()
626
627              Types:
628
629                 This = wxAuiPaneInfo()
630                 Option = {visible, boolean()}
631
632              minimizeButton/2  indicates  that  a  minimize  button should be
633              drawn for the pane.
634
635       movable(This) -> wxAuiPaneInfo()
636
637              Types:
638
639                 This = wxAuiPaneInfo()
640
641       movable(This, Options :: [Option]) -> wxAuiPaneInfo()
642
643              Types:
644
645                 This = wxAuiPaneInfo()
646                 Option = {b, boolean()}
647
648              Movable indicates whether a frame can be moved.
649
650       name(This, N) -> wxAuiPaneInfo()
651
652              Types:
653
654                 This = wxAuiPaneInfo()
655                 N = unicode:chardata()
656
657              name/2 sets the name of the pane so  it  can  be  referenced  in
658              lookup functions.
659
660              If  a  name  is  not specified by the user, a random name is as‐
661              signed to the pane when it is added to the manager.
662
663       paneBorder(This) -> wxAuiPaneInfo()
664
665              Types:
666
667                 This = wxAuiPaneInfo()
668
669       paneBorder(This, Options :: [Option]) -> wxAuiPaneInfo()
670
671              Types:
672
673                 This = wxAuiPaneInfo()
674                 Option = {visible, boolean()}
675
676              PaneBorder indicates that a border should be drawn for the pane.
677
678       pinButton(This) -> wxAuiPaneInfo()
679
680              Types:
681
682                 This = wxAuiPaneInfo()
683
684       pinButton(This, Options :: [Option]) -> wxAuiPaneInfo()
685
686              Types:
687
688                 This = wxAuiPaneInfo()
689                 Option = {visible, boolean()}
690
691              pinButton/2 indicates that a pin button should be drawn for  the
692              pane.
693
694       position(This, Pos) -> wxAuiPaneInfo()
695
696              Types:
697
698                 This = wxAuiPaneInfo()
699                 Pos = integer()
700
701              position/2 determines the position of the docked pane.
702
703       resizable(This) -> wxAuiPaneInfo()
704
705              Types:
706
707                 This = wxAuiPaneInfo()
708
709       resizable(This, Options :: [Option]) -> wxAuiPaneInfo()
710
711              Types:
712
713                 This = wxAuiPaneInfo()
714                 Option = {resizable, boolean()}
715
716              resizable/2  allows  a  pane  to  be resized if the parameter is
717              true, and forces it to be a  fixed  size  if  the  parameter  is
718              false.
719
720              This is simply an antonym for fixed/1.
721
722       right(This) -> wxAuiPaneInfo()
723
724              Types:
725
726                 This = wxAuiPaneInfo()
727
728              right/1  sets  the  pane  dock position to the right side of the
729              frame.
730
731              This is the same thing as calling Direction(wxAUI_DOCK_RIGHT).
732
733       rightDockable(This) -> wxAuiPaneInfo()
734
735              Types:
736
737                 This = wxAuiPaneInfo()
738
739       rightDockable(This, Options :: [Option]) -> wxAuiPaneInfo()
740
741              Types:
742
743                 This = wxAuiPaneInfo()
744                 Option = {b, boolean()}
745
746              rightDockable/2 indicates whether a pane can be  docked  on  the
747              right of the frame.
748
749       row(This, Row) -> wxAuiPaneInfo()
750
751              Types:
752
753                 This = wxAuiPaneInfo()
754                 Row = integer()
755
756              row/2 determines the row of the docked pane.
757
758       safeSet(This, Source) -> ok
759
760              Types:
761
762                 This = Source = wxAuiPaneInfo()
763
764              Write the safe parts of a PaneInfo object "source" into "this".
765
766              "Safe  parts" are all non-UI elements (e.g. all layout determin‐
767              ing parameters like the size,  position  etc.).  "Unsafe  parts"
768              (pointers  to button, frame and window) are not modified by this
769              write operation.
770
771              Remark: This method is used when loading perspectives.
772
773       setFlag(This, Flag, Option_state) -> wxAuiPaneInfo()
774
775              Types:
776
777                 This = wxAuiPaneInfo()
778                 Flag = integer()
779                 Option_state = boolean()
780
781              setFlag/3 turns the property given by flag on or  off  with  the
782              option_state parameter.
783
784       show(This) -> wxAuiPaneInfo()
785
786              Types:
787
788                 This = wxAuiPaneInfo()
789
790       show(This, Options :: [Option]) -> wxAuiPaneInfo()
791
792              Types:
793
794                 This = wxAuiPaneInfo()
795                 Option = {show, boolean()}
796
797              show/2 indicates that a pane should be shown.
798
799       toolbarPane(This) -> wxAuiPaneInfo()
800
801              Types:
802
803                 This = wxAuiPaneInfo()
804
805              toolbarPane/1  specifies  that the pane should adopt the default
806              toolbar pane settings.
807
808       top(This) -> wxAuiPaneInfo()
809
810              Types:
811
812                 This = wxAuiPaneInfo()
813
814              top/1 sets the pane dock position to the top of the frame.
815
816              This is the same thing as calling Direction(wxAUI_DOCK_TOP).
817
818       topDockable(This) -> wxAuiPaneInfo()
819
820              Types:
821
822                 This = wxAuiPaneInfo()
823
824       topDockable(This, Options :: [Option]) -> wxAuiPaneInfo()
825
826              Types:
827
828                 This = wxAuiPaneInfo()
829                 Option = {b, boolean()}
830
831              topDockable/2 indicates whether a pane can be docked at the  top
832              of the frame.
833
834       window(This, W) -> wxAuiPaneInfo()
835
836              Types:
837
838                 This = wxAuiPaneInfo()
839                 W = wxWindow:wxWindow()
840
841              window/2  assigns  the  window  pointer  that  the wxAuiPaneInfo
842              should use.
843
844              This normally does not need  to  be  specified,  as  the  window
845              pointer is automatically assigned to the wxAuiPaneInfo structure
846              as soon as it is added to the manager.
847
848       getWindow(This) -> wxWindow:wxWindow()
849
850              Types:
851
852                 This = wxAuiPaneInfo()
853
854       getFrame(This) -> wxFrame:wxFrame()
855
856              Types:
857
858                 This = wxAuiPaneInfo()
859
860       getDirection(This) -> integer()
861
862              Types:
863
864                 This = wxAuiPaneInfo()
865
866       getLayer(This) -> integer()
867
868              Types:
869
870                 This = wxAuiPaneInfo()
871
872       getRow(This) -> integer()
873
874              Types:
875
876                 This = wxAuiPaneInfo()
877
878       getPosition(This) -> integer()
879
880              Types:
881
882                 This = wxAuiPaneInfo()
883
884       getFloatingPosition(This) -> {X :: integer(), Y :: integer()}
885
886              Types:
887
888                 This = wxAuiPaneInfo()
889
890       getFloatingSize(This) -> {W :: integer(), H :: integer()}
891
892              Types:
893
894                 This = wxAuiPaneInfo()
895
896       destroy(This :: wxAuiPaneInfo()) -> ok
897
898              Destroys the object.
899
900
901
902wxWidgets team.                    wx 2.2.2                   wxAuiPaneInfo(3)