def tsGetStdioPositionAndSize(self): ''' Return position and size of window used for redirected output. ''' if not self.ts_PyOnDemandStdioWindow: # Establish defaults until attributes finalized theRedirectedPos = wxPoint(-1, -1) theRedirectedSize = wxSize(450, 300) else: try: self.Display = wxDisplay(self) theClientArea = self.Display.theRedirectedStdioArea theRedirectedSize = wxSize(theClientArea.width, theClientArea.height) theRedirectedPos = wxPoint( theClientArea.x, theClientArea.y) except Exception, getError: theRedirectedPos = wxPoint(-1, -1) theRedirectedSize = wxSize(450, 300) self.logger.debug( ' GetStdioPositionAndSize Exception. %s' % getError) msg = 'GetStdioPositionAndSize Exception: %s' % str(getError) raise tse.ProgramException(tse.APPLICATION_TRAP, msg)
def tsBestSize(self): ''' ''' borderThickness = self.tsIsBorderThickness( style=self.ts_Style, pixels=True) gaugeThickness = 1 gaugeLength = 10 if self.ts_Style & wx.SB_VERTICAL: # Vertical best = wxSize( (gaugeThickness * wx.pixelWidthPerCharacter + \ 2 * borderThickness.width), (gaugeLength * wx.pixelHeightPerCharacter + \ 2 * borderThickness.height)) else: # Horizontal best = wxSize( (gaugeLength * wx.pixelWidthPerCharacter + \ 2 * borderThickness.width), (gaugeThickness * wx.pixelHeightPerCharacter + \ 2 * borderThickness.height)) return (best)
def tsGetBorderCharacterDimensions(self, thickness): ''' Return width and height of border character in pixels. Parameter: thickness --- Border line thickness in pixels. ''' if thickness == -1: if wx.USE_BORDER_BY_DEFAULT: # Default (1-pixel) border required. dimensions = wxSize(wx.pixelWidthPerCharacter, wx.pixelHeightPerCharacter) else: # No border required. dimensions = wxSize(0, 0) elif thickness == 0: # No border required. dimensions = wxSize(0, 0) else: # Override thickness and apply default (1-pixel) border. dimensions = wxSize(min(1, thickness) * wx.pixelWidthPerCharacter, min(1, thickness) * wx.pixelHeightPerCharacter) return (dimensions)
def SetItemBounds(self, item, x, y, w, h): ''' Modeled after TBD in sizer.cpp file of wxWidgets. ''' pt = wxPoint(x, y) sz = wxSize(item.GetMinSizeWithBorder()) flag = int(item.GetFlag()) if flag & wx.EXPAND or \ flag & wx.SHAPED: sz = wxSize(w, h) else: if flag & wx.ALIGN_CENTER_HORIZONTAL: pt.x = x + (w - sz.x) // 2 elif flag & wx.ALIGN_RIGHT: pt.x = x + (w - sz.x) if flag & wx.ALIGN_CENTER_VERTICAL: pt.y = y + (h - sz.y) // 2 elif flag & wx.ALIGN_BOTTOM: pt.y = y + (h - sz.y) item.SetDimension(pt, sz)
def SizeFromMajorMinor(self, major, minor): ''' ''' if self.ts_Orientation == wx.HORIZONTAL: return (wxSize(major, minor)) else: # wxVERTICAL return (wxSize(minor, major))
def AddSpacer(self, size): ''' ''' if self.IsVertical(): item = wxSize(0, size) else: item = wxSize(size, 0) child = self.Add(item, proportion=0, flag=0, border=0, userData=None) # Register the child in the wxSizerItemList self.ts_Children.Add(child) return (child)
def SetWindow(self, window): ''' Set the window to be managed by this sizer item. Modeled after SetWindow in sizer.h file of wxWidgets. ''' self.logger.wxASSERT_MSG( (window is not None), 'SetWindow cannot have window be %s.' % str(window)) self.ts_Kind = wx.Item_Window self.ts_Window = window # window doesn't become smaller than its initial size, whatever happens if True: self.ts_MinSize = window.Size else: if window.Size is None: # TBD - What should size be when curses handle not yet created. self.ts_MinSize = wxSize(10 * wx.pixelWidthPerCharacter, 3 * wx.pixelHeightPerCharacter) else: self.ts_MinSize = window.Size ## print('tsWxSizerItem.SetWindow: MinSize=%s' % self.ts_MinSize) if self.ts_Flag & wx.FIXED_MINSIZE: window.SetMinSize(self.ts_MinSize) # aspect ratio calculated from initial size self.SetRatioSize(self.ts_MinSize)
def tsGetClientArea(self, pixels=True): ''' Returns the bounding rectangle the client area of the Frame, i.e., without menu bars, tool bars, status bars and such. ''' parent = self.ts_Parent pos = wxPoint(self.ts_Rect.x, self.ts_Rect.y) size = wxSize(self.ts_Rect.width, self.ts_Rect.height) style = self.ts_Style name = self.ts_Name (myRect, myClientRect) = self.tsFrameWindowLayout( parent, pos, size, style, name) if self.ts_Rect != myRect: # My Area changed after by new feature fmt1 = 'Wrong layout. myRect (%s) ' % str(myRect) fmt2 = 'changed from self.ts_Rect (%s) ' % str(self.ts_Rect) fmt3 = 'in tsWxFrame.tsGetClientArea' msg = fmt1 + fmt2 + fmt3 self.logger.wxASSERT_MSG( (self.ts_Rect == myRect), msg) self.ts_Rect = myRect if self.ts_ClientRect != myClientRect: # Client Area changed after by new feature self.ts_ClientRect = myClientRect return (self.ts_ClientRect)
def ShowFullScreen(self, show, style): ''' ''' # TBD - Under Construction. # Extent resize of the top level window to include its children. theDisplay = self.Display theDisplayPos = wxPoint(theDisplay.ClientArea.x, theDisplay.ClientArea.y) theDisplaySize = wxSize(theDisplay.ClientArea.width, theDisplay.ClientArea.height) self.logger.debug( ' ShowFullScreen (screen): pos=%s; size=%s.' % ( str(theDisplayPos), str(theDisplaySize))) self.Rect = wxRect(theDisplayPos.x, theDisplayPos.y, theDisplaySize.width, theDisplaySize.height) self.logger.debug( ' Need Event to ShowFullScreen (rect): %s.' % ( str(self.Rect))) return (show)
def __init__(self, orient=wx.HORIZONTAL): ''' Constructor for a wx.BoxSizer. orient may be one of wx.VERTICAL or wx.HORIZONTAL for creating either a column sizer or a row sizer. ''' theClass = 'BoxSizer' wx.RegisterFirstCallerClassName(self, theClass) Sizer.__init__(self) self.tsBeginClassRegistration(theClass, id) # either wxHORIZONTAL or wxVERTICAL self.ts_Orientation = orient # the sum of proportion of all of our elements self.ts_TotalProportion = 0 # minimal size needed for this sizer as calculated by # the last call to our CalcMin() self.ts_MinSize = DEFAULT_SIZE # minimal size needed for this sizer as calculated, by # calcMin, for the containing window (panel), the parent # of those subpanels managed by this BoxSizer instance. self.ts_CalcMinArea = [] self.ts_CalcMinAreaProportion = [] self.ts_CalcMinKind = [] self.ts_CalcMinWindow = [] self.ts_ClientArea = [] self.ts_ContainingWindow = None self.ts_MinSize = wxSize(0, 0) self.ts_SizeMinThis = [] self.ts_TotalFixedSize = wxSize(0, 0) self.ts_TotalProportion = 0 ## self.ts_SizeMinThis = None ## self.ts_CalcMinArea = None ## self.ts_CalcMinAreaProportion = None ## self.ts_CalcMinKind = None ## self.ts_CalcMinWindow = None ## self.ts_ClientArea = None ## self.ts_ContainingWindow = None self.ts_RecalcArea = None self.tsEndClassRegistration(theClass)
def SetMinSizeXY(self, x, y): ''' Modeled after SetMinSize in sizer.h file of wxWidgets. ''' size = wxSize(x, y) if (self.IsWindow()): self.ts_Window.SetMinSize(size) else: self.ts_MinSize = size
def CalcMin(self): ''' Calculate the total minimum width and height needed by all items in the sizer according to this sizer layout algorithm. This method is abstract and has to be overwritten by any derived class. Here, the sizer will do the actual calculation of its childrens minimal sizes. Implemented in wxGridBagSizer, and wxBoxSizer. ''' width = 0 height = 0 for i in range(0, self.ts_Children.GetCount()): node = self.ts_Children.GetIndex(i) item = node.GetUserData() size = wxSize(0, 0) if (isinstance(self, Window)): try: parent = self.ts_Parent theClientRect = parent.ClientArea except AttributeError: parent = None theClientRect = wxRect(0, 0, 0, 0) width = theClientRect.width height = theClientRect.height minSize = wxSize(width, height) self.logger.debug( 'CalcMin: item=%s; minSize=%s; width=%s; height=%s' % ( str(item), str(minSize), str(width), str(height))) size = minSize self.logger.debug('CalcMin: size=%s' % size) return (size)
def tsBestSize(self): ''' ''' borderThickness = self.tsIsBorderThickness( style=self.ts_Style, pixels=True) maxWidth = 0 maxHeight = 0 for choice in self.ts_Choices: buttonText = self.tsStripAcceleratorTextLabel(choice) if len(buttonText) > maxWidth: maxWidth = len(buttonText) maxHeight += 1 if self.ts_Style & wx.RA_VERTICAL: # Vertical best = wxSize( (maxWidth * wx.pixelWidthPerCharacter + \ 2 * borderThickness.width), (maxHeight * wx.pixelHeightPerCharacter + \ 2 * borderThickness.height)) elif self.ts_Style & wx.RA_HORIZONTAL: # Horizontal best = wxSize( (maxWidth * wx.pixelWidthPerCharacter + \ 2 * borderThickness.width), (maxHeight * wx.pixelHeightPerCharacter + \ 2 * borderThickness.height)) else: # TBD - Should this be allowed? best = wxSize( (maxWidth * wx.pixelWidthPerCharacter + \ 2 * borderThickness.width), (maxHeight * wx.pixelHeightPerCharacter + \ 2 * borderThickness.height)) return (best)
def tsShow(self): ''' Shows or hides the window. You may need to call Raise for a top level window if you want to bring it to top, although this is not needed if Show is called immediately after the frame creation. Returns True if the window has been shown or hidden or False if nothing was done because it already was in the requested state. ''' if self.tsIsShowPermitted: if self.ts_Handle is None: myRect = wxRect( self.ts_Parent.Rect.Left, (self.ts_Parent.Rect.Bottom - \ wx.ThemeToUse['StatusBar']['WindowHeight'] - \ wx.pixelHeightPerCharacter), self.ts_Parent.Rect.width, wx.ThemeToUse['StatusBar']['WindowHeight']) thePosition = wxPoint(myRect.x, myRect.y) theSize = wxSize(myRect.width, myRect.height) # TBD - Update Class geometry. self.ts_Rect = myRect self.logger.debug( 'tsShow: myRect=%s; Rect = %s' % (myRect, self.ts_Rect)) self.ts_BaseRect = self.ts_Rect if DEBUG: print('tsShow: myRect=%s; Rect = %s' % (myRect, self.ts_Rect)) self.Create(self, id=-1, pos=thePosition, size=theSize, style=self.ts_Style, name=self.Name, pixels=True) try: self.tsRegisterShowOrder() except Exception, e: self.logger.error('%s; %s' % (__title__, e)) self.tsUpdate()
def GetDefaultSize(self): ''' Returns the default button size for this platform. ''' thickness = self.tsIsBorderThickness( style=self.ts_Style, pixels=False) if False: width = (len(self.ts_ButtonText) + 1) * wx.pixelWidthPerCharacter height = (1) * wx.pixelHeightPerCharacter else: width = (thickness.width + \ len(self.ts_ButtonText) + 1) * wx.pixelWidthPerCharacter height = (thickness.height + 1) * wx.pixelHeightPerCharacter return (wxSize(width, height))
def SetItemBounds(self, item, x, y, w, h ): ''' ''' pt = wxPoint(x, y) sz = item.GetMinSizeWithBorder() flag = item.GetFlag() if ((flag & wx.EXPAND) or \ (flag & wx.SHAPED)): sz = wxSize(w, h) else: if (flag & wx.ALIGN_CENTER_HORIZONTAL): pt.x = x + (w - sz.width) / 2 elif (flag & wx.ALIGN_RIGHT): pt.x = x + (w - sz.width) if (flag & wx.ALIGN_CENTER_VERTICAL): pt.y = y + (h - sz.height) / 2 elif (flag & wx.ALIGN_BOTTOM): pt.y = y + (h - sz.height) msg = 'GridSizer.SetItemBounds: ' + \ 'item (%s); pt (%s); sz (%s)' % ( str(item), str(pt), str(sz)) if DEBUG: print(msg) self.logger.debug(msg) ## item.SetDimension(pt, sz) item.ts_Window.ts_Rect = wxRect(pt.x, pt.y, sz.width, sz.height)
def GetSize(self): ''' Get the current size of the item, as set in the last Layout. Modeled after GetSize in sizer.cpp file of wxWidgets. ''' if self.ts_Kind == wx.Item_None: ret = wxSize(0, 0) elif self.ts_Kind == wx.Item_Window: ret = self.ts_Window.GetSize() elif self.ts_Kind == wx.Item_Sizer: ret = self.ts_Sizer.GetSize() elif self.ts_Kind == wx.Item_Spacer: ret = self.ts_Spacer.GetSize() else: # elif self.ts_Kind == wx.Item_Max: self.logger.wxFAIL_MSG( 'Unexpected wxSizerItem.GetSize ts_Kind == wx.Item_Max.') border = self.tsGetBorderCharacterDimensions( thickness=self.ts_Border) if self.ts_Flag & wx.WEST: ret.x += border.width if self.ts_Flag & wx.EAST: ret.x += border.width if self.ts_Flag & wx.NORTH: ret.y += border.height if self.ts_Flag & wx.SOUTH: ret.y += border.height return (ret)
def CalcMin(self): ''' This method is where the sizer will do the actual calculation of its childrens minimal sizes. You should not need to call this directly as it is called by Layout Modeled after TBD in sizer.cpp file of wxWidgets. ''' width = 0 height = 0 for item in self.GetChildren(): # calculate the total minimum width and height needed # by all items in the sizer according to this sizer's # layout algorithm. minSize = item.MinSize width += minSize.width height += minSize.height size = wxSize(width, height) self.logger.debug('CalcMin: size=%s' % size) return (size)
def CreateOutputWindow(self, st): ''' Create frame and text control. Append st (text) to output. Show the frame and bind the frame OnCloseButtton to the event. ''' # TBD - Under Construction. The class wxTextCtrl is not available. if not (self.ts_Frame is None): return try: self.ts_Frame = wxFrame( self.ts_Parent, id=-1, title=self.ts_Title, pos=wxPoint(self.ts_Rect.x, self.ts_Rect.y), size=wxSize(self.ts_Rect.width, self.ts_Rect.height), style=self.ts_Style, name=self.ts_Name) except Exception, frameError: self.logger.error( ' CreateOutputWindow: frameError. %s' % frameError) msg = 'CreateOutputWindow Frame Error: %s' % str(frameError) raise tse.ProgramException(tse.APPLICATION_TRAP, msg)
def tsSetStdioWindowAttributes(self, title=None, pos=None, size=None, style=None, name=None): """ Set the title, position, size, style and name of the output window if the stdio has been redirected. """ if self.stdioWin: # TBD - Cannot set attributes when window does not exist. myRect = self.Display.theRedirectedStdioArea if title is not None: self.stdioWin.title = title else: self.stdioWin.title = wx.ThemeToUse["Stdio"]["Title"] if pos is not None: self.stdioWin.pos = pos else: self.stdioWin.pos = wxPoint(myRect.x, myRect.y) if size is not None: self.stdioWin.size = size else: self.stdioWin.size = wxSize(myRect.width, myRect.height) if style is not None: self.stdioWin.style = style elif wx.ThemeToUse["Stdio"]["Title"] == wx.StdioRedirectedTitleStr: self.stdioWin.style = wx.DEFAULT_STDIO_STYLE else: self.stdioWin.style = wx.DEFAULT_FRAME_STYLE if name is not None: self.stdioWin.name = name elif wx.ThemeToUse["Stdio"]["Title"] == wx.StdioRedirectedTitleStr: self.stdioWin.name = wx.StdioNameStr else: self.stdioWin.name = wx.FrameNameStr
def tsShow(self): ''' Create and update MenuBar specific native GUI. ''' if self.tsIsShowPermitted: if self.ts_Handle is None: myRect = wxRect( self.ts_Parent.Rect.x + wx.pixelWidthPerCharacter, self.ts_Parent.Rect.y + wx.pixelHeightPerCharacter, self.ts_Parent.Rect.width - 2* wx.pixelWidthPerCharacter, wx.ThemeToUse['MenuBar']['WindowHeight']) thePosition = wxPoint(myRect.x, myRect.y) theSize = wxSize(myRect.width, myRect.height) # TBD - Update Class geometry. ## self.ts_Rect = myRect ## self.logger.debug( ## '_show: myRect=%s; Rect = %s' % (myRect, self.ts_Rect)) self.Create(self, id=-1, pos=thePosition, size=theSize, style=self.ts_Style, name=self.Name, pixels=True) try: self.tsRegisterShowOrder() except Exception, e: self.logger.error('%s; %s' % (__title__, e)) self.tsUpdate()
def RecalcSizes(self): ''' Using the sizes calculated by CalcMin reposition and resize all the items managed by this sizer. You should not need to call this directly as it is called by Layout. Modeled after RecalcSizes in sizer.cpp file of wxWidgets. ''' nitems = self.CalcRowsCols() self.logger.debug( 'GridSizes.RecalcSizes: nitems=%d; Rows=%d; Cols=%d' % ( nitems, self.ts_Rows, self.ts_Cols)) if (nitems == 0): return # find the space allotted to this sizer if True: # Use CalcMin Output and Integer Arithmetic pt = self.GetPosition() sz = self.GetSize() w = (sz.width - ( (self.ts_Cols - 1) * self.ts_HGap)) / self.ts_Cols h = (sz.height - ( (self.ts_Rows - 1) * self.ts_VGap)) / self.ts_Rows else: # TBD - Use CalcMin Output and Floating Point Arithmetic pt = self.GetPosition() sz = self.GetSize() w = (sz.width - ( (self.ts_Cols - 1) * self.ts_HGap)) / self.ts_Cols h = (sz.height - ( (self.ts_Rows - 1) * self.ts_VGap)) / self.ts_Rows ## ptOrig = self.GetPosition() ## xOrig = ptOrig.x ## yOrig = ptOrig.y ## szOrig = self.GetSize() ## widthOrig = szOrig.width ## heightOrig = szOrig.height ## hGapOrig = self.ts_HGap ## vGapOrig = self.ts_VGap ## x = int(float(szOrig.x) + (float(wx.pixelWidthPerCharacter) / 2.0)) ## sz = wxSize(szOrig.x + ## pt = ptOrig ## w = (sz.width - ((self.ts_Cols - 1) * self.ts_HGap)) / self.ts_Cols ## h = (sz.height - ((self.ts_Rows - 1) * self.ts_VGap)) / self.ts_Rows y = pt.y for r in range(self.ts_Rows): x = pt.x for c in range(self.ts_Cols): i = (r * self.ts_Cols) + c if (i < nitems): node = self.ts_Children.indexedNodeList[i] self.logger.wxASSERT_MSG( (node is not None), 'GridSizer.RecalcSizes Failed to find node') if True: theItem = node.GetUserData() thePoint = wxPoint(x, y) theSize = wxSize(w, h) theItem.SetDimension(thePoint, theSize) theLabel = theItem.ts_Window.ts_Label if DEBUG: print( 'r=%d; c=%d; i=%d; pt=%s; sz=%s; label=%s' % ( r, c, i, str(thePoint), str(theSize), theLabel)) self.SetItemBounds(node.GetUserData(), x, y, w, h) x = x + w + self.ts_HGap y = y + h + self.ts_VGap
def CalcMin(self): ''' This method is where the sizer will do the actual calculation of its childrens minimal sizes. You should not need to call this directly as it is called by Layout Modeled after TBD in sizer.cpp file of wxWidgets. ''' nitems = self.CalcRowsCols() if DEBUG: print( 'GridSizes.CalcMin: nitems=%d; Rows=%d; Cols=%d' % ( nitems, self.ts_Rows, self.ts_Cols)) if (nitems == 0): return (wxSize(0, 0)) sizerClientArea = self.FindSizerClientArea() self.ts_Rect = sizerClientArea self.ts_Position = wxPoint(sizerClientArea.x, sizerClientArea.y) self.ts_Size = wxSize(sizerClientArea.width, sizerClientArea.height) if DEBUG: print( 'GridSizer.CalcMin: sizerClientArea=%s' % str(sizerClientArea)) sz = wxSize( ((sizerClientArea.width - ( (self.ts_Cols - 1) * self.ts_HGap)) / self.ts_Cols), ((sizerClientArea.height - ( (self.ts_Rows - 1) * self.ts_VGap)) / self.ts_Rows)) if DEBUG: print( 'GridSizer.CalcMin: sz=%s; sizerClientArea=%s' % ( str(sz), str(sizerClientArea))) # Find the max width and height for any component w = 0 h = 0 for i in range(0, self.ts_Children.GetCount()): node = self.ts_Children.GetIndex(i) item = node.GetUserData() if DEBUG: msg = 'GridSizer.CalcMin: item[%d]=%s' % (i, str(item)) print(msg) if (item.ts_Kind == wx.Item_Sizer): item.ts_Sizer.Layout() ## parent = item.ts_Window.ts_Parent ## clientArea = parent.ClientArea ## theRect = parent.Rect ## theClientArea = parent.ClientArea ## print('GridSizer.CalcMin: Rect=%s; ClientArea=%s' % ( ## str(theRect), ## str(theClientArea))) ## tempSize = item.CalcMin() ## sz = tempSize ## sz = wxSize((min(tempSize.width, ## ((self.ts_ContainingWindowClientArea.width / ## self.ts_Cols) - self.ts_Hgap))), ## (min(tempSize.width, ## ((self.ts_ContainingWindowClientArea.height / ## self.ts_Rows) - self.ts_Vgap)))) w = wx.Max( w, sz.x ) h = wx.Max( h, sz.y ) # In case we have a nested sizer with a two step algo , give it # a chance to adjust to that (we give it width component) didChangeMinSize = False for i in range(0, self.ts_Children.GetCount()): node = self.ts_Children.GetIndex(i) item = node.GetUserData() didChangeMinSize |= item.InformFirstDirection( wx.HORIZONTAL, w, -1 ) # And redo iteration in case min size changed if(didChangeMinSize): w = h = 0 for i in range(0, self.ts_Children.GetCount()): node = self.ts_Children.GetIndex(i) item = node.GetUserData() sz = item.GetMinSizeWithBorder() w = wx.Max( w, sz.x ) h = wx.Max( h, sz.y ) return (wxSize(self.ts_Cols * w + (self.ts_Cols-1) * self.ts_HGap, self.ts_Rows * h + (self.ts_Rows-1) * self.ts_VGap))
from tsWxGTUI_Py2x.tsLibGUI.tsWxSizer import Sizer from tsWxGTUI_Py2x.tsLibGUI.tsWxSizerItem import SizerItem as wxSizerItem #--------------------------------------------------------------------------- ##DEBUG = True DEBUG = wx.Debug_GUI_Launch | \ wx.Debug_GUI_Progress | \ wx.Debug_GUI_Termination | \ wx.Debug_GUI_Exceptions ##VERBOSE = True VERBOSE = wx.Debug_GUI_Configuration DEFAULT_POS = wxPoint(wx.DefaultPosition) DEFAULT_SIZE = wxSize(wx.DefaultSize) #--------------------------------------------------------------------------- class GridSizer(Sizer): ''' A grid sizer is a sizer which lays out its children in a two-dimensional table with all cells having the same size. In other words, the width of each cell within the grid is the width of the widest item added to the sizer and the height of each grid cell is the height of the tallest item. An optional vertical and/or horizontal gap between items can also be specified (in pixels.) Items are placed in the cells of the grid in the order they are added, in row-major order. In other words, the first row is filled first, then the second, and so on until all items have been added. (If neccessary,
def __init__(self, parent, id=wx.ID_ANY, label=wx.EmptyString, pos=wx.DefaultPosition, size=wx.DefaultSize, choices=wx.PyEmptyStringArray, majorDimension=0, style=wx.RA_HORIZONTAL, validator=wx.DefaultValidator, name=wx.RadioBoxNameStr): ''' Create a Control. Normally you should only call this from a subclass __init__ as a plain old wx.Control is not very useful. ''' # Also, remember that wx.RA_SPECIFY_COLS means that we arrange buttons # in left to right order and GetMajorDim() is the number of columns # while wx.RA_SPECIFY_ROWS means that the buttons are arranged top to # bottom and GetMajorDim() is the number of rows. theClass = 'RadioBox' # Capture initial caller parametsrs before they are changed self.caller_parent = parent self.caller_id = id self.caller_label = label self.caller_pos = pos self.caller_size = size self.caller_choices = choices self.caller_majorDimension = majorDimension self.caller_style = style self.caller_validator = validator self.caller_name = name wx.RegisterFirstCallerClassName(self, theClass) Control.__init__(self, parent, id=id, pos=pos, size=size, style=style, validator=validator, name=name) self.tsBeginClassRegistration(theClass, id) if DEBUG: self.logger.debug(' self: %s' % self) self.logger.debug(' parent: %s' % parent) self.logger.debug(' id: %s' % self.ts_Id) self.logger.debug(' AssignedId: %s' % self.ts_AssignedId) self.logger.debug(' label: %s' % label) self.logger.debug(' pos: %s' % str(pos)) self.logger.debug(' size: %s' % str(size)) self.logger.debug(' choices: %s' % choices) self.logger.debug(' majorDimension: %s' % majorDimension) self.logger.debug(' style: 0x%X' % style) # self.logger.debug(' validator: 0x%X' % validator) self.logger.debug(' name: %s' % name) self.ts_Default = False self.ts_Name = name self.ts_Parent = parent theTopLevelClass = self self.SetTopLevelAncestor(theTopLevelClass) if parent is None: self.ts_GrandParent = None else: self.ts_GrandParent = parent.Parent if False: # Leaves artifacts of different color than parent background. self.ts_BackgroundColour = wx.ThemeToUse[ 'BackgroundColour'].lower() self.ts_ForegroundColour = wx.ThemeToUse[ 'ForegroundColour'].lower() else: self.ts_BackgroundColour = self.Parent.ts_BackgroundColour self.ts_ForegroundColour = self.Parent.ts_ForegroundColour self.ts_Choices = choices self.ts_Count = len(choices) self.ts_Label = label self.ts_MajorDimension = max(majorDimension, self.ts_Count) self.ts_Style = style self.ts_Validator = validator myRect, myClientRect = self.tsRadioBoxLayout( parent, pos, size, style, name) self.ts_Rect = myRect self.ts_ClientRect = myClientRect bestSize = self.tsBestSize() ## style = 0 self.ts_ItemLabel = [] self.ts_ItemEnabled = [] self.ts_ItemHelpText = [] self.ts_ItemToolTip = [] self.ts_ItemShown = [] self.ts_ItemWindow = [] # TBD - Verify scaling. if self.ts_Style & wx.RA_HORIZONTAL: itemWidth = bestSize.width // (self.ts_MajorDimension + 1) else: itemWidth = bestSize.width for item in range(self.ts_Count): self.ts_ItemLabel.append(self.ts_Choices[item]) self.ts_ItemHelpText.append(self.ts_ItemLabel[item]) self.ts_ItemToolTip.append(self.ts_ItemLabel[item]) self.ts_ItemShown.append(True) if item == 0: self.ts_ItemEnabled.append(True) else: self.ts_ItemEnabled.append(False) # TBD - Under Construction. if self.ts_Style & wx.RA_HORIZONTAL: # Horizontal layout posTBD = wxPoint( self.Rect.x + (item * itemWidth + 2) * wx.pixelWidthPerCharacter, self.Rect.y + (2) * wx.pixelHeightPerCharacter) else: # Vertical layout posTBD = wxPoint( self.Rect.x + (2) * wx.pixelWidthPerCharacter, self.Rect.y + (item + 2) * wx.pixelHeightPerCharacter) ## sizeTBD = wxSize( ## (len('(*) ') + len( ## self.ts_ItemLabel[item])) * wx.pixelWidthPerCharacter, ## wx.pixelHeightPerCharacter) sizeTBD = wxSize( (len('(*) ') + len(self.tsStripAcceleratorTextLabel( self.ts_ItemLabel[item]))) * wx.pixelWidthPerCharacter, wx.pixelHeightPerCharacter) self.ts_ItemWindow.append(wxRadioButton( self, id=wx.ID_ANY, label=self.ts_ItemLabel[item], pos=posTBD, size=sizeTBD, style=(self.ts_Style & wx.ALIGN_LEFT | \ self.ts_Style & wx.ALIGN_RIGHT | \ wx.NO_BORDER), validator=wx.DefaultValidator, name=self.ts_ItemLabel[item])) self.ts_ItemWindow[item].SetValue(self.ts_ItemEnabled[item]) if self.ts_Style & wx.RA_HORIZONTAL: self.ts_ColumnCount = self.ts_MajorDimension self.ts_RowCount = 1 elif self.ts_Style & wx.RA_VERTICAL: self.ts_ColumnCount = 1 self.ts_RowCount = self.ts_MajorDimension else: # TBD - Temporary dimension self.ts_ColumnCount = self.ts_MajorDimension rows, cols = divmod(self.ts_Count, self.ts_MajorDimension) if cols == 0: self.ts_RowCount = rows else: self.ts_RowCount = rows + 1 self.ts_Selection = 0 self.ts_StringSelection = 0 # Automatically Bind all mouse events ASAP (now). # Will register event in the SystemEventTable. event = EVT_COMMAND_LEFT_CLICK handler = self.tsOnLeftClick source = self self.Bind(event, handler, source, useSystemEventTable=True) # Automatically Bind all Radio Button events ASAP (now). # Will register event in the SystemEventTable. event = EVT_RADIOBUTTON handler = self.tsOnRadioButtonClick source = self self.Bind(event, handler, source, useSystemEventTable=True) self.tsEndClassRegistration(theClass)
def tsButtonLayout(self, parent, pos, size, style, name): ''' Calculate position and size of button based upon arguments. ''' if (not (self.ts_Handle is None)): # Inhibit operation once self.ts_Handle has been # assigned a curses window identifier. return (self.ts_Rect, self.ts_ClientRect) if style is None: # Prevent pylint warning. pass thePosition = self.tsGetClassInstanceFromTuple(pos, wxPoint) theSize = self.tsGetClassInstanceFromTuple(size, wxSize) theDefaultPosition = self.tsGetClassInstanceFromTuple( wx.DefaultPosition, wxPoint) theDefaultSize = self.tsGetClassInstanceFromTuple( wx.DefaultSize, wxSize) label = self.ts_ButtonText # Ignore UseClientArea because cursor wraps beyond bottom # when last character has been output. if self.ts_UseClientArea: offset = wxPoint(0, 0) else: offset = wxPoint(0, 0) if theSize == theDefaultSize: # theDefaultSize theLabelSize = theSize self.logger.debug( ' theLabelSize (begin): %s' % theLabelSize) if label is wx.EmptyString: # TBD - Adjust for cursor width theLabelSize = wxSize( (len(label) + len('[]')) * wx.pixelWidthPerCharacter, wx.pixelHeightPerCharacter) elif label.find('\n') == -1: # TBD - Remove adjustment for extra cursor width theLabelSize = wxSize( (len(label) + len('[ ]')) * wx.pixelWidthPerCharacter, wx.pixelHeightPerCharacter) else: # TBD - Remove adjustment for extra cursor width theLines = label.split('\n') maxWidth = 0 maxHeight = len(theLines) for aLine in theLines: if len(aLine) > maxWidth: maxWidth = len(aLine) theLabelSize = wxSize( (maxWidth + len('[ ]')) * wx.pixelWidthPerCharacter, maxHeight * wx.pixelHeightPerCharacter) self.logger.debug( ' theLabelSize (end): %s' % theLabelSize) if thePosition == theDefaultPosition: # theDefaultPosition myRect = wxRect(parent.ClientArea.x, parent.ClientArea.y, theLabelSize.width, theLabelSize.height) else: # Not theDefaultPosition myRect = wxRect(offset.x + thePosition.x, offset.y + thePosition.y, theLabelSize.width, theLabelSize.height) else: # Not theDefaultSize if thePosition == theDefaultPosition: # theDefaultPosition myRect = wxRect(parent.ClientArea.x, parent.ClientArea.y, theSize.width, theSize.height) else: # Not theDefaultPosition myRect = wxRect(offset.x + thePosition.x, offset.y + thePosition.y, theSize.width, theSize.height) ## theDisplayRect = self.Display.GetClientArea() ## if not theDisplayRect.InsideRect(myRect): ## myRect = wxRect( ## max(thePosition.x, theDisplayRect.x), ## max(thePosition.y, theDisplayRect.y), ## min(theSize.width, theDisplayRect.width), ## min(theSize.height, theDisplayRect.height - 1)) ## if not theDisplayRect.InsideRect(myRect): ## myRect = theDisplayRect myClientRect = wxRect(myRect.x, myRect.y, myRect.width, myRect.height) self.tsTrapIfTooSmall(name, myRect) fmt = 'parent=%s; pos=%s; size=%s; ' + \ 'name="%s"; label="%s"; myRect=%s' msg = fmt % (parent, str(pos), str(size), name, label, str(myRect)) self.logger.debug(' tsButtonLayout: %s' % msg) return (myRect, myClientRect)
def __init__( self, parent, id=wx.ID_ANY, bitmap=None, splashStyle=0, milliseconds=0, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_SPLASHSCREEN_STYLE, ): """ Construct class. """ theClass = "SplashScreen" # Capture initial caller parametsrs before they are changed self.caller_bitmap = bitmap self.caller_splashStyle = splashStyle self.caller_milliseconds = milliseconds self.caller_parent = parent self.caller_id = id self.caller_pos = pos self.caller_size = size self.caller_style = style wx.RegisterFirstCallerClassName(self, theClass) TopLevelWindow.__init__(self) self.tsBeginClassRegistration(theClass, id) ## size = wxSize(500, 300) Frame.__init__( self, parent, id=wx.ID_ANY, title=wx.EmptyString, pos=pos, size=size, style=wx.BORDER_SIMPLE, # wx.DEFAULT_SPLASHSCREEN_STYLE, name=wx.SplashScreenNameStr, ) splashWindow = self splashWindow.ts_ForegroundColour = wx.COLOR_RED splashWindow.ts_BackgroundColour = wx.COLOR_WHITE self.ts_SplashStyle = splashStyle self.ts_SplashWindow = splashWindow self.ts_SplashTimeout = milliseconds self.ts_bitmap = wxTextCtrl( splashWindow, id=-1, value=wx.EmptyString, pos=wxPoint( splashWindow.ts_ClientRect.x + wx.pixelWidthPerCharacter, splashWindow.ts_ClientRect.y + wx.pixelHeightPerCharacter, ), size=wxSize( splashWindow.ts_ClientRect.width - (2 * wx.pixelWidthPerCharacter), splashWindow.ts_ClientRect.height - (2 * wx.pixelHeightPerCharacter), ), style=0, # wx.TE_MULTILINE |wx.TE_READONLY, validator=wx.DefaultValidator, name=wx.TextCtrlNameStr, ) self.ts_bitmap.AppendText(bitmap) self.ts_bitmap.Show() self.SetFocus() ## print('SplashScreen: Show') ## self.Show() ## print('SplashScreen: Sleep(%d)' % self.ts_SplashTimeout) ## time.sleep(self.ts_SplashTimeout / 1000) ## print('SplashScreen: Hide') ## self.Hide() self.tsEndClassRegistration(theClass)
def tsGetRedirectedStdioArea(self, pixels=True): ''' Return rectangle position and size of window used for redirected output from print, stdout and stderr. NOTE: Area includes top, bottom, left and right borders. It must support at least one message. Messages may optionally include a timestamp. The assumed length of a typical message, without its timestamp, but with the left and right borders, is 80 characters. The minimum height must therefore provide sufficient lines to display the full message and its timestamp. ''' ############################################################### # X=0 1 2 3 X=W-1 # 01234567890123456789012345678901234 # Y=0 +---------------------------------+ Frame Border Top # 1 |Client Area | # 2 | (ex. 35 cols x 6 rows) | # 3 | | # 4 | | # 5 +---------------------------------+ Frame Border Bottom # H-9 +---------------------------------+ Stdio Border Top # H-8 |Stdio Output (Optionl) | # H-7 | (ex. 35 cols x 5 rows) | # H-6 | | # H-5 +---------------------------------+ Stdio Border Bottom # H-4 +---------------------------------+ Task Border Top # H-3 |Task Bar Output (Optional) | # H-2 | (ex. 35 cols x 4 rows) | # Y=H-1 +---------------------------------+ Task Border Bottom ############################################################### if Display.EnableRedirectArea: theTotalArea = self.GetGeometry(pixels=False) borderRows = 2 # borderCols = 2 if wx.ThemeToUse['Stdio']['Timestamp']: minLineWidth = wx.pageWidth + len('2008/07/04 05:44:52.486 -') else: minLineWidth = wx.pageWidth (minDisplayPixelWidth, minDisplayPixelHeight) = \ wx.RedirectedWindowHeight['minDisplay'] (minDisplayWidth, minDisplayHeight) = ( minDisplayPixelWidth // wx.pixelWidthPerCharacter, minDisplayPixelHeight // wx.pixelHeightPerCharacter) minHeightPercent = int( wx.RedirectedWindowHeight['minHeightPercent']) maxHeightPercent = int( wx.RedirectedWindowHeight['maxHeightPercent']) maxRedirectedWidth = theTotalArea.width theTaskArea = self.tsGetTaskArea(pixels=False) # thePosition = wxPoint(theTotalArea.x, theTotalArea.y) theSize = wxSize(theTotalArea.width, theTotalArea.height) theRedirectedAreaOffset = - 1 if theSize.width < minDisplayWidth: if theSize.height < minDisplayHeight: maxRedirectedHeight = max( (borderRows + int( 1 + minLineWidth // maxRedirectedWidth)), ((theSize.height * minHeightPercent) // 100) * \ int(1 + minLineWidth // maxRedirectedWidth) + \ theRedirectedAreaOffset) else: maxRedirectedHeight = max( (borderRows + int( 1 + minLineWidth // maxRedirectedWidth)), ((theSize.height * minHeightPercent) // 100) + \ theRedirectedAreaOffset) elif theSize.height < minDisplayHeight: maxRedirectedHeight = max( (borderRows + int( 1 + minLineWidth // maxRedirectedWidth)), ((theSize.height * minHeightPercent) // 100) + \ theRedirectedAreaOffset) else: maxRedirectedHeight = max( (borderRows + int( 1 + minLineWidth // maxRedirectedWidth)), ((theSize.height * maxHeightPercent) // 100) + \ theRedirectedAreaOffset) theRedirectedSize = wxSize(maxRedirectedWidth, maxRedirectedHeight) theRedirectedPos = wxPoint( theTaskArea.x, theTaskArea.y - (theRedirectedSize.height + 0)) theCharacterArea = wxRect(theRedirectedPos.x, theRedirectedPos.y, theRedirectedSize.width, theRedirectedSize.height) thePixelArea = wxRect( theCharacterArea.x * wx.pixelWidthPerCharacter, theCharacterArea.y * wx.pixelHeightPerCharacter, theCharacterArea.width * wx.pixelWidthPerCharacter, theCharacterArea.height * wx.pixelHeightPerCharacter) if pixels: theArea = thePixelArea else: theArea = theCharacterArea if DEBUG and VERBOSE: self.tsPrivateLogger( 'tsGetRedirectedStdioArea: %s pixels = %s characters' % ( thePixelArea, theCharacterArea)) else: theArea = None if DEBUG and VERBOSE: self.tsPrivateLogger( 'tsGetRedirectedStdioArea: %s' % theArea) return (theArea)
def CalcMin(self): ''' Calculate the total minimum width and height needed by all items in the sizer according to this sizer layout algorithm. ''' # The minimal size for the sizer should be big enough to allocate # its element at least its minimal size but also, and this is the # non-trivial part, to respect the children proportion. To satisfy # the latter condition we must find the greatest min-size-to- # proportion ratio for all elements with non-zero proportion. # This sizer instance only manages a single parent's client area. # Unlike wxWidgets, a parent's client area depends on size of # Top Level Window (Frame or Dialog) that depends on initial size # of Display Screen which was manually set by a System Operator. sizerClientArea = self.FindSizerClientArea() self.logger.debug( 'StaticBoxSizer.CalcMin: sizerClientArea=%s' % str( sizerClientArea)) self.ts_CalcMinArea = [] self.ts_CalcMinAreaProportion = [] self.ts_CalcMinKind = [] self.ts_CalcMinWindow = [] self.ts_ClientArea = [] self.ts_ContainingWindow = None self.ts_MinSize = wxSize(0, 0) self.ts_SizeMinThis = [] self.ts_TotalFixedSize = wxSize(0, 0) self.ts_TotalProportion = 0 for i in range(0, self.ts_Children.GetCount()): node = self.ts_Children.GetIndex(i) item = node.GetUserData() msg = 'StaticBoxSizer.CalcMin: item[%d]=%s' % (i, str(item)) ## print(msg) self.logger.debug(msg) if (True or item.IsShown()): # sizeMinThis = item.CalcMin() # TBD - Not sure if the following is equivalent. if (item.ts_Kind == wx.Item_None): msg = 'Kind: %s' % 'Item_None' sizeMinThis = wxSize(0, 0) self.ts_CalcMinWindow += [None] elif (item.ts_Kind == wx.Item_Sizer): msg = 'Kind: %s' % 'Item_Sizer' self.ts_Sizer.Layout() self.ts_CalcMinWindow += [None] sizeMinThis = item.ts_Sizer.Size elif (item.ts_Kind == wx.Item_Spacer): msg = 'Kind: %s' % 'Item_Spacer' self.ts_CalcMinWindow += [None] sizeMinThis = item.ts_Spacer.Size elif (item.ts_Kind == wx.Item_Window): msg = 'Kind: %s' % 'Item_Window' self.ts_CalcMinWindow += [item.ts_Window] parent = item.ts_Window.ts_Parent clientArea = parent.ClientArea if (clientArea == sizerClientArea): theRect = parent.Rect theClientArea = parent.ClientArea print('StaticBoxSizer.CalcMin: ' + \ 'Rect=%s; ClientArea=%s' % ( str(theRect), str(theClientArea))) else: theRect = parent.Rect theClientArea = parent.ClientArea print( 'StaticBoxSizer.CalcMin: ' + \ 'Rect=%s; ClientArea=%s' % ( str(theRect), str(theClientArea))) self.logger.error( 'StaticBoxSizer.CalcMin: ' + \ 'Rect=%s; ClientArea=%s' % ( str(theRect), str(theClientArea))) msg = '%s; Parent.clientArea=%s' % (msg, str(clientArea)) sizeMinThis = wxSize(clientArea.width, clientArea.height) if (self.ts_ContainingWindow is None): self.ts_ContainingWindow = parent self.ts_ClientArea = clientArea elif (self.ts_ContainingWindow == parent): pass else: fmt1 = 'StaticBoxSizer.CalcMin: ' fmt2 = 'Rejected Parent=%s' % str(parent) fmt3 = 'Previous Parent=%s' % str( self.ts_ContainingWindow) msgError = fmt1 + fmt2 + fmt3 print(msgError) self.logger.error(msgError) elif (item.ts_Kind == wx.Item_Max): msg = 'Kind: %s' % 'Item_Max' self.ts_CalcMinWindow += [None] sizeMinThis = wxSize(0, 0) else: msg = 'Kind: %s' % 'Item_Unknown' self.ts_CalcMinWindow += [None] sizeMinThis = wxSize(0, 0) self.logger.debug(msg) propThis = item.GetProportion() self.ts_CalcMinArea += [sizeMinThis] self.ts_CalcMinAreaProportion += [propThis] self.ts_CalcMinKind += [item.ts_Kind] self.ts_SizeMinThis += [sizeMinThis] if (propThis != 0): # Adjustable size item self.ts_TotalProportion += propThis msg = 'StaticBoxSizer.CalcMin: ' + \ 'item[%d]=%s; totalProp= %s' % ( i, str(item), str(self.ts_TotalProportion)) self.logger.debug(msg) else: # Fixed size item self.ts_TotalFixedSize += sizeMinThis msg = 'StaticBoxSizer.CalcMin: ' + \ 'item[%d]=%s; totalFixed= %s' % ( i, str(item), str(self.ts_TotalFixedSize)) self.logger.debug(msg) for i in range(0, self.ts_Children.GetCount()): if (self.ts_Orientation == wx.HORIZONTAL): orientation = 'HORIZONTAL' self.ts_CalcMinArea[i].height = self.ts_ClientArea.height if (self.ts_CalcMinAreaProportion[i] == 0): self.ts_CalcMinArea[ i].width = self.ts_SizeMinThis[i].width else: scalableWidth = self.ts_ClientArea.width - \ self.ts_TotalFixedSize.width self.ts_CalcMinArea[i].width = int(0.5 + ( scalableWidth * ( float(self.ts_CalcMinAreaProportion[i]) / float(self.ts_TotalProportion)))) else: orientation = ' VERTICAL' self.ts_CalcMinArea[i].width = self.ts_ClientArea.width if (self.ts_CalcMinAreaProportion[i] == 0): self.ts_CalcMinArea[ i].height = self.ts_SizeMinThis[i].height else: scalableHeight = self.ts_ClientArea.height - \ self.ts_TotalFixedSize.height self.ts_CalcMinArea[i].height = int(0.5 + ( scalableHeight * ( float(self.ts_CalcMinAreaProportion[i]) / float(self.ts_TotalProportion)))) if True: # Adjust to be multiple of standard character size self.ts_CalcMinArea[i].width = ( (self.ts_CalcMinArea[i].width // \ wx.pixelWidthPerCharacter) * \ wx.pixelWidthPerCharacter) self.ts_CalcMinArea[i].height = ( (self.ts_CalcMinArea[i].height // \ wx.pixelHeightPerCharacter) * \ wx.pixelHeightPerCharacter) fmt1 = '%s CalcMinArea[%d]: width=%3d; height=%3d; ' % ( orientation, i, int(self.ts_CalcMinArea[i].width), int(self.ts_CalcMinArea[i].height)) fmt2 = 'totalProportion=%3d' % int(self.ts_TotalProportion) self.logger.debug(fmt1 + fmt2) theCalcMinSize = self.GetSizeInMajorDir(self.ts_ClientArea) self.logger.debug('theCalcMinSize=%d' % theCalcMinSize) return (theCalcMinSize)
def tsRadioButtonLayout(self, parent, pos, size, style, name): """ Calculate position and size of button based upon arguments. """ if not (self.ts_Handle is None): # Inhibit operation once self.ts_Handle has been # assigned a curses window identifier. return (self.ts_Rect, self.ts_ClientRect) if style is None: # Prevent pylint warning. pass thePosition = self.tsGetClassInstanceFromTuple(pos, wxPoint) theSize = self.tsGetClassInstanceFromTuple(size, wxSize) theDefaultPosition = self.tsGetClassInstanceFromTuple(wx.DefaultPosition, wxPoint) theDefaultSize = self.tsGetClassInstanceFromTuple(wx.DefaultSize, wxSize) label = self.ts_ButtonText if theSize == theDefaultSize: # theDefaultSize ## print('default size layout label="%s"; pos=%s size=%s' % ( ## label, pos, size)) theLabelSize = theSize self.logger.debug(" theLabelSize (begin): %s" % theLabelSize) maxWidth = self.ts_Parent.ts_ClientRect.width - (2 * wx.pixelWidthPerCharacter) if label is wx.EmptyString: # TBD - Adjust for cursor width theLabelSize = wxSize(maxWidth, wx.pixelHeightPerCharacter) elif label.find("\n") == -1: # TBD - Remove adjustment for extra cursor width theLabelSize = wxSize((len(label) + len("[ ]")) * wx.pixelWidthPerCharacter, wx.pixelHeightPerCharacter) else: # TBD - Remove adjustment for extra cursor width theLines = label.split("\n") maxWidth = 0 maxHeight = len(theLines) for aLine in theLines: if len(aLine) > maxWidth: maxWidth = len(aLine) theLabelSize = wxSize( (maxWidth + len("[ ]")) * wx.pixelWidthPerCharacter, maxHeight * wx.pixelHeightPerCharacter ) self.logger.debug(" theLabelSize (end): %s" % theLabelSize) if False and thePosition == theDefaultPosition: # theDefaultPosition myRect = wxRect(parent.ClientArea.x, parent.ClientArea.y, theLabelSize.width, theLabelSize.height) else: # Not theDefaultPosition myRect = wxRect(thePosition.x, thePosition.y, theLabelSize.width, theLabelSize.height) else: # Not theDefaultSize ## print('not default size layout label="%s"; pos=%s size=%s' % ( ## label, pos, size)) if False and thePosition == theDefaultPosition: # theDefaultPosition myRect = wxRect(parent.ClientArea.x, parent.ClientArea.y, theSize.width, theSize.height) else: # Not theDefaultPosition myRect = wxRect(thePosition.x, thePosition.y, theSize.width, theSize.height) ## theDisplayRect = self.Display.GetClientArea() ## if not theDisplayRect.InsideRect(myRect): ## myRect = wxRect( ## max(thePosition.x, theDisplayRect.x), ## max(thePosition.y, theDisplayRect.y), ## min(theSize.width, theDisplayRect.width), ## min(theSize.height, theDisplayRect.height - 1)) ## if not theDisplayRect.InsideRect(myRect): ## myRect = theDisplayRect myClientRect = wxRect(myRect.x, myRect.y, myRect.width, myRect.height) self.tsTrapIfTooSmall(name, myRect) fmt = "parent=%s; pos=%s; size=%s; " + 'name="%s"; label="%s"; myRect=%s' msg = fmt % (parent, str(pos), str(size), name, label, str(myRect)) self.logger.debug(" tsRadioButtonLayout: %s" % msg) return (myRect, myClientRect)