#!/usr/bin/env python

#----------------------------------------------------------------------------
# Name:        Joystick.py
# Purpose:     Demonstrate use of wx.adv.Joystick
#
# Author:      Jeff Grimmett (grimmtoo@softhome.net), adapted from original
#              .wdr-derived demo
#
# Created:     02-Jan-2004
# Copyright:
# Licence:     wxWindows license
#----------------------------------------------------------------------------


import math
import wx
import wx.adv


#----------------------------------------------------------------------------

# Once all supported versions of Python support 32-bit integers on all
# platforms, this can go up to 32.
MAX_BUTTONS = 16

#----------------------------------------------------------------------------

class Label(wx.StaticText):
    # A derived StaticText that always aligns right and renders
    # in a bold font.
    def __init__(self, parent, label):
        wx.StaticText.__init__(self, parent, -1, label, style=wx.ALIGN_RIGHT)

        f = parent.GetFont()
        f.SetWeight(wx.FONTWEIGHT_BOLD)
        self.SetFont(f)

#----------------------------------------------------------------------------


class JoyGauge(wx.Panel):
    def __init__(self, parent, stick):

        self.stick = stick
        size = (100,100)

        wx.Panel.__init__(self, parent, -1, size=size)

        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)

        self.buffer = wx.Bitmap(*size)
        dc = wx.BufferedDC(None, self.buffer)
        self.DrawFace(dc)
        self.DrawJoystick(dc)


    def OnSize(self, event):
        # The face Bitmap init is done here, to make sure the buffer is always
        # the same size as the Window
        w, h  = self.GetClientSize()
        self.buffer = wx.Bitmap(w,h)
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawJoystick(dc)

    def DrawFace(self, dc):
        dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
        dc.Clear()

    def OnPaint(self, evt):
        # When dc is destroyed it will blit self.buffer to the window,
        # since no other drawing is needed we'll just return and let it
        # do it's thing
        dc = wx.BufferedPaintDC(self, self.buffer)

    def DrawJoystick(self, dc):
        # draw the gauge as a maxed square in the center of this window.
        w, h = self.GetClientSize()
        edgeSize = min(w, h)

        xorigin = (w - edgeSize) / 2
        yorigin = (h - edgeSize) / 2
        center = edgeSize / 2

        # Restrict our drawing activities to the square defined
        # above.
        dc.SetClippingRegion(int(xorigin), int(yorigin), int(edgeSize), int(edgeSize))

        dc.SetBrush(wx.Brush(wx.Colour(251, 252, 237)))
        dc.DrawRectangle(int(xorigin), int(yorigin), int(edgeSize), int(edgeSize))

        dc.SetPen(wx.Pen(wx.BLACK, 1, wx.PENSTYLE_DOT_DASH))

        dc.DrawLine(int(xorigin), int(yorigin + center), int(xorigin + edgeSize), int(yorigin + center))
        dc.DrawLine(int(xorigin + center), int(yorigin), int(xorigin + center), int(yorigin + edgeSize))

        if self.stick:
            # Get the joystick position as a float
            joyx =  float(self.stick.GetPosition().x)
            joyy =  float(self.stick.GetPosition().y)

            # Get the joystick range of motion
            xmin = self.stick.GetXMin()
            xmax = self.stick.GetXMax()
            if xmin < 0:
                xmax += abs(xmin)
                joyx += abs(xmin)
                xmin = 0
            xrange = max(xmax - xmin, 1)

            ymin = self.stick.GetYMin()
            ymax = self.stick.GetYMax()
            if ymin < 0:
                ymax += abs(ymin)
                joyy += abs(ymin)
                ymin = 0
            yrange = max(ymax - ymin, 1)

            # calc a ratio of our range versus the joystick range
            xratio = float(edgeSize) / xrange
            yratio = float(edgeSize) / yrange

            # calc the displayable value based on position times ratio
            xval = int(joyx * xratio)
            yval = int(joyy * yratio)

            # and normalize the value from our brush's origin
            x = xval + xorigin
            y = yval + yorigin

            # Now to draw it.
            dc.SetPen(wx.Pen(wx.RED, 2))
            dc.DrawLine(int(x), 0, int(x), int(h))
            dc.DrawLine(0, int(y), int(w), int(y))


    def Update(self):
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawJoystick(dc)


