Hi, I have continued my experiments with the fantastic wxPython library.

Today I had to create a simple grid, so I followed some tutorials and read some documentation on how to use wx.grid.Grid along with wx.grid.PyGridTableBase, in a very MVC-ish fashion. The thing is, that I correctly set up both (you can look up tutorials online on how to use them, or the fantastic wxPython in Action book (which was published back in 2006, making it a little bit old, but very a very useful and educational resource nonetheless). But when invoking the AppendRows or DeleteRows on the grid, I saw no change in the Grid’s presentation (although I double checked that the table’s AppendRows and DeleteRows where called accordingly).

But thanks to the wonders of the lazyweb, I found my answer in this very useful post:

http://groups.google.com/group/wxpython-users/msg/f02fb345ef0b35cf

So, all I had to do was to send the corresponding message  on my table’s AppendRows and DeleteRows methods and all worked just fine.

Hope you find that useful too.

Hello!, this is my first real post.

I will say something about my latest project.

It is a system for writing soil descriptions for use in  archaeology. It will be written in python using wxpython for the GUI, this will allow the program to be used on many different OS’s. It will probably be form-based.

The name is going to be Podzel, or pyPodzel.

If I get the time from doing coursework etc. I will write this.

Let me clear first. I am a Python guy, most of my projects are written in Python programming language. I only had a few small projects written in Java before, I was never a Java guy. However, I do know the power of Java and now, I think it’s time to take advantage of Java, for powerful GUI toolkit.

People who want to develop GUI applications in Python always come into a question, “Which GUI toolkit should I use?” I tried Tk a few years ago, which comes with Python standard library, but definitely is not a good choice for large projects. Then I switched to wxPython, which is much better than Tk, but I was still unsatisfying with its GUI design tool. Finally, I met Qt.

Qt probably is the best GUI toolkit right there in my opinion. Though there are some Python bindings for Qt like PyQt and PySide, I found that both of them are not useful for me because PyQt is still only available under GPL and commercial licenses even though Qt is available under LGPL license since version 4.5, and PySide just seems not ready for Windows and Mac users.

Finally, I decided to use Qt Jambi, which is the Qt library made available for Java, and is officially supported by Nokia Corporation. My original thought was to use Qt Jambi with Jython, so I can take advantage of both Java and Python, and able to develop my applications under LGPL license.

The first step to a new programming language or library is always a simple “Hello World!” application, but I found that I was in trouble when I was following the official documentation, and that’s why I wrote this article. Here’s my working environment:

Before you start writing your “Hello World” application. You should make sure everything is working fine, this could be done by launching the Demo Launcher application included in Qt Jambi. Go open a Terminal window and change directory to the Qt Jambi installation directory. Then try to execute the `qtjambi.sh` script. If something is going wrong, simply open the `qtjambi.sh` file and find a line near the end of the file:

java -XstartOnFirstThread -cp $CP com.trolltech.launcher.Launcher

Then, add `-d32` after `java` like this:

java -d32 -XstartOnFirstThread -cp $CP com.trolltech.launcher.Launcher

Now execute the `qtjambi.sh` script again and everything should work fine now.

Next, we need to setup the environment for our Jambi applications. I made this by adding some lines to `.profile` file under my user’s home directory. You need to create one if you don’t have it yet. Once you have this file, add following lines to the button of the file:

# Qt Jambi
export QTDIR=/Users/olliwang/workspace/qtjambi-mac-lgpl-4.5.2_01
export DYLD_LIBRARY_PATH=$QTDIR/lib:$DYLD_LIBRARY_PATH
export QT_PLUGIN_PATH=$QTDIR/plugins
for lib in $(ls $QTDIR/qtjambi*.jar); do
    CLASSPATH=$lib:$CLASSPATH
done
export CLASSPATH

Note that only the `QTDIR` variable located in second line should be modified to point to your Qt Jambi installation directory. After you done, we can start make our “Hello World” application now.

Before you write your “Hello World” application, you need to choose a directory to place your Java source code, not the Qt Jambi installation directory, please. I created a new directory and switched directory to it in my Terminal window. Now you can create a file called “HelloWorld.java” and write the following code (borrowed from the Qt Jambi official documentation):

import com.trolltech.qt.gui.*;

public class HelloWorld
{
    public static void main(String[] args)
    {
        QApplication.initialize(args);
        QPushButton hello = new QPushButton("Hello World!");
        hello.resize(120, 40);
        hello.setWindowTitle("Hello World");
        hello.show();
        QApplication.exec();
    }
}

After saving that file, back to your Terminal window, and compile the source code by running

javac HelloWorld.java

Finally, you can execute the application by running

java -d32 -XstartOnFirstThread HelloWorld

And the result should look like this:

Done!

wxPython in Action

Noel Rappin & Robin Dunn

Al crear una wx.Frame,

class Frame(wx.Frame):
    def __init__(self, *args, **kwds):
        #MyFrame.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)

esta tendra el estilo wx.DEFAULT_FRAME_STYLE.

Este es una suma de estilos basicos: wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX | wx.RESIZE_BORDER |wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX.
Para cambiar un estilo individual en una composición de estilo se usa el operador or ‘^’.
Necesito crear una ventana basada en el estilo default pero que no pueda cambiar su tamaño.
Para ello al estilo default le quito maximizar , minimizar y que no sea redimencionable la composición quedaría asi:
kwds["style"]=wx.DEFAULT_FRAME_STYLE^(wx.MINIMIZE_BOX|wx.MAXIMIZE_BOX |wx.RESIZE_BORDER))
Esto permitiría ver una ventana de este tipo:

Let me begin with this: wxPython is fantastic! I could write a moderately simple app in ~17 hours which automates a task that is normally done manually loading data into a web form. The app consists on custom wizard classes, access to web resources (requesting and parsing) and session management with cookies. I’m impressed that I could finish the application, with no previous knowledge on any of the aforementioned subjects, in such a short time span.

Publicity aside, I faced a little problem. I packed the python application into an executable that didn’t require a full python install using the py2exe extension, after reading the guide on how to get py2exe to work with wxPython. My first problem was some silly issue with some MSCV*.dll files:

*** finding dlls needed ***
error: MSVCP90.dll: No such file or directory

After a quick read on several places, I found a simple solution for this problem, ignoring the dll file when building  the executables.

With that solved, I could successfully build and launch my application. The less obvious problem was, that even though the application launched it looked ugly! Here’s a screenshot on what I was getting when running the generated exe vs running the .py file directly:

Hideous indeed. The problem was that for some reason the application was not using XP Themes when drawing the application’s widgets, and after some reading I discovered that there are some serious issues regarding Python2.6 (the version I’m using), wxPython and py2exe when it comes to manifests. Long story short, I had to associate a correct manifest to my exe file, and after lurking around my Python installs, I found a manifest that wxPython creates for Python that served my needs:

