def __init__(self, mode=None, data=None, type=None, id_prj=0, *args, **kwds):

""" Constructor of the MainFrame class """

self.idPrj = id_prj

# Note that key stands for the text to display rather than a record key

# The name has not been changed to conform with the existing terminology

# of the system.

kwdsnew = copy.copy(kwds)

kwdsnew["style"] = wx.DEFAULT_FRAME_STYLE

wx.Frame.__init__(self, *args, **kwdsnew)

# Default path is the report

t = datetime.datetime.now().isoformat()

time_stamp = t.replace(':', '').replace('.', '').replace('T', '').replace('-','')

self.Path = os.path.join(os.getcwd(),'Report'+'_' + time_stamp + '.txt')

self.ReportObject, self.FormatOptions = data

# Create the tabs

self.NoteBook = wx.Notebook(self, -1, style=0)

self.ReportPane = wx.Panel(self.NoteBook, 0)

self.OptionsPane = wx.Panel(self.NoteBook, 1)

self.tc_ReportDisplay = stc.StyledTextCtrl(self.ReportPane, wx.ID_ANY )

self.tc_ReportDisplay.StyleSetFaceName(stc.STC_STYLE_DEFAULT,'Courier')

self.tc_ReportDisplay.StyleClearAll()

self.DisplayText()

# Now add the filter controls:

self.st_DetailLevel = wx.StaticText(self.OptionsPane, -1, 'Detail Level:')

self.cc_DetailLevel = cdml.Combo(self.OptionsPane, cdml.IDF_BUTTON1)

self.st_ShowDependency = wx.StaticText(self.OptionsPane, -1, 'Show Dependency:')

self.cc_ShowDependency = cdml.Combo(self.OptionsPane, cdml.IDF_BUTTON2, validator=cdml.KeyValidator(cdml.NO_EDIT))

self.st_SummaryIntevals = wx.StaticText(self.OptionsPane, -1, 'Summary Intervals:')

self.tc_SummaryIntevals = cdml.Text(self.OptionsPane, -1, "")

self.st_ColumnNumberFormatFloat = wx.StaticText(self.OptionsPane, -1, 'Float Column Number Format:')

self.tc_ColumnNumberFormatFloat = cdml.Text(self.OptionsPane, -1, "")

self.st_ColumnNumberFormatInteger = wx.StaticText(self.OptionsPane, -1, 'Integer Column Number Format:')

self.tc_ColumnNumberFormatInteger = cdml.Text(self.OptionsPane, -1, "")

self.st_ColumnSeparator = wx.StaticText(self.OptionsPane, -1, 'Column Separator:')

self.tc_ColumnSeparator = cdml.Text(self.OptionsPane, -1, "")

self.st_ShowHidden = wx.StaticText(self.OptionsPane, -1, 'Show Hidden:')

self.cc_ShowHidden = cdml.Combo(self.OptionsPane, cdml.IDF_BUTTON2, validator=cdml.KeyValidator(cdml.NO_EDIT))

# allow showing Hidden parameters only in Admin mode

IsVisible = cdml.GetAdminMode()

self.st_ShowHidden.Show(IsVisible)

self.cc_ShowHidden.Show(IsVisible)

self.st_CandidateColumns = wx.StaticText(self.OptionsPane, -1, 'Candidate Columns:')

self.lc_CandidateColumns = cdml.List(self.OptionsPane, -1, style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)

self.st_ColumnTitle = wx.StaticText(self.OptionsPane, -1, 'Column Title:')

self.tc_ColumnTitle = cdml.Text(self.OptionsPane, -1, "")

self.st_CalculationMethod = wx.StaticText(self.OptionsPane, -1, 'Calculation Method:')

self.cc_CalculationMethod = cdml.Combo(self.OptionsPane, cdml.IDF_BUTTON3, validator=cdml.KeyValidator(cdml.NO_EDIT))

self.st_StratificationTable = wx.StaticText(self.OptionsPane, -1, 'Stratification Table:')

self.tc_StratificationTable = cdml.Text(self.OptionsPane, -1, "", style = wx.TE_MULTILINE)

