wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/svg/__init__.py

@@ -0,0 +1,364 @@
+#----------------------------------------------------------------------
+# Name:        wx.svg.__init__.py
+# Purpose:     Python code to augment or extend the nanosvg wrappers,
+#              and provide wxPython-specific integrations.
+#
+# Author:      Robin Dunn
+#
+# Created:     23-July-2019
+# Copyright:   (c) 2019-2020 by Total Control Software
+# Licence:     wxWindows license
+# (c) 2021 Zombie
+#----------------------------------------------------------------------
+"""
+The classes in this package facilitate the parsing, normalizing, drawing and
+rasterizing of Scalable Vector Graphics (SVG) images. The primary interface to
+this functionality is via the :class:`wx.svg.SVGimage` class, which provides
+various integrations with wxPython. It, in turn, uses a set of wrappers around
+the NanoSVG library (https://github.com/memononen/nanosvg) to do the low-level
+work. There are a few features defined in the SVG spec that are not supported,
+but all the commonly used ones seem to be there.
+
+Example 1
+---------
+Drawing an SVG image to a window, scaled to fit the size of the window and using
+a :class:`wx.GraphicsContext` can be done like this::
+
+    def __init__(self, ...):
+        ...
+        self.img = wx.svg.SVGimage.CreateFromFile(svg_filename)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+    def OnPaint(self, event):
+        dc = wx.PaintDC(self)
+        dc.SetBackground(wx.Brush('white'))
+        dc.Clear()
+
+        dcdim = min(self.Size.width, self.Size.height)
+        imgdim = min(self.img.width, self.img.height)
+        scale = dcdim / imgdim
+        width = int(self.img.width * scale)
+        height = int(self.img.height * scale)
+
+        ctx = wx.GraphicsContext.Create(dc)
+        self.img.RenderToGC(ctx, scale)
+
+Since it is drawing the SVG shapes and paths using the equivalent GC primitives
+then any existing transformations that may be active on the context will be
+applied automatically to the SVG shapes.
+
+Note that not all GraphicsContext backends are created equal. Specifically, the
+GDI+ backend (the default on Windows) simply can not support some features that
+are commonly used in SVG images, such as applying transforms to gradients. The
+Direct2D backend on Windows does much better, and the Cairo backend on Windows
+is also very good. The default backends on OSX and Linux do very good as well.
+
+Example 2
+---------
+If you're not already using a ``wx.GraphicsContext`` then a :class:`wx.Bitmap`
+can easily be created instead. For example, the last 2 lines in the code above
+could be replaced by the following, and accomplish basically the same thing::
+
+    bmp = self.img.ConvertToBitmap(scale=scale, width=width, height=height)
+    dc.DrawBitmap(bmp, 0, 0)
+
+Example 3
+---------
+The ``ConvertToBitmap`` shown above gives a lot of control around scaling,
+translating and sizing the SVG image into a bitmap, but most of the time you
+probably just want to get a bitmap of a certain size to use as an icon or
+similar. The ``ConvertToScaledBitmap`` provides an easier API to do just that
+for you. It automatically scales the SVG image into the requested size in
+pixels.::
+
+    bmp = img.ConvertToScaledBitmap(wx.Size(24,24))
+
+Optionally, it can accept a window parameter that will automatically adjust the
+size according to the Content Scale Factor of that window, if supported by the
+platform and if the window is located on a HiDPI display the the bitmap's size
+will be adjusted accordingly.::
+
+    bmp = img.ConvertToScaledBitmap(wx.Size(24,24), self)
+
+"""
+
+import wx
+from six.moves import zip_longest
+
+from ._nanosvg import *
+
+# All the supported renderers now support gradient transforms, more or less, but
+# let's leave this in place in case it's needed again in the future.
+_RenderersWithoutGradientTransforms = []
+
+
+class SVGimage(SVGimageBase):
+    """
+    The SVGimage class provides various ways to load and use SVG images
+    in wxPython applications.
+    """
+
+    def ConvertToBitmap(self, tx=0.0, ty=0.0, scale=1.0,
+                        width=-1, height=-1, stride=-1):
+        """
+        Creates a :class:`wx.Bitmap` containing a rasterized version of the SVG image.
+
+        :param float `tx`: Image horizontal offset (applied after scaling)
+        :param float `ty`: Image vertical offset (applied after scaling)
+        :param float `scale`: Image scale
+        :param int `width`: width of the image to render, defaults to width from the SVG file
+        :param int `height`: height of the image to render, defaults to height from the SVG file
+        :param int `stride`: number of bytes per scan line in the destination buffer, typically ``width * 4``
+
+        :returns: :class:`wx.Bitmap`
+        """
+        buf = self.Rasterize(tx, ty, scale, width, height, stride)
+        bmp = wx.Bitmap.FromBufferRGBA(width, height, buf)
+        return bmp
+
+
+    def ConvertToScaledBitmap(self, size, window=None):
+        """
+        Automatically scales the SVG image so it will fit in the given size,
+        and creates a :class:`wx.Bitmap` of that size, containing a rasterized
+        version of the SVG image. If a window is passed then the size of the
+        bitmap will automatically be adjusted to the content scale factor of
+        that window. For example, if a (32,32) pixel bitmap is requested for a
+        window on a Retina display, then a (64,64) pixel bitmap will be created.
+
+        :param wx.Size `size`: Size of the bitmap to create, in pixels
+        :param wx.Window `window`: Adjust the size by this window's content scale factor, if supported on the platform
+
+        :returns: :class:`wx.Bitmap`
+        """
+        size = wx.Size(*size)
+        if window:
+            size.width *= int(window.GetContentScaleFactor())
+            size.height *= int(window.GetContentScaleFactor())
+
+        # We can only have one overall scale factor for both dimensions with
+        # this rasterization method, so chose either the minimum of width or
+        # height to help ensure it fits both ways within the specified size.
+        sx = size.width / self.width
+        sy = size.height / self.height
+        scale = min(sx, sy)
+        return self.ConvertToBitmap(scale=scale, width=size.width, height=size.height)
+
+
+    def RenderToGC(self, ctx, scale=None, size=None):
+        """
+        Draw the collection of shapes and paths in the SVG image
+        onto the given :class:`wx.GraphicsContext` using the drawing primitives
+        provided by the context. The Context's state is saved and restored so
+        any transformations done while rendering the SVG will be undone.
+
+        :param wx.GraphicsContext `ctx`: The context to draw upon
+        :param float `scale`: If given, apply to the context's scale.
+        :param (float, float) `size`: If given, scale the image's width and height
+            to that provided in this parameter. Ignored if ``scale`` is also specified.
+
+        .. note::
+            Some GraphicsContext backends perform better than others.
+            The default GDI+ backend on Windows is the most glitchy, but the
+            Direct2D backend works well.
+        """
+        ctx.PushState()
+        try:
+            # set scale either from the scale parameter or as ratio of the sizes
+            if scale is not None:
+                ctx.Scale(scale, scale)
+            elif size is not None:
+                # scale the context to the given size
+                size = wx.Size(*size)
+                sx = size.width / self.width
+                sy = size.height / self.height
+                ctx.Scale(sx, sy)
+
+            for shape in self.shapes:
+                if not shape.flags & SVG_FLAGS_VISIBLE:
+                    continue
+                if shape.opacity != 1.0:
+                    ctx.BeginLayer(shape.opacity)
+                brush = self._makeBrush(ctx, shape)
+                pen = self._makePen(ctx, shape)
+
+                rule = { SVG_FILLRULE_NONZERO : wx.WINDING_RULE,
+                        SVG_FILLRULE_EVENODD : wx.ODDEVEN_RULE }.get(shape.fillRule, 0)
+
+                # The shape's path is comprised of one or more subpaths, collect
+                # and accumulate them in a new GraphicsPath
+                path = ctx.CreatePath()
+                for svg_path in shape.paths:
+                    subpath = self._makeSubPath(ctx, svg_path)
+                    path.AddPath(subpath)
+
+                # Draw the combined set of paths, using the given pen and brush to
+                # fill and stroke the shape.
+                ctx.SetBrush(brush)
+                ctx.SetPen(pen)
+                ctx.DrawPath(path, rule)
+
+                if shape.opacity != 1.0:
+                    ctx.EndLayer()
+        finally:
+            ctx.Flush()
+            ctx.PopState()
+
+
+    def _makeSubPath(self, ctx, svg_path):
+        points = svg_path.points
+        path = ctx.CreatePath()
+        x, y = points[0]
+        path.MoveToPoint(x,y)
+        for (cx1, cy1), (cx2, cy2), (x,y) in _chunker(points[1:], 3, (0,0)):
+            path.AddCurveToPoint(cx1, cy1, cx2, cy2, x,y)
+        if svg_path.closed:
+            path.CloseSubpath()
+        return path
+
+
+    def _makeGradientStops(self, gradient):
+        stops = [stop for stop in gradient.stops]
+        first = stops[0]
+        last = stops[-1]
+        gcstops = wx.GraphicsGradientStops(wx.Colour(*first.color_rgba),
+                                           wx.Colour(*last.color_rgba))
+        for stop in stops:
+            color = wx.Colour(*stop.color_rgba)
+            gcstop = wx.GraphicsGradientStop(color, stop.offset)
+            gcstops.Add(gcstop)
+        return gcstops
+
+
+    def _getGradientColors(self, gradient):
+        return [stop.color_rgba for stop in gradient.stops]
+
+
+    def _makeBrush(self, ctx, shape):
+        # set up a brush from the shape.fill (SVGpaint) object
+
+        # no brush
+        if shape.fill.type == SVG_PAINT_NONE:
+            brush = wx.NullGraphicsBrush
+
+        # brush with a solid color
+        elif shape.fill.type == SVG_PAINT_COLOR:
+            r,g,b,a = shape.fill.color_rgba
+            brush = ctx.CreateBrush(wx.Brush(wx.Colour(r,g,b,a)))
+
+        # brush with a linear gradient
+        elif shape.fill.type == SVG_PAINT_LINEAR_GRADIENT:
+            # NanoSVG gives gradients their own transform which normalizes the
+            # linear gradients to go from (0, 0) to (0,1) in the transformed
+            # space. So once we have the transform set we can use those points
+            # too.
+            x1, y1, = (0.0, 0.0)
+            x2, y2, = (0.0, 1.0)
+            gradient = shape.fill.gradient
+            matrix = ctx.CreateMatrix(*gradient.xform)
+
+            # Except for GDI+, which doesn't support applying a transform to a
+            # gradient, so we'll translate the points back to real space
+            # ourselves. This is only an approximation of the desired outcome
+            # however, as things like scale and shear in the transform will not
+            # be applied to the rest of the fill.
+            if ctx.Renderer.Type in _RenderersWithoutGradientTransforms:
+                matrix.Invert()
+                x1, y1 = matrix.TransformPoint(x1, y1)
+                x2, y2 = matrix.TransformPoint(x2, y2)
+                matrix = wx.NullGraphicsMatrix
+
+            stops = self._makeGradientStops(gradient)
+            brush = ctx.CreateLinearGradientBrush(x1,y1, x2,y2, stops, matrix)
+
+        # brush with a radial gradient
+        elif shape.fill.type == SVG_PAINT_RADIAL_GRADIENT:
+            # Likewise, NanoSVG normalizes radial gradients with a transform
+            # that puts the center (cx, cy) at (0,0) and the radius has a length
+            # of 1.
+            cx, cy = (0.0, 0.0)
+            radius = 1
+            gradient = shape.fill.gradient
+            matrix = ctx.CreateMatrix(*gradient.xform)
+
+            # Except for GDI+...  See note above
+            if ctx.Renderer.Type in _RenderersWithoutGradientTransforms:
+                matrix.Invert()
+                cx, cy = matrix.TransformPoint(cx, cy)
+                r1, r2 = matrix.TransformPoint(0, 1)
+                radius = r2 - cy
+                matrix = wx.NullGraphicsMatrix
+
+            stops = self._makeGradientStops(gradient)
+            brush = ctx.CreateRadialGradientBrush(cx,cy, cx,cy, radius, stops, matrix)
+
+        else:
+            raise ValueError("Unknown fill type")
+        return brush
+
+
+    def _makePen(self, ctx, shape):
+        # set up a pen from the shape.stroke (SVGpaint) object
+        width = shape.strokeWidth
+        join = { SVG_JOIN_MITER : wx.JOIN_MITER,
+                 SVG_JOIN_ROUND : wx.JOIN_ROUND,
+                 SVG_JOIN_BEVEL : wx.JOIN_BEVEL}.get(shape.strokeLineJoin, 0)
+        cap =  { SVG_CAP_BUTT : wx.CAP_BUTT,
+                 SVG_CAP_ROUND : wx.CAP_ROUND,
+                 SVG_CAP_SQUARE : wx.CAP_PROJECTING}.get(shape.strokeLineCap, 0)
+        # TODO: handle dashes
+
+        info = wx.GraphicsPenInfo(wx.BLACK).Width(width).Join(join).Cap(cap)
+
+        if shape.stroke.type == SVG_PAINT_NONE:
+            pen = wx.NullGraphicsPen
+
+        elif shape.stroke.type == SVG_PAINT_COLOR:
+            info.Colour(shape.stroke.color_rgba)
+            pen = ctx.CreatePen(info)
+
+        elif shape.stroke.type == SVG_PAINT_LINEAR_GRADIENT:
+            x1, y1, = (0.0, 0.0)
+            x2, y2, = (0.0, 1.0)
+            gradient = shape.stroke.gradient
+            matrix = ctx.CreateMatrix(*gradient.xform)
+
+            # Except for GDI+...  See note above
+            if ctx.Renderer.Type in _RenderersWithoutGradientTransforms:
+                matrix.Invert()
+                x1, y1 = matrix.TransformPoint(x1, y1)
+                x2, y2 = matrix.TransformPoint(x2, y2)
+                matrix = wx.NullGraphicsMatrix
+
+            stops = self._makeGradientStops(gradient)
+            info.LinearGradient(x1,y1, x2,y2, stops, matrix)
+            pen = ctx.CreatePen(info)
+
+        elif shape.stroke.type == SVG_PAINT_RADIAL_GRADIENT:
+            cx, cy = (0.0, 0.0)
+            radius = 1
+            gradient = shape.stroke.gradient
+            matrix = ctx.CreateMatrix(*gradient.xform)
+
+            # Except for GDI+...  See note above
+            if ctx.Renderer.Type in _RenderersWithoutGradientTransforms:
+                matrix.Invert()
+                cx, cy = matrix.TransformPoint(cx, cy)
+                r1, r2 = matrix.TransformPoint(0, 1)
+                radius = r2 - cy
+                matrix = wx.NullGraphicsMatrix
+
+            stops = self._makeGradientStops(gradient)
+            info.RadialGradient(0,0, 0,0, 1, stops, matrix)
+            pen = ctx.CreatePen(info)
+
+        else:
+            raise ValueError("Unknown stroke type")
+        return pen
+
+
+def _chunker(iterable, n, fillvalue=None):
+    "Collect items from an iterable into fixed-length chunks or blocks"
+    args = [iter(iterable)] * n
+    return zip_longest(fillvalue=fillvalue, *args)
+

