class EthernetTransport(DeviceTransport):
config = Instance(EthernetConfig, ()).tag(config=True)
connection = Instance(socket.socket)
#: Whether a serial connection spools depends on the device (configuration)
always_spools = set_default(False)
def connect(self):
print("SeroIP connected")
print(self.config.ip)
print(self.config.port)
self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.connection.connect((self.config.ip, int(self.config.port)))
self.connected = True
def write(self, data):
print("SeroIP printing " + data)
self.connection.send(data.encode())
def disconnect(self):
print("SeroIP disconnected")
self.connection.close()
self.connected = False
# if self.connection:
# self.connection.close()
def repr(self):
return self.config
class Measurement(LogicalChannel):
'''
A class for measurement channels.
Measurements are special because they can be different types:
autodyne which needs an IQ pair or hetero/homodyne which needs just a marker channel.
'''
meas_type = Enum(
'autodyne',
'homodyne').tag(desc='Type of measurement (autodyne, homodyne)')
autodyne_freq = Float(0.0).tag(
desc=
'use to bake the modulation into the pulse, so that it has constant phase'
)
frequency = Float(0.0).tag(
desc='use frequency to asssociate modulation with the channel')
pulse_params = Dict(
default={
'length': 100e-9,
'amp': 1.0,
'shape_fun': PulseShapes.tanh,
'cutoff': 2,
'sigma': 1e-9
})
gate_chan = Instance((str, LogicalMarkerChannel))
trig_chan = Instance((str, LogicalMarkerChannel))
receiver_chan = Instance((str, ReceiverChannel))
def __init__(self, **kwargs):
super(Measurement, self).__init__(**kwargs)
if self.trig_chan is None:
self.trig_chan = LogicalMarkerChannel(label='digitizerTrig')
class SerialTransport(DeviceTransport):
#: Default config
config = Instance(SerialConfig, ())
#: Connection port
connection = Instance(SerialPort)
#: Whether a serial connection spools depends on the device (configuration)
always_spools = set_default(False)
#: Wrapper
_protocol = Instance(InkcutProtocol)
def connect(self):
try:
config = self.config
#: Save a reference
self.protocol.transport = self
#: Make the wrapper
self._protocol = InkcutProtocol(self, self.protocol)
self.connection = SerialPort(
self._protocol,
config.port,
reactor,
baudrate=config.baudrate,
bytesize=config.bytesize,
parity=SERIAL_PARITIES[config.parity],
stopbits=config.stopbits,
xonxoff=config.xonxoff,
rtscts=config.rtscts
)
log.debug("{} | opened".format(self.config.port))
except Exception as e:
#: Make sure to log any issues as these tracebacks can get
#: squashed by twisted
log.error("{} | {}".format(
self.config.port, traceback.format_exc()
))
raise
def write(self, data):
if not self.connection:
raise IOError("Port is not opened")
log.debug("-> {} | {}".format(self.config.port, data))
if hasattr(data, 'encode'):
data = data.encode()
self._protocol.transport.write(data)
def disconnect(self):
if self.connection:
log.debug("{} | closed".format(self.config.port))
self.connection.loseConnection()
self.connection = None
def __repr__(self):
return self.config.port
class AbstractQtWidgetItem(AbstractQtWidgetItemGroup, ProxyAbstractWidgetItem):
#:
is_destroyed = Bool()
#: Index within the view
index = Instance(QModelIndex)
#: Delegate widget to display when editing the cell
#: if the widget is editable
delegate = Instance(QtWidget)
#: Reference to view
view = ForwardInstance(_abstract_item_view)
def create_widget(self):
# View items have no widget!
for child in self.children():
if isinstance(child, (Pattern, QtWidget)):
self.delegate = child
def init_widget(self):
pass
def init_layout(self):
super(AbstractQtWidgetItem, self).init_layout()
self._update_index()
def _update_index(self):
""" Update where this item is within the model"""
raise NotImplementedError
def destroy(self):
""" Set the flag so we know when this item is destroyed """
self.is_destroyed = True
super(AbstractQtWidgetItem, self).destroy()
class CalendarView(FrameLayout):
""" CalendarView is a view group that displays
child views in relative positions.
"""
#: Selected date
date = d_(Instance(datetime))
#: Max date
max_date = d_(Instance(datetime))
#: Min date
min_date = d_(Instance(datetime))
#: First day of week
first_day_of_week = d_(Range(1, 7))
#: A reference to the ProxyLabel object.
proxy = Typed(ProxyCalendarView)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe('date', 'max_date', 'min_date', 'first_day_of_week')
def _update_proxy(self, change):
""" An observer which sends the state change to the proxy.
"""
# The superclass implementation is sufficient.
super(CalendarView, self)._update_proxy(change)
class DatePicker(FrameLayout):
"""A simple control for displaying read-only text."""
#: Update the current year.
date = d_(Instance(datetime, factory=datetime.now))
#: Sets the minimal date supported by this DatePicker in milliseconds
#: since January 1, 1970 00:00:00 in getDefault() time zone.
min_date = d_(Instance(datetime, factory=datetime.now))
#: Sets the maximal date supported by this DatePicker in milliseconds
#: since January 1, 1970 00:00:00 in getDefault() time zone.
max_date = d_(Instance(datetime, factory=datetime.now))
#: Sets the first day of week.
first_day_of_week = d_(Range(1, 7))
#: A reference to the ProxyLabel object.
proxy = Typed(ProxyDatePicker)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe("date", "min_date", "max_date", "first_day_of_week")
def _update_proxy(self, change):
super()._update_proxy(change)
class CalendarView(FrameLayout):
"""CalendarView is a view group that displays
child views in relative positions.
"""
#: Selected date
date = d_(Instance(datetime, factory=datetime.now))
#: Max date
max_date = d_(Instance(datetime, factory=datetime.now))
#: Min date
min_date = d_(Instance(datetime, factory=datetime.now))
#: First day of week
first_day_of_week = d_(Range(1, 7))
#: A reference to the ProxyLabel object.
proxy = Typed(ProxyCalendarView)
# -------------------------------------------------------------------------
# Observers
# -------------------------------------------------------------------------
@observe("date", "max_date", "min_date", "first_day_of_week")
def _update_proxy(self, change):
super()._update_proxy(change)
class CodeComponent(RawComponent, ProxyCode):
#: Lexer used
lexer = Instance(Lexer)
#: HTML Formatter
formatter = Instance(HtmlFormatter)
def _default_formatter(self):
return HtmlFormatter(style=self.declaration.highlight_style)
def _default_lexer(self):
d = self.declaration
if d.language:
return lexers.find_lexer_class_by_name(d.language)()
return lexers.guess_lexer(d.source)
def set_source(self, source):
super(CodeComponent, self).set_source(
highlight(source, lexer=self.lexer, formatter=self.formatter))
def set_language(self, language):
self.lexer = self._default_lexer()
self.set_source(self.declaration.source)
def set_highlight_style(self, style):
self.formatter = self._default_formatter()
self.set_source(self.declaration.source)
class Comment(SQLModel):
page = Instance(Page)
author = Instance(User)
status = Enum("pending", "approved")
body = Str().tag(type=sa.UnicodeText())
reply_to = ForwardInstance(lambda: Comment).tag(nullable=True)
when = Instance(time)
class Bookmark(Atom):
#: Name of it
name = Unicode()
#: Bible
bible = ForwardInstance(lambda: Bible)
#: Book
book = Instance(Book)
#: Chapter
chapter = Instance(Chapter)
#: Verse
#verse = Instance(Verse)
#: Save / load state
state = Dict()
def __init__(self, *args, **kwargs):
super(Bookmark, self).__init__(*args, **kwargs)
if kwargs.get('state') is None:
#: If we're not loading from state
self.state = {
'bible': self.bible.version.key,
'book': self.book.name,
'chapter': self.chapter.number,
#'verse': self.verse.number
}
def _default_name(self):
return u"{} {}".format(self.book.name, self.chapter.number)
def _default_bible(self):
try:
#: Prevent loading two bibles if it was bookmarked in a different bible
bible = AppState.instance().bible
if bible is not None:
return bible
return AppState.instance().get_bible(self.state['bible'])
except KeyError:
return None
def _default_book(self):
if not self.bible:
return None
try:
return self.bible.get_book(self.state['book'])
except KeyError:
return None
def _default_chapter(self):
if not self.book:
return None
try:
#: They're supposed to be in order
return self.book.chapters[self.state['chapter'] - 1]
except KeyError:
return None
class OccSvg(OccShape, ProxySvg):
#: Update the class reference
reference = set_default('https://dev.opencascade.org/doc/refman/html/'
'class_b_rep_builder_a_p_i___make_wire.html')
#: Make wire
shape = Instance(TopoDS_Shape)
#: The document
doc = Instance(OccSvgDoc)
def create_shape(self):
d = self.declaration
if not d.source:
return
if os.path.exists(os.path.expanduser(d.source)):
svg = etree.parse(os.path.expanduser(d.source)).getroot()
else:
svg = etree.fromstring(d.source)
node = self.doc = OccSvgDoc(element=svg)
viewbox = svg.attrib.get('viewBox')
x, y = (0, 0)
sx, sy = (1, 1)
if viewbox:
ow = parse_unit(svg.attrib.get('width'))
oh = parse_unit(svg.attrib.get('height'))
x, y, iw, ih = map(parse_unit, viewbox.split())
sx = ow / iw
sy = oh / ih
builder = BRep_Builder()
shape = TopoDS_Compound()
builder.MakeCompound(shape)
shapes = node.create_shape()
for s in shapes:
builder.Add(shape, s)
bbox = self.get_bounding_box(shape)
# Move to position and align along direction axis
t = self.get_transform()
if d.mirror:
m = gp_Trsf()
m.SetMirror(gp_Ax2(gp_Pnt(*bbox.center), gp_Dir(0, 1, 0)))
t.Multiply(m)
# Apply viewport scale
s = gp_Trsf()
s.SetValues(sx, 0, 0, x, 0, sy, 0, y, 0, 0, 1, 0)
t.Multiply(s)
self.shape = BRepBuilderAPI_Transform(shape, t, False).Shape()
def set_source(self, source):
self.create_shape()
def set_mirror(self, mirror):
self.create_shape()
class MatPlot(Atom):
"""
Overall class for matplotlib figure. can have several child axes instances.
allow slider and next/prev buttons, interactive fitting?
"""
fig = Typed(Figure)
_axes = Instance(subplot_class_factory(), np.ndarray)
axes = Instance(AtomAxes, np.ndarray)
def __init__(self,
nrows=1,
ncols=1,
sharex=False,
sharey=False,
squeeze=True,
subplot_kw=None,
gridspec_kw=None,
**fig_kw):
super(MatPlot, self).__init__()
self.fig, self._axes = plt.subplots(nrows=1,
ncols=1,
sharex=sharex,
sharey=sharey,
squeeze=squeeze,
subplot_kw=subplot_kw,
gridspec_kw=gridspec_kw,
**fig_kw)
if isinstance(self._axes, np.ndarray):
self.axes = np.array([AtomAxes(self, ax)
for ax in self._axes]).reshape(nrows, ncols)
else:
self.axes = AtomAxes(self, self._axes)
def __iadd__(self, other):
if isinstance(self.axes, AtomAxes):
self.axes.add_dataobject(other)
else:
raise ValueError(
'Please add the DataObject to the appropriate axes')
return self
def __isub__(self, other):
if isinstance(self.axes, AtomAxes):
self.axes.remove_dataobject(other)
else:
raise ValueError(
'Please add the DataObject to the appropriate axes')
@staticmethod
def show(*args, **kwargs):
plt.show(*args, **kwargs)
@staticmethod
def savefig(*args, **kwargs):
plt.savefig(*args, **kwargs)
class AreaBase(Model):
#: Size (in px)
size = ContainerList(Float(), default=[1800, 2700]).tag(config=True)
# Left, Top, Right, Bottom (in px)
padding = ContainerList(Float(), default=[10, 10, 10, 10]).tag(config=True)
area = Instance(QtCore.QRectF)
path = Instance(QtGui.QPainterPath)
padding_path = Instance(QtGui.QPainterPath)
def _default_area(self):
return QtCore.QRectF(0, 0, self.size[0], self.size[1])
def _default_path(self):
p = QtGui.QPainterPath()
p.addRect(self.area)
return p
def _default_padding_path(self):
p = QtGui.QPainterPath()
p.addRect(self.available_area)
return p
@observe('size', 'padding')
def _sync_size(self, change):
self.area.setWidth(self.size[0])
self.area.setHeight(self.size[1])
self.path = self._default_path()
self.padding_path = self._default_padding_path()
@property
def padding_left(self):
return self.padding[0]
@property
def padding_top(self):
return self.padding[1]
@property
def padding_right(self):
return self.padding[2]
@property
def padding_bottom(self):
return self.padding[3]
def width(self):
return self.size[0]
def height(self):
return self.size[1]
@property
def available_area(self):
x, y = self.padding_left, self.padding_bottom
w, h = (self.size[0] - (self.padding_right + self.padding_left),
self.size[1] - (self.padding_bottom + self.padding_top))
return QtCore.QRectF(x, y, w, h)
class PageImage(SQLModel):
# Example through table for job role
page = Instance(Page).tag(nullable=False)
image = Instance(Page).tag(nullable=False)
class Meta:
db_table = "page_image_m2m"
unique_together = ("page", "image")
class OccPipe(OccOperation, ProxyPipe):
reference = set_default('https://dev.opencascade.org/doc/refman/html/'
'class_b_rep_offset_a_p_i___make_pipe.html')
#: References to observed shapes
_old_spline = Instance(OccShape)
_old_profile = Instance(OccShape)
fill_modes = Dict(
default={
'corrected_frenet': GeomFill_IsCorrectedFrenet,
'fixed': GeomFill_IsFixed,
'frenet': GeomFill_IsFrenet,
'constant_normal': GeomFill_IsConstantNormal,
'darboux': GeomFill_IsDarboux,
'guide_ac': GeomFill_IsGuideAC,
'guide_plan': GeomFill_IsGuidePlan,
'guide_ac_contact': GeomFill_IsGuideACWithContact,
'guide_plan_contact': GeomFill_IsGuidePlanWithContact,
'discrete_trihedron': GeomFill_IsDiscreteTrihedron
})
def update_shape(self, change=None):
d = self.declaration
if d.spline and d.profile:
spline, profile = d.spline, d.profile
elif d.spline:
spline = d.spline
profile = self.get_first_child().shape
elif d.profile:
profile = d.profile
spline = self.get_first_child().shape
else:
shapes = [
c.shape for c in self.children() if isinstance(c, OccShape)
]
spline, profile = shapes[0:2]
args = [coerce_shape(spline), coerce_shape(profile)]
# Make sure spline is a wire
if isinstance(args[0], TopoDS_Edge):
args[0] = BRepBuilderAPI_MakeWire(args[0]).Wire()
if d.fill_mode:
args.append(self.fill_modes[d.fill_mode])
pipe = BRepOffsetAPI_MakePipe(*args)
self.shape = pipe.Shape()
def set_spline(self, spline):
self.update_shape()
def set_profile(self, profile):
self.update_shape()
def set_fill_mode(self, mode):
self.update_shape()
class ViewerSelection(Atom):
#: Selected shape or shapes
selection = Dict()
#: Selection position, may be None
position = Instance(tuple)
#: Selection area, may be None
area = Instance(tuple)
class UserSettings(Model):
PasswordMode = BInt()
Email = Instance(Email)
News = Int()
Locale = Str()
LogAuth = BInt()
InvoiceText = Str()
TwoFactor = BInt()
Phone = Instance(Phone)
class AndroidDataSet(AndroidToolkitObject, ProxyDataSet):
#: Holds the data
data = Instance(EntryList)
#: Holds settings and such for the data
data_set = Instance(DataSet)
def create_widget(self):
self.data = EntryList()
self.data.entry_factory = self.parent().entry_factory
def init_widget(self):
super(AndroidDataSet, self).init_widget()
d = self.declaration
if d.data:
self.set_data(d.data)
#: Let the parent choose the type
chart = self.parent()
chart.make_data_set(self)
#: Now update the data set
if d.colors:
self.set_colors(d.colors)
if d.text_color:
self.set_text_color(d.text_color)
#: Text is set when the data set is created
if d.show_icons is not None:
self.set_show_icons(d.show_icons)
# --------------------------------------------------------------------------
# DataSet API
# --------------------------------------------------------------------------
def set_data(self, data):
self.data.refresh_data(data)
def update_data(self, change):
self.data.handle_change(change)
self.parent().handle_data_set_change(change)
def set_colors(self, colors):
if isinstance(colors, list):
self.data_set.setColors(colors)
else:
self.data_set.setColor(colors)
def set_text(self, text):
self.data_set.setLabel(text)
def set_text_color(self, color):
self.data_set.setValueTextColor(color)
def set_show_icons(self, show):
self.data_set.setDrawIcons(show)
class BooleanOperation(Operation):
shape1 = d_(Instance(object))
shape2 = d_(Instance(object))
#: Optional pave filler
pave_filler = d_(Instance(object)) #BOPAlgo_PaveFiller))
@observe('shape1', 'shape2', 'pave_filler')
def _update_proxy(self, change):
super(BooleanOperation, self)._update_proxy(change)
class FileTransport(DeviceTransport):
#: Default config
config = Instance(FileConfig, ()).tag(config=True)
#: The OS spools file writes
always_spools = set_default(True)
#: The output buffer
file = Instance(object)
#: Current path
path = Unicode()
def _default_path(self):
config = self.config
params = dict(time=str(time.time()).split(".")[0],
protocol=str(self.protocol.declaration.id).lower())
return join(config.directory, config.format.format(**params))
def connect(self):
config = self.config
path = self.path = self._default_path()
if not exists(config.directory):
os.makedirs(config.directory)
log.debug("-- File | Writing to '{}'".format(path))
self.file = open(path, 'wb')
self.connected = True
#: Save a reference
self.protocol.transport = self
self.protocol.connection_made()
def write(self, data):
log.debug("-> File | {}".format(data))
#: Python 3 is annoying
if hasattr(data, 'encode'):
data = data.encode()
self.file.write(data)
def read(self, size=None):
return ""
def disconnect(self):
log.debug("-- File | Closed '{}'".format(self.path))
self.connected = False
self.protocol.connection_lost()
if self.file:
self.file.close()
self.file = None
def __repr__(self):
return self.path
class PrinterTransport(DeviceTransport):
#: Default config
config = Instance(PrinterConfig).tag(config=True)
#: Delegate to the implementation based on the current platform
connection = Instance(PrinterConnection)
#: The OS printing subsystem will take care of spooling
always_spools = set_default(True)
def _default_config(self):
if sys.platform == 'win32':
return Win32PrinterConfig()
else:
return CupsPrinterConfig()
def _default_connection(self):
if sys.platform == 'win32':
return Win32PrinterConnection()
else:
return LPRPrinterConnection()
def connect(self):
try:
# Always create a new connection
self.connection = self._default_connection()
# Save a reference
self.protocol.transport = self
self.connection.transport = self
self.connection.open()
log.debug("{} | opened".format(self.config.printer))
except Exception as e:
# Make sure to log any issues as these tracebacks can get
# squashed by twisted
log.error("{} | {}".format(
self.config.printer, traceback.format_exc()
))
raise
def write(self, data):
if not self.connection:
raise IOError("Port is not opened")
self.connection.write(data)
def disconnect(self):
if self.connection:
self.connection.close()
log.debug("{} | closed".format(self.config.printer))
self.connection = None
def __repr__(self):
return self.config.printer
class Tweet(SQLModel):
id = Typed(int).tag(type=sa.BigInteger(), primary_key=True)
text = Unicode()
retweet = Bool(False)
created_at = Instance(datetime)
user = Instance(User).tag(nullable=False)
coin = Unicode(default='')
class Meta:
db_table = 'tweet'
class AbstractRibSlot(Operation):
#: Base shape
shape = d_(Instance(Shape))
#: Profile to make the pipe from
contour = d_(Instance(Shape))
#: Profile to make the pipe from
plane = d_(Instance(Shape))
#: Fuse (False to remove, True to add)
fuse = d_(Bool(False)).tag(view=True)
class RawFdTransport(DeviceTransport):
#: Default config
config = Instance(RawFdConfig, ()).tag(config=True)
#: The device handles
fd = Value()
#: Current path
device_path = Unicode()
#: Wrapper
_protocol = Instance(RawFdProtocol)
#: A raw device connection
connection = Instance(stdio.StandardIO)
def connect(self):
config = self.config
device_path = self.device_path = config.device_path
if 'win32' in sys.platform:
# Well, technically it works, but only with stdin and stdout
raise OSError("Raw device support cannot be used on Windows")
try:
self.fd = open(device_path, config.mode)
fd = self.fd.fileno()
log.debug("-- {} | opened".format(device_path))
self._protocol = RawFdProtocol(self, self.protocol)
self.connection = stdio.StandardIO(self._protocol, fd, fd)
except Exception as e:
#: Make sure to log any issues as these tracebacks can get
#: squashed by twisted
log.error("{} | {}".format(device_path, traceback.format_exc()))
raise
def write(self, data):
if not self.connection:
raise IOError("{} is not opened".format(self.device_path))
log.debug("-> {} | {}".format(self.device_path, data))
if hasattr(data, 'encode'):
data = data.encode()
self.last_write = data
self.connection.write(data)
def disconnect(self):
if self.connection:
log.debug("-- {} | closed by request".format(self.device_path))
self.connection.loseConnection()
self.connection = None
def __repr__(self):
return self.device_path
class Image(SQLModel):
name = Str().tag(length=100)
path = Str().tag(length=200)
metadata = Typed(dict).tag(nullable=True)
alpha = Range(low=0, high=255)
data = Instance(bytes).tag(nullable=True)
# Maps to sa.ARRAY, must include the item_type tag
# size = Tuple(int).tag(nullable=True)
#: Maps to sa.JSON
info = Instance(ImageInfo, ())
class EventsResponse(Response):
""" Expected response from api/events/<id> """
EventID = Str()
Refresh = BInt()
More = BInt()
Notices = List(Notice)
UsedSpace = Int()
Messages = List(MessageEvent)
MessageCounts = List(UnreadCount)
ConversationCounts = List(UnreadCount)
Conversations = List(ConversationEvent)
Total = Instance(EventsResult)
Unread = Instance(EventsResult)
class PreviewPlugin(Plugin):
#: Set's the plot that is drawn in the preview
preview = Instance(PreviewModel, ())
#: Plot for showing live status
live_preview = Instance(PreviewModel, ())
#: Transform applied to all view items
transform = Instance(QtGui.QTransform)
def _default_transform(self):
""" Qt displays top to bottom so this can be used to flip it.
"""
return QtGui.QTransform.fromScale(1, -1)
def set_preview(self, *items):
""" Sets the items that will be displayed in the plot
Parameters
----------
items: list of kwargs
A list of kwargs to to pass to each plot item
"""
t = self.transform
view_items = [
PainterPathPlotItem(kwargs.pop('path'), **kwargs)
for kwargs in items
]
self.preview.plot = view_items
def set_live_preview(self, *items):
""" Set the items that will be displayed in the live plot preview.
After set, use live_preview.update(position) to update it.
Parameters
----------
items: list of kwargs
A list of kwargs to to pass to each plot item
"""
view_items = [
PainterPathPlotItem(kwargs.pop('path'), **kwargs)
for kwargs in items
]
self.live_preview.init(view_items)
class AbstractGraphicsShapeItem(GraphicsItem):
"""A common base for all path items."""
#: Proxy reference
proxy = Typed(ProxyAbstractGraphicsShapeItem)
#: Set the pen or "line" style.
pen = d_(Instance(Pen))
#: Set the brush or "fill" style.
brush = d_(Instance(Brush))
@observe("pen", "brush")
def _update_proxy(self, change):
super(AbstractGraphicsShapeItem, self)._update_proxy(change)
class NoSQLModel(Model):
""" An atom model that can be serialized and deserialized to and from
MongoDB.
"""
#: ID of this object in the database
_id = Instance(bson.ObjectId)
#: Handles encoding and decoding
serializer = NoSQLModelSerializer.instance()
#: Handles database access
objects = NoSQLModelManager.instance()
async def save(self):
""" Alias to delete this object to the database """
db = self.objects
state = self.__getstate__()
if self._id is not None:
return await db.replace_one({'_id': self._id}, state, upsert=True)
else:
r = await db.insert_one(state)
self._id = r.inserted_id
return r
async def delete(self):
""" Alias to delete this object in the database """
db = self.objects
if self._id:
return await db.delete_one({'_id': self._id})
class Brush(Atom):
"""Defines the fill pattern"""
#: Color
color = ColorMember()
#: Image
image = Instance(Image)
#: Style
style = Enum(
"solid",
"dense1",
"dense2",
"dense3",
"dense4",
"dense5",
"dense6",
"dense7",
"horizontal",
"vertical",
"cross",
"diag",
"bdiag",
"fdiag",
"linear",
"radial",
"conical",
"texture",
"none",
)
#: Internal data
_tkdata = Value()
