Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxPython 2.1b1 for wxMSW (wxGTK coming soon)

Browse Source 
Lots of changes, see the README.txt for details...


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2857 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
1999-06-22 07:03:29 +00:00
parent 2233e5b82c
commit bb0054cda8
71 changed files with 9629 additions and 4102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
utils/wxPython/lib/sizers/.cvsignore Normal file
View File

@@ -0,0 +1,2 @@
*.pyc

18
utils/wxPython/lib/sizers/__init__.py Normal file
View File

@@ -0,0 +1,18 @@
#----------------------------------------------------------------------------
# Name: __init__.py
# Purpose: The presence of this file turns this directory into a
# Python package.
#
# Author: Robin Dunn
#
# Created: 18-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------------
from sizer import *
from box import *
from border import *
#----------------------------------------------------------------------------

109
utils/wxPython/lib/sizers/border.py Normal file
View File

@@ -0,0 +1,109 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.border
# Purpose: A Sizer that wraps an empty border around its contents
#
# Author: Robin Dunn
#
# Created: 9-June-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from sizer import wxSizer
wxNORTH = 1
wxSOUTH = 2
wxEAST = 4
wxWEST = 8
wxALL = wxNORTH | wxSOUTH | wxEAST | wxWEST
#----------------------------------------------------------------------
class wxBorderSizer(wxSizer):
"""
wxBorderSizer
This sizer provides an empty buffer on one or more sides of it's
contents. It can only hold a single widget, but that can be a
sizer containing other items if you wish.
The sizer is constructed with a parameter specifying which sides
should have the border. You can use a logical OR of the following
values to specify the sides:
wxNORTH -- the top side
wxSOUTH -- the bottom side
wxEAST -- the right side
wxWEST -- the left side
wxALL -- all sides
The width in pixels of the border is specified when the child
widget is Added to the sizer.
"""
def __init__(self, sides = wxALL):
wxSizer.__init__(self)
self.sides = sides
def Add(self, widget, borderSize):
if self.children:
raise ValueError("wxBorderSizer can only contain one child.")
wxSizer.Add(self, widget, borderSize)
def CalcMin(self):
isSizer, widget, width, height, borderSize = self.children[0]
if isSizer:
width, height = widget.CalcMin()
if self.sides & wxEAST:
width = width + borderSize
if self.sides & wxWEST:
width = width + borderSize
if self.sides & wxNORTH:
height = height + borderSize
if self.sides & wxSOUTH:
height = height + borderSize
return width, height
def RecalcSizes(self):
isSizer, widget, width, height, borderSize = self.children[0]
width = self.size.width
height = self.size.height
px = self.origin.x
py = self.origin.y
if self.sides & wxWEST:
width = width - borderSize
px = px + borderSize
if self.sides & wxEAST:
width = width - borderSize
if self.sides & wxNORTH:
height = height - borderSize
py = py + borderSize
if self.sides & wxSOUTH:
height = height - borderSize
widget.SetDimensions(px, py, width, height)
#----------------------------------------------------------------------
#
# TODO... Make an abstract class wxBorder whose decendants can be added to
# a wxBorderSizer to provide drawing for the buffer area. Ideas are
# to provide a color border, beveled borders, rounded borders, etc.

137
utils/wxPython/lib/sizers/box.py Normal file
View File

