def __init__(self, parent, config):
wx.Panel.__init__(self, parent=parent, id=wx.ID_ANY)
scrolled_panel = ScrolledPanel(self)
scrolled_panel.SetAutoLayout(1)
scrolled_panel.SetupScrolling()
main_sizer = wx.BoxSizer(wx.HORIZONTAL)
grid_sizer = wx.FlexGridSizer(2, 10, 10)
for index, entry in enumerate(config):
if index > 0:
for _ in range(0, 2):
rule = wx.StaticLine(
scrolled_panel,
style=wx.LI_HORIZONTAL,
size=(-1, 2)
)
grid_sizer.Add(rule, proportion=1, flag=wx.EXPAND |
wx.TOP | wx.BOTTOM, border=10)
if entry.help_value:
grid_sizer.Add(1, 0, 1, wx.EXPAND)
help_sizer = wx.BoxSizer(wx.HORIZONTAL)
help_label = HidableAutoWrapStaticText(
parent=scrolled_panel,
label=u"%s" % entry.help_value.decode('utf8', 'ignore'),
kind='help_value',
)
help_sizer.Add(help_label, -1, wx.EXPAND)
grid_sizer.Add(help_sizer, 1, wx.EXPAND)
label_sizer = wx.BoxSizer(wx.VERTICAL)
label_sizer.Add(0, 1, 1, wx.EXPAND)
label = wx.StaticText(
scrolled_panel,
label=entry.key_name,
style=wx.ALIGN_RIGHT
)
label_sizer.Add(label, flag=wx.ALIGN_RIGHT)
label_sizer.Add(0, 1, 1, wx.EXPAND)
grid_sizer.Add(label_sizer, 0, wx.EXPAND)
current_value = wx.TextCtrl(
scrolled_panel,
value=str(entry.current),
size=(-1, -1)
)
grid_sizer.Add(current_value, -1, wx.EXPAND)
if entry.man:
grid_sizer.Add(1, 0, 1, wx.EXPAND)
man_sizer = wx.BoxSizer(wx.HORIZONTAL)
man_label = HidableAutoWrapStaticText(
parent=scrolled_panel,
label=u"%s" % entry.man.decode('utf8', 'ignore'),
kind='man',
)
man_sizer.Add(man_label, -1, wx.EXPAND)
grid_sizer.Add(man_sizer, 1, wx.EXPAND)
grid_sizer.AddGrowableCol(1, 1)
scroll_sizer = wx.BoxSizer(wx.HORIZONTAL)
scroll_sizer.Add(grid_sizer, 1, wx.EXPAND | wx.ALL, 10)
scrolled_panel.SetSizer(scroll_sizer)
main_sizer.Add(scrolled_panel, 1, wx.EXPAND)
self.SetSizer(main_sizer)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
bg_color = 'green'
# changes the background of the scrollbars
self.SetBackgroundColour(bg_color)
sizer = wx.BoxSizer(wx.VERTICAL)
panel = ScrolledPanel(self)
panel.SetBackgroundColour(bg_color)
panel.SetupScrolling(scroll_y=True)
panelsizer = wx.BoxSizer(wx.VERTICAL)
for _ in range(4):
p = wx.Panel(panel, size=(400, 300))
p.SetBackgroundColour(bg_color)
panelsizer.Add(p, 0, flag=wx.EXPAND)
panelsizer.Add((-1, 10))
panel.SetSizer(panelsizer)
for child in panel.GetChildren():
print(type(child)) # there is no scrollbar
sizer.Add(panel, 1, flag=wx.EXPAND)
self.SetSizer(sizer)
self.Layout()
def GenerateDataGrid(self, sizer):
vsizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, 'Column names and preview:'))
self.scrollW = ScrolledPanel(self, -1, size=(800, 150))
self.comboIDs = []
self.combos = []
fgSizer = wx.FlexGridSizer(1+len(self.dataLines), len(self.colNames), 4, 4)
for cn in self.colNames:
id = wx.NewId()
self.comboIDs.append(id)
cb = wx.ComboBox(self.scrollW, id, size=(120, -1), choices=[cn]+ list(self.requiredVariables.keys()) +list(self.recommendedVariables.keys()) + list(self.niceVariables.keys()))
self.combos.append(cb)
cb.SetSelection(0)
cb.Bind(wx.EVT_COMBOBOX, self.OnColNameChange)
cb.Bind(wx.EVT_TEXT, self.OnColNameChange)
fgSizer.Add(cb)
for dl in self.dataLines:
for de in dl:
fgSizer.Add(wx.StaticText(self.scrollW, -1, de))
self.scrollW.SetSizer(fgSizer)
self.scrollW.SetAutoLayout(True)
self.scrollW.SetupScrolling()
vsizer.Add(self.scrollW, 0, wx.EXPAND|wx.ALL,5)
sizer.Add(vsizer, 0, wx.EXPAND|wx.ALL,5)
def __init__(self, parent, ID, title):
wx.Frame.__init__(self, parent, ID, title, wx.DefaultPosition,
wx.Size(600, 400))
# Controls
self.tin = wx.TextCtrl(self,
size=wx.Size(600, 400),
style=wx.TE_MULTILINE)
self.test_panel = ScrolledPanel(self, size=wx.Size(600, 400))
self.test_panel.SetupScrolling()
self.tin2 = wx.StaticText(self.test_panel)
# Layout
# -- Scrolled Window
self.panel_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.panel_sizer.Add(self.tin2, 0, wx.EXPAND)
self.test_panel.SetSizer(self.panel_sizer)
self.panel_sizer.Fit(self.test_panel)
# -- Main Frame
self.inner_sizer = wx.BoxSizer(wx.HORIZONTAL)
self.inner_sizer.Add(self.tin, 1, wx.LEFT | wx.RIGHT | wx.EXPAND, 50)
self.inner_sizer.Add(self.test_panel, 1,
wx.LEFT | wx.RIGHT | wx.EXPAND, 50)
self.sizer = wx.BoxSizer(wx.VERTICAL)
self.sizer.Add(self.inner_sizer, 1, wx.ALL | wx.EXPAND, 20)
self.SetSizer(self.sizer)
self.sizer.Fit(self)
self.sizer.Layout()
self.test_panel.SetAutoLayout(1)
# Bind Events
self.tin.Bind(wx.EVT_TEXT, self.TextChange)
def __init__(self,
parent,
label_style='bold',
content_style='normal',
contents=None,
*args,
**kwargs):
dlg_style = wx.CAPTION | wx.CLOSE_BOX | wx.RESIZE_BORDER | wx.STAY_ON_TOP
IOTABaseDialog.__init__(self,
parent,
style=dlg_style,
label_style=label_style,
content_style=content_style,
size=(600, 500),
*args,
**kwargs)
self.txt_panel = ScrolledPanel(self)
self.txt_sizer = wx.BoxSizer(wx.VERTICAL)
self.txt_panel.SetSizer(self.txt_sizer)
self.txt = wx.StaticText(self.txt_panel, label=contents)
self.txt_sizer.Add(self.txt)
self.txt_panel.SetupScrolling()
self.envelope.Add(self.txt_panel,
1,
flag=wx.EXPAND | wx.ALL,
border=10)
def initUI(self):
""" Define dialog elements """
num_sensors = self.settings.ReadInt("numSensors", 1)
vbox0 = wx.BoxSizer(wx.VERTICAL)
pnl = ScrolledPanel(self)
vbox1 = wx.BoxSizer(wx.VERTICAL)
st = wx.StaticText(
pnl,
label="If the sensor numbers don't match, "
+ "make first the adjustments in "
+ "Settings>Ports",
size=(600, 60),
)
st.SetFont(wx.Font(18, wx.DEFAULT, wx.NORMAL, wx.NORMAL))
vbox1.Add(st, proportion=0, flag=wx.ALL)
image = wx.Image("docs/diagram.png", wx.BITMAP_TYPE_ANY).Rescale(450, 300)
imageBitmap = wx.StaticBitmap(pnl, bitmap=wx.Bitmap(image))
vbox1.Add(imageBitmap, proportion=1, flag=wx.ALL | wx.CENTER)
st = wx.StaticText(pnl, label="All distances in cm")
vbox1.Add(st, proportion=0, flag=wx.ALL)
self.setting_to_control = {}
self.addLabelledCtrl(pnl, vbox1, "DB1")
self.addLabelledCtrl(pnl, vbox1, "DB2")
for i in range(num_sensors):
self.addLabelledCtrl(pnl, vbox1, "DL" + str(i + 1))
for i in range(num_sensors):
self.addLabelledCtrl(pnl, vbox1, "DR" + str(i + 1))
if self.settings.ReadBool("connectedgL", False):
self.addLabelledCtrl(pnl, vbox1, "DGLX")
self.addLabelledCtrl(pnl, vbox1, "DGLY")
if self.settings.ReadBool("connectedgR", False):
self.addLabelledCtrl(pnl, vbox1, "DGRX")
self.addLabelledCtrl(pnl, vbox1, "DGRY")
if self.settings.ReadBool("connectedeL", False):
self.addLabelledCtrl(pnl, vbox1, "IEL")
self.addLabelledCtrl(pnl, vbox1, "DEL")
if self.settings.ReadBool("connectedeR", False):
self.addLabelledCtrl(pnl, vbox1, "IER")
self.addLabelledCtrl(pnl, vbox1, "DER")
pnl.SetSizer(vbox1)
pnl.SetupScrolling()
hbox = wx.BoxSizer(wx.HORIZONTAL)
okButton = wx.Button(self, label="OK")
cancelButton = wx.Button(self, label="Cancel")
hbox.Add(okButton)
hbox.Add(cancelButton, flag=wx.LEFT, border=5)
okButton.Bind(wx.EVT_BUTTON, self.OnOK)
cancelButton.Bind(wx.EVT_BUTTON, self.OnCancel)
vbox0.Add(pnl, proportion=1, flag=wx.ALL | wx.EXPAND, border=5)
vbox0.Add(hbox, proportion=0, flag=wx.ALIGN_CENTER | wx.ALL, border=10)
self.SetSizer(vbox0)
def __init__(self,
parent,
phil,
backend_name='BACKEND',
target=None,
content_style='normal',
label_style='bold',
opt_size=(500, 500),
phil_size=(500, 500),
*args,
**kwargs):
BaseDialog.__init__(self,
parent,
content_style=content_style,
label_style=label_style,
*args,
**kwargs)
self.parent = parent
self.target_phil = target
self.backend = backend_name
self.params = phil.extract()
self.opt_size = opt_size
self.phil_size = phil_size
self.sash_position = None
self.splitter = wx.SplitterWindow(self,
style=wx.SP_LIVE_UPDATE
| wx.SP_3DSASH | wx.SP_NOBORDER)
# Create options panel (all objects should be called as self.options.object)
self.options = ScrolledPanel(self.splitter, size=self.opt_size)
self.options_sizer = wx.BoxSizer(wx.VERTICAL)
self.options.SetSizer(self.options_sizer)
# Create PHIL panel
phil_label = "{} Target Settings".format(backend_name)
self.phil_panel = wx.Panel(self.splitter, size=self.opt_size)
phil_box = wx.StaticBox(self.phil_panel, label=phil_label)
self.phil_sizer = wx.StaticBoxSizer(phil_box, wx.VERTICAL)
self.phil_panel.SetSizer(self.phil_sizer)
# Dialog control
self.dlg_ctr = ct.DialogButtonsCtrl(self, preset='PROC_DIALOG')
# Splitter button
self.btn_hide_script = GenToggleButton(self, label='Show Script >>>')
self.show_hide_script()
self.btn_hide_script.SetValue(False)
self.main_sizer.Add(self.btn_hide_script,
flag=wx.ALIGN_RIGHT | wx.ALL,
border=10)
self.main_sizer.Add(self.splitter,
1,
flag=wx.EXPAND | wx.ALL,
border=10)
self.main_sizer.Add(self.dlg_ctr,
flag=wx.EXPAND | wx.ALIGN_RIGHT | wx.RIGHT,
border=10)
def update(self, **kwargs):
"""
Results
-------
wxPanel obj
https://stackoverflow.com/questions/3104323/getting-a-wxpython-panel-item-to-expand
"""
p1 = ScrolledPanel(self,
-1,
style=wx.TAB_TRAVERSAL | wx.SUNKEN_BORDER,
name="panel1")
p1.SetBackgroundColour("White")
vbox = wx.BoxSizer(wx.VERTICAL)
txt_info = wx.StaticText(p1, -1, txt)
txt_info.SetForegroundColour("Green")
vbox.Add(txt_info, 0, wx.ALIGN_LEFT | wx.ALL, 5)
vbox.Add(wx.StaticLine(p1, -1, size=(1024, -1)), 0, wx.ALL, 5)
vbox.Add((20, 20))
p1.SetSizer(vbox)
p1.SetAutoLayout(1)
p1.SetupScrolling()
return p1
def __init__(self, *args, **kwargs):
super(PanelContainer, self).__init__(*args, **kwargs)
self._current_panel = None
self._settings = RideSettings()
self.settings = self._settings['General']
self.title = wx.StaticText(self, label="Your message here")
self.panels_container = ScrolledPanel(self, wx.ID_ANY, style=wx.TAB_TRAVERSAL)
self.panels_container.SetupScrolling()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.title, 0, wx.TOP|wx.LEFT|wx.EXPAND, 4)
sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.TOP|wx.BOTTOM, 4)
sizer.Add(self.panels_container,1, wx.EXPAND)
self.SetSizer(sizer)
self.panels_container.SetSizer(wx.BoxSizer(wx.VERTICAL))
font = self.title.GetFont()
font.SetFaceName(self.settings['font face'])
font.SetPointSize(self.settings['font size'])
font.MakeLarger()
self.title.SetFont(font)
self.title.SetForegroundColour(self.settings['foreground'])
self.title.SetBackgroundColour(self.settings['background'])
self.SetForegroundColour(self.settings['foreground'])
self.SetBackgroundColour(self.settings['background'])
def __init__(self, parent, pos, size, model):
super(Frame, self).__init__(parent, pos, size, model)
# setup layout
self.ax_size = 200
figsize = (10, 10)
self.SetMinSize((400, 400))
# setup scrolled panel
panel = ScrolledPanel(self)
self.panel = panel
# setup figure canvas
self.canvas = FigureCanvasPanel(panel, figsize=figsize)
self.canvas.figure.subplots_adjust(0, 0, 1, 1, 0, 0)
panel.SetupScrolling(False, scrollToTop=False, scrollIntoView=False)
# sizer
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 0)
panel.SetSizer(sizer)
self.canvas_sizer = sizer
# Toolbar
tb = self.InitToolbar(can_open=False)
tb.AddSeparator()
# buttons
button = wx.Button(tb, ID.SHOW_SOURCES, "Sources")
button.Bind(wx.EVT_BUTTON, self.OnShowSources)
tb.AddControl(button)
button = wx.Button(tb, ID.FIND_RARE_EVENTS, "Rare Events")
button.Bind(wx.EVT_BUTTON, self.OnFindRareEvents)
tb.AddControl(button)
# tail
tb.AddStretchableSpace()
self.InitToolbarTail(tb)
tb.Realize()
self.CreateStatusBar()
# Bind Events ---
self.doc.callbacks.subscribe('case_change', self.CaseChanged)
self.panel.Bind(wx.EVT_SIZE, self.OnPanelResize)
self.canvas.mpl_connect('axes_enter_event', self.OnPointerEntersAxes)
self.canvas.mpl_connect('axes_leave_event', self.OnPointerEntersAxes)
self.canvas.mpl_connect('button_press_event', self.OnCanvasClick)
self.canvas.mpl_connect('key_release_event', self.OnCanvasKey)
# re-Bind right click
self.canvas.Unbind(wx.EVT_RIGHT_DOWN)
self.canvas.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
# attributes
self.last_model = ""
self.source_frame = None
self.butterfly_baseline = ID.BASELINE_NONE
# Finalize
self.plot()
self.UpdateTitle()
def make_page(self, title):
page = ScrolledPanel(parent=self.notebook, id=-1)
vbox = BoxSizer(VERTICAL)
field = Field(page, title)
self.get_fields(page, vbox, field)
self.fields.append(field)
page.SetupScrolling()
page.SetSizer(vbox)
self.notebook.AddPage(page, title)
def _create_control(self, parent):
""" Create the toolkit-specific control that represents the widget. """
panel = ScrolledPanel(parent, -1, style=self.STYLE)
sizer = wx.BoxSizer(wx.VERTICAL)
panel.SetSizer(sizer)
panel.SetAutoLayout(True)
panel.SetupScrolling()
return panel
def __init__(self, parent, config, **kwargs):
pdsim_panels.PDPanel.__init__(self, parent, **kwargs)
# Now we are going to put everything into a scrolled window
main_sizer = wx.BoxSizer(wx.VERTICAL)
# The scrolled panel
scrolled_panel = ScrolledPanel(self, size = (-1,-1), style = wx.TAB_TRAVERSAL, name="panel1")
scrolled_panel.SetScrollbars(1, 1, 1, 1)
annotated_GUI_objects = []
self.config = config
self.keys_for_config = []
#----------------------------------------------------------------------
# The sizer for all the heat transfer terms
sizer_for_port_inputs = wx.FlexGridSizer(cols = 2, vgap = 4, hgap = 4)
# Loop over the HT inputs
annotated_values = self.get_annotated_values(['d_discharge','d_suction'])
# Build the items and return the list of annotated GUI objects, add to existing list
annotated_GUI_objects += self.construct_items(annotated_values,
sizer = sizer_for_port_inputs,
parent = scrolled_panel)
#----------------------------------------------------------------------
# The sizer for all the valve terms
sizer_for_valve_inputs = wx.FlexGridSizer(cols = 2, vgap = 4, hgap = 4)
# Loop over the HT inputs
annotated_values = self.get_annotated_values(['valve_E','valve_d','valve_h','valve_l','valve_a','valve_x_stopper','valve_rho','valve_C_D'])
# Build the items and return the list of annotated GUI objects, add to existing list
annotated_GUI_objects += self.construct_items(annotated_values,
sizer = sizer_for_valve_inputs,
parent = scrolled_panel)
# Register terms in the GUI database
self.main.register_GUI_objects(annotated_GUI_objects)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(HeaderStaticText(scrolled_panel, "Geometric Inputs"), 0, wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(sizer_for_port_inputs, 0, wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(HeaderStaticText(scrolled_panel, "Valve Inputs"), 0, wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(sizer_for_valve_inputs, 0, wx.ALIGN_CENTER_HORIZONTAL)
scrolled_panel.SetSizer(sizer)
main_sizer.Add(scrolled_panel, 1, wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL)
self.SetSizer(main_sizer)
sizer.Layout()
def __init__(self, contents, *args, **kw):
super().__init__(*args, **kw)
icon_bundle = self.GetParent().GetIcons()
if not icon_bundle.IsEmpty():
self.SetIcon(icon_bundle.GetIconByIndex(0))
self.scrolled_panel = ScrolledPanel(self)
self.contents = HelpText(self.scrolled_panel, style=TE_MULTILINE)
self.layout()
self.contents.SetLabel(contents)
self.SetupScrolling()
def DoCreateResource(self):
assert self.GetInstance() is None
control = ScrolledPanel(parent=self.GetParentAsWindow(),
id=self.GetID(),
pos=self.GetPosition(),
size=self.GetSize(),
style=self.GetStyle(),
name=self.GetName())
self.SetupWindow(control)
self.CreateChildren(control)
return control
def __init__(self, *args, **kwargs):
"""Construct a new Config page.
"""
Page.__init__(self, name='Config', *args, **kwargs)
self.scrolledPanel = ScrolledPanel(self)
self.initSourceConfig()
self.initChannelConfig()
self.initMessageArea()
self.initLayout()
self.selectSource()
def __init__(self, parent, controller: C, scrollable=False, **kwargs):
"""Init."""
self._controller = controller
if scrollable:
self._ui_item = ScrolledPanel(parent)
self._ui_item.SetupScrolling()
else:
self._ui_item = wx.Panel(parent)
super().__init__()
self._sizer_ = wx.BoxSizer(wx.VERTICAL)
self.ui_item.SetSizer(self._sizer)
self._ui_item.Parent.Bind(wx.EVT_SIZE, self._on_size)
def __init__(self,user,passw):
"""This function sets the dimensions of the frame and
the layout of the buttons"""
self.user = user
self.passw=passw
wx.Frame.__init__(self, None, -1, 'Friends',
size=(500, 350))
self.panel = ScrolledPanel(self, size = wx.Size( 500, 350 ))
self.panel.SetupScrolling()
self.Bind(wx.EVT_CLOSE, self.OnCloseMe)
self.sizer = wx.FlexGridSizer(5,2,5,5)
self.buttons=[]
Publisher().subscribe(self.createButton, "update")
Publisher().subscribe(self.updateButton, "updatebuttons")
def _create_body(self, plugins, activation_callback):
panel = ScrolledPanel(self, wx.ID_ANY, style=wx.TAB_TRAVERSAL)
panel.SetupScrolling()
sizer = wx.FlexGridSizer(1, 2, hgap=8, vgap=8)
sizer.AddGrowableCol(1, 1)
sizer.Add(self._create_label(panel, 'Enabled'), 0, wx.BOTTOM, border=8)
sizer.Add(self._create_label(panel, 'Plugin'), 0,
wx.BOTTOM|wx.EXPAND, border=8)
for plugin in sorted(plugins, key=lambda p: p.name):
sizer.Add(_PluginEnablationCheckBox(panel, plugin, activation_callback),
flag=wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(_PluginRow(panel, plugin), 0, wx.EXPAND)
panel.SetSizer(sizer)
return panel
def construct_gui(self):
"""Constructs the page GUI"""
self.scrolled_panel = ScrolledPanel(self)
self.scrolled_panel.SetAutoLayout(1)
self.scrolled_panel.SetupScrolling()
self.main_sizer = BoxSizer(HORIZONTAL)
self.grid_sizer = FlexGridSizer(1, 10, 10)
for index, entry in enumerate(self.config):
self.construct_entry_row(entry, index)
self.grid_sizer.AddGrowableCol(0, 1)
scroll_sizer = BoxSizer(HORIZONTAL)
scroll_sizer.Add(self.grid_sizer, 1, EXPAND | ALL, 20)
self.scrolled_panel.SetSizer(scroll_sizer)
self.main_sizer.Add(self.scrolled_panel, 1, EXPAND)
self.SetSizer(self.main_sizer)
def __init__(self, parent):
wx.Dialog.__init__(self,
parent,
id=wx.ID_ANY,
title=u"车辆保险到期提醒",
pos=wx.DefaultPosition,
size=(800, 530),
style=wx.CAPTION | wx.STAY_ON_TOP
| wx.RESIZE_BORDER)
self.alarm_time = None
border = wx.BoxSizer(wx.VERTICAL)
# 操作条
opt_sizer = wx.BoxSizer(wx.HORIZONTAL)
if not auth.Auth.logon_user[2] == 2:
export_btn = wx.Button(self, wx.ID_ANY, u"导出")
self.Bind(wx.EVT_BUTTON, self.on_export, export_btn)
opt_sizer.Add(export_btn, 0, wx.ALIGN_CENTER_VERTICAL | wx.ALL, 5)
border.Add(opt_sizer, 0, wx.ALIGN_RIGHT, 5)
# 网格条
grid_boxer = wx.BoxSizer(wx.HORIZONTAL)
panel = ScrolledPanel(self, size=(780, 400))
alarm_grid = vehiclepanel.VehicleGrid(panel)
# 加载预警数据
self.data = service.search_vehicle(30, None)
alarm_grid.set_data(self.data)
grid_boxer.Add(alarm_grid, 0, wx.ALIGN_TOP, 5)
panel.SetSizer(grid_boxer)
panel.Fit()
panel.SetAutoLayout(1)
panel.SetupScrolling()
border.Add(panel, 0, wx.FIXED_MINSIZE, 5)
# 按钮条
buttons = wx.BoxSizer()
self.close_btn = wx.Button(self, wx.ID_OK, u"关闭")
self.close_btn.SetDefault()
self.close_btn.Enable(False)
buttons.Add(self.close_btn)
border.Add(buttons, 0, wx.ALIGN_RIGHT | wx.ALL, 5)
self.SetSizer(border)
def __init__(self, parent, song, audio_album):
wx.Dialog.__init__(self,
parent,
wx.ID_ANY,
"Tag Input",
size=(650, 240))
self.text_controls_v1 = {}
self.text_controls_v2 = {}
self.song = song
self.audio_album = audio_album
self.panel = ScrolledPanel(self, wx.ID_ANY)
self.panel.SetupScrolling()
self.sizer = wx.BoxSizer(wx.VERTICAL)
t1 = wx.StaticText(self.panel, label='ID3v1')
self.sizer.Add(t1)
for key in self.song.tags_v1.keys():
if key == 'Genre':
control = self.add_choice('Genre', self.song.tags_v1[key],
GENRES)
elif type(self.song.tags_v1[key]) == str:
control = self.add_text_control(key, self.song.tags_v1[key])
elif type(self.song.tags_v1[key]) == list:
control = self.add_int_controls(key, self.song.tags_v1[key])
self.text_controls_v1[key] = control
t2 = wx.StaticText(self.panel, label='ID3v2')
self.sizer.Add(t2)
for key in self.song.tags_v2.keys():
if key == 'Genre':
control = self.add_choice('Genre', self.song.tags_v2[key],
GENRES)
elif type(self.song.tags_v2[key]) == str:
control = self.add_text_control(key, self.song.tags_v2[key])
elif type(self.song.tags_v2[key]) == list:
control = self.add_int_controls(key, self.song.tags_v2[key])
self.text_controls_v2[key] = control
self.saveButton = wx.Button(self.panel, label="Save")
btn_sizer = wx.BoxSizer(wx.HORIZONTAL)
btn_sizer.Add(self.saveButton)
self.closeButton = wx.Button(self.panel, label="Cancel")
btn_sizer.Add(self.closeButton)
self.sizer.Add(btn_sizer)
self.saveButton.Bind(wx.EVT_BUTTON, self.save)
self.closeButton.Bind(wx.EVT_BUTTON, self.on_quit)
self.Bind(wx.EVT_CLOSE, self.on_quit)
self.panel.SetSizer(self.sizer)
self.Show()
def createInterface(self):
panel = wx.Panel(self, -1)
vbox = wx.BoxSizer(wx.VERTICAL)
hbox = wx.BoxSizer(wx.HORIZONTAL)
hbox.Add(wx.StaticText(panel, label='Current Vis Group : '))
currVisGroupCombo = wx.Choice(panel, -1, choices=self.visGroupNames)
currVisGroupCombo.Bind(wx.EVT_CHOICE, self.selectVisGroup)
hbox.Add(currVisGroupCombo)
panel.SetSizer(hbox)
scrolledPanel = ScrolledPanel(self)
vbox2 = wx.BoxSizer(wx.VERTICAL)
self.checkBoxes = []
for groupInfo in self.visGroups:
nodePath = groupInfo[0]
group = groupInfo[1]
name = group.getName()
checkBox = wx.CheckBox(scrolledPanel, -1, name)
checkBox.Bind(wx.EVT_CHECKBOX,
lambda p0=None, p1=name: self.toggleVisGroup(p0, p1))
self.checkBoxes.append(checkBox)
vbox2.Add(checkBox)
# Assemble list of groups visible from this group
visible = []
for i in range(group.getNumVisibles()):
visible.append(group.getVisibleName(i))
visible.sort()
self.visDict[name] = [nodePath, group, visible]
scrolledPanel.SetSizer(vbox2)
scrolledPanel.SetupScrolling(scroll_y=True, rate_y=20)
buttonPanel = wx.Panel(self, -1)
self.showOptionBox = wx.RadioBox(buttonPanel,
-1,
"",
choices=['Show All', 'Show Target'],
majorDimension=1,
style=wx.RA_SPECIFY_ROWS)
self.showOptionBox.Bind(wx.EVT_RADIOBOX, self.refreshVisibility)
vbox.Add(panel)
vbox.Add(scrolledPanel, 1, wx.EXPAND, 0)
vbox.Add(buttonPanel)
self.SetSizer(vbox)
def __init__(self, parent, config, **kwargs):
pdsim_panels.PDPanel.__init__(self, parent, **kwargs)
# Now we are going to put everything into a scrolled window
main_sizer = wx.BoxSizer(wx.VERTICAL)
# The scrolled panel
scrolled_panel = ScrolledPanel(self, size = (-1,-1), style = wx.TAB_TRAVERSAL, name="panel1")
scrolled_panel.SetScrollbars(1, 1, 1, 1)
annotated_GUI_objects = []
self.config = config
self.keys_for_config = []
#----------------------------------------------------------------------
# The sizer for all the heat transfer terms
sizer_for_inputs = wx.FlexGridSizer(cols = 2, vgap = 4, hgap = 4)
# Loop over the HT inputs
keys = ['piston_diameter','piston_length','crank_length',
'connecting_rod_length','x_TDC','shell_volume',
'inlet_tube_length','inlet_tube_ID','outlet_tube_length',
'outlet_tube_ID']
annotated_values = self.get_annotated_values(keys)
# Build the items and return the list of annotated GUI objects, add to existing list
annotated_GUI_objects += self.construct_items(annotated_values,
sizer = sizer_for_inputs,
parent = scrolled_panel)
# Register terms in the GUI database
self.main.register_GUI_objects(annotated_GUI_objects)
#self.main.get_GUI_object('L_ratio_bearings').GUI_location.SetToolTipString('Ratio of z1/z2, where\n\nz1 : the length from the centerline of the upper bearing to the lower bearing\nz2 : the length from the centerline of the upper bearing to the orbiting scroll bearing')
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(HeaderStaticText(scrolled_panel, "Geometric Inputs"), 0, wx.ALIGN_CENTER_HORIZONTAL)
sizer.Add(sizer_for_inputs, 0, wx.ALIGN_CENTER_HORIZONTAL)
scrolled_panel.SetSizer(sizer)
main_sizer.Add(scrolled_panel, 1, wx.EXPAND|wx.ALIGN_CENTER_HORIZONTAL)
self.SetSizer(main_sizer)
sizer.Layout()
def __init__(self, parent, **kwargs):
pdsim_panels.PDPanel.__init__(self, parent, **kwargs)
#Now we are going to put everything into a scrolled window
main_sizer = wx.BoxSizer(wx.VERTICAL)
self.scrolled_panel = ScrolledPanel(self,
size=(-1, -1),
style=wx.TAB_TRAVERSAL,
name="panel1")
self.scrolled_panel.SetScrollbars(1, 1, 1, 1)
self.scrolled_panel.SetupScrolling()
#Add the header row of buttons
self.View = wx.Button(self.scrolled_panel, label='View')
self.View.Bind(wx.EVT_BUTTON, self.OnView)
self.AddInjection = wx.Button(self.scrolled_panel,
label='Add Injection Line')
self.AddInjection.Bind(wx.EVT_BUTTON, self.OnAddInjection)
self.PlotExistence = wx.Button(self.scrolled_panel,
label='Plot Existence')
self.PlotExistence.Bind(wx.EVT_BUTTON, self.OnPlotExistence)
buttons_sizer = wx.BoxSizer(wx.HORIZONTAL)
buttons_sizer.Add(self.AddInjection)
buttons_sizer.Add(self.View)
buttons_sizer.Add(self.PlotExistence)
sizer = wx.FlexGridSizer(cols=1)
sizer.Add(buttons_sizer)
sizer.AddSpacer(10)
sizer.Layout()
self.scrolled_panel.SetAutoLayout(1)
#Do the layout of all the panels
self.scrolled_panel.SetSizer(sizer)
main_sizer.Add(self.scrolled_panel, 1, wx.EXPAND)
self.SetSizer(main_sizer)
main_sizer.Layout()
#Set some local variables
self.Nterms = 0
self.Lines = []
def __init__(self, *args, **kwargs):
super(PanelContainer, self).__init__(*args, **kwargs)
self._current_panel = None
self.title = wx.StaticText(self, label="Your message here")
self.panels_container = ScrolledPanel(self,
wx.ID_ANY,
style=wx.TAB_TRAVERSAL)
self.panels_container.SetupScrolling()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.title, 0, wx.TOP | wx.LEFT | wx.EXPAND, 4)
sizer.Add(wx.StaticLine(self), 0, wx.EXPAND | wx.TOP | wx.BOTTOM, 4)
sizer.Add(self.panels_container, 1, wx.EXPAND)
self.SetSizer(sizer)
self.panels_container.SetSizer(wx.BoxSizer(wx.VERTICAL))
font = self.title.GetFont()
font.SetPointSize(font.GetPointSize() + 2)
self.title.SetFont(font)
self.title.SetForegroundColour("#000000")
def main():
from wx.lib.scrolledpanel import ScrolledPanel
app = wx.PySimpleApp()
frame = wx.Frame(None, wx.ID_ANY, __doc__)
#~ sizer = wx.GridSizer(1, 1)
#~ canvas = irrlicht_canvas(frame)
panel = ScrolledPanel(frame, wx.ID_ANY)
sizer = wx.GridSizer(1, 1)
canvas = irrlicht_canvas(panel)
sizer.Add(canvas, 0, wx.EXPAND | wx.ALL)
panel.SetSizer(sizer)
panel.SetAutoLayout(1)
panel.SetupScrolling()
#~ frame.SetSizer(sizer)
#~ frame.SetAutoLayout(1)
app.SetTopWindow(frame)
#~ frame.SetIcon(wx.IconFromBitmap(svg_to_bitmap(logo, (32, 32), use_cairo = False)))
#~ frame.SetSize(canvas.GetVirtualSize())
frame.Show()
app.MainLoop()
def __init__(self, parent, id, title, pos, size, style, name):
super(DubList, self).__init__(parent, id, title, pos, size, style,
name)
masterSizer = wx.BoxSizer(wx.VERTICAL)
#self.SetSizeHints(wx.DefaultSize, wx.DefaultSize)
self.nodeNumbers = 0
#self.listWindow = scrolledpanel(self, wx.ID_ANY, self.Position, self.Size, wx.VSCROLL, "list window")
self.listWindow = ScrolledPanel(self, wx.ID_ANY, self.GetPosition(),
self.GetSize(),
wx.TAB_TRAVERSAL | wx.VSCROLL,
"list window")
self.listWindow.SetupScrolling(0, 1, 0, 20, 1, 1)
#self.listWindow.SetScrollRate(5,5) not needced
self.listOfNodes = []
self.mysizer = wx.GridBagSizer(5, 5)
#self.mysizer = wx.BoxSizer(wx.VERTICAL)
button = wx.Button(self.listWindow, wx.ID_ANY, "push new node",
wx.DefaultPosition + (150, 0), wx.DefaultSize, 0,
wx.DefaultValidator, "make")
button.Bind(wx.EVT_BUTTON, self.buttonDown, button)
button0 = wx.Button(self.listWindow, wx.ID_ANY, "pop last node",
wx.DefaultPosition + (260, 0), wx.DefaultSize,
wx.BU_EXACTFIT, wx.DefaultValidator, "take")
button0.Bind(wx.EVT_BUTTON, self.button0Down, button0)
#layout
#self.mysizer.SetSizeHints(self.listWindow) not needed
#self.mysizer.Add(button, 0,0,1,None)
#self.mysizer.Add(button0, 0,0,1,None)
self.mysizer.Add(button, (0, 1), (0, 0), 0, 1, "addButton")
self.mysizer.Add(button0, (1, 1), (0, 0), 0, 1, "removeButton")
self.listWindow.SetSizer(self.mysizer)
self.mysizer.Fit(self.listWindow)
self.listWindow.SetAutoLayout(1)
def __init__(self,
parent,
controller=None,
window=None,
enable_required=True,
scrolling=True):
wx.Notebook.__init__(self, parent)
self.Controller = controller
self.ParentWindow = window
self.Values = None
# Project Panel elements
self.ProjectPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)
self.ProjectPanel.SetAutoLayout(1)
if scrolling:
self.ProjectPanel.SetupScrolling()
projectpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=5, vgap=15)
projectpanel_sizer.AddGrowableCol(1)
self.ProjectPanel.SetSizer(projectpanel_sizer)
self.AddSizerParams(
self.ProjectPanel, projectpanel_sizer,
[("projectName", _('Project Name (required):')),
("projectVersion", _('Project Version (optional):')),
("productName", _('Product Name (required):')),
("productVersion", _('Product Version (required):')),
("productRelease", _('Product Release (optional):'))])
self.AddPage(self.ProjectPanel, _("Project"))
# Author Panel elements
self.AuthorPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)
self.AuthorPanel.SetAutoLayout(1)
if scrolling:
self.AuthorPanel.SetupScrolling()
authorpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=4, vgap=15)
authorpanel_sizer.AddGrowableCol(1)
self.AuthorPanel.SetSizer(authorpanel_sizer)
self.AddSizerParams(self.AuthorPanel, authorpanel_sizer,
[("companyName", _('Company Name (required):')),
("companyURL", _('Company URL (optional):')),
("authorName", _('Author Name (optional):')),
("organization", _('Organization (optional):'))])
self.AddPage(self.AuthorPanel, _("Author"))
# Graphics Panel elements
self.GraphicsPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)
self.GraphicsPanel.SetAutoLayout(1)
if scrolling:
self.GraphicsPanel.SetupScrolling()
graphicpanel_sizer = wx.FlexGridSizer(cols=1, hgap=5, rows=4, vgap=5)
graphicpanel_sizer.AddGrowableCol(0)
graphicpanel_sizer.AddGrowableRow(3)
self.GraphicsPanel.SetSizer(graphicpanel_sizer)
pageSize_st = wx.StaticText(self.GraphicsPanel,
label=_('Page Size (optional):'))
graphicpanel_sizer.AddWindow(pageSize_st,
border=10,
flag=wx.ALIGN_CENTER_VERTICAL | wx.TOP
| wx.LEFT | wx.RIGHT)
pageSize_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=5)
pageSize_sizer.AddGrowableCol(1)
graphicpanel_sizer.AddSizer(pageSize_sizer,
border=10,
flag=wx.GROW | wx.LEFT | wx.RIGHT)
for name, label in [('PageWidth', _('Width:')),
('PageHeight', _('Height:'))]:
st = wx.StaticText(self.GraphicsPanel, label=label)
pageSize_sizer.AddWindow(st,
border=12,
flag=wx.ALIGN_CENTER_VERTICAL | wx.LEFT)
sp = wx.SpinCtrl(self.GraphicsPanel,
min=0,
max=2**16,
style=wx.TE_PROCESS_ENTER)
setattr(self, name, sp)
callback = self.GetPageSizeChangedFunction(sp, name)
self.Bind(wx.EVT_TEXT_ENTER, callback, sp)
sp.Bind(wx.EVT_KILL_FOCUS, callback)
pageSize_sizer.AddWindow(sp, flag=wx.GROW)
scaling_st = wx.StaticText(self.GraphicsPanel,
label=_('Grid Resolution:'))
graphicpanel_sizer.AddWindow(scaling_st,
border=10,
flag=wx.GROW | wx.LEFT | wx.RIGHT)
scaling_nb = wx.Notebook(self.GraphicsPanel)
graphicpanel_sizer.AddWindow(scaling_nb,
border=10,
flag=wx.GROW | wx.BOTTOM | wx.LEFT
| wx.RIGHT)
self.Scalings = {}
for language, translation in [("FBD", _("FBD")), ("LD", _("LD")),
("SFC", _("SFC"))]:
scaling_panel = wx.Panel(scaling_nb, style=wx.TAB_TRAVERSAL)
scalingpanel_sizer = wx.FlexGridSizer(cols=2,
hgap=5,
rows=2,
vgap=5)
scalingpanel_sizer.AddGrowableCol(1)
scaling_panel.SetSizer(scalingpanel_sizer)
scaling_controls = []
for idx, (name, label) in enumerate([('XScale', _('Horizontal:')),
('YScale', _('Vertical:'))]):
if idx == 0:
border = wx.TOP
else:
border = wx.BOTTOM
st = wx.StaticText(scaling_panel, label=label)
scalingpanel_sizer.AddWindow(st,
border=10,
flag=wx.ALIGN_CENTER_VERTICAL
| border | wx.LEFT)
sp = wx.SpinCtrl(scaling_panel,
min=0,
max=2**16,
style=wx.TE_PROCESS_ENTER)
scaling_controls.append(sp)
callback = self.GetScalingChangedFunction(sp, language, name)
self.Bind(wx.EVT_TEXT_ENTER, callback, sp)
sp.Bind(wx.EVT_KILL_FOCUS, callback)
scalingpanel_sizer.AddWindow(sp,
border=10,
flag=wx.GROW | border | wx.RIGHT)
self.Scalings[language] = scaling_controls
scaling_nb.AddPage(scaling_panel, translation)
self.AddPage(self.GraphicsPanel, _("Graphics"))
# Miscellaneous Panel elements
self.DescriptionPanel = ScrolledPanel(parent=self,
name='DescriptionPanel',
style=wx.TAB_TRAVERSAL)
self.DescriptionPanel.SetAutoLayout(1)
if scrolling:
self.DescriptionPanel.SetupScrolling()
DescriptionPanel_sizer = wx.FlexGridSizer(cols=1,
hgap=5,
rows=5,
vgap=5)
DescriptionPanel_sizer.AddGrowableCol(0)
DescriptionPanel_sizer.AddGrowableRow(4)
self.DescriptionPanel.SetSizer(DescriptionPanel_sizer)
description_label = wx.StaticText(
self.DescriptionPanel, label=_('Content Description (optional):'))
DescriptionPanel_sizer.AddWindow(description_label,
border=10,
flag=wx.TOP | wx.LEFT)
self.ContentDescription = wx.TextCtrl(self.DescriptionPanel,
size=wx.Size(400, 200),
style=wx.TE_MULTILINE
| wx.TE_PROCESS_ENTER)
self.Bind(wx.EVT_TEXT_ENTER, self.OnContentDescriptionChanged,
self.ContentDescription)
self.ContentDescription.Bind(wx.EVT_KILL_FOCUS,
self.OnContentDescriptionChanged)
DescriptionPanel_sizer.AddWindow(self.ContentDescription,
border=10,
flag=wx.ALIGN_CENTER_VERTICAL | wx.TOP
| wx.LEFT | wx.RIGHT)
self.AddPage(self.DescriptionPanel, _("Description"))
for param in REQUIRED_PARAMS:
getattr(self, param).Enable(enable_required)
def initUI(self, num_sensors):
""" Define dialog elements """
ports = [""] + self.getSerialPorts()
cameras = [""] + self.getCameraPorts()
vbox0 = wx.BoxSizer(wx.VERTICAL)
pnl = ScrolledPanel(self)
vbox1 = wx.BoxSizer(wx.VERTICAL)
hbox0 = wx.BoxSizer(wx.HORIZONTAL)
st0 = wx.StaticText(pnl,
label="Number of sensor units per side",
size=(300, 30))
hbox0.Add(st0, proportion=0, flag=wx.ALL)
self.spinCtrl = wx.SpinCtrl(pnl, min=1, initial=num_sensors)
self.spinCtrl.Bind(wx.EVT_TEXT, self.OnNumberChange)
hbox0.Add(self.spinCtrl, proportion=0, flag=wx.ALL)
vbox1.Add(hbox0, proportion=0, border=10, flag=wx.TOP | wx.BOTTOM)
device_tuples = list(devices.values())
self.checkbox_to_combobox = {}
self.setting_to_checkbox = {}
for device_tuple in device_tuples:
name = device_tuple[0]
scaling = device_tuple[1]
vbox_aux = wx.BoxSizer(wx.VERTICAL)
st_aux = wx.StaticText(pnl, label=name, size=(120, 30))
vbox_aux.Add(st_aux, proportion=0, flag=wx.ALL)
if scaling:
for i in range(num_sensors):
self.addCheckComboBoxes(vbox_aux,
pnl,
ports,
name,
"L",
number=i + 1)
for i in range(num_sensors):
self.addCheckComboBoxes(vbox_aux,
pnl,
ports,
name,
"R",
number=i + 1)
else:
self.addCheckComboBoxes(vbox_aux, pnl, ports, name, "L")
self.addCheckComboBoxes(vbox_aux, pnl, ports, name, "R")
vbox1.Add(vbox_aux,
proportion=0,
border=10,
flag=wx.TOP | wx.BOTTOM | wx.EXPAND)
vbox_aux = wx.BoxSizer(wx.VERTICAL)
st_aux = wx.StaticText(pnl, label="Camera", size=(120, 30))
vbox_aux.Add(st_aux, proportion=0, flag=wx.ALL)
vbox1.Add(vbox_aux,
proportion=1,
border=10,
flag=wx.TOP | wx.BOTTOM | wx.EXPAND)
self.addCheckComboBoxes(vbox_aux, pnl, cameras, "Camera", "L")
self.addCheckComboBoxes(vbox_aux, pnl, cameras, "Camera", "R")
pnl.SetSizer(vbox1)
pnl.SetupScrolling()
hbox1 = wx.BoxSizer(wx.HORIZONTAL)
okButton = wx.Button(self, label="OK")
cancelButton = wx.Button(self, label="Cancel")
hbox1.Add(okButton)
hbox1.Add(cancelButton, flag=wx.LEFT, border=5)
okButton.Bind(wx.EVT_BUTTON, self.OnOK)
cancelButton.Bind(wx.EVT_BUTTON, self.OnCancel)
vbox0.Add(pnl, proportion=1, flag=wx.ALL | wx.EXPAND, border=5)
vbox0.Add(hbox1,
proportion=0,
flag=wx.ALIGN_CENTER | wx.ALL,
border=10)
self.SetSizer(vbox0)
