MS-Windows

• A 486 or higher PC running MS Windows.
• At least ?? MB of disk space.

Linux or Unix

• Almost any C++ compiler, including GNU C++ (EGCS 1.1.1 or above).
• Almost any Unix workstation, and one of: GTK+ 1.2, GTK+ 2.0, Motif 1.2 or higher, Lesstif.
• At least ?? MB of disk space.

Mac OS X

• A PowerPC Mac running Mac OS X 10.x.
• At least ?? MB of disk space.

Application initialization

The OnInit method defined for a class derived from wx.App will usually create a top window as a bare minimum.

OnInit must return a boolean value to indicate whether processing should continue (True) or not (False). You call App.SetTopWindow to let wxPython know about the top window.

An application closes by destroying all windows. Because all frames must be destroyed for the application to exit, it is advisable to use parent frames wherever possible when creating new frames, so that deleting the top level frame will automatically delete child frames. The alternative is to explicitly delete child frames in the top-level frame's CloseEvent handler.

In emergencies the wx.Exit() function can be called to kill the application, however, normally the application shuts down automatically, see below.

An example of defining an application follows:

import wx

from frame import Frame

class App(wx.App):
    """Application class."""

    def OnInit(self):
        self.frame = Frame()
        self.frame.Show()
        self.SetTopWindow(self.frame)
        return True

def main():
    app = App()
    app.MainLoop()

if __name__ == '__main__':
    main()

Application shutdown

The application normally shuts down when the last of its top level windows is closed. This is normally the expected behaviour and means that it is enough to call Close() in response to the "Exit" menu command if your program has a single top level window. If this behaviour is not desirable, App.SetExitOnFrameDelete can be called to change it. Note that such logic doesn't apply for the windows shown before the program enters the main loop: in other words, you can safely show a dialog from App.OnInit and not be afraid that your application terminates when this dialog -- which is the last top level window for the moment -- is closed.

Another aspect of the application shutdown is the OnExit which is called when the application exits but before wxPython cleans up its internal structures. You should delete all wxPython objects that you created by the time OnExit finishes.

For example, this code may crash:

[Need examples of objects needing cleanup to keep app from crashing.]

The idea behind sizers

The layout algorithm used by sizers in wxPython is closely related to layout systems in other GUI toolkits, such as Java's AWT, the GTK toolkit or the Qt toolkit. It is based upon the idea of individual subwindows reporting their minimal required size and their ability to get stretched if the size of the parent window has changed. This will most often mean that the programmer does not set the start-up size of a dialog, the dialog will rather be assigned a sizer and this sizer will be queried about the recommended size. This sizer in turn will query its children (which can be normal windows, empty space or other sizers) so that a hierarchy of sizers can be constructed. Note that wx.Sizer does not derive from wx.Window and thus does not interfere with tab ordering and requires very few resources compared to a real window on screen.

What makes sizers so well fitted for use in wxPython is the fact that every control reports its own minimal size and the algorithm can handle differences in font sizes or different window (dialog item) sizes on different platforms without problems. For example, if the standard font as well as the overall design of Linux/GTK widgets requires more space than on Windows, the initial dialog size will automatically be bigger on Linux/GTK than on Windows.

There are currently five different kinds of sizers available in wxPython. Each represents either a certain way to lay out dialog items in a dialog or it fulfils a special task such as wrapping a static box around a dialog item (or another sizer). These sizers will be discussed one by one in the text below.

Common features

All sizers are containers, that is, they are used to lay out one dialog item (or several dialog items), which they contain. Such items are sometimes referred to as the children of the sizer. Independent of how the individual sizers lay out their children, all children have certain features in common:

BoxSizer

BoxSizer can lay out its children either vertically or horizontally, depending on what flag is being used in its constructor. When using a vertical sizer, each child can be centered, aligned to the right or aligned to the left. Correspondingly, when using a horizontal sizer, each child can be centered, aligned at the bottom or aligned at the top. The stretch factor described in the last paragraph is used for the main orientation, i.e. when using a horizontal box sizer, the stretch factor determines how much the child can be stretched horizontally. The following sample shows the same dialog as in the last sample, only the box sizer is a vertical box sizer now:

[Need graphics]

StaticBoxSizer

StaticBoxSixer is the same as a BoxSizer, but surrounded by a static box. Here is a sample:

[Need graphics]

GridSizer

GridSizer is a two-dimensional sizer. All children are given the same size, which is the minimal size required by the biggest child, in this case the text control in the left bottom border. Either the number of columns or the number or rows is fixed and the grid sizer will grow in the respectively other orientation if new children are added:

[Need graphics]

FlexGridSizer

Another two-dimensional sizer derived from GridSizer. The width of each column and the height of each row are calculated individually according the minimal requirements from the respectively biggest child. Additionally, columns and rows can be declared to be stretchable if the sizer is assigned a size different from that which it requested. The following sample shows the same dialog as the one above, but using a flex grid sizer:

[Need graphics]

NotebookSizer

