1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
# (C) Copyright 2005-2023 Enthought, Inc., Austin, TX
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in LICENSE.txt and may be redistributed only under
# the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!
from io import StringIO
import sys
from traits.api import (
Enum, HasStrictTraits, Int, Instance, List, Str, Union,
)
class LayoutItem(HasStrictTraits):
""" The base class for all Task-related layout objects.
"""
def __repr__(self):
return self.pformat()
def iterleaves(self):
yield self
def pargs(self):
return []
def pformat(self, indent=0, multiline=False):
""" Pretty-format the layout item. Returns a string.
"""
stream = StringIO()
self.pstream(stream, indent, multiline)
return stream.getvalue()
def pprint(self, indent=0, multiline=False):
""" Pretty-prints the layout item.
"""
self.pstream(sys.stdout, indent, multiline)
def pstream(self, stream, indent=0, multiline=False):
""" Pretty-formats the layout item to a stream.
"""
call = self.__class__.__name__ + "("
indent += len(call)
stream.write(call)
args = [(None, arg) for arg in self.pargs()]
traits = []
for name, trait in sorted(self.traits().items()):
if not trait.pretty_skip and not trait.transient:
value = getattr(self, name)
if trait.default != value:
traits.append((name, value))
traits.sort()
args.extend(traits)
for i, (name, value) in enumerate(args):
arg_indent = indent
if name:
arg_indent += len(name) + 1
stream.write(name + "=")
if isinstance(value, LayoutItem):
value.pstream(stream, arg_indent, multiline)
else:
stream.write(repr(value))
if i < len(args) - 1:
stream.write(",")
if multiline:
stream.write("\n" + indent * " ")
else:
stream.write(" ")
stream.write(")")
class LayoutContainer(LayoutItem):
""" The base class for all layout items that contain other layout items.
"""
items = List(pretty_skip=True)
def __init__(self, *items, **traits):
# Items may either be specified as a positional arg or a kwarg.
if items:
if "items" in traits:
raise ValueError(
"Received 'items' as positional and keyword argument."
)
else:
traits["items"] = list(items)
super().__init__(**traits)
def iterleaves(self):
for item in self.items:
for leaf in item.iterleaves():
yield leaf
def pargs(self):
return self.items
class PaneItem(LayoutItem):
""" A pane in a Task layout.
"""
#: The ID of the item. If the item refers to a TaskPane, this is the ID of
#: that TaskPane.
id = Union(Str, Int, default_value="", pretty_skip=True)
#: The width of the pane in pixels. If not specified, the pane will be
#: sized according to its size hint.
width = Int(-1)
#: The height of the pane in pixels. If not specified, the pane will be
#: sized according to its size hint.
height = Int(-1)
def __init__(self, id="", **traits):
super().__init__(**traits)
self.id = id
def pargs(self):
return [self.id]
class Tabbed(LayoutContainer):
""" A tab area in a Task layout.
"""
#: A tabbed layout can only contain PaneItems as sub-items. Splitters and
#: other Tabbed layouts are not allowed.
items = List(PaneItem, pretty_skip=True)
#: The ID of the TaskPane which is active in layout. If not specified, the
#: first pane is active.
active_tab = Union(Str, Int, default_value="")
class Splitter(LayoutContainer):
""" A split area in a Task layout.
"""
#: The orientation of the splitter.
orientation = Enum("horizontal", "vertical")
#: The sub-items of the splitter, which are PaneItems, Tabbed layouts, and
#: other Splitters.
items = List(
Union(
Instance(PaneItem),
Instance(Tabbed),
Instance("pyface.tasks.task_layout.Splitter"),
),
pretty_skip=True,
)
class HSplitter(Splitter):
""" A convenience class for horizontal splitters.
"""
orientation = Str("horizontal")
class VSplitter(Splitter):
""" A convenience class for vertical splitters.
"""
orientation = Str("vertical")
class DockLayout(LayoutItem):
""" The layout for a main window's dock area.
"""
# The layouts for the task's dock panes.
left = Union(Instance(PaneItem), Instance(Tabbed), Instance(Splitter))
right = Union(Instance(PaneItem), Instance(Tabbed), Instance(Splitter))
top = Union(Instance(PaneItem), Instance(Tabbed), Instance(Splitter))
bottom = Union(Instance(PaneItem), Instance(Tabbed), Instance(Splitter))
#: Assignments of dock areas to the window's corners. By default, the top
#: and bottom dock areas extend into both of the top and both of the
#: bottom corners, respectively.
top_left_corner = Enum("top", "left")
top_right_corner = Enum("top", "right")
bottom_left_corner = Enum("bottom", "left")
bottom_right_corner = Enum("bottom", "right")
class TaskLayout(DockLayout):
""" The layout for a Task.
"""
#: The ID of the task for which this is a layout.
id = Str()
|