<?xml version='1.0' encoding='UTF-8' standalone='yes'?>
<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
    <security>
      <requestedPrivileges>
        <requestedExecutionLevel level='asInvoker' uiAccess='false' />
      </requestedPrivileges>
    </security>
  </trustInfo>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity
     type='win32'
     name='Microsoft.VC90.CRT'
     version='9.0.21022.8'
     processorArchitecture='*'
     publicKeyToken='1fc8b3b9a1e18e3b' />
    </dependentAssembly>
  </dependency>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity
         type="win32"
         name="Microsoft.Windows.Common-Controls"
         version="6.0.0.0"
         processorArchitecture="*"
         publicKeyToken="6595b64144ccf1df"
         language="*" />
    </dependentAssembly>
  </dependency>
</assembly>

Both the “Microsoft.VC90.CRT” and “Microsoft.Windows.Common-Controls” assemblies are important. The first one is mandatory for Python >= 2.6 is built with Visual Studio 2008, and the second one is the one that links our app to the dlls that provide the nice XP Theme widgets.

Just loaded that text into a string (called manifest in my case) in my setup.py file and passed it as an  argument to the setup function like this:

setup(windows=[{
               'script':"app.py",
               'other_resources' : [(24, 1, manifest)]
               }],
        name = "My App",
        version="0.1"
    )

Easy as pie .

Hope you find this useful!

Hacer lista con consulta a db

Cambio del diseño; como los datos de la primera columna están en la base de datos (apellido, nombre y documento) se decidió colocar dentro de la grilla un combobox donde seleccionar estos datos del alumno.
La segunda columna de la grilla quedo igual, con un ComboBox dentro.
Para hacer esto se conecta a la db y se hace la consulta.

tChoiceEditor = wx.grid.GridCellChoiceEditor(['Padre ',
 'Madre','Tio/a ','Primo/a','Hermano/a', 'Madrina',
'Padrino','Vecino/a'] , allowOthers=True)
 c.execute('''select apellidos, nombres, documento from
 alumnos order by apellidos''')
        q = c.fetchall()
        c.close() 

Luego se crea una lista vacia ‘lista’, se recorre la variable q, que tiene los datos del fetchall a la db con un for buscando por el indice de q(q[0]) cada dato en la lista.

lista = []
        for i in q:
            lista.append(i[0]+" "+ i[1]+" "+ i[2])

Se carga a la lista que luego va a usar el tChoiceEditor2 para mostrar en el ComboBox que esta dentro de la grilla.

tChoiceEditor2 = wx.grid.GridCellChoiceEditor(lista, allowOthers=True)
        #Asignar a los editores de la célula  la  fila y la columna.
        self.grid_parientes.SetCellEditor(0, 1, tChoiceEditor)
        self.grid_parientes.SetCellEditor(0, 0, tChoiceEditor2)
        #lista
        # Mostrar el tercer elemento de la lista en la celda ChoiceEditor
        #en este caso esta vacia, asi que no aparecera nada
        self.grid_parientes.SetCellValue(0, 1, self.grid_parientes.list[0][5])

El código completo y funcional de este formulario se llama ingreso_datos.py y es parte del proyecto relaxtives.

Como la lista editable que agrega filas de la entrada anterior, tiene en la segunda columna varios datos pre establecidos, se penso poner un combo box con todas las opciones.

Se describe brevemente en los comentarios del codigo como se implemento este agregado

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# generated by wxGlade 0.6.3 on Sun Aug 16 16:45:13 2009

import wx
import wx.grid

# begin wxGlade: extracode
# end wxGlade

class MyFrame(wx.Frame):

    def __init__(self, *args, **kwds):
        self.rows = 0
        self.fila = 0
        # begin wxGlade: MyFrame.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.button_1 = wx.Button(self, -1, "Agregar")
        self.button_2 = wx.Button(self, -1, "Quitar")
        self.grid_1 = wx.grid.Grid(self, -1, size=(1, 1))

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.OnAgregar, self.button_1)
        self.Bind(wx.EVT_BUTTON, self.OnQuitar, self.button_2)
        #bindeo evento
        self.grid_1.Bind(wx.grid.EVT_GRID_EDITOR_CREATED, self.OnGrid1GridEditorCreated)
        # end wxGlade

    def __set_properties(self):
        # begin wxGlade: MyFrame.__set_properties
        self.SetTitle("Lista editable")
        self.SetSize((400, 300))
        self.Center()
        self.grid_1.CreateGrid(1, 2)
        self.grid_1.SetRowLabelSize(0)
        self.grid_1.SetColLabelSize(30)
        self.grid_1.SetColLabelValue(0, "Nombre")
        self.grid_1.SetColLabelValue(1, "Pariente")
        # Crear la GridCellChoiceEditor con una lista en blanco. Los artículos serán
        # agregados más tarde, en tiempo de ejecución. "allowOthers" permite al usuario
        # crear nuevos elementos de selección sobre la marcha.
        tChoiceEditor = wx.grid.GridCellChoiceEditor([], allowOthers=True)
        #Asignar a los editores de la célula de la primera fila y segunda columna(fila 0).
        self.grid_1.SetCellEditor(0, 1, tChoiceEditor)
        #lista
        self.grid_1.list = ['Padre ', 'Madre','Tio/a ','Primo/a','Hermano/a', 'Abuelo/a','Vecino/a']
        #Mostrar el primer elemento de la lista en la celda ChoiceEditor
        #en este caso esta vacia, asi que no aparecera nada
        self.grid_1.SetCellValue(0, 1, self.grid_1.list[0][5])

        # end wxGlade

    def __do_layout(self):
        # begin wxGlade: MyFrame.__do_layout
        sizer_1 = wx.BoxSizer(wx.VERTICAL)
        sizer_2 = wx.BoxSizer(wx.VERTICAL)
        sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_3.Add(self.button_1, 0, wx.ALIGN_BOTTOM |wx.ADJUST_MINSIZE, 0)
        sizer_3.Add(self.button_2, 0, wx.ALIGN_BOTTOM |wx.ADJUST_MINSIZE, 0)
        sizer_2.Add(sizer_3, 1, wx.EXPAND, 0)
        sizer_2.Add(self.grid_1, 1, wx.EXPAND, 0)
        sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
        self.SetSizer(sizer_1)
        self.Layout()
        # end wxGlade

    def OnAgregar(self, event): # wxGlade: MyFrame.
        self.grid_1.ForceRefresh()
        self.fila += 1
        #Se agrega una fila
        self.grid_1.AppendRows()
        self.grid_1.MakeCellVisible(self.rows, 0)
        self.grid_1.ForceRefresh()
        #Se agrega el comboBox
        tChoiceEditor = wx.grid.GridCellChoiceEditor([], allowOthers=True)
        self.grid_1.SetCellEditor(self.fila, 1, tChoiceEditor)
        #lista
        self.grid_1.SetCellValue(self.fila, 1, self.grid_1.list[0][5])
        self.rows += 1

    def OnQuitar(self, event): # wxGlade: MyFrame.

        if self.rows > 0:
            self.grid_1.DeleteRows(self.rows)
            self.grid_1.ForceRefresh()
            self.rows -= 1
            #Cuando quito una fila tambien debo quitar self.fila
            self.fila -= 1

    def OnGrid1GridEditorCreated(self, event):
        #toma el numero de columna
        Col = event.GetCol()
        if Col == 1 :
            #Obtiene una referencia al control ComboBox subyacente
            self.comboBox = event.GetControl()
            #Cargar la lista de opciones iniciales.
            for (item) in self.grid_1.list:

                self.comboBox.Append(item)

        event.Skip()

