Développement d'applications de bureau GUI Python avec Telerik UI pour WPF

Vous cherchez à créer une interface graphique pour votre application Python? Vous avez une application de bureau Python qui a besoin d'un coup de pouce et d'un éclat? Bien devinez quoi? Vous pouvez maintenant y parvenir à l'aide de nos contrôles d'interface utilisateur puissants et modernes pour WPF.

Python et WPF? Oh, oui, IronPython et L'interface utilisateur Telerik pour WPF sont une alliance faite au paradis qui amènera votre application de bureau Python au niveau supérieur.

IronPython

Ne le faites pas inquiétez-vous si c'est la première fois que vous entendez parler d'IronPython. Pas de soucis si la première chose qui vous a traversé l'esprit est Iron Man. Oui, je sais qu'il n'avait pas de super-pouvoirs en soi, mais avec l'aide de son imagination, il est devenu extrêmement puissant.

IronPython est une puissante variante open-source de Python intégrée au .NET Framework. Il vous donne la possibilité d'utiliser .NET Framework dans l'interface graphique de bureau Python et vice versa. Cool, non? ? Je veux apprendre quelque chose d'encore plus cool – la dernière version est livrée avec un projet de modèle intégré pour Visual Studio 2019.

Donc, utilisons-le comme base et créez d'abord une application Hello WPF simple.

Une fois le projet Python créé, vous pouvez voir que les assemblages WPF bien connus sont intégrés ainsi qu'une fenêtre WPF de départ et un fichier compilé Python.

Pour moi, personnellement, cela ressemble beaucoup à une application standard avec la différence majeure que le code derrière le fichier C # / VB est remplacé par un fichier Python. Si vous ajoutez un exemple de bouton dans la fenêtre XAML et exécutez l'application, vous aurez votre première "Bonjour WPF App en Python" en cours d'exécution.

Activez Telerik Datagrid sur

Maintenant, faisons un pas de géant dans l'utilisation des contrôles Telerik. Tout d'abord, vous devez installer le Interface utilisateur Telerik pour WPF Suite de composants d'interface utilisateur: vous pouvez la télécharger à partir d'ici . Ajoutez ensuite les assemblages Telerik requis pour utiliser RadGridView pour WPF .

Pour référencer les fichiers binaires dans l'application, importez la bibliothèque clr puis utilisez les méthodes addReference :

 import   wpf  [19659002]   import   clr  
   clr.AddReference ( 'Telerik.Windows.Controls.dll' )  [19659002]   clr.AddReference ( 'Telerik.Windows.Controls.Input.dll' )  
   clr.AddReference ( 'Tel erik.Windows.Data.dll ')  
   clr.AddReference (' Telerik.Windows.Controls.GridView.dll ') 

As une dernière étape, écrivons du XAML pour afficher un DataGrid rempli avec des "informations commerciales très sensibles":

 < Fenêtre 



  Titre  =  "WpfApplication1"   Hauteur  =  "240"   Largeur  =  "600"   x: Nom  =  "Root"  >   
    < Grille >   
    < telerik: RadGridView   telerik : StyleManager.Theme  =  "Fluent"   
    ItemsSource  =  "ABCDE"   />  ]  
    </  Grille >   
   </  Fenêtre > 

C'est parti. Le RadGridView (avec le génial Fluent Theme appliqué) fonctionne dans le monde Python:

MVVM Ready

La plupart des affaires réelles Les applications dans WPF utilisent le modèle MVVM pour séparer la logique métier de la vue. Mais comment construire les fondations de MVVM dans notre projet Python WPF? Permettez-moi de vous guider.

1. Créez une classe de base de modèle de vue pour tous les futurs elle doit être propriété modifiée afin de notifier l'interface utilisateur pour les modifications des données:

 de   System.ComponentModel  import   INotifyPropertyChanged, PropertyChangedEventArgs  
  
   classe   ViewModelBase (INotifyPropertyChanged):  
    def   __ init __ ( self ):   
    self  .proper tyChangedHandlers  =   []   
  
    def   RaisePropertyChanged ( self propertyName ):   
    args  =   PropertyChangedEventArgs (propertyName)   
    pour   handler  in   self  .propertyChangedHandlers:   
    handler ( self args)   
     
    def   add_PropertyChanged ( self gestionnaire):   
    self  .propertyChangedHandlers.append (gestionnaire)   [19659002]     
    def   remove_PropertyChanged ( self gestionnaire):   [19659002]    self  .propertyChangedHandlers.remove (gestionnaire)  

2. Créez une classe Command, qui recevra des actions de l'interface utilisateur et les exécutera dans les ViewModels:

    
 de   System.Windows.Input  import   ICommand 
    
 
    
 class   Command (ICommande): 
    
  def   __ init __ ( self execute): 
    
  self  .execute  =  ] execute 
    
  
    
  def   Execute ( self paramètre): 
    
  self  .execute () 
    
  
    
 [19659083] def   add_CanExecuteChanged ( self gestionnaire): 
    
  pass 
    
  
    
  def   remove_CanExecuteChanged ( self  ]gestionnaire): 
    
  réussite 
    
 
    
  déf.   CanExecute ([19659085] self paramètre): 
    
  return   True 
    

3. Générez les classes ViewModel pour l'application qui connectera l'interface utilisateur aux données:

