azul

Azul - Framework GUI de bureau

Azul est un framework GUI gratuit, fonctionnel et réactif pour Rust, C et C++, construit à l'aide du moteur de rendu WebRender et d'un modèle objet de document de type CSS/HTML pour le développement rapide de belles applications de bureau natives.

Site Web | Sorties | Guide de l'utilisateur | Documentation API | Démo vidéo | Chat matriciel

Caractéristiques

Azul utilise webrender (le moteur de rendu derrière Firefox) pour afficher votre interface utilisateur, il prend donc en charge de nombreuses fonctionnalités CSS courantes telles que :

• dégradés (linéaire, radial, conique)
• ombres de boîte
• Filtres SVG
• opérateurs de composition (multiplier, assombrir, etc.)
• style de bordure
• rayons-bordures
• défilement / débordement automatique
• Transformations CSS

Consultez la liste des clés/valeurs CSS prises en charge pour plus d'informations.

En plus de cela, Azul propose...

• de nombreux widgets intégrés (Button, TextInput, CheckBox, ColorInput, TextInput, NumberInput)
• intégration de textures OpenGL
• système de mise en page relatif/absolu simplifié de type HTML basé sur CSS flexbox
• Plus de 60 animations FPS via l'API d'animation
• boîtes de dialogue natives multiplateformes
• mise en forme et rendu du texte multiplateforme
• Analyse et rendu SVG
• pavage de forme pour le rendu d'un grand nombre de lignes 2D, de cercles, de rectangles, de formes, etc. en un seul appel de dessin
• gestion des tâches hors thread principal pour les E/S
• liaison dynamique via une bibliothèque partagée*
• utilisable depuis Rust, C, C++ et Python via des liaisons API générées automatiquement**
• Compilation HTML vers Rust pour un prototypage rapide/rechargement à chaud

* liaison statique pas encore disponible

** Les liaisons C++ et Python ne sont pas encore stabilisées et peuvent ne pas fonctionner selon la branche que vous utilisez. Ils seront stabilisés avant la sortie.

Captures d'écran

Bonjour le monde

Python

 from azul import *

class DataModel :
    def __init__ ( self , counter ):
        self . counter = counter

def render_dom ( data , info ):
    
    label = Dom . text ( "{}" . format ( data . counter ))
    label . set_inline_style ( "font-size: 50px;" )
    
    button = Button ( "Increment counter" )
    button . set_on_click ( data , increment_counter )

    dom = Dom . body ()
    dom . add_child ( label )
    dom . add_child ( button . dom ())

    return dom . style ( Css . empty ())

def increment_counter ( data , info ):
    data . counter += 1 ;
    return Update . RefreshDom

app = App ( DataModel ( 5 ), AppConfig ( LayoutSolver . Default ))
app . run ( WindowCreateOptions ( render_dom ))

Rouiller

 use azul :: prelude :: * ;
use azul :: widgets :: { button :: Button , label :: Label } ;

struct DataModel {
    counter : usize ,
}

extern "C" 
fn render_dom ( data : & mut RefAny , _ : & mut LayoutInfo ) -> StyledDom {

    let data = data . downcast_ref :: < DataModel > ( ) ? ;

    let label = Dom :: text ( format ! ( "{}" , data . counter ) )
        . with_inline_style ( "font-size: 50px;" ) ;
        
    let button = Button :: new ( "Increment counter" )
        . onmouseup ( increment_counter , data . clone ( ) ) ;

    Dom :: body ( )
    . with_child ( label )
    . with_child ( button . dom ( ) )
    . style ( Css :: empty ( ) )
}

extern "C" 
fn increment_counter ( data : & mut RefAny , _ : & mut CallbackInfo ) -> Update {
    let mut data = data . downcast_mut :: < DataModel > ( ) ? ;
    data . counter += 1 ;
    Update :: RefreshDom // call render_dom() again
}

fn main ( ) {
    let initial_data = RefAny :: new ( DataModel { counter : 0 } ) ;
    let app = App :: new ( initial_data , AppConfig :: default ( ) ) ;
    app . run ( WindowCreateOptions :: new ( render_dom ) ) ;
}

C

 #include "azul.h"

typedef struct {
    uint32_t counter ;
} DataModel ;

void DataModel_delete ( DataModel * restrict A ) { }
AZ_REFLECT ( DataModel , DataModel_delete );

AzStyledDom render_dom ( AzRefAny * data , AzLayoutInfo * info ) {

    DataModelRef d = DataModelRef_create ( data );
    if !( DataModel_downcastRef ( data , & d )) {
        return AzStyledDom_empty ();
    }
    
    char buffer [ 20 ];
    int written = snprintf ( buffer , 20 , "%d" , d -> counter );
    AzString const labelstring = AzString_copyFromBytes ( & buffer , 0 , written );
    AzDom label = AzDom_text ( labelstring );
    AzString const inline_css = AzString_fromConstStr ( "font-size: 50px;" );
    AzDom_setInlineStyle ( & label , inline_css );
    
    AzString const buttontext = AzString_fromConstStr ( "Increment counter" );
    AzButton button = AzButton_new ( buttontext , AzRefAny_clone ( data ));
    AzButton_setOnClick ( & button , incrementCounter );

    AzDom body = Dom_body ();
    AzDom_addChild ( body , AzButton_dom ( & button ));
    AzDom_addChild ( body , label );
    
    AzCss global_css = AzCss_empty ();
    return AzDom_style ( body , global_css );
}

Update incrementCounter ( RefAny * data , CallbackInfo * event ) {
    DataModelRefMut d = DataModelRefMut_create ( data );
    if !( DataModel_downcastRefMut ( data , & d )) {
        return Update_DoNothing ;
    }
    d -> ptr . counter += 1 ;
    DataModelRefMut_delete ( & d );
    return Update_RefreshDom ;
}

int main () {
    DataModel model = { . counter = 5 };
    AzApp app = AzApp_new ( DataModel_upcast ( model ), AzAppConfig_default ());
    AzApp_run ( app , AzWindowCreateOptions_new ( render_dom ));
    return 0 ;
}

Licence

Azul est sous licence MPL-2.0. Ce qui signifie que oui, vous pouvez créer des applications propriétaires en utilisant azul sans avoir à publier votre code : il vous suffit de publier les modifications apportées à la bibliothèque elle-même .

Copyright 2017 - actuel Felix Schütt