@@ -0,0 +1,137 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.box
# Purpose: A sizer/layout managers for wxPython that places items in
# a stretchable box
#
# Author: Robin Dunn and Dirk Holtwick
#
# Created: 17-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from sizer import wxSizer
from wxPython.wx import wxVERTICAL, wxHORIZONTAL
#----------------------------------------------------------------------
class wxBoxSizer(wxSizer):
"""
wxBoxSizer
A Sizer that lays components out in a box, in the order they are
added to the layout manager, with a given orientation. The
orientation is specified in the constructor with either wxVERTICAL
or wxHORIZONTAL.
The optional parameter to the Add method (for this sizer it's
called the stretch flag) can be used to flag one or more components
as stretchable, meaning that they will expand to fill available
space in the given orientation. The default is zero, or not
stretchable.
If the stretch flag is non-zero then the widget will stretch. If
the sizer holds more than one item that is stretchable then they
share the available space.
If the strech flag is greater than 1 then it serves as a weighting
factor. Widgets with a flag of 2 will get twice as much space as
widgets with 1, etc.
"""
def __init__(self, orientation, size = None):
wxSizer.__init__(self, size)
self.orientation = orientation
def CalcMin(self):
self.stretchable = 0 # number of stretchable items
self.minWidth = 0 # minimal size
self.minHeight = 0
self.fixedWidth = 0 # size without stretched widgets
self.fixedHeight = 0
# iterate through children
for (isSizer, widget, width, height, stretch) in self.children:
weight = 1
if stretch:
weight = stretch
if isSizer:
# let sub-sizers recalc their required space
width, height = widget.CalcMin()
# minimal size
if self.orientation == wxVERTICAL:
self.minHeight = self.minHeight + (height * weight)
self.minWidth = max(self.minWidth, width)
else:
self.minWidth = self.minWidth + (width * weight)
self.minHeight = max(self.minHeight, height)
# stretchable items
if stretch:
self.stretchable = self.stretchable + weight
else:
if self.orientation == wxVERTICAL:
self.fixedHeight = self.fixedHeight + height
self.fixedWidth = max(self.fixedWidth, width)
else:
self.fixedWidth = self.fixedWidth + width
self.fixedHeight = max(self.fixedHeight, height)
return self.minWidth, self.minHeight
def RecalcSizes(self):
# get current dimensions, for performance
myWidth = self.size.width
myHeight = self.size.height
# relative recent positions & sizes
px = self.origin.x
py = self.origin.y
newWidth = 0
newHeight = 0
# calculate space for one stretched item
if self.stretchable:
if self.orientation == wxHORIZONTAL:
delta = (myWidth - self.fixedWidth) / self.stretchable
extra = (myWidth - self.fixedWidth) % self.stretchable
else:
delta = (myHeight - self.fixedHeight) / self.stretchable
extra = (myHeight - self.fixedHeight) % self.stretchable
# iterate children ...
for (isSizer, widget, width, height, stretch) in self.children:
weight = 1
if stretch:
weight = stretch
if isSizer:
width, height = widget.CalcMin()
# ... vertical
if self.orientation == wxVERTICAL:
newHeight = height
if stretch:
newHeight = (delta * weight) + extra # first stretchable gets extra pixels
extra = 0
widget.SetDimensions(px, py, myWidth, newHeight)
# ... horizontal
elif self.orientation == wxHORIZONTAL:
newWidth = width
if stretch:
newWidth = (delta * weight) + extra # first stretchable gets extra pixels
extra = 0
widget.SetDimensions(px, py, newWidth, myHeight)
px = px + newWidth
py = py + newHeight
#----------------------------------------------------------------------

110
utils/wxPython/lib/sizers/sizer.py Normal file
View File

@@ -0,0 +1,110 @@
#----------------------------------------------------------------------
# Name: wxPython.lib.sizers.sizer
# Purpose: General purpose sizer/layout managers for wxPython
#
# Author: Robin Dunn and Dirk Holtwick
#
# Created: 17-May-1999
# RCS-ID: $Id$
# Copyright: (c) 1998 by Total Control Software
# Licence: wxWindows license
#----------------------------------------------------------------------
from wxPython.wx import wxPoint, wxSize
#----------------------------------------------------------------------
class wxSizer:
"""
wxSizer
An abstract base sizer class. A sizer is able to manage the size and
layout of windows and/or child sizers.
Derived classes should implement CalcMin, and RecalcSizes.
A window or sizer is added to this sizer with the Add method:
def Add(self, widget, opt=0)
The meaning of the opt parameter is different for each type of
sizer. It may be a single value or a collection of values.
"""
def __init__(self, size = None):
self.children = []
self.origin = wxPoint(0, 0)
if not size:
size = wxSize(0,0)
self.size = size
def Add(self, widget, opt=0):
"""
Add a window or a sizer to this sizer. The meaning of the opt
parameter is different for each type of sizer. It may be a single
value or a collection of values.
"""
size = widget.GetSize()
isSizer = isinstance(widget, wxSizer)
self.children.append( (isSizer, widget, size.width, size.height, opt) )
def AddMany(self, widgets):
"""
Add a sequence (list, tuple, etc.) of widgets to this sizer. The
items in the sequence should be tuples containing valid args for
the Add method.
"""
for childinfo in widgets:
apply(self.Add, childinfo)
def SetDimensions(self, x, y, width, height):
self.origin = wxPoint(x, y)
self.size = wxSize(width, height)
self.RecalcSizes()
def GetSize(self):
return self.size
def GetPosition(self):
return self.origin
def CalcMin(self):
raise NotImplementedError("Derived class should implement CalcMin")
def RecalcSizes(self):
raise NotImplementedError("Derived class should implement RecalcSizes")
def __getMinWindowSize(self, win):
"""
Calculate the best size window to hold this sizer, taking into
account the difference between client size and window size.
"""
min = self.GetMinSize()
a1,a2 = win.GetSizeTuple()
b1,b2 = win.GetClientSizeTuple()
w = min.width + (a1 - b1)
h = min.height + (a2 - b2)
return (w, h)
def GetMinSize(self):
minWidth, minHeight = self.CalcMin()
return wxSize(minWidth, minHeight)
def SetWindowSizeHints(self, win):
w, h = self.__getMinWindowSize(win)
win.SetSizeHints(w,h)
def FitWindow(self, win):
w, h = self.__getMinWindowSize(win)
win.SetSize(wxSize(w,h))
def Layout(self, size):
self.CalcMin()
self.SetDimensions(self.origin.x, self.origin.y,
size.width, size.height)
#----------------------------------------------------------------------