tkpf

tkpf es una biblioteca para construir GUI tkinter en un paradigma influenciado por WPF (Windows Presentation Foundation) y Angular.

Las características principales son:

• Jerarquía y diseño de vista declarativa en XML o YAML
• Enlace de datos unidireccional y bidireccional
• Soporte de componentes

Tutorial

La plantilla de diseño

Usted especifica la GUI en formato XML o YAML. Aquí hay un ejemplo simple, ExampleWindow.xml :

< Frame pack-anchor = " nw " pack-padx = " 5 " >
     < LabelFrame text = " Options " pack-anchor = " w " pack-fill = " x " >
        < Radiobutton pack-anchor = " w " variable = " [(choice)] " value = " option1 " >
            Option 1
        </ Radiobutton >        
        < Radiobutton pack-anchor = " w " variable = " [(choice)] " value = " option2 " >
            Option 2
        </ Radiobutton >
        < Combobox pack-anchor = " w " textvariable = " (selected_suboption) " values = " [available_suboptions] "
                  name = " combobox " />
        < Button command = " do_stuff " >Do stuff</ Button >
    </ LabelFrame >
</ Frame >

Como puede ver, los nombres de etiquetas XML corresponden a los nombres de clase de widget de tkinter, mientras que XML atribuye a sus argumentos. tkpf es obstinado que siempre usa los widgets temáticos ttk de mejor aspecto cuando estén disponibles.

Opciones como pack-anchor="nw" o grid-row="0" Especifique el diseño y se pasarán al método apropiado del Administrador de diseño Tkinter, en este caso .pack(anchor='nw') .

Sobre cómo especificar una GUI en formato YAML, vea example/ExampleWindow.yaml .

La clase View

Muestra la GUI creando una clase derivada de Window y mostrándola. Debe suministrar el Modelo View en el constructor.

 class ExampleWindow ( Window ):
    template_path = 'ExampleWindow.xml'  # 'ExampleWindow.yaml' works too

ExampleWindow ( ExampleModel ()). show ()

Si desea mantener el diseño XML en este archivo en línea, también puede hacerlo:

 class ExampleWindow ( Window ):
    template = '<Label>Some text</Label>'

o

 class ExampleWindow ( Window ):
    template_yaml = '''
    Label:
      text: Some text
    '''

Configuración del título de la ventana:

    def __init__ ( self , model ):
        super (). __init__ ( model )
        self . title = 'My application'

En la clase View puede escribir manejadores de eventos. Haga que ese botón funcione, por ejemplo:

    def do_stuff ( self ):
        self . combobox . config ( state = 'disabled' )

Esto también muestra cómo puede acceder a widgets por nombre en los métodos de la clase View. Pero si prefiere, puede acceder a ellos dinámicamente así:

        self . named_widgets [ 'combobox' ]

La clase ViewModel

 class ExampleModel ( ViewModel ):
    choice = Bindable ( AutoProperty ( 1 ))
    available_suboptions = Bindable ( AutoProperty ())
    selected_suboption = Bindable ( AutoProperty ())
    
    def __init__ ( self ):
        super (). __init__ ()
        self . available_suboptions = ( 'suboption1' , 'suboption2' )

AutoProperty es similar a una propiedad autogenerada C#. Por defecto, su tipo de datos es str . Puede proporcionar un valor predeterminado o un tipo a su constructor.

Bindable es un decorador que puede usar en cualquier propiedad para devolver una propiedad vinculable. Tiene que conocer el tipo de datos de la propiedad envuelta, así que especifique su tipo de devolución con una anotación de tipo:

 @ Bindable
@ property
def foo () -> int :
    return 1

AutoProperty se encarga de eso por usted.

Solo los tipos int , bool , float y str son compatibles con las fijaciones de tkinter, aunque para los valores de Combobox, puede asignar una tupla Python.

Si no se encuentra un controlador de eventos en la clase View, también se buscará en el modelado ViewModel.

Sintaxis de enlace de datos

En el XML especifica la dirección de la unión de datos con una sintaxis similar a la de Angular:

 values="[available_suboptions]"

es un enlace unidireccional desde la fuente de datos para ver el objetivo,

 textvariable="(selected_suboption)"

es un enlace unidireccional desde el objetivo de vista hasta la fuente de datos, y

 variable="[(choice)]"

es una unión de dos vías.

Uso de widgets personalizados

Puede usar widgets personalizados derivados de las clases de widgets tkinter. Lo único que tienes que hacer es llamar

 Directive . Registry . register ( YourCustomWidgetClass )

Antes de cargar una plantilla que la use.

Componentes

tkpf admite dividir su GUI en componentes. Aquí hay un ejemplo de un componente de barra de progreso con su propio ViewModel:

 class ProgressbarModel ( ViewModel ):
    value = BindableProperty ( 0 )
    target = BindableProperty ( 100 )
    

class CustomProgressbar ( Component ):
    template = '<Progressbar name="progressbar" variable="[value]" maximum="[target]"/>'

Y puedes usarlo así:

< CustomProgressbar tkpf-model = " [progressbar_model] " />

donde progressbar_model es un atributo o propiedad en su Modelo de vista principal.

En Python 3.5 debe registrar su componente antes de usarlo. En Python 3.6+ eso es automático.

 Directive . Registry . register ( CustomProgressbar )

Se planifica que podrá agregar atributos ADD personalizados y vinculables a los componentes, como este:

 class ExampleComponent ( Component ):
    template = '<Label name="thelabel">Example component text</Label>'

    def config ( self , ** kwargs ):
        self . thelabel . config ( text = kwargs [ 'custom-text' ])

Y luego úselos así:

< ExampleComponent custom-text = " Custom text " />

El único requisito es que el nombre del atributo contiene un guión.

Advertencias

tkpf solo admite Python 3.5+.

Este es un trabajo en progreso. También mi primer intento de crear una biblioteca. Mire los problemas del proyecto para ver lo que aún no es compatible.