Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 15:12  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Quizz
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Trucs et astuces
 · Articles divers

 · Articles in english


Twitter

Suivez-nous sur Twitter




Liste des jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z,
ALL


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Galeries

 · Menu des galeries

 · BD d'Amiga Spécial
 · Caricatures Dudai
 · Caricatures Jet d'ail
 · Diagrammes de Jay Miner
 · Images insolites
 · Fin de jeux (de A à E)
 · Fin de Jeux (de F à O)
 · Fin de jeux (de P à Z)
 · Galerie de Mike Dafunk
 · Logos d'Obligement
 · Pubs pour matériels
 · Systèmes d'exploitation
 · Trombinoscope Alchimie 7
 · Vidéos


Téléchargement

 · Documents
 · Jeux
 · Logiciels
 · Magazines
 · Divers


Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


Programmation : Premiers pas à la programmation avec Hollywood sur MorphOS
(Article écrit par jPV et extrait de MorphOS Library - septembre 2020)


Note : traduction par David Brunet.

1. Préface

Hollywood est une couche d'application multimédia multiplate-forme conçue par Airsoft Software. C'est un langage de programmation/script simple conçu pour la création d'applications graphiques ou multimédias, mais il peut également être utilisé pour créer d'autres types de programmes, notamment grâce à sa gamme complète de greffons. Hollywood est également plus ou moins basé sur le populaire langage Lua.

Les programmes Hollywood sont créés en écrivant des fichiers de script, qui sont ensuite exécutés à partir du programme principal Hollywood, ou ils peuvent être compilés en "applets" ou en exécutables autonomes pour être utilisés sans l'environnement Hollywood.

Les applets sont de petits fichiers binaires indépendants de la plate-forme qui peuvent être exécutés à l'aide du lecteur gratuit d'Hollywood sur toute plate-forme gérée par Hollywood. Les exécutables autonomes contiennent le lecteur, un script et des fichiers de données facultatifs liés dans un seul fichier exécutable. Le fait de lier l'ensemble du binaire du lecteur dans un exécutable fait que la taille minimale des exécutables d'Hollywood est d'environ 2 Mo sur MorphOS, mais les programmes qui en résultent sont complètement indépendants et peuvent être exécutés sans installation préalable.

Ce qui rend Hollywood spécial est sa capacité à réaliser des compilations croisées de programmes entre toutes les plates-formes gérées. Des programmes pour Windows, Linux, macOS ou AmigaOS peuvent être compilés en utilisant MorphOS, et inversement. Les programmes compilés de manière croisée ne nécessitent généralement aucune modification et le même script source fonctionnera sur toutes les plates-formes.

Hollywood est un langage facile, sûr et très bien documenté, et convient donc également aux débutants. Tous les programmes Hollywood s'exécutent à l'intérieur d'un bac à sable, et vous ne pouvez pas casser ou planter le système d'exploitation sous-jacent avec vos erreurs de programmation. Si un bogue provoque une erreur dans l'exécution du script, Hollywood ferme simplement le programme et libère les ressources sans autre dommage.

2. Pour commencer

2.1 Pré-requis

Hollywood

Hollywood est un produit commercial qui peut être acheté ici. Le paquet principal est suffisant pour la programmation et la compilation avec Hollywood pour toutes les autres plates-formes, sauf Android (le compilateur APK pour Windows est nécessaire pour la gestion d'Android).

Hollywood Designer est une extension uniquement disponible sur Amiga qui permet de créer des présentations multimédias via une interface graphique WYSIWYG. Il fonctionne sur les plates-formes compatibles Amiga, y compris MorphOS, mais les présentations résultantes peuvent être compilées pour toute autre plate-forme gérée. De toute façon, cette extension n'est pas nécessaire pour programmer avec Hollywood, mais votre propre code peut aussi être inséré dans les scripts de présentation.

Éditeur de texte

Hollywood dispose d'un IDE (environnement de développement intégré) pour Windows, mais sur les autres plates-formes, un éditeur de texte ou un IDE tiers est nécessaire.

La façon la plus simple de commencer est avec Flow Development Studio, qui est fourni avec MorphOS. Il comprend un analyseur syntaxique pour Hollywood, et offre la coloration syntaxique et d'autres fonctionnalités.

Cubic IDE reste probablement l'environnement de développement le plus complet pour la programmation Hollywood sur MorphOS, bien qu'il soit un peu dépassé sur certains points. Par exemple, il ne gère pas l'UTF-8 et l'interface graphique n'est pas aussi flexible qu'une interface graphique MUI. Avec le greffon Cubic IDE pour Hollywood, vous disposez de la coloration syntaxique, de la casse automatique, de l'aide en ligne, de l'accès rapide à la documentation, de l'indentation automatique, de la correspondance des parenthèses, de la complétion automatique des mots-clés, d'options de compilation et d'exécution, et de bien d'autres choses encore.

Hollywood tutoriel
Cubic IDE avec le greffon Hollywood

MiniHollyEdit NG pourrait également être une bonne option gratuite, mais il est défectueux dans son état actuel et a besoin d'une mise à jour.

Un IDE avec une gestion d'Hollywood est bien sûr la solution la plus confortable, mais tout autre éditeur de texte fera également l'affaire.

2.2 Exécution d'un script

Les scripts d'Hollywood peuvent être exécutés à partir de l'exécutable principal d'Hollywood (l'interpréteur), et bien que l'exécutable principal accepte des dizaines d'arguments en ligne de commande, vous n'avez généralement pas besoin de beaucoup d'entre eux.

Lorsque vous développez et testez votre application, il suffit d'exécuter le script sans le compiler. Il est recommandé d'enregistrer vos scripts avec l'extension ".hws".

Pour exécuter un script à partir du Shell, tapez :

Hollywood MyProgram.hws

Et sans la fenêtre d'information, tapez :

Hollywood MyProgram.hws -quiet

Hollywood tutoriel
Exécuter un script

Hollywood possède un moniteur de ressources intégré, qui peut être activé avec l'argument "-resourcemonitor". Vous devriez vérifier les ressources que votre application utilise et que vous n'augmentez pas inconsidérément l'utilisation de la mémoire :

Hollywood MyProgram.hws -resourcemonitor

Hollywood tutoriel
Moniteur de ressources

Si vous utilisez Cubic IDE, vous n'avez pas besoin du Shell. Vous pouvez simplement appuyer sur la touche "F4" pour exécuter le script ou sélectionner d'autres options d'exécution dans les menus de Cubic IDE.

