def setDataControl(self):
if self.dataType == 1:
# integer, use wx.SpinCtrl
self.data_control = wx.SpinCtrl(self.parent,-1)
self.data_control.SetRange(-2147483648,2147483647)
# full Int range and not 0-100
if self.dataType in self.control_memory.keys():
self.data_control.SetValue(self.control_memory[self.dataType])
else:
self.data_control.SetValue(0)
wx.EVT_SPINCTRL(self.parent,self.data_control.GetId(),self.valueChanged)
wx.EVT_TEXT(self.parent,self.data_control.GetId(),self.valueChanged)
elif self.dataType in [2,3]:
# string, use a TextCtrl
self.data_control = wx.TextCtrl(self.parent,-1)
if self.dataType in self.control_memory.keys():
self.data_control.SetValue(self.control_memory[self.dataType])
elif self.dataType in[4,5]:
# object and location - unsupported
self.data_control = wx.StaticText(self.parent,-1,'Uneditable Data')
if self.dataType in self.control_memory.keys():
self.data_control.SetValue(self.control_memory[self.dataType])
if self.data_control:
self.Add(self.data_control,flag=wx.ALL,border=2)
self.Layout()
self.parent.propGrid.Layout()
def init(self, parent):
""" Finishes initializing the editor by creating the underlying toolkit
widget.
"""
factory = self.factory
if not factory.low_name:
self.low = factory.low
if not factory.high_name:
self.high = factory.high
self.sync_value(factory.low_name, 'low', 'from')
self.sync_value(factory.high_name, 'high', 'from')
low = self.low
high = self.high
self.control = wx.SpinCtrl(parent,
-1,
self.str_value,
min=low,
max=high,
initial=self.value)
wx.EVT_SPINCTRL(parent, self.control.GetId(), self.update_object)
if wx.VERSION < (3, 0):
wx.EVT_TEXT(parent, self.control.GetId(), self.update_object)
self.set_tooltip()
def bind_event(self, function):
def func_2(event):
if self.is_active():
function(event)
event.Skip()
wx.EVT_KILL_FOCUS(self.spin, func_2)
if wx.Platform == '__WXMAC__' or self.immediate:
wx.EVT_TEXT(self.spin, self.spin.GetId(), func_2)
wx.EVT_SPINCTRL(self.spin, self.spin.GetId(), func_2)
def __init__(self, parent, name):
PPanel.__init__(self, parent, name)
self.ID_SPIN_CTRL = wx.NewId()
sizer = wx.BoxSizer()
self.spin = wx.SpinCtrl(self, self.ID_SPIN_CTRL, size=(60, -1))
self.spin.SetRange(0, 10000) # min/max integers
sizer.Add(self.spin)
self.SetAutoLayout(True)
self.SetSizerAndFit(sizer)
wx.EVT_SPINCTRL(self, self.ID_SPIN_CTRL, self.OnChange)
def SetupSpinCtrl(self): SpinCtrlID=wx.NewId() self.widget=wx.SpinCtrl(self,SpinCtrlID,size=self.button_size) self.widget.SetRange(self.obj_dict['min'],self.obj_dict['max']) self.widget.SetValue(int(self.obj_dict['value'])) self.sbsizer.Add(self.widget) wx.EVT_SPINCTRL(self.widget,SpinCtrlID,self.SpinCtrlCB) label_str='' self.label=wx.StaticText(self,wx.NewId(),label_str,size=self.button_size) self.label.SetLabel(`self.obj_dict['value']`) self.sbsizer.Add(self.label)
def _bindEvents(self):
wx.EVT_BUTTON(self.viewerFrame, self.viewerFrame.showControlsButtonId,
self._handlerShowControls)
wx.EVT_BUTTON(self.viewerFrame, self.viewerFrame.resetCameraButtonId,
lambda e: self._resetCamera())
wx.EVT_SPINCTRL(self.controlFrame,
self.controlFrame.pairNumberSpinCtrlId,
self._handlerPairNumberSpinCtrl)
wx.EVT_BUTTON(self.controlFrame, self.controlFrame.transformButtonId,
self._handlerTransformButton)
wx.EVT_BUTTON(self.controlFrame, self.controlFrame.registerButtonId,
self._handlerRegisterButton)
def __init__(self, FileName):
wx.Dialog.__init__(self, None, title="Importing a CSV file",\
size=(600,470))
self.FileName = FileName
self.decider = wx.Notebook(self, -1, pos=(10,0), \
size=(580,240), style=wx.NB_TOP)
self.p1 = PanelDelimiter(self.decider, self.FileName.fileName)
self.p2 = PanelFixedWidth(self.decider, self.FileName.fileName)
self.decider.AddPage(self.p1, "Delimited files")
self.decider.AddPage(self.p2, "Fixed width files")
t1 = wx.StaticText(self, -1, label="Import from row:", pos=(245, 250))
self.headerRow = wx.CheckBox(self, 760, " Header on first row", \
pos=(430,250))
self.dataRow = wx.SpinCtrl(self,766,min=1,max=100, initial=1, \
pos=(365,250),size=(50,-1))
self.dataRow.SetValue(1)
self.buttonImport = wx.Button(self,763,"Import", \
pos=(500,400),size=(70,-1))
self.buttonImport.SetDefault()
self.buttonCancel = wx.Button(self,764,"Cancel", \
pos=(405,400),size=(70,-1))
self.grid = gridlib.Grid(self, -1, size=(560, 100), pos=(20, 290))
#self.grid.HideRowLabels()
self.MaxRows = 100
self.MaxCols = 8
self.grid.SetColLabelSize(16)
self.grid.SetRowLabelSize(40)
self.grid.SetDefaultColSize(60)
self.grid.CreateGrid(self.MaxRows, self.MaxCols)
for i in range(8):
self.grid.SetRowSize(i, 16)
self.grid.SetColLabelValue(i, " ")
self.gridFont = wx.Font(10, wx.MODERN, wx.NORMAL, wx.NORMAL)
self.grid.SetDefaultCellFont(self.gridFont)
lineEndChoices = [
'Not sure', '\\n (Unix)', '\\r\\n (Windows)', '\\r (old Mac)'
]
t3 = wx.StaticText(self, -1, "Line ending:", pos=(20, 250))
self.lineEnd = wx.Choice(self, 765,pos=(105,248),size=(120,-1),\
choices = lineEndChoices)
self.AttemptPreview()
# It seems odd but it seems better for all events to be routed to the same method
wx.EVT_CHECKBOX(self, 760, self.AttemptPreview)
wx.EVT_TEXT(self, 761, self.AttemptPreview)
wx.EVT_TEXT(self, 762, self.AttemptPreview)
wx.EVT_BUTTON(self, 764, self.CancelButton)
wx.EVT_BUTTON(self, 763, self.ImportButton)
wx.EVT_CHOICE(self, 765, self.AttemptPreview)
wx.EVT_SPINCTRL(self, 766, self.AttemptPreview)
def __init__(self, MainFrame):
# Create data table window
wx.Frame.__init__(self,
None,
wx.ID_ANY,
title="Data Entry",
style=wx.DEFAULT_FRAME_STYLE | wx.RESIZE_BORDER)
self.MainFrame = MainFrame
# Panel: Data Entry
PanelDataEntry = wx.Panel(self, wx.ID_ANY)
sizerPanelDataEntry = wx.BoxSizer(wx.HORIZONTAL)
# Panel: Data Sheet (XLS-style)
PanelSheet = wx.Panel(PanelDataEntry, wx.ID_ANY)
sizerPanelSheet = wx.BoxSizer(wx.VERTICAL)
sizerPanelSheet.AddSpacer(5)
# Panel: Cell content field at top of data sheet
PanelCellContent = wx.Panel(PanelSheet, wx.ID_ANY)
sizerPanelCellContent = wx.BoxSizer(wx.HORIZONTAL)
sizerPanelCellContent.AddSpacer(10)
TextContentCell = wx.StaticText(PanelCellContent,
wx.ID_ANY,
label='Cell Content:',
style=wx.ALIGN_LEFT)
sizerPanelCellContent.Add(TextContentCell, 0, wx.EXPAND)
sizerPanelCellContent.AddSpacer(3)
self.CellContentTxt = wx.TextCtrl(PanelCellContent,
wx.ID_ANY,
value="",
size=(861, 23),
style=wx.TE_READONLY)
sizerPanelCellContent.Add(self.CellContentTxt, 0, wx.EXPAND)
PanelCellContent.SetSizer(sizerPanelCellContent)
sizerPanelSheet.Add(PanelCellContent)
sizerPanelSheet.AddSpacer(5)
# Grid: XLS (XLS-style)
self.Sheet = wx.grid.Grid(PanelSheet)
# Specify gird relevant variables
self.factorNames = []
self.factorLevels = []
self.Sheet.nRow = 30
self.Sheet.nCol = 11
self.Sheet.content4undo = [0, 0, '']
self.Sheet.filePath = ''
# Creating the grid object (specify label names)
self.Sheet.CreateGrid(self.Sheet.nRow, self.Sheet.nCol)
self.Sheet.SetColLabelValue(0, "Subject")
for i in xrange(1, self.Sheet.nCol):
self.Sheet.SetColLabelValue(i, "F%d" % i)
# Create the grid object
sizerPanelSheet.Add(self.Sheet)
PanelSheet.SetSizer(sizerPanelSheet)
sizerPanelDataEntry.Add(PanelSheet, 0, wx.EXPAND)
sizerPanelDataEntry.AddSpacer(10)
# Panel: Button field below table
PanelButton = wx.Panel(self, wx.ID_ANY)
sizerButton = wx.BoxSizer(wx.HORIZONTAL)
sizerButton.AddSpacer(10)
# Number of Rows Field
TextInserRow = wx.StaticText(PanelButton,
wx.ID_ANY,
label="Number of &Rows: ")
sizerButton.Add(TextInserRow, 0, wx.ALIGN_CENTRE)
self.Sheet.nRow = self.Sheet.GetNumberRows()
self.Row = wx.SpinCtrl(PanelButton,
1,
str(self.Sheet.nRow),
size=(75, 25),
min=1,
max=1000,
style=wx.SP_ARROW_KEYS)
sizerButton.Add(self.Row, 0, wx.EXPAND)
sizerButton.AddSpacer(20)
# Number of Columns Field
TextInserCol = wx.StaticText(PanelButton,
wx.ID_ANY,
label="Number of &Columns: ")
sizerButton.Add(TextInserCol, 0, wx.ALIGN_CENTRE)
self.Sheet.nCol = self.Sheet.GetNumberCols()
self.Col = wx.SpinCtrl(PanelButton,
2,
str(self.Sheet.nCol),
size=(75, 25),
min=1,
max=1000,
style=wx.SP_ARROW_KEYS)
sizerButton.Add(self.Col, 0, wx.EXPAND)
sizerButton.AddSpacer(20)
# Define Import Button
ButtonImport = wx.Button(PanelButton,
wx.ID_ANY,
size=(135, 25),
label="&Import CSV Table")
sizerButton.Add(ButtonImport, 0, wx.EXPAND)
sizerButton.AddSpacer(20)
# Define Save Button
ButtonSave = wx.Button(PanelButton,
wx.ID_ANY,
size=(135, 25),
label="&Save Table as CSV")
sizerButton.Add(ButtonSave, 0, wx.EXPAND)
sizerButton.AddSpacer(20)
# Define Factor Button
ButtonDefineFactor = wx.Button(PanelButton,
wx.ID_ANY,
size=(135, 25),
label="&Define Factor")
sizerButton.Add(ButtonDefineFactor, 0, wx.EXPAND)
sizerButton.AddSpacer(20)
# Resize everything and create the window
PanelButton.SetSizerAndFit(sizerButton)
sizerFrame = wx.BoxSizer(wx.VERTICAL)
sizerFrame.Add(PanelDataEntry, 0, wx.EXPAND)
sizerFrame.AddSpacer(5)
sizerFrame.Add(PanelButton, 0, wx.EXPAND)
sizerFrame.AddSpacer(5)
PanelDataEntry.SetSizer(sizerPanelDataEntry)
self.SetSizerAndFit(sizerFrame)
# Specification of events
wx.EVT_SPINCTRL(self, self.Row.Id, self.modifyRow)
wx.EVT_SPINCTRL(self, self.Col.Id, self.modifyCol)
wx.EVT_BUTTON(self, ButtonDefineFactor.Id, self.defineFactor)
wx.EVT_BUTTON(self, ButtonSave.Id, self.exportData)
wx.EVT_BUTTON(self, ButtonImport.Id, self.importData)
self.Bind(wx.EVT_CLOSE, self.onClose)
self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.onCellSelected)
self.Bind(wx.EVT_CHAR_HOOK, self.onKeyDown)
# Specify grid events
self.Sheet.Bind(wx.grid.EVT_GRID_LABEL_RIGHT_CLICK,
self.onLabelRightClick)
self.Bind(wx.grid.EVT_GRID_CELL_RIGHT_CLICK, self.onCellRightClick)
# Drag and Drop Function
dropTarget = GridFileDropTarget(self)
self.Sheet.SetDropTarget(dropTarget)
self.Sheet.EnableDragRowSize()
self.Sheet.EnableDragColSize()
# Fill in table if dataset already exists
if self.MainFrame.Dataset != {}:
self.loadDataset()
def __init__(self, parent, key, val, global_config, env):
if DEBUG: print key, val
self.parent = parent
self.env = env
self.key = key
self.val = val
self.global_config = global_config
self.env = env
WIDGET_W = global_config['CONFIG_WIDGET_W']['value']
WIDGET_H = global_config['CONFIG_WIDGET_H']['value']
self.wsize = wx.Size(WIDGET_W, WIDGET_H)
self.sbox = wx.StaticBox(self.parent, -1, key, style=wx.BORDER_STATIC)
self.sbox.SetWindowStyle(wx.BORDER_NONE)
self.sizer = wx.StaticBoxSizer(self.sbox, wx.HORIZONTAL)
self.widget = None
self.label = None
self.defaultB = None
self.showColourDialogB = None
self.defaultBID = wx.NewId()
self.set = 0
self.bmp = None
#every CfgCtrlObj has a defaultB:
self.defaultB = wx.Button(self.parent,
self.defaultBID,
"Default",
size=self.wsize)
if self.val['wtype'] == 'wx.ComboBox':
cbID = wx.NewId()
cb = wx.ComboBox(self.parent, cbID, size=self.wsize, choices=[])
for idx in range(len(self.val['default'])):
cb.Append(self.val['default'][idx])
cb.SetValue(self.val['value'])
self.widget = cb
#self.widget.SetValue(self.val['value'])
self.sizer.Add(self.widget)
wx.EVT_COMBOBOX(self.parent, cbID, self.comboCB)
if self.val['icon']:
#in this version, if icon, then actor.
fname = os.path.abspath(
os.path.join(self.env.sitepkgdir, global_config['APPNAME'],
'Actors', self.val['value'], 'icon.gif'))
gif = wx.Image(fname, wx.BITMAP_TYPE_GIF).ConvertToBitmap()
self.bmp = wx.StaticBitmap(
self.parent, -1, gif) #,size=wx.Size(WIDGET_W,WIDGET_W)
self.sizer.Add(self.bmp)
else:
self.label = wx.StaticText(self.parent,
wx.NewId(),
'',
size=self.wsize)
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.TextCtrl':
self.widget = wx.TextCtrl(self.parent,
wx.NewId(),
style=self.val['style'],
size=self.wsize)
self.widget.SetValue(self.val['value'])
self.widget.SetLabel(self.val['descr'])
self.sizer.Add(self.widget)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.ImageDialog':
ImgBrowserID = wx.NewId()
self.widget = ib.ImageDialog(
self.parent,
self.val['path'],
)
ibID = wx.NewId()
self.ibB = wx.Button(self.parent,
ibID,
"ImageDialog",
size=self.wsize)
self.sizer.Add(self.ibB)
wx.EVT_BUTTON(self.ibB, ibID, self.imagedialogCB)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.label.SetLabel(self.val['value'])
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.FileDialog':
FileDialogID = wx.NewId()
self.widget = wx.FileDialog(
self.parent,
message="Choose file",
defaultDir=self.val['path'],
)
fdID = wx.NewId()
self.fdB = wx.Button(self.parent,
fdID,
"ShowDialog",
size=self.wsize)
self.sizer.Add(self.fdB)
wx.EVT_BUTTON(self.fdB, fdID, self.filedialogCB)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.label.SetLabel(self.val['value'])
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.CheckBox':
CheckBoxID = wx.NewId()
self.widget = wx.CheckBox(self.parent,
CheckBoxID,
"",
size=self.wsize)
self.widget.SetValue(int(self.val['value']))
self.sizer.Add(self.widget)
wx.EVT_CHECKBOX(self.widget, CheckBoxID, self.checkboxCB)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.label.SetLabel( ` self.val['value'] `)
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
self.checkboxCB(None) #to set the label after label exists
elif self.val['wtype'] == 'wx.SpinCtrl':
SpinCtrlID = wx.NewId()
self.widget = wx.SpinCtrl(self.parent, SpinCtrlID, size=self.wsize)
self.widget.SetRange(self.val['min'], self.val['max'])
self.widget.SetValue(int(self.val['value']))
self.sizer.Add(self.widget)
wx.EVT_SPINCTRL(self.widget, SpinCtrlID, self.spinctrlCB)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.label.SetLabel( ` self.val['value'] `)
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.ColourDialog':
self.widget = wx.ColourDialog(self.parent)
self.widget.GetColourData().SetChooseFull(True)
self.widget.GetColourData().SetColour(
wx.Colour(self.val['value'][0], self.val['value'][1],
self.val['value'][2]))
showColourDialogBID = wx.NewId()
self.showColourDialogB = wx.Button(self.parent,
showColourDialogBID,
"ShowDialog",
size=self.wsize)
self.showColourDialogB.SetBackgroundColour(
self.widget.GetColourData().GetColour().Get())
self.sizer.Add(self.showColourDialogB)
wx.EVT_BUTTON(self.showColourDialogB, showColourDialogBID,
self.showColourDialogCB)
label_str = ''
self.label = wx.StaticText(self.parent,
wx.NewId(),
label_str,
size=self.wsize)
self.label.SetLabel( ` self.val['value'] `)
self.sizer.Add(self.label)
self.defaultB.SetBackgroundColour(self.val['default'])
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
elif self.val['wtype'] == 'wx.Slider':
self.widget = wx.Slider(self.parent,
wx.NewId(),
int(self.val['value'] *
self.val['divisor']),
int(self.val['min']),
int(self.val['max']),
style=self.val['style'],
size=self.wsize)
self.sizer.Add(self.widget)
sliderID = wx.NewId()
div = self.val['divisor']
if div == 1.: label_str = "%.0f" % (self.val['value'])
if div == 10.: label_str = "%.1f" % (self.val['value'])
if div == 100.: label_str = "%.2f" % (self.val['value'])
if div == 1000.: label_str = "%.3f" % (self.val['value'])
if div == 10000.: label_str = "%.4f" % (self.val['value'])
self.label = wx.StaticText(self.parent,
sliderID,
label_str,
size=self.wsize)
self.sizer.Add(self.label)
wx.EVT_BUTTON(self.defaultB, self.defaultBID, self.defaultCB)
wx.EVT_SCROLL(self.widget, self.sliderCB)
self.sizer.Add(self.defaultB)
if self.val.has_key('tooltip'):
if DEBUG: print self.val
self.defaultB.SetToolTip(wx.ToolTip(self.val['tooltip']))
def __init__(self, URL):
wx.Dialog.__init__(self, None, title="Scraping a web page",\
size=(600,380))
self.URL = URL
# ensure URL is a valid URL
# TODO
# page is retrieved
try:
request = requests.get(self.URL)
page = request.text
except:
page = None
# page is parsed and tables extracted
if not page:
self.URL = None
self.Close()
else:
parser = HTMLParser.HTMLParser()
soup = BS.BeautifulSoup(page)
self.tables = soup.findAll('table')
# user selects which table to import
# table & data are imported
ID_WINDOW_CLOSE = wx.NewId()
help_text = "These are all the tables in the web page you just entered. "
t1 = wx.StaticText(self, -1, label=help_text, pos=(20, 10))
t1.Wrap(545)
t2 = wx.StaticText(self,
-1,
label="Import from row:",
pos=(20, 50))
self.headerRow = wx.CheckBox(self, 760, " Header on first row", \
pos=(210,50))
self.dataRow = wx.SpinCtrl(self,766,min=1,max=100, initial=1, \
pos=(140,49),size=(50,-1))
self.dataRow.SetValue(1)
self.buttonImport = wx.Button(self,763,"Import", \
pos=(500,310),size=(70,-1))
self.buttonImport.SetDefault()
self.buttonCancel = wx.Button(self,764,"Cancel", \
pos=(405,310),size=(70,-1))
self.worksheets = wx.aui.AuiNotebook(self, -1, pos=(20,90), \
size=(560,210),style=wx.NB_TOP|wx.aui.AUI_NB_WINDOWLIST_BUTTON)
self.MaxRows = 100
self.MaxCols = 40
self.gridFont = wx.Font(10, wx.MODERN, wx.NORMAL, wx.NORMAL)
self.grids = []
for idx, table in enumerate(self.tables):
caption = table.find('caption')
if caption == None:
caption = 'table %04.f' % (idx)
# set attributes to hold headers & stats
variableNames = []
gridData = []
# get number cols, rows
headings = table.findAll('th')
for heading in headings:
val = heading.text
val = parser.unescape(val)
variableNames.append(val)
rows = table.findAll('tr')
ncols = 0
nrows = len(rows)
for row in rows:
line = []
cols = row.findAll('td')
if len(cols) > ncols:
ncols = len(cols)
for col in cols:
line.append(col.text)
gridData.append(line)
self.grids.append(Grid(self.worksheets, -1))
self.grids[idx].HideRowLabels()
self.grids[idx].SetColLabelSize(16)
self.grids[idx].SetRowLabelSize(40)
self.grids[idx].SetDefaultColSize(60)
self.grids[idx].CreateGrid(nrows + 10, ncols + 10)
for i in range(ncols):
self.grids[idx].SetColLabelValue(i, " ")
for i in range(nrows):
self.grids[idx].SetRowSize(i, 16)
self.grids[idx].SetDefaultCellFont(self.gridFont)
if caption == None:
caption = 'table %04.f' % (idx)
headings = table.findAll('th')
for idxhead, heading in enumerate(headings):
self.grids[idx].SetColLabelValue(idxhead, heading.text)
self.worksheets.AddPage(self.grids[idx], caption)
for idx_row in range(len(gridData)):
for idx_col in range(len(gridData[idx_row])):
val = unicode(gridData[idx_row][idx_col])
val = parser.unescape(val)
self.grids[idx].SetCellValue(idx_row, idx_col, val)
# It seems odd but it seems better for all events to be routed to the same method
wx.EVT_CHECKBOX(self, 760, self.AdjustGrid)
wx.EVT_SPINCTRL(self, 766, self.AdjustGrid)
wx.EVT_BUTTON(self, 764, self.CancelButton)
wx.EVT_BUTTON(self, 763, self.ImportButton)
def makeControlForProp(self, prop, parent):
'''Make a wxWindows control for the given NWN property and add
it to the given parent wxWindow.'''
control = None
typeSpec = prop.getSpec()
type = typeSpec[0]
if type == 'CExoLocString':
control = CExoLocStringControl(typeSpec, prop, self,
self.defaultlang)
elif type == 'CExoString':
if len(typeSpec) > 1:
if typeSpec[1] != 'FactionName':
control = self.makeCustomChoiceControl(
typeSpec, prop, parent)
else:
control = wx.TextCtrl(parent,-1,prop.getValue(),wx.DefaultPosition,\
(250,24),style=wx.TE_PROCESS_ENTER)
wx.EVT_TEXT_ENTER(self, control.GetId(), self.controlUsed)
else:
control = wx.TextCtrl(parent, -1, prop.getValue(),
wx.DefaultPosition, (250, 24))
wx.EVT_TEXT(self, control.GetId(), self.controlUsed)
# self.Bind(wx.EVT_TEXT,self,self.controlUsed,id=control.GetId())
elif type == 'Percentage':
control = wx.SpinCtrl(parent, -1)
control.SetRange(0, 100)
control.SetValue(prop.getValue())
wx.EVT_SPINCTRL(self, control.GetId(), self.controlUsed)
#control.SetTickFreq(5,0)
elif type == 'Boolean':
control = wx.CheckBox(parent, -1, '')
control.SetValue(prop.getValue())
wx.EVT_CHECKBOX(self, control.GetId(), self.controlUsed)
elif type == 'Integer':
min = 0
max = 100
if len(typeSpec) > 1:
maxMin = typeSpec[1].split('-')
min = int(maxMin[0])
max = int(maxMin[1])
control = wx.SpinCtrl(parent, -1)
control.SetRange(min, max)
try:
control.SetValue(prop.getValue())
except OverflowError:
# I got that with some factions that have 0xFFFFFFFF as parents
# and as they shouldn't be edited anyway..
control.SetValue(-1)
control.Disable()
wx.EVT_SPINCTRL(self, control.GetId(), self.controlUsed)
wx.EVT_TEXT(self, control.GetId(), self.controlUsed)
elif type == "ResRef":
control = self.makeResRefControl(typeSpec, prop, parent)
elif type == "BGRColour":
blue = prop.getValue() >> 16
green = (prop.getValue() >> 8) & (0xff)
red = prop.getValue() & (0xff)
control = GenButton(parent, -1, '', wx.DefaultPosition,
wx.Size(40, 40))
control.SetBezelWidth(0)
control.SetForegroundColour(wx.Colour(red, green, blue))
control.SetBackgroundColour(wx.Colour(red, green, blue))
wx.EVT_BUTTON(self, control.GetId(), self.handleColourButton)
elif type == "List":
if typeSpec[1] == 'HAKs':
control = HAKListControl(prop, parent)
elif typeSpec[1] == 'Vars':
control = VarListControl(prop, parent)
elif type == "CheckList":
choices = []
# if typeSpec[1] == 'HAKs':
# choices = [x['Mod_Hak'].lower()
# for x in prop.getValue()]
# choices.extend([x.split('.')[0].lower() for x in
# neverglobals.getResourceManager().getHAKFileNames()
# if x.split('.')[0].lower() not in choices])
control = wx.CheckListBox(parent, -1, wx.DefaultPosition,
(200, 200), choices)
for i in range(len(choices)):
control.Check(i, False)
# for n in prop.getValue():
# control.Check(choices.index(n['Mod_Hak'].lower()))
wx.EVT_CHECKLISTBOX(self, control.GetId(), self.controlUsed)
elif type == '2daIndex':
twoda = neverglobals.getResourceManager().getResourceByName(
typeSpec[1])
choices = []
col = typeSpec[2]
if typeSpec[3] == 'strref':
for i in xrange(twoda.getRowCount()):
entry = 'invalid'
try:
entry = neverglobals.getResourceManager().\
getDialogString(int(twoda.getEntry(i,col)))
except ValueError:
if len(typeSpec) > 4:
entry = twoda.getEntry(i, typeSpec[4])
choices.append(entry)
else:
choices = [
twoda.getEntry(i, col) for i in xrange(twoda.getRowCount())
]
if typeSpec[1] in [
'ambientmusic.2da', 'ambientsound.2da', 'soundset.2da'
]:
# may be used for other 2das in the future
control = SoundControl(prop, parent, choices, typeSpec[1])
else:
control = wx.Choice(parent,
-1,
choices=[cleanstr(s) for s in choices])
control.SetSelection(prop.getValue())
elif type == 'Portrait':
p = neverglobals.getResourceManager().getPortraitByIndex(
prop.getValue(), 's')
if p:
control = wx.BitmapButton(parent, -1,
WxUtils.bitmapFromImage(p))
wx.EVT_BUTTON(self, control.GetId(), self.handlePortraitButton)
else:
logger.error('unknown portrait index:' + str(prop.getValue()))
import Image, ImageDraw, ImageFont
image = Image.new("1", (32, 64))
font = ImageFont.load_default()
draw = ImageDraw.Draw(image)
draw.text((3, 3), "portrait not found", font=font)
control = wx.BitmapButton(parent, -1,
WxUtils.bitmapFromImage(image))
wx.EVT_BUTTON(self, control.GetId(), self.handlePortraitButton)
if control:
label = wx.StaticText(self, -1, prop.getName().split('.')[-1])
else:
label = None
return (label, PropControl(control))
def _init_ctrls(self, prnt):
# generated method, don't edit
wx.Panel.__init__(self,
id=wxID_PANEL,
name='Zplots',
parent=prnt,
pos=wx.Point(0, 0),
size=wx.Size(604, 349),
style=wx.TAB_TRAVERSAL)
self._init_utils()
self.SetClientSize(wx.Size(596, 315))
self.Color = wx.Choice(choices=[
'black', 'white', 'red', 'green', 'blue', 'cyan', 'magenta',
'yellow'
],
id=wxID_PANELCOLOR,
name='Color',
parent=self,
pos=wx.Point(512, 0),
size=wx.Size(80, 21),
style=0,
validator=wx.DefaultValidator)
wx.EVT_CHOICE(self.Color, wxID_PANELCOLOR, self.OnColorChoice)
self.LineType = wx.Choice(
choices=['solid', 'dash', 'dot', 'dashdot', 'dashdotdot', 'none'],
id=wxID_PANELLINETYPE,
name='LineType',
parent=self,
pos=wx.Point(512, 24),
size=wx.Size(80, 21),
style=0,
validator=wx.DefaultValidator)
wx.EVT_CHOICE(self.LineType, wxID_PANELLINETYPE, self.OnLinetypeChoice)
self.Marker = wx.TextCtrl(id=wxID_PANELMARKER,
name='Marker',
parent=self,
pos=wx.Point(560, 72),
size=wx.Size(22, 22),
style=wx.TE_PROCESS_ENTER,
value='A')
wx.EVT_TEXT_ENTER(self.Marker, wxID_PANELMARKER,
self.OnMarkerTextEnter)
self.staticText1 = wx.StaticText(id=wxID_PANELSTATICTEXT1,
label='Marker',
name='staticText1',
parent=self,
pos=wx.Point(516, 74),
size=wx.Size(39, 16),
style=0)
self.staticText2 = wx.StaticText(id=wxID_PANELSTATICTEXT2,
label='Size',
name='staticText2',
parent=self,
pos=wx.Point(516, 50),
size=wx.Size(24, 16),
style=0)
# self.Size = wx.SpinCtrl(id=wxID_PANELSIZE, initial=1, max=10, min=1,
# name='Size', parent=self, pos=wx.Point(550, 48),
# size=wx.Size(40,22), style=wx.SP_ARROW_KEYS)
# wx.EVT_SPINCTRL(self.Size, wxID_PANELSIZE, self.OnSizeSpinctrl)
self.MarkerSize = wx.SpinCtrl(id=wxID_PANELMARKERSIZE,
initial=1,
max=10,
min=1,
name='MarkerSize',
parent=self,
pos=wx.Point(550, 96),
size=wx.Size(40, 22),
style=wx.SP_ARROW_KEYS)
wx.EVT_SPINCTRL(self.MarkerSize, wxID_PANELMARKERSIZE,
self.OnMarkersizeSpinctrl)
self.staticText3 = wx.StaticText(id=wxID_PANELSTATICTEXT3,
label='Size',
name='staticText3',
parent=self,
pos=wx.Point(516, 98),
size=wx.Size(24, 16),
style=0)
self.Marks = wx.CheckBox(id=wxID_PANELMARKS,
label='',
name='Marks',
parent=self,
pos=wx.Point(496, 71),
size=wx.Size(20, 20),
style=0)
self.Marks.SetValue(false)
wx.EVT_CHECKBOX(self.Marks, wxID_PANELMARKS, self.OnMarksCheckbox)
def __init__(self, *args, **kwargs):
super(IntegerField, self).__init__(*args, **kwargs)
wx.EVT_SPINCTRL(self, wx.ID_ANY, self.OnChange)
def __init__(self,
parent,
id,
file,
data,
isValidCallback=None,
pos=wx.DefaultPosition,
size=wx.DefaultSize,
style=wx.TAB_TRAVERSAL,
name="ImportWizardPanel"):
wx.Panel.__init__(self, parent, id, pos, size, style, name)
self.SetAutoLayout(True)
mainSizer = wx.FlexGridSizer(4, 1, gap=wx.Size(0, 0))
self.SetSizer(mainSizer)
mainSizer.AddGrowableCol(0)
self.initialized = False
self.data = data
self.isValidCallback = isValidCallback
self.Validate = (isValidCallback
and self.Validate) or self.BuildPreview
dlg = wx.ProgressDialog(_("Import Wizard"),
_("Analyzing %s... Please wait.") % file,
3, parent,
wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
textQualifier = guessTextQualifier(data)
dlg.Update(1)
newdata = organizeIntoLines(data,
textQualifier=textQualifier,
limit=100)
dlg.Update(2)
delimiter = guessDelimiter(newdata, textQualifier=textQualifier)
dlg.Update(3)
dlg.Destroy()
# -------------
msg = (_(
"This screen lets you set the delimiters your data contains.\n"
"You can see how your data is affected in the preview below."))
message1 = wx.StaticText(self, -1, msg)
# -------------
delimiterBox = wx.BoxSizer(wx.HORIZONTAL)
delimStaticBox = wx.StaticBox(self, -1, _("Delimiters"))
delimStaticSizer = wx.StaticBoxSizer(delimStaticBox, wx.VERTICAL)
delimGridSizer = wx.FlexGridSizer(2, 3, gap=wx.Size(0, 0))
delims = {
_('Tab'): '\t',
_('Semicolon'): ';',
_('Comma'): ',',
_('Space'): ' ',
}
self.delimChecks = {}
for label, value in list(delims.items()):
self.delimChecks[value] = wx.CheckBox(self, -1, label)
delimGridSizer.Add(self.delimChecks[value], 0, wx.ALL, 3)
wx.EVT_CHECKBOX(self, self.delimChecks[value].GetId(),
self.Validate)
otherSizer = wx.BoxSizer(wx.HORIZONTAL)
self.delimChecks['Other'] = wx.CheckBox(self, -1, _('Other:'))
wx.EVT_CHECKBOX(self, self.delimChecks['Other'].GetId(),
self.Validate)
self.otherDelim = wx.TextCtrl(self, -1, size=(20, -1))
wx.EVT_TEXT(self, self.otherDelim.GetId(), self.OnCustomDelim)
if delimiter in self.delimChecks:
self.delimChecks[delimiter].SetValue(True)
elif delimiter is not None:
self.delimChecks['Other'].SetValue(wx.T)
self.otherDelim.SetValue(delimiter)
otherSizer.AddMany([
(self.delimChecks['Other'], 0, wx.ALL, 3),
(self.otherDelim, 0, wx.ALIGN_CENTER),
])
delimGridSizer.Add(otherSizer)
delimStaticSizer.Add(delimGridSizer, 1, wx.EXPAND)
delimOtherSizer = wx.BoxSizer(wx.VERTICAL)
self.consecutiveDelimsAs1 = wx.CheckBox(
self, -1, _("Treat consecutive delimiters as one"))
self.consecutiveDelimsAs1.Enable(False)
tqSizer = wx.BoxSizer(wx.HORIZONTAL)
self.textQualifierChoice = wx.Choice(self,
-1,
choices=['"', "'", "{None}"])
wx.EVT_CHOICE(self, self.textQualifierChoice.GetId(),
self.BuildPreview)
if textQualifier is not None:
self.textQualifierChoice.SetStringSelection(textQualifier)
else:
self.textQualifierChoice.SetStringSelection('{None}')
tqSizer.AddMany([
(wx.StaticText(self, -1, _("Text qualifier:")), 0,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL),
(self.textQualifierChoice, 0,
wx.ALL | wx.ALIGN_LEFT | wx.ALIGN_CENTER_VERTICAL, 5),
])
delimOtherSizer.AddMany([
(self.consecutiveDelimsAs1, 1, wx.EXPAND | wx.ALL, 5),
(tqSizer, 1, wx.ALL | wx.ALIGN_CENTER, 5),
])
delimiterBox.AddMany([
(delimStaticSizer, 0, wx.ALIGN_CENTER),
(delimOtherSizer, 0, wx.ALIGN_CENTER),
])
delimStaticBox.Fit()
# -------------
self.displayRows = 6
previewSettingsBox = wx.BoxSizer(wx.HORIZONTAL)
self.hasHeaderRow = wx.CheckBox(self, -1, _("First row is header"))
wx.EVT_CHECKBOX(self, self.hasHeaderRow.GetId(), self.BuildPreview)
if wx.Platform in ('__WX.WXGTK__', '__WX.WXMSW__'):
# wx.SpinCtrl causes seg fault under GTK when <enter> is hit in text - use wx.SpinButton instead
self.previewRowsText = wx.TextCtrl(self,
-1,
str(self.displayRows),
size=(30, -1),
style=wx.TE_PROCESS_ENTER)
h = self.previewRowsText.GetSize().height
self.previewRows = wx.SpinButton(self,
-1,
size=(-1, h),
style=wx.SP_VERTICAL)
self.previewRows.SetRange(self.displayRows, 100)
self.previewRows.SetValue(self.displayRows)
wx.EVT_SPIN(self, self.previewRows.GetId(),
self.OnSpinPreviewRows)
wx.EVT_TEXT_ENTER(self, self.previewRowsText.GetId(),
self.OnTextPreviewRows)
else:
self.previewRows = wx.SpinCtrl(self,
-1,
str(self.displayRows),
min=self.displayRows,
max=100,
size=(50, -1))
wx.EVT_SPINCTRL(self, self.previewRows.GetId(),
self.BuildPreview)
previewSettingsBox.AddMany([
(self.hasHeaderRow, 1, wx.ALL | wx.EXPAND, 5),
(wx.StaticText(self, -1, _("Preview")), 0,
wx.WEST | wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL, 10),
])
if wx.Platform in ('__WX.WXGTK__', '__WX.WXMSW__'):
previewSettingsBox.Add(self.previewRowsText, 0,
wx.ALIGN_CENTER | wx.ALL, 3)
previewSettingsBox.AddMany([
(self.previewRows, 0, wx.ALIGN_CENTER | wx.ALL, 3),
(wx.StaticText(self, -1, _("rows")), 0,
wx.ALIGN_RIGHT | wx.ALIGN_CENTER_VERTICAL),
])
# -------------
if delimiter is not None:
previewData = importDSV(newdata[:self.displayRows],
textQualifier=textQualifier,
delimiter=delimiter,
errorHandler=padRow)
hasHeaders = guessHeaders(previewData)
self.hasHeaderRow.SetValue(hasHeaders)
cols = len(previewData[0])
else:
previewData = []
hasHeaders = 0
cols = 1
previewStaticBox = wx.StaticBox(self, -1, _("Data Preview"))
previewStaticSizer = wx.StaticBoxSizer(previewStaticBox,
wx.VERTICAL)
self.preview = wx.grid.Grid(self, -1)
self.preview.CreateGrid(self.displayRows, cols)
#self.preview.SetDefaultRowSize(self.preview.GetCharHeight() + 4, rue)
self.preview.EnableEditing(False)
self.preview.SetColLabelSize(0)
self.preview.SetRowLabelSize(0)
self.preview.SetMargins(1, 0)
self.initialized = True
self.BuildPreview()
rowheight = self.preview.GetRowSize(0) + 2
self.preview.SetSize((-1, rowheight * self.displayRows))
previewStaticSizer.Add(self.preview, 0, wx.ALL | wx.EXPAND, 5)
# -------------
mainSizer.AddMany([(message1, 0, wx.ALL, 5),
(delimiterBox, 0, wx.ALL, 5),
(previewSettingsBox, 0, wx.ALL, 5),
(previewStaticSizer, 0, wx.ALL | wx.EXPAND, 5)])
self.Layout()
self.Fit()
def __init__(self, parent, port=None):
ToolPane.__init__(self, parent, port)
# default data
self.signs = "+" * 18
self.curpose = ""
self.ikChoice = ""
self.optChoice = ""
self.sizer = wx.GridBagSizer(10, 10)
# IK styles/Config
temp = wx.StaticBox(self, -1, 'IK Config')
temp.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD))
configBox = wx.StaticBoxSizer(temp, orient=wx.VERTICAL)
configSizer = wx.GridBagSizer(5, 5)
configSizer.Add(wx.StaticText(self, -1, "IK Type:"), (0, 0),
wx.GBSpan(1, 1), wx.ALIGN_CENTER_VERTICAL | wx.TOP, 10)
self.ikType = wx.ComboBox(self,
self.ID_IKTYPE,
choices=iKmodels.keys())
configSizer.Add(self.ikType, (0, 1), wx.GBSpan(1, 1), wx.TOP, 10)
# IK Option (typical # of legs or # of DOF)
hbox = wx.BoxSizer(wx.HORIZONTAL)
self.optLabel = wx.StaticText(self, -1, "# of Legs:")
configSizer.Add(self.optLabel, (1, 0), wx.GBSpan(1, 1),
wx.ALIGN_CENTER_VERTICAL)
self.ikOpt = wx.ComboBox(self, self.ID_IKOPT, choices=["4", "6"])
configSizer.Add(self.ikOpt, (1, 1))
configBox.Add(configSizer)
self.sizer.Add(configBox, (0, 1), wx.GBSpan(1, 1), wx.EXPAND)
# Actions buttons
temp = wx.StaticBox(self, -1, 'Actions')
temp.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD))
actionBox = wx.StaticBoxSizer(temp, orient=wx.VERTICAL)
actionSizer = wx.GridBagSizer(5, 5)
actionSizer.Add(wx.StaticText(self, -1, "Capture Limits:"), (0, 0),
wx.GBSpan(1, 1), wx.ALIGN_CENTER_VERTICAL)
actionSizer.Add(wx.StaticText(self, -1, "Capture Neutral:"), (1, 0),
wx.GBSpan(1, 1), wx.ALIGN_CENTER_VERTICAL)
actionSizer.Add(wx.StaticText(self, -1, "Set/Test Signs:"), (2, 0),
wx.GBSpan(1, 1), wx.ALIGN_CENTER_VERTICAL)
actionSizer.Add(wx.Button(self, self.BT_LIMITS, 'Capture'), (0, 1))
actionSizer.Add(wx.Button(self, self.BT_NEUTRAL, 'Capture'), (1, 1))
self.signButton = wx.Button(self, self.BT_SIGN, 'Go')
actionSizer.Add(self.signButton, (2, 1))
actionBox.Add(actionSizer)
self.sizer.Add(actionBox, (1, 1), wx.GBSpan(1, 1), wx.EXPAND)
# NUKE Label
nukeIt = wx.StaticText(self, -1, "NUKE: Get Your IK On")
nukeIt.SetFont(wx.Font(15, wx.DEFAULT, wx.NORMAL, wx.BOLD, wx.ITALIC))
self.sizer.Add(nukeIt, (2, 0), wx.GBSpan(1, 2),
wx.ALIGN_CENTER_VERTICAL)
# Buttons
hbox = wx.BoxSizer(wx.HORIZONTAL)
gaitBut = wx.Button(self, -1, 'Gait Builder')
gaitBut.Disable()
hbox.Add(gaitBut)
viewBut = wx.Button(self, -1, 'Viewer/Tuner')
viewBut.Disable()
hbox.Add(viewBut)
hbox.Add(wx.Button(self, self.BT_DRIVE, 'Test Drive'))
hbox.Add(wx.Button(self, self.BT_EXPORT, 'Export'))
self.sizer.Add(hbox, (2, 2), wx.GBSpan(1, 1), wx.ALIGN_CENTER)
# Load Data (if possible)
self.loadData()
self.SetSizer(self.sizer)
self.SetAutoLayout(1)
self.sizer.Fit(self)
# event handling
wx.EVT_BUTTON(self, self.BT_LIMITS, self.doLimits)
wx.EVT_BUTTON(self, self.BT_NEUTRAL, self.doNeutral)
wx.EVT_BUTTON(self, self.BT_SIGN, self.doSignTest)
wx.EVT_BUTTON(self, self.BT_DRIVE, self.doWalkTest)
wx.EVT_BUTTON(self, self.BT_EXPORT, self.doExport)
wx.EVT_COMBOBOX(self, self.ID_IKTYPE, self.doIKType)
wx.EVT_COMBOBOX(self, self.ID_IKOPT, self.doIkOpt)
wx.EVT_SPINCTRL(self, self.ID_ANY, self.save)
def __init__(self, parent, text_objects):
wx.Panel.__init__(self, parent, wx.ID_ANY)
self.__text_objects = text_objects
self.mpl_figure = text_objects[0].get_figure()
hsizer = wx.BoxSizer(wx.HORIZONTAL)
grid_sizer = wx.FlexGridSizer(cols=2, vgap=5)
#create a list of available truetype fonts on this system
self.avail_fonts = sorted(list(set([f.name for f in matplotlib.font_manager.fontManager.ttflist])))
#create a font selection listbox
self.font_selector = wx.ListBox(self, wx.ID_ANY, choices=self.avail_fonts)
hsizer.Add(self.font_selector, 1, wx.ALIGN_TOP | wx.ALIGN_LEFT | wx.ALL,
border=10)
#set the initial font selection to that of the text object
cur_fonts = list(set([t.get_fontname() for t in text_objects]))
if len(cur_fonts) == 1:
self.font_selector.SetSelection(self.avail_fonts.index(cur_fonts[0]))
#create a colour picker button
text = wx.StaticText(self, -1, "Colour: ")
grid_sizer.Add(text, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_RIGHT)
wx.EVT_LISTBOX(self, self.font_selector.GetId(), self.on_font_selection)
#set the colour picker's initial value to that of the text object
prev_cols = [matplotlib.colors.colorConverter.to_rgb(t.get_color()) for t in text_objects]
#TODO - what if the text objects have different colors
prev_col = (255 * prev_cols[0][0], 255 * prev_cols[0][1], 255 * prev_cols[0][2])
self.colour_picker = wx.ColourPickerCtrl(self, -1, prev_col)
grid_sizer.Add(self.colour_picker, 0 ,
wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_LEFT)
wx.EVT_COLOURPICKER_CHANGED(self, self.colour_picker.GetId(), self.on_font_colour)
#create a font size control and set the initial value to that of the text
text = wx.StaticText(self, -1, "Size: ")
grid_sizer.Add(text, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_RIGHT)
prev_size = [t.get_size() for t in text_objects][0]
#TODO - what if the text objects have different sizes
self.size_ctrl = wx.SpinCtrl(self, wx.ID_ANY, min=4, max=100,
initial=prev_size)
grid_sizer.Add(self.size_ctrl, 0 , wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_LEFT)
wx.EVT_SPINCTRL(self, self.size_ctrl.GetId(), self.on_font_size)
#create a drop-down box for specifying font weight
self.possible_weights = ['ultralight', 'light', 'normal', 'regular',
'book', 'medium', 'roman', 'semibold',
'demibold', 'demi', 'bold', 'heavy',
'extra bold', 'black']
text = wx.StaticText(self, -1, "Weight: ")
grid_sizer.Add(text, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_RIGHT)
self.weight_ctrl = wx.Choice(self, wx.ID_ANY, choices=self.possible_weights)
grid_sizer.Add(self.weight_ctrl, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_LEFT)
wx.EVT_CHOICE(self, self.weight_ctrl.GetId(), self.on_font_weight)
#set the initial font weight selection to that of the text, this is a
#bit tricky since get_weight can return an integer or a string
cur_weight = [t.get_weight() for t in text_objects][0]
#TODO - what if the text objects have different weights
if not type(cur_weight) is str:
idx = int(round(cur_weight / 1000.0 * len(self.possible_weights), 0))
else:
idx = self.possible_weights.index(cur_weight)
self.weight_ctrl.SetSelection(idx)
#create a drop down box for specifying font style
self.possible_styles = ['normal', 'italic', 'oblique']
text = wx.StaticText(self, -1, "Style: ")
grid_sizer.Add(text, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_RIGHT)
self.style_ctrl = wx.Choice(self, wx.ID_ANY, choices=self.possible_styles)
grid_sizer.Add(self.style_ctrl, 0 , wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_LEFT)
wx.EVT_CHOICE(self, self.style_ctrl.GetId(), self.on_font_style)
#set the initial font style selection to that of the text
cur_style = [t.get_style() for t in text_objects][0]
#TODO - what if the text objects have different styles
idx = self.possible_styles.index(cur_style)
self.style_ctrl.SetSelection(idx)
#create a drop down box for selecting font stretch
self.possible_stretches = ['ultra-condensed', 'extra-condensed',
'condensed', 'semi-condensed', 'normal',
'semi-expanded', 'expanded', 'extra-expanded',
'ultra-expanded']
text = wx.StaticText(self, -1, "Stretch: ")
grid_sizer.Add(text, 0, wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_RIGHT)
self.stretch_ctrl = wx.Choice(self, wx.ID_ANY, choices=self.possible_stretches)
grid_sizer.Add(self.stretch_ctrl, 0 , wx.ALIGN_CENTRE_VERTICAL | wx.ALIGN_LEFT)
wx.EVT_CHOICE(self, self.stretch_ctrl.GetId(), self.on_font_stretch)
#set the initial font stretch selection to that of the text, this is a
#bit tricky since get_weight can return an integer or a string
cur_stretch = [t.get_stretch() for t in text_objects][0]
#TODO - what if the text objects have different stretches
if not type(cur_stretch) is str:
idx = int(round(cur_stretch / 1000.0 * len(self.possible_stretches), 0))
else:
idx = self.possible_stretches.index(cur_stretch)
self.stretch_ctrl.SetSelection(idx)
hsizer.Add(grid_sizer, 1, wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT | wx.ALL,
border=10)
self.SetSizer(hsizer)
hsizer.Fit(self)
self.SetAutoLayout(True)
def optic_flow_panel_init(self):
"""
Initializes the optic flow notebook page of the GUI
"""
self.optic_flow_panel = xrc.XRCCTRL(self.notebook, Optic_Flow_PANEL)
# Setup optic flow panel controls
self.optic_flow_enable_box = xrc.XRCCTRL(self.optic_flow_panel,
Optic_Flow_Enable_CHECKBOX)
self.num_row_spin_ctrl = xrc.XRCCTRL(self.optic_flow_panel,
Num_Row_SPINCTRL)
self.num_col_spin_ctrl = xrc.XRCCTRL(self.optic_flow_panel,
Num_Col_SPINCTRL)
self.window_size_spin_ctrl = xrc.XRCCTRL(self.optic_flow_panel,
Window_Size_SPINCTRL)
self.poll_int_text_ctrl = xrc.XRCCTRL(self.optic_flow_panel,
Poll_Interval_TEXTCTRL)
self.horiz_space_slider = xrc.XRCCTRL(self.optic_flow_panel,
Horiz_Space_SLIDER)
self.horiz_position_slider = xrc.XRCCTRL(self.optic_flow_panel,
Horiz_Position_SLIDER)
self.vert_space_slider = xrc.XRCCTRL(self.optic_flow_panel,
Vert_Space_SLIDER)
self.vert_position_slider = xrc.XRCCTRL(self.optic_flow_panel,
Vert_Position_SLIDER)
# Setup events for optic flow panel controls
wx.EVT_CHECKBOX(self.optic_flow_enable_box,
xrc.XRCID(Optic_Flow_Enable_CHECKBOX),
self.on_optic_flow_enable)
wx.EVT_SPINCTRL(self.num_row_spin_ctrl, xrc.XRCID(Num_Row_SPINCTRL),
self.on_num_row_spin_ctrl)
wx.EVT_SPINCTRL(self.num_col_spin_ctrl, xrc.XRCID(Num_Col_SPINCTRL),
self.on_num_col_spin_ctrl)
wx.EVT_SPINCTRL(self.window_size_spin_ctrl,
xrc.XRCID(Window_Size_SPINCTRL),
self.on_window_size_spin_ctrl)
wx.EVT_TEXT_ENTER(self.poll_int_text_ctrl,
xrc.XRCID(Poll_Interval_TEXTCTRL),
self.on_poll_int_text_enter)
wx.EVT_SLIDER(self.horiz_space_slider, xrc.XRCID(Horiz_Space_SLIDER),
self.on_horiz_space_slider)
wx.EVT_SLIDER(self.horiz_position_slider,
xrc.XRCID(Horiz_Position_SLIDER),
self.on_horiz_position_slider)
wx.EVT_SLIDER(self.vert_space_slider, xrc.XRCID(Vert_Space_SLIDER),
self.on_vert_space_slider)
wx.EVT_SLIDER(self.vert_position_slider,
xrc.XRCID(Vert_Position_SLIDER),
self.on_vert_position_slider)
# Set default values for optic flow panel
self.optic_flow_enable = OPTIC_FLOW_DEFAULTS['opticflow_enable']
self.optic_flow_enable_box.SetValue(self.optic_flow_enable)
self.poll_int = OPTIC_FLOW_DEFAULTS['poll_int']
self.poll_int_text_ctrl.SetValue(str(self.poll_int))
self.wnd = OPTIC_FLOW_DEFAULTS['wnd']
self.window_size_spin_ctrl.SetValue(self.wnd)
self.num_row = OPTIC_FLOW_DEFAULTS['num_row']
self.num_row_spin_ctrl.SetValue(self.num_row)
self.num_col = OPTIC_FLOW_DEFAULTS['num_col']
self.num_col_spin_ctrl.SetValue(self.num_col)
self.horiz_space = OPTIC_FLOW_DEFAULTS['horiz_space']
set_slider_value(self.horiz_space_slider, self.horiz_space)
self.horiz_pos = OPTIC_FLOW_DEFAULTS['horiz_pos']
set_slider_value(self.horiz_position_slider, self.horiz_pos)
self.vert_space = OPTIC_FLOW_DEFAULTS['vert_space']
set_slider_value(self.vert_space_slider, self.vert_space)
self.vert_pos = OPTIC_FLOW_DEFAULTS['vert_pos']
set_slider_value(self.vert_position_slider, self.vert_pos)
def __init__(self, parent, titles, cfg, cfgGl):
wx.Dialog.__init__(self,
parent,
-1,
"Title pages",
style=wx.DEFAULT_DIALOG_STYLE)
self.titles = titles
self.cfg = cfg
self.cfgGl = cfgGl
# whether some events are blocked
self.block = False
self.setPage(0)
vsizer = wx.BoxSizer(wx.VERTICAL)
self.pageLabel = wx.StaticText(self, -1, "")
vsizer.Add(self.pageLabel, 0, wx.ADJUST_MINSIZE)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
tmp = wx.Button(self, -1, "Add")
hsizer.Add(tmp)
wx.EVT_BUTTON(self, tmp.GetId(), self.OnAddPage)
gutil.btnDblClick(tmp, self.OnAddPage)
self.delPageBtn = wx.Button(self, -1, "Delete")
hsizer.Add(self.delPageBtn, 0, wx.LEFT, 10)
wx.EVT_BUTTON(self, self.delPageBtn.GetId(), self.OnDeletePage)
gutil.btnDblClick(self.delPageBtn, self.OnDeletePage)
self.moveBtn = wx.Button(self, -1, "Move")
hsizer.Add(self.moveBtn, 0, wx.LEFT, 10)
wx.EVT_BUTTON(self, self.moveBtn.GetId(), self.OnMovePage)
gutil.btnDblClick(self.moveBtn, self.OnMovePage)
self.nextBtn = wx.Button(self, -1, "Next")
hsizer.Add(self.nextBtn, 0, wx.LEFT, 10)
wx.EVT_BUTTON(self, self.nextBtn.GetId(), self.OnNextPage)
gutil.btnDblClick(self.nextBtn, self.OnNextPage)
vsizer.Add(hsizer, 0, wx.TOP, 5)
vsizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.TOP | wx.BOTTOM,
10)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
vsizer2 = wx.BoxSizer(wx.VERTICAL)
tmp = wx.StaticText(self, -1, "Strings:")
vsizer2.Add(tmp)
self.stringsLb = wx.ListBox(self, -1, size=(200, 150))
vsizer2.Add(self.stringsLb)
hsizer2 = wx.BoxSizer(wx.HORIZONTAL)
self.addBtn = gutil.createStockButton(self, "Add")
hsizer2.Add(self.addBtn)
wx.EVT_BUTTON(self, self.addBtn.GetId(), self.OnAddString)
gutil.btnDblClick(self.addBtn, self.OnAddString)
self.delBtn = gutil.createStockButton(self, "Delete")
hsizer2.Add(self.delBtn, 0, wx.LEFT, 10)
wx.EVT_BUTTON(self, self.delBtn.GetId(), self.OnDeleteString)
gutil.btnDblClick(self.delBtn, self.OnDeleteString)
vsizer2.Add(hsizer2, 0, wx.TOP, 5)
hsizer.Add(vsizer2)
self.previewCtrl = TitlesPreview(self, self, self.cfg)
util.setWH(self.previewCtrl, 150, 150)
hsizer.Add(self.previewCtrl, 1, wx.EXPAND | wx.LEFT, 10)
vsizer.Add(hsizer, 0, wx.EXPAND)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "Text:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.textEntry = wx.TextCtrl(self,
-1,
style=wx.TE_MULTILINE | wx.TE_DONTWRAP,
size=(200, 75))
hsizer.Add(self.textEntry, 1, wx.LEFT, 10)
wx.EVT_TEXT(self, self.textEntry.GetId(), self.OnMisc)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.TOP, 20)
# TODO: should use FlexGridSizer, like headersdlg, to get neater
# layout
hsizerTop = wx.BoxSizer(wx.HORIZONTAL)
vsizer2 = wx.BoxSizer(wx.VERTICAL)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "Alignment:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.alignCombo = wx.ComboBox(self, -1, style=wx.CB_READONLY)
for it in [("Left", util.ALIGN_LEFT), ("Center", util.ALIGN_CENTER),
("Right", util.ALIGN_RIGHT)]:
self.alignCombo.Append(it[0], it[1])
hsizer.Add(self.alignCombo, 0, wx.LEFT, 10)
wx.EVT_COMBOBOX(self, self.alignCombo.GetId(), self.OnMisc)
vsizer2.Add(hsizer, 0, wx.TOP, 5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "X / Y Pos (mm):"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.xEntry = wx.TextCtrl(self, -1)
hsizer.Add(self.xEntry, 0, wx.LEFT, 10)
wx.EVT_TEXT(self, self.xEntry.GetId(), self.OnMisc)
self.yEntry = wx.TextCtrl(self, -1)
hsizer.Add(self.yEntry, 0, wx.LEFT, 10)
wx.EVT_TEXT(self, self.yEntry.GetId(), self.OnMisc)
vsizer2.Add(hsizer, 0, wx.TOP, 5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "Font / Size:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.fontCombo = wx.ComboBox(self, -1, style=wx.CB_READONLY)
for it in [("Courier", pml.COURIER), ("Helvetica", pml.HELVETICA),
("Times-Roman", pml.TIMES_ROMAN)]:
self.fontCombo.Append(it[0], it[1])
hsizer.Add(self.fontCombo, 0, wx.LEFT, 10)
wx.EVT_COMBOBOX(self, self.fontCombo.GetId(), self.OnMisc)
self.sizeEntry = wx.SpinCtrl(self, -1, size=(50, -1))
self.sizeEntry.SetRange(4, 288)
wx.EVT_SPINCTRL(self, self.sizeEntry.GetId(), self.OnMisc)
wx.EVT_KILL_FOCUS(self.sizeEntry, self.OnKillFocus)
hsizer.Add(self.sizeEntry, 0, wx.LEFT, 10)
vsizer2.Add(hsizer, 0, wx.TOP, 10)
hsizerTop.Add(vsizer2)
bsizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, "Style"),
wx.HORIZONTAL)
vsizer2 = wx.BoxSizer(wx.VERTICAL)
# wxGTK adds way more space by default than wxMSW between the
# items, have to adjust for that
pad = 0
if misc.isWindows:
pad = 5
self.addCheckBox("Bold", self, vsizer2, pad)
self.addCheckBox("Italic", self, vsizer2, pad)
self.addCheckBox("Underlined", self, vsizer2, pad)
bsizer.Add(vsizer2)
hsizerTop.Add(bsizer, 0, wx.LEFT, 20)
vsizer.Add(hsizerTop, 0, wx.TOP, 10)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add((1, 1), 1)
self.previewBtn = gutil.createStockButton(self, "Preview")
hsizer.Add(self.previewBtn)
cancelBtn = gutil.createStockButton(self, "Cancel")
hsizer.Add(cancelBtn, 0, wx.LEFT, 10)
okBtn = gutil.createStockButton(self, "OK")
hsizer.Add(okBtn, 0, wx.LEFT, 10)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.TOP, 20)
util.finishWindow(self, vsizer)
wx.EVT_BUTTON(self, self.previewBtn.GetId(), self.OnPreview)
wx.EVT_BUTTON(self, cancelBtn.GetId(), self.OnCancel)
wx.EVT_BUTTON(self, okBtn.GetId(), self.OnOK)
wx.EVT_LISTBOX(self, self.stringsLb.GetId(), self.OnStringsLb)
# list of widgets that are specific to editing the selected string
self.widList = [
self.textEntry, self.xEntry, self.alignCombo, self.yEntry,
self.fontCombo, self.sizeEntry, self.boldCb, self.italicCb,
self.underlinedCb
]
self.updateGui()
self.textEntry.SetFocus()
def __init__(self, parent):
myStyle = wx.MINIMIZE_BOX | wx.CAPTION | wx.ALIGN_CENTER | \
wx.ALIGN_CENTER_VERTICAL | wx.TAB_TRAVERSAL | wx.STAY_ON_TOP
wx.Frame.__init__(self,
parent,
-1,
_("Pregnancy Calculator"),
style=myStyle)
# initialization of variables used in the control & calculation
self.xfer_cal_date_to = LMP_FIELD # controls which variable (LMP or Ultrasound) a calendar event changes
# (if == 0): {calendar selection modifies LMP}
# (if == 1): {calendar selection modifies Ultrasound Date}
self.ustxt = wx.DateTime_Today(
) # avoids problem - one would have if the user clicked on
# ultrasound date
# BONUS: makes the preg. calculator useful for EDC calcs given
# a date and the gestation time
# get icon
if __name__ == '__main__':
png_fname = os.path.join('..', 'bitmaps', 'preg_calculator.png')
else:
from Gnumed.pycommon import gmGuiBroker
gb = gmGuiBroker.GuiBroker()
png_fname = os.path.join(gb['gnumed_dir'], 'bitmaps',
'preg_calculator.png')
icon = wx.Icon()
icon.LoadFile(png_fname, wx.BITMAP_TYPE_PNG)
self.SetIcon(icon)
szr_rc = wx.lib.rcsizer.RowColSizer()
#------------------------------
# sizer holding the 'LMP' stuff
#------------------------------
label = wx.StaticText(self, -1, _("LMP"), size=(50, 20)) #label Lmp
label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label.SetForegroundColour(wx.Colour(0, 0, 0))
self.txt_lmp = wx.TextCtrl(self, -1, "",
size=(100, 20)) # text for lmp
self.txt_lmp.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.txt_lmp.SetToolTip(
wx.ToolTip(
_("Click on calendar to enter the last menstrual period date"))
)
#tiplmp=self.txt_lmp.GetToolTip()
szr_row1 = wx.BoxSizer(wx.HORIZONTAL)
szr_row1.Add(self.txt_lmp, 1, wx.EXPAND | wx.ALL, 2)
wx.EVT_SET_FOCUS(self.txt_lmp, self.OnSetFocus_lmp)
szr_lmp = wx.BoxSizer(wx.HORIZONTAL)
szr_lmp.Add(label, 1, 0, 0)
szr_lmp.Add((10, 1), 0, 0)
szr_rc.Add(szr_lmp, flag=wx.EXPAND, row=0, col=1)
szr_rc.Add(szr_row1, flag=wx.EXPAND, row=0, col=2, colspan=5)
#------------------------------
# sizer holding the 'Gest.' stuff
#------------------------------
label = wx.StaticText(self, -1, _("Gest."), size=(50, 20))
label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtgest = wx.TextCtrl(self, -1, "", size=(100, 20))
self.txtgest.Enable(False)
self.txtgest.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.txtgest_szr = wx.BoxSizer(wx.HORIZONTAL)
self.txtgest_szr.Add(self.txtgest, 1, wx.EXPAND | wx.ALL, 2)
szr_gest = wx.BoxSizer(wx.HORIZONTAL)
szr_gest.Add(label, 1, 0, 0)
szr_gest.Add((10, 1), 0, 0)
szr_rc.Add(szr_gest, flag=wx.EXPAND, row=1, col=1)
szr_rc.Add(self.txtgest_szr, flag=wx.EXPAND, row=1, col=2, colspan=5)
#------------------------------
# sizer holding the 'EDC' stuff
#------------------------------
label = wx.StaticText(self, -1, _("EDC"), size=(50, 20))
label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtedc = wx.TextCtrl(self, -1, "", size=(100, 20))
self.txtedc.Enable(False)
self.txtedc.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
szr_txtedc = wx.BoxSizer(wx.HORIZONTAL)
szr_txtedc.Add(self.txtedc, 1, wx.EXPAND | wx.ALL, 2)
szr_edc = wx.BoxSizer(wx.HORIZONTAL)
szr_edc.Add(label, 1, 0, 0)
szr_edc.Add((10, 1), 0, 0)
szr_rc.Add(szr_edc, flag=wx.EXPAND, row=2, col=1)
szr_rc.Add(szr_txtedc, flag=wx.EXPAND, row=2, col=2, colspan=5)
#------------------------------
# "Ultrasound Scan" label
#------------------------------
us_label = wx.StaticText(self,
-1,
_("18 Week Ultrasound Scan"),
size=(200, 20))
us_label.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False, ''))
us_label.SetForegroundColour(wx.Colour(50, 50, 204))
szr_backgrnd_18WkScanDue = wx.BoxSizer(wx.VERTICAL)
szr_backgrnd_18WkScanDue.Add((1, 3), 0)
szr_backgrnd_18WkScanDue.Add(us_label, 1, wx.EXPAND, 1)
szr_rc.Add(szr_backgrnd_18WkScanDue,
flag=wx.ALIGN_CENTRE_HORIZONTAL,
row=3,
col=2,
colspan=5)
#------------------------------
# sizer holding the 'Due' stuff
#------------------------------
label = wx.StaticText(self, -1, _("Due"), size=(100, 20))
label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtdue = wx.TextCtrl(self, -1, "", size=(100, 20))
self.txtdue.Enable(False)
self.txtdue.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.szr_txtdue = wx.BoxSizer(wx.HORIZONTAL)
self.szr_txtdue.Add(self.txtdue, 1, wx.EXPAND | wx.ALL, 2)
szr_due = wx.BoxSizer(wx.HORIZONTAL)
szr_due.Add(label, 1, 0, 0)
szr_due.Add((10, 1), 0, 0)
szr_rc.Add(szr_due, flag=wx.EXPAND, row=4, col=1)
szr_rc.Add(self.szr_txtdue, flag=wx.EXPAND, row=4, col=2, colspan=5)
#------------------------------
# "Ultrasound Scan - Revised EDC" label
#------------------------------
rev_edc_label = wx.StaticText(self,
-1,
_("Ultrasound Scan - Revised EDC"),
size=(300, 20))
rev_edc_label.SetFont(
wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD, False, ''))
rev_edc_label.SetForegroundColour(wx.Colour(50, 50, 204))
szr_backgrnd_RevEDCLabel = wx.BoxSizer(wx.VERTICAL)
szr_backgrnd_RevEDCLabel.Add((1, 3), 0)
szr_backgrnd_RevEDCLabel.Add(rev_edc_label, 1, wx.EXPAND, 1)
szr_rc.Add(szr_backgrnd_RevEDCLabel,
flag=wx.ALIGN_CENTRE_HORIZONTAL,
row=5,
col=2,
colspan=5)
#------------------------------
# sizer holding the 'newedc' stuff
#------------------------------
label1 = wx.StaticText(self, -1, _("Scan Date"), size=(25, 20))
label1.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label1.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtdate = wx.TextCtrl(self, -1, "", size=(25, 20))
self.txtdate.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.txtdate.SetToolTip(
wx.ToolTip(
_("Click on this field and then the ultrasound scan date on the calendar"
)))
#tipdue=self.txtdate.GetToolTip()
#wx.ToolTip_Enable(1)
self.szr_txtdate = wx.BoxSizer(wx.HORIZONTAL)
self.szr_txtdate.Add(self.txtdate, 1, wx.EXPAND | wx.ALL, 2)
wx.EVT_SET_FOCUS(self.txtdate, self.OnSetFocus_USDate)
szr_label1 = wx.BoxSizer(wx.HORIZONTAL)
szr_label1.Add(label1, 1, 0, 0)
szr_label1.Add((10, 1), 0, 0)
szr_rc.Add(szr_label1, flag=wx.EXPAND, row=6, col=1)
szr_rc.Add(self.szr_txtdate, flag=wx.EXPAND, row=6, col=2, colspan=5)
#------------------------------
label2 = wx.StaticText(self, -1, _("Weeks"), size=(25, 20))
label2.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label2.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtweeks = wx.SpinCtrl(self, -1, value="0", min=0, max=42)
wx.EVT_SPINCTRL(self.txtweeks, self.txtweeks.GetId(),
self.EvtText_calcnewedc)
self.txtweeks.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.szr_txtweeks = wx.BoxSizer(wx.HORIZONTAL)
self.szr_txtweeks.Add(self.txtweeks, 1, wx.EXPAND | wx.ALL, 2)
label3 = wx.StaticText(self, -1, _("Days"), size=(25, 20))
label3.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label3.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtdays = wx.SpinCtrl(self, -1, value="0", min=0, max=6)
wx.EVT_SPINCTRL(self.txtdays, self.txtdays.GetId(),
self.EvtText_calcnewedc)
self.txtdays.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.szr_txtdays = wx.BoxSizer(wx.HORIZONTAL)
self.szr_txtdays.Add(self.txtdays, 1, wx.EXPAND | wx.ALL, 2)
szr_label2 = wx.BoxSizer(wx.HORIZONTAL)
szr_label2.Add(label2, 1, wx.ALIGN_CENTRE_VERTICAL, 0)
szr_label2.Add((10, 1), 0, 0)
szr_label3 = wx.BoxSizer(wx.HORIZONTAL)
szr_label3.Add((10, 1), 0, 0)
szr_label3.Add(label3, 1, wx.ALIGN_CENTRE_VERTICAL, 0)
szr_label3.Add((10, 1), 0, 0)
szr_rc.Add(szr_label2, flag=wx.EXPAND, row=7, col=1)
szr_rc.Add(self.szr_txtweeks, flag=wx.EXPAND, row=7, col=2, colspan=2)
szr_rc.Add(szr_label3, flag=wx.EXPAND, row=7, col=4)
szr_rc.Add(self.szr_txtdays, flag=wx.EXPAND, row=7, col=5, colspan=2)
#------------------------------
# sizer holding the new (or revised) 'EDC' stuff
#------------------------------
label = wx.StaticText(self, -1, _("Rev EDC"), size=(100, 20))
label.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
label.SetForegroundColour(wx.Colour(0, 0, 0))
self.txtnewedc = wx.TextCtrl(self, -1, "", size=(100, 20))
self.txtnewedc.Enable(False)
self.txtnewedc.SetFont(
wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False, ''))
self.szr_txtnewedc = wx.BoxSizer(wx.HORIZONTAL)
self.szr_txtnewedc.Add(self.txtnewedc, 1, wx.EXPAND | wx.ALL, 2)
szr_label = wx.BoxSizer(wx.HORIZONTAL)
szr_label.Add(label, 1, 0, 0)
szr_label.Add((10, 1), 0, 0)
szr_rc.Add(szr_label, flag=wx.EXPAND, row=8, col=1)
szr_rc.Add(self.szr_txtnewedc, flag=wx.EXPAND, row=8, col=2, colspan=5)
self.btnPrint = wx.Button(self, 1011, _('&Print'))
self.btnSave = wx.Button(self, 1011, _('&Save'))
szr_buttons = wx.BoxSizer(wx.HORIZONTAL)
szr_buttons.Add(self.btnPrint, 0, wx.EXPAND)
szr_buttons.Add(self.btnSave, 0, wx.EXPAND)
szr_rc.Add(szr_buttons, flag=wx.EXPAND, row=9, col=3, colspan=4)
#------------------------------
# Sizer holding stuff on the right
#------------------------------
szr_main_rt = wx.BoxSizer(wx.VERTICAL)
szr_main_rt.Add(szr_rc)
wx.EVT_BUTTON(self, 1010, self.EvtReset)
wx.EVT_BUTTON(self, 1011, self.EvtPrint)
wx.EVT_BUTTON(self, 1012, self.EvtSave)
#------------------------------
# Add calendar (stuff on the left)
#------------------------------
self.lmp_cal = wx.calendar.CalendarCtrl(self,
ID_LMP,
style=wx.RAISED_BORDER)
wx.calendar.EVT_CALENDAR_SEL_CHANGED(self.lmp_cal, ID_LMP,
self.OnCalcByLMP)
szr_main_lf = wx.BoxSizer(wx.VERTICAL)
szr_main_lf.Add(self.lmp_cal, 0, wx.ALIGN_CENTRE_HORIZONTAL)
btn_reset = wx.Button(self, 1010, _('&Reset'))
#szr_main_lf.Add(5,0,5)
szr_main_lf.Add(btn_reset, 0, wx.EXPAND)
#--------------------------------------
# Super-sizer holds all the stuff above
#--------------------------------------
szr_main_top = wx.BoxSizer(wx.HORIZONTAL)
szr_main_top.Add(szr_main_lf, 0, 0)
szr_main_top.Add((15, 0), 0, 0)
szr_main_top.Add(szr_main_rt, 0, 0)
#szr_main_top.Add(15,1,0,0)
#------------------------------
# Put everything together in one big sizer
#------------------------------
szr_main = wx.BoxSizer(wx.HORIZONTAL)
szr_main.Add(szr_main_top, 1, wx.EXPAND | wx.ALL, 10)
self.SetSizer(szr_main)
self.SetAutoLayout(1)
szr_main.Fit(self)
wx.EVT_CLOSE(self, self.OnClose)
def __init__(self, parent, ID, title):
wx.Frame.__init__(self, parent, ID, title, wx.DefaultPosition,
wx.DefaultSize)
self.dicepool = dicepool.dicepool()
self.config = wx.Config.Get()
pan = wx.Panel(self, -1)
ts = wx.BoxSizer(wx.VERTICAL)
ts.Add(pan, 1, wx.EXPAND | wx.ALL)
self.SetSizer(ts)
root = wx.BoxSizer(wx.HORIZONTAL)
controls = wx.BoxSizer(wx.VERTICAL)
poolbox = wx.BoxSizer(wx.HORIZONTAL)
poolbox.Add(wx.StaticText(pan, -1, _("Dice pool:")), 0,
wx.ALIGN_CENTER_VERTICAL)
self.poolctl = wx.SpinCtrl(pan, DIEROLLER_POOL, u"",
wx.DefaultPosition, wx.DefaultSize, 0, 1,
99)
self.poolctl.SetValue(self.dicepool.pool)
poolbox.Add(self.poolctl, 1, wx.ALIGN_CENTER_VERTICAL)
controls.Add(poolbox, 1, wx.EXPAND)
facebox = wx.BoxSizer(wx.HORIZONTAL)
facebox.Add(wx.StaticText(pan, -1, _("Die faces:")), 0,
wx.ALIGN_CENTER_VERTICAL)
self.facectl = wx.SpinCtrl(pan, DIEROLLER_FACES, u"",
wx.DefaultPosition, wx.DefaultSize, 0, 2,
99)
self.facectl.SetValue(self.dicepool.faces)
facebox.Add(self.facectl, 1, wx.ALIGN_CENTER_VERTICAL)
controls.Add(facebox, 1, wx.EXPAND)
rngbox = wx.BoxSizer(wx.VERTICAL)
rngbox.Add(
wx.StaticText(pan, -1, _("Pseudo-random number generator:")), 0)
self.rngctl = wx.Choice(pan, DIEROLLER_RNG, wx.DefaultPosition,
wx.DefaultSize,
headerdata.SF_DIEROLLER_RNGSTRINGS)
rngstring = self.config.Read(headerdata.SF_CONFIGKEY_RNG,
headerdata.SF_CONFIGDEFAULT_RNG)
self.dicepool.setrng(rngstring)
self.rngctl.SetStringSelection(rngstring)
rngbox.Add(self.rngctl, 1, wx.EXPAND)
controls.Add(rngbox, 0, wx.EXPAND)
self.tabctl = wx.CheckBox(pan, DIEROLLER_TAB, _("Tabulate"))
self.tabctl.SetValue(self.dicepool.tabulate)
controls.Add(self.tabctl, 0, wx.EXPAND)
self.botchctl = wx.CheckBox(pan, DIEROLLER_BOTCH, _("Botches"))
self.botchctl.SetValue(self.dicepool.botch)
controls.Add(self.botchctl, 0, wx.EXPAND)
self.doublectl = wx.CheckBox(pan, DIEROLLER_DOUBLE, _("Double"))
self.doublectl.SetValue(self.dicepool.double)
controls.Add(self.doublectl, 0, wx.EXPAND)
diffbox = wx.BoxSizer(wx.HORIZONTAL)
self.difflabel = wx.StaticText(pan, -1, _("Difficulty:"))
diffbox.Add(self.difflabel, 0, wx.ALIGN_CENTER_VERTICAL)
self.diffctl = wx.SpinCtrl(pan, DIEROLLER_DIFF, u"",
wx.DefaultPosition, wx.DefaultSize, 0, 1,
self.dicepool.faces, 6)
diffbox.Add(self.diffctl, 1, wx.ALIGN_CENTER_VERTICAL)
controls.Add(diffbox, 1, wx.EXPAND)
roll = wx.Button(pan, DIEROLLER_ROLL, _("Roll"))
controls.Add(roll, 0, wx.EXPAND)
root.Add(controls, 1, wx.EXPAND)
results = wx.BoxSizer(wx.VERTICAL)
self.resultbox = wx.TextCtrl(pan, -1, u"", wx.DefaultPosition,
wx.DefaultSize,
wx.TE_MULTILINE | wx.TE_READONLY)
results.Add(self.resultbox, 2, wx.EXPAND)
finalbox = wx.BoxSizer(wx.HORIZONTAL)
self.finallabel = wx.StaticText(pan, -1, _("Final score:"))
finalbox.Add(self.finallabel, 1, wx.ALIGN_CENTER_VERTICAL)
self.finalscore = wx.StaticText(pan, -1, u"")
finalbox.Add(self.finalscore, 1)
results.Add(finalbox, 0, wx.EXPAND)
successbox = wx.BoxSizer(wx.VERTICAL)
successlabelbox = wx.BoxSizer(wx.HORIZONTAL)
self.successtag = wx.StaticText(pan, -1, _("Successes:"))
successlabelbox.Add(self.successtag, 1, wx.ALIGN_LEFT)
self.successlabel = wx.StaticText(pan, -1,
"0/" + str(self.dicepool.pool))
successlabelbox.Add(self.successlabel, 0, wx.ALIGN_RIGHT)
successbox.Add(successlabelbox, 0, wx.EXPAND)
self.successgauge = wx.Gauge(pan, -1, self.dicepool.pool)
successbox.Add(self.successgauge, 0, wx.EXPAND)
results.Add(successbox, 0, wx.EXPAND)
failurebox = wx.BoxSizer(wx.VERTICAL)
failurelabelbox = wx.BoxSizer(wx.HORIZONTAL)
self.failuretag = wx.StaticText(pan, -1, _("Failures:"))
failurelabelbox.Add(self.failuretag, 1, wx.ALIGN_LEFT)
self.failurelabel = wx.StaticText(pan, -1,
"0/" + str(self.dicepool.pool))
failurelabelbox.Add(self.failurelabel, 0, wx.ALIGN_RIGHT)
failurebox.Add(failurelabelbox, 0, wx.EXPAND)
self.failuregauge = wx.Gauge(pan, -1, self.dicepool.pool)
failurebox.Add(self.failuregauge, 0, wx.EXPAND)
results.Add(failurebox, 0, wx.EXPAND)
botchbox = wx.BoxSizer(wx.VERTICAL)
botchlabelbox = wx.BoxSizer(wx.HORIZONTAL)
self.botchtag = wx.StaticText(pan, -1, _("Botches:"))
botchlabelbox.Add(self.botchtag, 1, wx.ALIGN_LEFT)
self.botchlabel = wx.StaticText(pan, -1,
"0/" + str(self.dicepool.pool))
botchlabelbox.Add(self.botchlabel, 0, wx.ALIGN_RIGHT)
botchbox.Add(botchlabelbox, 0, wx.EXPAND)
self.botchgauge = wx.Gauge(pan, -1, self.dicepool.pool)
botchbox.Add(self.botchgauge, 0, wx.EXPAND)
results.Add(botchbox, 0, wx.EXPAND)
close = wx.Button(pan, DIEROLLER_CLOSE, u"Close")
results.Add(close, 0, wx.EXPAND)
root.Add(results, 1, wx.EXPAND)
pan.SetSizer(root)
self.Fit()
self.Centre(wx.BOTH)
self.freshen()
wx.EVT_BUTTON(self, DIEROLLER_CLOSE, self.onclose)
wx.EVT_BUTTON(self, DIEROLLER_ROLL, self.onroll)
wx.EVT_SPINCTRL(self, DIEROLLER_POOL, self.onpool)
wx.EVT_SPINCTRL(self, DIEROLLER_FACES, self.onfaces)
wx.EVT_CHOICE(self, DIEROLLER_RNG, self.onrng)
wx.EVT_SPINCTRL(self, DIEROLLER_DIFF, self.ondiff)
wx.EVT_CHECKBOX(self, DIEROLLER_BOTCH, self.onbotch)
wx.EVT_CHECKBOX(self, DIEROLLER_TAB, self.ontab)
wx.EVT_CHECKBOX(self, DIEROLLER_DOUBLE, self.ondouble)
def Init(self, res):
"""Method called after the panel has been initialized."""
self.guiDVH = guidvh.guiDVH(self)
res.AttachUnknownControl('panelDVH', self.guiDVH.panelDVH, self)
# Initialize the Constraint selector controls
self.lblType = XRCCTRL(self, 'lblType')
self.choiceConstraint = XRCCTRL(self, 'choiceConstraint')
self.txtConstraint = XRCCTRL(self, 'txtConstraint')
self.sliderConstraint = XRCCTRL(self, 'sliderConstraint')
self.lblResultType = XRCCTRL(self, 'lblResultType')
self.lblConstraintUnits = XRCCTRL(self, 'lblConstraintUnits')
self.lblConstraintTypeUnits = XRCCTRL(self, 'lblConstraintTypeUnits')
# Initialize the result labels
self.lblConstraintType = XRCCTRL(self, 'lblConstraintType')
self.lblResultDivider = XRCCTRL(self, 'lblResultDivider')
self.lblConstraintPercent = XRCCTRL(self, 'lblConstraintPercent')
# Modify the control and font size on Mac
controls = [
self.lblType, self.choiceConstraint, self.sliderConstraint,
self.lblResultType, self.lblConstraintUnits,
self.lblConstraintPercent, self.lblConstraintType,
self.lblConstraintTypeUnits, self.lblResultDivider
]
# Add children of composite controls to modification list
compositecontrols = [self.txtConstraint]
for control in compositecontrols:
for child in control.GetChildren():
controls.append(child)
# Add the constraint static box to the modification list
controls.append(self.lblType.GetContainingSizer().GetStaticBox())
if guiutil.IsMac():
font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
font.SetPointSize(10)
for control in controls:
control.SetWindowVariant(wx.WINDOW_VARIANT_SMALL)
control.SetFont(font)
# Adjust the control size for the result value labels
te = self.lblType.GetTextExtent('0')
self.lblConstraintUnits.SetMinSize((te[0] * 10, te[1]))
self.lblConstraintPercent.SetMinSize((te[0] * 6, te[1]))
self.Layout()
# Bind ui events to the proper methods
wx.EVT_CHOICE(self, XRCID('choiceConstraint'),
self.OnToggleConstraints)
wx.EVT_SPINCTRL(self, XRCID('txtConstraint'), self.OnChangeConstraint)
wx.EVT_COMMAND_SCROLL_THUMBTRACK(self, XRCID('sliderConstraint'),
self.OnChangeConstraint)
wx.EVT_COMMAND_SCROLL_CHANGED(self, XRCID('sliderConstraint'),
self.OnChangeConstraint)
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
# Initialize variables
self.structures = {} # structures from initial DICOM data
self.checkedstructures = {} # structures that need to be shown
self.dvhs = {} # raw dvhs from initial DICOM data
self.dvhdata = {} # dict of dvh constraint functions
self.dvharray = {} # dict of dvh data processed from dvhdata
self.dvhscaling = {} # dict of dvh scaling data
self.plan = {} # used for rx dose
self.structureid = 1 # used to indicate current constraint structure
# Set up pubsub
pub.subscribe(self.OnUpdatePatient, 'patient.updated.parsed_data')
pub.subscribe(self.OnStructureCheck, 'structures.checked')
pub.subscribe(self.OnStructureSelect, 'structure.selected')
def __init__(self, *args, **kwds):
# begin wxGlade: MyFrame.__init__
kwds["style"] = wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self, *args, **kwds)
# Menu Bar
self.frame_1_menubar = wx.MenuBar()
self.SetMenuBar(self.frame_1_menubar)
wxglade_tmp_menu = wx.Menu()
self.Exit = wx.MenuItem(wxglade_tmp_menu, ID_EXIT, "Exit", "Exit",
wx.ITEM_NORMAL)
wxglade_tmp_menu.AppendItem(self.Exit)
self.frame_1_menubar.Append(wxglade_tmp_menu, "File")
# Menu Bar end
self.panel_1 = wx.Panel(self, -1)
self.button_1 = wx.Button(self, ID_BUTTON_1, "LSB")
self.button_2 = wx.Button(self, ID_BUTTON_2, "USB")
self.button_3 = wx.Button(self, ID_BUTTON_3, "AM")
self.button_4 = wx.Button(self, ID_BUTTON_4, "CW")
self.button_5 = wx.ToggleButton(self, ID_BUTTON_5, "Upper")
self.slider_fcutoff_hi = wx.Slider(self,
ID_SLIDER_1,
0,
-15798,
15799,
style=wx.SL_HORIZONTAL
| wx.SL_LABELS)
self.button_6 = wx.ToggleButton(self, ID_BUTTON_6, "Lower")
self.slider_fcutoff_lo = wx.Slider(self,
ID_SLIDER_2,
0,
-15799,
15798,
style=wx.SL_HORIZONTAL
| wx.SL_LABELS)
self.panel_5 = wx.Panel(self, -1)
self.label_1 = wx.StaticText(self, -1, " Band\nCenter")
self.text_ctrl_1 = wx.TextCtrl(self, ID_TEXT_1, "")
self.panel_6 = wx.Panel(self, -1)
self.panel_7 = wx.Panel(self, -1)
self.panel_2 = wx.Panel(self, -1)
self.button_7 = wx.ToggleButton(self, ID_BUTTON_7, "Freq")
self.slider_3 = wx.Slider(self, ID_SLIDER_3, 3000, 0, 6000)
self.spin_ctrl_1 = wx.SpinCtrl(self, ID_SPIN_1, "", min=0, max=100)
self.button_8 = wx.ToggleButton(self, ID_BUTTON_8, "Vol")
self.slider_4 = wx.Slider(self, ID_SLIDER_4, 0, 0, 500)
self.slider_5 = wx.Slider(self, ID_SLIDER_5, 0, 0, 20)
self.button_9 = wx.ToggleButton(self, ID_BUTTON_9, "Time")
self.button_11 = wx.Button(self, ID_BUTTON_11, "Rew")
self.button_10 = wx.Button(self, ID_BUTTON_10, "Fwd")
self.panel_3 = wx.Panel(self, -1)
self.label_2 = wx.StaticText(self, -1, "PGA ")
self.panel_4 = wx.Panel(self, -1)
self.panel_8 = wx.Panel(self, -1)
self.panel_9 = wx.Panel(self, -1)
self.label_3 = wx.StaticText(self, -1, "AM Sync\nCarrier")
self.slider_6 = wx.Slider(self,
ID_SLIDER_6,
50,
0,
200,
style=wx.SL_HORIZONTAL | wx.SL_LABELS)
self.label_4 = wx.StaticText(self, -1, "Antenna Tune")
self.slider_7 = wx.Slider(self,
ID_SLIDER_7,
1575,
950,
2200,
style=wx.SL_HORIZONTAL | wx.SL_LABELS)
self.panel_10 = wx.Panel(self, -1)
self.button_12 = wx.ToggleButton(self, ID_BUTTON_12, "Auto Tune")
self.button_13 = wx.Button(self, ID_BUTTON_13, "Calibrate")
self.button_14 = wx.Button(self, ID_BUTTON_14, "Reset")
self.panel_11 = wx.Panel(self, -1)
self.panel_12 = wx.Panel(self, -1)
self.__set_properties()
self.__do_layout()
# end wxGlade
parser = OptionParser(option_class=eng_option)
parser.add_option("",
"--address",
type="string",
default="addr=192.168.10.2",
help="Address of UHD device, [default=%default]")
parser.add_option("-c",
"--ddc-freq",
type="eng_float",
default=3.9e6,
help="set Rx DDC frequency to FREQ",
metavar="FREQ")
parser.add_option(
"-s",
"--samp-rate",
type="eng_float",
default=256e3,
help="set sample rate (bandwidth) [default=%default]")
parser.add_option("-a",
"--audio_file",
default="",
help="audio output file",
metavar="FILE")
parser.add_option("-r",
"--radio_file",
default="",
help="radio output file",
metavar="FILE")
parser.add_option("-i",
"--input_file",
default="",
help="radio input file",
metavar="FILE")
parser.add_option(
"-O",
"--audio-output",
type="string",
default="",
help="audio output device name. E.g., hw:0,0, /dev/dsp, or pulse")
(options, args) = parser.parse_args()
self.usrp_center = options.ddc_freq
input_rate = options.samp_rate
self.slider_range = input_rate * 0.9375
self.f_lo = self.usrp_center - (self.slider_range / 2)
self.f_hi = self.usrp_center + (self.slider_range / 2)
self.af_sample_rate = 32000
fir_decim = long(input_rate / self.af_sample_rate)
# data point arrays for antenna tuner
self.xdata = []
self.ydata = []
self.tb = gr.top_block()
# radio variables, initial conditions
self.frequency = self.usrp_center
# these map the frequency slider (0-6000) to the actual range
self.f_slider_offset = self.f_lo
self.f_slider_scale = 10000
self.spin_ctrl_1.SetRange(self.f_lo, self.f_hi)
self.text_ctrl_1.SetValue(str(int(self.usrp_center)))
self.slider_5.SetValue(0)
self.AM_mode = False
self.slider_3.SetValue(
(self.frequency - self.f_slider_offset) / self.f_slider_scale)
self.spin_ctrl_1.SetValue(int(self.frequency))
POWERMATE = True
try:
self.pm = powermate.powermate(self)
except:
sys.stderr.write("Unable to find PowerMate or Contour Shuttle\n")
POWERMATE = False
if POWERMATE:
powermate.EVT_POWERMATE_ROTATE(self, self.on_rotate)
powermate.EVT_POWERMATE_BUTTON(self, self.on_pmButton)
self.active_button = 7
# command line options
if options.audio_file == "": SAVE_AUDIO_TO_FILE = False
else: SAVE_AUDIO_TO_FILE = True
if options.radio_file == "": SAVE_RADIO_TO_FILE = False
else: SAVE_RADIO_TO_FILE = True
if options.input_file == "": self.PLAY_FROM_USRP = True
else: self.PLAY_FROM_USRP = False
if self.PLAY_FROM_USRP:
self.src = uhd.usrp_source(device_addr=options.address,
io_type=uhd.io_type.COMPLEX_FLOAT32,
num_channels=1)
self.src.set_samp_rate(input_rate)
input_rate = self.src.get_samp_rate()
self.src.set_center_freq(self.usrp_center, 0)
self.tune_offset = 0
else:
self.src = gr.file_source(gr.sizeof_short, options.input_file)
self.tune_offset = 2200 # 2200 works for 3.5-4Mhz band
# convert rf data in interleaved short int form to complex
s2ss = gr.stream_to_streams(gr.sizeof_short, 2)
s2f1 = gr.short_to_float()
s2f2 = gr.short_to_float()
src_f2c = gr.float_to_complex()
self.tb.connect(self.src, s2ss)
self.tb.connect((s2ss, 0), s2f1)
self.tb.connect((s2ss, 1), s2f2)
self.tb.connect(s2f1, (src_f2c, 0))
self.tb.connect(s2f2, (src_f2c, 1))
# save radio data to a file
if SAVE_RADIO_TO_FILE:
radio_file = gr.file_sink(gr.sizeof_short, options.radio_file)
self.tb.connect(self.src, radio_file)
# 2nd DDC
xlate_taps = gr.firdes.low_pass ( \
1.0, input_rate, 16e3, 4e3, gr.firdes.WIN_HAMMING )
self.xlate = gr.freq_xlating_fir_filter_ccf ( \
fir_decim, xlate_taps, self.tune_offset, input_rate )
# Complex Audio filter
audio_coeffs = gr.firdes.complex_band_pass(
1.0, # gain
self.af_sample_rate, # sample rate
-3000, # low cutoff
0, # high cutoff
100, # transition
gr.firdes.WIN_HAMMING) # window
self.slider_fcutoff_hi.SetValue(0)
self.slider_fcutoff_lo.SetValue(-3000)
self.audio_filter = gr.fir_filter_ccc(1, audio_coeffs)
# Main +/- 16Khz spectrum display
self.fft = fftsink2.fft_sink_c(self.panel_2,
fft_size=512,
sample_rate=self.af_sample_rate,
average=True,
size=(640, 240))
# AM Sync carrier
if AM_SYNC_DISPLAY:
self.fft2 = fftsink.fft_sink_c(self.tb,
self.panel_9,
y_per_div=20,
fft_size=512,
sample_rate=self.af_sample_rate,
average=True,
size=(640, 240))
c2f = gr.complex_to_float()
# AM branch
self.sel_am = gr.multiply_const_cc(0)
# the following frequencies turn out to be in radians/sample
# gr.pll_refout_cc(alpha,beta,min_freq,max_freq)
# suggested alpha = X, beta = .25 * X * X
pll = gr.pll_refout_cc(.5, .0625,
(2. * math.pi * 7.5e3 / self.af_sample_rate),
(2. * math.pi * 6.5e3 / self.af_sample_rate))
self.pll_carrier_scale = gr.multiply_const_cc(complex(10, 0))
am_det = gr.multiply_cc()
# these are for converting +7.5kHz to -7.5kHz
# for some reason gr.conjugate_cc() adds noise ??
c2f2 = gr.complex_to_float()
c2f3 = gr.complex_to_float()
f2c = gr.float_to_complex()
phaser1 = gr.multiply_const_ff(1)
phaser2 = gr.multiply_const_ff(-1)
# filter for pll generated carrier
pll_carrier_coeffs = gr.firdes.complex_band_pass(
2.0, # gain
self.af_sample_rate, # sample rate
7400, # low cutoff
7600, # high cutoff
100, # transition
gr.firdes.WIN_HAMMING) # window
self.pll_carrier_filter = gr.fir_filter_ccc(1, pll_carrier_coeffs)
self.sel_sb = gr.multiply_const_ff(1)
combine = gr.add_ff()
#AGC
sqr1 = gr.multiply_ff()
intr = gr.iir_filter_ffd([.004, 0], [0, .999])
offset = gr.add_const_ff(1)
agc = gr.divide_ff()
self.scale = gr.multiply_const_ff(0.00001)
dst = audio.sink(long(self.af_sample_rate), options.audio_output)
if self.PLAY_FROM_USRP:
self.tb.connect(self.src, self.xlate, self.fft)
else:
self.tb.connect(src_f2c, self.xlate, self.fft)
self.tb.connect(self.xlate, self.audio_filter, self.sel_am,
(am_det, 0))
self.tb.connect(self.sel_am, pll, self.pll_carrier_scale,
self.pll_carrier_filter, c2f3)
self.tb.connect((c2f3, 0), phaser1, (f2c, 0))
self.tb.connect((c2f3, 1), phaser2, (f2c, 1))
self.tb.connect(f2c, (am_det, 1))
self.tb.connect(am_det, c2f2, (combine, 0))
self.tb.connect(self.audio_filter, c2f, self.sel_sb, (combine, 1))
if AM_SYNC_DISPLAY:
self.tb.connect(self.pll_carrier_filter, self.fft2)
self.tb.connect(combine, self.scale)
self.tb.connect(self.scale, (sqr1, 0))
self.tb.connect(self.scale, (sqr1, 1))
self.tb.connect(sqr1, intr, offset, (agc, 1))
self.tb.connect(self.scale, (agc, 0))
self.tb.connect(agc, dst)
if SAVE_AUDIO_TO_FILE:
f_out = gr.file_sink(gr.sizeof_short, options.audio_file)
sc1 = gr.multiply_const_ff(64000)
f2s1 = gr.float_to_short()
self.tb.connect(agc, sc1, f2s1, f_out)
self.tb.start()
# for mouse position reporting on fft display
self.fft.win.Bind(wx.EVT_LEFT_UP, self.Mouse)
# and left click to re-tune
self.fft.win.Bind(wx.EVT_LEFT_DOWN, self.Click)
# start a timer to check for web commands
if WEB_CONTROL:
self.timer = UpdateTimer(self, 1000) # every 1000 mSec, 1 Sec
wx.EVT_BUTTON(self, ID_BUTTON_1, self.set_lsb)
wx.EVT_BUTTON(self, ID_BUTTON_2, self.set_usb)
wx.EVT_BUTTON(self, ID_BUTTON_3, self.set_am)
wx.EVT_BUTTON(self, ID_BUTTON_4, self.set_cw)
wx.EVT_BUTTON(self, ID_BUTTON_10, self.fwd)
wx.EVT_BUTTON(self, ID_BUTTON_11, self.rew)
wx.EVT_BUTTON(self, ID_BUTTON_13, self.AT_calibrate)
wx.EVT_BUTTON(self, ID_BUTTON_14, self.AT_reset)
wx.EVT_TOGGLEBUTTON(self, ID_BUTTON_5, self.on_button)
wx.EVT_TOGGLEBUTTON(self, ID_BUTTON_6, self.on_button)
wx.EVT_TOGGLEBUTTON(self, ID_BUTTON_7, self.on_button)
wx.EVT_TOGGLEBUTTON(self, ID_BUTTON_8, self.on_button)
wx.EVT_TOGGLEBUTTON(self, ID_BUTTON_9, self.on_button)
wx.EVT_SLIDER(self, ID_SLIDER_1, self.set_filter)
wx.EVT_SLIDER(self, ID_SLIDER_2, self.set_filter)
wx.EVT_SLIDER(self, ID_SLIDER_3, self.slide_tune)
wx.EVT_SLIDER(self, ID_SLIDER_4, self.set_volume)
wx.EVT_SLIDER(self, ID_SLIDER_5, self.set_pga)
wx.EVT_SLIDER(self, ID_SLIDER_6, self.am_carrier)
wx.EVT_SLIDER(self, ID_SLIDER_7, self.antenna_tune)
wx.EVT_SPINCTRL(self, ID_SPIN_1, self.spin_tune)
wx.EVT_MENU(self, ID_EXIT, self.TimeToQuit)
def _bind_event_spin(self, function):
wx.EVT_KILL_FOCUS(self.spin, function)
if wx.Platform == '__WXMAC__':
wx.EVT_TEXT(self.spin, self.spin.GetId(), function)
wx.EVT_SPINCTRL(self.spin, self.spin.GetId(), function)
def __init__(self, parent, headers, cfg, cfgGl, applyFunc):
wx.Dialog.__init__(self,
parent,
-1,
"Headers",
style=wx.DEFAULT_DIALOG_STYLE)
self.headers = headers
self.cfg = cfg
self.cfgGl = cfgGl
self.applyFunc = applyFunc
# whether some events are blocked
self.block = False
self.hdrIndex = -1
if len(self.headers.hdrs) > 0:
self.hdrIndex = 0
vsizer = wx.BoxSizer(wx.VERTICAL)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "Empty lines after headers:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.elinesEntry = wx.SpinCtrl(self, -1)
self.elinesEntry.SetRange(0, 5)
wx.EVT_SPINCTRL(self, self.elinesEntry.GetId(), self.OnMisc)
wx.EVT_KILL_FOCUS(self.elinesEntry, self.OnKillFocus)
hsizer.Add(self.elinesEntry, 0, wx.LEFT, 10)
vsizer.Add(hsizer)
vsizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND | wx.TOP | wx.BOTTOM,
10)
tmp = wx.StaticText(self, -1, "Strings:")
vsizer.Add(tmp)
self.stringsLb = wx.ListBox(self, -1, size=(200, 100))
vsizer.Add(self.stringsLb, 0, wx.EXPAND)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
self.addBtn = gutil.createStockButton(self, "Add")
hsizer.Add(self.addBtn)
wx.EVT_BUTTON(self, self.addBtn.GetId(), self.OnAddString)
gutil.btnDblClick(self.addBtn, self.OnAddString)
self.delBtn = gutil.createStockButton(self, "Delete")
hsizer.Add(self.delBtn, 0, wx.LEFT, 10)
wx.EVT_BUTTON(self, self.delBtn.GetId(), self.OnDeleteString)
gutil.btnDblClick(self.delBtn, self.OnDeleteString)
vsizer.Add(hsizer, 0, wx.TOP, 5)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add(wx.StaticText(self, -1, "Text:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.textEntry = wx.TextCtrl(self, -1)
hsizer.Add(self.textEntry, 1, wx.LEFT, 10)
wx.EVT_TEXT(self, self.textEntry.GetId(), self.OnMisc)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.TOP, 20)
vsizer.Add(
wx.StaticText(self, -1,
"'${PAGE}' will be replaced by the page number."), 0,
wx.ALIGN_CENTER | wx.TOP, 5)
hsizerTop = wx.BoxSizer(wx.HORIZONTAL)
gsizer = wx.FlexGridSizer(3, 2, 5, 0)
gsizer.Add(wx.StaticText(self, -1, "Header line:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.lineEntry = wx.SpinCtrl(self, -1)
self.lineEntry.SetRange(1, 5)
wx.EVT_SPINCTRL(self, self.lineEntry.GetId(), self.OnMisc)
wx.EVT_KILL_FOCUS(self.lineEntry, self.OnKillFocus)
gsizer.Add(self.lineEntry)
gsizer.Add(wx.StaticText(self, -1, "X offset (characters):"), 0,
wx.ALIGN_CENTER_VERTICAL | wx.RIGHT, 10)
self.xoffEntry = wx.SpinCtrl(self, -1)
self.xoffEntry.SetRange(-100, 100)
wx.EVT_SPINCTRL(self, self.xoffEntry.GetId(), self.OnMisc)
wx.EVT_KILL_FOCUS(self.xoffEntry, self.OnKillFocus)
gsizer.Add(self.xoffEntry)
gsizer.Add(wx.StaticText(self, -1, "Alignment:"), 0,
wx.ALIGN_CENTER_VERTICAL)
self.alignCombo = wx.ComboBox(self, -1, style=wx.CB_READONLY)
for it in [("Left", util.ALIGN_LEFT), ("Center", util.ALIGN_CENTER),
("Right", util.ALIGN_RIGHT)]:
self.alignCombo.Append(it[0], it[1])
gsizer.Add(self.alignCombo)
wx.EVT_COMBOBOX(self, self.alignCombo.GetId(), self.OnMisc)
hsizerTop.Add(gsizer)
bsizer = wx.StaticBoxSizer(wx.StaticBox(self, -1, "Style"),
wx.HORIZONTAL)
vsizer2 = wx.BoxSizer(wx.VERTICAL)
# wxGTK adds way more space by default than wxMSW between the
# items, have to adjust for that
pad = 0
if misc.isWindows:
pad = 5
self.addCheckBox("Bold", self, vsizer2, pad)
self.addCheckBox("Italic", self, vsizer2, pad)
self.addCheckBox("Underlined", self, vsizer2, pad)
bsizer.Add(vsizer2)
hsizerTop.Add(bsizer, 0, wx.LEFT, 40)
vsizer.Add(hsizerTop, 0, wx.TOP, 20)
hsizer = wx.BoxSizer(wx.HORIZONTAL)
hsizer.Add((1, 1), 1)
previewBtn = gutil.createStockButton(self, "Preview")
hsizer.Add(previewBtn)
applyBtn = gutil.createStockButton(self, "Apply")
hsizer.Add(applyBtn, 0, wx.LEFT, 10)
cancelBtn = gutil.createStockButton(self, "Cancel")
hsizer.Add(cancelBtn, 0, wx.LEFT, 10)
okBtn = gutil.createStockButton(self, "OK")
hsizer.Add(okBtn, 0, wx.LEFT, 10)
vsizer.Add(hsizer, 0, wx.EXPAND | wx.TOP, 20)
util.finishWindow(self, vsizer)
wx.EVT_BUTTON(self, previewBtn.GetId(), self.OnPreview)
wx.EVT_BUTTON(self, applyBtn.GetId(), self.OnApply)
wx.EVT_BUTTON(self, cancelBtn.GetId(), self.OnCancel)
wx.EVT_BUTTON(self, okBtn.GetId(), self.OnOK)
wx.EVT_LISTBOX(self, self.stringsLb.GetId(), self.OnStringsLb)
# list of widgets that are specific to editing the selected string
self.widList = [
self.textEntry, self.xoffEntry, self.alignCombo, self.lineEntry,
self.boldCb, self.italicCb, self.underlinedCb
]
self.updateGui()
self.textEntry.SetFocus()
def __init__(self, FileName):
wx.Dialog.__init__(self, None, title="Importing a spreadsheet file",\
size=(600,380))
self.FileName = FileName
self.excel = ['.xls','.xlsx']
self.loo = ['.ods']
extension = os.path.splitext(self.FileName.fileName)[1]
if extension.lower() in self.excel:
self.ftype = "excel"
elif extension.lower() in self.loo:
self.ftype = "libre"
else:
self.ftype = None
if not self.ftype:
self.CancelButton(None)
help_text = "Salstat can load files from Excel and LibreOffice/OpenOffice. "
t1 = wx.StaticText(self, -1, label=help_text, pos=(20,10))
t1.Wrap(545)
t2 = wx.StaticText(self,-1,label="Import from row:",pos=(20,50))
self.headerRow = wx.CheckBox(self, 760, " Header on first row", \
pos=(210,50))
self.dataRow = wx.SpinCtrl(self,766,min=1,max=100, initial=1, \
pos=(140,49),size=(50,-1))
self.dataRow.SetValue(1)
self.buttonImport = wx.Button(self,763,"Import", \
pos=(500,310),size=(70,-1))
self.buttonImport.SetDefault()
self.buttonCancel = wx.Button(self,764,"Cancel", \
pos=(405,310),size=(70,-1))
self.worksheets = wx.aui.AuiNotebook(self, -1, pos=(20,90), \
size=(560,210),style=wx.NB_TOP|wx.aui.AUI_NB_WINDOWLIST_BUTTON)
self.MaxRows = 100
self.MaxCols = 40
self.gridFont = wx.Font(10, wx.MODERN, wx.NORMAL, wx.NORMAL)
if self.ftype == "excel":
self.workbook = xlrd.open_workbook(self.FileName.fileName)
sheets = self.workbook.sheets()
elif self.ftype == "libre":
self.workbook = ezodf.opendoc(self.FileName.fileName)
sheets = self.workbook.sheets
self.grids = []
for idx, sheet in enumerate(sheets):
self.grids.append(Grid(self.worksheets, -1))
self.grids[idx].HideRowLabels()
self.grids[idx].SetColLabelSize(16)
self.grids[idx].SetRowLabelSize(40)
self.grids[idx].SetDefaultColSize(60)
self.grids[idx].CreateGrid(self.MaxRows,self.MaxCols)
for i in range(self.MaxCols):
self.grids[idx].SetColLabelValue(i, " ")
for i in range(self.MaxRows):
self.grids[idx].SetRowSize(i,16)
self.grids[idx].SetDefaultCellFont(self.gridFont)
self.worksheets.AddPage(self.grids[idx],sheet.name)
if self.ftype == 'excel':
nrows = sheet.nrows
ncols = sheet.ncols
elif self.ftype == 'libre':
nrows = sheet.nrows()
ncols = sheet.ncols()
self.grids[idx].ResizeGrid(ncols, nrows)
for idx_row in range(nrows):
for idx_col in range(ncols):
if self.ftype == 'excel':
val = unicode(sheet.cell(idx_row, idx_col).value)
elif self.ftype == 'libre':
val = unicode(sheet[idx_row, idx_col].value)
self.grids[idx].SetCellValue(idx_row, idx_col, val)
# It seems odd but it seems better for all events to be routed to the same method
wx.EVT_CHECKBOX(self, 760, self.AdjustGrid)
wx.EVT_SPINCTRL(self, 766, self.AdjustGrid)
wx.EVT_BUTTON(self, 764, self.CancelButton)
wx.EVT_BUTTON(self, 763, self.ImportButton)