#----------------------------------------------------------------------------

class JoyPanel(wx.Panel):
    def __init__(self, parent, stick):

        self.stick = stick

        wx.Panel.__init__(self, parent, -1)

        sizer = wx.BoxSizer(wx.VERTICAL)

        fn = parent.GetFont()
        fn.SetPointSize(fn.GetPointSize() + 3)
        fn.SetWeight(wx.FONTWEIGHT_BOLD)

        t = wx.StaticText(self, -1, "X - Y Axes", style = wx.ALIGN_CENTRE)
        t.SetFont(fn)
        sizer.Add(t, 0, wx.ALL | wx.EXPAND, 1)

        self.control = JoyGauge(self, self.stick)
        sizer.Add(self.control, 1, wx.ALL | wx.EXPAND, 1)

        self.SetSizer(sizer)
        sizer.Fit(self)

    def Update(self):
        self.control.Update()


#----------------------------------------------------------------------------

class POVGauge(wx.Panel):
    #
    # Display the current position of the POV control
    #
    def __init__(self, parent, stick):

        self.stick = stick
        self.size = (100, 100)
        self.avail = False
        self.fourDir = False
        self.cts = False

        wx.Panel.__init__(self, parent, -1, size=self.size)

        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)

        self.buffer = wx.Bitmap(*self.size)
        dc = wx.BufferedDC(None, self.buffer)
        self.DrawFace(dc)
        self.DrawPOV(dc)


    def OnSize(self, event):
        # calculate the size of our display and make a buffer for it.
        w, h  = self.GetClientSize()
        s = min(w, h)
        self.size = (s, s)
        self.buffer = wx.Bitmap(w,h)
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawPOV(dc)

    def DrawFace(self, dc):
        dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
        dc.Clear()

    def OnPaint(self, evt):
        # When dc is destroyed it will blit self.buffer to the window,
        # since no other drawing is needed we'll just return and let it
        # do it's thing
        dc = wx.BufferedPaintDC(self, self.buffer)

    def DrawPOV(self, dc):
        # draw the gauge as a maxed circle in the center of this window.
        w, h = self.GetClientSize()
        diameter = min(w, h)

        xorigin = (w - diameter) / 2
        yorigin = (h - diameter) / 2
        xcenter = xorigin + diameter / 2
        ycenter = yorigin + diameter / 2

        # our 'raster'.
        dc.SetBrush(wx.Brush(wx.WHITE))
        dc.DrawCircle(int(xcenter), int(ycenter), int(diameter/2))
        dc.SetBrush(wx.Brush(wx.BLACK))
        dc.DrawCircle(int(xcenter), int(ycenter), 10)

        # fancy decorations
        dc.SetPen(wx.Pen(wx.BLACK, 1, wx.PENSTYLE_DOT_DASH))
        dc.DrawLine(int(xorigin), int(ycenter), int(xorigin + diameter), int(ycenter))
        dc.DrawLine(int(xcenter), int(yorigin), int(xcenter), int(yorigin + diameter))

        if self.stick:
            if self.avail:

                pos = -1

                # use the appropriate function to get the POV position
                if self.fourDir:
                    pos = self.stick.GetPOVPosition()

                if self.cts:
                    pos = self.stick.GetPOVCTSPosition()

                # trap invalid values
                if 0 <= pos <= 36000:
                    vector = 30
                else:
                    vector = 0

                # rotate CCW by 90 so that 0 is up.
                pos = (pos / 100) - 90

                # Normalize
                if pos < 0:
                    pos = pos + 360

                # Stolen from wx.lib.analogclock :-)
                radiansPerDegree = math.pi / 180
                pointX = int(round(vector * math.cos(pos * radiansPerDegree)))
                pointY = int(round(vector * math.sin(pos * radiansPerDegree)))

                # normalise value to match our actual center.
                nx = pointX + xcenter
                ny = pointY + ycenter

                # Draw the line
                dc.SetPen(wx.Pen(wx.BLUE, 2))
                dc.DrawLine(int(xcenter), int(ycenter), int(nx), int(ny))

                # And a little thing to show the endpoint
                dc.SetBrush(wx.Brush(wx.BLUE))
                dc.DrawCircle(int(nx), int(ny), 8)


    def Update(self):
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawPOV(dc)

    def Calibrate(self):
        s = self.stick
        self.avail = s.HasPOV()
        self.fourDir = s.HasPOV4Dir()
        self.cts = s.HasPOVCTS()