2.3 Compilation d'un script

Lorsqu'une application est prête à être publiée, elle doit être compilée dans un exécutable autonome, ce qui est fait avec l'argument "-compile" :

Hollywood MyProgram.hws -compile MyProgram

Avec la commande ci-dessus, vous obtenez un exécutable appelé "MyProgram" qui fonctionnera sur la même architecture que celle sur laquelle il a été compilé.

Pour compiler une application pour différentes plates-formes (AmigaOS 4 dans cet exemple), tapez :

Hollywood MyProgram.hws -compile MyProgram -exetype amigaos4

Ou pour plusieurs plates-formes à la fois :

Hollywood MonyProgram.hws -compile MyProgram -exetype morphos|amigaos4|win32|applet

Hollywood tutoriel
Compilation d'un script

Si vous souhaitez compresser vos propres données (script et fichiers de données liés), ajoutez l'argument "-compress" :

Hollywood MyProgram.hws -compile MyProgram -exetype morphos|amigaos4|win32|applet -compress

La compression peut rendre les exécutables plus petits, mais elle permet également de "cacher" toute donnée, qui est normalement en clair dans les exécutables, si vous préférez cela.

La compilation dans Cubic IDE se fait simplement en appuyant sur la touche "F2" ou en sélectionnant la plate-forme pour la compilation croisée dans les menus.

3. Exemple 1 : premier test

Tapez ceci dans un éditeur de texte et sauvegardez-le dans un fichier appelé "RAM:firsttest.hws" :

@BGPIC 1, "SYS:MorphOS/Prefs/Wallpapers/1024x768/Arida.png"
TextOut(100,10, "Hello World!")
WaitLeftMouse()
; Le programme se termine après la dernière ligne d'un script, mais vous pouvez aussi le terminer avec la commande End()

La première ligne est une commande de préprocesseur qui charge le fichier image donné en tant qu'image d'arrière-plan d'Hollywood. Les objets dans Hollywood sont gérés par leurs numéros d'identification, et dans ce cas, nous chargeons l'image comme un "bgpic numéro 1". Ce bgpic est également chargé initialement lorsque l'application ouvre sa fenêtre.

Toutes les commandes du préprocesseur sont préfixées par le caractère "@" et traitées avant l'exécution du script proprement dit. Les fichiers de données chargés avec les commandes du préprocesseur sont également liés à l'exécutable lors de la compilation d'un programme. Si vous ne souhaitez pas lier les fichiers, vous pouvez les charger séparément plus tard dans le script.

La deuxième ligne affiche le texte "Hello World!" à x=100, y=10 (en pixels) sur l'image de fond.

La troisième ligne attend que l'utilisateur appuie sur le bouton gauche de la souris. Sans cette ligne, le programme se contenterait de se terminer et de fermer sa fenêtre, et nous ne verrions pas grand-chose.

La dernière ligne est une ligne de commentaire, qui est juste une note à l'intérieur du code. Les lignes de commentaire peuvent être insérées entre "/*" et "*/", ou le reste de la ligne peut être commenté avec le caractère ";".

Exécutons le script pour voir les résultats. Appuyez sur la touche "F4" dans Cubic IDE ou tapez ceci dans le Shell :

Hollywood RAM:firsttest.hws -quiet

Hollywood tutoriel
firsttest.hws en exécution

Hollywood ouvre une nouvelle fenêtre et prend ses dimensions à partir de l'image de fond. Si nous ne préchargeons pas d'image d'arrière-plan, l'écran sera ouvert dans la résolution par défaut de 640x480, ou vous pouvez définir ses dimensions avec la commande de préprocesseur "@DISPLAY".

