+wrappers will figure out what to do. **[Changed in 2.5.2.x]**
+AddWindow, AddSizer, AddSpacer and etc. will now issue a
+DeprecationWarning. **[Changed in 2.5.4.x]** These methods have now
+been undeprecated at the request of Riaan Booysen, the Boa Constructor
+team lead. They are now just simple compatibility aliases for Add,
+and etc.
+
+**[Changed in 2.5.2.x]** The Sizers have had some fundamental internal
+changes in the 2.5.2.x release intended to make them do more of the
+"Right Thing" but also be as backwards compatible as possible.
+First a bit about how things used to work:
+
+ * The size that a window had when Add()ed to the sizer was assumed
+ to be its minimal size, and that size would always be used by
+ default when calculating layout size and positions, and the
+ sizer itself would keep track of that minimal size.
+
+ * If the window item was added with the ``wx.ADJUST_MINSIZE``
+ flag then when layout was calculated the item's ``GetBestSize``
+ would be used to reset the minimal size that the sizer used.
+
+The main thrust of the new Sizer changes was to make behavior like
+``wx.ADJUST_MINSIZE`` be the default, and also to push the tracking of
+the minimal size to the window itself (since it knows its own needs)
+instead of having the sizer take care of it. Consequently these
+changes were made:
+
+ * The ``wx.FIXED_MINSIZE`` flag was added to allow for the old
+ behavior. When this flag is used the size a window has when
+ added to the sizer will be treated as its minimal size and it
+ will not be readjusted on each layout.
+
+ * The min size stored in ``wx.Window`` and settable with
+ ``SetSizeHints`` or ``SetMinSize`` will by default be used by
+ the sizer (if it was set) as the minimal size of the sizer item.
+ If the min size was not set (or was only partially set) then the
+ window's best size is fetched and it is used instead of (or
+ blended with) the min size. ``wx.Window.GetBestFittingSize``
+ was added to facilitate getting the size to be used by the
+ sizers.
+
+ * The best size of a window is cached so it doesn't need to
+ recaculated on every layout. ``wx.Window.InvalidateBestSize``
+ was added and should be called (usually just internally in
+ control methods) whenever something is done that would make the
+ best size change.
+
+ * All wxControls were changed to set the minsize to what is passed
+ to the constructor or Create method, and also to set the real
+ size of the control to the blending of the min size and best
+ size. ``wx.Window.SetBestFittingSize`` was added to help with
+ this, although most controls don't need to call it directly
+ because it is called indirectly via the ``SetInitialSize``
+ called in the base classes.
+
+At this time, the only situation known not to work the same as before
+is the following::
+
+ win = SomeWidget(parent)
+ win.SetSize(SomeNonDefaultSize)
+ sizer.Add(win)
+
+In this case the old code would have used the new size as the minimum,
+but now the sizer will use the default size as the minimum rather than
+the size set later. It is an easy fix though, just move the
+specification of the size to the constructor (assuming that SomeWidget
+will set its minsize there like the rest of the controls do) or call
+``SetMinSize`` instead of ``SetSize``.
+
+In order to fit well with this new scheme of things, all wxControls or
+custom controls should do the following things. (Depending on how
+they are used you may also want to do the same thing for non-control
+custom windows.)
+
+ * Either override or inherit a meaningful ``DoGetBestSize`` method
+ that calculates whatever size is "best" for the control. Once
+ that size is calculated then there should normally be a call to
+ ``CacheBestSize`` to save it for later use, unless for some
+ reason you want the best size to be recalculated on every
+ layout.
+
+ Note: In order to successfully override ``DoGetBestSize`` in
+ Python the class needs to be derived from ``wx.PyWindow``,
+ ``wx.PyControl``, or etc. If your class instead derives from
+ one of the standard wx classes then just be sure that the min
+ size gets explicitly set to what would have been the best size
+ and things should work properly in almost all situations.
+
+ * Any method that changes the attributes of the control such that
+ the best size will change should call ``InvalidateBestSize`` so
+ it will be recalculated the next time it is needed.
+
+ * The control's constructor and/or Create method should ensure
+ that the minsize is set to the size passed in, and that the
+ control is sized to a blending of the min size and best size.
+ This can be done by calling ``SetBestFittingSize``.
+
+
+
+PlatformInfo
+------------
+
+Added wx.PlatformInfo which is a tuple containing strings that
+describe the platform and build options of wxPython. This lets you
+know more about the build than just the __WXPORT__ value that
+wx.Platform contains, such as if it is a GTK2 build. For example,
+instead of::
+
+ if wx.Platform == "__WXGTK__":
+ ...
+
+you should do this::
+
+ if "__WXGTK__" in wx.PlatformInfo:
+ ...
+
+and you can specifically check for a wxGTK2 build by looking for
+"gtk2" in wx.PlatformInfo. Unicode builds are also detectable this
+way. If there are any other platform/toolkit/build flags that make
+sense to add to this tuple please let me know.
+
+BTW, wx.Platform will probably be deprecated in the future.
+
+
+
+ActiveX
+-------
+
+Lindsay Mathieson's newest wxActiveX_ class has been wrapped into a new
+extension module called wx.activex. It is very generic and dynamic
+and should allow hosting of arbitray ActiveX controls within your
+wxPython apps. So far I've tested it with IE, PDF, and Flash
+controls, (and there are new samples in the demo and also library
+modules supporting these.)
+
+.. _wxActiveX: http://members.optusnet.com.au/~blackpaw1/wxactivex.html
+
+The new wx.activex module contains a bunch of code, but the most
+important things to look at are ActiveXWindow and ActiveXEvent.
+ActiveXWindow derives from wxWindow and the constructor accepts a
+CLSID for the ActiveX Control that should be created. (There is also
+a CLSID class that can convert from a progID or a CLSID String.) The
+ActiveXWindow class simply adds methods that allow you to query some
+of the TypeInfo exposed by the ActiveX object, and also to get/set
+properties or call methods by name. The Python implementation
+automatically handles converting parameters and return values to/from
+the types expected by the ActiveX code as specified by the TypeInfo,
+(just bool, integers, floating point, strings and None/Empty so far,
+but more can be handled later.)
+
+That's pretty much all there is to the class, as I mentioned before it
+is very generic and dynamic. Very little is hard-coded and everything
+that is done with the actual ActiveX control is done at runtime and
+referenced by property or method name. Since Python is such a dynamic
+language this is a very good match. I thought for a while about doing
+some Python black-magic and making the specific methods/properties of
+the actual ActiveX control "appear" at runtime, but then decided that
+it would be better and more understandable to do it via subclassing.
+So there is a utility class in wx.activex that given an existing
+ActiveXWindow instance can generate a .py module containing a derived
+class with real methods and properties that do the Right Thing to
+reflect those calls to the real ActiveX control. There is also a
+script/tool module named genaxmodule that given a CLSID or progID and
+a class name, will generate the module for you. There are a few
+examples of the output of this tool in the wx.lib package, see
+iewin.py, pdfwin.py and flashwin.py.
+
+Currently the genaxmodule tool will tweak some of the names it
+generates, but this can be controled if you would like to do it
+differently by deriving your own class from GernerateAXModule,
+overriding some methods and then using this class from a tool like
+genaxmodule. [TODO: make specifying a new class on genaxmodule's
+command-line possible.] The current default behavior is that any
+event names that start with "On" will have the "On" dropped, property
+names are converted to all lower case, and if any name is a Python
+keyword it will have an underscore appended to it. GernerateAXModule
+does it's best when generating the code in the new module, but it can
+only be as good as the TypeInfo data available from the ActiveX
+control so sometimes some tweaking will be needed. For example, the
+IE web browser control defines the Flags parameter of the Navigate2
+method as required, but MSDN says it is optional.
+
+It is intended that this new wx.activex module will replace both the
+older version of Lindsay's code available in iewin.IEHtmlWindow, and
+also the wx.lib.activexwraper module. Probably the biggest
+differences you'll ecounter in migrating activexwrapper-based code
+(besides events working better without causing deadlocks) is that
+events are no longer caught by overriding methods in your derived
+class. Instead ActiveXWindow uses the wx event system and you bind
+handlers for the ActiveX events exactly the same way you do for any wx
+event. There is just one extra step needed and that is creating an
+event ID from the ActiveX event name, and if you use the genaxmodule
+tool then this extra step will be handled for you there. For example,
+for the StatusTextChange event in the IE web browser control, this
+code is generated for you::
+
+ wxEVT_StatusTextChange = wx.activex.RegisterActiveXEvent('StatusTextChange')
+ EVT_StatusTextChange = wx.PyEventBinder(wxEVT_StatusTextChange, 1)
+
+and you would use it in your code like this::
+
+ self.Bind(iewin.EVT_StatusTextChange, self.UpdateStatusText, self.ie)
+
+When the event happens and your event handler function is called the
+event properties from the ActiveX control (if any) are converted to
+attributes of the event object passed to the handler. (Can you say
+'event' any more times in a single sentence? ;-) ) For example the
+StatusTextChange event will also send the text that should be put into
+the status line as an event parameter named "Text" and you can access
+it your handlers as an attribute of the event object like this::
+
+ def UpdateStatusText(self, evt):
+ self.SetStatusText(evt.Text)
+
+Usually these event object attributes should be considered read-only,
+but some will be defined by the TypeInfo as output parameters. In
+those cases if you modify the event object's attribute then that value
+will be returned to the ActiveX control. For example, to prevent a
+new window from being opened by the IE web browser control you can do
+this in the handler for the iewin.EVT_NewWindow2 event::
+
+ def OnNewWindow2(self, evt):
+ evt.Cancel = True
+
+So how do you know what methods, events and properties that an ActiveX
+control supports? There is a funciton in wx.activex named GetAXInfo
+that returns a printable summary of the TypeInfo from the ActiveX
+instance passed in. You can use this as an example of how to browse
+the TypeInfo provided, and there is also a copy of this function's
+output appended as a comment to the modules produced by the
+genaxmodule tool. Beyond that you'll need to consult the docs
+provided by the makers of the ActiveX control that you are using.
+
+
+
+
+PNG Images
+----------
+
+Prior to 2.5 the PNG image handler would convert all alpha channel
+information to a mask when the image was loaded. Pixels that were
+more than halfway transparent would be made fully transparent by the
+mask and the rest would be made fully opaque.
+
+In 2.5 the image handler has been updated to preserve the alpha
+channel and will now only create a mask when all the pixels in the
+image are either fully transparent or fully opaque. In addition, the
+wx.DC.DrawBitmap and wx.DC.Blit methods are able to correctly blend
+the pixels in the image with partially transparent alpha values.
+
+If you are using a PNG with an alpha channel but you need to have a
+wx.Mask like you automatically got in 2.4 then you can do one of the
+following:
+
+ * Edit the image and make all the partially transparent pixels be
+ fully transparent.
+
+ * Use a different image type.
+
+ * Set a mask based on colour after you load the image.
+
+
+
+OGL is dead! LONG LIVE OGL!
+---------------------------
+
+**[Changed in 2.5.2.x]**
+
+The wx.ogl module was deprecated in version 2.5.2 in favor of the new
+Python port of the OGL library located at wx.lib.ogl contributed by
+Pierre Hjälm. Starting in version 2.5.5 the old ogl is no longer
+being built in the distributed binaries, however the source code is
+still in the source tree so people can built it themselves if desired.
+
+The reason this changes was done was to greatly extend the life of OGL
+within wxPython by making it more easily maintainable and less prone
+to getting rusty as there seems to be less and less interest in
+maintaining the C++ version.
+
+There are only a few known compatibility issues at this time. First
+is the location of OGL. The old version was located in the
+wx.ogl module, and the new version is in the wx.lib.ogl package. So
+this just means that to start using the new version you need to adjust
+your imports. So if your code currently has something like this::
+
+ import wx
+ import wx.ogl as ogl
+
+Then just change it to this::
+
+ import wx
+ import wx.lib.ogl as ogl
projects / wxWidgets.git / blobdiff