wx/tools/__init__.py

@@ -0,0 +1,18 @@
+"""
+Some useful tools and utilities for wxPython.
+"""
+
+
+# XRCed is purposfully left out so epydoc won't document it
+__all__ = [
+    'dbg',
+    'genaxmodule',
+    'helpviewer',
+    'img2img',
+    'img2png',
+    'img2py',
+    'img2xpm',
+    ]
+
+
+

wx/tools/dbg.py

@@ -0,0 +1,268 @@
+#----------------------------------------------------------------------------
+# Name:         dbg.py
+# Author:       Will Sadkin
+# Email:        wsadkin@nameconnector.com
+# Created:      07/11/2002
+# Copyright:    (c) 2002 by Will Sadkin, 2002
+# License:      wxWindows license
+# Tags:         phoenix-port
+#----------------------------------------------------------------------------
+# 12/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o V2.5 compatibility update
+#
+
+"""
+This module provides a useful debugging framework that supports
+showing nesting of function calls and allows a program to contain
+lots of debugging print statements that can easily be turned on
+or off to debug the code.  It also supports the ability to
+have each function indent the debugging statements contained
+within it, including those of any other function called within
+its scope, thus allowing you to see in what order functions are
+being called, and from where.
+
+This capability is particularly useful in wxPython applications,
+where exactly events occur that cause functions to be called is
+not entirely clear, and because wxPython programs can't be run
+from inside other debugging environments that have their own
+message loops.
+
+This module defines a Logger class, responsible for managing
+debugging output.  Each Logger instance can be given a name
+at construction; if this is done, '<name>:' will precede each
+logging output made by that Logger instance.
+
+The log() function this class provides takes a set of positional
+arguments that are printed in order if debugging is enabled
+(just like print does), followed by a set of keyword arguments
+that control the behavior of the log() function itself on subsequent
+calls.  The current keyword arguments are:
+
+indent
+    When set to a value of 1, this increments the current
+    indentation level, causing all subsequent dbg() outputs to be
+    indented by 3 more spaces.  When set to a value of 0,
+    this process is reversed, causing the indent to decrease by
+    3 spaces.  The default indentation level is 0.
+
+enable
+    When set to a value of 1, this turns on dbg() output for
+    for program importing this module, until told to do otherwise.
+    When set to a value of 0, dbg output is turned off.  (dbg
+    output is off by default.)
+
+suspend
+    When set to a value of 1, this increments the current
+    "suspension" level.  This makes it possible for a function
+    to temporarily suspend its and any of its dependents'
+    potential outputs that use the same Logger instance.
+    When set to a value of 0, the suspension level is
+    decremented.  When the value goes back to 0, potential
+    logging is resumed (actual output depends on the
+    "enable" status of the Logger instance in question.)
+
+wxlog
+    When set to a value of 1, the output will be sent to the
+    active wxLog target.
+
+stream
+    When set to a non-None value, the current output stream
+    (default of sys.stdout) is pushed onto a stack of streams,
+    and is replaced in the dbg system with the specified stream.
+    When called with a value of None, the previous stream will
+    be restored (if stacked.)  If set to None without previously
+    changing it will result in no action being taken.
+
+You can also call the log function implicitly on the Logger
+instance, ie. you can type::
+
+    from wx.tools.dbg import Logger
+    dbg = Logger()
+    dbg('something to print')
+
+Using this fairly simple mechanism, it is possible to get fairly
+useful debugging output in a program.  Consider the following
+code example:
+
+>>> d = {1:'a', 2:'dictionary', 3:'of', 4:'words'}
+>>> dbg = dbg.Logger('module')
+>>> dbg(enable=1)
+module: dbg enabled
+>>> def foo(d):
+...     dbg('foo', indent=1)
+...     bar(d)
+...     dbg('end of foo', indent=0)
+...
+>>> def bar(d):
+...     dbg('bar', indent=1)
+...     dbg('contents of d:', indent=1)
+...     l = d.items()
+...     l.sort()
+...     for key, value in l:
+...         dbg('%d =' % key, value)
+...     dbg(indent=0)
+...     dbg('end of bar', indent=0)
+...
+>>> foo(d)
+module: foo
+   module: bar
+      module: contents of d:
+         module: 1 = a
+         module: 2 = dictionary
+         module: 3 = of
+         module: 4 = words
+      module: end of bar
+   module: end of foo
+>>>
+
+"""
+
+
+class Logger:
+    def __init__(self, name=None):
+        import sys
+        self.name = name
+        self._indent = 0     # current number of indentations
+        self._dbg = 0        # enable/disable flag
+        self._suspend = 0    # allows code to "suspend/resume" potential dbg output
+        self._wxLog = 0      # use wxLogMessage for debug output
+        self._outstream = sys.stdout  # default output stream
+        self._outstream_stack = []    # for restoration of streams as necessary
+
+
+    def IsEnabled():
+        return self._dbg
+
+    def IsSuspended():
+        return _suspend
+
+
+    def log(self, *args, **kwargs):
+        """
+        This function provides a useful framework for generating
+        optional debugging output that can be displayed at an
+        arbitrary level of indentation.
+        """
+        if not self._dbg and not 'enable' in kwargs:
+            return
+
+        if self._dbg and len(args) and not self._suspend:
+            # (emulate print functionality; handle unicode as best as possible:)
+            strs = []
+            for arg in args:
+                try:
+                    strs.append(str(arg))
+                except:
+                    strs.append(repr(arg))
+
+            output = ' '.join(strs)
+            if self.name: output = self.name+': ' + output
+            output = ' ' * 3 * self._indent + output
+
+            if self._wxLog:
+                wx.LogMessage(output)
+            else:
+                self._outstream.write(output + '\n')
+                self._outstream.flush()
+        # else do nothing
+
+        # post process args:
+        for kwarg, value in kwargs.items():
+            if kwarg == 'indent':
+                self.SetIndent(value)
+            elif kwarg == 'enable':
+                self.SetEnabled(value)
+            elif kwarg == 'suspend':
+                self.SetSuspend(value)
+            elif kwarg == 'wxlog':
+                self.SetWxLog(value)
+            elif kwarg == 'stream':
+                self.SetStream(value)
+
+    # aliases for the log function
+    dbg = log       # backwards compatible
+    msg = log       #
+    __call__ = log  # this one lets you 'call' the instance directly
+
+
+    def SetEnabled(self, value):
+        if value:
+            old_dbg = self._dbg
+            self._dbg = 1
+            if not old_dbg:
+                self.dbg('dbg enabled')
+        else:
+            if self._dbg:
+                self.dbg('dbg disabled')
+                self._dbg = 0
+
+
+    def SetSuspend(self, value):
+        if value:
+            self._suspend += 1
+        elif self._suspend > 0:
+            self._suspend -= 1
+
+
+    def SetIndent(self, value):
+        if value:
+            self._indent += 1
+        elif self._indent > 0:
+            self._indent -= 1
+
+
+    def SetWxLog(self, value):
+        self._wxLog = value
+
+
+    def SetStream(self, value):
+        if value:
+            self._outstream_stack.append( self._outstream )
+            self._outstream = value
+        elif value is None and len(self._outstream_stack) > 0:
+            self._outstream = self._outstream_stack.pop(-1)
+
+
+#------------------------------------------------------------
+
+if __name__ == "__main__":
+    import  sys
+    import  wx
+
+    wx.Log.SetActiveTarget(wx.LogStderr())
+    logger = Logger('module')
+    dbg = logger.dbg
+    dbg(enable=1)
+    logger('test __call__ interface')
+    dbg('testing wxLog output to stderr:', wxlog=1, indent=1)
+    dbg('1,2,3...')
+    dbg('testing wx.LogNull:')
+    devnull = wx.LogNull()
+    dbg('4,5,6...') # shouldn't print, according to doc...
+    del devnull
+    dbg('(resuming to wx.LogStdErr)', '7,8,9...', indent=0)
+    dbg('disabling wx.Log output, switching to stderr:')
+    dbg(wxlog=0, stream=sys.stderr)
+    dbg(logger._outstream, 'switching back to stdout:')
+    dbg(stream=None)
+    dbg(logger._outstream )
+    def foo(str):
+        dbg('foo:', indent=1)
+        dbg(str, indent=0)
+    foo('testing dbg inside function')
+    class bar(Logger):
+        def __init__(self, name):
+            Logger.__init__(self, name)
+        def enable(self, value):
+            self.dbg(enable=value)
+        def foo(self, str):
+            self.dbg('foo:', indent=1)
+            self.dbg(str, indent=0)
+    f = bar('class mixin')
+    f.foo("shouldn't print")
+    f.enable(1)
+    f.foo("should print")
+    dbg('test completed.', enable=0)
+    dbg('(double-checking ;-)')
+