# end of class MyFrame

class MyApp(wx.App):
    def OnInit(self):
        wx.InitAllImageHandlers()
        frame_1 = MyFrame(None, -1, "")
        self.SetTopWindow(frame_1)
        frame_1.Show()
        return 1

# end of class MyApp

if __name__ == "__main__":
    app = MyApp(0)
    app.MainLoop()

Para el proyecto relaxtives me pidieron una lista editable de dos columnas que agregué filas, tipo las que tiene wxGlade en el control ComboBox en la solapa widget.
El Jefe del proyecto consiguió el código fuente a través de la página web del proyecto wxGlade. En base a el armé este control.

Este es el código.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# generated by wxGlade 0.6.3 on Sun Aug 16 16:45:13 2009

import wx
import wx.grid

# begin wxGlade: extracode
# end wxGlade

class MyFrame(wx.Frame):

    def __init__(self, *args, **kwds):
        self.rows = 0
        # begin wxGlade: MyFrame.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.button_1 = wx.Button(self, -1, "Agregar")
        self.button_2 = wx.Button(self, -1, "Quitar")
        self.grid_1 = wx.grid.Grid(self, -1, size=(1, 1))

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.OnAgregar, self.button_1)
        self.Bind(wx.EVT_BUTTON, self.OnQuitar, self.button_2)
        # end wxGlade

    def __set_properties(self):
        # begin wxGlade: MyFrame.__set_properties
        self.SetTitle("Lista editable")
        self.SetSize((400, 300))
        self.grid_1.CreateGrid(1, 2)
        self.grid_1.SetRowLabelSize(0)
        self.grid_1.SetColLabelSize(30)
        self.grid_1.SetColLabelValue(0, "Nombre")
        self.grid_1.SetColLabelValue(1, "Pariente")
        # end wxGlade

    def __do_layout(self):
        # begin wxGlade: MyFrame.__do_layout
        sizer_1 = wx.BoxSizer(wx.VERTICAL)
        sizer_2 = wx.BoxSizer(wx.VERTICAL)
        sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
        sizer_3.Add(self.button_1, 0, wx.ALIGN_BOTTOM |wx.ADJUST_MINSIZE, 0)
        sizer_3.Add(self.button_2, 0, wx.ALIGN_BOTTOM |wx.ADJUST_MINSIZE, 0)
        sizer_2.Add(sizer_3, 1, wx.EXPAND, 0)
        sizer_2.Add(self.grid_1, 1, wx.EXPAND, 0)
        sizer_1.Add(sizer_2, 1, wx.EXPAND, 0)
        self.SetSizer(sizer_1)
        self.Layout()
        # end wxGlade

    def OnAgregar(self, event): # wxGlade: MyFrame.

        self.grid_1.AppendRows()
        self.grid_1.MakeCellVisible(self.rows, 0)
        self.grid_1.ForceRefresh()
        self.rows += 1

    def OnQuitar(self, event): # wxGlade: MyFrame.

        if self.rows > 0: #1:
            self.grid_1.DeleteRows(self.rows)
            self.rows -= 1

# end of class MyFrame

class MyApp(wx.App):
    def OnInit(self):
        wx.InitAllImageHandlers()
        frame_1 = MyFrame(None, -1, "")
        self.SetTopWindow(frame_1)
        frame_1.Show()
        return 1

# end of class MyApp

if __name__ == "__main__":
    app = MyApp(0)
    app.MainLoop()

Esta es mi primer práctica con wxGlade donde estoy empesando a usar sizer.

Es un simple formulario, donde mi objetivo fué que al maximizar el frame, los TextCrtl de ingreso de datos se expandieran a lo largo y el TextCtrl de observaciones lo hiciera a lo largo y a lo ancho. Para ello se configuro el gridSizerFormulario.AddGrowableRow(4), gridSizerFormulario.AddGrowableCol(1), gridSizerFormulario.AddGrowableCol(3), esto permite que la columna 1 , 3 y la fila 4 se agranden, los TextCtrl para aumentar su temaño tienen que tener aliniación wx.Expand para ocupar todo el espacio disponible, gridSizerFormulario.Add(self.textCtrlNroSocio, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0).
Este es el código generado por wxGlade, esta probado en linux Debian, Ubuntu y windows xp.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# generated by wxGlade 0.6.3 on Fri Aug  7 11:21:21 2009

import wx

# begin wxGlade: extracode
# end wxGlade