#----------------------------------------------------------------------------

class POVStatus(wx.Panel):
    #
    # Displays static info about the POV control
    #
    def __init__(self, parent, stick):

        self.stick = stick

        wx.Panel.__init__(self, parent, -1, size=(100, 100))

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add((20,20))

        self.avail = wx.CheckBox(self, -1, "Available")
        sizer.Add(self.avail, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)

        self.fourDir = wx.CheckBox(self, -1, "4-Way Only")
        sizer.Add(self.fourDir, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)

        self.cts = wx.CheckBox(self, -1, "Continuous")
        sizer.Add(self.cts, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)

        self.SetSizer(sizer)
        sizer.Fit(self)

        # Effectively makes the checkboxes read-only.
        self.Bind(wx.EVT_CHECKBOX, self.Calibrate)


    def Calibrate(self, evt=None):
        s = self.stick
        self.avail.SetValue(s.HasPOV())
        self.fourDir.SetValue(s.HasPOV4Dir())
        self.cts.SetValue(s.HasPOVCTS())


#----------------------------------------------------------------------------

class POVPanel(wx.Panel):
    def __init__(self, parent, stick):

        self.stick = stick

        wx.Panel.__init__(self, parent, -1, size=(100, 100))

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        gsizer = wx.BoxSizer(wx.VERTICAL)

        sizer.Add((25,25))

        fn = parent.GetFont()
        fn.SetPointSize(fn.GetPointSize() + 3)
        fn.SetWeight(wx.FONTWEIGHT_BOLD)

        t = wx.StaticText(self, -1, "POV Control", style = wx.ALIGN_CENTER)
        t.SetFont(fn)
        gsizer.Add(t, 0, wx.ALL | wx.EXPAND, 1)

        self.display = POVGauge(self, stick)
        gsizer.Add(self.display, 1, wx.ALL | wx.EXPAND, 1)
        sizer.Add(gsizer, 1, wx.ALL | wx.EXPAND, 1)

        self.status = POVStatus(self, stick)
        sizer.Add(self.status, 1, wx.ALL | wx.EXPAND, 1)

        self.SetSizer(sizer)
        sizer.Fit(self)


    def Calibrate(self):
        self.display.Calibrate()
        self.status.Calibrate()


    def Update(self):
        self.display.Update()


#----------------------------------------------------------------------------

class LED(wx.Panel):
    def __init__(self, parent, number):

        self.state = -1
        self.size = (20, 20)
        self.number = number

        fn = parent.GetFont()
        fn.SetPointSize(fn.GetPointSize() - 1)
        fn.SetWeight(wx.FONTWEIGHT_BOLD)
        self.fn = fn

        wx.Panel.__init__(self, parent, -1, size=self.size)

        self.Bind(wx.EVT_PAINT, self.OnPaint)
        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)

        self.buffer = wx.Bitmap(*self.size)
        dc = wx.BufferedDC(None, self.buffer)
        self.DrawFace(dc)
        self.DrawLED(dc)


    def OnSize(self, event):
        # calculate the size of our display.
        w, h  = self.GetClientSize()
        s = min(w, h)
        self.size = (s, s)
        self.buffer = wx.Bitmap(*self.size)
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawLED(dc)


    def DrawFace(self, dc):
        dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
        dc.Clear()


    def OnPaint(self, evt):
        # When dc is destroyed it will blit self.buffer to the window,
        # since no other drawing is needed we'll just return and let it
        # do it's thing
        dc = wx.BufferedPaintDC(self, self.buffer)


    def DrawLED(self, dc):
        # bitmap size
        bw, bh = self.size

        # center of bitmap
        center = bw / 2

        # calc the 0, 0 origin of the bitmap
        xorigin = center - (bw / 2)
        yorigin = center - (bh / 2)

        # our 'raster'.
        if self.state == 0:
            dc.SetBrush(wx.Brush(wx.RED))
        elif self.state == 1:
            dc.SetBrush(wx.Brush(wx.GREEN))
        else:
            dc.SetBrush(wx.Brush(wx.BLACK))

        dc.DrawCircle(int(center), int(center), int(bw/2))

        txt = str(self.number)

        # Set the font for the DC ...
        dc.SetFont(self.fn)
        # ... and calculate how much space our value
        # will take up.
        fw, fh = dc.GetTextExtent(txt)

        # Calc the center of the LED, and from that
        # derive the origin of our value.
        tx = center - (fw/2)
        ty = center - (fh/2)

        # I draw the value twice so as to give it a pseudo-shadow.
        # This is (mostly) because I'm too lazy to figure out how
        # to blit my text onto the gauge using one of the logical
        # functions. The pseudo-shadow gives the text contrast
        # regardless of whether the bar is under it or not.
        dc.SetTextForeground(wx.WHITE)
        dc.DrawText(txt, int(tx), int(ty))



    def Update(self):
        dc = wx.BufferedDC(wx.ClientDC(self), self.buffer)
        self.DrawFace(dc)
        self.DrawLED(dc)