self.btn_LoadReportOptions = wx.Button(self.OptionsPane, cdml.IDP_BUTTON1, "Load Report Options")

self.btn_SaveReportOptions = wx.Button(self.OptionsPane, cdml.IDP_BUTTON2, "Save Report Options")

self.btn_Add = wx.Button(self.OptionsPane, wx.ID_ADD, ">")

self.btn_Del = wx.Button(self.OptionsPane, wx.ID_DELETE, "X")

self.st_SelectedColumns = wx.StaticText(self.OptionsPane, -1, 'Selected Columns:')

self.lc_SelectedColumns = cdml.List(self.OptionsPane, -1, style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_SINGLE_SEL)

self.btn_Regenerate = wx.Button(self.OptionsPane, wx.ID_APPLY, "Regenerate Report")

# Add Standard menu while skipping a few options

cdml.GenerateStandardMenu(self, SkipItems = [cdml.ID_MENU_REPORT_THIS, cdml.ID_MENU_REPORT_ALL])

# Add a SaveAs option to the menu

self.MenuItemSave = wx.MenuItem(self.MenuBarFile, wx.ID_SAVE, "&Save", "", wx.ITEM_NORMAL)

self.MenuBarFile.AppendItem(self.MenuItemSave)

self.MenuItemSaveAs = wx.MenuItem(self.MenuBarFile, wx.ID_SAVEAS, "Save &As", "", wx.ITEM_NORMAL)

self.MenuBarFile.AppendItem(self.MenuItemSaveAs)

#

self.Bind(wx.EVT_MENU, self.OnMenuSelected, self.MenuItemSave)

self.Bind(wx.EVT_MENU, self.OnMenuSelected, self.MenuItemSaveAs)

self.Bind(wx.EVT_BUTTON, self.FrameEventHandler)

self.Bind(wx.EVT_CLOSE, self.FrameEventHandler)

self.__set_properties()

self.__do_layout()

def __set_properties(self):

self.HelpContext = 'ReportViewer'

self.SetTitle("Report Viewer")

self.SetSize((900, 700))

self.MyMakeModal(True)

self.st_DetailLevel.SetMinSize((-1, -1))

self.st_ShowDependency.SetMinSize((-1, -1))

self.st_ColumnNumberFormatFloat.SetMinSize((-1, -1))

self.st_ColumnNumberFormatInteger.SetMinSize((-1, -1))

self.st_CandidateColumns.SetMinSize((-1, -1))

self.st_SelectedColumns.SetMinSize((-1, -1))

self.st_ColumnSeparator.SetMinSize((-1, -1))

self.st_ShowHidden.SetMinSize((-1, -1))

self.st_ColumnTitle.SetMinSize((-1, -1))

self.st_CalculationMethod.SetMinSize((-1, -1))

self.st_StratificationTable.SetMinSize((-1, -1))

self.cc_DetailLevel.SetMinSize((80, 21))

self.cc_DetailLevel.SetColumns([('Detail Level', 100)])

self.cc_DetailLevel.InRow = False

self.cc_DetailLevel.AllowInput = True

self.cc_DetailLevel.SetItems([(str(Entry),-1) for Entry in range(10)], allowBlank = True, do_sort = False)

self.cc_ShowDependency.SetMinSize((80, 21))

self.cc_ShowDependency.SetColumns([('Show Dependency', 100)])

self.cc_ShowDependency.InRow = False

self.cc_ShowDependency.SetItems([('No',-1),('Yes',-1)], allowBlank = True, do_sort = False)

self.cc_ShowHidden.SetMinSize((80, 21))

self.cc_ShowHidden.SetColumns([('Show Dependency', 100)])

self.cc_ShowHidden.InRow = False

self.cc_ShowHidden.SetItems([('No',-1),('Yes',-1)], allowBlank = True, do_sort = False)

self.tc_SummaryIntevals.SetMinSize((80, -1))

self.tc_ColumnNumberFormatFloat.SetMinSize((80, -1))

self.tc_ColumnNumberFormatInteger.SetMinSize((80, -1))

