"""Decorator classes for documentation and shell scripting. """ __author__ = "Patrick K. O'Brien " __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