class Frame(wx.Frame):
    def __init__(self, *args, **kwds):
        # begin wxGlade: Frame.__init__
        kwds["style"] = wx.DEFAULT_FRAME_STYLE
        wx.Frame.__init__(self, *args, **kwds)
        self.panel = wx.Panel(self, -1)
        self.stTitulo = wx.StaticText(self.panel, -1, u"Historia Clínica", style=wx.ALIGN_CENTRE)
        self.stNroSocio = wx.StaticText(self.panel, -1, "Nro Socio:")
        self.textCtrlNroSocio = wx.TextCtrl(self.panel, -1, "")
        self.stNacionalidad = wx.StaticText(self.panel, -1, "Nacionalidad:")
        self.cbNacionalidad = wx.ComboBox(self.panel, -1,u'Argentina', choices=["Argentina", "Uruguay", "Chile", "Paraguay", "Bolivia", "Venezuela", "Ecuador", "Colombia", "Honduras", "Mexico", "Estados Unidos", "Canada", "España", "Italia", "Francia", "Inglaterra", "Alemania", "Japon", "China", "India", "Rusia", "Israel","Egipto", "Etiopia"], style=wx.CB_DROPDOWN)
        self.stApellido = wx.StaticText(self.panel, -1, "Apellido:")
        self.textCtrlApellido = wx.TextCtrl(self.panel, -1, "")
        self.stRell_ = wx.StaticText(self.panel, -1, "")
        self.checkbox_1 = wx.CheckBox(self.panel, -1, "Operado")
        self.stNombre = wx.StaticText(self.panel, -1, "Nombre:")
        self.textCtrlNombre = wx.TextCtrl(self.panel, -1, "")
        self.stRell_8 = wx.StaticText(self.panel, -1, "")
        self.checkbox_2 = wx.CheckBox(self.panel, -1, "Madre")
        self.stFechNac = wx.StaticText(self.panel, -1, "Fech Nac:")
        self.datepicker = wx.DatePickerCtrl(self.panel, -1)
        self.stRell_9 = wx.StaticText(self.panel, -1, "")
        self.stObservaciones = wx.StaticText(self.panel, -1, "Observaciones:")
        self.stRell_11 = wx.StaticText(self.panel, -1, "")
        self.stRell_12 = wx.StaticText(self.panel, -1, "")
        self.stRell_13 = wx.StaticText(self.panel, -1, "")
        self.textCtrlObs = wx.TextCtrl(self.panel, -1, "", style=wx.TE_MULTILINE)
        self.btnCancelar = wx.Button(self.panel, -1, "Cancelar")
        self.btnAceptar = wx.Button(self.panel, -1, "Aceptar")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.OnCancelar, self.btnCancelar)
        self.Bind(wx.EVT_BUTTON, self.OnAceptar, self.btnAceptar)
        # end wxGlade

    def __set_properties(self):
        # begin wxGlade: Frame.__set_properties
        self.SetTitle("Sanatorio Olivos")
        self.SetFont(wx.Font(12, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, ""))
        self.stTitulo.SetFont(wx.Font(12, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, ""))
        self.cbNacionalidad.SetSelection(-1)
        self.Center()
        self.textCtrlNroSocio.SetFocus()
        # end wxGlade

    def __do_layout(self):
        # begin wxGlade: Frame.__do_layout
        boxSizerFrame = wx.BoxSizer(wx.VERTICAL)
        boxSizerPanel = wx.BoxSizer(wx.VERTICAL)
        gridSizerBotones = wx.FlexGridSizer(0, 2, 4, 4)
        gridSizerFormulario = wx.FlexGridSizer(6, 4, 4, 4)
        boxSizerPanel.Add(self.stTitulo, 0, wx.TOP|wx.ALIGN_CENTER_HORIZONTAL|wx.ADJUST_MINSIZE, 10)
        gridSizerFormulario.Add(self.stNroSocio, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.textCtrlNroSocio, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stNacionalidad, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.cbNacionalidad, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stApellido, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.textCtrlApellido, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.checkbox_1, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stNombre, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.textCtrlNombre, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_8, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.checkbox_2, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stFechNac, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.datepicker, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_9, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stObservaciones, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_11, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_12, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.stRell_13, 0, wx.ADJUST_MINSIZE, 0)
        gridSizerFormulario.Add(self.textCtrlObs, 0, wx.EXPAND|wx.ALIGN_BOTTOM, 0)
        gridSizerFormulario.AddGrowableRow(4)
        gridSizerFormulario.AddGrowableCol(1)
        gridSizerFormulario.AddGrowableCol(3)
        boxSizerPanel.Add(gridSizerFormulario, 1, wx.LEFT|wx.RIGHT|wx.TOP|wx.EXPAND, 20)
        gridSizerBotones.Add(self.btnCancelar, 0, wx.ALIGN_BOTTOM, 0)
        gridSizerBotones.Add(self.btnAceptar, 0, wx.LEFT|wx.ALIGN_BOTTOM, 30)
        gridSizerBotones.AddGrowableRow(0)
        gridSizerBotones.AddGrowableCol(0)
        gridSizerBotones.AddGrowableCol(1)
        boxSizerPanel.Add(gridSizerBotones, 0, wx.RIGHT|wx.TOP|wx.BOTTOM|wx.ALIGN_RIGHT, 20)
        self.panel.SetSizer(boxSizerPanel)
        boxSizerFrame.Add(self.panel, 1, wx.EXPAND, 0)
        self.SetSizer(boxSizerFrame)
        boxSizerFrame.Fit(self)
        self.Layout()
        # end wxGlade

    def OnCancelar(self, event): # wxGlade: Frame.
        self.Close()
        event.Skip()

    def OnAceptar(self, event): # wxGlade: Frame.
        ingresoNroSocio = self.textCtrlNroSocio.GetValue()
        ingresoApellido = self.textCtrlApellido.GetValue()
        ingresoNombre = self.textCtrlNombre.GetValue()
        ingresoFechNac = self.datepicker.GetValue()
        #formato de fecha= año-mes-día, Ej: 1961/01/05
        ingresoFechNac = ('%4d/%02d/%02d' %(ingresoFechNac.GetYear(), ingresoFechNac.GetMonth()+1,ingresoFechNac.GetDay()))
        ingresoNacionalidad = self.cbNacionalidad.GetValue()
        ingresoOperado = self.checkbox_1.GetValue()
        if ingresoOperado == True:
            operado = 'Si'
        else:
            operado = 'No'
        ingresoMadre = self.checkbox_2.GetValue()
        if ingresoMadre == True:
            madre = 'Si'
        else:
            madre = 'No'
        ingresoObs = self.textCtrlObs.GetValue()
        datos = u'''
        Nro Socio: %s
        Apellido: %s
        Nombre: %s
        Fecha Nac: %s
        Nacionalidad: %s
        Operado: %s
        Madre: %s
        Observaciones: %s
        ''' %(ingresoNroSocio,ingresoApellido,ingresoNombre,ingresoFechNac,ingresoNacionalidad, operado, madre, ingresoObs)
        dlg = wx.MessageDialog(self, datos, u'Confirmación de Envio',wx.OK | wx.ICON_INFORMATION)
        dlg.ShowModal()
        dlg.Destroy()
        event.Skip()

# end of class Frame

class MyApp(wx.App):
    def OnInit(self):
        wx.InitAllImageHandlers()
        frame = Frame(None, -1, "")
        self.SetTopWindow(frame)
        frame.Show()
        return 1

# end of class MyApp

if __name__ == "__main__":
    app = MyApp(0)
    app.MainLoop()

I recently encountered a need to be able to determine how long a user held down a button on a GUI dialog in order to command a proportional amount of movement in a mechanism. In other words, the longer the button was down, the longer the mechanism would be commanded to move.

It turns out that this is relatively easy to do with wxPython. Basically one merely needs to bind the mouse events wx.EVT_LEFT_DOWN and wx.EVT_LEFT_UP events to the button of interest. When the left mouse button is pressed the wx.EVT_LEFT_DOWN event is generated, and when it is released a wx.EVT_LEFT_UP event occurs. By binding handlers to these events one can use them to determine when a button was selected and how long it was held down by the user.

There are two ways to bind the mouse button events. The first uses the “old” style and looks like this:

wx.EVT_LEFT_DOWN(self.button1, self.OnBtn1Down)

and the second form using the “new” style with the Bind method looks like this:

self.button1.Bind(wx.EVT_LEFT_DOWN, self.OnBtn1Down)

There are also corresponding handlers for the wx.EVT_LEFT_UP event.

In the button up/down event handlers the last statement must be event.Skip(), otherwise the button event will not be passed on to the “real” button event handler.

I’ve provided two examples below. The first is frame-based and uses a textbox widget to display the timing data for each button. The second use a modal dialog box and text control widgets to display the click data.

Both versions display a running average “down-time” for button 1, along with a click total. For buttons 2 and 3 just the down-time is displayed. The clear button, as one might surmise, clears out all previous data.

Frame and Panel Version

""" wxPython Button timing example

    Uses the wx.EVT_LEFT_DOWN and wx.EVT_LEFT_UP events to determine how long
    a button has been held down by the user.

    The up/down events are bound to the buttons, and the actual button event
    is processed after the button is released. It is important to note that
    the up/down handlers MUST call event.Skip() in order to pass the events
    along to the "real" button event handlers.

    Button 1 generates a cumulative click count and an average hold-down time.
    Multiple clicking has shown that the average down time is around 70 mS
    unless the user is really quick, in which case it can drop to around 55 mS.

    Buttons 2 and 3 simply display the hold-down time.

    The Clear button clears the text display and resets the count and average
    values for button 1.

    To execute:

        python buttontime.py

    29 June 2009 - jmh
"""

import wx
import time

class ButtonPanel(wx.Panel):

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

        self.btn1downtime = 0
        self.btn2downtime = 0
        self.btn3downtime = 0

        self.btn1_time = 0
        self.btn2_time = 0
        self.btn3_time = 0

        self.btn1_clks = 0
        self.btn1_tot  = 0

        self.idBtn1 = wx.NewId()
        self.idBtn2 = wx.NewId()
        self.idBtn3 = wx.NewId()
        self.idBtn4 = wx.NewId()
        self.idBtn5 = wx.NewId()

        topsizer     = wx.BoxSizer( wx.HORIZONTAL )
        menusizer    = wx.BoxSizer( wx.VERTICAL )
        contentsizer = wx.BoxSizer( wx.VERTICAL )

        self.textbox = wx.TextCtrl(self, -1, "",
            wx.DefaultPosition, wx.DefaultSize,
            wx.TE_MULTILINE)

        self.textbox.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.button1 = wx.Button(self, self.idBtn1, "Button 1")
        self.button2 = wx.Button(self, self.idBtn2, "Button 2")
        self.button3 = wx.Button(self, self.idBtn3, "Button 3")
        self.button4 = wx.Button(self, self.idBtn4, "Quit")
        self.button5 = wx.Button(self, self.idBtn5, "Clear")

        self.button1.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
        self.button2.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
        self.button3.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
        self.button4.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
        self.button5.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        wx.EVT_LEFT_DOWN(self.button1, self.OnBtn1Down)
        wx.EVT_LEFT_UP(self.button1, self.OnBtn1Up)

        wx.EVT_LEFT_DOWN(self.button2, self.OnBtn2Down)
        wx.EVT_LEFT_UP(self.button2, self.OnBtn2Up)

        wx.EVT_LEFT_DOWN(self.button3, self.OnBtn3Down)
        wx.EVT_LEFT_UP(self.button3, self.OnBtn3Up)

        wx.EVT_BUTTON(self, self.idBtn1, self.OnBtn1)
        wx.EVT_BUTTON(self, self.idBtn2, self.OnBtn2)
        wx.EVT_BUTTON(self, self.idBtn3, self.OnBtn3)
        wx.EVT_BUTTON(self, self.idBtn4, self.OnBtn4)
        wx.EVT_BUTTON(self, self.idBtn5, self.OnBtn5)

        contentsizer.Add(self.textbox, 1, wx.EXPAND)

        menusizer.Add(self.button1, 1, wx.EXPAND)
        menusizer.Add(self.button2, 1, wx.EXPAND)
        menusizer.Add(self.button3, 1, wx.EXPAND)
        menusizer.Add(self.button4, 1, wx.EXPAND)
        menusizer.Add(self.button5, 1, wx.EXPAND)

        topsizer.Add(menusizer, 0)
        topsizer.Add(contentsizer, 1, wx.EXPAND)

        self.SetSizer(topsizer)

    #---------------------------------------------------------------------------
    # Mouse button event handlers
    #---------------------------------------------------------------------------
    def OnBtn1Down(self, event):
        self.btn1_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnBtn1Up(self, event):
        self.btn1_uptime = time.time()
        self.btn1_time = self.btn1_uptime - self.btn1_downtime
        self.btn1_clks += 1
        self.btn1_tot += self.btn1_time
        event.Skip()    # REQUIRED!

    def OnBtn2Down(self, event):
        self.btn2_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnBtn2Up(self, event):
        self.btn2_uptime = time.time()
        self.btn2_time = self.btn2_uptime - self.btn2_downtime
        event.Skip()    # REQUIRED!

    def OnBtn3Down(self, event):
        self.btn3_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnBtn3Up(self, event):
        self.btn3_uptime = time.time()
        self.btn3_time = self.btn3_uptime - self.btn3_downtime
        event.Skip()    # REQUIRED!

    #---------------------------------------------------------------------------
    # Button widget event handlers
    #---------------------------------------------------------------------------
    def OnBtn1(self, event):
        self.textbox.AppendText("Btn1: %3.3f, clicks: %d, avg: %3.3f\n" % \
                                (self.btn1_time,
                                 self.btn1_clks,
                                (self.btn1_tot/self.btn1_clks)))

    def OnBtn2(self, event):
        self.textbox.AppendText("Btn2: %3.3f\n" % self.btn2_time)

    def OnBtn3(self, event):
        self.textbox.AppendText("Btn3: %3.3f\n" % self.btn3_time)

    def OnBtn4(self, event):
        self.GetParent().Close(True)

    def OnBtn5(self, event):
        self.btn1_time = 0
        self.btn2_time = 0
        self.btn3_time = 0

        self.btn1_clks = 0
        self.btn1_tot  = 0

        self.textbox.Clear()

#-------------------------------------------------------------------------------
# Launch
#-------------------------------------------------------------------------------
app     = wx.PySimpleApp(0)
frame   = wx.Frame(None, -1, "Timed Buttons")

ButtonPanel(frame)

frame.Show(True)
frame.SetSize(wx.Size(800, 600))
frame.Move(wx.Point(50,50))

app.MainLoop()

wx.Dialog Version

Note that this version is in two parts: buttondlg.py and dlgTimedButtons.py. The Boa Constructor tool was used to create the dialog skeleton, and the rest was filled in afterwards. Use the “Evts” tab in Boa’s Inspector panel to add the mouse events to a particular button.

