Python tsWxSize.wxSize函数代码示例

    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 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 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 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 SizeFromMajorMinor(self, major, minor):
        '''
        '''
        if self.ts_Orientation == wx.HORIZONTAL:

            return (wxSize(major, minor))

        else: # wxVERTICAL

            return (wxSize(minor, major))

    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 as frameError:
            self.logger.error(
                '  CreateOutputWindow: frameError. %s' % frameError)
            msg = 'CreateOutputWindow Frame Error: %s' % str(frameError)
            raise tse.ProgramException(tse.APPLICATION_TRAP, msg)

        if self.ts_Frame.display.HasColors:
            self.ts_Markup = wx.ThemeToUse['Stdio']['Markup']['DEFAULT']
        else:
            self.ts_Markup = None

        try:
            self.ts_Text  = wxTextCtrl(
                self.ts_Frame,
                id=-1,
                value=wx.EmptyString,
                pos=wxPoint(
                    self.ts_ClientRect.x + self.ts_Margin.width,
                    self.ts_ClientRect.y + self.ts_Margin.height),
                size=wxSize(
                    self.ts_ClientRect.width - 2 * self.ts_Margin.width,
                    self.ts_ClientRect.height - 2 * self.ts_Margin.height),
                style=0, # wx.TE_MULTILINE |wx.TE_READONLY,
                validator=wx.DefaultValidator,
                name=wx.TextCtrlNameStr)
        except Exception as textCtrError:
            self.logger.error(
                '  CreateOutputWindow: textCtlError. %s' % textCtrError)
            msg = 'CreateOutputWindow textCtr Error: %s' % str(textCtrError)
            raise tse.ProgramException(tse.APPLICATION_TRAP, msg)

        # Skip this since text has been pre-cached in self.write
        # before invocation of self.CreateOutputWindow.
        if False:
            self.ts_Text.AppendText(st)

        self.ts_Frame.Show(True)

    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 __init__(self, window, size):
        """
        Create a new caret object.
        """
        theClass = "Caret"

        wx.RegisterFirstCallerClassName(self, theClass)

        ##        self.tsBeginClassRegistration(theClass, id)
        try:

            self.logger = tsLogger.TsLogger(
                threshold=tsLogger.ERROR, start=time.time(), name=tsLogger.StandardOutputFile
            )

        except AttributeError as e:

            self.logger = None
            msg = "tsWxCaret.__init__: Exception = %s" % e
            raise tse.ProgramException(tse.APPLICATION_TRAP, msg)

        self.ts_Position = wxPoint(0, 0)
        self.ts_Size = wxSize(0, 0)

        self.ts_Window = window
        self.ts_visibility = wx.caretNormal
        self.theScreen = tsGTUI.GraphicalTextUserInterface(theClass)
        self.theScreen.curs_set(self.ts_visibility)

    def tsGetClientArea(self, pixels=True):
        '''
        Returns the bounding rectangle the client area of the Dialog.
        '''
        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.tsDialogWindowLayout(
            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 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 as e:
                self.logger.error("%s; %s" % (__title__, e))

            self.tsUpdate()

    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 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 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))