self.tc_ColumnSeparator.SetMinSize((80, -1))

self.tc_StratificationTable.SetMinSize((320, -1))

self.lc_CandidateColumns.SetMinSize((320,140))

self.lc_CandidateColumns.AllowBlank = False

# add column information only if there are columns

if self.ReportObject.__class__.__name__ in ['SimulationResult','SimulationResults']:

self.lc_CandidateColumns.CreateColumns([('Column Name/Group',300)])

DetailedStateIndicatorList = []

for Ending1 in [',State', ',Sub-Process' ]:

for Ending2 in ['', '_Actual'] + DB.ParamNameExtensitons[1:] :

DetailedStateIndicatorList.append('<State Indicator'+ Ending1 + Ending2 +'>')

ColumnGroupsToAdd = ['<Header>','<Number>','<Integer>','<State Indicator>','<System Option>'] + DetailedStateIndicatorList

self.lc_CandidateColumns.SetItems([(Entry,Num) for (Num,Entry) in enumerate(ColumnGroupsToAdd + self.ReportObject.DataColumns)], do_sort=False)

self.tc_ColumnTitle.SetMinSize((320, -1))

self.cc_CalculationMethod.SetColumns([('Calculation Method', 290)])

self.cc_CalculationMethod.SetItems([(Entry,-1) for Entry in DB.ReportCalculationMethods], allowBlank = False, do_sort = False)

self.cc_CalculationMethod.InRow = False

self.cc_CalculationMethod.SetMinSize((320, -1))

self.cc_CalculationMethod.GetTextCtrl().SetValue(DB.ReportCalculationMethods[0])

self.btn_Add.SetMinSize((50,50))

self.btn_Add.SetToolTipString("Add column to the selected column list")

self.btn_Del.SetMinSize((50,50))

self.btn_Del.SetToolTipString("Delete column From the selected column list")

self.btn_LoadReportOptions.SetMinSize((200,-1))

self.btn_LoadReportOptions.SetToolTipString("Load report options from file")

self.btn_SaveReportOptions.SetMinSize((200,-1))

self.btn_SaveReportOptions.SetToolTipString("Save report options to file")

self.lc_SelectedColumns.SetMinSize((455,280))

self.lc_SelectedColumns.CreateColumns([('Column Name/Group',220),('Calculation Method',150),('Title',80)])

self.btn_Regenerate.SetMinSize((150,50))

self.tc_ReportDisplay.SetMinSize((850,650))

def __do_layout(self):

OptionsSizer = wx.GridBagSizer(0,0)