# buttondlg.py
#
# Creates frame with menu and status bar for use with dlgTimedButtons
#
# 3 July 2009 - jmh

import wx

import dlgTimedButtons

idShowDlg = wx.NewId()
idQuit    = wx.NewId()

class DlgTimedButton(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title, size=(250, 150))

        menubar = wx.MenuBar()
        mainmenu = wx.Menu()
        mainmenu.Append(idShowDlg, 'Dialog', 'Timed buttons dialog')
        mainmenu.Append(idQuit, 'Quit', 'Quit application')

        self.Bind(wx.EVT_MENU, self.OnShowDlg, id=idShowDlg)
        self.Bind(wx.EVT_MENU, self.OnQuit, id=idQuit)

        menubar.Append(mainmenu, 'Main')
        self.SetMenuBar(menubar)

        self.statusbar = self.CreateStatusBar()

        self.Centre()
        self.Show(True)

    def OnShowDlg(self, event):
        dlg = dlgTimedButtons.dlgTimedButtons(self)
        dlg.ShowModal()

    def OnQuit(self, event):
        self.Close()

#-------------------------------------------------------------------------------
# Launch
#-------------------------------------------------------------------------------
app = wx.App()
DlgTimedButton(None, -1, 'Timed Button Dialog Example')
app.MainLoop()

and here is the actual dialog with the timed button goodness:

#Boa:Dialog:dlgTimedButtons
#
# Timed button modal dialog example
# 3 July 2009 - jmh
# initially created with Boa Constructor

import wx
import time

def create(parent):
    return dlgTimedButtons(parent)

[wxID_DLGTIMEDBUTTONS, wxID_DLGTIMEDBUTTONSBTNCLEAR,
 wxID_DLGTIMEDBUTTONSBTNQUIT, wxID_DLGTIMEDBUTTONSBUTTON1,
 wxID_DLGTIMEDBUTTONSBUTTON2, wxID_DLGTIMEDBUTTONSBUTTON3,
 wxID_DLGTIMEDBUTTONSSTATICTEXT1, wxID_DLGTIMEDBUTTONSSTATICTEXT2,
 wxID_DLGTIMEDBUTTONSSTATICTEXT3, wxID_DLGTIMEDBUTTONSTXTBTN1CLICKS,
 wxID_DLGTIMEDBUTTONSTXTBTNTIME1, wxID_DLGTIMEDBUTTONSTXTBTNTIME1AVG,
 wxID_DLGTIMEDBUTTONSTXTBTNTIME2, wxID_DLGTIMEDBUTTONSTXTBTNTIME3,
] = [wx.NewId() for _init_ctrls in range(14)]

class dlgTimedButtons(wx.Dialog):
    def __init__(self, parent):
        self.btn1downtime = 0
        self.btn2downtime = 0
        self.btn3downtime = 0

        self.btn1_time = 0
        self.btn2_time = 0
        self.btn3_time = 0

        self.btn1_clks = 0
        self.btn1_tot  = 0

        self._init_ctrls(parent)
        self.ClrDisplay()

    def _init_ctrls(self, prnt):
        # generated method, don't edit
        wx.Dialog.__init__(self, id=wxID_DLGTIMEDBUTTONS,
              name='dlgTimedButtons', parent=prnt, pos=wx.Point(477, 295),
              size=wx.Size(353, 201), style=wx.DEFAULT_DIALOG_STYLE,
              title='Timed Buttons')
        self.SetClientSize(wx.Size(345, 174))

        self.button1 = wx.Button(id=wxID_DLGTIMEDBUTTONSBUTTON1,
              label='Button 1', name='button1', parent=self, pos=wx.Point(16,
              24), size=wx.Size(75, 23), style=0)
        self.button1.Bind(wx.EVT_BUTTON, self.OnButton1Button,
              id=wxID_DLGTIMEDBUTTONSBUTTON1)
        self.button1.Bind(wx.EVT_LEFT_UP, self.OnButton1LeftUp)
        self.button1.Bind(wx.EVT_LEFT_DOWN, self.OnButton1LeftDown)

        self.button2 = wx.Button(id=wxID_DLGTIMEDBUTTONSBUTTON2,
              label='Button 2', name='button2', parent=self, pos=wx.Point(16,
              72), size=wx.Size(75, 23), style=0)
        self.button2.Bind(wx.EVT_BUTTON, self.OnButton2Button,
              id=wxID_DLGTIMEDBUTTONSBUTTON2)
        self.button2.Bind(wx.EVT_LEFT_UP, self.OnButton2LeftUp)
        self.button2.Bind(wx.EVT_LEFT_DOWN, self.OnButton2LeftDown)

        self.button3 = wx.Button(id=wxID_DLGTIMEDBUTTONSBUTTON3,
              label='Button 3', name='button3', parent=self, pos=wx.Point(16,
              96), size=wx.Size(75, 23), style=0)
        self.button3.Bind(wx.EVT_BUTTON, self.OnButton3Button,
              id=wxID_DLGTIMEDBUTTONSBUTTON3)
        self.button3.Bind(wx.EVT_LEFT_UP, self.OnButton3LeftUp)
        self.button3.Bind(wx.EVT_LEFT_DOWN, self.OnButton3LeftDown)

        self.btnQuit = wx.Button(id=wxID_DLGTIMEDBUTTONSBTNQUIT, label='Close',
              name='btnQuit', parent=self, pos=wx.Point(16, 144),
              size=wx.Size(75, 23), style=0)
        self.btnQuit.Bind(wx.EVT_BUTTON, self.OnBtnQuitButton,
              id=wxID_DLGTIMEDBUTTONSBTNQUIT)

        self.txtBtnTime1 = wx.TextCtrl(id=wxID_DLGTIMEDBUTTONSTXTBTNTIME1,
              name='txtBtnTime1', parent=self, pos=wx.Point(112, 24),
              size=wx.Size(100, 21), style=0, value='')
        self.txtBtnTime1.SetEditable(False)

        self.txtBtnTime2 = wx.TextCtrl(id=wxID_DLGTIMEDBUTTONSTXTBTNTIME2,
              name='txtBtnTime2', parent=self, pos=wx.Point(112, 72),
              size=wx.Size(100, 21), style=0, value='')
        self.txtBtnTime2.SetEditable(False)

        self.txtBtnTime3 = wx.TextCtrl(id=wxID_DLGTIMEDBUTTONSTXTBTNTIME3,
              name='txtBtnTime3', parent=self, pos=wx.Point(112, 96),
              size=wx.Size(100, 21), style=0, value='')
        self.txtBtnTime3.SetEditable(False)

        self.txtBtnTime1Avg = wx.TextCtrl(id=wxID_DLGTIMEDBUTTONSTXTBTNTIME1AVG,
              name='txtBtnTime1Avg', parent=self, pos=wx.Point(272, 24),
              size=wx.Size(64, 21), style=0, value='')
        self.txtBtnTime1Avg.SetEditable(False)

        self.staticText1 = wx.StaticText(id=wxID_DLGTIMEDBUTTONSSTATICTEXT1,
              label='Times', name='staticText1', parent=self, pos=wx.Point(144,
              48), size=wx.Size(40, 16), style=0)

        self.staticText2 = wx.StaticText(id=wxID_DLGTIMEDBUTTONSSTATICTEXT2,
              label='Average', name='staticText2', parent=self,
              pos=wx.Point(224, 32), size=wx.Size(41, 13), style=0)

        self.txtBtn1Clicks = wx.TextCtrl(id=wxID_DLGTIMEDBUTTONSTXTBTN1CLICKS,
              name='txtBtn1Clicks', parent=self, pos=wx.Point(272, 48),
              size=wx.Size(64, 21), style=0, value='')
        self.txtBtn1Clicks.SetEditable(False)

        self.staticText3 = wx.StaticText(id=wxID_DLGTIMEDBUTTONSSTATICTEXT3,
              label='Clicks', name='staticText3', parent=self, pos=wx.Point(240,
              56), size=wx.Size(26, 13), style=0)

        self.btnClear = wx.Button(id=wxID_DLGTIMEDBUTTONSBTNCLEAR,
              label='Clear', name='btnClear', parent=self, pos=wx.Point(160,
              144), size=wx.Size(51, 23), style=0)
        self.btnClear.Bind(wx.EVT_BUTTON, self.OnBtnClearButton,
              id=wxID_DLGTIMEDBUTTONSBTNCLEAR)

        self.txtBtnTime1.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, False, 'Arial'))
        self.txtBtnTime2.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, False, 'Arial'))
        self.txtBtnTime3.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, False, 'Arial'))
        self.txtBtnTime1Avg.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, False, 'Arial'))
        self.txtBtn1Clicks.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL, False, 'Arial'))

    def ClrDisplay(self):
        self.txtBtnTime1.SetValue("0.0")
        self.txtBtnTime2.SetValue("0.0")
        self.txtBtnTime3.SetValue("0.0")

        self.txtBtnTime1Avg.SetValue("0")
        self.txtBtn1Clicks.SetValue("0.0")

    def OnButton1LeftUp(self, event):
        self.btn1_uptime = time.time()
        self.btn1_time = self.btn1_uptime - self.btn1_downtime
        self.btn1_clks += 1
        self.btn1_tot += self.btn1_time
        event.Skip()    # REQUIRED!

    def OnButton1LeftDown(self, event):
        self.btn1_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnButton2LeftUp(self, event):
        self.btn2_uptime = time.time()
        self.btn2_time = self.btn2_uptime - self.btn2_downtime
        event.Skip()    # REQUIRED!

    def OnButton2LeftDown(self, event):
        self.btn2_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnButton3LeftUp(self, event):
        self.btn3_uptime = time.time()
        self.btn3_time = self.btn3_uptime - self.btn3_downtime
        event.Skip()    # REQUIRED!

    def OnButton3LeftDown(self, event):
        self.btn3_downtime = time.time()
        event.Skip()    # REQUIRED!

    def OnButton1Button(self, event):
        self.txtBtnTime1.SetValue("%3.3f" % self.btn1_time)
        self.txtBtnTime1Avg.SetValue("%3.3f" % (self.btn1_tot/self.btn1_clks))
        self.txtBtn1Clicks.SetValue(str(self.btn1_clks))

    def OnButton2Button(self, event):
        self.txtBtnTime2.SetValue("%3.3f" % self.btn2_time)

    def OnButton3Button(self, event):
        self.txtBtnTime3.SetValue("%3.3f" % self.btn3_time)

    def OnBtnQuitButton(self, event):
        self.Destroy()

    def OnBtnClearButton(self, event):
        self.btn1_time = 0
        self.btn2_time = 0
        self.btn3_time = 0
        self.btn1_clks = 0
        self.btn1_tot  = 0
        self.ClrDisplay()

