+<div class="section">
+<h1><a id="activex" name="activex">ActiveX</a></h1>
+<p>Lindsay Mathieson's newest <a class="reference" href="http://members.optusnet.com.au/~blackpaw1/wxactivex.html">wxActiveX</a> 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.)</p>
+<p>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.)</p>
+<p>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.</p>
+<p>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.</p>
+<p>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:</p>
+<pre class="literal-block">
+wxEVT_StatusTextChange = wx.activex.RegisterActiveXEvent('StatusTextChange')
+EVT_StatusTextChange = wx.PyEventBinder(wxEVT_StatusTextChange, 1)
+</pre>
+<p>and you would use it in your code like this:</p>
+<pre class="literal-block">
+self.Bind(iewin.EVT_StatusTextChange, self.UpdateStatusText, self.ie)
+</pre>
+<p>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:</p>
+<pre class="literal-block">
+def UpdateStatusText(self, evt):
+ self.SetStatusText(evt.Text)
+</pre>
+<p>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:</p>
+<pre class="literal-block">
+def OnNewWindow2(self, evt):
+ evt.Cancel = True
+</pre>
+<p>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.</p>
+</div>
+<div class="section">
+<h1><a id="png-images" name="png-images">PNG Images</a></h1>
+<p>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.</p>
+<p>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.</p>
+<p>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:</p>
+<blockquote>
+<ul class="simple">
+<li>Edit the image and make all the partially transparent pixels be
+fully transparent.</li>
+<li>Use a different image type.</li>
+<li>Set a mask based on colour after you load the image.</li>
+</ul>
+</blockquote>
+</div>
+<div class="section">
+<h1><a id="ogl-is-dead-long-live-ogl" name="ogl-is-dead-long-live-ogl">OGL is dead! LONG LIVE OGL!</a></h1>
+<p><strong>[Changed in 2.5.2.x]</strong></p>
+<p>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.</p>
+<p>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.</p>
+<p>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:</p>
+<pre class="literal-block">
+import wx
+import wx.ogl as ogl
+</pre>
+<p>Then just change it to this:</p>
+<pre class="literal-block">
+import wx
+import wx.lib.ogl as ogl
+</pre>
+<p>The other compatibility issue deals with removing a wart in the
+original API that was necessary in order to allow overloaded methods
+in derived classes to call the same method in the base class when
+using the old SWIG. Instead dedaling with the wart you can now just
+call the base class method like you woudl for any other Python class.
+For example, if you had to do something like this previously:</p>
+<pre class="literal-block">
+class MyDividedShape(ogl.DividedShape):
+ ...
+ def OnSizingEndDragLeft(self, pt, x, y, keys, attch):
+ self.base_OnSizingEndDragLeft(pt, x, y, keys, attch)
+ ...
+</pre>
+<p>You will need to change it to be like this:</p>
+<pre class="literal-block">
+class MyDividedShape(ogl.DividedShape):
+ ...
+ def OnSizingEndDragLeft(self, pt, x, y, keys, attch):
+ ogl.DividedShape.OnSizingEndDragLeft(self, pt, x, y, keys, attch)
+ ...
+</pre>
+</div>
+<div class="section">
+<h1><a id="obsolete-modules" name="obsolete-modules">Obsolete Modules</a></h1>
projects / wxWidgets.git / blobdiff