+++ /dev/null
-"""Decorator classes for documentation and shell scripting.
-"""
-
-__author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
-__cvsid__ = "$Id$"
-__revision__ = "$Revision$"[11:-2]
-
-
-# These are not the real wxPython classes. These are Python versions
-# for documentation purposes. They are also used to apply docstrings
-# to the real wxPython classes, which are SWIG-generated wrappers for
-# C-language classes.
-
-
-from Base import Object
-import Parameters as wx
-from Window import TopLevelWindow, Window
-
-
-class Frame(TopLevelWindow):
- """A frame is a window whose size and position can (usually) be
- changed by the user. It usually has thick borders and a title bar,
- and can optionally contain a menu bar, toolbar and status bar. A
- frame can contain any window that is not a frame or dialog.
-
- A frame that has a status bar and toolbar created via the
- CreateStatusBar/CreateToolBar functions manages these windows, and
- adjusts the value returned by GetClientSize to reflect the
- remaining size available to application windows.
-
- An application should normally define a CloseEvent handler for the
- frame to respond to system close events, for example so that
- related data and subwindows can be cleaned up."""
-
- def __init__(self, parent, id, title, pos=wx.DefaultPosition,
- size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
- name=wx.PyFrameNameStr):
- """Create a Frame instance.
-
- parent - The window parent. This may be None. If it is not
- None, the frame will always be displayed on top of the parent
- window on Windows.
-
- id - The window identifier. It may take a value of -1 to
- indicate a default value.
-
- title - The caption to be displayed on the frame's title bar.
-
- pos - The window position. A value of (-1, -1) indicates a
- default position, chosen by either the windowing system or
- wxWindows, depending on platform.
-
- size - The window size. A value of (-1, -1) indicates a
- default size, chosen by either the windowing system or
- wxWindows, depending on platform.
-
- style - The window style.
-
- name - The name of the window. This parameter is used to
- associate a name with the item, allowing the application user
- to set Motif resource values for individual windows."""
- pass
-
- def Create(self, parent, id, title, pos=wx.DefaultPosition,
- size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE,
- name=wx.PyFrameNameStr):
- """Create a Frame instance."""
- pass
-
- def Command(self, id):
- """Simulate a menu command; id is a menu item identifier."""
- pass
-
- def CreateStatusBar(self, number=1, style=wx.ST_SIZEGRIP, id=-1,
- name=wx.PyStatusLineNameStr):
- """Create a status bar at the bottom of frame.
-
- number - The number of fields to create. Specify a value
- greater than 1 to create a multi-field status bar.
-
- style - The status bar style. See wx.StatusBar for a list of
- valid styles.
-
- id - The status bar window identifier. If -1, an identifier
- will be chosen by wxWindows.
-
- name - The status bar window name.
-
- The width of the status bar is the whole width of the frame
- (adjusted automatically when resizing), and the height and
- text size are chosen by the host windowing system.
-
- By default, the status bar is an instance of wx.StatusBar."""
- pass
-
- def CreateToolBar(self, style=wx.NO_BORDER | wx.TB_HORIZONTAL,
- id=-1, name=wx.PyToolBarNameStr):
- """Create a toolbar at the top or left of frame.
-
- style - The toolbar style. See wxToolBar for a list of valid
- styles.
-
- id - The toolbar window identifier. If -1, an identifier will
- be chosen by wxWindows.
-
- name - The toolbar window name.
-
- By default, the toolbar is an instance of wx.ToolBar (which is
- defined to be a suitable toolbar class on each platform, such
- as wx.ToolBar95).
-
- When a toolbar has been created with this function, or made
- known to the frame with wx.Frame.SetToolBar, the frame will
- manage the toolbar position and adjust the return value from
- wx.Window.GetClientSize to reflect the available space for
- application windows."""
- pass
-
- def DoGiveHelp(self, text, show):
- """Show help text (typically in the statusbar).
-
- show is False if you are hiding the help, True otherwise.
-
- Meant to be overridden if a derived frame wants to do
- something else with help text from menus and etc. The default
- implementation simply calls Frame.SetStatusText."""
- pass
-
- def GetClientAreaOrigin(self):
- """Return origin of frame client area (in client coordinates).
-
- It may be different from (0, 0) if the frame has a toolbar."""
- pass
-
- def GetMenuBar(self):
- """Return menubar currently associated with frame (if any)."""
- pass
-
- def GetStatusBar(self):
- """Return status bar currently associated with frame (if any)."""
- pass
-
- def GetStatusBarPane(self):
- """Return status bar pane used to display menu/toolbar help."""
- pass
-
- def GetToolBar(self):
- """Return toolbar currently associated with frame (if any)."""
- pass
-
- def PopStatusText(self, number=0):
- """Redraw status bar with previous status text.
-
- number - The status field (starting from zero)."""
- pass
-
- def ProcessCommand(self, id):
- """Process menu command; return True if processed.
-
- id is the menu command identifier."""
- pass
-
- def PushStatusText(self, text, number=0):
- """Set status bar text and redraw status bar, remembering
- previous text.
-
- text - The text for the status field.
-
- number - The status field (starting from zero).
-
- Use an empty string to clear the status bar."""
- pass
-
- def SendSizeEvent(self):
- """Send a dummy size event to the frame forcing it to
- reevaluate its children positions. It is sometimes useful to
- call this function after adding or deleting a children after
- the frame creation or if a child size changes.
-
- Note that if the frame is using either sizers or constraints
- for the children layout, it is enough to call Frame.Layout()
- directly and this function should not be used in this case."""
- pass
-
- def SetMenuBar(self, menubar):
- """Show the menu bar in the frame.
-
- menuBar - The menu bar to associate with the frame.
-
- If the frame is destroyed, the menu bar and its menus will be
- destroyed also, so do not delete the menu bar explicitly
- (except by resetting the frame's menu bar to another frame or
- NULL).
-
- Under Windows, a call to Frame.OnSize is generated, so be sure
- to initialize data members properly before calling SetMenuBar.
-
- Note that it is not possible to call this function twice for
- the same frame object."""
- pass
-
- def SetStatusBar(self, statBar):
- """Associate a status bar with the frame."""
- pass
-
- def SetStatusBarPane(self, n):
- """Set the status bar pane used to display menu and toolbar
- help. Using -1 disables help display."""
- pass
-
- def SetStatusText(self, text, number=0):
- """Set status bar text and redraw status bar.
-
- text - The text for the status field.
-
- number - The status field (starting from zero).
-
- Use an empty string to clear the status bar."""
- pass
-
- def SetStatusWidths(self, choices):
- """Sets the widths of the fields in the status bar.
-
- choices - a Python list of integers, each of which is a status
- field width in pixels. A value of -1 indicates that the field
- is variable width; at least one field must be -1.
-
- The widths of the variable fields are calculated from the
- total width of all fields, minus the sum of widths of the
- non-variable fields, divided by the number of variable fields."""
- pass
-
- def SetToolBar(self, toolbar):
- """Associate a toolbar with the frame."""
- pass
-
-
-class LayoutAlgorithm(Object):
- """LayoutAlgorithm implements layout of subwindows in MDI or SDI
- frames. It sends a wx.CalculateLayoutEvent event to children of
- the frame, asking them for information about their size. For MDI
- parent frames, the algorithm allocates the remaining space to the
- MDI client window (which contains the MDI child frames). For SDI
- (normal) frames, a 'main' window is specified as taking up the
- remaining space.
-
- Because the event system is used, this technique can be applied to
- any windows, which are not necessarily 'aware' of the layout
- classes. However, you may wish to use wx.SashLayoutWindow for
- your subwindows since this class provides handlers for the
- required events, and accessors to specify the desired size of the
- window. The sash behaviour in the base class can be used,
- optionally, to make the windows user-resizable.
-
- LayoutAlgorithm is typically used in IDE (integrated development
- environment) applications, where there are several resizable
- windows in addition to the MDI client window, or other primary
- editing window. Resizable windows might include toolbars, a
- project window, and a window for displaying error and warning
- messages.
-
- When a window receives an OnCalculateLayout event, it should call
- SetRect in the given event object, to be the old supplied
- rectangle minus whatever space the window takes up. It should
- also set its own size accordingly.
- SashLayoutWindow.OnCalculateLayout generates an OnQueryLayoutInfo
- event which it sends to itself to determine the orientation,
- alignment and size of the window, which it gets from internal
- member variables set by the application.
-
- The algorithm works by starting off with a rectangle equal to the
- whole frame client area. It iterates through the frame children,
- generating OnCalculateLayout events which subtract the window size
- and return the remaining rectangle for the next window to process.
- It is assumed (by SashLayoutWindow.OnCalculateLayout) that a
- window stretches the full dimension of the frame client, according
- to the orientation it specifies. For example, a horizontal window
- will stretch the full width of the remaining portion of the frame
- client area. In the other orientation, the window will be fixed
- to whatever size was specified by OnQueryLayoutInfo. An alignment
- setting will make the window 'stick' to the left, top, right or
- bottom of the remaining client area. This scheme implies that
- order of window creation is important. Say you wish to have an
- extra toolbar at the top of the frame, a project window to the
- left of the MDI client window, and an output window above the
- status bar. You should therefore create the windows in this
- order: toolbar, output window, project window. This ensures that
- the toolbar and output window take up space at the top and bottom,
- and then the remaining height in-between is used for the project
- window.
-
- LayoutAlgorithm is quite independent of the way in which
- OnCalculateLayout chooses to interpret a window's size and
- alignment. Therefore you could implement a different window class
- with a new OnCalculateLayout event handler, that has a more
- sophisticated way of laying out the windows. It might allow
- specification of whether stretching occurs in the specified
- orientation, for example, rather than always assuming
- stretching. (This could, and probably should, be added to the
- existing implementation).
-
- The algorithm object does not respond to events, but itself
- generates the following events in order to calculate window sizes:
- EVT_QUERY_LAYOUT_INFO(func), EVT_CALCULATE_LAYOUT(func)."""
-
- def __init__(self):
- """Create a LayoutAlgorithm instance."""
- pass
-
- def LayoutFrame(self, frame, mainWindow=wx.NULL):
- """Lay out the children of a normal frame.
-
- mainWindow is set to occupy the remaining space. This
- function simply calls LayoutWindow()."""
- pass
-
- def LayoutMDIFrame(self, frame, rect=wx.NULL):
- """Lay out the children of an MDI parent frame.
-
- If rect is non-NULL, the given rectangle will be used as a
- starting point instead of the frame's client area.
-
- The MDI client window is set to occupy the remaining space."""
- pass
-
- def LayoutWindow(self, parent, mainWindow=wx.NULL):
- """Lay out the children of a normal frame or other window.
-
- mainWindow is set to occupy the remaining space. If this is
- not specified, then the last window that responds to a
- calculate layout event in query mode will get the remaining
- space (that is, a non-query OnCalculateLayout event will not
- be sent to this window and the window will be set to the
- remaining size)."""
- pass
-
-
-class MDIChildFrame(Frame):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def Create(self):
- """"""
- pass
-
- def Activate(self):
- """"""
- pass
-
- def Maximize(self):
- """"""
- pass
-
- def Restore(self):
- """"""
- pass
-
-
-class MDIClientWindow(Window):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def Create(self):
- """"""
- pass
-
-
-class MDIParentFrame(Frame):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def Create(self):
- """"""
- pass
-
- def ActivateNext(self):
- """"""
- pass
-
- def ActivatePrevious(self):
- """"""
- pass
-
- def ArrangeIcons(self):
- """"""
- pass
-
- def Cascade(self):
- """"""
- pass
-
- def GetActiveChild(self):
- """"""
- pass
-
- def GetClientWindow(self):
- """"""
- pass
-
- def GetToolBar(self):
- """"""
- pass
-
- def Tile(self):
- """"""
- pass
-
-
-class MiniFrame(Frame):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def Create(self):
- """"""
- pass
-
-
-class SplashScreen(Frame):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def GetSplashStyle(self):
- """"""
- pass
-
- def GetSplashWindow(self):
- """"""
- pass
-
- def GetTimeout(self):
- """"""
- pass
-
-
-class SplashScreenWindow(Window):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def GetBitmap(self):
- """"""
- pass
-
- def SetBitmap(self):
- """"""
- pass
-
-
-class StatusBar(Window):
- """"""
-
- def __init__(self):
- """"""
- pass
-
- def Create(self):
- """"""
- pass
-
- def GetBorderX(self):
- """"""
- pass
-
- def GetBorderY(self):
- """"""
- pass
-
- def GetFieldRect(self):
- """"""
- pass
-
- def GetFieldsCount(self):
- """"""
- pass
-
- def GetStatusText(self):
- """"""
- pass
-
- def PopStatusText(self):
- """"""
- pass
-
- def PushStatusText(self):
- """"""
- pass
-
- def SetFieldsCount(self):
- """"""
- pass
-
- def SetMinHeight(self):
- """"""
- pass
-
- def SetStatusText(self):
- """"""
- pass
-
- def SetStatusWidths(self):
- """"""
- pass
projects / wxWidgets.git / blobdiff