And that’s it. It’s just that easy. Once the time interval between the down and up events has been captured it can be put to use in various interesting ways.

Remember in 2007 Sonivox donated some game sound technology to OHA and Android? Some examples of JetCreator and JetCreator to create the MIDI sequences for game music are in the Git repo, the sub-folder is:

external/sonivox/jettools

You need Python Version 2.5.4 and wxPython Version 2.8.7.1 installed or versions higher than that. To run the samples copy that sub-folder to your Home/opt directory and cd to JetCreator directory to run JetCreator.py. I do not know any Linux tools that create the JET asset archives files other than jetCreator.py. The JetCreator manual is here. You wil not be able to play back soudn sin JetCreator in Liux but have to use the emulator. The code to use the JetPlaer class looks like this from the media instructions:

<pre>JetPlayer myJet = JetPlayer.getJetPlayer();
myJet.loadJetFile("/sdcard/level1.jet");
byte segmentId = 0;

// queue segment 5, repeat once, use General MIDI, transpose by -1 octave
myJet.queueJetSegment(5, -1, 1, -1, 0, segmentId++);
// queue segment 2
myJet.queueJetSegment(2, -1, 0, 0, 0, segmentId++);

myJet.play();</pre>

The JetBoy example is in the reop sub-folder of:

development/samples

You can access JET files form two locations. Ones, as a raw resource in your APK file so in other words it would be in your assets project sub-folder. Second, as a JET file in on the SDCard. You will want to look at the jetBoy sample code as there is  some beginning code to adjust animation ot speed of the JET MIDI music playing per FPS.Iam referrrign you to the reop rather than the SDK as ther obviously will be changes as they ready Android SDK 2.0.

Obviously, we than can apply this to non-game such as playing sounds in the HomeScreen application.

After much tinkering, and switching from openGL (which I don’t want to abandon yet) to wxPython, I came to this simple mock up. I hope to advance from this in the near future, but I think maybe my eyes need a bit of a rest.

UPDATE ::

Mark I put together this mock-up just a moment ago, making things inspiring.

Tengo la intencion de hacer screencast del desarrollo de las pantallas del cliente de tumblr, pero no he encontrado algun programa gratuito o no logro hacer funcionar vlc.

Wxglade permite el diseño rapido de interfaces para el usuario, la estructura de una interfaz debe ser frame/panel/dialog/etc despues de cualquiera de estos se debe colocar un sizer para acomodar los widgets a utilizar.

En el caso de la pantalla del login se uso un frame para generar la ventana que contiene un sizer (sizer_1), en este sizer se agrega un slot para colocar la etiqueta l_tumblr que muestra el titulo “Tumblr” y el otro slot se coloca un panel . En la pagina web de tumblr todos los elementos se encuentran dentro de un “marco” blanco, para hacer algo similar se agrega un panel con su respectivo sizer y colocar ahora si el panel que contendra los widgets del login.