#----------------------------------------------------------------------------

class JoyButtons(wx.Panel):
    def __init__(self, parent, stick):

        self.stick = stick
        self.leds = {}

        wx.Panel.__init__(self, parent, -1)

        tsizer = wx.BoxSizer(wx.VERTICAL)

        fn = parent.GetFont()
        fn.SetPointSize(fn.GetPointSize() + 3)
        fn.SetWeight(wx.FONTWEIGHT_BOLD)

        t = wx.StaticText(self, -1, "Buttons", style = wx.ALIGN_LEFT)
        t.SetFont(fn)
        tsizer.Add(t, 0, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 1)

        sizer = wx.FlexGridSizer(4, 16, 2, 2)

        fn.SetPointSize(parent.GetFont().GetPointSize() + 1)

        for i in range(0, MAX_BUTTONS):
            t = LED(self, i)
            self.leds[i] = t
            sizer.Add(t, 1, wx.ALL|wx.ALIGN_CENTER|wx.ALIGN_CENTER_VERTICAL, 1)
            sizer.AddGrowableCol(i)

        tsizer.Add(sizer, 1, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 1)

        self.SetSizer(tsizer)
        tsizer.Fit(self)

    def Calibrate(self):
        for i in range(0, MAX_BUTTONS):
            self.leds[i].state = -1

        t = self.stick.GetNumberButtons()

        for i in range(0, t):
            self.leds[i].state = 0

    def Update(self):
        t = self.stick.GetButtonState()

        for i in range(0, MAX_BUTTONS):
            if self.leds[i].state == 1:
                self.leds[i].state = 0

            if (t & (1<<i)):
                self.leds[i].state = 1

            self.leds[i].Update()


#----------------------------------------------------------------------------