OptionsSizer.Add(self.st_DetailLevel, (0,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.cc_DetailLevel, (0,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_StratificationTable, (0,2), (1,1), wx.ALIGN_CENTER, 1)

OptionsSizer.Add(self.tc_StratificationTable, (1,2), (2,1), wx.EXPAND | wx.ALL, 1)

OptionsSizer.Add(self.btn_LoadReportOptions, (4,2), (1,1), wx.ALIGN_CENTER, 1)

OptionsSizer.Add(self.btn_SaveReportOptions, (5,2), (1,1), wx.ALIGN_CENTER, 1)

OptionsSizer.Add(self.st_ShowDependency, (1,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.cc_ShowDependency, (1,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_SummaryIntevals, (2,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.tc_SummaryIntevals, (2,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_ColumnNumberFormatFloat, (3,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.tc_ColumnNumberFormatFloat, (3,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_ColumnNumberFormatInteger, (4,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.tc_ColumnNumberFormatInteger, (4,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_ColumnSeparator, (5,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.tc_ColumnSeparator, (5,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_ShowHidden, (6,0), (1,1), wx.ALIGN_RIGHT, 1)

OptionsSizer.Add(self.cc_ShowHidden, (6,1), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.st_CandidateColumns, (7,0), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.lc_CandidateColumns, (8,0), (5,1), wx.ALL, 1)

OptionsSizer.Add(self.st_CalculationMethod, (13,0), (1,1), wx.ALIGN_BOTTOM | wx.ALL, 1)

OptionsSizer.Add(self.cc_CalculationMethod, (14,0), (1,1), wx.ALIGN_TOP |wx.ALL, 1)

OptionsSizer.Add(self.st_ColumnTitle, (15,0), (1,1), wx.ALIGN_BOTTOM | wx.ALL , 1)

OptionsSizer.Add(self.tc_ColumnTitle, (16,0), (1,1), wx.ALIGN_TOP | wx.ALL , 1)

OptionsSizer.Add(self.btn_Add, (8,1), (1,1), wx.ALIGN_CENTER, 1)

OptionsSizer.Add(self.btn_Del, (9,1), (1,1), wx.ALIGN_CENTER, 1)

OptionsSizer.Add(self.st_SelectedColumns, (7,2), (1,1), wx.ALL, 1)

OptionsSizer.Add(self.lc_SelectedColumns, (8,2), (10,1), wx.ALL, 1)

OptionsSizer.Add(self.btn_Regenerate, (18,0), (1,3), wx.ALL|wx.EXPAND, 1)

self.OptionsPane.SetSizer(OptionsSizer)

ReportSizer = wx.BoxSizer(wx.HORIZONTAL)

ReportSizer.Add(self.tc_ReportDisplay, flag = wx.ALL|wx.EXPAND)

self.ReportPane.SetSizer(ReportSizer)

# add each panel to notebook control as pages

self.NoteBook.AddPage(self.ReportPane, "Report Text")

self.NoteBook.AddPage(self.OptionsPane, "Report Options")

self.Layout()

def AddColumnHandler(self):

" Add a column to the report "

# Get text from the list box

Index = self.lc_CandidateColumns.GetFirstSelected()

if Index != -1:

ColumnText = str(self.lc_CandidateColumns.GetItemText(Index))

CalculationMethod = str(self.cc_CalculationMethod.GetTextCtrl().GetValue())

ColumnTitle = str(self.tc_ColumnTitle.GetValue())

Item = (ColumnText,CalculationMethod,ColumnTitle)

ToIndex = self.lc_SelectedColumns.GetFirstSelected()

if ToIndex == -1:

ToIndex = self.lc_SelectedColumns.GetItemCount()

self.lc_SelectedColumns.AddItem(Item, ToIndex, False)

# Reset the title to an empty string for the next add

self.tc_ColumnTitle.SetValue('')

return

def DelColumnHandler(self):

" Delete a column from the report "

Index = self.lc_SelectedColumns.GetFirstSelected()

if Index != -1:

self.lc_SelectedColumns.DeleteItem(Index)

return

def ExtractReportOptions(self):

" Extract the options from the screen "

FormatOptions = self.FormatOptions

# Detail level

DetailLevelStr = str(self.cc_DetailLevel.GetTextCtrl().GetValue())

if DetailLevelStr != '':

try:

DetailLevel = int (DetailLevelStr)

except:

cdml.dlgSimpleMsg('Report Parameter Error', 'The text in the detail level box is not a number, please enter a positive number in the detail level box or leave it blank for the default' , wx.OK, wx.ICON_ERROR, Parent = self)

return

if DetailLevel < 0:

cdml.dlgSimpleMsg('Report Parameter Error', 'The number in the detail level box is negative, please enter a positive number in the detail level box or leave it blank for the default' , wx.OK, wx.ICON_ERROR, Parent = self)

return

FormatOptions = DB.HandleOption('DetailLevel', FormatOptions, DetailLevel, True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('DetailLevel', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Show Dependency

ShowDependencyStr = str(self.cc_ShowDependency.GetTextCtrl().GetValue())

if ShowDependencyStr != '':

FormatOptions = DB.HandleOption('ShowDependency', FormatOptions, ShowDependencyStr == 'Yes', True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('ShowDependency', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Summary Intervals

SummaryIntevalStr = str(self.tc_SummaryIntevals.GetValue())

if SummaryIntevalStr != '':

# Analyze the Summary Interval and make sure there

# are only numbers there and valid punctuations there

for Char in SummaryIntevalStr:

if Char not in (DB.NumericCharacters + '[], '):

raise ValueError, 'Summary Interval may contain only numeric characters, brackets, commas, and spaces'

try:

# Transform this to a number

SummaryInterval = eval(SummaryIntevalStr , DB.EmptyEvalDict)

except:

(ExceptType, ExceptValue, ExceptTraceback) = sys.exc_info()

cdml.dlgSimpleMsg('Report Parameter Error', 'Summary Interval does not evaluate to a valid expression. Here are Additional Details: '+ str(ExceptValue), wx.OK, wx.ICON_ERROR, Parent = self)

return

if not DB.IsList(SummaryInterval):

# Handle the case that the user asked for only one

# Summary Interval

if DB.IsInt(SummaryInterval):

# Convert integer to list

SummaryInterval = [SummaryInterval]

elif DB.IsTuple(SummaryInterval):

# Convert Tuple to list

SummaryInterval = list(SummaryInterval)

else:

cdml.dlgSimpleMsg('Report Parameter Error', 'Invalid Summary Interval format', wx.OK, wx.ICON_ERROR, Parent = self)

return

# Now verify that each member of the list is valid:

for Member in SummaryInterval:

if not (DB.IsInt(Member) or (DB.IsList(Member) and len(Member)==2 and all(map(lambda Entry: DB.IsInt(Entry), Member)))):

cdml.dlgSimpleMsg('Report Parameter Error', 'A member of the Summary interval list is not valid, i.e. not an integer or a list of two integers. The offending member is: ' + str(Member), wx.OK, wx.ICON_ERROR, Parent = self)

return

FormatOptions = DB.HandleOption('SummaryIntervals', FormatOptions, SummaryInterval, True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('SummaryIntervals', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Number Formats

ColumnNumberFormatFloatStr = str(self.tc_ColumnNumberFormatFloat.GetValue())

ColumnNumberFormatIntegerStr = str(self.tc_ColumnNumberFormatInteger.GetValue())

if ColumnNumberFormatFloatStr != '' or ColumnNumberFormatIntegerStr != '':

if ColumnNumberFormatFloatStr == '' or ColumnNumberFormatIntegerStr == '':

cdml.dlgSimpleMsg('Report Parameter Error', 'If a number format is defined, it should be defined both for floats and for integers', wx.OK, wx.ICON_ERROR, Parent = self)

return

ColumnNumberFormatFloatTest = ColumnNumberFormatFloatStr

# Test that the float format is valid

try:

ColumnNumberFormatFloatTest % 123.456

except:

cdml.dlgSimpleMsg('Report Parameter Error', 'Float format is invalid - format should correspond to python string formatting conventions', wx.OK, wx.ICON_ERROR, Parent = self)

return

# Test that the Integer format is valid

try:

ColumnNumberFormatIntegerStr % 123456

except:

cdml.dlgSimpleMsg('Report Parameter Error', 'Integer format is invalid - format should correspond to python string formatting conventions', wx.OK, wx.ICON_ERROR, Parent = self)

return

# If reached here, format options can be specified

FormatOptions = DB.HandleOption('ColumnNumberFormat', FormatOptions, (ColumnNumberFormatFloatStr,ColumnNumberFormatIntegerStr), True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('ColumnNumberFormat', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Column Separator

ColumnSeparatorStr = str(self.tc_ColumnSeparator.GetValue())

if ColumnSeparatorStr != '':

FormatOptions = DB.HandleOption('ColumnSpacing', FormatOptions , ColumnSeparatorStr, True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('ColumnSpacing', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Show Hidden

ShowHiddenStr = str(self.cc_ShowHidden.GetTextCtrl().GetValue())

if ShowHiddenStr != '':

FormatOptions = DB.HandleOption('ShowHidden', FormatOptions, ShowHiddenStr == 'Yes', True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('ShowHidden', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Column Selections

NumberOfSelectedColumns = self.lc_SelectedColumns.GetItemCount()

if NumberOfSelectedColumns > 0:

ColumnList = []

for Index in range(NumberOfSelectedColumns):

ColumnText = str(self.lc_SelectedColumns.GetItem(Index,0).Text)

CalculationMethod = str(self.lc_SelectedColumns.GetItem(Index,1).Text)

ColumnTitle = str(self.lc_SelectedColumns.GetItem(Index,2).Text)

ColumnList.append((ColumnText,CalculationMethod,ColumnTitle))

FormatOptions = DB.HandleOption('ColumnFilter', FormatOptions, ColumnList, True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('ColumnFilter', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

# Stratification table

StratificationTableStr = str(self.tc_StratificationTable.GetValue()).strip()

if StratificationTableStr != '':

try:

#first verify that this is a valid expression

DB.Expr(StratificationTableStr)

#then verify that this is a valid expression

DB.TableClass(StratificationTableStr)

except:

(ExceptType, ExceptValue, ExceptTraceback) = sys.exc_info()

cdml.dlgSimpleMsg('Report Parameter Error', 'The text in the Stratification Table box is not a valid table, please enter a valid table in the box or leave it blank for the default of no stratification. Here are Additional Details: '+ str(ExceptValue) , wx.OK, wx.ICON_ERROR, Parent = self)

return

FormatOptions = DB.HandleOption('StratifyBy', FormatOptions, StratificationTableStr, True)

else:

# Handle the defualt case by removing the option form the list

NewFormatOptions = DB.HandleOption('StratifyBy', FormatOptions, None, False, True)

if NewFormatOptions != None:

FormatOptions = NewFormatOptions

return FormatOptions

def PopulateOptionsOnScreen(self,FormatOptions):

""" updates controls with values from an option list """

# Detail level

DetailLevelStr = str(DB.HandleOption('DetailLevel', FormatOptions, ''))

self.cc_DetailLevel.GetTextCtrl().SetValue(DetailLevelStr)

# Show Dependency

ShowDependency = str(DB.HandleOption('ShowDependency', FormatOptions, ''))

ShowDependencyStr = DB.Iif(ShowDependency == '','',DB.Iif(ShowDependency,'Yes','No'))

self.cc_ShowDependency.GetTextCtrl().SetValue(ShowDependencyStr)

# Summary Intervals

SummaryIntevalStr = str(DB.HandleOption('SummaryIntervals', FormatOptions, ''))

self.tc_SummaryIntevals.SetValue(SummaryIntevalStr)

# Number Formats

(ColumnNumberFormatFloatStr,ColumnNumberFormatIntegerStr) = DB.HandleOption('ColumnNumberFormat', FormatOptions, ('',''))

self.tc_ColumnNumberFormatFloat.SetValue(ColumnNumberFormatFloatStr)

self.tc_ColumnNumberFormatInteger.SetValue(ColumnNumberFormatIntegerStr)

# Column Separator

ColumnSeparatorStr = str(DB.HandleOption('ColumnSpacing', FormatOptions , ''))

self.tc_ColumnSeparator.SetValue(ColumnSeparatorStr)

# Show Hidden

ShowHidden = str(DB.HandleOption('ShowHidden', FormatOptions, ''))

ShowHiddenStr = DB.Iif(ShowHidden == '','',DB.Iif(ShowHidden,'Yes','No'))

self.cc_ShowHidden.GetTextCtrl().SetValue(ShowHiddenStr)

# Column Selections

ColumnList = DB.HandleOption('ColumnFilter', FormatOptions, [])

# first delete all items to allow rebuilding the list

self.lc_SelectedColumns.DeleteAllItems()

# add to column list

for Item in reversed(ColumnList):

# each item is of the following format

#Item = (ColumnText,CalculationMethod,ColumnTitle)

self.lc_SelectedColumns.AddItem(Item, 0, False)

# Stratification table

StratificationTableStr = str(DB.HandleOption('StratifyBy', FormatOptions, ''))

self.tc_StratificationTable.SetValue(StratificationTableStr)

return

def RegenerateHandler(self):

" Regenerates the Report Text according to the new options"

# Extract report options

FormatOptions = self.ExtractReportOptions()

if FormatOptions != None:

# Actually display the text

ReportGenerationSuccess = self.DisplayText(FormatOptions)

if ReportGenerationSuccess:

# change the pane to see the text

self.NoteBook.ChangeSelection(0)

return

def FrameEventHandler(self, evt):

"The frame handling routine"

# if current event is close window, call CloseForm function

evtType = evt.GetEventType()

evtId = evt.GetId()

if evtType == wx.wxEVT_CLOSE_WINDOW:

cdml.CloseForm(self,False)

return

elif evtType == wx.wxEVT_COMMAND_BUTTON_CLICKED:

if evtId == wx.ID_ADD:

self.AddColumnHandler()

if evtId == wx.ID_DELETE:

self.DelColumnHandler()

if evtId == wx.ID_APPLY:

self.RegenerateHandler()

if evtId == cdml.IDP_BUTTON1:

self.LoadReportOptions()

if evtId == cdml.IDP_BUTTON2:

self.SaveReportOptions()

return

def GetReportOptionsFileName(self, style_part):

""" Open file selection window and get a report name"""

NewPath = None

wildcard = "Options file (*.opt)|*.opt|All files (*.*)|*.*"

dlg = wx.FileDialog(

self, message="Choose a file for report options",

defaultDir=os.getcwd(),

defaultFile='RepOpt.opt',

wildcard=wildcard,

style= style_part)

if dlg.ShowModal() == wx.ID_OK:

NewPath = str(dlg.GetPath())

return NewPath

def SaveReportOptions(self):

""" Save report options to file"""

FormatOptions = self.ExtractReportOptions()

if FormatOptions != None:

# filter out the KeyFilter options since it is internal to the system

# and should not be loaded or saved

FormatOptionModified = DB.HandleOption('KeyFilter', FormatOptions, Value = None, UseNewValue = False, DeleteThisOption = True)

if FormatOptionModified == None:

# if KeyFilter did not exist, then use the original OptionList

FormatOptionModified = FormatOptions

# get path name

path = self.GetReportOptionsFileName(wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)

if path != None:

try:

DB.SaveOptionList(path,FormatOptionModified)

except:

cdml.dlgErrorMsg(Parent = self)

return

def LoadReportOptions(self):

""" Load report options from file"""

path = self.GetReportOptionsFileName(wx.FD_OPEN)

if path != None:

try:

BackupFormatOptions = copy.deepcopy(self.FormatOptions)

FormatOptions = DB.LoadOptionList(path)

KeyFilterOptionValue = DB.HandleOption('KeyFilter', self.FormatOptions, Value = None, UseNewValue = False, DeleteThisOption = False)

if KeyFilterOptionValue != None:

DB.HandleOption('KeyFilter', FormatOptions, Value = KeyFilterOptionValue, UseNewValue = True, DeleteThisOption = False)

# now load the data to the controls to reflect the newly loaded data

# note that not validity checks are made, so if the file loaded

# properly and had bad data this may be reflected as bad text in

# the control or even raise an error that can be caught. Since this

# is not disruptive to data stored in the system no additional

# checks are made beyond what the system will allow in the controls

self.PopulateOptionsOnScreen(FormatOptions)

# now after data was updated update self with the new options

self.FormatOptions = FormatOptions

# Everything went fine - no need for backup anymore

BackupFormatOptions = None

except:

cdml.dlgErrorMsg(Parent = self)

if BackupFormatOptions != None:

try:

# in case of a bad file or an error, restore blank values

self.PopulateOptionsOnScreen(BackupFormatOptions)

except:

answer = cdml.dlgErrorMsg(msg_prefix='ASSERTION ERROR: Unable to recover from Error. Here are additional details: ',yesno=True, Parent = self)

if answer == wx.ID_YES :

return

else:

cdml.CloseForm(self, False)

return

def OnMenuSelected(self, event):

""" Handles Menu selection """

MenuID = event.GetId()

if MenuID in [ wx.ID_SAVE, wx.ID_SAVEAS ]: # save or save as menu

self.SaveReport(MenuID)

else:

cdml.OnMenuSelected (self, event)

def SaveReport(self, menuId=wx.ID_SAVE):

""" Save current report"""

if '*' in self.Path or menuId == wx.ID_SAVEAS:

NewPath = self.GetReportFileName()

if NewPath == None:

return False

else:

self.Path = NewPath # replace previous path with current path

try:

OutputFileName = open(self.Path,'w')

OutputFileName.write(self.ReportText)

OutputFileName.close()

except:

msg = 'Could not complete saving into the selected file, check if the file is not in use or otherwise locked'

cdml.dlgSimpleMsg('ERROR', msg, wx.OK, wx.ICON_ERROR, Parent = self)

return False

return True

def GetReportFileName(self):

""" Open file selection window and get a report name"""

NewPath = None

wildcard = "Text file (*.txt)|*.txt|All files (*.*)|*.*"

[Head,Tail]=os.path.split(self.Path)

dlg = wx.FileDialog(

self, message="Choose a file name to save the report",

defaultDir=Head,

defaultFile=Tail,

wildcard=wildcard,

style= wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)

if dlg.ShowModal() == wx.ID_OK:

NewPath = str(dlg.GetPath())

return NewPath

def DisplayText(self, FormatOptions=None):

""" displays the text """

if FormatOptions==None:

FormatOptions = self.FormatOptions

TheProgressDialog = None

try:

# version 2.5 does not support canceling simulation

TheProgressDialog = cdml.ProgressDialogTimeElapsed(Parent = self, StartTimerUponCreation = False, AllowCancel = DB.SystemSupportsProcesses)

# Define the Function to run on a thread

def ReportGenerationStartMiniScript():

"Generate the report and copy the text"

# Define an encapsulating function so no arguments will be needed

def FunctionToRunAsProcess():

ReturnVal = self.ReportObject.GenerateReport(FormatOptions)

return ReturnVal

# Now run this function as a process - if possible

(ProcessList, PipeList)=DB.RunFunctionAsProcess(FunctionToRunAsProcess)

return (ProcessList, PipeList)

def ReportGenerationEndMiniScript(ProcessList, PipeList):

"Copy the text"

ReturnVal = PipeList[0].recv()

return ReturnVal

ThreadObject = cdml.WorkerThread(ReportGenerationStartMiniScript,ReportGenerationEndMiniScript)

# Tell the dialog box what to do when cancel is pressed

TheProgressDialog.FunctionToRunUponCancel = ThreadObject.StopProcess

# Now start the timer for the progress dialog box

TheProgressDialog.StartTimer()

# wait until thread/process exits

Info = ThreadObject.WaitForJob()

# Cancel through the dialog box is no longer possible

TheProgressDialog.FunctionToRunUponCancel = None

# Properly destroy the dialog

WasCanceled = TheProgressDialog.WasCanceled

TheProgressDialog.Destroy()

TheProgressDialog = None

if WasCanceled:

self.ReportText = 'The report generation operation was canceled by user request!'

else:

self.ReportText = Info

except:

(ExceptType, ExceptValue, ExceptTraceback) = sys.exc_info()

self.ReportText = 'Report Generation Error : The report could not be generated due to an error during generation. Here are Additional Details: '+ str(ExceptValue)

# Properly destroy the progress dialog box if not done before

if TheProgressDialog != None:

TheProgressDialog.Destroy()

# Clear previous text

self.tc_ReportDisplay.SetReadOnly(False)

self.tc_ReportDisplay.ClearAll()

# Actually display the text

self.tc_ReportDisplay.AddText(str(self.ReportText))

self.tc_ReportDisplay.SetReadOnly(True)

# Calculate the horizontal scroll width. Default is the number reported

# by the system that should be 2000 pixels

MaxPixelWidth = self.tc_ReportDisplay.GetScrollWidth()

# Split the text lines to allow counting their length

TextLines = self.ReportText.split('\n')

for TextLine in TextLines:

PixelLineWidth = self.tc_ReportDisplay.TextWidth(stc.STC_STYLE_DEFAULT,TextLine)

MaxPixelWidth = max(MaxPixelWidth,PixelLineWidth)

self.tc_ReportDisplay.SetScrollWidth(MaxPixelWidth)

self.tc_ReportDisplay.ScrollToLine(0)

self.tc_ReportDisplay.ScrollToColumn(0)