3.1. Définissez une classe ViewModel pour les données de chaque ligne DataGrid:

 classe   Club (ViewModelBase):  



  


               




    def   __ init __ ( self [19659021]nom, est, capacité, stadName):   
    ViewModelBase .__ init __ ( self )   [19659002]    self  .Name  =   nom   
    self  .Established . ] =   est   
    self  .StadiumCapacity  =   capacité   
    self  .StadiumName  =   stadName   

3.2. Définissez un ViewModel principal qui fournit une liste de modèles enfants et définit des commandes pour manipuler les données:

 à partir de   System.Collections.ObjectModel  import   ObservableCollection  
   de   datetime  importation   date  
  
   classe   ViewModel (ViewModelBase):  
    def   __ init __ ( self ):   
    ViewModelBase .__ init __ ( self )   
    self  .Clubs  =   ObservableCollection [Club] ()   
    self  .Clubs.Add (Club ( 'FC Barcelona' date ( 1899  11  29) [19659021]),  99354.0  'Camp Nou' ))   
    self  self  .Clubs.Add (Club ( «Juventus FC» date ( 1897  1  1 ),  41507.0 [19659020] 'Juventus Stadium' ))   
    self  .Clubs.Add (Club ( 'Real Madrid'  , date ( 1902  3  6 ),  81044.0  'Santiago Bernabeu' ))   
    self  .Clubs.Add (Club ( 'Liverpool' date ( 1892  1  1 ),  54074.0  'Anfield' ))   
   [19659088] s elf  .Clubs.Add (Club ( 'Manchester United' date ( 1878  1  1 ), [19659250] 76212.0  'Old Trafford' ))   
    self  .Clubs.Add (Club ([1965902020)] «Chelsea» date ( 1905  1  1 ),  42055.0  «Stamford Bridge» ))   
    self  .ClearCommand  =   Command ( self  .clear)  ]  
    self  .DecreaseCapacityCommand  =   Command ( self  .decreaseCapacity)   
     
    def   clair (  85] self ):   
    self  .Clubs.Clear ()   
  [19659002]    déf   diminutionCapacité ( auto ):   
    pour   club  ] dans   soi  .Clubs:   
    casquette  =   club.StadiumCapacity   
    club.StadiumCapacity  *  =   0.9   
    club.RaisePropertyChanged ( " StadiumCapacity ") 

Notez que lorsqu'une propriété a changé et nécessite une mise à jour de l'interface utilisateur, la fonction RaisePropertyChanged est appelée.

4. Attribuez le DataContext dans le code et les élémentsSource et commandes dans XAML:

 à partir de   System.Windows  importation   Application, fenêtre  
  
  [1945901919] classe   MyWindow (fenêtre):  
    def   __ init __ ( self ):   
    xaml  =   wpf.LoadComponent ( self  'WpfApplication1.xaml' )   
    xaml.Root.DataContext  =   ViewModel ()   
  
   si   __ nom__ [19659033] =  =   '__ main __' :  
    Application (). Run (MyWindow ()) 

 < telerik : RadGridView   ShowGroupPanel  =  "False" [1 9659038] telerik: StyleManager.Theme  =  "Fluent"  
    ItemsSource  =  "{Binding Clubs}"   Hauteur  =  "240"   
    AutoGenerateColumns  =  "Faux"   
 [1945902626]   EditTriggers  =  "None"   
    Margin  =  "30 30 30 50" >   
    < telerik: RadGridView.Columns >   
    < telerik: GridViewDataColumn   DataMemberBinding  =  "{Binding Nom} "  En-tête  = " Nom "  />   
    < telerik: GridViewDataColumn   DataMemberBinding  =  "{Binding Established}"   Header  =  "Established"   />   
   [19659053] < telerik: GridViewDataColumn   DataMemberBinding  =  "{Binding StadiumName}"   Header  =  "StadiumName"   />   
    < telerik: GridViewDataColumn   DataMemberBinding  =  "{Binding StadiumCapacity}"   En-tête  =  "StadiumCapacity"   DataFormatString  =  "n2"  />   
    </  telerik: RadGridView.Columns  >   [19659002]   </  telerik: RadGridView >  
  
   < StackPanel   Orientation  =  "Horizontal"   VerticalAlignment  =  "Bottom"   HorizontalAlignment  =  "Center" >  
    < telerik: RadButton   Contenu  =  "Clear Clubs"   Command  =  "{Binding ClearCommand}"   Margin  =  "20"   Largeur  =  "240"   
    telerik: StyleManager.Theme  = [19659020] "Courant"   />   
    < telerik: RadButton   Contenu  =  "Diminuer la capacité du stade 10 % "  Commande  = " {Binding DecreaseCapacity Commande} "  Marge  = " 20 "  Largeur  = " 240 "  
    telerik : StyleManager.Theme  =  "Fluent"   />   
   </  StackPanel > 

En conséquence , vous obtenez un DataGrid entièrement fonctionnel prêt pour MVVM avec des modifications de données reflétées dans l'interface utilisateur au moment de l'exécution:

Résumé [19659004] Il s'agissait d'une courte introduction à la combinaison de l'interface graphique de bureau Python et de l'interface utilisateur Telerik pour WPF. Je serai ravi de découvrir votre expérience avec l'intégration de Telerik UI for WPF dans vos projets Python.

N'hésitez pas à nous laisser un commentaire dans la section des commentaires ci-dessous sur la façon dont cela s'est passé avec nos composants ou à soumettre vos commentaires directement à notre Portail de commentaires .

---