NotebookSizer can be used with notebooks. It calculates the size of each notebook page and sets the size of the notebook to the size of the biggest page plus some extra space required for the notebook tabs and decorations.

[Need graphics]

Programming with BoxSizer

The basic idea behind a BoxSizer is that windows will most often be laid out in rather simple basic geometry, typically in a row or a column or several hierarchies of either.

As an example, we will construct a dialog that will contain a text field at the top and two buttons at the bottom. This can be seen as a top-hierarchy column with the text at the top and buttons at the bottom and a low-hierarchy row with an OK button to the left and a Cancel button to the right. In many cases (particularly dialogs under Unix and normal frames) the main window will be resizable by the user and this change of size will have to get propagated to its children. In our case, we want the text area to grow with the dialog, whereas the button shall have a fixed size. In addition, there will be a thin border around all controls to make the dialog look nice and - to make matter worse - the buttons shall be centred as the width of the dialog changes.

It is the unique feature of a box sizer, that it can grow in both directions (height and width) but can distribute its growth in the main direction (horizontal for a row) unevenly among its children. In our example case, the vertical sizer is supposed to propagate all its height changes to only the text area, not to the button area. This is determined by the proportion parameter when adding a window (or another sizer) to a sizer. It is interpreted as a weight factor, i.e. it can be zero, indicating that the window may not be resized at all, or above zero. If several windows have a value above zero, the value is interpreted relative to the sum of all weight factors of the sizer, so when adding two windows with a value of 1, they will both get resized equally much and each half as much as the sizer owning them.

Then what do we do when a column sizer changes its width? This behaviour is controlled by flags (the second parameter of the Add() function): zero or no flag indicates that the window will preserve it is original size, wx.GROW flag (same as wx.EXPAND) forces the window to grow with the sizer, and wx.SHAPED flag tells the window to change it is size proportionally, preserving original aspect ratio. When wx.GROW flag is not used, the item can be aligned within available space. wx.ALIGN_LEFT, wx.ALIGN_TOP, wx.ALIGN_RIGHT, wx.ALIGN_BOTTOM, wx.ALIGN_CENTER_HORIZONTAL and wx.ALIGN_CENTER_VERTICAL do what they say. wx.ALIGN_CENTRE (same as wx.ALIGN_CENTER) is defined as (wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL). Default alignment is wx.ALIGN_LEFT | wx.ALIGN_TOP.

As mentioned above, any window belonging to a sizer may have border, and it can be specified which of the four sides may have this border, using the wx.TOP, wx.LEFT, wx.RIGHT and wx.BOTTOM constants or wx.ALL for all directions (and you may also use wx.NORTH, wx.WEST etc instead). These flags can be used in combination with the alignment flags above as the second parameter of the Add() method using the binary or operator (|). The sizer of the border also must be made known, and it is the third parameter in the Add() method. This means, that the entire behaviour of a sizer and its children can be controlled by the three parameters of the Add() method.

[Show code and graphic here.]

Programming with GridSizer

GridSizer is a sizer which lays out its children in a two-dimensional table with all table fields having the same size, i.e. the width of each field is the width of the widest child, the height of each field is the height of the tallest child.

[Show code and graphic here.]

Programming with FlexGridSizer

FlexGridSizer is a sizer which lays out its children in a two-dimensional table with all table fields in one row having the same height and all fields in one column having the same width, but all rows or all columns are not necessarily the same height or width as in the GridSizer.

[Show code and graphic here.]

Programming with NotebookSizer

NotebookSizer is a specialized sizer to make sizers work in connection with using notebooks. This sizer is different from any other sizer as you must not add any children to it - instead, it queries the notebook class itself. The only thing this sizer does is to determine the size of the biggest page of the notebook and report an adjusted minimal size to a more toplevel sizer.

In order to query the size of notebook page, this page needs to have its own sizer, otherwise the NotebookSizer will ignore it. Notebook pages get their sizer by assigning one to them using SetSizer() and setting the auto-layout option to True using SetAutoLayout(). Here is one example showing how to add a notebook page that the notebook sizer is aware of:

[Show code and graphic here.]

Programming with StaticBoxSizer

StaticBoxSizer is a sizer derived from BoxSizer but adds a static box around the sizer. Note that this static box has to be created separately.

[Show code and graphic here.]

Dialog.CreateButtonSizer

As a convenience, the Dialog class has a CreateButtonSizer(flags) method that can be used to create a standard button sizer in which standard buttons are displayed. The following flags can be passed to this method:

All date/time classes at a glance

There are 3 main classes: except DateTime itself which represents an absolute moment in time, there are also two classes - TimeSpan and DateSpan which represent the intervals of time.

There are also helper classes which are used together with DateTime: DateTimeHolidayAuthority which is used to determine whether a given date is a holiday or not and DateTimeWorkDays which is a derivation of this class for which (only) Saturdays and Sundays are the holidays. See more about these classes in the discussion of the holidays.

DateTime characteristics