En la panel (panel_login) siguiendo la misma secuencia se agrega un sizer (sizer_login) y por cada widget que agreguemos se debe insertar en su respectivo slot. Entonces el sizer_login contendra 7 slots en el orden para los widgets como: l_login, l_mail, tc_mail, l_password, tc_password, spacer, b_login. Ya para terminar basta con generar el codigo, para esto en la ventana del arbol de widgets se debe seleccionar la raiz (Application) e ir a la ventana de propiedades en la parte inferior se debe colocar el path del archivo donde se va a generar el codigo, desde el menu->file se puede generar.

Hi all,

I’ve run into a blog post the other day that used the Psycho module to accelerate their Python code with trivial changes to the source code.  These are described well in the Pyscho Documentation.

I’ve been having some trouble with the AutoComplete function which I talk about here.  When I have large ontologies it takes ~1 second to sort all of the terms as each letter is typed.  While this may not seem like a long time, try counting to 5-Mississippi while typing “Blood” and you’ll see how frustrating this could be.  Profiling has revealed that the sorting function takes up a large portion of that time.  Even though it only takes 0.001 seconds per call, it needs ~5-10K calls per letter.  A 10% speed-up would save a lot of time, and Pyscho claims 2-100x speed-up.

If I have a free hour or two I’m going to try out Pyscho and see if it can help out a little.  If anyone has suggestions, like will Pyscho work for wxPython, please leave them in the comments.

-Will

Hi all,

Sadly nobody gets to program in a bubble.  Everyone has deadlines, legacy code, legacy computers, legacy programmers, etc.  We also don’t have unlimited time to “re-invent the wheel” at each opportunity.  Assumming you’re doing an open source project (much like this one), you can incorporate other people’s tools into your own code.

If I need to fix some automatically generated XML or HTML, instead of writing my own code, I can just import BeautifulSoup.  If I need to render information into HTML or an e-mail, instead of writing my own code, I can just use jinja templates.  If I need to make a GUI, instead of complaining about how people have forgotten (or never learned) how to use command line, I can just use wxPython.

I’m new to the development world.  I’m usually the only user of my code, and it only needs to run on my computer.  When I submit code for publication I do a cursory check to make sure it runs on another computer, but ultimately I leave it up to the readers to figure out the dependencies.  However, this project is different.  I need to ensure that the code runs on any computer with only a minor amount of fiddling … especially since this may be used by technically unsavy users.

After plenty of googling and some half-brained ideas to use command-line calls to easy_install I found that setuptools allows a programmer to specify the dependencies.  Whenever I used easy_install I noticed that it would install dependencies, I just didn’t make the obvious leap that I could also define them in my own setup file.

In the next post I’ll discuss some of my trials and tribulations on ensuring that all of my code is packaged correctly.

-Will

wxpython

Existen diferentes metodos y nombres de paquetes a instalar de acuerdo a la plataforma de desarrollo a usar, lo mas recomendable es usar un sistema linux y despues probar la aplicacion en otras.

Los paquetes necesarios son:

• python
• wxpython
• wxpython docs/demos ( opcional , pero muy util )

El sistema que uso es osx, para iniciar basta con descargar los paquetes (dmg)  e instalarlos como cualquier otra aplicacion. En el caso de python ya viene por default en osx ( leopard ), en este momento tengo la 2.5 pero se puede trabajar con la 2.6 . En el caso de sistemas linux se debe utilizar

apt-get install wxpython-version

yum install wxpython-version

Tambien es opcional la instalacion de wxglade, sirve para crear la interfaz grafica mas rapido. Solo hay que  descargarlo y  “desempaquetar”.

Hi all,

Today’s project was to finish up loose ends on the wxPython Annotation GUI.  There are two things left that prevent me from annotating the GEO database with ontologies.  I need to be able to search the ontology tree with a search term while annotating (in case the suggestions provided are incorrect or unhelpful) and I need a way to auto-download all of the GSE/GSM records that result from a search engine.  I decided to work on the former problem today.

When I parse the ontology file I gather the official names and synonyms into a dictionary for easy retrieval of the OntolgyRecord by name.  This may get me into trouble if there are two different ontology records with overlapping synonyms, but I haven’t encountered this yet and I’ll deal with it then.  I want a way to search these terms with an AutoCompleting feature.  After doing some googling I came across this post.  The authors wrote a subclass of wxTextCtlr with an associated wxListCtrl.  I included this file at Revision 65 in svn/trunk/ DMtools/wxAutoComplete.py. 

The control will auto-complete your entry by scrolling to the relevant entry in the listctrl.  However, the code as downloaded was insufficient for my needs.

1.      It would scroll to the first instance where it could auto-complete.  If the input list was unsorted it would only show one helpful suggestion.

2.      It couldn’t deal with inputs that had spaces.

As with all things in Python, it is trivially easy to extend features by subclassing the relevant classes.  I subclassed the TextCtrlAutoComplete.  I went through a couple of ideas on how to accomplish what I was looking for:

1. I tried to modify the for-loop in the onEnteredText to continue even after it found a match and then append the items to a list.  Then after each run through the search I would delete everything in the listctrl and then re-create the listctrl with on the relevant items.  This turned out to be eye-bleedingly slow.  It took about ~2 seconds for each letter typed to render the new box.
2. I then tried to use my OntologyDatabase.SeachTree function to search the entire tree at once and then render the listctrl from there.  However, this doesn’t work on partial words, which is the whole thing I’m trying to accomplish with the auto-complete box.

None of these ideas panned out.  Instead I settled on using the listctlr.SortItems function.  This uses a provided function to evaluate pairwise comparisons of each list item and then uses QuickSort to arrange them.  I provided a comparison function (_sortItems) which places all words containing the search-term ABOVE non-containing words.  It then sorts by dictionary order within each class.  This solution sorts items as expected and works instantaneously, at least I can’t notice a slowdown while typing.

I came across two “gotchas” while programming today.  One is in wxWidgets and it was easily worked around.  It turns out that the listctrl GetItemData function is unreliable when the order is changing.  I found this in the post.  So I changed my original:

def _sortItems(self, data1, data2):
    text1 = self.GetItemData(data1)
    text2 = self.GetItemData(data2)

To:

text1 = self.itemDataMap[data1]
text2 = self.itemDataMap[data2]

The other gotcha is that I came across is that Python string comparisons are NOT lexographical.  Simply put, this means that shorter words are ALWAYS smaller then longer words regardless of the letter composition.  I had to throw together a conversion tool quickly.  It’s an ugly wart that I’ll fix later, I PROMISE.  It errors out when there are non-letter characters or strange encodings that can’t be converted to integers.  I use a memoize decorator to cut down on the calculations.

Tomorrow’s project is to create the GEO searching tool and do some more dry-runs on the annotation before I make a big push to annotate next week.