wx/tools/genaxmodule.py

@@ -0,0 +1,50 @@
+#----------------------------------------------------------------------------
+# Name:         genaxmodule.py
+# Tags:         phoenix-port
+#----------------------------------------------------------------------------
+"""
+
+
+When this script is run it will create a .py module (output to the
+current directory) containing a class derived from
+wx.activex.ActiveXWindow for the progID or CLSID given on the command
+line.  By default the class name will be used as the module name as
+well, but this is just because I am lazy, not trying to define a
+standard or anything.  Feel free to rename the module, I do.
+
+Usage:
+
+    python genax.py CLSID|progID className
+
+"""
+
+import wx
+import wx.activex
+import sys
+
+
+def main(args=None):
+    if not args:
+        args = sys.argv
+
+    if len(args) < 3:
+        print(__doc__)
+        sys.exit(1)
+
+    # unfortunatly we need to make an app, frame and an instance of
+    # the ActiceX control in order to get the TypeInfo about it...
+    app = wx.App()
+    f = wx.Frame(None, -1, "")
+    clsid = wx.activex.CLSID(args[1])
+    axw = wx.activex.ActiveXWindow(f, clsid)
+
+    wx.activex.GernerateAXModule(axw, args[2], '.', verbose=True)
+
+    # Cleanup
+    f.Close()
+    app.MainLoop()
+
+
+if __name__ == "__main__":
+    main(sys.argv)
+