DateTime stores the time as a signed number of milliseconds since the Epoch which is fixed, by convention, to Jan 1, 1970 - however this is not visible to the class users (in particular, dates prior to the Epoch are handled just as well (or as bad) as the dates after it). But it does mean that the best resolution which can be achieved with this class is 1 millisecond.

The size of DateTime object is 8 bytes because it is represented as a 64 bit integer. The resulting range of supported dates is thus approximatively 580 million years, but due to the current limitations in the Gregorian calendar support, only dates from Nov 24, 4714BC are supported (this is subject to change if there is sufficient interest in doing it).

Finally, the internal representation is time zone independent (always in GMT) and the time zones only come into play when a date is broken into year/month/day components. See more about timezones below.

Currently, the only supported calendar is Gregorian one (which is used even for the dates prior to the historic introduction of this calendar which was first done on Oct 15, 1582 but is, generally speaking, country, and even region, dependent). Future versions will probably have Julian calendar support as well and support for other calendars (Maya, Hebrew, Chinese...) is not ruled out.

Difference between DateSpan and TimeSpan

While there is only one logical way to represent an absolute moment in the time (and hence only one DateTime class), there are at least two methods to describe a time interval.

First, there is the direct and self-explaining way implemented by TimeSpan: it is just a difference in milliseconds between two moments in time. Adding or subtracting such an interval to DateTime is always well-defined and is a fast operation.

But in daily life other, calendar-dependent time interval specifications are used. For example, 'one month later' is commonly used. However, it is clear that this is not the same as TimeSpan of 60*60*24*31 seconds because 'one month later' Feb 15 is Mar 15 and not Mar 17 or Mar 16 (depending on whether the year is leap or not).

This is why there is another class for representing such intervals called DateSpan. It handles these sort of operations in the most natural way possible, but note that manipulating with intervals of this kind is not always well-defined. Consider, for example, Jan 31 + '1 month': this will give Feb 28 (or 29), i.e. the last day of February and not the non-existent Feb 31. Of course, this is what is usually wanted, but you still might be surprised to notice that now subtracting back the same interval from Feb 28 will result in Jan 28 and not Jan 31 we started with!

So, unless you plan to implement some kind of natural language parsing in the program, you should probably use TimeSpan instead of DateSpan (which is also more efficient). However, DateSpan may be very useful in situations when you do need to understand what 'in a month' means (of course, it is just DateTime.Now() + DateSpan.Month()).

Date arithmetics

Many different operations may be performed with the dates, however not all of them make sense. For example, multiplying a date by a number is an invalid operation, even though multiplying either of the time span classes by a number is perfectly valid.

Here is what can be done:

Time zone considerations

Although the time is always stored internally in GMT, you will usually work in the local time zone. Because of this, all DateTime constructors and setters which take the broken down date assume that these values are for the local time zone. Thus, DateTime(1, DateTime.Jan, 1970) will not correspond to the DateTime Epoch unless you happen to live in the UK.

All methods returning the date components (year, month, day, hour, minute, second...) will also return the correct values for the local time zone by default. So, generally, doing the natural things will lead to natural and correct results.

If you only want to do this, you may safely skip the rest of this section. However, if you want to work with different time zones, you should read it to the end.

In this (rare) case, you are still limited to the local time zone when constructing DateTime objects, i.e. there is no way to construct a DateTime corresponding to the given date in, say, Pacific Standard Time. To do it, you will need to call ToTimezone or MakeTimezone methods to adjust the date for the target time zone. There are also special versions of these functions ToGMT and MakeGMT for the most common case - when the date should be constructed in GMT.

You also can just retrieve the value for some time zone without converting the object to it first. For this you may pass TimeZone argument to any of the methods which are affected by the time zone (all methods getting date components and the date formatting ones, for example). In particular, the Format() family of methods accepts a TimeZone parameter and this allows to simply print time in any time zone.

To see how to do it, the last issue to address is how to construct a TimeZone object which must be passed to all these methods. First of all, you may construct it manually by specifying the time zone offset in seconds from GMT, but usually you will just use one of the symbolic time zone names and let the conversion constructor do the job. I.e. you would just write

wxDateTime dt(...whatever...); printf("The time is %s in local time zone", dt.FormatTime().c_str()); printf("The time is %s in GMT", dt.FormatTime(wxDateTime::GMT).c_str());

Daylight saving time (DST)

DST (a.k.a. 'summer time') handling is always a delicate task which is better left to the operating system which is supposed to be configured by the administrator to behave correctly. Unfortunately, when doing calculations with date outside of the range supported by the standard library, we are forced to deal with these issues ourselves.

Several functions are provided to calculate the beginning and end of DST in the given year and to determine whether it is in effect at the given moment or not, but they should not be considered as absolutely correct because, first of all, they only work more or less correctly for only a handful of countries (any information about other ones appreciated!) and even for them the rules may perfectly well change in the future.

The time zone handling methods use these functions too, so they are subject to the same limitations.

DateTime and Holidays

[TODO]