class InfoPanel(wx.Panel):
    def __init__(self, parent, stick):

        self.stick = stick

        wx.Panel.__init__(self, parent, -1)

        sizer = wx.GridBagSizer(1, 1)

        sizer.Add(Label(self, 'Mfr ID: '), (0, 0), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.MfgID = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.MfgID, (0, 1), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        sizer.Add(Label(self, 'Prod Name: '), (0, 2), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.ProdName = wx.TextCtrl(self, -1, value='', style=wx.TE_READONLY)
        sizer.Add(self.ProdName, (0, 3), (1, 3), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        sizer.Add(Label(self, 'Threshold: '), (0, 6), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.Threshold = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.Threshold, (0, 7), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        #----------------------------------------------------------------------------
        b = wx.Button(self, -1, "Calibrate")
        sizer.Add(b, (1, 0), (2, 2), wx.ALL | wx.ALIGN_CENTER, 2)

        sizer.Add(Label(self, '# of Sticks: '), (1, 2), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.NumJoysticks = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.NumJoysticks, (1, 3), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        sizer.Add(Label(self, '# of Axes: '), (1, 4), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.NumAxis = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.NumAxis, (1, 5), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        sizer.Add(Label(self, 'Max # Axes: '), (1, 6), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.MaxAxis = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.MaxAxis, (1, 7), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        #----------------------------------------------------------------------------

        sizer.Add(Label(self, 'Polling -- '), (2, 3), (1, 1), wx.ALL | wx.GROW, 2)

        sizer.Add(Label(self, 'Min: '), (2, 4), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.PollMin = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.PollMin, (2, 5), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        sizer.Add(Label(self, 'Max: '), (2, 6), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_RIGHT, 2)
        self.PollMax = wx.TextCtrl(self, -1, value='', size=(45, -1), style=wx.TE_READONLY)
        sizer.Add(self.PollMax, (2, 7), (1, 1), wx.ALL | wx.GROW | wx.ALIGN_LEFT, 2)

        #----------------------------------------------------------------------------

        self.SetSizer(sizer)
        sizer.Fit(self)


    def Calibrate(self):
        if not self.stick:
            return

        s = self.stick

        self.MfgID.SetValue(str(s.GetManufacturerId()))
        self.ProdName.SetValue(str(s.GetProductName()))
        self.Threshold.SetValue(str(s.GetMovementThreshold()))
        self.NumJoysticks.SetValue(str(s.GetNumberJoysticks()))
        self.NumAxis.SetValue(str(s.GetNumberAxes()))
        self.MaxAxis.SetValue(str(s.GetMaxAxes()))
        self.PollMin.SetValue(str(s.GetPollingMin()))
        self.PollMax.SetValue(str(s.GetPollingMax()))


#----------------------------------------------------------------------------

class AxisBar(wx.Gauge):
    #
    # This class allows us to use a wx.Gauge to display the axis value
    # with a fancy label overlaid onto the gauge itself. Two values are
    # used to do things: first of all, since the gauge is limited to
    # positive numbers, the scale is fixed at 0 to 1000. We will receive
    # an adjusted value to use to render the gauge itself. The other value
    # is a raw value and actually reflects the value from the joystick itself,
    # which is then drawn over the gauge.
    #
    def __init__(self, parent):
        wx.Gauge.__init__(self, parent, -1, 1000, size=(-1, 20), style = wx.GA_HORIZONTAL | wx.GA_SMOOTH )

        # This is the value we will display.
        self.rawvalue = 0

        self.SetBackgroundColour('light blue')
        self.SetForegroundColour('orange')

        # NOTE: See comment below
        # # Capture paint events for purpose of updating
        # # the displayed value.
        # self.Bind(wx.EVT_PAINT, self.onPaint)

    def Update(self, value, rawvalue):
        # Updates the gauge itself, sets the raw value for
        # the next EVT_PAINT
        self.SetValue(value)
        self.rawvalue = rawvalue

    def onPaint(self, evt):
        # Must always create a PaintDC when capturing
        # an EVT_PAINT event
        self.ShowValue(wx.PaintDC(self), evt)

    def ShowValue(self, dc, evt):
        # This method handles actual painting of and drawing
        # on the gauge.

        # Clear out the gauge
        dc.Clear()

        # NOTE: in Classic we exposed wxWindow::OnPaint for MSW, so the default
        #       paint behavior can be triggered and then we can draw on top of
        #       that after the native OnPaint is done. For Phoenix, I chose to
        #       not do this any more, so this breaks. Not sure this is really
        #       needed for this demo, but if so then we'll nede to find another
        #       way to do this. In the meantime, this is commented out, and the
        #       Paint event will also not be captured at all.

        # # and then carry out business as usual
        # wx.Gauge.OnPaint(self, evt)

        # This is the size available to us.
        w, h = dc.GetSize()

        # This is what we will overlay on the gauge.
        # It reflects the actual value received from the
        # wx.adv.Joystick.
        txt = str(self.rawvalue)

        # Copy the default font, make it bold.
        fn = self.GetParent().GetFont()
        fn.SetWeight(wx.FONTWEIGHT_BOLD)

        # Set the font for the DC ...
        dc.SetFont(fn)
        # ... and calculate how much space our value
        # will take up.
        fw, fh = dc.GetTextExtent(txt)

        # Calc the center of the gauge, and from that
        # derive the origin of our value.
        center = w / 2
        tx = center - (fw/2)

        center = h / 2
        ty = center - (fh/2)

        # I draw the value twice so as to give it a pseudo-shadow.
        # This is (mostly) because I'm too lazy to figure out how
        # to blit my text onto the gauge using one of the logical
        # functions. The pseudo-shadow gives the text contrast
        # regardless of whether the bar is under it or not.
        dc.SetTextForeground(wx.BLACK)
        dc.DrawText(txt, int(tx), int(ty))

        dc.SetTextForeground('white')
        dc.DrawText(txt, int(tx-1), int(ty-1))


#----------------------------------------------------------------------------

class Axis(wx.Panel):
    #
    # This class is a container for the min, max, and current
    # values of the joystick axis in question. It contains
    # also special features to render a 'dummy' if the axis
    # in question is not available.
    #
    def __init__(self, parent, token, stick):

        self.stick = stick

        #
        # token represents the type of axis we're displaying.
        #
        self.token = token

        #
        # Create a call to the 'Has*()' method for the stick.
        # X and Y are always there, so we tie the Has* method
        # to a hardwired True value.
        #
        if token not in ['X', 'Y']:
            self.HasFunc = eval('stick.Has%s' % token)
        else:
            self.HasFunc = self.alwaysTrue

        # Now init the panel.
        wx.Panel.__init__(self, parent, -1)

        sizer = wx.BoxSizer(wx.HORIZONTAL)

        if self.HasFunc():
            #
            # Tie our calibration functions to the appropriate
            # stick method. If we don't have the axis in question,
            # we won't need them.
            #
            self.GetMin = eval('stick.Get%sMin' % token)
            self.GetMax = eval('stick.Get%sMax' % token)

            # Create our displays and set them up.
            self.Min = wx.StaticText(self, -1, str(self.GetMin()), style=wx.ALIGN_RIGHT)
            self.Max = wx.StaticText(self, -1, str(self.GetMax()), style=wx.ALIGN_LEFT)
            self.bar = AxisBar(self)

            sizer.Add(self.Min, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
            sizer.Add(self.bar, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
            sizer.Add(self.Max, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)

        else:
            # We go here if the axis in question is not available.
            self.control = wx.StaticText(self, -1, '       *** Not Present ***')
            sizer.Add(self.control, 1, wx.ALL, 1)

        #----------------------------------------------------------------------------

        self.SetSizer(sizer)
        sizer.Fit(self)
        wx.CallAfter(self.Update)


    def Calibrate(self):
        if not self.HasFunc():
            return

        self.Min.SetLabel(str(self.GetMin()))
        self.Max.SetLabel(str(self.GetMax()))


    def Update(self):
        # Don't bother if the axis doesn't exist.
        if not self.HasFunc():
            return

        min = int(self.Min.GetLabel())
        max = int(self.Max.GetLabel())

        #
        # Not all values are available from a wx.JoystickEvent, so I've elected
        # to not use it at all. Therefore, we are getting our values direct from
        # the stick. These values also seem to be more stable and reliable than
        # those received from the event itself, so maybe it's a good idea to
        # use the stick directly for your program.
        #
        # Here we either select the appropriate member of stick.GetPosition() or
        # apply the appropriate Get*Position method call.
        #
        if self.token == 'X':
            val = self.stick.GetPosition().x
        elif self.token == 'Y':
            val = self.stick.GetPosition().y
        else:
            val = eval('self.stick.Get%sPosition()' % self.token)


        #
        # While we might be able to rely on a range of 0-FFFFFF on Win, that might
        # not be true of all drivers on all platforms. Thus, calc the actual full
        # range first.
        #
        if min < 0:
            max += abs(min)
            val += abs(min)
            min = 0
        range = float(max - min)

        #
        # The relative value is used by the derived wx.Gauge since it is a
        # positive-only control.
        #
        relative = 0
        if range:
            relative = int( val / range * 1000)

        #
        # Pass both the raw and relative values to the derived Gauge
        #
        self.bar.Update(relative, val)


    def alwaysTrue(self):
        # a dummy method used for X and Y axis.
        return True


#----------------------------------------------------------------------------

class AxisPanel(wx.Panel):
    #
    # Contained herein is a panel that offers a graphical display
    # of the levels for all axes supported by wx.adv.Joystick. If
    # your system doesn't have a particular axis, it will be
    # 'dummied' for transparent use.
    #
    def __init__(self, parent, stick):

        self.stick = stick

        # Defines labels and 'tokens' to identify each
        # supported axis.
        axesList = [
            ('X Axis ', 'X'),   ('Y Axis ', 'Y'),
            ('Z Axis ', 'Z'),   ('Rudder ', 'Rudder'),
            ('U Axis ', 'U'),   ('V Axis ', 'V')
            ]

        # Contains a list of all axis initialized.
        self.axes = []

        wx.Panel.__init__(self, parent, -1)

        sizer = wx.FlexGridSizer(3, 4, 1, 1)
        sizer.AddGrowableCol(1)
        sizer.AddGrowableCol(3)

        #----------------------------------------------------------------------------

        # Go through the list of labels and tokens and add a label and
        # axis display to the sizer for each.
        for label, token in axesList:
            sizer.Add(Label(self, label), 0, wx.ALL | wx.ALIGN_RIGHT, 2)
            t = Axis(self, token, self.stick)
            self.axes.append(t)
            sizer.Add(t, 1, wx.ALL | wx.EXPAND | wx.ALIGN_LEFT, 2)

        #----------------------------------------------------------------------------

        self.SetSizer(sizer)
        sizer.Fit(self)
        wx.CallAfter(self.Update)

    def Calibrate(self):
        for i in self.axes:
            i.Calibrate()

    def Update(self):
        for i in self.axes:
            i.Update()


#----------------------------------------------------------------------------

class JoystickDemoPanel(wx.Panel):

    def __init__(self, parent, log):

        self.log = log

        wx.Panel.__init__(self, parent, -1)

        # Try to grab the control. If we get it, capture the stick.
        # Otherwise, throw up an exception message and play stupid.
        try:
            self.stick = wx.adv.Joystick()
            self.stick.SetCapture(self)
            # Calibrate our controls
            wx.CallAfter(self.Calibrate)
            wx.CallAfter(self.OnJoystick)
        except NotImplementedError as v:
            wx.MessageBox(str(v), "Exception Message")
            self.stick = None

        # One Sizer to Rule Them All...
        sizer = wx.GridBagSizer(2,2)

        self.info = InfoPanel(self, self.stick)
        sizer.Add(self.info, (0, 0), (1, 3), wx.ALL | wx.GROW, 2)

        self.info.Bind(wx.EVT_BUTTON, self.Calibrate)

        self.joy = JoyPanel(self, self.stick)
        sizer.Add(self.joy, (1, 0), (1, 1), wx.ALL | wx.GROW, 2)

        self.pov = POVPanel(self, self.stick)
        sizer.Add(self.pov, (1, 1), (1, 2), wx.ALL | wx.GROW, 2)

        self.axes = AxisPanel(self, self.stick)
        sizer.Add(self.axes, (2, 0), (1, 3), wx.ALL | wx.GROW, 2)

        self.buttons = JoyButtons(self, self.stick)
        sizer.Add(self.buttons, (3, 0), (1, 3), wx.ALL | wx.EXPAND | wx.ALIGN_CENTER | wx.ALIGN_CENTER_VERTICAL, 1)

        self.SetSizer(sizer)
        sizer.Fit(self)

        # Capture Joystick events (if they happen)
        self.Bind(wx.EVT_JOYSTICK_EVENTS, self.OnJoystick)
        self.stick.SetMovementThreshold(10)


    def Calibrate(self, evt=None):
        # Do not try this without a stick
        if not self.stick:
            return

        self.info.Calibrate()
        self.axes.Calibrate()
        self.pov.Calibrate()
        self.buttons.Calibrate()


    def OnJoystick(self, evt=None):
        if not self.stick:
            return

        self.axes.Update()
        self.joy.Update()
        self.pov.Update()
        if evt is not None and evt.IsButton():
            self.buttons.Update()


    def ShutdownDemo(self):
        if self.stick:
            self.stick.ReleaseCapture()
        self.stick.Destroy()
        self.stick = None

#----------------------------------------------------------------------------

def runTest(frame, nb, log):
    if not wx.adv.USE_JOYSTICK:
        from wx.lib.msgpanel import MessagePanel
        win = MessagePanel(nb, 'wx.Joystick is not available on this platform.',
                        'Sorry', wx.ICON_WARNING)
        return win

    elif wx.adv.Joystick.GetNumberJoysticks() != 0:
        win = JoystickDemoPanel(nb, log)
        return win

    else:
        from wx.lib.msgpanel import MessagePanel
        win = MessagePanel(nb, 'No joysticks are found on this system.',
                           'Sorry', wx.ICON_WARNING)
        return win


#----------------------------------------------------------------------------

overview = """\
<html>
<body>
<h1>wx.adv.Joystick</h1>
This demo illustrates the use of the wx.adv.Joystick class, which is an interface to
one or more joysticks attached to your system.

<p>The data that can be retrieved from the joystick comes in four basic flavors.
All of these are illustrated in the demo. In fact, this demo illustrates everything
you <b>can</b> get from the wx.adv.Joystick control.

<ul>
<li>Static information such as Manufacturer ID and model name,
<li>Analog input from up to six axes, including X and Y for the actual stick,
<li>Button input from the fire button and any other buttons that the stick has,
<li>and the POV control (a kind of mini-joystick on top of the joystick) that many sticks come with.
</ul>

<p>Getting data from the joystick can be event-driven thanks to four event types associated
with wx.JoystickEvent, or the joystick can be polled programmatically to get data on
a regular basis.

<h2>Data types</h2>

Data from the joystick comes in two flavors: that which defines the boundaries, and that
which defines the current state of the stick. Thus, we have Get*Max() and Get*Min()
methods for all axes, the max number of axes, the max number of buttons, and so on. In
general, this data can be read once and stored to speed computation up.

<h3>Analog Input</h3>

Analog input (the axes) is delivered as a whole, positive number. If you need to know
if the axis is at zero (centered) or not, you will first have to calculate that center
based on the max and min values. The demo shows a bar graph for each axis expressed
in native numerical format, plus a 'centered' X-Y axis compass showing the relationship
of that input to the calculated stick position.

Analog input may be jumpy and spurious, so the control has a means of 'smoothing' the
analog data by setting a movement threshold. This demo sets the threshold to 10, but
you can set it at any valid value between the min and max.

<h3>Button Input</h3>

Button state is retrieved as one int that contains each button state mapped to a bit.
You get the state of a button by AND-ing its bit against the returned value, in the form

<pre>
     # assume buttonState is what the stick returned, and buttonBit
     # is the bit you want to examine

     if (buttonState & ( 1 &lt;&lt; buttonBit )) :
         # button pressed, do something with it
</pre>

<p>The problem here is that some OSs return a 32-bit value for up to 32 buttons
(imagine <i>that</i> stick!). Python V2.3 will generate an exception for bit
values over 30. For that reason, this demo is limited to 16 buttons.

<p>Note that more than one button can be pressed at a time, so be sure to check all of them!


<h3>POV Input</h3>

POV hats come in two flavors: four-way, and continuous. four-way POVs are restricted to
the cardinal points of the compass; continuous, or CTS POV hats can deliver input in
.01 degree increments, theoretically. The data is returned as a whole number; the last
two digits are considered to be to the right of the decimal point, so in order to
use this information, you need to divide by 100 right off the bat.

<p>Different methods are provided to retrieve the POV data for a CTS hat
versus a four-way hat.

<h2>Caveats</h2>

The wx.adv.Joystick control is in many ways incomplete at the C++ library level, but it is
not insurmountable.  In short, while the joystick interface <i>can</i> be event-driven,
the wx.JoystickEvent class lacks event binders for all event types. Thus, you cannot
rely on wx.JoystickEvents to tell you when something has changed, necessarily.

<ul>
<li>There are no events associated with the POV control.
<li>There are no events associated with the Rudder
<li>There are no events associated with the U and V axes.
</ul>

<p>Fortunately, there is an easy workaround. In the top level frame, create a wx.Timer
that will poll the stick at a set interval. Of course, if you do this, you might as
well forgo catching wxEVT_JOYSTICK_* events at all and rely on the timer to do the
polling.

<p>Ideally, the timer should be a one-shot; after it fires, collect and process data as
needed, then re-start the timer, possibly using wx.CallAfter().

</body>
</html>
"""

#----------------------------------------------------------------------------

if __name__ == '__main__':
    import sys,os
    import run
    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