Ensuite, nous allons compiler le programme dans un exécutable autonome. Appuyez sur la touche "F2" dans Cubic IDE ou utilisez le Shell (vous n'avez pas besoin de définir les chemins si vous avez déjà changé le répertoire en RAM: dans le Shell) :

Hollywood RAM:firsttest.hws -compile RAM:firsttest

Nous avons maintenant un nouveau fichier exécutable qui contient également les graphiques d'arrière-plan prétraités/liés. Le programme fonctionne même si vous n'avez pas le fichier Arida.png dans le système.

4. Exemple 2 : programmation Hollywood

@VERSION 6,0
@APPTITLE "Hollywood Example"
@APPVERSION "$VER: Hollywood Example 1.0 (31.10.17)"
@APPDESCRIPTION "A Hollywood example program."
@DISPLAY {Title="Hollywood Example", ScreenTitle="Hollywood Example", Width=400,
Height=300, Sizeable=True, Layers=True, ScaleMode=#SCALEMODE_LAYER, SmoothScale=True}
@BRUSH 1, "MOSSYS:Data/Jalapeno/ReadMode.png", {LoadAlpha=True}

Function p_DrawGfx()
    Local brush_number = Rnd(2) + 1
    If LayerExists("gfx") Then RemoveLayerFX("gfx")
    SetDisplayAttributes({Title = "Brush " .. brush_number})
    DisplayBrushFX(brush_number, #CENTER, #CENTER)
    SetLayerName(0, "gfx")
EndFunction

Function p_Input(msg)
    DebugPrint("Input event!", msg.Action)
    Switch(msg.Action)
    Case "OnKeyDown":
        DebugPrint(msg.Key, "key was pressed.")
        Switch(msg.Key)
        Case " ":
            p_DrawGfx()
        Case "ESC":
            DebugPrint("Quitting...")
            End
        EndSwitch
    Case "OnMouseDown":
        p_DrawGfx()
    EndSwitch
EndFunction

LoadBrush(2, "MOSSYS:Data/Jalapeno/TrackMode.png", {LoadAlpha=True})
p_DrawGfx()

InstallEventHandler({OnKeyDown = p_Input, OnMouseDown = p_Input})

Repeat
   WaitEvent
Forever

L'exemple précédent (exemple 1 : premier test) pourrait être étendu pour avoir plus de commandes à exécuter en lot, ce qui pourrait être bien pour des présentations ou des diaporamas, mais prenons une approche plus pratique et créons un script interactif dont la structure ressemble à un vrai programme.

@VERSION 6,0

Cette commande de préprocesseur définit quelle version d'Hollywood est requise pour exécuter le script. Si vous souhaitez exécuter cet exemple avec une version antérieure d'Hollywood, supprimez l'attribut "ScreenTitle" de la ligne du préprocesseur "@DISPLAY".

@APPTITLE "Hollywood Example"
@APPVERSION "$VER: Hollywood Example 1.0 (26.10.17)"
@APPDESCRIPTION "A Hollywood example program".

Il existe plusieurs commandes de préprocesseur pour ajouter des chaînes d'information à une application. Ces trois sont particulièrement utiles pour les programmes Amiga et MorphOS, car les programmes Hollywood se comportent comme des commodités et vous verrez ces informations par exemple dans le programme Exchange. Le format "@APPVERSION" doit respecter les règles standards des chaînes de version, ce qui signifie que la date doit être donnée au format JJ.MM.AA, etc.

@DISPLAY {Title="Hollywood Example", ScreenTitle="Hollywood Example", Width=400, Height=300, Sizeable=True, Layers=True, ScaleMode=#SCALEMODE_LAYER, SmoothScale=True}

Cette fois, nous n'utilisons pas le préprocesseur "@BGPIC", mais nous définissons manuellement la taille de l'affichage et ajoutons quelques attributs supplémentaires.

"Title" définit ce qui sera affiché dans la barre de titre de la fenêtre, et "ScreenTitle" ce qui est affiché dans la barre de titre de l'écran lorsque la fenêtre de notre programme est active.

Les attributs "Width" et "Height" définissent la zone de dessin réelle (affichage) de notre application. La fenêtre de l'application elle-même sera un peu plus grande avec les bordures de fenêtre standard du système d'exploitation ajoutées autour de ce qu'affiche le programme Hollywood. Il est également possible d'ouvrir des fenêtres sans bordure et en plein écran sans les bordures de fenêtre standard.

L'attribut "Sizeable" définit si la fenêtre de l'application est redimensionnable par l'utilisateur.

"Layers=True" active le système de couches d'Hollywood. L'activation ou non des couches dépend du programme que vous développez. Lorsque les couches sont activées, toutes les opérations de dessin ont leur propre couche qui peut être déplacée, supprimée et traitée de toute autre manière. Lorsqu'ils sont désactivés, tous les graphismes sont simplement affichés les uns sur les autres à l'écran et il est plus difficile de modifier ou d'annuler les choses. Mais si vous ne faites qu'afficher des graphismes en plein écran, il est préférable de garder les couches désactivées.

"ScaleMode" définit si le contenu de l'affichage est mis à l'échelle automatiquement lorsque la taille de l'affichage change. Souvent, il est préférable de laisser cette option désactivée et de recalculer vos propres graphismes après un événement de redimensionnement afin de conserver le rapport d'aspect intact et d'éviter les ralentissements, mais activons-la maintenant pour obtenir plus de fonctionnalités dans notre application sans lignes de code supplémentaires.

"SmoothScale" rend la mise à l'échelle plus esthétique au détriment de la vitesse.

@BRUSH 1, "MOSSYS:Data/Jalapeno/ReadMode.png", {LoadAlpha=True}

Les brosses sont le moyen le plus courant de charger, traiter et afficher des graphismes dans Hollywood. Cette ligne du préprocesseur charge une image PNG en tant que brosse avec le numéro d'identification 1. Toutes les opérations de manipulation de la brosse sont effectuées en se référant au numéro d'identification à partir de maintenant. Le dernier argument est un tableau optionnel contenant toutes les options supplémentaires pour le chargement. Nous utilisons maintenant des graphismes avec un canal alpha (transparence), nous demandons donc à Hollywood de charger également les valeurs du canal alpha.

Function p_DrawGfx()
    Local brush_number = Rnd(2) + 1
    If LayerExists("gfx") Then RemoveLayerFX("gfx")
    SetDisplayAttributes({Title = "Brush " .. brush_number})
    DisplayBrushFX(brush_number, #CENTER, #CENTER)
    SetLayerName(0, "gfx")
EndFunction

C'est ainsi que vous créez vos propres fonctions dans Hollywood. Les noms de nos propres fonctions doivent toujours commencer par le préfixe "p_" pour les distinguer des fonctions internes d'Hollywood. Dans ce cas, la fonction ne prend aucun paramètre et ne renvoie aucune valeur, elle peut simplement être appelée depuis le programme avec "p_DrawGfx()" pour exécuter les lignes qu'elle contient.

Le but de cette fonction est d'afficher une des deux brosses que nous avons en mémoire. Les numéros d'identification des brosses sont 1 et 2, et nous en choisissons une au hasard. Comme nous avons activé le système de couches, nous obtenons une nouvelle couche chaque fois que nous dessinons une brosse à l'écran. Pour éviter de se retrouver avec un nombre illimité de couches, nous supprimons d'abord une couche existante. Nous changeons également le texte de la barre de titre de la fenêtre pour afficher le numéro de la brosse affichée.

Hollywood tutoriel
"Hollywwod Example" en exécution

La première ligne de la fonction déclare une nouvelle variable locale appelée "brush_number" et lui attribue une valeur aléatoire (1 ou 2). Vous devez déclarer les nouvelles variables en tant que variables locales chaque fois que cela est possible ; vous trouverez plus d'informations à ce sujet ici.

La deuxième ligne vérifie si un calque spécifique a déjà été créé, et le supprime avec un effet aléatoire fantaisiste si c'est le cas. Cette ligne est simplement sautée lorsque la fonction est appelée la première fois, car nous n'avons pas encore de couche spécifique.

La troisième ligne modifie le texte du titre de la fenêtre avec le numéro de brosse obtenu à la première ligne. Presque tous les attributs d'affichage peuvent être modifiés à la volée, et vous n'êtes pas limité à ceux que vous avez définis avec la commande du préprocesseur "@DISPLAY". Ici, vous pouvez également voir comment vous pouvez combiner une chaîne de caractères à partir d'autres chaînes ou variables avec l'opérateur ".." qui est familier à Lua.

"DisplayBrushFX()" affiche la brosse sélectionnée et crée une nouvelle couche sur la pile de couches. La position de la brosse peut être donnée en pixels, mais aussi en utilisant des constantes intégrées comme "#CENTER". "FX" à la fin du nom de la fonction indique qu'il y a un effet de transition affiché lorsque la fonction est appelée. Dans la plupart des cas, ils sont un peu exagérés et vous finirez probablement par utiliser "DisplayBrush()" ou d'autres options pour faire le rendu des graphismes.

Les couches obtiennent automatiquement des numéros d'identification et ils sont attribués dynamiquement, ce qui signifie que la suppression d'une couche modifie les numéros d'identification des couches situées au-dessus d'elle. Pour nous faciliter la vie, nous pouvons nommer les couches et les gérer par leur nom plutôt que par leur numéro d'identification. "SetLayerName()" est une façon de le faire, et nous l'utilisons ici pour nommer la couche avec la brosse. La fonction accepte un numéro d'identification et un nom de couche comme paramètres. Notre brosse affichée crée la première couche de la pile de couches et son numéro d'identification sera donc 1. "SetLayerName(1,"gfx")" fonctionnerait dans ce cas, et notre couche recevrait le nom "gfx" comme prévu. Mais pour rendre la vie encore plus facile, nous pouvons attribuer le numéro d'identification 0 comme premier paramètre, et le nom sera donné à la dernière couche créée. De cette façon, il n'est pas nécessaire de compter les couches.

Function p_Input(msg)
    DebugPrint("Input event!", msg.Action)
    Switch(msg.Action)
    Case "OnKeyDown":
        DebugPrint(msg.Key, "key was pressed.")
        Switch(msg.Key)
        Case " ":
            p_DrawGfx()
        Case "ESC":
            DebugPrint("Quitting...")
            End
        EndSwitch
    Case "OnMouseDown":
        p_DrawGfx()
    EndSwitch
EndFunction

Voici une autre fonction créée par nos soins. Elle est utilisée pour gérer les événements de saisie de l'utilisateur. Les fonctions de gestion des événements recevront un tableau de messages comme paramètre, et nous l'obtiendrons comme variable locale appelée "msg".

"DebugPrint()" est une fonction utile pour vérifier les valeurs que nous avons dans certaines variables pendant l'exécution du programme. N'hésitez pas à l'utiliser temporairement pour apprendre quels résultats vous obtenez avec les différentes fonctions et quelles valeurs vous avez dans les variables. Ici, elle est utilisée pour imprimer le champ "Action" de la table des messages, qui nous indique le nom de l'événement qui s'est produit.

Si l'utilisateur appuie sur une touche, nous obtenons un événement "OnKeyDown", et si l'utilisateur appuie sur le bouton gauche de la souris, nous obtenons un événement "OnMouseDown". Une liste complète des événements standards est disponible ici.

Dans cet exemple, nous gérons les différents événements à l'aide d'une instruction "Switch-Case", mais n'hésitez pas à utiliser d'autres méthodes si vous le souhaitez. Il est également possible d'avoir une fonction distincte pour chaque événement.

Si nous jetons un coup d'oeil à la documentation, nous voyons que l'événement "OnKeyDown" contient la touche exacte qui a été pressée dans son champ "Key". On peut y accéder avec l'élément de table "msg.Key" dans notre fonction.

L'instruction interne "Switch-Case" vérifie si la touche pressée était "Espace" ou "Échappement". S'il s'agit d'une touche "Espace", notre fonction de dessin précédente est appelée et de nouveaux graphismes s'affichent à l'écran, tandis qu'en appuyant sur la touche "Échappement", le programme s'arrête avec un message. Si vous appuyez sur n'importe quelle autre touche, vous n'aurez qu'à imprimer la touche sans rien faire d'autre.

Le fait d'appuyer sur le bouton gauche de la souris appelle également notre fonction de dessin précédente, et l'écran est rafraîchi.

LoadBrush(2, "MOSSYS:Data/Jalapeno/TrackMode.png", {LoadAlpha=True})

La première image de notre programme d'exemple a été chargée avec la commande du préprocesseur "@BRUSH", mais chargeons la deuxième image séparément. La différence entre les deux est qu'en procédant de la sorte, l'image n'est pas liée à notre fichier exécutable lorsque nous compilons le programme. L'image est chargée depuis le système de fichiers à chaque fois que vous exécutez le programme, qu'il ait été compilé ou non.

p_DrawGfx()

Maintenant que les deux images sont chargées en tant que brosses, nous pouvons appeler la fonction que nous avons définie plus tôt, et nous obtenons des graphismes affichés dans la fenêtre de l'application.

InstallEventHandler({OnKeyDown = p_Input, OnMouseDown = p_Input})

Notre fonction "p_Input()" définie précédemment ne reçoit aucun événement à moins que nous n'installions des gestionnaires d'événements. Un tableau transmis à la fonction "InstallEventHandler()" définit les événements qui sont pris en compte et les fonctions qu'ils appellent lorsqu'ils sont déclenchés. Ici, nous définissons à la fois les événements "OnKeyDown" et "OnMouseDown" pour appeler notre propre fonction "p_Input()", et l'entrée utilisateur fonctionnera à partir de maintenant. Comme vous pouvez le constater, les événements peuvent appeler la même fonction ou appeler d'autres fonctions si nécessaire.

Repeat
    WaitEvent
Forever

Voici la boucle principale du programme. La fonction "WaitEvent" est appelée de manière répétée tant que notre programme est en cours d'exécution et elle attend uniquement qu'un événement se produise. Le programme se contente de rester en sommeil et ne gaspille pas de temps processeur lorsqu'il n'y a pas d'événement.

Enregistrez le script sous le nom de "hwexample.hws" et exécutez-le avec la commande Hollywood "hwexample.hws -quiet" à partir du Shell ou avec la touche "F4" dans Cubic IDE.

5. Exemple 3 : interface graphique adaptée au système

5.1 Préface

Les applications standards d'Hollywood sont quelque peu limitées lorsqu'il s'agit d'y implémenter des fonctionnalités d'interface graphique. Il est possible de créer des menus système et toutes sortes de requêtes, mais si vous voulez des boutons ou d'autres éléments d'interface graphique dans l'affichage d'Hollywood, vous devez les créer avec vos propres graphismes et les gérer de manière personnalisée.

Heureusement, Hollywood dispose d'un puissant système de greffons multiplate-forme, et de nombreux greffons intéressants sont disponibles. Certains des plus impressionnants sont les greffons MUI Royale et RapaGUI, qui peuvent être utilisés pour créer des interfaces graphiques natives adaptées au système pour les applications. Les deux sont des greffons officiels de l'auteur d'Hollywood, et sont donc bien gérés et documentés.

MUI Royale, comme son nom l'indique, vous permet de créer des interfaces graphiques MUI pour les plates-formes compatibles Amiga. RapaGUI, d'autre part, est une véritable bête à son niveau, car il vous permet de créer des interfaces graphiques qui fonctionnent sur plusieurs plates-formes complètement différentes en utilisant la boîte à outils sous-jacente sur chaque plate-forme. Qu'elle soit compatible avec Windows, Linux, Mac ou Amiga, il suffit d'écrire une définition d'interface graphique pour qu'elle fonctionne sur tous les systèmes d'exploitation sans modification. Lorsque vous exécutez une application RapaGUI, elle aura la même apparence que les autres programmes sur chaque plate-forme, car elle utilise MUI sur les compatibles Amiga, GTK sur Linux, et ainsi de suite.

MUI Royale et RapaGUI sont tous deux très similaires - la définition d'une interface graphique est créée en écrivant un fichier XML, qui est ensuite inclus dans votre programme Hollywood. L'exemple suivant est réalisé avec MUI Royale, car nous nous concentrons maintenant sur la programmation d'Hollywood sous MorphOS, et MUI Royale offre un peu plus de fonctionnalités spécifiques au système d'exploitation que RapaGUI, plus générique. Quoi qu'il en soit, lorsque vous avez appris l'un d'entre eux, il est facile de passer à l'autre.

La chose la plus importante à apprendre maintenant est de regarder les informations sur l'applicabilité dans la documentation. L'applicabilité de chaque attribut d'objet disponible est décrite dans sa page de documentation. L'applicabilité est simplement indiquée par quatre lettres : I, S, G et N. S'il y a "I", vous pouvez utiliser l'attribut à l'initialisation, ce qui signifie qu'il peut être utilisés lors de l'écriture du fichier XML. "S" (définit la valeur d'un attribut d'objet MUI) et "G" (obtient la valeur d'un attribut d'objet MUI) peuvent être utilisé à partir du script Hollywood actuel au moment de l'exécution. "N" peut être utilisé dans les deux cas pour gérer les notifications d'attributs.

5.2 Fichier XML

<?xml version="1.0" encoding="iso-8859-1"?>
<application base="HWEXAMPLE" id="app" dropobject="disp" icon="muiexample.info">
   <menustrip id="examplemenustrip">
      <menu title="Project">
         <item id="menu_about" notify="selected">About...</item>
         <item id="menu_about_mui" notify="selected">About MUI...</item>
         <item id="menu_about_muiroyale" notify="selected">About MUI Royale...</item>
         <item/>
         <item id="menu_quit" notify="selected" shortcut="Q">Quit</item>
      </menu>
      <menu title="Settings">
         <item id="menu_muisettings" notify="selected">MUI...</item>
      </menu>
   </menustrip>
   <window id="win" muiid="MAIN" title="Hollywood MUI Example" screentitle="Hollywood MUI Example 1.0"
notify="closerequest" menustrip="examplemenustrip" appwindow="true">
   <vgroup>
       <hgroup>
           <button id="button1" notify="pressed" cyclechain="true" shorthelp="Displays brush 1">Brush _1</button>
           <button id="button2" notify="pressed" cyclechain="true" shorthelp="Displays brush 2">Brush _2</button>
       </hgroup>
       <hgroup>
          <button id="button_random" notify="pressed" cyclechain="false" shorthelp="Displays a random brush">_Random</button>
           <rectangle/>
           <text id="clock" preparse="\33r">00:00:00</text>
       </hgroup>
       <hollywood id="disp" display="1" minwidth="32" minheight="32" maxwidth="16384" maxheight="16384" notify="appmessage"/>
   </vgroup>
  </window>
</application>

Regardons d'abord le fichier XML. Créez un fichier texte et enregistrez-le sous le nom de "muigui.xml".

<?xml version="1.0" encoding="iso-8859-1"?>

Il s'agit d'une ligne de prologue XML standard, et le fichier devrait commencer par elle. "ISO-8859-1" pourrait être un choix plus sûr qu'UTF-8 dans notre cas. "Version" signifie la version du langage de balisage XML, pas la version de l'application. Copiez et collez simplement cette ligne telle quelle.

<application base="HWEXAMPLE" id="app" dropobject="disp" icon="muiexample.info">

L'objet "application" est l'objet maître, et toutes les autres définitions doivent se trouver sous lui dans l'arbre des objets.

L'attribut "base" (applicabilité IG) est important ici, car il définit le nom utilisé lors de la sauvegarde des préférences MUI et il est également utilisé lors de la création d'un port ARexx pour l'application. N'utilisez pas d'espaces ou de caractères spéciaux, et essayez de choisir un nom unique qui ne sera pas utilisé par d'autres programmes.

L'attribut "id" (I) est nécessaire pour chaque objet auquel vous prévoyez d'accéder plus tard à partir du script Hollywood. Il est bien de l'avoir défini pour l'objet d'application aussi.

Les deux derniers attributs sont plutôt optionnels, mais prenons-les comme exemples, car ils sont assez utiles en général. L'attribut "dropobject" (IS) définit quel objet est notifié si vous glissez et déposez un fichier sur son AppIcon. Dans ce cas, l'objet appelé "disp", que nous définirons plus tard, reçoit la notification.

Une icône pour l'application peut être définie avec l'attribut "icon" (I). Sans chemin, il prend le fichier du répertoire à partir duquel le programme a été lancé.

Comme vous pouvez le constater, tous ces attributs ont "I" dans leurs informations d'applicabilité. Lorsque vous parcourez la documentation et recherchez de nouveaux attributs ou la manière de faire certaines choses, l'applicabilité vous indique si vous pouvez les utiliser dans le fichier XML ou pendant l'exécution du programme.

<menustrip id="examplemenustrip">
      <menu title="Project">
          <item id="menu_about" notify="selected">About...</item>
          <item id="menu_about_mui" notify="selected">About MUI...</item>
          <item id="menu_about_muiroyale" notify="selected">About MUI Royale...</item>
          <item/>
          <item id="menu_quit" notify="selected" shortcut="Q">Quit</item>
      </menu>
      <menu title="Settings">
          <item id="menu_muisettings" notify="selected">MUI...</item>
      </menu> 
</menustrip>

Chaque application MUI devrait contenir un menu déroulant avec des éléments pour ouvrir les fenêtres "A propos de MUI" et "A propos de MUI Royale", ainsi qu'un élément pour ouvrir le programme de préférences MUI. Nous définissons un menu ici et l'assignons plus tard à la fenêtre principale de notre programme. N'oubliez pas de définir des attributs "id" pour tous les éléments fonctionnels ainsi que pour l'objet "menustrip" lui-même. Ajoutons également notre propre fenêtre "A propos" comme premier élément du menu "Projet" et une option "Quitter" comme dernier élément. La ligne "<item/>" ajoute une barre de séparation au menu.

Hollywood tutoriel
"A propos de MUI" et "A propos de MUI Royale" dans le menu

Si nous voulons être informés lorsque l'utilisateur sélectionne un élément du menu, nous devons ajouter des balises "notify" aux éléments. Pour en savoir plus sur le mécanisme de notification, cliquez ici. En lisant le chapitre de la documentation consacré à la classe "Menuitem", nous constatons que l'attribut "Selected" a une applicabilité de "N", ce qui signifie que nous pouvons lui attribuer une notification. Ainsi, notify="selected" fait l'affaire.

Vous pouvez également définir des raccourcis clavier pour tous les éléments de menu à l'aide de l'attribut "Shortcut". Dans cet exemple, nous pouvons quitter le programme en appuyant sur la combinaison de touches "Commande-q".

N'oubliez pas non plus les traditionnelles règles de style Amiga. Si un élément ouvre une nouvelle fenêtre interactive ou un requérant, ajoutez "..." à la fin de celui-ci.

<window id="win" muiid="MAIN" title="Hollywood MUI Example" screentitle="Hollywood MUI Example 1.0" notify="closerequest" menustrip="examplemenustrip" appwindow="true">

Il est ensuite temps de définir notre fenêtre d'application. L'attribut le plus important est "muiid", car sans lui, les utilisateurs ne peuvent pas modifier la taille ou la position de la fenêtre. muiid doit comporter exactement quatre caractères, et chaque fenêtre de votre programme doit avoir une valeur muiid différente. Il importe peu que vous utilisiez le même ID (comme "MAIN") dans différents programmes, car ils enregistrent leurs paramètres dans des fichiers différents.

L'attribut "title" définit le texte de la barre de titre de la fenêtre de notre programme, et l'attribut "screentitle" définit le texte affiché dans la barre de titre de l'écran lorsque notre fenêtre est active.

La notification "closerequest" nous indique si le gadget de fermeture de la fenêtre a été cliqué, et nous pouvons y réagir dans notre script principal d'Hollywood.

L'objet "menu" que nous avons défini précédemment peut être spécifié pour cette fenêtre avec l'attribut "menustrip". Si vous utilisez plusieurs fenêtres dans une application et que vous souhaitez voir le même menu dans toutes ces fenêtres, déplacez cet attribut de la définition "<window>" vers la définition "<application>".

Le dernier attribut "appwindow" nous permet d'écouter si une icône (un fichier) est glissée et déposée sur la fenêtre de notre programme. Il peut être laissé de côté si vous n'en avez pas besoin.

<vgroup>
     <hgroup>
         <button id="button1" notify="pressed" cyclechain="true" shorthelp="Displays brush 1">Brush _1</button>
         <button id="button2" notify="pressed" cyclechain="true" shorthelp="Displays brush 2">Brush _2</button>
     </hgroup>

Les objets de notre fenêtre peuvent être organisés en groupes verticaux ou horizontaux. Ici, nous créons un groupe vertical avec des groupes horizontaux plus petits à l'intérieur. Sur ces lignes, nous définissons que nous avons deux boutons l'un à côté de l'autre horizontalement.

Si nous lisons la documentation de la classe "Button" (Bouton), nous voyons que nous pouvons être notifiés par l'attribut "Pressed" (Pressé). Nous pourrions également être notifiés par l'attribut "Selected" (Sélectionné) si nous créons un bouton "Toggle" (Commutateur).

Hollywood tutoriel
Notre exemple d'interface MUI

Les attributs "cyclechain" et "shorthelp" sont intéressants, car ils ne sont pas spécifiques à un bouton. Ce sont en fait des attributs de la classe "Area" (Aire), qui est une super classe pour presque tout le reste, et vous pouvez utiliser ses attributs avec presque tous les objets. Lorsque vous définissez un objet, vous pouvez également consulter les attributs dans la documentation de la classe "Area".

L'attribut "cyclechain" définit si vous pouvez activer l'objet à partir du clavier en utilisant la touche de tabulation. En général, vous devriez autoriser cette possibilité.

Le contenu du texte de la bulle d'aide MUI peut être défini avec l'attribut "shorthelp". Une infobulle s'ouvre si vous maintenez le pointeur de la souris sur un objet pendant un certain temps.

Un trait de soulignement dans le nom du bouton fait du caractère suivant un raccourci clavier. On peut appuyer sur "1" ou "2" sur le clavier pour appuyer sur un bouton maintenant.

<hgroup>
   <button id="button_random" notify="pressed" cyclechain="false" shorthelp="Displays a random brush">_Random</button>
   <rectangle/>
   <text id="clock" preparse="\33r">00:00:00</text>
</hgroup>

Nous définissons ici un autre groupe horizontal dont les objets sont affichés sous le groupe précédent.

Le nouveau bouton ici est retiré du "cyclechain" à titre d'exemple ; vous ne pouvez pas l'activer avec la touche de tabulation.

"<rectangle/>" ajoute un espace dynamique entre deux objets. Cela peut être très utile lors de la conception d'une interface graphique, et surtout si vous avez quelques problèmes de redimensionnement.

L'objet "text" (texte) affiche simplement un texte, mais nous prévoyons de mettre à jour le texte plus tard avec l'heure actuelle. Mettons quand même quelque chose comme valeur initiale. L'attribut "preparse" (préparer) contient un code de format pour le texte, et nous l'utilisons pour aligner le texte à droite maintenant.

<hollywood id="disp" display="1" minwidth="32" minheight="32" maxwidth="16384" maxheight="16384" notify="appmessage"/>

Cet objet n'est pas à l'intérieur d'un groupe horizontal et prend toute la largeur de la fenêtre.

L'objet "hollywood" incorpore un affichage Hollywood complet dans l'interface graphique. "display" définit le numéro d'identification de l'affichage Hollywood que vous voulez afficher dans l'objet. En définissant les tailles, l'objet est également redimensionnable. Si vous voulez faire des programmes MUI sans l'affichage graphique d'Hollywood, c'est très bien aussi.

        </vgroup>
    </window>
</application>

Après avoir terminé nos définitions, nous avons un code fonctionnel pour la partie interface graphique de notre programme !

5.3 Script Hollywood

Code source

@VERSION 5,2
@APPTITLE "Hollywood MUI Example"
@APPVERSION "$VER: Hollywood MUI Example 1.0 (31.10.17)"
@APPDESCRIPTION "A Hollywood example program."
@REQUIRE "muiroyale", {Version=1, Revision=7}
@DISPLAY {Hidden=True, Width=400, Height=300, Sizeable=True, Layers=True, ScaleMode=#SCALEMODE_LAYER, SmoothScale=True}
@BRUSH 1, "MOSSYS:Data/Jalapeno/ReadMode.png", {LoadAlpha=True}
@FILE 1, "muigui.xml"

Function p_DrawGfx(brush_number)
    If Not brush_number Then brush_number = Rnd(2) + 1
    If LayerExists("gfx") Then RemoveLayerFX("gfx")
    mui.Set("win", "title", "Brush " .. brush_number)
    DisplayBrushFX(brush_number, #CENTER, #CENTER)
    SetLayerName(0, "gfx")
EndFunction

Function p_Input(msg)
    DebugPrint("Input event!", msg.Action)
    Switch(msg.Action)
    Case "OnKeyDown":
        DebugPrint(msg.Key, "key was pressed.")
        Switch(msg.Key)
        Case " ":
            p_DrawGfx()
        Case "ESC":
            DebugPrint("Quitting...")
            End
        EndSwitch
    Case "OnMouseDown":
        p_DrawGfx()
    EndSwitch
EndFunction

Function p_MUIEvent(msg)
    DebugPrint("MUI event!", "  Class:", msg.Class, "  ID:", msg.ID, "  Attribute:", msg.Attribute)
    Switch msg.Class
    Case "Window":
        Switch msg.Attribute
        Case "CloseRequest":
            End
        EndSwitch
    Case "Menuitem":
        Switch msg.ID
        Case "menu_about":
            Local reqtext$ = "\27c\27bHollywood MUI Example\n\27nFor a tutorial at the MorphOS Library."
            If mui.Request("About", reqtext$, "Open tutorial|*OK") Then
            OpenURL("http://library.morph.zone/Crash_Course_to_Hollywood_Programming")
        Case "menu_about_mui":
            mui.DoMethod("app", "AboutMUI")
        Case "menu_about_muiroyale":
            mui.DoMethod("app", "AboutMUIRoyale")
        Case "menu_quit":
            End
        Case "menu_muisettings":
            mui.DoMethod("app", "OpenConfigWindow")
        EndSwitch
    Case "Button":
        Switch msg.ID
        Case "button1":
            p_DrawGfx(1)
        Case "button2":
            p_DrawGfx(2)
        Case "button_random":
            p_DrawGfx()
        EndSwitch
    EndSwitch
EndFunction

Function p_UpdateClock()
    mui.Set("clock", "contents", GetTime(True))
EndFunction

mui.CreateGUI(ReadString(1))

InstallEventHandler({OnKeyDown = p_Input, OnMouseDown = p_Input, MUIRoyale = p_MUIEvent})
SetInterval(1, p_UpdateClock, 1000)

LoadBrush(2, "MOSSYS:Data/Jalapeno/TrackMode.png", {LoadAlpha = True})
p_DrawGfx()

Repeat
   WaitEvent
Forever

Modifions notre script d'exemple précédent (Exemple 2 : Programmation Hollywood) pour qu'il fonctionne maintenant avec l'interface graphique MUI, et ajoutons également quelques nouvelles fonctionnalités intéressantes.

@REQUIRE "muiroyale", {Version=1, Revision=7}

Avec cette déclaration du préprocesseur, nous pouvons nous assurer que nous avons une version suffisamment récente du greffon MUI Royale disponible. Dans ce cas, nous nous assurons que nous avons au moins MUI Royale 1.7 en service.

@DISPLAY {Hidden=True, Width=400, Height=300, Sizeable=True, Layers=True, ScaleMode=#SCALEMODE_LAYER, SmoothScale=True}

Hollywood ouvre sa fenêtre d'affichage initiale automatiquement, mais lorsque nous prévoyons d'ouvrir une fenêtre MUI séparée avec l'affichage Hollywood à l'intérieur, nous pouvons dire à Hollywood de garder son affichage caché au démarrage. Ajoutons un élément "Hidden=True" à la table du préprocesseur "@DISPLAY".

Nous pouvons également supprimer les éléments "Title" et "ScreenTitle", car nous les avons déjà définis dans le fichier XML de l'interface graphique MUI.

@FILE 1, "muigui.xml"

Cette commande de préprocesseur ouvre notre fichier de définition de l'interface graphique pour une utilisation ultérieure. Nous pourrions également ouvrir ou charger le fichier par d'autres moyens ultérieurement, mais lorsqu'il est ouvert avec la commande du préprocesseur, le fichier est lié à l'exécutable lorsque nous compilons le programme. De cette façon, nous n'avons pas besoin d'avoir un fichier de définition de l'interface graphique en texte clair distribué avec notre logiciel compilé.

Function p_DrawGfx(brush_number)
    If Not brush_number Then brush_number = Rnd(2) + 1
    If LayerExists("gfx") Then RemoveLayerFX("gfx")
    mui.Set("win", "title", "Brush " .. brush_number)
    DisplayBrushFX(brush_number, #CENTER, #CENTER)
    SetLayerName(0, "gfx")
EndFunction

Modifions également un peu notre fonction de dessin.

Maintenant, nous acceptons un numéro de brosse comme paramètre et n'attribuons une valeur aléatoire que si rien n'a été donné.

Nous allons également utiliser MUI pour changer le texte du titre de la fenêtre. La section sur la classe "Window" dans la documentation de MUI Royale révèle qu'il existe un attribut "Title", qui peut être modifié à partir de notre script, car il est marqué "S" (set) dans ses informations d'applicabilité. La fonction "mui.Set" peut être utilisée pour définir les valeurs des attributs, et nous lui passons l'ID de notre fenêtre MUI, le nom de l'argument que nous voulons changer, et une nouvelle valeur pour celui-ci.

Function p_MUIEvent(msg)
  DebugPrint("MUI event!", "  Class:", msg.Class, "  ID:", msg.ID, "  Attribute:", msg.Attribute)

Voici une nouvelle fonction pour gérer les événements MUI. Nous pourrions les gérer dans le même gestionnaire d'événement d'entrée que nous avons fait plus tôt, mais gardons-les séparés pour plus de clarté maintenant.

La ligne "DebugPrint()" nous montre la classe qui a déclenché l'événement, l'ID de l'objet et l'attribut qui a changé.

Switch msg.Class
   Case "Window":
      Switch msg.Attribute
      Case "CloseRequest":
         End
      EndSwitch

Si la classe était "Window" et l'attribut "CloseRequest" (le gadget de fermeture a été pressé), nous quittons tout le programme avec la fonction "End()". Hollywood ferme la fenêtre MUI et libère les ressources automatiquement.

Case "Menuitem":
        Switch msg.ID

Si l'événement provient de la classe "Menuitem", il suffit de vérifier quel objet l'a déclenché. Les ID sont les mêmes que ceux que nous avons définis dans le fichier XML.

Case "menu_about":
     Local reqtext$ = "\27c\27bHollywood MUI Example\27n\nFor a tutorial at the MorphOS Library."
     If mui.Request("About", reqtext$, "Open tutorial|*OK") Then OpenURL("http://library.morph.zone/Crash_Course_to_Hollywood_Programming")

Il s'agit de notre propre fenêtre "A propos" du programme. Nous déclarons une variable locale contenant une chaîne de caractères, et comme il s'agit d'une variable de type chaîne de caractères, nous utilisons le signe "$" (dollar) comme dernier caractère du nom de la variable. Cela fonctionnerait aussi sans le signe du dollar, mais c'est une suggestion des règles de style d'Hollywood pour séparer les chaînes de caractères ($) et les valeurs en virgule flottante (!) des valeurs entières.

Hollywood tutoriel
Fenêtre "A propos" de notre exemple

La chaîne elle-même peut sembler un peu cryptique, car nous avons utilisé des codes de formatage à titre d'exemple. "\27c" centre le texte, "\27b" met le texte en gras, "\27n" rétablit le style de texte normal et "\N" commence une nouvelle ligne. Remarquez que nous utilisons "\27" ici alors que nous avons utilisé "\33" dans le fichier XML.

La fonction "mui.Request()" est un moyen facile de faire apparaître une fenêtre de requête système MUI. Cette fois, nous n'avons que deux boutons, ce qui nous permet de vérifier directement le résultat avec l'instruction "If" sur la même ligne. Si l'utilisateur sélectionne le bouton "Open tutorial", le résultat sera "1" et nous ouvrirons la page Web avec la fonction "OpenURL()". Le bouton "OK" renvoie 0 et rien ne se passe alors. L'option "*" peut être utilisée pour indiquer quel bouton est présélectionné par défaut.

Case "menu_about_mui":
            mui.DoMethod("app", "AboutMUI")
        Case "menu_about_muiroyale":
            mui.DoMethod("app", "AboutMUIRoyale")
        Case "menu_quit":
            End
        Case "menu_muisettings":
            mui.DoMethod("app", "OpenConfigWindow")
        EndSwitch

L'ouverture d'autres fenêtres est assez automatique avec les méthodes MUI fournies par la classe "Application". Les méthodes peuvent être exécutées à l'aide de la fonction "mui.DoMethod()".

Case "Button":
        Switch msg.ID
        Case "button1":
            p_DrawGfx(1)
        Case "button2":
            p_DrawGfx(2)
        Case "button_random":
            p_DrawGfx()
        EndSwitch
    EndSwitch
EndFunction

Enfin, nous gérons les pressions sur les boutons. Nous pouvons maintenant sélectionner la brosse à afficher, ou appuyer sur le bouton aléatoire pour appeler notre fonction de dessin sans numéro de brosse défini.

Function p_UpdateClock()
    mui.Set("clock", "contents", GetTime(True))
EndFunction

Nous avons également créé un objet texte dans notre interface graphique avec l'ID "clock". Voici une courte fonction pour définir son contenu en fonction du résultat que nous obtenons de la fonction "GetTime()". "GetTime()" se trouve dans la bibliothèque "Time", et si vous mettez son argument optionnel à "True", elle renverra l'heure au format hh:mm:ss au lieu du format hh:mm.

mui.CreateGUI(ReadString(1))

La fonction "mui.CreateGUI()" crée l'interface graphique réelle à partir d'une chaîne de code source XML. Vous pourriez aussi mettre la chaîne dans un script Hollywood, mais il est plus confortable d'avoir le source XML dans un fichier séparé pour tout projet plus important.

Comme nous avons déjà ouvert le fichier avec la commande de préprocesseur "@FILE", nous pouvons simplement utiliser la fonction "ReadString()" avec le numéro d'identification du fichier comme argument pour obtenir le fichier retourné sous forme de chaîne de caractères.

InstallEventHandler({OnKeyDown = p_Input, OnMouseDown = p_Input, MUIRoyale = p_MUIEvent})

Nous devrons installer le gestionnaire d'événements MUI Royale pour obtenir des notifications liées à MUI à notre fonction "p_MUIEvent()".

SetInterval(1, p_UpdateClock, 1000)

La fonction "SetInterval()" peut être utilisée pour déclencher des événements périodiquement. Ici, nous créons une nouvelle fonction d'intervalle qui appelle notre fonction "p_UpdateClock()" à plusieurs reprises à des intervalles de 1000 ms. Notre horloge est maintenant mise à jour une fois par seconde.

Et voilà ! Notre premier programme MUI réalisé avec Hollywood. Si vous avez sauvegardé le script Hollwood sous le nom, par exemple, de "muiexample.hws", et que vous avez les fichiers "muigui.xml" et "muiroyale.hwp" dans le même répertoire, vous pouvez exécuter le programme avec la commande Hollywood "muiexample.hws -quiet" à partir du Shell ou avec la touche "F4" dans Cubic IDE. Et si vous compilez le programme, vous n'avez plus besoin du fichier "muigui.xml" dans le même répertoire.

Le fichier greffon "muiroyale.hwp" peut être installé dans le répertoire "SYS:Libs/Hollywood/" pour être toujours disponible pour vos programmes, mais lorsque vous les distribuez, je vous conseille d'en avoir une copie dans le même répertoire que l'exécutable. De cette façon, les utilisateurs n'ont pas besoin d'installer quoi que ce soit et cela n'a pas d'importance s'ils n'ont pas la bonne version dans leur répertoire Libs.

6. Bilan

Ce tutoriel vous a permis, nous l'espérons, de comprendre la programmation avec Hollywood, et il devrait être plus facile d'en apprendre davantage sur ce langage par vous-même. Hollywood dispose également d'un forum assez actif où vous pouvez trouver de l'aide pour tout problème en utilisant le champ de recherche ou en lançant de nouveaux fils de discussion. De nombreux exemples de scripts sont également fournis avec Hollywood et ses lots de greffons. La programmation (et surtout la programmation multiplate-forme) ne peut pas être plus facile que cela. ;)

Amusez-vous bien avec Hollywood et attendez-vous à voir de nouveaux produits à l'avenir !

7. Liens


[Retour en haut] / [Retour aux articles]