Copyright: Copyleft 2000 Sylvain Bizoirre  sbfg@wanadoo.fr


Aide Rapid-Q - Sommaire
Documentation de Rapid-Q par William Yu (c)1999                               Sommaire

                                     SOMMAIRE                                                                      Annexes

Préface

Chapitre 1 : Présentation de Rapid-Q

1.1  Tapid-Q est-il lent ?

1.2  Au sujet de sa gourmandise

1.3  Rapid-Q a-t-il besoin de DLL externes ?

1.4  Combien de mémoire Rapid-Q consomme t-il au delà de mon programme ?

1.5  Est-il facile pour un intrus de décoder mon programme ?

1.6  Ai-je besoin d'une licence pour distribuer mes programmes

Chapitre 2 : Eléments de base de Rapid-Q

2.1  L'environnement de Rapid-Q

                 Implantation et fichiers requis

2.2  Utiliser l'EDI de Rapid-Q

2.3  Compiler et exécuter une application simple

2.4  Les options de la ligne de commande de RC.EXE

2.5  Structure générale d'un programme Rapid-Q

2.6  Rapid-Q est-il proche du langage Basic standard ?

Chapitre 3 : Guide du langage Rapid-Q

      3.1  Les directives de Rapid-Q

                 $APPTYPE

                 $DEFINE and $UNDEF

                 $INCLUDE

                 $RESOURCE

                 $TYPECHECK

3.2  Les variables et leur utilisation

                 • Types numériques et chaînes de caractères

                 • Les différentes variables numériques

                 • Les méthodes d'assignation

3.3  Les Objets et composants de Rapid-Q

3.4  Les méthodes et événements d'un composant

3.5  Les routines et Fonctions de Rapid-Q

                 • Principes importants

                 • Utilisation de la pile interne

       3.6  Règles de visibilité

Chapitre 4 : Ecrire votre premier programme en Rapid-Q

       4.1  Décider d'abord ce que l'on va écrire

                 • Version simplifiée d'une base de données

                 • Utilisation de  QButton, QEdit, QForm, QLabel, and QListBox

       4.2  Créer l'interface

       4.3  Gérer les événements

                 • Comment gérer un événement Clic

       4.4  Listing du code source

Chapitre 5 : Introduction aux fenêtres

       5.1  Qu'est-ce qu'une fenêtre

       5.2  Ajouter des composants à une fenêtre

       5.3  Détecter la position de la souris sur votre fenêtre

                 • Introduction à MOUSEX et MOUSEY

       5.4  Les événements spécifiques aux fenêtres.

                 • OnResize, OnKeypress, OnKeydown

       5.5  Les boîtes de dialogues

                 • Utilisation de ModalResult

       5.6  Utilisation de la méthode CREATE

       5.7  Structures CREATE imbriquées

       5.8  Créer des menus

Chapitre 6 : Ecrire des applications dans une fenêtre MS-DOS

       6.1  Résumé des instructions DOS

       6.2  Un exemple du type ‘Bonjour le monde’

                 • Ecrire / Copier entre pages écran

       6.3  Utilisation de PEEK et POKE

       6.4  Détecter les touches étendues du clavier

                 • Introduction à DoEvents

       6.5  Mélanger les fenêtres DOS et Windows

       6.6  Le mode Texte sous Linux/Unix

Chapitre 7 : Introduction aux files de données

       7.1  Les commandes de files de données

                 • Lire / Ecrire des nombres et des chaînes

       7.2  Les files de données en mémoire

                 • Copie entre files de données

Chapitre 8 : Utiliser des ressources graphiques

       8.1  Les ressources supportées

       8.2  Introduction aux listes d’images

Chapitre 9 : SUBI, FUNCTIONI, et DLLs

       9.1  SUB/FUNCTIONs avec paramètres variables

       9.2  Des précisions sur FUNCTIONI

       9.3  Introduction aux DLLs

       9.4  Comment appeler une DLL

       9.5  Utilisation de Quick View (Aperçu Rapide)

       9.6  Ecrire vos propres DLLs

Chapitre 10 : Créer des composants personnalisés

       10.1  Introduction à la création d’objets

       10.2  Etendre Qcanvas

                 • Ajouter de nouvelles propriétés

                 • Utiliser Constructor

       10.3  Ajouter / Redéfinir des méthodes

       10.4  Definir des événements

                 • Héritage d'événements

       10.5  Ajouter des composants à un composant

       10.6  Paramétrer un composant vide

       10.7  Propriétés et méthodes Publiques et Privées

       10.8  Résumé de la création de composants personnalisés

       10.9  Listing source de QDiamondBox

Chapitre 11 : Utiliser les pointeurs de fonctions

       11.1  Introduction au concept

       11.2  Définir des pointeurs de fonctions

       11.3  Utiliser correctement les pointeurs de fonctions

       11.4  Ce que Rapid-Q ne propose pas

                                              ANNEXES                                                                             Sommaire

Annexe A : Composants	 (U = Disponible également sous Unix/Linux)

	QBITMAP	QFORM   (U)	QNOTIFYICONDATA	QSCROLLBOX
	QBUTTON   (U)	QGAUGE	QOPENDIALOG   (U)	QSOCKET   (U)
	QCANVAS   (U)	QGROUPBOX	QOUTLINE	QSTATUSBAR
	QCHEXKBOX   (U)	QIMAGE	QOVALBTN   (U)	QSTRINGGRID
	QCOMBOBOX   (U)	QIMAGELIST	QPANEL   (U)	QTABCONTROL
	QCOOLBTN   (U)	QLABEL   (U)	QPOPUPMENU	QTIMER   (U)
	QDIRTREE	QLISTBOX   (U)	QRADIOBUTTON   (U)	QTRACKBAR
	QEDIT   (U)	QLISTVIEW	QRECT
	QFILELISTBOX	QMAINMENU   (U)	QRICHEDIT   (U)
	QFILESTREAM   (U)	QMEMORYSTREAM	QSAVEDIALOG
	QFONT   (U)	QMENUITEM   (U)	QSCROLLBAR   (U)

Annexe B : Composants ActiveX

QDXIMAGELIST	QDXSCREEN	QDXTIMER

Annexe C : Commandes et Mots-Clé de Rapid-Q

Opérateurs valides (dans l'ordre de priorité) :

• Puissance (^)

• Multiplication, division et décalages (*, /, \, SHL, SHR)

• Modulo arithmétique (MOD, INV)

• Addition et soustration (+, -)

• Opérateurs relationnels (=, >, <>, <=, >=)

• Opérateurs logiques par order de priorité (NOT, AND, OR, XOR)

       Introduction aux commandes conditionnelles

IF...THEN

SELECT CASE

       Introduction aux Boucles

FOR...NEXT

WHILE...WEND

DO...LOOP

       Introduction aux méthodes

CREATE ... END CREATE

WITH ... END WITH

CONSTRUCTOR ... END CONSTRUCTOR

       Introduction aux procédures

Différences entre FUNCTIONs et SUBs

SUBI et FUNCTIONI

       Variables internes

MouseX, MouseY, etc...

       Mots-Clé du mode Console

CLS, COLOR, PRINT, INKEY$, etc...

       Mots-Clé réservés

ABS, LEN, MID$, SWAP, etc...

      Comment corriger vos programmes

Passage des paramètres par référence

Utilisation de caractéristiques non documentées

Les autres erreurs

E-mail me 	Traduction :

William Yu voxel@edmc.net 	Sylvain BIZOIRRE  sbfg@wanadoo.fr


Aide Rapid-Q - Préface
Documentation de Rapid-Q par William Yu (c)1999

Préface

Préface

BASIC est un langage utilisé depuis plusieurs decennies. Par bonheur, la majorité de ses caractéristiques ont été maintenues pendant tout ce temps, et je n’ai pas l’intention de changer le monde en proposant un langage qui dévie de la sémantique «standard» de BASIC. Le plus souvent, BASIC a été considéré comme un pur langage procédural dépourvu de toutes caractéristique orientée objet, tout simplement parce les gens pensaient que cela ne pourrait jamais exister. On a dit la même chose de Pascal jusqu’à ce que Delphi prouve le contraire. Rapid-Q n’est pas un langage orienté objet, mais il reprend et utilise les concepts «Objet». Rapid-Q est conçu pour être un langage sufisamment intuitif, considérant qu’il y a une logique dans la manière dont vous concevez votre programme. Je n’ai pas créé ce langage comme un remplaçant de tout autre compilateur commercial, Basic ou autre. Ce sera à vous de décider. Bien que Rapid-Q propose bon nombre de caractéristiques modernes pour la programmation de Windows, il n’est définitivement pas une fin en soi. Comme j’en connais les limitations et ce qu’il peut et ne peut pas faire, je suis sûr de ne pas concurrencer les sociétés commerciales. Je vous propose simplement de tester ce programme. Si vous le trouvez trop restrictif pour vos besoins en programmation, alors peut-être que Basic-Q n’est pas le langage qu’il vous faut.

Mes objectifs

Ils sont très simples : favoriser un meilleur accès à la connaissance en proposant des produits et services gratuits à la communauté. Je propose Rapid-Q comme un moyen pour tous, et spécialement les éducateurs, pour enseigner ou apprendre la programmation sous Windows sans devoir investir des sommes importantes dans des compilateurs commerciaux. De nombreux concepts comme la gestion des événements, les propriétés d’objets ou les méthodes peuvent prendre un caractère abstrait dans d’autres langages. Rapid-Q étant beaucoup plus simple à utiliser pour le débutant que C++ ou Java, il peut devenir ce pont entre découragement et succès. Beaucoup de néophytes ont abandonné à cause des confusions dans l’utilisation des MFC de Visual C++, ou de la stricte et rigide syntaxe de Java. Même Delphi intimide souvent le débutant si celui-ci ne connait pas les rudiments de Pascal. Rapid-Q débarasse l’utilisateur de ces shémas complexes, c’est pourquoi il n’interessera les utilisateurs avancés ou professionnels que pour des petites applications rapidement écrites. Je destine donc spécialement Rapid-Q aux débutant de la programmation Windows ainsi qu’aux programmeurs intermédiaires; à ceux qui n’ont pas moyens financiers d’investir dans de coûteux systèmes de développement comme C++ ou Delphi ou qui ne veulent pas subir la rigidité de Java. Il peuvent télécharger rapidement Rapid-Q et commencer immédiatement à programmer et à tester ce compilateur.

.

Les exemples

J’ai toujours insisté sur le fait que le meilleur moyen d’apprendre était l’exemple. Cela ne sert à rien de regarder un code source et de s’en satisfaire. Prenez un peu de temps pour étudier un exemple et le modifier. Les essais et les erreurs sont de bons moyens pour progresser. Nos erreurs nous font beaucoup apprendre, c’est également vrai pour la programmation. Oui, vous passerez de nombreuses nuits, frustré devant un programme qui ne tourne pas comme vous le souhaitez. Mais quand le «bug» sera trouvé, votre plaisir et votre satisfaction n’auront pas d’égal.

A qui s’adresse Rapid-Q

Comme je l’ai déjà mentionné, Rapid-Q ne sera certainement pas votre langage si vous êtes un programmeur avancés ou professionnel, mais cela ne veut pas dire que vous ne l’utiliserez pas. Vous pouvez écrire une application simple en Rapid-Q qui vous prendra moins de temps à programmer que le même programme en C++, Java ou Delphi. Il suffit que vous soyez à l’aise dans ce langage. BASIC étant un langage souple avec les variables, vous pourrez quelquefois ne pas avoir le courage de déclarer toutes vos variables, et Rapid-Q l’acceptera. D’autres fois, vous choisirez Rapid-Q parce certaines de ses caractéristiques le rendent plus simple à utiliser que d’autres langages. Cela dit, j’ai privilégié les programmeurs débutants et intermédiaires et Rapid-Q sera mieux adapté dans une classe ou une salle de formation, mais il y a encore un long chemin.

L’avenir de Rapid-Q

J’envisage d’adapter l’interpréteur de Rapid-Q à Linux et, pourquoi pas, aux systèmes Unix. L’analyseur syntaxique est déjà tranférable, mais il est sûr que la version Linux sera un peu allégée. Plus d’informations seront bientôt disponibles.

Commentaires & Suggestions

J’apprécie tous les commentaires, suggestions et critiques constructives. Je suis toujours démoralisé par les commentaires du type «Ce n’est que du code Intermédiaire», qui n’est pas une critique constructive, mais destructrice. Oui, Rapid-Q est basé sur un code intermédiaire. Je n’ai simplement ni le temps, ni la patience d’écrire un véritable compilateur temps réel. Si vous avez déjà tenté d’en réaliser un vous-même, je suis sûr que vous connaissez l’étendue des efforts et du temps que cela demande. Cela ne veut pas dire que l’écriture d’un compilateur code intermédiaire soit plus facile, cela réclame aussi beaucoup de temps et d’efforts.

E-mail me

William Yu voxel@edmc.net

Sommaire


Présentation
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 1 - Présentation du langage Rapid-Q

1. Présentation du langage Rapid-Q

1. Présentation de Rapid-Q

Qu’est-ce que Rapid-Q ? Simplement un compilateur BASIC gratuit, pour Windows et différentes versions d’ Unix, dont Linux. Face à cette offre étonnante, vous vous posez de nombreuses questions : Rapid-Q est-il lent ?, est-il aussi gourmand que Visual Basic ?, faut-il des DLL pour faire tourner mes programmes ?, quelle mémoire est utilisée par Rapid-Q en plus de mes programmes? Les réponses ne sont que des arguments commerciaux. La véritable question est : ce langage convient-il à vos besoins? Si non, essayez-en un autre. Rapid-Q ne conviendra pas à tout le monde, ni à la majorité des programmeurs. Je ne tenterai pas de vous berner en vous proclamant que Rapid-Q est plus rapide que tel langage, ou meilleur que tel autre. C’est un langage, identique à beaucoup d’autres, destiné à être utilisé, étudié, bien ou mal jugé, mais avant tout conçu pour créer des applications Windows ou Unix/Linux telles que vous souhaitez qu’elles soient crées.

1.1 Rapid-Q est-il lent ?

Comme Rapid-Q est basé sur la gestion d’événements et que son code est optimisé pour une programmation de haut niveau, il n’est pas aussi lent que beaucoup peuvent le penser. Il est lent seulement si vous le faites calculer intensément ou si vous manipulez de gros volumes de données. Si, par exemple, vous voulez lire une simple valeur dans un fichier de plus de 1 Mo., cela prendra plus de temps que dans certains autres langages, mais pas suffisamment de temps pour que vous vous endormiez devant votre clavier ! Même réponse pour des boucles du type I = I + 1 répétées quelques milliers de fois. Mais, en termes d’affichages graphiques ou de gestion de contrôles et de fenêtres, sa vitesse est équivalente à celle de tous les autres langages. Pour des traitements intenses, je vous suggère d’écrire une DLL séparée dans un langage courant de type C et d’appeler cette DLL dans Rapid-Q quand vous avez besoin d’une grande vitesse de traitement.

1.2 Au sujet de sa gourmandise

Un sujet sur lequel vous ne pourrez rien changer. Rapid-Q demande, pour sa partie interpréteur, environ 300 Ko. de mémoire (150 Ko. pour Linux, 600 Ko. pour Sparc). C’est donc la taille minimum de vos programmes, et ce n’est pas si mal, comparé à de nombreux autres langages. Ca reste cependant gourmand si vous n’écrivez qu’un simple programme du type «Bonjour, le monde!» qui s’ajoutera à l’interpréteur. C’est plus raisonnable dans le cas de programmes moyens ou grands de moins de 50 Ko. auxquels vous intégrerez quelques ressources graphiques.

1.3 Rapid-Q a-t-il besoin de DLL externes ?

Non. Vos programmes ne nécessitent aucune DLL ou autre composant externes, juste votre programme .EXE, c’est tout. Il pourra tourner sur tout PC sous WIN95/98/NT en supposant que l’utilisateur n’a rien modifié dans ses fichiers Système. Si vous comparez la gourmandise de Rapid-Q face aux «runtime» des autres langages, Il n’est pas si mauvais que ça.

1.4 Combien de mémoire Rapid-Q consomme t’il au delà de mon programme ?

Rapid-Q ne consomme (littéralement) rien en dehors de votre programme, mais il consomme un peu de mémoire au delà de la zone réservée par Windows pour votre (vos) programme(s). En fait, ce n’est pas considérable et représente moins de 80 Ko. pour la combinaison des mémoires virtuelles, globales et de variables. Cela est dû au fait que toutes les variables et objets sont créés dynamiquement, et qu’un objet demande moins de 1 Ko. pour sa création. La mémoire de variables est la seule qui devra retenir votre attention. Si votre programme comporte de nombreux niveaux de routines ou utilise intensément des fonctions récursives, elle variera dans de fortes proportions. Cependant vous n’aurez pas à vous soucier du ‘nettoyage’ de cette mémoire lors de la fermeture de votre programme, Rapid-Q le fera pour vous et libérera tous les objets.

1.5 Est-il facile pour un intrus de décoder mon programme?

Si l’intrus connait parfaitement la manière dont tout est construit à l’intérieur d’un programme, ce ne sera alors qu’une formalité. Cependant Rapid-Q génère un code intermédiaire spécifique et non standard. Cela veut dire que, pour un intrus qui ne connait pas exactement ce que fait précisément chaque opération, il sera vraiment difficile de décoder votre programme. Il est facile de décoder les chaînes de caractères (comme dans les autres langages) parce qu’elles ne sont pas cryptées, mais un pirate ne pourra guère aller au delà sans deviner qu’il s’agit d’un code intermédiaire et sans avoir toutes les clés pour le décoder. A la différence de Java ou d’autres langages, Rapid-Q n’ajoute aucune table de variables ou toute autre information à votre programme .EXE

1.6 Ai-je besoin d’une licence pour distribuer mes programmes?

Non, Rapid-Q est gratuit et vous n’avez définitivement besoin d’aucune licence pour l’utiliser, distribuer vos programmes ou les vendre. Rapid-Q peut être utilisé pour tous type d’applications, qu’elles soient commerciales ou non. Vous n’aurez jamais à me payer un centime, et vous n’avez aucune obligation de mentionner que votre programme a été écrit en Rapid-Q (bien que j’apprécierais le geste). Cependant, vous NE POUVEZ PAS vendre le programme Rapid-Q. Vous êtes autorisé à joindre Rapid-Q avec votre (vos) programme(s) si vous informez clairement l’utilisateur qu’il n’achète pas Rapid-Q, mais seulement votre programme. Le mieux est de ne pas faire de publicité sur le fait que votre distribution inclut une copie Rapid-Q, et de la considérer comme un ‘cadeau caché’. Si vous intégrez votre création dans un CD-ROM de sharewares ou freewares, faites la publicité que vous voulez !

Sommaire 	Chapitre suivant


Eléments de base
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 2 - Les éléments de base de Rapid-Q

2. Les éléments de base de Rapid-Q

Avant d’aborder tout nouveau langage, il vaut mieux d’abord apprendre à l’utiliser. Ce chapitre vous présente l’environnement de Rapid-Q, vous apprend à compiler et exécuter vos programmes, et vous montre à quoi va ressembler la structure générale de votre programme programme Rapid-Q

2.1 L’environnement Rapid-Q

Dans vos fichiers Rapid-Q, vous trouverez un EDI de base (Environnement de Développement Intégré) appelé RAPIDQ.EXE, ainsi que la version actuelle du compilateur Rapid-Q (RC.EXE), et les programmes RAPIDQ32.LIB et RAPIDQCC.LIB qui sont indispensables pour compiler vos programmes. Ce sont les 4 programmes essentiels dont vous aurez besoin pour développer et compiler vos programmes sources Basic. l’EDI n’est pas indispensable. Il vous est tout à fait possible d’écrire vos programmes avec l’éditeur de texte de votre choix. Si c’est votre cas, sautez le prochain chapitre consacré à l’utilisation de l’EDI de Rapid-Q. Tous les programmes cités doivent résider dans le même répertoire.

2.2 Utiliser l’EDI de Rapid-Q

Contrairement à d’autres EDI qui offent, entre autres, des options de déboggage, l’EDI de Rapid-Q n’offre rien de plus qu’un environnement pour écrire vos programmes, les exécuter, ainsi que quelques options. Une gestion des erreurs est également disponible, bien que cet EDI n’ait aucune fonction de tests d’erreurs. En fait, le compilateur RC.EXE le fait pour lui, mais l’EDI bénéficie d’une interface privilégiée avec RC.EXE. Dernière caractéristique intéressante, vous bénéficiez d’une mise en surbrillance des mots-clé de Rapid-Q, ce qui facilite grandement la saisie et la vérification du programme source.

Quelles sont ses limites :

Limitation à 100 fichiers ouverts simultanément,

Quand un fichier est exécuté, il est automatiquement enregistré,

Tous les programmes sont compilés avant d’être exécutés

D’un point de vue général, l’EDI de Rapid-Q est un bon outil pour commencer et apprendre Rapid-Q. Quand vous deviendrez plus aguerri, vous préférerez certainement utiliser votre éditeur de texte préféré. Personnellement, je préfère écrire mes programmes sous DOS, avec EDIT.COM. Ca ne veut pas dire qu’il faut abandonner l’EDI de Rapid-Q. S’il vous convient pour l’écriture de vos programmes, gardez-le !

2.3 Compiler et exécuter un application simple

Nous n’avons pas encore appris à écrire une application simple... Patience ! Nous allons y venir. Il est préférable de savoir d’abord comment compiler et exécuter un programme avant de l’écrire. Voici un programme Windows très simple que vous pouvez taper et compiler vous-même.

            DIM MainForm AS QFORM

      MainForm.ShowModal

Si vous utilisez l’EDI de Rapid-Q, tapez simplement ce code (ou faites un Copier-Coller si vous préférez). Cliquez sur le menu Run et sélectionnez Run. Si tout va bien, vous devez voir une fenêtre vide apparaitre sur le coin supérieur gauche de votre écran. Fermez-la et retournez à l’EDI. Si vous préférez la méthode de compilation par lignes de commandes :

Chargez votre éditeur favori et tapez le code ci-dessus. Enregistrez-le (Form.BAS).

Pour le compiler, tapez :

RC Form.BAS

Si tout va bien, vous devez obtenir un fichier Form.EXE dans le répertoire courant.

Tapez simplement Form pour l’exécuter. Si votre fenêtre apparaît, continuez votre lecture, sinon quelquechose s’est mal passé, voyez alors la section ‘Résolution des problèmes’

2.4 Les options de la ligne de commande de RC.EXE

Je n’aborderai que les 2 plus importantes :

-I[Chemin] : Change le chemin d’accès des fichiers Include

-L[Chemin] : Change le chemin d’accès des fichiers Library

Par défaut, le compilateur cherche dans le répertoire courant pour les fichiers .LIB et les fichiers à inclure. Les commandes précédentes forcent la recherche dans un autre répertoire. Comme nous parlons de paramètres de type C, vous devez connaître quelques précisions sur la manière dont sont spécifiés les chemins d’accès. La meilleure méthode est la suivante :

      RC -Ic:/rapidq/includes

Vous pouvez utiliser \ à la place de /, mais il y a une bonne raison pour préférer /. Etudions la ligne suivante :

      RC -I"c:\rapidq long dir\includes\"

Si vous préférez la commande ci-dessus, vous devrez ajouter un \ supplémentaire ou supprimer le dernier \, comme ceci :

      RC -I"c:\rapidq long dir\includes\\"

ou

   RC -I"c:\rapidq long dir\includes"

Cela est dû au fait que C traduit \ comme «A l’intérieur de». Ceux qui n’ont jamais programmé en C/C++ laisseront ces subtilités aux spécialistes. Enfin, les noms de répertoires longs doivent être saisis «entre guillemets». Ce sont des détails, mais maintenant vous les connaissez.

2.4 Structure générale d’un programme Rapid-Q

En fait, il n’y a pas de structure pré-définie dans un programme BASIC, mais les programmeurs ont pris l’habitude de séparer leurs programmes en blocs distincts :

- Directives

- Declarations

- Variables globales

- Programme principal

Ce n’est qu’un modèle de présentation, votre programme Rapid-Q pouvant être structuré de bien d’autres manières. Certaines aboutiront au même résultat, d’autres auront un effet dévastateur ou particulier. Par exemple, $INCLUDE est une directive qui importe un fichier et le place à l’endroit où se trouve la directive. Les résultats peuvent être très différents selon que vous placez cette directive au début ou à l’intérieur de votre programme.

2.5 Rapid-Q est-il proche du langage Basic standard ?

Très proche, toutes les commandes courantes comme DIM, PRINT ou MID$ sont équivalentes. Cela ne veut pas dire que vous allez pouvoir transformer votre programme Dos Qbasic en Rapid-Q sans modifications. Rapid-Q étant une application Windows intégrant des instructions spécifiques au mode CONSOLE, il y a fort à parier que vous ne convertirez pas votre programme Qbasic sans réécrire 90% de votre code. En Rapid-Q, les commentaires commence par le symbole ‘ , exactement comme Qbasic. Cependant, l’utilisation de REM n’a aucun effet en Rapid-Q et est considérée comme un nom de variable. N’utilisez donc jamais REM en entête de vos commentaires. Vous pouvez également séparer deux instructions en utilisant le symbole : . Cela a le même effet que d’écrire deux lignes.

PRINT «Hello» : PRINT «World»

est équivalent à :

PRINT «Hello»

PRINT «World»

De nombreux programmeurs Basic deviennent très habitués à l’environnement de leur langage après quelques temps d’utilisation. Rapid-Q rompt avec ces habitudes et n’hérite pas des propriétés de Visual Basic. Par exemple, il n’existe pas de procédure SUB MAIN, pas plus que de variables publique ou privée. Votre programme entier est considéré comme un programme MAIN. Cela vous demandera certainement plus d’efforts d’aller de Rapid-Q vers Visual Basic que l’inverse. Aller de Rapid-Q vers Delphi sera plus simple puisque la majorité des idées et composants proviennent de modèles Delphi. Par eemple, tous les événements comme OnShow, OnClick, etc. en sont directement dérivés.

Chapitre précédent	Sommaire	Chapitre suivant


Guide du langage
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 3 - Guide du langage Rapid-Q

3. Guide du langage Rapid-Q

Dans ce chapitre, je n’aborderai pas les commandes standard du langage BASIC, mais uniquement les particularités de Basic-Q. Basic-Q étant fortement inspiré du BASIC standard, ceux d’entre vous qui savent déjà programmer ce langage pourront survoler ce chapitre s’ils le souhaitent. Quelques nouveaux concepts, inconnus du Basic standard sont cependant présentés comme le passage d’un nombre infini de paramètres ou le signe ‘-’ dans la concaténation de chaines de caractères.

3.1 Les directives de Rapid-Q

Dans Rapid-Q, les directives sont utilisées pour indiquer à l’ordinateur comment, et quel type de code sera généré. Rapid-Q supporte les directives suivantes, qui sont généralement insérées au début de votre programme.

$APPTYPE  [ CONSOLE | GUI ]    Default is GUI

$APPTYPE est utilisé pour indiquer à l’ordinateur quel type d’application vous souhaitez générer : Windows ou Console. Bien que l’option par défaut soit GUI si aucune directive $APPTYPE n’est utilisée, Rapid-Q détectera le type de votre programme, simplement en étudiant son code. Pour éviter toute ambiguité, insérez la directive $APPTYPE au début de votre programme.

Utilisation : $APPTYPE CONSOLE

$TYPECHECK  [ OFF | ON ]    Default is OFF

$TYPECHECK est utilisé pour indiquer à votre ordinateur que vous souhaitez une compilation avec un  contrôle strict de vos variable par ON (toutes vos variables doivent alors être déclarées) ou un contrôle plus souple par OFF, à la manière des BASIC’s traditionnels, et où vous n’aurez pas à déclarer vos variables.

Utilisation: $TYPECHECK ON

 $INCLUDE  [ NomDeFichier ]

L’utilisation de $INCLUDE a le même effet que d’importer un fichier directement dans votre programme à l’endroit de la directive. Vous pouvez utiliser $INCLUDE n’importe où dans votre programme, mais il est le plus souvent placé au début du code code source.

Utilisation : $INCLUDE "RAPIDQ.INC"

 $RESOURCE  Titre AS NomDeFichier

De nombreux langages de programmation offrent la possibilité d’inclure des fichiers de ressources externes. C’est un peu différent dans Rapid-Q, où les ressources ne sont que des collections de fichiers graphiques, à l’exclusion de toutes autres ressources de type ‘chaînes de caractères’ par exemple. Le gros avantage avec Rapid-Q, c’est que ces fichiers sont directement intégrés à votre application. Si vous utilisez, par exemple, 10 fichiers images différents, vous n’aurez pas à les joindre à votre application car ils seront tous rassemblés dans votre fichier .EXE

Utilisation : $RESOURCE RES_BMP1 AS "CLOUDS.BMP"

 $DEFINE  NouvelleDéfinition   AncienneDéfinition

Utilisez cette directive si vous souhaitez redéfinir ou créer un nouveau mot-clé. Vous ne pourrez pas redéfinir une série de mots-clé, ni redéfinir des opérateurs ou des signes de ponctuation. $DEFINE ne peut pas être utilisé pour définir une fonction (comme en C).

Utilisation : $DEFINE INT16 SHORT

 $UNDEF  NomDéfini [, NomDéfini]

Utilisez $UNDEF pour annuler la définition créée par $DEFINE. Vous pouvez spécifier plusieurs définitions dans une même ligne, séparées par des virgules.

Utilisation : $UNDEF INT16, INT32

3.2 Les variables et leur utilisation

Les variables sont stockées en mémoire et y restent pendant toute la durée d’exécution de votre programme. Avec Rapid-Q la vérification du type de variable est très souple. Cela veut dire que vous pouvez assigner une chaîne de caractères à une variable entière. Le résultat est indéfini mais retournera dans la plupart des cas la valeur 0. Il en est de même si vous assignez une valeur numérique à une chaîne de caractères, il en résultera une chaîne vide. Dans Rapid-Q, la vérification des variables se passe réellement lors de l’interprétation. Pour éviter la multiplication des massages d’erreurs, je l’ai complètement supprimée. Cela veut dire que vous devez être très attentif dans l’assignation de valeurs à vos variables car vous n’aurez aucun message d’erreur. Seuls les Objets de Rapid-Q sont soumis à une stricte vérification. Ainsi, vous ne pourrez pas assigner une valeur ou une chaîne à une variable attendant un Objet comme argument. Voici quelques exemples d’assignations valides :

         A% = "Hello" > "World"

         A$ = "Hi World!"

         A# = 34 + 34 - 324 * 3 / (34 / 5 + 5)

Si vous n’avez jamais programmé en BASIC, vous vous demandez certainement à quoi servent tous ces symboles qui suivent la variable A. Comme de nombreuses versions de BASIC, Rapid-Q vous permet de définir à vos variables avant de les utiliser, en utilisant les symboles suivants :

         ?,  ??,  ???,  %,  &,  !,  #,  $

Ils représentent les caractéristiques de vos variables qui peuvent être respectivement du type BYTE (octet), WORD (Mot), DWORD (double mot), SHORT (entier court), INTEGER (entier), LONG (entier long), SINGLE (simple précision), DOUBLE (double précision), et STRING (chaîne de caractères). Si vous n’ajoutez aucun symbole à une variable non déclarée, celle-ci sera considérée par défaut comme une variable de type DOUBLE. C’est un choix de Rapid-Q, dans certains autres langages, le type par défaut peut être SINGLE ou LONG. Voici un rappel de la table des types de variables avec la place prise en mémoire et la plage d’utilisation de chaque type :

Type	Symbole	Place mémoire	Plage d’utilisation
Byte	?	1 octet	0 ... 255
Word	??	2    «	0 ... 65535
Dword	???	4    «	Seulement dans la version Linux pour l’instant...
Short	%	2    «	-32768 ... 32767
Integer	&	4    «	-2147483648 ... 2147483647
Long	&	4    «	-2147483648 ... 2147483647
Single	!	4    «	1.5 x 1045 ... 3.4 x 1038
Double	#	8    «	5.0 x 10324 ... 1.7 x 10308

Si vous n’aimez pas cette méthode, vous pouvez également déclarer vos variables en utilisant l’instruction DIM, de la manière suivante :

     DIM Nombre AS INTEGER

     DIM S AS STRING

     DIM B AS BYTE

Petit rappel : Si vous insérez la directive $TYPECHECK ON, vous serez obligé de déclarer toutes vos variables de cette manière. C’est généralement une bonne habitude, surtout si vous envisagez de vous orienter plus tard vers des langages de type C ou Pascal qui imposent de déclarer toutes vos variables avant de les utiliser. Voici une déclaration Rapid-Q autorisée :

            DIM Num$ AS INTEGER

A utiliser avec prudence (ou, de préférence, à bannir) car elle risque de perturber de nombreux programmeurs et de rendre votre code pratiquement illisible.

3.3 Les Objets et Composants de Rapid-Q

Rapid-Q offre une gamme de composants réutilisables (ou objets) qui aident le programmeur dans le développement d’applications Windows. De nombreux langages de programmation de type RAD (Rapid Application Development) en proposent également. Il s’agit de MFC pour Visual C++ ou de JFC Swing pour Java. Que sont ces composants ? Ce sont des morceaux de code préfabriqués qui permettent d’accéder aux caractéristiques et aux contrôles API de Windows sans récupérer les maux de tête qui accompagnent souvent la programmation directe de ces API. Vous pourriez, par exemple, créer une fenêtre Windows en appelant directement les API de Windows, mais cela pourrait vous demander plusieurs pages de programme. Dans Rapid-Q, cette fonction a été intégrée dans un composant appelé QFORM. Donc, au lieu de vous occuper des registres de classe de votre fenêtre, puis de l’afficher, puis de recenser tous les retours possibles, il vous suffira, en Rapid-Q, de taper :

DIM Fenetre AS QFORM

Fenetre.ShowModal

Comparée à la même commande en C++, celle-ci est plus claire et plus facile à comprendre. Dans Rapid-Q, il y a de nombreux composants de ce type, comme QBUTTON, QIMAGE, QFILESTREAM, etc. Certains autres ne sont pas supportés, cela fait partie des restrictions de Rapid-Q qui ne propose pas un accès direct aux fonctions API de Windows et ne vous permet dons pas de créer vos propres contrôles. Vos composants sont créés exactement de la même manière que vos variables, en utilisant l’instruction DIM. Chaque composant possède ses propres propriétés, méthodes et événements. Les propriétés sont des attributs du composants. Par exemples, Left (gauche), Top (haut), Width (largeur) et Height (hauteur) sont des propriétés communes à tous les contrôles visibles; elles définissent leur position dans un autre contrôle ou une fenêtre. Caption est une propriété du type STRING. Pour le composant Qform, la propriété Caption définit le titre de la fenêtre. Pour un composant QBUTTON, elle définit le texte du bouton. Caption n’existe pas pour un composant du type QFILESTREAM puisque ce n’est pas un composant visible; celui-ci possède ses propres propriétés. La section Appendice de ce manuel vous propose un guide complet de toutes les propriétés, méthodes et événements pour chaque composant. Voici un exemple rapide de la méthode à employer pour assigner des propriétés à vos composants :

DIM Fenetre AS QFORM

Fenetre.Caption = "Mon Application"

Fenetre.Left = 100

Fenetre.Top = 100

Il est nécessaire de savoir quelles propriétés sont en Lecture Seule, ou en Ecriture Seule car Rapid-Q ne vous retournera actuellement aucune information utile à ce sujet. Dans la majorité des cas, les propriétés sont autorisées en lecture et écriture. La propriété ITEMCOUNT du composant QLISTBOX est un exemple de propriété à lecture seule. La propriété ICON du composant QFORM est un exemple de propriété en écriture seule. Elle est utilisée pour préciser la position d’une icone à utiliser par défaut. Lire une propriété en ecriture seule ou écrire dans une propriété à lecture seule peut provoquer un plantage de votre programme.

3.4 les Méthodes et Evénements d’un composant

Maintenant que nous avons étudié les propriétés, passons maintenant aux Méthodes qui ne sont pas très différentes. Qu’est-ce qu’une méthode ? Tout simplement une SUB (routine) ou une FUNCTION. Elles sont appelées Méthodes parce que, dans ce cas, la SUB ou FUNCTION ne se réfère qu’à un composant. C’est plus difficile à expliquer qu’à comprendre. Voici donc un exemple :

DIM Form AS QFORM

Form.Center

Form.ShowModal

Ici, nous utilison 2 méthodes : Center et ShowModal. La méthode Center est une SUB qui n’accepte aucun paramètre. Elle a pour rôle de centrer la fenetre sur votre écran. ShowModal est actuellement une FUNCTION, mais nous ignorons la valeur retournée dans ce cas. Cette méthode est utilisée pour afficher une fenêtre jusqu’à ce que l’utilisateur la referme. Précision : A la différence de certaines versions de BASIC, en Rapid-Q, l’appel d’une FUNCTION peut donner le même résultat que l’appel d’une SUB, il suffit d’ignorer la valeur retournée, comme dans C ou C++. D’autres méthodes demandent des paramètres supplémentaires, certaines peuvent accepter une infinité de paramètres. En Rapid-Q, vous pouvez les écrire vous-même, nous étudierons cela dans un prochain chapitre. En résumé, les méthodes sont des fonctions qui exécutent une certaine tâche pour un composant. Dans l’exemple précédent, nous avons centré puis affiché une fenêtre.

Passons maintenant aux événements. Ca pourrait être compliqué si je vous en parlais à la mode API Windows, en termes de passages de messages et d’attente de retours. Heureusement, avec Rapid-Q nous utilisons un langage de plus haut niveau. Voyons donc. Un événement intervient quand quelquechose se passe... et il peut se passer beaucoup de choses : une période de temps dépassée, un clic de souris provenant de l’utilisateur ou une touche tapée au clavier, etc. Rapid-Q reconnait tous ces événements. Si, par exemple, l’utilisateur clique sur sa souris, il faudra écrire une routine qui correspond à cette action. Pour cela nous devrons définir une fonction de retour (CALLBACK) qui exécutera cette routine. Ainsi, vous redirigerez chaque événement intercepté vers une routine qui exécutera la portion de programme correspondante. Voici comment :

       SUB BoutonClique

          PRINT "Le bouton a été cliqué"

       END SUB

       DIM Bouton AS QBUTTON

       DIM Fenetre AS QFORM

       Bouton.Parent = Form            '' Propriété

       Bouton.OnClick = BoutonClique   '' Evénement

       Form.ShowModal                  '' Méthode

Cela vous parait-il facile ? En réalité, ça l’est vraiment. Dès qu’un événement «OnClick» intervient, le programme saute vers votre routine BoutonClique et exécute le code qui attendait ici. Ce programme est complet, vous pouvez l’essayer tel quel. Consultez ensuite la section Appendice pour connaître la liste de tous les événement que peut recevoir chaque composant

3.5 Les routines et fonctions de Rapid-Q

Quelques principes très importants sont à connaître au sujet des SUB et FUNCTION de Rapid-Q. Le premier, et le plus important, est que toutes les variables passées à une routine le sont par VALEUR (sauf pour les composants et tableaux). Cela veut dire que toute variable passée à une SUB ou FUNCTION ne sera pas modifiée lors du retour de la SUB ou FUNCTION vers le programme appelant. Le second principe est que vous ne pouvez pas passer/recevoir de variable prédéfinies du type TYPE. Contrairement à d’autres langages BASIC (QBasic, Power Basic), il n’y a aucune différence dans la manière de créer une SUB ou FUNCTION :

    FUNCTION TrouveMax (X AS INTEGER, Y AS INTEGER) AS INTEGER

      IF X > Y THEN

        TrouveMax = X      '' La valeur retournée est X

      ELSE

        TrouveMax = Y      '' La valeur retournée est Y

      END IF

    END FUNCTION

La fonction précédente est valide, tout comme la suivante :

    FUNCTION TrouveMax (X%, Y%) AS INTEGER

      IF X% > Y% THEN

        TrouveMax = X%      '' La valeur retournée est X

      ELSE

        TrouveMax = Y%      '' La valeur retournée est Y

      END IF

    END FUNCTION

Même si vous utilisez la variable TrouveMax%, vous devrez ajouter l’indicateur AS INTEGER à la fin de la fonction. Il a déjà été mentionné que toutes les variables sont passées par valeur. Cependant, si vous devez absolument récupérer la valeur de retour, vous pouvez utiliser la pile interne de Rapid-Q :

    SUB Strcat (A$, B$)

       A$ = A$ + B$

    END SUB

    A$ = "Hello"

    Strcat(A$, " world!")

    A$ = STACK.STR(0)

    PRINT A$

La pile contient un tableau de valeurs entieres et de chaînes de caractères. Pour accéder à la bonne valeur, vous devrez spécifier l’index correspondant (de gauche à droite), le premier élément commencant à l’index 0. Vous pouvez passer des Objets à une routine, mais vous ne pouvez pas les utiliser comme valeur de retour.

    SUB (Button AS QButton)

        Button.Left = 100

    END SUB

Tous les composants et objets sont passés par référence.

3.6 Règles de visibilité des variables

Dans ce domaine, Rapid-Q ne ressemble pas à BASIC. Le compilateur de Rapid-Q fonctionnant en une passe, la règle de visibilité des variables est très ressemblante à Pascal. Voici ce que je veux dire :

       SUB Test

          DIM I AS INTEGER

          I = 100

          PRINT I

       END SUB

       DIM I AS INTEGER

       I = 10

       SUB Test2

         PRINT I

       END SUB

       Test    '' Appelle la routine

       Test2

Voici comment fonctionne la règle de visibilité : dans la SUB Test, la variable locale I n’existe que jusqu’à la fin du bloc SUB. La variable I du programme principal est visible depuis sa déclaration jusqu’à la fin du programme. Cela veut dire que la SUB Test2 peut utiliser la variable globale I puisqu’elle est dans sa zone de visibilité. Cela veut également dire que vous ne pouvez pas redéclarer la variable I. Si vous souhaitez avoir une visibilité globale pour toutes vos variables, vous devrez placer toutes vos SUB et FUNCTION après les déclarations de vos variables globales.

Chapitre précédent 	Sommaire	Chapitre suivant


Premier programme
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 4 - Ecrire votre premier programme en Rapid-Q

4. Ecrire votre premier programme en Rapid-Q

Lancons-nous dans l’écriture d’une première application Windows en Rapid-Q !. Ce chapitre est un guide qui vous fera progresser pas à pas dans chaque phase de l’élaboration de votre programme. Il se termine par le code source complet de ce programme.

4.1 Décider d’abord de ce qu’on va écrire.

Nous n’allons pas écrire une simple application du type «Bonjour le monde !». Nous n’allons pas non plus écrire un navigateur Internet ! Nous allons commencer par une application concrète, mais simple à écrire. Ce sera la version simplifiée d’une base de données. Nous allons ainsi aborder plusieurs concepts comme la gestion des fenêtres et des événements. Nous utiliserons également des composants comme QEDIT, QBUTTON, QFORM, QLABEL, et QLISTBOX. Voici à quoi ressemblera notre application quand nous l’aurons terminée. Si vous êtes sufisamment à l’aise dans le langage, vous pourrez ensuite modifier l’interface et les caractéristiques du programme selon vos besoins.

Ce n’est pas très original mais la code source fait moins de 100 lignes ! et la part la plus importante du travail consiste à concevoir l’interface.

(Ceci est l’image de la version anglaise, mais notre application sera en Français)

4.2 Créer l’interface

Vous pouvez déjà deviner les composants dont nous aurons besoin : Un QFORM, 2 QBUTTONs, 4 QEDITs, 4 QLABELs, et enfin 1 QLISTBOX. Mais avant tout, nous avons besoin d’une fenêtre (c’est notre QFORM). Commencez donc par taper cela :

DIM fenetre AS QFORM

           fenetre.Center

           fenetre.Caption = "Ma Première Application"

           fenetre.Height = 340

           fenetre.Width = 350

           fenetre.ShowModal

Si vous avez entré ce code correctement, vous devez voir apparaître une fenêtre vide dont les dimensions sont celles de l’image ci-dessus. A noter que nous n’utilisons pas MainForm.Left ou MainForm.Top car nous avons utilisé la propriété MainForm.Center qui a pour effet de calculer automatiquement la position de la fenêtre au centre de l’écran. Nous devons cependant spécifier la largeur (width) et la hauteur (height) de notre fenêtre.

Très bien, nous avons donc notre fenêtre. Nous devons maintenant y ajouter les différents contrôles. Commençons, dans l’ordre, par insérer les zones de texte :

DIM LabelNom AS QLABEL, LabelAdresse AS QLABEL, _

       LabelVille AS QLABEL, LabelTeleph AS QLABEL

LabelNom.Parent = Fenetre

    	LabelNom.Caption = "Nom :"

    	LabelNom.Top = 13

    	LabelNom.Left = 10

    	LabelAdresse.Parent = Fenetre

    	LabelAdresse.Caption = "Addresse :"

    	LabelAdresse.Top = 38

    	LabelAdresse.Left = 10

    	LabelVille.Parent = Fenetre

    	LabelVille.Caption = "Ville :"

    	LabelVille.Top = 63

    	LabelVille.Left = 10

    	LabelTeleph.Parent = Fenetre

    	LabelTeleph.Caption = "Téléphone :"

    	LabelTeleph.Top = 88

   LabelTeleph.Left = 10

Nous avons créé 4 composants de type label et nous avons utilisé notre fenêtre principale pour contenir ces composants par les commandes d’association .Parent = Fenetre. Si nous avions, par exemple, créé un composant QPANEL sur notre fenêtre, celui-ci aurait pu également contenir nos contrôles. Mais nous verrons cela plus tard. Pour le moment, prenez le temps de digérer le code ci-dessus et ajoutez-le à votre premier morceau de code. Nous avons toujours notre fenêtre sur laquelle se sont ajoutés les 4 textes des Labels. Il est temps d’ajouter les 4 contrôles d’édition à notre application :

DIM EditNom AS QEDIT, EditAdresse AS QEDIT, _

       EditVille AS QEDIT, EditTeleph AS QEDIT

      EditNom.Parent = Fenetre

 	EditNom.Left = 70

 	EditNom.Top = 10

 	EditNom.Width = 230

EditAdresse.Parent = Fenetre

EditAdresse.Left = EditNom.Left

EditAdresse.Width = EditNom.Width

EditAdresse.Top = 35

EditVille.Parent = Fenetre

EditVille.Left = EditNom.Left

EditVille.Width = EditNom.Width

EditVille.Top = 60

EditTeleph.Parent = Fenetre

EditTeleph.Left = EditNom.Left

EditTeleph.Width = EditNom.Width

EditTeleph.Top = 85

Facile et logique ! Le principe est le même que pour QLABEL, le plus difficile étant de trouver les bonnes position et dimension dans la fenêtre. Dans cette portion de code, nous alignons tous les contrôles QEDIT sur les contrôles QLABEL correspondants. Prenez encore un peu de temps pour comprendre ce code et ajoutez-le aux morceaux précédents.

Tout ce qu’il reste à faire est d’ajouter 2 boutons et un contrôle de Boîte de Liste (Listbox). Voici comment l’on fait :

DIM BoiteListe AS QLISTBOX

   DIM BoutonAjoute AS QBUTTON, BoutonEfface AS QBUTTON

BoutonAjoute.Parent = Fenetre

BoutonAjoute.Left = 70

BoutonAjoute.Top = 115

BoutonAjoute.Width = 110

BoutonAjoute.Caption = "&Ajouter à la base"

BoutonEfface.Parent = Fenetre

BoutonEfface.Left = 190

BoutonEfface.Top = 115

BoutonEfface.Width = 110

BoutonEfface.Caption = "&Effacer la base"

BoiteListe.Parent = Fenetre

BoiteListe.Top = 150

BoiteListe.Left = 70

BoiteListe.Width = 230

   BoiteListe.Height = 150

Copiez et Collez, et voilà ! Nous avons maintenant une fenêtre qui ressemble exactement à l’image du paragraphe 4.1. Lancez et profitez de votre programme pendant un moment, puis revenez ici, nous avons encore deux petites choses à ajouter.

4.3 Gérer les événements

Comme vous avez pu le constater, notre programme s’est transformé en une jolie interface... complètement inutile. Quand vous cliquez sur un bouton, il ne se passe rien. Nous devons maintenant écrire la gestion d’événement qui fera fonctionner nos boutons. Voici comment :

      BoutonAjoute.OnClick = BoutonAjouteClic

C’est tout ? Presque... Le gestionnaire d’événement Onclick se charge de transférer l’exécution du programme vers une routine que nous avons nommé BoutonAjouteClic. Nous devons maintenant écrire cette routine, sachant que la routine ci-après devra être insérée avant la routine ci-dessus.

SUB BoutonAjouteClic

  	   IF BoiteListe.ItemCount > 0 THEN

            '-- Ajoute un séparateur entre les fiches

            BoiteListe.AddItems "--------------------------------"

         END IF

         BoiteListe.AddItems EditNom.Text, EditAdresse.Text, _

                             EditVille.Text, EditTeleph.Text

      END SUB

Bon, nous avons maintenant un endroit où aller. A chaque clic de l’utilisateur sur le bouton «Ajouter à la base», le code ci dessus sera exécuté. Son rôle consiste simplement à ajouter le contenu des 4 champs de saisie dans la boîte de liste. Si vous ne le saviez pas encore, le caractère de soulignement «_» peut être utilisé pour scinder une longue ligne en 2 ou plusieurs plus courtes. Nous y sommes presque. Il ne reste plus qu’à ajouter un gestionnaire d’événement pour le second bouton :

SUB BoutonEffaceClic

         BoiteListe.Clear

   END SUB

   BoutonEfface.OnClick = BoutonEffaceClic

Ca y est ! Si vous comptez les lignes de ce programme, vous en trouverez moins de 100. Notre application est maintenant opérationnelle. Vous pouvez l’utiliser, la modifier, et vous en servir comme outil d’apprentissage.

4.4 L’intégralité du code source.

   DIM Fenetre AS QFORM

   DIM EditNom AS QEDIT, EditAdresse AS QEDIT, _

       EditVille AS QEDIT, EditTeleph AS QEDIT

   DIM LabelNom AS QLABEL, LabelAdresse AS QLABEL, _

       LabelVille AS QLABEL, LabelTeleph AS QLABEL

   DIM BoiteListe AS QLISTBOX

   DIM BoutonAjoute AS QBUTTON, BoutonEfface AS QBUTTON

   SUB BoutonAjouteClic

     IF BoiteListe.ItemCount > 0 THEN

       '-- Ajoute un séparateur entre les fiches

       BoiteListe.AddItems "--------------------------------"

     END IF

     BoiteListe.AddItems EditNom.Text, EditAdresse.Text, _

                      EditVille.Text, EditTeleph.Text

   END SUB

   SUB BoutonEffaceClic

     BoiteListe.Clear

   END SUB

    LabelNom.Parent = Fenetre

    LabelNom.Caption = "Nom :"

    LabelNom.Top = 13

    LabelNom.Left = 10

    LabelAdresse.Parent = Fenetre

    LabelAdresse.Caption = "Addresse :"

    LabelAdresse.Top = 38

    LabelAdresse.Left = 10

    LabelVille.Parent = Fenetre

    LabelVille.Caption = "Ville :"

    LabelVille.Top = 63

    LabelVille.Left = 10

    LabelTeleph.Parent = Fenetre

    LabelTeleph.Caption = "Téléphone :"

    LabelTeleph.Top = 88

    LabelTeleph.Left = 10

    EditNom.Parent = Fenetre

    EditNom.Left = 70

    EditNom.Top = 10

    EditNom.Width = 230

    EditAdresse.Parent = Fenetre

    EditAdresse.Left = EditNom.Left

    EditAdresse.Width = EditNom.Width

    EditAdresse.Top = 35

    EditVille.Parent = Fenetre

    EditVille.Left = EditNom.Left

    EditVille.Width = EditNom.Width

    EditVille.Top = 60

    EditTeleph.Parent = Fenetre

    EditTeleph.Left = EditNom.Left

    EditTeleph.Width = EditNom.Width

    EditTeleph.Top = 85

    BoutonAjoute.Parent = Fenetre

    BoutonAjoute.Left = 70

    BoutonAjoute.Top = 115

    BoutonAjoute.Width = 110

    BoutonAjoute.Caption = "&Ajouter à la base"

    BoutonAjoute.OnClick = BoutonAjouteClic

    BoutonEfface.Parent = Fenetre

    BoutonEfface.Left = 190

    BoutonEfface.Top = 115

    BoutonEfface.Width = 110

    BoutonEfface.Caption = "&Effacer la base"

    BoutonEfface.OnClick = BoutonEffaceClic

    BoiteListe.Parent = Fenetre

    BoiteListe.Top = 150

    BoiteListe.Left = 70

    BoiteListe.Width = 230

    BoiteListe.Height = 150

    Fenetre.Center

    Fenetre.Caption = "Ma première application."

    Fenetre.Height = 340

    Fenetre.Width = 350

    Fenetre.ShowModal

Chapitre précédent 	Sommaire	Chapitre suivant


Introduction aux fenêtres
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 5 - Introduction aux fenêtres

5 - Introduction aux fenêtres

5. Introduction aux fenêtres

Ce chapitre présente les concepts de base de la gestion des fenêtres. L’exemple du chapitre précédent vous a déjà permis d’aborder ces concepts et de commencer à les comprendre.

5.1 Qu’est-ce qu’un fenêtre ?

Un fenêtre est une sorte de boîte à tout faire qui peut être affichée à l’écran. C’est un peu comme un panneau d’affichage (voir QPANEL). Une fenêtre peut prendre de nombreuses apparences. En Rapid-Q, les apparences possibles sont :

L’apparence par défaut est bsSizeable (redimensionnable). A quoi peut bien servir bsNone ? Pour les jeux :-) Exact ! Si la fenêtre est agrandie au maximum (maximized), vous pouvez utiliser toute la surface de votre écran pour votre jeu. Elle peut servir dans bien d’autres domaines... MSIE (Microsoft Internet Explorer) l’utilise pour l’option Pleine Page de son navigateur Internet. Si vous voulez savoir d’où viennent toutes ces variables, jetez un oeil sur le fichier RAPIDQ.INC. Vous y verrez bsNone = 0, bsSingle = 1, etc...Ces variables servent à faciliter votre programmation car Il est plus facile de retenir un nom qu’un numéro d’identification. Quand vous serez à l’aise avec le fichier RAPIDQ.INC, il ne vous sera pas interdit de traduire ces variables en français.

          $INCLUDE "RAPIDQ.INC"

          DIM Fenetre AS QFORM

          Fenetre.BorderStyle = bsDialog

          Fenetre.ShowModal

La fenêtre bsSingle est exactement la même que bsSizeable à la seule différence que vous ne pourrez pas la redimensionner. Dans la majorité des cas, les fenêtres les plus utilisées seront  bsSizeable et bsDialog.

5.2 Ajouter des composants à une fenêtre

Si vous avez bien suivi l’exemple du chapitre précédent, vous savez maintenant que vous pouvez inclure différents composants dans une fenêtre en assignant la propriété Parent de ces composants à cette fenêtre.

        DIM Fenetre AS QForm

        DIM Bouton  AS QButton

        Bouton.Parent = Fenetre       '' Ajoute un bouton à la fenêtre

Si cette «parentée» vous étonne, imaginez simplement un programme gérant de multiples fenêtres. Il est nécessaire, pour vous et pour le programme, de savoir quels composants s’affichent et interviennent lors de l’ouverture de chaque fenêtre. Certains composants comme QMENUITEM ou QTIMER n’ont pas de propriété Parent. Même si l’on considère QMENUITEM comme un composant «visible», ses seuls parents ne peuvent être que QMAINMENU ou QPOPMENU. Dans ce cas, plutôt que d’assigner une propriété Parent, vous devrez ajouter/insérer le QMENUITEM dans le menu auquel il appartient. Si aucun Parent ne lui est assigné, un composant reste invisible. Dans le cas de QCANVAS ou QIMAGE, vous obtiendrez un message d’erreur si vous tentez d’afficher un élément graphique, parce qu’il n’est pas possible d’afficher quoi que ce soit sur un composant non visible. Dans la majorité des cas, la propriété Parent doit être la première à assigner avant toute autre propriété. Pour rendre un composant invisible, utilisez la propriété Visible.

5.3 Détecter la position de la souris sur votre fenêtre

Il est quelquefois utile de détecter la position de la souris sur une fenêtre. le programme de démo TIC-TAC-TOE en est l’exemple type. Quelle que soit la configuration des différentes fenêtres ouvertes simultanément sur votre écran, Rapid-Q ne reconnaîtra le déplacement de la souris que sur la fenêtre active, la position indiquée sera donc relative à cette fenêtre. Pour récupérer ces valeurs, il vous suffit d’utiliser les varaibles internes MouseX et MouseY.

      X = MouseX

      Y = MouseY

Souvenez-vous que ces variables fournissent une position relative à la fenêtre active, et pas de la totalité de l’écran. Donc, MouseX = 0 et MouseY = 0 signifient que la souris est placée sur le coin supérieur gauche de la fenêtre active.

5.4 Les événements spécifiques aux fenêtres.

Il y a peu d’événements que seules les fenêtres peuvent gérer. Le plus important est l’événement OnResize

(si redimensionnement). Cela arrive quand l’utilisateur clique sur le bouton d’ouverture maximum de la fenêtre ou quand il redimensionne manuellement votre fenêtre. Votre programme devrait presque toujours capturer cet événement pour modifier la dimension de vos contrôles en proportion. Imaginez que votre navigateur Internet soit en 320x200 points et qu’il ne se modifie pas quand vous le passez en 640x480 points. Le résultat ne serait pas très esthétique. Si vous ne voulez pas que l’utilisateur redimensionne votre fenêtre, utilisez une apparence (BorderStyle) différente, comme mentionné ci-dessus.

L’appui sur une touche du clavier est un autre événement important. Je vous suggère d’utiliser OnKeyDown plutôt que OnKeyPress. OnKeyDown peut en effet détecter les caractères étendus, ainsi que les touches de fonctions Majuscule (Shift), Alt et Ctrl. N’utilisez OnKeyPress que si votre application ne doit pas gérer de caractères étendus.

La gestion du clavier est utile dans de nombreuses applications : éditeur de textes, jeux, etc... Le fait que OnKeyPress et OnKeyDown retournent un ou plusieurs paramètres peut prêter à confusion, car nous n’avons étudié jusqu’à maintenant que des événements simples qui ne demandaient aucun processus particulier comme :

SUB AjouteBoutonClic

        '' Faire ce qu’il faut

      END SUB

      	Bouton.OnClick = AjouteBoutonClic

Un clic sur notre contrôle bouton passe un simple message lui indiquant que ce clic a bien été reçu. Pour une touche du clavier, c’est un peu plus compliqué. Il ne suffit pas de dire qu’une touche a été pressée, il faut aussi savoir laquelle, nous devons donc ajouter un information supplémentaire :

      SUB TouchePressee(Touche AS BYTE)

        '' Faire ce qu’il faut

        PRINT Touche

      END SUB

      Fenetre.OnKeyPress = TouchePressee

La touche pressée est retournée dans la variable Touche. Vous pouvez donner à cette variable le nom que vous voulez, mais votre SUB doit avoir au moins un paramètre. Rapid-Q ne vous alertera pas si vous placez 2 paramètres, pas plus que si vous n’en placez pas du tout. C’est à vous de vous assurer que ce paramètre est bien présent. Dans le cas de OnKeyDown, deux paramètres sont passés :

      	SUB ToucheEtendue(Touche AS BYTE, Shift AS INTEGER)

        '' Faire ce qu’il faut

        PRINT Touche;" ";Shift

      END SUB

      Fenetre.OnKeyDown = ToucheEtendue

Trois touches de fonctions sont retenues : Shift, Alt et Ctrl. Avec la fonction Shift, deux interprétations sont possibles : avec OnKeyDown qui vous indique, en plus de la touche pressée, l’état de la touche de fonction; ou avec OnKeyPress qui ne reconnaîtra pas le Shift et vous obligera à utiliser UCASE$(Touche) si vous tapez Shift+i. La gestion des touches étendues est très différente en Rapid-Q de ce qu’offre QBasic. En QBasic, les touches de direction sont, par exemple, faciles à décoder :

    DO

      A$=INKEY$

      IF A$=CHR$(0)+"H" THEN PRINT "Flèche haute pressée"

    LOOP

En utilisant OnKeyDown, le code retourné n’est pas sur 2 octets. La flèche haute est = à 38, flèche Gauche = 37, flèche Droite = 39, flèche basse = 40

5.5 Les boîtes de dialogues

La boîte de dialogue est un type spécial de fenêtre, pratiquement jamais utilisée comme fenêtre seule, mais généralement ajoutée à votre fenêtre principale. Prenons par exemple une fenêtre où nous avons 3 choix :

Pour chaque choix, (sauf, éventuellement, pour le dernier) vous devrez créer une fenêtre de dialogue pour gérer les entrées de l’utilisateur. Quand celui-ci cliquera sur le premeir bouton, une boîte de dialogue de ce type devra apparaître :

Ces jolis boutons sont fabriqués sur mesure. Leurs valeurs sont dans RAPIDQ.INC

     	BoutonOK.Kind = bkOK

     	BoutonEfface.Kind = bkCancel

Mais comment savons-nous si l’utilisateur a cliqué sur le bouton OK ou CANCEL (efface). Deux moyens sont actuellement à votre disposition, les deux utilisent la propriété ModalResult. Souvenez-vous comment nous avons appelé notre boîte de dialogue :

   IF Dialogue1.ShowModal = mrOK THEN

      '' L’utilisateur a cliqué sur OK

   ELSE

      '' Il a cliqué sur Cancel

   END IF

La propriété ModalResult est utilisée par QButtons et Qforms. Quant nous tapons cela :

     BoutonOK.Kind = bkOK

Nous générons automatiquement cela :

     BoutonOK.ModalResult = mrOK

Cela veut dire qu’à chaque fois que l’utilisateur clique sur le bouton OK, la propriété ModalResult retournée est mrOK. Cela a pour effet de fermer automatiquement votre boîte de dialogue. Une autre approche moins élégante consiste à assigner vous-même la valeur de l’action réalisée par l’utilisateur à ModalResult. Ce programme en est l’exemple :

      SUB BoutonClic

          Dialog1.ModalResult = mrOK

      END SUB

      BoutonOK1.ModalResult = mrNone   '' Pas de résultat

      BoutonOK1.OnClick = BoutonClic

Dans ce scenario, le fait de cliquer sur le bouton transfère le contrôle à la SUB BoutonClic qui place la valeur correcte dans la propriété ModalResult de boîte de dialogue Dialogue1. Cela revient exactement au même que l’exemple précédent.

5.6 Utilisation de la méthode CREATE

Dans la majorité des cas, il vaut mieux utiliser la structure CREATE que l’instruction DIM. Vous gagnerez du temps et votre code source vous paraîtra plus clair. Pour vous en convaivre, il vous suffit de comparer ces deux listings :

        	DIM Fenetre AS QForm

            Fenetre.Left = 100

            Fenetre.Top = 50

            Fenetre.Height = 300

            Fenetre.Width = 400

            Fenetre.Caption = "Bonjour le monde !"

Le même code en utilisant la structure CREATE :

      CREATE Fenetre AS QForm

           Left = 100

           Top = 50

           Height = 300

           Width = 400

           Caption = "Bonjour le monde !"

      END CREATE

Le compilateur sachant à quel composant s’adresse chaque propriété, vous n’avez pas à retaper le nom du composant Fenetre à chaque ligne.

5.7 Structures CREATE imbriquées

On peut encore augmenter l’économie de caractères saisis et la clarté de notre programme en créant des structures CREATE imbriquées :

        CREATE Fenetre AS QForm

           Center

           CREATE Bouton1 AS QButton

              Left = 10: Top = 10: Height = 20: Width = 20

           END CREATE

           ShowModal

        END CREATE

Vous avez certainement remarqué que, dans ce cas, nous n’avons plus besoin de la propriété Parent. Dans cette structure, le compilateur a simplement compris que  vous avez inclus un bouton dans une fenêtre principale. Il a donc automatiquement généré un Bouton1.Parent = Fenetre pour vous. Comme vous pouvez le remarquer, ce code, beaucoup plus clair, vous permet de visualiser rapidement quel composant appartient à tel autre. Rapid-Q peut ainsi enregistrer jusque 25 niveaux d’imbrication bien qu’un programmeur normalement constitué n’en utilise que 4 ou 5. J’ai tout de même voulu satisfaire le 1% de programmeurs qui en a vraiment besoin. Comme vous pouvez vous en douter, les composants qui n’ont pas de propriété Parent (non visibles) ne sont pas admis dans une structure CREATE.

5.8 Créer des menus

Créer des menus par la structure CREATE est aussi simple :

 CREATE Fenetre AS QForm

           Center

           CREATE MenuPrincipal AS QMainMenu

              CREATE MenuFichiers AS QMenuItem

                Caption = "&Fichiers"

                CREATE MenuOuvrir AS QMenuItem

                  Caption = "&Ouvrir"

                END CREATE

                CREATE MenuEnregistrer AS QMenuItem

                  Caption = "&Enregistrer"

                END CREATE

              END CREATE

           END CREATE

           ShowModal

        END CREATE

Au lieu de la propriété Parent, nous avons économisé la frappe des propriétés AddItems. De plus, cette stucture est beaucoup plus lisible que par l’utilisation de DIM

Chapitre Précédent	 Sommaire	 Chapitre Suivant


Applications DOS
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 6 - Ecrire des applications dans une fenêtre MS-DOS

6 - Ecrire des applications dans une fenêtre MS-DOS

6. Ecrire des applications dans une fenêtre MS-DOS

Ecrire de telles applications (que nous appelerons Application DOS) est aussi facile, sinon plus que d’écrire des applications sous Windows. Pour créer un programme en mode texte sous DOS, il vous suffira de le compiler avec l’option CONSOLE (voir $APPTYPE) au lieu de GUI. Cette option est interessante pour les débutants en Basic qui disposeront alors d’un outil simple pour apprendre les notions fondamentales du langage et créer, puis tester rapidement de petites routines d’initiation. Cette option est également utile comme outil de debuggage (correction) pour vos applications Windows.

6.1 Résumé des instructions DOS

Une application DOS est un programme fonctionnant en mode texte dont le rôle est d’afficher et de recevoir des informations. En Rapid-Q, une application DOS dispose d’un écran d’affichage visible et de 7 autres écrans disponibles en mémoire. Voici un résumé des instructions liées à l’affichage et à la collecte d’informations :

   CLS	- Efface l’écran

   PRINT  	- Ecrit du texte à l’écran (visible ou en mémoire)

   INPUT  	- Attend une saisie au clavier de l’utilisateur

   PCOPY  	- Utilisé pour copier ou afficher des écrans en mémoire

   LOCATE 	- Positionne le curseur

   POS(0) 	- Donne la position actuelle du curseur (colonne)

   CSRLIN 	- Donne la position actuelle du curseur (ligne)

   COLOR  	- Change la couleur du texte

   POKE   	- Affiche un caractère et ses attributs de couleur à l’écran

   PEEK   	- Donne la valeur et les attributs de couleur d’un caractère affiché

   SLEEP  	- Délai d’attente

   INKEY$ 	- Saisie ‘au vol’ d’un caractère au clavier

Ces instructions ressemblent beaucoup à celles de QBasic. PEEK et POKE agissent de la même manière, SLEEP est plus précis que la version QBasic (vous pouvez utiliser des fractions de secondes, comme dans PowerBasic). A noter que vous n’avez pas à déclarer de segment (DEF SEG) puisque vous êtes dans le mode étendu de Windows.

6.2 Un exemple du type ‘Bonjour le monde’

Rapid-Q ressemble à de nombreux autre langages Basic. Ainsi, vous pouvez créer votre programme ‘Bonjour le monde’ en une seule ligne :

     PRINT "Bonjour le Monde !"

Compilez et lancez..., vous venez de créer votre première application DOS sous Windows ! Voyons maintenant quelque chose de plus interessant : la copie entre différents écrans en mémoire :

      CLS

   PRINT "C’est la page 1"

   PCOPY 0, 1    '-- Copie la page visible 0 dans la page mémoire 1

   CLS

   PRINT "Tapez une touche pour voir la page 1"

   DO:LOOP UNTIL INKEY$<>""

   PCOPY 1, 0    '-- Copie la page mémoire 1 dans la page visible 0

Comme vous pouvez le voir, notre page visible est toujours la page 0. Nos pages en mémoire portent les numéros 1 à 7. PCOPY copie simplement le contenu d’une page dans une autre. Vous pouvez ainsi copier une page mémoire vers une autre page mémoire, comme cela :

   PCOPY 1,5

Le contenu de la page mémoire 1 est maintenant copié dans la page mémoire 5. En fait, il n’y a rien de nouveau par rapport à ce qui existe déjà dans QBasic. Une caractéristique est cependant nouvelle, elle vous permet d’écrire directement dans une page mémoire :

   PRINT #1, "Bonjour!"       '-- Ecrit directement dans la page 1

N’oubliez pas d’utiliser le signe #, sinon le 1 sera traité comme une valeur numérique. Pour voir votre texte, tapez PCOPY 1,0. LOCATE et COLOR peuvent être utilisés de la même manière dans des pages mémoire, tout comme PEEK et POKE, il vous suffit d’ajouter le même paramètre qui correspond au numéro de page.

6.3 Utilisation de PEEK et POKE

PEEK et POKE ont les mêmes caractéristiques que dans QBasic, excepté dans le cas de PEEK/POKE dans une page écran. Si vous n’avez jamais utilisé ces instructions avant, il vous suffit de les tester, justement, dans les pages écran. Dans ce cas, les adresses vont de 1 à 3999, parce qu’un écran de texte contient 25 lignes x 80 caractères. Mais 25x80 ça fait 2000 ! Alors pourquoi 2000 de plus ?... Etudions cet exemple :

    POKE 0, ASC("A")

    POKE 1, 15

Si vous exécutez ce programme, vous verrez apparaître la lettre ‘A’, en blanc, sur le coin supérieur-gauche de votre écran. Cela nous permet de tirer la conclusion suivante : un caractère affiché à l’écran est composé de 2 valeurs (ou octets). La première contient la valeur du caractère, la seconde contient son attribut de couleurs. L’attribut est la combinaison des couleurs de caractère et de fond codée sur un octet (8 bits). Les 4 bits de poids faible correspondent à la couleur du caractère (parmi 16), les 4 octets de poids fort correspondent à la couleur du fond (parmi 16). Si vous êtes accoutumé aux octets et bits, vous pourrez facilement déterminer l’attribut de couleur :

    B? = &H07       '-- Fond = 0, Caractère = 7

Vous pouvez ainsi obtenir des couleurs de fond en haute intensité, mais le mode clignotant n’est pas supporté.

6.4 Détecter les touches étendues du clavier

Il n’est pas possible de détecter les touches étendues du clavier par la commande INKEY$ (seulement sous Windows, vous pouvez le faire sous Linux/Unix). Une abominable astuce permet cependant de le faire, je ne vous la conseille que dans ce cas. Le composant QFORM gère la propriété OnKeyDown, nous allons donc détecter toutes nos touches par ce moyen. Le seul problème, c’est que la fenêtre doit être visible pour gérer des événements, nous la cacherons en lui donnant des dimensions à zéro et un BorderStyle de type bsNone. A noter que cet exemple n’e doit être utilisé que dans ce cas précis :

   $APPTYPE CONSOLE

   $INCLUDE "RAPIDQ.INC"

   DIM Fenetre AS QForm

   SUB ToucheClavier(Touche AS BYTE, Controle AS INTEGER)

     PRINT "Touche: ";Touche; "  Controle: "; Controle

   END SUB

   Fenetre.OnKeyDown = ToucheClavier

   Fenetre.BorderStyle = bsNone

   Fenetre.Width = 0

   Fenetre.Height = 0

   Fenetre.Enabled = True

   Fenetre.Visible = True

   DO

     DoEvents       '-- Gère les événéments

   LOOP

Vous avez probablement noté que la fenêtre DOS est désactivée, mais que les entrées/sorties continuent à fonctionner. Tapez quelques touches pour essayer. Ne cliquez pas sur la fenêtre DOS (sauf quand vous voudrez arrêter), sinon le programme ne fonctionnera plus. Tapez Ctrl+C pour sortir du programme.

6.5 Mélanger les fenêtres DOS et Windows

Dans l’exemple précédent, nous avons ouvert simultanément une fenêtre DOS et une fenêtre Windows. Ce mélange est tout à fait possible à la condition que vous compiliez votre application en mode CONSOLE. Il y a quelques différences bizarres sous Linux/Unix, référez-vous au guide de compatibilité pour plus d’informations. Une application GUI sous Linux/Unix peut, par exemple, exécuter quelques instructions DOS comme PRINT, INPUT et CLS sans être compilée en mode CONSOLE.

6.6 Le mode Texte sous Linux/Unix

Comme il existe de nombreux terminaux différents, certaines instructions du mode Texte pourront ne pas fonctionner. Si votre terminal ne supporte pas la couleur, il n’affichera rien. Dans tous les cas, ne vous inquiétez pas, Rapid-Q saura gérer ce type d’erreur pour vous. Il en est de même pour les claviers étendus dont certaines touches ne sont pas supportées par certains terminaux. Cependant, la majorité des terminaux supporte les touches de directions et les touches Page-Haut et Page-Bas et vous êtes presque assuré que votre programme fonctionnera avec ces touches.

Chapitre Précédent	Sommaire	Chapitre suivant


Files de données
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 7 - Introduction aux files de données

7. Introduction aux files de données

7. Introduction aux files de données

Rapid-Q utilise des commandes de files de données appelées stream à la place de la commande standard OPEN utilisée dans les autres BASICs. Seul le nom change, les fonctionnalités sont pratiquement identiques. Les files ont de gros avantages : elles sont de taille illimitée et elles peuvent se copier entre elles, par exemple depuis un fichier sur disque vers la mémoire.

7.1 Les commandes de files de données

Ces commandes sont utilisées pour créer, lire et écrire des fichier. Une file est ouverte en mode binaire, sans pouvoir être bloquée (lock). Tous les fichiers ouverts sont partagés avec l’application. Prenez un moment pour vous familiariser avec ces commandes de fichiers :

     fmCreate    	- Crée un fichier (en lecture/ecriture) et remplace un éventuel fichier de même nom

     fmOpenRead  	- Ouvre un fichier en lecture seule

     fmOpenWrite 	- Ouvre un fichier en écriture seule

     fmOpenReadWrite	- Ouvre un fichier en lecture et écriture

Pour ouvrir un fichier, vous devez indiquer le titre et l’un des modes d’accès ci-dessus.

      DIM Fichier AS QFileStream

   Fichier.Open("Test.txt", fmOpenRead)

Cela ouvrira le fichier test.txt en lecture seule. Pour lire des données, vous utiliserez les méthodes ReadNum (lire un nombre) et ReadStr (lire un chaîne de caractères). Voir RAPIDQ.INC pour les valeurs de ces commandes.

     PRINT Fichier.ReadNum(Num_SINGLE)   '-- Lit une valeur SINGLE de 4 octets

     PRINT Fichier.ReadStr(1024)         '-- Lit 1024 caractères

Vous devrez écrire vous-même vos routines de lecture et écriture de lignes de texte. Quand vous en aurez terminé avec votre fichier, n’oubliez pas de le fermer. Cela ne vous empêchera pas de continuer à utiliser votre file de données et d’ouvrir un autre fichier. Comme il n’y a pas de fonction EOF (End Of File) qui teste si vous avez atteint la fin d’un fichier, vous devrez comparer en permanence la propriété File.Position avec la propriété File.Size (longueur du fichier). Vous n’avez pas atteint la fin de votre fichier tant que File.Position est inférieur à File.Size. Il y a actuellement 2 méthodes pour tester l’existence d’un fichier :

     IF FileExists("Test.txt") <> FALSE THEN

       File.Open("Test.txt", fmOpenRead)

     END IF

Il est cependant plus sûr d’utiliser cette méthode :

     IF File.Open("Test.txt", fmOpenRead) = FALSE THEN

        ShowMessage("Could not open file")

     END IF

File.Open retournera une valeur différente de 0 si le fichier est trouvé, ou 0 sinon.

7.2 Les files de données en mémoire

Comme pour les fichiers de files de données, une file de données en mémoire est créée dès que vous l’ouvrez par DIM. Les méthodes comme ReadNum et WriteNum, etc... sont également identiques. La seule différence est que le stockage des données s’effectue en mémoire. La file peut se réduire ou grandir sans limite de taille. Il est également possible de stocker des tableaux de nombres (voir l’exemple ARRAY.BAS). Les files de données en mémoire peuvent être utilisées dans de nombreux domaines. L’un d’entre eux consiste à copier un fichier sur disque en mémoire, d’en modifier les données et de le recopier sur le disque. Il est très simple de copier une file de données vers une autre, qu’elle soit sur disque ou en mémoire :

    DIM Fichier AS QFileStream

    Fichier.Open("test.txt", fmOpenRead)

    DIM Memoire AS QMemoryStream

    Memoire.CopyFrom(Fichier, Fichier.Size)  '-- Copie toute le file

Dans cet exemple, nous avons simplement copié la totalité du fichier «test.txt» dans une file de données en mémoire. Nous pouvons maintenant la manipuler sans modifier le fichier sur disque.

Chapitre Précédent	Sommaire	Chapitre Suivant


RessourcesGraphiques
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 8 - Utiliser les ressources graphiques

8. Utiliser les ressources graphiques

8. Utiliser des ressources graphiques

La majorité des langages de programmation proposent l’intégration de fichiers .RES (Ressource). Un fichier Ressource n’est rien d’autre qu’une collection d’images (et quelquefois de textes et de données). Dans ce chapitre vous allez apprendre la notion de listes d’images, la manière d’utiliser correctement des ressources dans votre application et de les intégrer dans votre fichier exécutable.

8.1 Les ressources supportées

Rapid-Q supporte uniquement les ressources graphiques sous formes d’icones ou de fichiers par points (Bitmap). L’intégration de ressources n’a pas encore été réalisée sous Linux/Unix. Donc, quelle est la différence entre le chargement de ressources pendant l’exécution du programme et la gestion interne des ressources ? Il n’y en a qu’une : quand vous gérer une ressource interne, celle-ci est intégrée automatiquement dans votre fichier exécutable. Voici un exemple :

     $RESOURCE ICO_TEST AS "C:\ICONS\TEST.ICO"

     DIM Fenetre AS QForm

     Fenetre.ICOHandle = ICO_TEST

     'Fenetre.Icon = "C:\ICONS\TEST.ICO"

le fichier C:\ICONS\TEST.ICO est intégré dans votre fichier exécutable, cela veut dire que vous n’aurez pas à ajouter le fichier TEST.ICO si vous distribuez votre programme .EXE. Rapid-Q ne génère pas de fichiers .RES et ne gère pas non plus les autres fichiers .RES. Vous avez certainement déjà vu des langages qui utilisent des fichiers .RES. Pour les utiliser avec Rapid-Q, vous devrez d’abord extraire les images qu’ils contiennent, puis les inclure dans votre application à l’aide de la directive $RESSOURCE. Il est également possible de faire comme cela :

     Form.ICOHandle = ICO_TEST

     DIM Image AS QImage

     Image.Icon = Form.Icon

Normalement, Image.Icon accepte une chaîne de caractères, mais si aucune chaîne n’est spécifiée, l’argument sera l’image qui a été préalablement mise en «cache». Dans ce cas, nous plaçons Form.Icon dans notre cache, puis faisons lire ce cache par Image.Icon. Mais alors, que fait cette ligne ? :

     Image.Icon = Form.Icon + Form2.Icon

Elle place Form2.Icon dans le cache, puis Image.Icon lit le cache et prend la valeur de Form2.Ico.  Notez cependant que vous ne pouvez pas faire de IcoHandle un argument, par exemple :

     Image.IcoHandle = Form.IcoHandle

8.2 Introduction aux listes d’images

Pour mieux comprendre les listes d’images, il est préférable de vous aider de la liste des méthodes et propriétés de QImageList située dans l’appendice. Une liste d’images est un tableau d’icones et/ou d’images (Bitmap). Elles sont rangées dans l’ordre 0 à N. Votre première image portera le No. 0, la seconde le No.1, etc... Une liste d’images contient des images de largeur et hauteur FIXES. Dès que vous changez la propriété Width (largeur) ou Height (hauteur), vous effacez irrémédiablement le tableau d’images entier. Cela ne veut cependant pas dire que vous ne pouvez pas ajouter une image BMP de 100x100 points quand la largeur de votre liste d’images est de 32 points, mais dans ce cas, que vous le vouliez ou non, votre image sera redimensionnée.

    DIM Liste_Images AS QImageList

        Liste_Images.Width = 32

        Liste_Images.Height = 32

        Liste_Images.AddICOFile("app.ico")

        Liste_Images.AddBMPFile("app.bmp", 0)

Vous pouvez ajouter des icones et images Bitmap dans n’importe quel ordre. Comme dans le chapitre précédent, vous pouvez également ajouter des images en provenance du «cache» si aucun nom de fichier n’est spécifié :

    Liste_Images.AddICOFile(Form.Icon)

    Liste_Images.AddICOFile(ImageList.GetICO(0))

Puisque que nous parlons du cache, ceci est également valide :

    Liste_Images.GetICO(0)        '-- Remplit le cache avec des données

    Liste_Images.AddICOFile(7*546/4*2^6+23-21)

Il est évident que ce genre d’idée génère un code très confus que je ne recommande pas, il est neanmoins valide puisque notre cache contient l’icone de l’index 0 de la liste d’images. Quelle que soit la taille de votre fichier d’image, n’hésitez pas à utiliser le cache dès que vous en avez l’utilité. 2 caches sont actuellement à votre disposition dans Rapid-Q, le cache BNP et le cache Icone. Ils sont indépendants, le fait de remplir l’un ne détruit pas l’autre.

Chapitre précédent	Sommaire	Chapitre suivant


SUBI FUNCTIONI DLL
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 9 - SUBI, FUNCTIONI et DLLs

9 - SUBI, FUNCTIONI et DLLs

9. SUBI, FUNCTIONI, et DLLs

Vous allez maintenant apprendre comment créer vos propres SUB/FUNCTIONS avec un nombre variable de paramètres. Si vous avez quelques notions de C, vous connaissez certainement sa commande la plus connue : printf. Avec Rapid-Q, vous allez pouvoir créer votre propre commande printf !

9.1 SUB/FUNCTIONs avec paramètres variables

Avec les SUBs et FUNCTIONs traditionnelles, vous pouvez passer un nombre fixe de paramètres. Par contre, les SUBIs et FUNCTIONIs peuvent accepter jusqu’à 255 paramètres. Mais comment peut-on récupérer autant de paramètres ? c’est simple, ils sont actuellement stochés dans une pile interne, et vous allez devoir explorer cette pile pour en extraire le paramètre correct. Voici les instructions utilisées pour cela :

   ParamStr$()   	- Tableau de paramètres chaînes de caractères

   ParamVar()    	- Tableau de paramètres numériques

   ParamValCount 	- Nombre de paramètres numériques passés

   ParamStrCount 	- Nombre de paramètres chaînes passés

Avec cet exemple simple, nous allons juste tester si ça marche :

    SUBI TestSUBI (...)

       PRINT "Paramètres chaînes : " ; ParamStrCount

         FOR I = 1 TO ParamStrCount

           PRINT I;" "; ParamStr$(I)

         NEXT I

       PRINT "Paramètres numériques : " ; ParamValCount

         FOR I = 1 TO ParamValCount

           PRINT I;" "; ParamVal(I)

         NEXT I

    END SUBI

    TestSUBI "Hello", 1234, "Hmmm", "Yeah...", 9876, 1*2*3*4, UCASE$("Last one")

Notez également que la première valeur des tableaux ParamStr$() et ParamVal() démarre à 1 et pas à 0. C’est contraire à la règle générales des tableaux en Rapid-Q dont la base est toujours 0. Une autre bizarrerie est l’utilisation de (...) à la place des noms de paramètres. En fait, vous pouvez placer ce que vous voulez entre les parenthèses, à la condition que ce soit un mot-clé valide (de 1 mot). En résumé, la création d’une FUNCTIONI n’est pas différente de la création d’une FUNCTION standard, excepté que vous remplacez vos paramètres fixes par (...)

9.2 Des précisions sur FUNCTIONI

Pour compléter vos connaissances, étudions un autre exemple. Celui-ci va rechercher la valeur la plus haute des paramètres que vous aurez passés :

   FUNCTIONI TrouveMax (...) AS DOUBLE

     DIM LePlusGrand AS DOUBLE

     DIM I AS BYTE

     LePlusGrand = -999999999999

     FOR I = 1 TO ParamValCount

       IF ParamVal(I) > LePlusGrand THEN

          LePlusGrand = ParamVal(I)

       END IF

     NEXT

     TrouveMax = LePlusGrand         ' ou Resultat = LePlusGrand

   END FUNCTIONI

La fonction scrute la liste entière des paramètres et détecte le plus grand. Tous les paramètres chaînes sont simplemnt ignorés. Testez maintenant cela :

  PRINT "Le plus grand nombre est : "; TrouveMax(523, 12.4, 602, 45, -1200)

 PRINT "Le plus grand nombre est : "; TrouveMax(523, 12.4, TrouveMax(602, 45, -1200))

Si cela vous plait, vous pouvez imbriquer vos FUNCTIONI, Rapid-Q aime ça!

Pour bien assimiler les SUBI/FUNCTIONI, souvenez-vous simplement des instructions nécessaires à l’accès à la pile interne, et n’hésitez pas à les utiliser!

9.3 Introduction aux DLLs

Avant d’aborder ce vaste sujet, notez que Rapid-Q propose une gestion simplifiée des DLLs; et ne passe qu’un maximum de 2 paramètres. (Depuis la version du 7 octobre 1999, Rapid-Q peut gérer un nombre quelconque de paramètres, mais la solution la plus stable reste à 2). Cela veut dire que l’accès aux API de Windows risque d’être compliqué si vous ne disposez pas d’un autre moyen d’accès. Il vous est possible d’écrire un programme en C (ou autre langage) et de l’interfacer avec Rapid-Q pour remplacer cette gestion simpifiée. Vous écrirez, par exemple un programme C qui accédera directement aux API Windows et que vous transformerez en une DLL à laquelle Rapid-Q pourra accéder. C’est du travail supplémentaire, mais ce sera actuellement votre seul recours. Au fait, qu’est-ce qu’une DLL ? c’est une Dynamic Link Library (librairie de liens dynamiques) qui est liée à votre programme au moment de l’exécution.

9.4 Comment appeler une DLL

Dans le répertoire exemples de Rapid-Q, vous trouverez un programme appelé DLL.BAS, ainsi qu’une DLL appelée PASCAL.DLL. Jetez un oeil sur leur contenu. Le moyen pour appeler une DLL en Rapid-Q est pratiquement identique à celui utilisé dans PowerBASIC ou VisualBASIC. Il n’est pas des plus plaisants, mais j’ai décidé de me conformer au standard. Notez en premier lieu qu’il vous faudra respecter... les Majuscules/Minuscules (oui, vous avez bien lu !) qu‘on appelle aussi la casse. Si vous ne le faites pas... Splatchhh ! c’est le plantage. Pas d’inquiétude cependant, il n’existe actuellement que 2 fonctions : la première que vous appelez dans votre programme, la seconde qui est contenue dans la DLL. Seules, ces 2 fonctions/sub imposent le respect de la casse... sinon Splatch!

    DECLARE SUB Test LIB "TEST.DLL" ALIAS "MyFunc" (S AS STRING)

Vous vous demandez bien sûr où doit être respectée la casse dans cette ligne, dans Test ou MyFunc. Test est le nom que vous donnez à la fonction que vous appelerez dans votre programme, ce n’est donc pas là. MyFunc est le nom contenu dans la DLL, celui doit être correctement saisi ! La SUB ci-dessus va pointer sur l’adresse mémoire de votre DLL (quand elle sera chargée) et va exécuter le code qu’elle contient. Comme vous le voyez, il n’y a qu’un paramètre dans notre routine MyFunc. Deux nouvelles instructions sont également présentes : LIB et ALIAS. Après LIB, la chaîne doit correspondre au chemin d’accès et au titre de votre DLL. Si cette DLL est dans votre répertoire courant ou dans les paramètres de votre $PATH, vous n’avez pas à spécifier le chemin (si, par exemple, TEST.DLL existe dans C:\WINDOWS\SYSTEM). L’instruction ALIAS sert à indiquer la routine que vous souhaitez exécuter à l’intérieur de la DLL appelée. Vérifiez encore la casse, c’est très important. Si vous n’en êtes pas sûr, vous pouvez utiliser un éditeur de DLL, comme Quick View (voir plus loin).

Quels type de données peut-on passer comme argument ? : SHORT/WORD, INTEGER/LONG/DWORD, DOUBLE, STRING. Au contraire de quelques langages qui vous forcent à passer une chaîne comme un pointeur, Rapid-Q le fait dans ce cas pour vous et vous n’avez pas à vous en soucier. Dès que vous voyez un paramètre du type LPZSTR, qui veut dire Long Pointer Zero-Terminated String (Pointeur Long sur une Chaîne terminée par un Zéro), vous pouvez passer un paramètre chaîne en toute sécurité. Il est à noter que certains BASIC (comme VB) n’imposent pas l’instruction ALIAS quand la routine appelée porte le même nom que la fonction déclarée, par exemple :

    DECLARE SUB MyFunc LIB "TEST.DLL"

La possibilité de supprimer l’instruction ALIAS dans ce cas précis NE S’APPLIQUE PAS à Rapid-Q. Je vous recommande donc de ne pas essayer.

Quand je vous aurai dit que le fait d’appeler une FUNCTION est exactement identique à celui d’appeler une fonction DLL, vous saurez tout sur l’appel des DLL avec Rapid-Q :

    MyFunc("Hello")

9.5 Utilisation de Quick View (Aperçu Rapide)

Comme je l’ai déjà indiqué, si vous n’êtes pas sûr de la casse exacte de votre fonction, ce serait une bonne idée d’apprendre à utiliser Quick View :

Quick View est inclus dans les utilitaires de Windows (il est inutile de le télécharger). Pour appeler Quick View, lancez votre Explorateur Windows (ou cliquez sur « Poste de Travail ») et cherchez un fichier .DLL. Faites ensuite un Click Droit (bouton de droite) puis cliquez sur Aperçu Rapide. Cherchez la Table d’Importation, c’est là que vous verrez la casse exacte de vos routines. Il existe certainement de meilleurs utilitaires de ce type, mais, dans la majorité des cas, l’Aperçu Rapide suffira amplement pour vos besoins.

9.6 Ecrire vos propres DLLs

Dans sa version actuelle, il n’est pas possible d’écrire de DLLs avec Rapid-Q. De nombreux langages sont capables de le faire. Si vous écrivez une DLL pour Rapid-Q, rappelez-vous simplement ces 2 conditions : 2 paramètres au plus, et seulement des types de données simples : SHORT, WORD, INTEGER, LONG, DWORD, DOUBLE, et STRING.

Chapitre Précédent	Sommaire	Chapitre Suivant


Composants personnalises
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 10 - Créer des composants personnalisés

10 Créer des composants personnalisés

10. Créer des composants personnalisés

La création de composants personnalisés peut être utile si vous souhaitez, entre autres, apporter une touche d’originalité à vos fenêtres et applications. Vous pourrez, par exemple, remplacer les boutons de sélection standard de Windows par des losanges de couleur (le listing complet est à la fin de ce chapitre). Quand vous aurez étudié ce chapitre, vous serez capable de créer vos propres composants, et même vos propres fenêtres ! Commençons par un exemple simple de bouton de sélection.

10.1 Introduction à la création d’objets

Vous n’aurez pas vraiment besoin de réinventer la roue pour créer vos objets personnalisés. Créer votre propre objet revient à étendre les capacités d’un composant (comme Qcanvas), à hériter de toutes ses propriétés, méthodes et événements. Ensuite, vous pourrez choisir d’étendre les propriété et/ou méthodes ou d’en créer de nouvelles. Le concept est vraiment facile à comprendre, pour peu que vous acquis quelque expérience dans la gestion des composants et de leurs propriétés/méthodes. La création de composants Rapid-Q ne ressemble en soi à aucun autre langage, mais elle ne leur est pas non plus très éloignée. Comme le concept de création d’objets n’est pas vraiment nouveau, il est nécessaire de vous familiariser vous-même avec les notions de propriétés, de méthodes et d’événements. Vous devez également acquérir une bonne compréhension des TYPEs car la gestion des événements/méthodes à l’intérieur de structures TYPE est, par contre, un concept nouveau. Ne confondez pas non plus Rapid-Q avec un Langage Orienté Objet, car il ignore les concepts de surcharge, ou de membres protégés ou virtuels. Les concepts OCC (Création de Composants Objets) de Rapid-Q ne se réfèrent à aucun autre langage, mais ils empruntent plusieurs idées à certains Langages Orientés Objet comme Delphi, C++ et Java.

10.2 Etendre Qcanvas

Qcanvas est un composant universel de type «feuille blanche». Il vous permet de créer et d’afficher ce que vous voulez et se prête à des extensions très utiles. D’abord, comment pouvons-nous faire pour l’étendre ?

     TYPE QDiamondBox EXTENDS QCanvas

     END TYPE

Bon, ça paraît facile. Le code ci-dessus est parfaitement valide, bien qu‘il ne fasse rien d‘utile, hormis de créer un nouvel objet appelé QDiamondBox (boîte ovale) qui hérite de toutes les propriétés, méthodes et événements de QCanvas. Nous pouvons maintenant lui donner un nom par DIM et lui assigner des valeurs :

     DIM DBox AS QDiamondBox

         DBox.Top = 10

On a avancé, mais notre composant n’est pas encore utilisable, il faut encore lui ajouter quelques propriétés indispensables comme Caption, et peut-être Checked puisque nous voulons créer un bouton de sélection. L’addition de propriétés s’effectue comme nous l’avons déjà appris :

     TYPE QDiamondBox EXTENDS QCanvas

        Caption AS STRING

        Checked AS INTEGER

     END TYPE

Comme vous le constatez, cela ressemble fort à une procédure TYPE (variable Type définie par l’utilisateur) que l’on rencontre dans de nombreux BASICs. Nous avons donc ajouté 2 propriétés supplémentaires à notre composant et pouvons y accéder comme nous le ferions pour n’importe quelle propriété. Oui, mais que se passe-t-il si vous voulez initialiser des valeurs au momoent de la création de ce composant ? C’est très simple, plus simple que la procédure constructor de C++. Il vous suffit d’intégrer ces informations comme ceci :

     TYPE QDiamondBox EXTENDS QCanvas

        Caption AS STRING

        Checked AS INTEGER

        CONSTRUCTOR

          Caption = "DiamondBox"

          Checked = 0

        END CONSTRUCTOR

     END TYPE

Après chaque DIM (dans le cas d'un objet), les valeurs par défaut sont initialisées. Quand votre programme se termine, toutes ces valeurs sont effacées et vous n’avez jamais besoin d’instructions du type DESTRUCTOR. Si vous n’en êtes pas convaincu, testez cela :

     DIM DBox AS QDiamondBox

     ShowMessage(DBox.Caption)

Si cette routine ne retourne pas 'DiamondBox' , relisez votre programme et activez $TYPECHECK ON.

10.3 Ajouter / Redéfinir des méthodes

Pour les utilisateurs familiers des langages Objet, il n’y a pas de structures comme les membres protégés en Rapid-Q, toutes les méthodes (dont les propriétés) sont virtuelles et peuvent donc être redéfinies. Le principe est donc simple : au lieu d’utiliser les propriétés héritées d’une méthode, on peut les reféfinir librement.

     TYPE QDiamondBox EXTENDS QCanvas

        Left AS STRING

        Top AS BYTE

        SUB Pset

        END SUB

     END TYPE

Dans cet exemple, nous avons redéfini 2 propriétés de Qcanvas et 1 méthode. La redéfinition de propriétés et méthodes est utile dans de nombreux cas. Imaginez une listbox (boîte de liste) dont vous voudriez filtrer les lignes. Il vous suffit de redéfinir la méthode AddItem pour filtrer les mots que vous ne voulez pas voir affichés. La redéfinition est également utile quand vous voulez transférer votre code Windows vers Linux et vice versa, elle vous permet de créer votre filtre "standard" de conversion pour les 2 versions. Arrêtons-nous là, nous n'irons pas plus loin dans cette voie. Revenons plutôt à la création de méthodes pour nos composants :

     TYPE QDiamondBox EXTENDS QCanvas

       Caption AS STRING

       Checked AS INTEGER

       FUNCTION TextSize AS INTEGER

         Result = LEN(QDiamondBox.Caption)

         'QDiamondBox.TextSize = LEN(QDiamondBox.Caption)

       END FUNCTION

     END TYPE

L'exemple ci-dessus est un bon point de départ. Nous avons juste défini une nouvelle méthode pour le composant QdiamondBox. Comme vous l'avez remarqué, nous devons intégrer nos FUNCTIONs ou SUBs dans notre structure TYPE. Cela s'appelle du code EN LIGNE (INLINE) que vous devez connaître si vous avez utilisé C++ ou un autre langage Objet. Rapid-Q impose ce code EN LIGNE car votre SUB doit être intégrée à la structure TYPE de redéfinition. Il y a quand même quelquechose en dehors de la structure, c'est QdiamondBox.Caption… qui fait quoi exactement ? Vous vous demandez peut-être pourquoi on ne peut pas simplement écrire :

      Result = LEN(Caption)

Bref, ce n'est pas si simple, sachant que l'on aurait très bien pu ajouter dans notre fonction :

      DIM Caption AS INTEGER

Dans ce cas, Rapid-Q aurait été bien embarassé… Heu… Quelle variable dois-je utiliser, la variable locale ? ou celle de la propriété ? Pour lui faciliter les choses, quand vous voulez utiliser une propriété ou une méthode, vous devez l'appeler par la méthode classique. Dans cet exemple, notre objet c'est QDiamondBox, et nous voulons utiliser la propriété Caption. Comme les 2 lignes précédentes sont inutiles et inefficaces, nous allons tout simplement les oublier. Ce que nous voulons en fait, c'est une méthode qui crée notre composant, la voici :

  SUB DrawComponent

    IF QDiamondBox.Checked THEN

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,0)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,0) QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Paint(QDiamondBox.Height/2, QDiamondBox.Height/2, QDiamondBox.HiLightColor,0)

QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,&HFFFFFF)

QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBoxHeight,&HFFFFFF)

    ELSE

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,0)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,0)

QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QdiamondBox.Height,0)

      QDiamondBox.Paint(QDiamondBox.Height/2, QDiamondBox.Height/2, &HBBBBBB, 0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,&HFFFFFF)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,&HFFFFFF)

    END IF

    QDiamondBox.TextOut(QDiamondBox.Height + 5, QDiamondBox.Height/2-QDiamondBox.Height/4,

    QDiamondBox.Caption, 0, -1)

  END SUB

Ce code peut paraître un peu lourd, c'est essentiellement dû à la longueur des lignes. En fait, il dessine un losange avec des dimensions proportionnelles de manière à ce qu'il conserve ses proportions dès que vous redimensionnez le composant. Cette notion est très importants si vous ne voulez pas que votre composant se transforme en miniature si l'utilisateur décide de lui donner une largeur = 100, hauteur = 100, etc… Insérez ce code dans votre déclaration TYPE. Nous devons ensuite définir la propriété HiLightColor qui informera l'utilisateur que le composant a été cliqué.

10.4 Definir des événements

Il n'est pas possible de définir de nouveaux événements pour notre composant. Il bénéficie donc de tous les événements dont il a hérité. Par bonheur, nous avons tout ce qu'il nous faut pour notre composant DiamondBox ; OnPaint et OnClick. Au fait, pourquoi devons-nous définir des événements alors que l'utilisateur peut les déclencher lui-même ? C'est vrai, mais n'oublions pas que ce composant est personnalisé et que nous devons décider des modifications qu'il doit subir. Par exemple, le composant QcheckBox prend une apparence "testé" ou "non testé" à chaque fois que l'on clique dessus sans que nous ayons à écrire de gestion d'événement pour cela. Si nous voulons qu'il arrive la même chose pour notre composant, nous devons le gérer. Pour commencer, nous allons utiliser l'événement OnPaint qui est appelé chaque fois que l'apparence de notre composant est mise à jour.

     TYPE QDiamondBox EXTENDS QCanvas

       'On place les propriétés ici

       'et ici les méthodes (commandes d'affichage)

       EVENT OnClick

         IF QDiamondBox.Checked THEN

           QDiamondBox.Checked = 0

         ELSE

           QDiamondBox.Checked = 1

         END IF

         QDiamondBox.DrawComponent

       END EVENT

       EVENT OnPaint

         QDiamondBox.DrawComponent

       END EVENT

     END TYPE

Nous avons déjà étudié pourquoi nous utilisons DrawComponent de dette manière, par contre, l'instruction EVENT est nouvelle.  Elle est là pour  nous permettre de gérer les événements de notre composant et vous permet d'écrire simplement votre code pour chaque événement. A chaque fois que nous créons un un nouveau composant (par DIM), les événement sont automatiquement pris en compte et sont appelés quand l'événement correspondant se produit. Très bien, mais comment faire pour ajouter la gestion d'un nouvel événement. Dans l'exemple QdiamondBox, nous avons dû complètement redéfinir OnClick, puisque l'utilisateur devait savoir s'il avait cliqué ou non sur l'objet, cela a egffectivement pour effet d'alourdir le code. Comme nous voulons utiliser notre déclarations de OnClick, nous devons en hériter :

     DIM DBox AS QDiamondBox

     SUB NewDBoxOnClick

         DBox.InheritOnClick

         ' Placer le code de l'action ici

     END SUB

     DBox.OnClick = NewDBoxOnClick

Comme vous pouvez le voir, si l'on veut hériter de l'événement OnClick, on doit le référencer en utilisant Qobjet.Inherit <NomDeL'événement>, où NomDeL'événement est le nom de l'événement dont on veut hériter. Dans l'exemple précédent, nous pourrions également hériter de OnPaint, mais ça n'aurait aucun intérêt. Si l'événement hérité n'est pas trouvé (ou non déclaré avant), le compilateur vous enverra un message d'erreur.

10.5 Ajouter des composants à un composant

Dans notre exemple, il n'est vraiment pas utile d'inclure un autre composant dans notre composant QdiamondBox. Cependant, comme cette caractéristique est utile dans de nombreux cas, nous allons l'étudier ici. Dans un programme Rapid-Q, il est possible de n'utiliser que des composants standard et aucun composant personnalisé. La méthode pour ajouter ces composants et leurs propriétés a déjà été vue :

     TYPE QFenetreGenerique AS QForm

       Panel AS QPanel

     END TYPE

     DIM GF AS QFenetreGenerique

         GF.Panel.Left = 123

Notez cependant comment on référence un objet dans un objet. Il faut d'abord référencer notre objet Panel, puis ensuite référencer les propriétés et méthodes de Panel. Si vous souhaitez donner des valeurs par défaut à votre composant Panel, utilisez la structure CONSTRUCTOR comme ceci :

     TYPE QFenetreGenerique AS QForm

       Panel AS QPanel

       CONSTRUCTOR

          Panel.Parent = QFenetreGenerique

          Panel.Width = QFenetreGenerique.ClientWidth

          Panel.Height = QFenetreGenerique.ClientHeight

       END CONSTRUCTOR

     END TYPE

Il est à remarquer que, bien qu'il paraisse évident que Panel fait partie de QfenetreGenerique, nous devons tout de même lui assigner une propriété Parent, sinon, QfenetreGenerique ne s'affichera pas. Tout cela est simple, il n'y a pas plus de difficultés pour définir ses événements :

     TYPE QFenetreGenerique AS QForm

       Panel AS QPanel

       EVENT Panel.OnClick

         ShowMessage("L'utilisateur a cliqué sur Panel")

       END EVENT

       EVENT OnClick

         ShowMessage("L'utilisateur a cliqué sur la fenêtre")

       END EVENT

     END TYPE

Notez que si vous ne précisez pas la référence Panel., l'événement OnClick sera attaché à la FenetreGenerale. Comme déjà indiqué plus haut, pour hériter d'événements, vous devrez taper quelque chose du type :

     GF.Panel.OnClick = GF.Panel.InheritOnClick

Dans la majorité des cas, vous n'aurez pas à accéder à des composants intégrés dans d'autres composants. Vous pourrez créer vos propres fenêtres avec de nombreux composants et boutons sans devoir réécrire aucune gestion d'événement.

10.6 Paramétrer un composant vide

Dans certains cas, vous souhaiterez créer votre propre objet sans qu'il vous soit utile d'étendre les propriétés d'un composant existant. Un bon exemple consiste à créer un objet d'interface QiniFile qui fournira les méthodes et propriétés qui vous permettront d'écrire et d'accéder à votre propre fichier.INI. Pour y parvenir, Rapid-Q propose un objet particulier : l'objet vide :

    TYPE QIniFile EXTENDS QObject

       Size AS INTEGER

       FileName AS STRING

       SUB SaveINI

       END SUB

       SUB LoadINI

       END SUB

    END TYPE

Ce type d'objet se comporte comme Qsocket. Ce n'est pas un composant visible, c'est principalement un objet de type interface.

Plus généralement, l'utilisation des Objets permet un code plus élégant et une interface plus claire.

En conclusion, nous avons abordé tout ce qu'il vous fallait savoir concernant l'addition de composants personnalisés dans Rapid-Q. C'est assez facile à comprendre dès que l'on est un peu accoutumé à l'utilisation des composants et objets.

10.7 Propriétés et méthodes Publiques et Privées

Toutes les propriétés et méthodes sont PUBLIC par défaut. Voici comment vous pouvez définir la visibilité de vos propriétés et méthodes :

     TYPE QText EXTENDS QObject

       PUBLIC:

         I AS INTEGER

         X AS INTEGER

       PRIVATE:

         Y AS INTEGER

       PUBLIC:

         SUB Test

            X = Y + 1

         END SUB

     END TYPE

Les propriétés I et X sont PUBLIC, cela s'ignifie qu'elles peuvent être utilisées en dehors de leur structure de création. Il en est de même pour la méthode Test. Par contre, la propriété Y est PRIVATE, vous ne pourrez donc pas l'utiliser en dehors de sa structure (donc en dehors de TYPE). Vous pourrez cependant l'utiliser dans la sub Test puisque cette Sub est incluse dans la zone de visibilité de Y (intérieur de TYPE). Vous pouvez définir des propriétés comme PROTECTED, mais elle réagissent exactement comme des propriétés  et méthodes PUBLIC puisque (pour l'instant) vous ne pouvez pas créer votre propre extension à TYPE. Pour ceux qui n'ont aucune connaissance des langages Objet, la raison d'être des membres PUBLIC ou PRIVATE réside essentiellement dans la sécurité du programmeur. Vous savez ainsi précisément quels membres ne doivent pas être utilisés en dehors de leur zone de visibilité, et vous prévenez les autres utilisateurs de ne pas toucher à ces variables qui n'ont d'utilité qu'à l'intérieur d'une structure.

10.8 Résumé de la création de composants personnalisés

Créer des composants personnalisés se révèle être très utile dans de nombreux cas et relativement facile à mettre en oeuvre. Voici quelques derniers détails que vous devez connaître : La partie la plus contraignante dans ce domaine vient du fait que vous devez hériter d'un événements dès que vous voulez le redéfinir. Cela veut dire que, si vous distribuez votre composant personnalisé à d'autres utilisateurs, ils devront savoir quels événements sont héritables, et lesquels ne le sont pas. Dans ce cas, la meilleure solution consiste à clairement documenter votre portion de programme. Vous pouvez également ajouter des QObjects dans votre composant personnalisé et créer un composant "propre" qui contient déjà d'autres composants.

J'espère que vous prendrez plaisir à créer vos propres composants Rapid-Q !

10.9 Listing source de QDiamondBox

$APPTYPE GUI

$TYPECHECK ON

TYPE QDiamondBox EXTENDS QCanvas     '' You can extend any QObject

  '-- New Properties, you can also add components

  Caption AS STRING

  Checked AS INTEGER

  HiLightColor AS INTEGER

  '-- There are no protected methods, but you should let the user know anyway.

  '-- PROTECTED (meaning you shouldn't directly call it in your program).

  SUB DrawComponent

    IF QDiamondBox.Checked THEN

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,0)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,0)

      QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Paint(QDiamondBox.Height/2, QDiamondBox.Height/2, QDiamondBox.HiLightColor, 0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,&HFFFFFF)

      QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,&HFFFFFF)

    ELSE

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,0)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,QDiamondBox.Height,QDiamondBox.Height/2,0)

      QDiamondBox.Line(QDiamondBox.Height,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,0)

      QDiamondBox.Paint(QDiamondBox.Height/2, QDiamondBox.Height/2, &HBBBBBB, 0)

      QDiamondBox.Line(QDiamondBox.Height/2,0,0,QDiamondBox.Height/2,&HFFFFFF)

      QDiamondBox.Line(0,QDiamondBox.Height/2,QDiamondBox.Height/2,QDiamondBox.Height,&HFFFFFF)

    END IF

    QDiamondBox.TextOut(QDiamondBox.Height + 5, QDiamondBox.Height/2-QDiamondBox.Height/4, QDiamondBox.Caption, 0, -1)

  END SUB

  '-- Inherited Events (sorry, can't create any new events)

  '-- The user can still override these events, but it's not a good idea.

  EVENT OnClick

    IF QDiamondBox.Checked THEN

      QDiamondBox.Checked = 0

    ELSE

      QDiamondBox.Checked = 1

    END IF

    QDiamondBox.DrawComponent

  END EVENT

  EVENT OnPaint

    QDiamondBox.DrawComponent

  END EVENT

  '-- Default values

  CONSTRUCTOR

    Height = 30

    Width = 100

    HiLightColor = &H00FF00

    Caption = "DiamondBox"

    Checked = 0

  END CONSTRUCTOR

END TYPE

'----- Test de notre nouveau composant

DECLARE SUB DBox2Click

DIM Font AS QFont

    Font.Name = "Arial"

    Font.Size = 10

CREATE Form AS QForm

  Center

  Height = 120

  Caption = "Custom Check Boxes"

  CREATE DBox1 AS QDiamondBox

    Caption = "Diamond Box 1"

    Left = 100

    Height = 20

  END CREATE

  CREATE DBox2 AS QDiamondBox

    Caption = "Diamond Box 2"

    Top = 30

    Left = 100

    Height = 20

    Width = 140

    HiLightColor = &H0000FF

    Font = Font

    ShowHint = 1 ' True

    Hint = "Click me"

    OnClick = DBox2Click

  END CREATE

  CREATE DBox3 AS QDiamondBox

    Caption = "Diamond Box 3"

    Top = 60

    Left = 100

    Height = 20

  END CREATE

  ShowModal

END CREATE

SUB DBox2Click

  DBox2.InheritOnClick    '' Inherit event

  ShowMessage("Diamond Box 2 clicked")

END SUB

Chapitre précédent	Sommaire	Chapitre suivant


Pointeurs de fonctions
Documentation de Rapid-Q par William Yu (c)1999

Chapitre 11 - Utiliser les pointeurs de fonctions

11 Utiliser les pointeurs de fonctions

11. Utiliser les pointeurs de fonctions

Bizarre, on n'image pas trouver des pointeurs de fonctions dans un langage BASIC… et pourtant ! Dans Rapid-Q, les pointeurs de fonctions sont un peu différents de ce que l'on a l'habitude de rencontrer. Ils sont même un peu curieux, mais leurs caractéristiques les plus importantes sont bien présentes, comme les pointeurs de fonctions dynamiques ou la redéfinition de pointeurs. Malheureusement, vous ne pourrez pas (pour l'instant) passer un pointeur de fonction comme argument.

11.1 Introduction au concept

Bien que cela risque d'en lasser certains qui connaissent le sujet par cœur, je vais tout de même poser la question : A quoi sert un pointeur de fonction ? A vous aider à comprendre comment les choses sont rangées en mémoire, et comment on y accède. Par exemple, une fonction (SUB ou FUNCTION) occupe un espace mémoire à partir d'une certaine adresse, quelque part dans la zone de programme. Un pointeur pour cette fonction contient juste cette adresse. Donc, si je connais l'adresse de la fonctions, je peux sauter directement vers cette "zone de programme" et exécuter son contenu. Il s'agit là d'un raisonnement de bas niveau : j'empile d'abord le pointeur puis je saute (équivalent d'un CALL) vers la fonction. Donc, si les pointeurs sont uniquement des valeurs d'adresses, comment puis-je trouver l'adresse d'une fonction ? C'est justement le sujet du prochain chapitre.

11.2 Définir des pointeurs de fonctions

 Si vous êtes déjà accoutumé aux pointeurs de fonctions (de C par exemple), il existe, en Rapid-Q, quelques différences auxquelles vous devrez vous habituer. Comme les pointeurs de fonctions ne sont que des valeurs numériques, vous pourrez utiliser tout type de donnée numérique pour définir votre pointeur. Cela peut paraître étrange, mais les pointeurs ne sont que des nombres. Essayez d'éviter le type BYTE car votre adresse a de fortes chances d'être supérieure à 255, je vous suggère plutôt d'adopter les Types INTEGER ou LONG.

    DECLARE SUB Test (I AS INTEGER)

    DIM FPtr AS INTEGER

    BIND FPtr TO Test

Nous utilisons donc BIND pour associer notre variable FPtr à la fonction Test. Deux opérations sont alors effectuées. D'abord FPtr va bien sûr pointer sur l'adresse de l'espace de Test, mais FPtr va recevoir également le nombre de paramètres de la fonction. C'est une information importante pour que le compilateur sache combien de paramètres doivent être passés/acceptés. Pour appeler notre fonction, nous devons utiliser le mot-clé CALLFUNC …

    CALLFUNC(FPtr, 120)

… Qui appelle notre SUB avec 1 paramètre. Bien sûr, ce n'est pas un exemple très utile, voyons donc une version plus interessante…

    DECLARE SUB Test1 (I AS INTEGER)

    DECLARE SUB Test2 (I AS INTEGER)

    DIM FPtr(1 TO 2) AS INTEGER

    BIND FPtr(1) TO Test1

    BIND FPtr(2) TO Test2

Quand vous associez des fonctions dans un tableau de données, notez que la première fonction associée sera le modèle (TEMPLATE) des autres. Pas très clair ? Bon, je simplifie l'explication : notre tableau s'appelle FPtr et notre instruction BIND associe FPtr(1) à la SUB Test1. Notre tableau FPtr est maintenant ASSOCIE, ce qui veut dire que si vous associez tout autre élément du tableau FPtr(i), la fonction doit AVOIR LE MEME NOMBRE DE PARAMETRES. Un exemple peut peut-être nous aider :

    DECLARE SUB Test1 (I AS INTEGER)

    DECLARE SUB Test2 (I AS INTEGER, J AS STRING)

    DIM FPtr(1 TO 2) AS INTEGER

    BIND FPtr(1) TO Test1

    BIND FPtr(2) TO Test2

Le second BIND est incorrect car il ne possède pas le même nombre de paramètres que Test1. Si vous écrivez cela, vous recevrez un message d'erreur. Notez que j'ai indiqué qu'il devait y avoir concordance dans le NOMBRE de paramètre. Vous n'êtes théoriquement pas obligé de faire concorder les TYPEs de paramètres, mais il n'est pas conseillé de le faire car, dans ce cas, les résultats peuvent varier.

11.3 Utiliser correctement les pointeurs de fonctions

 Quand vous vous serez accoutumé aux pointeurs de fonctions, vous vous appercevrez qu'ils sont nécessaires dans certains cas, et inutiles dans d'autres. Chaque situation est différente, mais étudions celle-ci :

     SELECT CASE I

       CASE 1

         Process1("1", 44)

       CASE 2

         Process2("2", 55)

       CASE 3

         Process3("3", 66)

       CASE 4

         :

         :

      etc...

Vous pouvez utiliser ce type de structure dans de nombreux cas, par exemple pour gérer les options d'un menu ou, peut-être, d'un analyseur syntaxique (Rapid-Q utilise cette méthode et les pointeurs de fonctions pour analyser votre code). Il peut y avoir ainsi un nombre important de comparaisons, particulièrement si votre analyseur doit tester un nombre important de mots-clé (plus de 50). Les pointeurs de fonctions nous permettent d'éliminer facilement ces comparaisons, et d'augmenter d'autant la vitesse de notre programme. Etudiez pour cela FUNCPTR.BAS comme un exemple concret.

     BIND FPtr(1) AS Process1

     BIND FPtr(2) AS Process2

     BIND FPtr(3) AS Process3

     BIND FPtr(4) AS Process4

     BIND FPtr(5) AS Process5

     BIND FPtr(6) AS Process6

     BIND FPtr(7) AS Process7

     x = VAL(INPUT$(1))

     CALLFUNC(FPtr(x), 33)

Ce code n'est pas utilisable tel quel, mais il vous permettra de comprendre l'idée générale. Vous n'avez donc plus besoin d'aucune comparaison si vous avez pris soin, au préalable, de créer soigneusement vos pointeurs de fonctions.

11.4 Ce que Rapid-Q ne propose pas

Utiliser des pointeurs de fonctions comme arguments n'est pas possible dans Rapid-Q. C'est pourtant très utile, mais je n'ai pas pu l'intégrer pour l'instant. En fait, vous pouvez passer un pointeur de fonction comme argument, mais vous pourrez jamais appeler votre fonction. Le seul remède serait de définir un pointeur de fonction global comme modèle et de l'assigner à votre argument. C'est plus facile à comprendre avec un exemple :

     DECLARE FUNCTION MyFuncTemp (X AS LONG) AS LONG

     DECLARE FUNCTION Func1 (X AS LONG) AS LONG

     DECLARE FUNCTION Func2 (X AS LONG) AS LONG

     DIM Template AS INTEGER

     DIM I(100) AS INTEGER

     BIND Template TO MyFuncTemp

     BIND I(1) TO Func1

     BIND I(2) TO Func2

     SUB Test (FPtr AS INTEGER)

        Template = FPtr

        PRINT CALLFUNC(Template, 10)

     END SUB

     Test I(1)

C'est à peu prés le seul moyen de contourner cette limitation.

Chapitre précédent	Sommaire	Chapitre suivant


Appendice QBITMAP
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QBITMAP

Composant QBITMAP

Qbitmap est un composant non visible, utilisé pour créer, lire, enregistrer des images .BMP

> Propriétés de QBITMAP

Nom	Type	L/E	Par Défaut
BMP	STRING	E
BMPHandle	RESOURCE	E
Empty	INTEGER	L
Font	QFONT	E
Handle	INTEGER	L
Height	INTEGER	L/E
Monochrome	INTEGER	L/E
Pixel	2D TABLEAU D' INTEGER	L/E
Transparent	INTEGER	L/E	Faux
TransparentColor	INTEGER	L/E
TransparentMode	INTEGER	L/E	0
Width	INTEGER	L/E

> Méthodes de QBITMAP

Méthode	Type	Description	Param.
Circle	SUB (x1%, y1%, x2%, y2%, c%, fill%)	Trace et colore un cercle	6
Draw	SUB (x%, y%, BMP)	Affiche une image BitMap sur Canvas	3
FillRect	SUB (x1%, y1%, x2%, y2%, c%)	Trace et colore un rectangle	5
Line	SUB (x1%, y1%, x2%, y2%, c%)	Trace une ligne	5
LoadFromFile	SUB (FileName$)	Lit un fichier .BMP	1
LoadFromStream	SUB (Stream)	Lit une image BMP depuis la file de données	1
Paint	SUB (x%, y%, c%, borderc%)	Colore une zone	4
Pset	SUB (x%, y%, c%)	Affiche un point graphique	3
Rectangle	SUB (x1%, y1%, x2%, y2%, c%)	Trace un rectangle	5
SaveToFile	SUB (FileName$)	Enregistre une image dans un fichier	1
SaveToStream	SUB (Stream)	Enreg. une image dans une file de données	1
TextOut	SUB (x%, y%, S$, fc%, bc%)	Affiche un texte graphique	5

Exemple de QBITMAP

DIM BitMap AS QBitMap

BitMap.BMP = "close.bmp"

CREATE Form AS QForm

  CREATE Image1 AS QImage

    Left = 100

    Draw 5, 5, BitMap.BMP

  END CREATE

  Center

  ShowModal

END CREATE

Sommaire	Annexes	Composant suivant


Annexe QBUTTON
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QBUTTON

Composant QBUTTON

Qbutton est un bouton de contrôle à usage général.

> Propriétés de QBUTTON

Composant	Type	L/E	Par défaut
BMP	STRING	E
BMPHandle	RESOURCE	E
Cancel	INTEGER	L/E	Faux
Caption	STRING	L/E
Cursor	INTEGER	L/E	crDefault
Default	INTEGER	L/E	Faux
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Handle	INTEGER	R
Height	INTEGER	L/E
Hint	STRING	L/E
Kind	INTEGER	L/E	bkCustom
Layout	INTEGER	L/E	blBMPLeft
Left	INTEGER	L/E	0
ModalResult	INTEGER	L/E	mrNone
NumBMPs	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
Spacing	INTEGER	L/E
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai
> Méthodes de QBUTTON

Methode	Type	Description	Params
StartDrag	SUB	Autorise le bouton à être déplacé	0
> Evénements QBUTTON

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur a cliqué sur le bouton	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	La bouton de la souris est relâché	4
WndProc	SUB (Hwnd%, Msg%, wParam%, lParam%)	Messages envoyés au bouton	4
> Exemple de QBUTTON

  '-- A drag button

  DIM Form AS QForm

  DIM Button AS QButton

  SUB MouseDown

      Button.StartDrag

      SHOWMESSAGE STR$(Button.Left)+", "+STR$(Button.Top)

  END SUB

  Button.Parent = Form

  Button.OnMouseDown = MouseDown

  Form.ShowModal

Composant précédent	Sommaire	Annexes	Composant suivant


Annexe QCANVAS
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QCANVAS

Composant QCANVAS

Qcanvas est une image vide destinée à recevoir des commandes graphiques. Au lieu d'y charger une image, vous devez créer vous-même votre propre dessin

> Propriétés de QCANVAS

Propriétés	Type	L/E	Par défaut
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	True
Font	QFONT	L
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	L
Pixel	2D ARRAY of INTEGER	L/E
PopupMenu	QPOPUPMENU	L
ShowHint	INTEGER	L/E	False
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	True

> Méthodes de QCANVAS

Méthode	Type	Description	Params
Circle	SUB (x1%, y1%, x2%, y2%, c%, fill%)	Dessine et peint un cercle	6
Draw	SUB (x%, y%, BMP)	Affiche une image	3
FillRect	SUB (x1%, y1%, x2%, y2%, c%)	Dessine et peint un rectangle	5
Line	SUB (x1%, y1%, x2%, y2%, c%)	Dessine une ligne	5
Paint	SUB (x%, y%, c%, borderc%)	Peint une zone	4
Pset	SUB (x%, y%, c%)	Affiche un point	3
Rectangle	SUB (x1%, y1%, x2%, y2%, c%)	Dessine un rectangle	5
TextOut	SUB (x%, y%, S$, fc%, bc%)	Affiche un texte	5

> Evénements de QCANVAS

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur la feuille	0
OnDblClick	VOID	L'utilisateur double-clique sur le feuille	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est appuyé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris bouge	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4
OnPaint	VOID	Reçoit le message WM_PAINT	0

> Exemple de QCANVAS

'  Pixel by pixel credit scroller for Rapid-Q by William Yu

DIM Canvas AS QCanvas

DIM Form AS QForm

DIM Timer1 AS QTimer

DIM Font AS QFont

DIM Y AS INTEGER

    Y = -20

SUB Resize

  Canvas.Height = Form.ClientHeight

  Canvas.Width = Form.ClientWidth

END SUB

SUB Paint

  Canvas.Textout (65,Y-30,"Beware the power of Rapid-Q!", &H00FF00, 0)

  Canvas.Textout (30,Y,"Credit Scroller written in Rapid-Q by William Yu", &HFFFFFF, 0)

END SUB

SUB TimerOver

  Timer1.Interval = 1  '' Can't go any lower!

  Y = Y + 1            '' Pixel by pixel!

  Paint

END SUB

Form.Width = 400

Form.Height = 200

Form.Center

Form.Color = 0

Font.Name = "Arial"

Font.Size = 12

Font.Color = &H00FF00

Canvas.Parent = Form

Canvas.Font = Font

Canvas.Color = 0

Canvas.OnPaint = Paint

Timer1.Interval = 1

Timer1.OnTimer = TimerOver

Form.Onresize = Resize

Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Annexe QCHECKBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QCHECKBOX

Composant QCHECKBOX

QCheckbox est l'outil générique pour gérer les cases à cocher

> Les propriétés de QCHECKBOX

Propriété	Type	L/E	Par défaut
Checked	INTEGER	L/E	Faux
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Les événements de QCHECKBOX

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur la case à cocher	0

> Exemple de QCHECKBOX

  DIM Form AS QForm

  DIM Checkbox as QCheckBox

  SUB Check

    IF CheckBox.Checked THEN

       SHOWMESSAGE "Checked!"

    END IF

  END SUB

  CheckBox.Parent = Form

  CheckBox.OnClick = Check

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Annexe QCOMBOBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QCOMBOBOX

Composant QCOMBOBOX

QCombobox permet de créer une zone de liste déroulante. Le premier élément porte le numéro 0, le second, 1, etc…

> Propriétés de QCombobox

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
DropDownCount	INTEGER	L/E	8
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Hint	STRING	L/E
Item	ARRAY of STRING	L/E
ItemCount	INTEGER	R
ItemIndex	INTEGER	L/E	-1
Left	INTEGER	L/E	0
MaxLength	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
Sorted	INTEGER	L/E	Faux
Style	INTEGER	L/E	csDropDown
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Méthodes de QCombobox

Méthode	Type	Description	Params
AddItems	SUBI	Ajoute un élément à la liste	STRINGs, Infinite
Clear	SUB	Efface tous les éléments de la liste	0
DelItems	SUBI	Supprime des éléments par leurs index	Index #s, Infinite

> Evénements de QCombobox

Evénement	Type	Se produit quand…	Params
OnChange	VOID	L'utilisateur sélectionne au élément différent	0
> Exemple de QCombobox

  DIM Form AS QForm

  DIM ComboBox AS QComboBox

  SUB ItemChanged

    PRINT ComboBox.Item(ItemIndex)

  END SUB

  ComboBox.Parent = Form

  ComboBox.OnChange = ItemChanged

  ComboBox.AddItems "1. Apples", "2. Oranges", "3. Bananas"

  Form.ShowModal

Composant Précédent	Annexes	Sommaire	Composant Suivant


Annexe QCOOLBTN
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QCOOLBTN

Composant QCOOLBTN

QCoolbtn est une extension de Qbutton qui permet des variantes de présentation comme le bouton à bascule (via GroupIndex).

> Propriétés de QCoolbtn

Propriété	Type	L/E	Par défaut
AllowAllUp	INTEGER	L/E	Faux
BMP	STRING	E
BMPHandle	RESOURCE	E
Caption	STRING	L/E
Cursor	INTEGER	L/E	crDefault
Down	INTEGER	L/E	Faux
Enabled	INTEGER	L/E	Vrai
Flat	INTEGER	L/E	Faux
Font	QFONT	E
GroupIndex	INTEGER	L/E	0
Height	INTEGER	L/E
Hint	STRING	L/E
Layout	INTEGER	L/E	blBMPLeft
Left	INTEGER	L/E	0
NumBMPs	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
ShowHint	INTEGER	L/E	Faux
Spacing	INTEGER	L/E
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes QCoolbtn

Méthode	Type	Description	Params
StartDrag	SUB	Permet au bouton d'être déplacé	0

> Evénements QCoolbtn

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur le bouton	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4

> Exemple QCoolbtn

  '-- An example of toggle buttons (via GroupIndex)

  CONST Faux = 0: CONST Vrai = 1

  DIM Form AS QForm

  DIM Cool1 AS QCoolbtn

  DIM Cool2 AS QCoolbtn

  Cool1.Parent = Form

  Cool1.GroupIndex = 1       '' Must be > 0

  Cool1.Down = Vrai          '' Button initially down

  Cool2.Parent = Form

  Cool2.GroupIndex = 1       '' Same group as Cool1

  Cool2.Left = 40

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Annexe QDIRTREE
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QDIRTREE

Composant QDIRTREE

QDirTree est un composant spécialisé qui propose à l'utilisateur des fonctions tirées de l'explorateur Windows du type Liste de Répertoire. Ce composant est gourmand en ressources, utilisez-le avec parcimonie. Vous ne devez normalement n'en utiliser qu'un dans votre programme.

> Propriétés QDirTree

Propriété	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Directory	STRING	L/E	Faux
Enabled	INTEGER	L/E	Vrai
FastLoad	INTEGER	L/E	Faux
Font	QFONT	E
Height	INTEGER	L/E
HideSelection	INTEGER	L/E	Faux
Hint	STRING	L/E
InitialDir	STRING	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ReadOnly	INTEGER	L/E	Faux
ReadOnStart	INTEGER	L/E	Faux
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai
> Méthodes QdirTree

Méthode	Type	Description	Params
FullCollapse	SUB	Réduit l'affichage d'un répertoire	0
FullExpand	SUB	Etend l'affichage d'un répertoire (lentement!)	0
Reload	SUB	Lit à nouveau le répertoire	0

> Evénements QdirTree

Evénement	Type	Se produit quand…	Params
OnChange	VOID	Le répertoire courant change	0

> Exemple QDirTree

'' A Directory Tree like Windows Explorer.

'' QDIRTREE Component courtesy of Markus Stephany.

'' I took out removable drives because it doesn't work properly.

'' So you won't be able to view your floppy disk drives.  CD-ROM drives

'' are fine, as far as I know...

$TYPECHECK ON

DECLARE SUB ChangeDirectory

CREATE Form AS QForm

  Caption = "Directory Tree"

  Center

  CREATE DirTree AS QDirTree

    InitialDir = CURDIR$

    Width = Form.ClientWidth

    Height = Form.ClientHeight

    OnChange = ChangeDirectory

  END CREATE

  ShowModal

END CREATE

SUB ChangeDirectory

  ShowMessage DirTree.Directory

END SUB

Composant précédent	Annexes	Sommaire	Composant suivant


Annexe QDXIMAGELIST
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QDXIMAGELIST

Composant QDXIMAGELIST

QDXImageList contient une liste d'images utilisées par votre programme. Vous devez utiliser Image Library pour créer cette liste.

> Propriétés QDXImageList

Propriété	Type	L/E	Par défaut
Parent	QDXSCREEN	E
> Méthodes QDXImageList

Méthode	Type	Description	Params
Draw	SUB (Item%, X%, Y%, Mask%)	Affiche une image à l'écran	4
LoadFromFile	SUB (FileName$)	Lit la liste d'images	1

Exemple QDXImageList

Voir l'exemple DIRECTX.BAS

Composant précédent	Annexes	Sommaire	Composant suivant


Annexe QDXSCREEN
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QDXSCREEN

Composant QDXSCREEN

QDXScreen vous permet de créer un écran DirectX pour tous vos composants DX. Toutes les opérations sont effectuées dans un buffer et ne sont affichées que quand vous transférez ce buffer à l'écran. Pour utiliser le mode Plein Ecran, paramétrez FullScreen comme Vrai et assurez-vous que votre BorderStyle soit à bsNone.

> Propriétés QDXScreen

Propriété	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
AutoSize	INTEGER	L/E	Vrai
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
FullScreen	INTEGER	L/E	Faux
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
Pixel	2D ARRAY of INTEGER	L/E
ShowHint	INTEGER	L/E	Faux
Top	INTEGER	L/E
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Méthodes QDXScreen

Méthode	Type	Description	Params
Circle	SUB (x1%, y1%, x2%, y2%, c%, fill%)	Dessine et colore un cercle	6
Draw	SUB (x%, y%, BMP)	Affiche une image à X, Y	3
Fill	SUB (DevCol%)	Colore l'écran avec un couleur personnalisée	1
FillRect	SUB (x1%, y1%, x2%, y2%, c%)	Dessine et colore un rectangle	5
Flip	SUB	Copie le contenu d'un buffer vers l'écran	0
Init	SUB (Width%, Height%)	Crée un écran	2
Line	SUB (x1%, y1%, x2%, y2%, c%)	Dessine une ligne	5
Paint	SUB (x%, y%, c%, borderc%)	Colore une zone	4
Pset	SUB (x%, y%, c%)	Affiche un point	3
Rectangle	SUB (x1%, y1%, x2%, y2%, c%)	Dessine un rectangle	5
TextOut	SUB (x%, y%, S$, fc%, bc%)	Ecrit du texte	5
> Evénements QDXScreen

Evénement	Type	Se produit quand…	Params
OnClick	VOID	Le bouton de la souris est cliqué	0
OnDblClick	VOID	Le bouton de la souris est double-cliqué	0
OnMouseDown	SUB (Button%, X%, Y%)	Le bouton de la souris est pressé	3
OnMouseMove	SUB (X%, Y%)	La souris se déplace	2
OnMouseUp	SUB (Button%, X%, Y%)	Le bouton de la souris est relâché	3

> Exemple QDXScreen

$APPTYPE GUI

$TYPECHECK ON

$INCLUDE "RAPIDQ.INC"

DIM Form AS QForm

    Form.ClientHeight = 480

    Form.ClientWidth = 640

DIM Screen AS QDXScreen

Screen.Parent = Form

Screen.Init(640, 480)

Screen.Align = alClient

Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QDXTIMER
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QDXTIMER

Composant QDXTIMER

QDXTimer est un chronomètre de haute précision pour DirectX.

> Propriétés QDXTimer

Propriété	Type	L/E	Par défaut
Enabled	INTEGER	L/E	Faux
FrameRate	INTEGER	L
Interval	INTEGER	L/E

> Evénement QDXTimer

Evénement	Type	Se produit quand…	Params
OnTimer	VOID	Le temps a expiré	0

> Exemple QDXTimer

Voir exemple DIRECTX.BAS

Composant précédent	Annexes	Sommaire


Comosant QEDIT
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QEDIT

Composant QEDIT

QEdit est un contrôle qui permet d'éditer une simple ligne. Il est souvent utilisé pour l'entrée d'une information par l'utilisateur

> Propriétés QEdit

Propriété	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Handle	INTEGER	L
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
MaxLength	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
Text	STRING	L/E
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Evénements QEdit

Evénement	Type	Se produit quand…	Params
OnChange	VOID	Le texte change	0
OnKeyDown	SUB (Key AS WORD, Shift AS INTEGER)	Une touche est pressée	2
OnKeyPress	SUB (Key AS BYTE)	Une touche est pressée	1
WndProc	SUB (Hwnd%, Msg%, wParam%, lParam%)	Message envoyé à QEdit	4
> Exemple QEdit

  DIM Form AS QForm

  DIM Edit1 AS QEdit

  Edit1.Parent = Form

  Edit1.Text = "Hello"   '' Set as default text

  Form.ShowModal

Composant précédent	Annexes	Sommaire	 	Composant suivant


Composant QFILILISTBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QFILELISTBOX

Composant QFILELISTBOX

QFileListBox vous permet de créer une boîte de liste avec tous les fichiers d'un répertoire, il peut également afficher une liste de répertoires.

> Propriétés de QFileListBox

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Directory	STRING	L/E
Drive	STRING	L/E
Enabled	INTEGER	L/E	Vrai
ExtendedSelect	INTEGER	L/E	Vrai
Filename	STRING	L/E
Font	QFONT	E
Height	INTEGER	L/E
Hint	STRING	L/E
Item	ARRAY of STRING	L/E
ItemCount	INTEGER	L/E
ItemHeight	INTEGER	L/E
ItemIndex	INTEGER	L/E
Left	INTEGER	L/E	0
Mask	STRING	L/E	*.*
MultiSelect	INTEGER	L/E	Faux
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Selected	ARRAY of INTEGER	L/E
ShowHint	INTEGER	L/E	Faux
ShowIcons	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
TopIndex	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QFileListBox

Méthodes	Type	Description	Paramètres
AddFileTypes	SUBI	Ajoute certains types de fichiers à la liste	INTEGER, Infinite
DelFileTypes	SUBI	Supprime certains types de fichiers à la liste	INTEGER, Infinite

> Evénements QFileListBox

Evénement	Type	Se produit quand…	Params
OnChange	VOID	Le répertoire change	0
OnClick	VOID	Un fichier a été cliqué	0
OnDblClick	VOID	Une sélection a été double-cliquée	0

> Exemple de QFileListBox

'' Simple Application Launcher

'' How to use the File List Box as a Directory List Box in Rapid-Q by William Yu

$INCLUDE "RAPIDQ.INC"

DECLARE SUB ChangeDirectories

DECLARE SUB ExecuteApplication

DECLARE SUB ResizeForm

CREATE Form AS QForm

  Height = 300

  Width = 450

  CREATE DirList AS QFileListBox     '' Can double as a Directory list box

   ShowIcons = True

   Mask = "*.*"

   AddFileType(ftDirectory)          '' Add Directories

   DelFileType(ftNormal)             '' Remove files (see RAPIDQ.INC for values)

   OnDblClick = ChangeDirectories

   Height = Form.ClientHeight

   Width = 200

  END CREATE

  CREATE EXEList AS QFileListBox

   ShowIcons = True

   Mask = "*.EXE"

   OnDblClick = ExecuteApplication

   Left = 215

   Height = Form.ClientHeight

   Width = 225

  END CREATE

  Center

  Caption = DirList.Directory

  OnResize = ResizeForm

  ShowModal

END CREATE

SUB ChangeDirectories

  ChDir(DirList.Item(DirList.ItemIndex) - "[" - "]")

  DirList.Directory = CurDir$:  EXEList.Directory = CurDir$

  Form.Caption = CurDir$

END SUB

SUB ExecuteApplication

  RUN EXEList.FileName    ' Non-Blocking

'  SHELL EXEList.FileName  ' Blocks, until program terminates

                           ' Becareful running 16-bit applications

END SUB

SUB ResizeForm

  DirList.Height = Form.ClientHeight

  EXEList.Height = Form.ClientHeight

  EXEList.Width = Form.ClientWidth - 215

END SUB

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QFILESTREAM
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QFILESTREAM

Composant QFILESTREAM

QFilestream est le moyen de gérer les fichiers de données en Rapid-Q. C'est une méthode plus élégante que les traditionnels GET et PUT des autres BASICs

> Propriétés de QFilestream

Propriété	Type	L/E	Par défaut
Position	INTEGER	L/E
Size	INTEGER	L

> Méthodes de QFilestream

Méthode	Type	Description	Params
Close	SUB	Ferme la file	0
CopyFrom	SUB (Stream, Bytes%)	Copie à partir d'une autre file,  QFileStream ou QMemoryStreamIf. Si Bytes%=0, la file entière est copiée	2
Open	SUB (FileName$, Method%)	Ouvre un fichier. Pour Method%, voir RAPIDQ.INC	2
ReadNum	FUNCTION (Size%)	Lit un nombre Size% d'octets, retourne un nombre	1
ReadStr	FUNCTION (Size%)	Lit un nombre Size% d'octets, retourne une chaîne de caractères	1
Seek	SUB (Position%, From%)	Recherche jusqu'à Position%, depuis From%.  Voir RAPIDQ.INC	2
WriteNum	SUB (number, bytes%)	Ecrit un nombre dans le fichier	2
WriteStr	SUB (string, bytes%)	Ecrit une chaîne de caractères dans le fichier	2

> Exemple de QFileStream

  $INCLUDE "RAPIDQ.INC"

  DIM File AS QFileStream

  File.Open("test.bas", fmOpenRead)

  File.ReadStr(S$, File.Size)         '' Read entire file

  PRINT S$                            '' print it

  File.Close

Composant Précédent	Annexes	Sommaire	Composant suivant


Composant QFONT
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QFONT

Composant QFONT

QFont est un composant utilisé pour spécifier la police, la couleur et la taille de votre texte. Il n'est pas destiné à être utilisé seul, et n'aura un effet que si vous affectez ce composant à un autre composant qui l'utilisera.

> Propriétés de QFont

Propriété	Type	L/E	Par défaut
Color	INTEGER	L/E
FontCount	INTEGER	L
FontName	ARRAY of STRING	L
Name	STRING	L/E
Size	INTEGER	L/E

> Méthodes de QFont

Méthode	Type	Description	Paramètres
AddStyles	SUBI	Ajoute des styles (Gras, Itallique, etc…)	INTEGER, Infinite
DelStyles	SUBI	Supprime des styles	INTEGER, Infinite
> Exemples QFont

  $INCLUDE "RAPIDQ.INC"

  DIM Font AS QFONT

  DIM Label AS QLABEL

  Font.Name = "Arial"

  Font.AddStyles(fsBold, fsItalic)

  Label.Font = Font      '' Assign font values

Composant précédent	Annexes	Sommaire 	Composant suivant


Composant QFORM
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QFORM

Composant QFORM

QForm est une fenetre standard de Windows. Vous pouvez y placer tous types de composants visibles comme QEdit, QLabel, QButton, etc...

> Propriétés QForm

Propriété	Type	L/E	Par défaut
AutoScroll	INTEGER	L/E	Vrai
Affiche automatiquement des ascenceurs si la fenêtre n'est pas assez grande pour contenir tous les contrôles.

BorderStyle	INTEGER	L/E	bsSizeable
Change le style de bordure de votre fenêtre. Voir RAPIDQ.INC pour toutes les constantes

Caption	STRING	L/E
ClientHeight	INTEGER	L/E
ClientWidth	INTEGER	L/E
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
FormStyle	INTEGER	L/E	fsNormal
Handle	INTEGER	L
Height	INTEGER	L/E
Hint	STRING	L/E
IcoHandle	RESOURCE	E
Icon	STRING	E
Assigne un nom de fichier à l'icone par défaut de votre fenêtre

Left	INTEGER	L/E	0
ModalResult	INTEGER	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Faux
Width	INTEGER	L/E
WindowState	INTEGER	L/E	wsNormal
> Méthodes de QForm

Méthodes	Type	Description	Paramètres
AddBorderIcons	SUBI	Ajoute des icones	INTEGER, Infinite
Center	SUB	Centre la fenêtre	0
Close	SUB	Ferme la fenêtre	0
DelBorderIcons	SUBI	Supprime des icones	INTEGER, Infinite
HideTitleBar	SUB	Efface la barre de titre	0
Line	SUB (x1%, y1%, x2%, y2%, c%)	Trace une ligne sur la fenêtre	5
Repaint	SUB	Redessine la fenêtre	0
Show	SUB	Affiche une fenêtre qui a été cachée	0
ShowModal	FUNCTION	Affiche une fenêtre et attend une action	0
ShowTitleBar	SUB	Affiche la barre de titre	0
TextOut	SUB (x%, y%, s$, fc%, bc%)	Ecrit du texte dans la fenêtre	5

> Evénements de QForm

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur une surface libre	0
OnClose	SUB (Action AS INTEGER)	La fenêtre est fermée	1
OnKeyDown	SUB (Key AS Word, Shift AS INTEGER)	L'utilisateur tape une touche	2
OnKeyPress	SUB (Key AS BYTE)	L'utilisateur tape une touche	1
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4
OnPaint	VOID	La fenêtre doit être redessinée	0
OnResize	VOID	La fenêtre est redimensionnée	0
OnShow	VOID	La fenêtre est affichée	0
WndProc	SUB (Hwnd%, Msg%, wParam%, lParam%)	Un message est envoyé à la fenêtre	4
Un seul WndProc est autorisé par fenêtre. Si vous avez plusieurs fenêtres, un message ne peut être envoyé qu'à une seule à la fois. (Cette caractéristique sera modifiée dans le futur)

> Exemple de QForm

  DIM Form AS QForm

  DIM Button AS QBUTTON

  Button.Parent = Form     '' Add button to form container

  Form.Center

  Form.Caption = "Hello world!"

  IF Form.ShowModal THEN

    PRINT "Return result is TRUE"

  ELSE

    PRINT "Return result is FALSE"

  END IF

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QGAUGE
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QGAUGE

Composant QGAUGE

QGauge est une barre de progression sophistiquée. Elle permet à l'utilisateur de visualiser la progression d'une opération.

> Propriétés de QGauge

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BackColor	INTEGER	L/E
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
ForeColor	INTEGER	L/E
Hint	STRING	L/E
Height	INTEGER	L/E
Kind	INTEGER	L/E	gkHorizontalBar
Left	INTEGER	L/E
Max	INTEGER	L/E	100
Min	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
Position	INTEGER	L/E	0
ShowText	INTEGER	L/E	Vrai
Top	INTEGER	L/E
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Exemple de QGauge

$INCLUDE "RAPIDQ.INC"

CREATE Form AS QForm

  Center

  CREATE Gauge AS QGauge

    Position = 20

    Kind = gkPie

  END CREATE

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QGROUPBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QGROUPBOX

Composant QGROUPBOX

QGroupBox permet de créer une zone de groupe

> Propriétés de QGroupBox

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Caption	STRING	L/E
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Handle	INTEGER	L
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Méthodes de QGroupBox

Méthode	Type	Description	Params
Repaint	SUB	Redessine la zone et tout ce qu'elle contient	0

> Evénements de QGroupBox

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur le groupe	0
OnDblClick	VOID	L'utilisateur double-clique sur le groupe	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4

> Exemple de QGroupBox

CREATE Fenetre AS QForm

  CREATE GroupBox AS QGroupBox

    Caption = " Group Box "

    Left = 100

    CREATE Button AS QButton

      Caption = "Button"

    END CREATE

  END CREATE

  Center

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QIMAGE
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QIMAGE

Composant QIMAGE

QImage Est utilisé pour afficher des images (BMP/ICON). Il peut aussi servir à dessiner des graphiques de base.

> Propriétés de QImage

Propriété	Type	L/E	Par défaut
Autosize	INTEGER	L/E	Faux
BMP	STRING	E
BMPHandle	RESOURCE	E
Center	INTEGER	L/E	Faux
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
ICOHandle	RESOURCE	E
Icon	STRING	E
IncrementalDisplay	INTEGER	L/E	Faux
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
Pixel	2D ARRAY of INTEGER	L/E
PopupMenu	QPOPUPMENU	E
Stretch	INTEGER	L/E	Faux
Top	INTEGER	L/E	0
Transparent	INTEGER	L/E	Faux
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QImage

Méthodes	Type	Description	Params
Center	SUB	Centre l'image	0
Circle	SUB (x1%, y1%, x2%, y2%, c%, fill%)	Dessine et colore un cercle	6
Draw	SUB (x%, y%, BMP)	Affiche l'image en X, Y	3
FillRect	SUB (x1%, y1%, x2%, y2%, c%)	Dessine et colore un rectangle	5
Line	SUB (x1%, y1%, x2%, y2%, c%)	Dessine une ligne	5
Paint	SUB (x%, y%, c%, borderc%)	Colore une zone	4
Pset	SUB (x%, y%, c%)	Affiche un point	3
Rectangle	SUB (x1%, y1%, x2%, y2%, c%)	Dessine un rectangle	5
TextOut	SUB (x%, y%, S$, fc%, bc%)	Ecrit un texte	5

> Evénements de QImage

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique dur l'image	0
OnDblClick	VOID	L'utilisateur double-clique sur l'image	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4
> Exemple de QImage

  '-- How to use a resource file

  CONST False = 0

  CONST True = 1

  $RESOURCE RES_BMP1 AS "C:\WINDOWS\CLOUDS.BMP"

  DIM Form AS QForm

  DIM Image AS QImage

  Image.Parent = Form

  Image.Autosize = True

  Image.BMPHandle = RES_BMP1

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QIMAGELIST
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QIMAGELIST

Composant QIMAGELIST

QImageList est un tableau d'images qui ont toutes les mêmes dimensions

> Propriétés de QimageList

Propriétés	Type	L/E	Par défaut
BkColor	INTEGER	L/E	0
BlendColor	INTEGER	L/E	0
Count	INTEGER	L/E
DrawStyle	INTEGER	L/E	dsNormal
Font	QFONT	E
GetBMP	Tableau d' IMAGES/BMP	L
GetICO	Tableau d' IMAGES/ICO	L
Height	INTEGER	L/E
ImageType	INTEGER	L/E	itImage
Masked	INTEGER	L/E	Vrai
ShareImages	INTEGER	L/E	Faux
Width	INTEGER	L/E

> Méthodes de QImageList

Méthodes	Type	Description	Params
AddBMPFile	SUB (FileName$, MaskColor%)	Ajoute un fichier BMP à Imagelist	2
AddICOFile	SUB (FileName$)	Ajoute un fichier Icône à Imagelist	1
AddBMPHandle	SUB (BMP_Resource, MaskColor%)	Ajoute un titre BMP à Imagelist	2
AddICOHandle	SUB (ICO_Resource)	Ajoute un titre ICO à Imagelist	1
Clear	SUB	Supprime toutes les images	0
Delete	SUB (Index%)	Supprime l'image à l'index Index%	1
InsertBMPFile	SUB (Index%, Filename$, Mask%)	Place un fichier BMP à l'index Index%	3
InsertICOFile	SUB (Index%, Filename$)	Place un fichier Icône à l'index Index%	2
InsertBMPHandle	SUB (Index%, BMP_Resource, Mask%)	Place un titre BMP à l'index Index%	3
InsertICOHandle	SUB (Index%, ICO_Resource)	Place un titre Icône à l'index Index%	2

> Exemple de QImageList

' Imagelist demo

$resource bmp_handle as "nolight.bmp"

$resource ico_handle as "close.ico"

DIM ImageList AS QImageList

DIM Form AS QForm

DIM Button AS QButton

ImageList.Width = 9

ImageList.Height = 17

ImageList.AddBMPHandle bmp_handle,0

'ImageList.AddBMPFile "nolight.bmp", 0

ImageList.AddICOHandle ico_handle

'ImageList.AddICOFile "close.ico"

Button.Parent = Form

Button.BMP = Imagelist.GetBMP(0)

Form.Icon = ImageList.GetICO(1)

Form.Showmodal

Composant précedent	Annexes	Sommaire	Composant suivant


Composant QLABEL
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QLABEL

Composant QLABEL

QLabel est un composant destiné à afficher du texte dans une fenêtre.

> Propriétés de QLabel

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Alignment	INTEGER	L/E	taLeftJustify
Autosize	INTEGER	L/E	Faux
Caption	STRING	L/E
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Handle	INTEGER	L
Height	INTEGER	L/E
Hint	STRING	L/E
Layout	INTEGER	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
Top	INTEGER	L/E	0
Transparent	INTEGER	L/E	Faux
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E
Wordwrap	INTEGER	L/E	Faux

> Evénements de QLabel

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur le Label	0
OnDblClick	VOID	L'utilisateur double-clique sur le Label	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste pressé	3
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	2
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relaché	3
WndProc	SUB (Hwnd%, Msg%, wParam%, lParam%)	Des messages sont envoyés à QLabel	4
> Exemple de QLabel

  DIM Form AS QForm

  DIM Label1 AS QLabel

  Label1.Parent = Form

  Label1.Text = "Hello"

  Form.ShowModal

Composant précedent	Annexes	Sommaire	Composant suivant


Composant QLISTBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QLISTBOX

Composant QLISTBOX

QListbox propose une boîte de liste générique à déplacement vertical. Le premier élément de toute ListBox porte le No. 0, le second, le No. 1, etc…

> Propriétés de QListbox

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Columns	INTEGER	L/E	0
Enabled	INTEGER	L/E	Vrai
ExtendedSelect	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Item	ARRAY of STRING	L/E
ItemCount	INTEGER	L
ItemHeight	INTEGER	L/E
ItemIndex	INTEGER	L/E	-1
Left	INTEGER	L/E	0
MultiSelect	INTEGER	L/E	Faux
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Selected	ARRAY of INTEGER	L/E
Sorted	INTEGER	L/E	Faux
TopIndex	INTEGER	L/E
TabOrder	INTEGER	L/E
TabWidth	INTEGER	L/E	0
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Méthodes de QListbox

Méthodes	Type	Description	Paramètres
AddItems	SUBI	Ajoute un élément à la liste	STRINGs, Infinite
Clear	SUB	Efface tous les éléments	0
DelItems	SUBI	Efface un élément par son index	Index #s, Infinite
InsertItem	SUB (Index%, String$)	Insère un élément par son index	2

> Evénements de QListbox

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur l'élément	0
OnDblClick	VOID	L'utilisateur double-clique sur l'élément	0
OnEnter	VOID	L'utilisateur tape Enter sur un élément	0
WndProc	SUB (Hwnd%, Msg%, wParam%, lParam%)	Des messages sont envoyés à QListbox	4
> Exemple de QListbox

  DIM Form AS QForm

  DIM ListBox AS QListBox

  ListBox.Parent = Form

  ListBox.AddItems "1. Apples", "2. Oranges", "3. Bananas"

  ListBox.DelItems 1,2       '' Deletes Oranges and Bananas

  ListBox.Item(0) = "1. Strawberries"   '-- Change the first item

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QLISTVIEW
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QLISTVIEW

Composant QLISTVIEW

QListView propose 3 méthodes différentes pour afficher des éléments dans une fenêtre : Affichage en colonne avec entête, ou affichage individuel avec grandes ou petites icones.

> Propriétés de QListView

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BorderStyle	INTEGER	L/E	bsSingle
CheckBoxes	INTEGER	L/E	Faux
Color	INTEGER	L/E
Column	ARRAY of ColumnType	L/E
ColumnClick	INTEGER	L/E	Vrai
ColumnsCount	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
GridLines	INTEGER	L/E	Faux
Height	INTEGER	L/E
Hint	STRING	L/E
HotTrack	INTEGER	L/E	Faux
Item	ARRAY of ItemType	L/E
ItemCount	INTEGER	L/E
ItemIndex	INTEGER	L/E
LargeImages	QIMAGELIST	E
Left	INTEGER	L/E	0
MultiSelect	INTEGER	L/E	Faux
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ReadOnly	INTEGER	L/E	Faux
RowSelect	INTEGER	L/E	Faux
SelCount	INTEGER	L/E
Selected	ARRAY of INTEGER	L/E
ShowColumnHeaders	INTEGER	L/E	Vrai
ShowHint	INTEGER	L/E	Faux
SmallImages	QIMAGELIST	E
SortType	INTEGER	L/E	stNone
StateImages	QIMAGELIST	E
SubItem	2D ARRAY of STRING	L/E
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
ViewStyle	INTEGER	L/E	vsIcon
Visible	INTEGER	L/E	Vrai

> Méthodes de QListView

Méthodes	Type	Description	Paramètres
AddColumns	SUBI	Ajoute une entête de colonne	STRING, Infinite
AddItems	SUBI	Ajoute des éléments	STRING, Infinite
AddSubItem	SUB (Index%, String$)	Ajoute/Retire des éléments à l'index	2
Clear	SUB	Efface tous les éléments	0
ClearColumns	SUB	Efface toutes les colonnes	0
DelItems	SUBI	Supprime des éléments	INTEGER, Infinite
InsertItem	SUB (Index%, String$)	Insère un élément à l'index	2

> Evénements de QListView

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'élément a été cliqué	0
OnChange	SUB (Index%, Change AS BYTE)	L'élément a changé (Texte, image ou état)	2
OnColumnClick	SUB (Column%)	L'entête de colonne a été cliquée	1
OnDblClick	VOID	La sélection a été double-cliquée	0
OnKeyPressed	SUB (Key AS BYTE)	Une touche a été pressée	1

> Exemple de QListView

' Simple .ZIP viewer (doesn't extract or anything useful like that).

' You're free to modify and distribute the code without restrictions.

' Written in Rapid-Q by William Yu

' Demonstrates QOpenDialog, QFileStream, QListView, QMainMenu, QMenuItem

'              and QImageList.

$APPTYPE GUI

$TYPECHECK ON

$INCLUDE "RAPIDQ.INC"

$RESOURCE ICO_ZIP AS "ZIP.ICO"

$RESOURCE ICO_APP AS "APP.ICO"

DECLARE SUB ZipView (ZIPFile AS STRING)

DECLARE SUB FormResize

DECLARE SUB OpenClick

DECLARE SUB ExitClick

DECLARE SUB IconClick

DECLARE SUB SmallIconClick

DECLARE SUB ReportClick

DECLARE SUB ItemDblClick

CONST SIG = &H04034B50         ' ZIP Signature/ID

TYPE ZFHeader

  Signature AS LONG

  Version AS WORD

  GPBFlag AS WORD              ' ?

  Compress AS WORD             ' Compression types

  DateTime AS LONG             ' Packed format

  CRC32 AS LONG

  CSize AS LONG                ' Compressed size

  USize AS LONG                ' Uncompressed size

  FileNameLen AS LONG

END TYPE

TYPE PackedDateType            ' I think this is it:

  Year AS SHORT                ' 7 bits

  Month AS BYTE                ' 4 bits

  Day AS BYTE                  ' 5 bits

  Hour AS BYTE                 ' 5 bits

  Minute AS BYTE               ' 6 bits

  Secs AS BYTE                 ' 5 bits

END TYPE                       ' Total = 32 bits

DIM CompType(0 TO 9) AS STRING

    CompType(0) = "Stored"

    CompType(1) = "Shrunk"

    CompType(2) = "Reduced1"

    CompType(3) = "Reduced2"

    CompType(4) = "Reduced3"

    CompType(5) = "Reduced4"

    CompType(6) = "Imploded"

    CompType(7) = "Defalted"

    CompType(8) = "DeflatN"      '' Could be DeflatX as well...

    CompType(9) = "DeflatX"

DIM OpenItem AS QMenuItem

    OpenItem.Caption = "&Open"

    OpenItem.OnClick = OpenClick

DIM BreakItem AS QMenuItem

    BreakItem.Caption = "-"

DIM ExitItem AS QMenuItem

    ExitItem.Caption = "E&xit"

    ExitItem.OnClick = ExitClick

DIM IconItem AS QMenuItem

    IconItem.Caption = "vs&Icon"

    IconItem.RadioItem = Vrai

    IconItem.OnClick = IconClick

DIM SmallIconItem AS QMenuItem

    SmallIconItem.Caption = "vs&SmallIcon"

    SmallIconItem.RadioItem = Vrai

    SmallIconItem.OnClick = SmallIconClick

DIM ReportItem AS QMenuItem

    ReportItem.Caption = "vs&Report"

    ReportItem.RadioItem = Vrai

    ReportItem.Checked = Vrai

    ReportItem.OnClick = ReportClick

DIM FileMenu AS QMenuItem

    FileMenu.Caption = "&File"

    FileMenu.AddItems OpenItem, BreakItem, ExitItem

DIM ViewMenu AS QMenuItem

    ViewMenu.Caption = "&View"

    ViewMenu.AddItems IconItem, SmallIconItem, ReportItem

DIM ImageList1 AS QImageList

    ImageList1.Height = 32

    ImageList1.Width = 32

    ImageList1.AddICOHandle ICO_APP

    ImageList1.AddICOHandle ICO_ZIP

DIM ImageList2 AS QImageList            ' Scale 16x16

    ImageList2.Height = 16

    ImageList2.Width = 16

    ImageList2.AddICOHandle ICO_APP

    ImageList2.AddICOHandle ICO_ZIP

CREATE Form AS QForm

  ICOHandle = ICO_ZIP

  Center

  OnResize = FormResize

  Height = 330

  Width = 525

  Caption = "Simple .ZIP Viewer for Rapid-Q"

  CREATE MainMenu AS QMainMenu

    AddItems FileMenu, ViewMenu

  END CREATE

  CREATE ListView AS QListView

    Width = Form.ClientWidth

    Height = Form.ClientHeight

    SmallImages = ImageList2

    LargeImages = ImageList1

    ViewStyle = vsReport

    AddColumns "FileName","Length","Method","Size","Rate","Date","Time","CRC-32"

    Column(0).Width = 200

    Column(4).Width = 40

    Column(5).Width = 70

    Column(7).Width = 70

    OnDblClick = ItemDblClick

  END CREATE

  ShowModal

END CREATE

'------------------------------------------------------------------

SUB ZipView (ZIPFile AS STRING)

  DIM Hdr      AS ZFHeader

  DIM ZF       AS QFileStream

  DIM PD       AS PackedDateType

  DIM FileName AS STRING

  DIM Index    AS INTEGER

  IF ZF.Open(ZIPFile, fmOpenRead) = Faux THEN

    ShowMessage("Problem with reading "+ZIPFile)

    EXIT SUB

  END IF

  ListView.Clear

  Hdr.Signature = ZF.ReadNum(4)

  Index = 0

  WHILE Hdr.Signature = SIG

    Hdr.Version  = ZF.ReadNum(2)

    Hdr.GPBFlag  = ZF.ReadNum(2)

    Hdr.Compress = ZF.ReadNum(2)

    Hdr.DateTime = ZF.ReadNum(4)

    Hdr.CRC32 = ZF.ReadNum(4)

    Hdr.CSize = ZF.ReadNum(4)

    Hdr.USize = ZF.ReadNum(4)

    Hdr.FileNameLen = ZF.ReadNum(4)

    FileName = ZF.ReadStr(Hdr.FileNameLen)

    PD.Year = ((Hdr.DateTime SHR 25) AND &H7F) + 1980

    PD.Month = (Hdr.DateTime SHR 21) AND &H0F

    PD.Day = (Hdr.DateTime SHR 16) AND &H1F

    PD.Hour = (Hdr.DateTime SHR 11) AND &H1F

    PD.Minute = (Hdr.DateTime SHR 5) AND &H3F

    PD.Secs = Hdr.DateTime AND &H1F

    ListView.AddItems FileName

    IF INSTR(UCASE$(FileName), ".ZIP") THEN

      ListView.Item(Index).ImageIndex = 1

    END IF

    ListView.AddSubItem Index, STR$(Hdr.USize)

    ListView.AddSubItem Index, CompType(Hdr.Compress)

    ListView.AddSubItem Index, STR$(Hdr.CSize)

    IF Hdr.USize = 0 THEN

      ListView.AddSubItem Index, "----"

    ELSE

      ListView.AddSubItem Index, STR$(INT((Hdr.USize - Hdr.CSize) / Hdr.USize * 100))+"%"

    END IF

    ListView.AddSubItem Index, STR$(PD.Month)+"-"+STR$(PD.Day)+"-"+STR$(PD.Year)

    ListView.AddSubItem Index, STR$(PD.Hour)+":"+STR$(PD.Minute)

    ListView.AddSubItem Index, LCASE$(HEX$(Hdr.CRC32))

    ZF.Seek(Hdr.CSize, soFromCurrent)

    Hdr.Signature = ZF.ReadNum(4)

    Index = Index + 1

  WEND

  IF Index = 0 THEN

     '-- Likely not a .ZIP file

     ShowMessage(ZIPFile+" is not a valid ZIP file!")

  END IF

END SUB

SUB OpenClick

  DIM OpenDialog AS QOpenDialog

  OpenDialog.InitialDir = CurDir$

  OpenDialog.Filter = "ZIP Files (*.zip)|*.zip|All Files (*.*)|*.*"

  IF OpenDialog.Execute THEN

    ZipView(OpenDialog.FileName)

  END IF

END SUB

SUB ExitClick

  Form.Close

END SUB

SUB FormResize

  ListView.Height = Form.ClientHeight

  ListView.Width = Form.ClientWidth

END SUB

SUB IconClick

  IconItem.Checked = Vrai

  ListView.ViewStyle = vsIcon

END SUB

SUB SmallIconClick

  SmallIconItem.Checked = Vrai

  ListView.ViewStyle = vsSmallIcon

END SUB

SUB ReportClick

  ReportItem.Checked = Vrai

  ListView.ViewStyle = vsReport

END SUB

SUB ItemDblClick

  IF ListView.ItemIndex >= 0 THEN

    ShowMessage("Can't extract "+ListView.Item(ListView.ItemIndex).Caption);

  END IF

END SUB

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QMAINMENU
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QMAINMENU

Composant QMAINMENU

QMainmenu est l'environnement permettant de gérer des menus déroulants. Utilisez-le pour assurer la gestion des menus de votre fenêtre.

> Propriétés de QMainMenu

Propriété	Type	L/E	Par défaut
Parent	QFORM	E
> Méthodes de QmainMenu

Méthodes	Type	Description	Paramètres
AddItems	SUBI	Ajoute un élément au menu	QMENUITEMs, Infinite
Insert	SUB (I%, Item AS QMENUITEM)	Insère un élément	2

> Exemple de QMainMenu

  DIM Form AS QForm

  DIM MainMenu AS QMainMenu

  DIM Item1 AS QMenuItem

  Item1.Caption = "&File"

  MainMenu.AddItems Item1

  MainMenu.Parent = Form

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QMEMORYSTREAM
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QMEMORYSTREAM

Composant QMEMORYSTREAM

QMemorystream est utilisé pour stocker des files de données en mémoire destinées à être manipulées.

> Propriétés de QMemorystream

Propriétés	Type	L/E	Par défaut
Position	INTEGER	L/E
SetSize	INTEGER	E
Size	INTEGER	L
> Méthodes de QMemorystream

Méthodes	Type	Description	Params
Close	SUB	Ferme la file	0
CopyFrom	SUB (Stream, Bytes%)	Copie d'une file à l'autre (QFileStream ou QmemoryStream) Bytes%=0 quand on souhaite copier l'intégralité d'une file de données	2
ReadNum	FUNCTION (Size%)	Lit Size% octets et retourne un nombre	1
ReadStr	FUNCTION (Size%)	Lit Size% octets et retourne une chaîne de caractères	1
Seek	SUB (Position%, From%)	Recherche une valeur depuis From%  jusque Position%, voir RAPIDQ.INC	2
WriteNum	SUB (number, bytes%)	Ecrit un nombre dans la file	2
WriteStr	SUB (string, bytes%)	Ecrit une chaîne dans la file	2

> Exemple de QMemoryStream

  DIM Mem AS QMemoryStream

  S$ = "Hello world!"

  Mem.WriteStr(S$, LEN(S$))

  Mem.Position = 0

  S$ = Mem.ReadStr(LEN(S$))

  PRINT S$                            '' print it

  Mem.Close

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QMENUITEM
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QMENUITEM

Composant QMENUITEM

QMenuItem est utilisé pour décrire les propriétés d'un élément de menu. Il ne doit pas être utilisé seul. Vous devez généralement l'ajouter à QMainMenu ou QPopupMenu.

> Propriétés de QMenuItem

Propriété	Type	L/E	Default
Caption	STRING	L/E
Checked	INTEGER	L/E
Enabled	INTEGER	L/E	Vrai
RadioItem	INTEGER	L/E	Faux
ShortCut	STRING	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QMenuItem

Méthodes	Type	Description	Paramètres
AddItems	SUBI	Ajoute un élément à un menu	QMENUITEMs, Infinite
Insert	SUB (I%, Item AS QMENUITEM)	Insère un élément	2

> Evénements de QMenuItem

Evénement	Type	Se produit quand	Params
OnClick	VOID	L'utilisateur sélectionne l'élément	0

> Exemple de QMenuItem

  DIM Form AS QForm

  DIM MainMenu AS QMainMenu

  DIM Item1 AS QMenuItem

  Item1.Caption = "&File"

  MainMenu.AddItems Item1

  MainMenu.Parent = Form

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QNOTIFYICONDATA
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QNOTIFYICONDATA

Composant QNOTIFYICONDATA

QNotifyIconData n'est pas un composant visible, c'est un type de donnée qui accompagne une fenêtre

   TYPE QNotifyIconData

     cbSize AS INTEGER       ' Lecture seule

     hWnd AS INTEGER

     uID AS INTEGER

     uFlags as INTEGER

     uCallBackMessage as INTEGER

     hIcon as INTEGER

     szTip as STRING

   END TYPE

Au départ, son utilisation est limitée à l'appel de l'API Shell_NotifyIcon, mais vous pouvez très bien y trouver d'autres utilisations.

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QOPENDIALOG
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QOPENDIALOG

Composant QOPENDIALOG

QOpenDialog affiche une boîte de dialogue spécialisée dans la sélection de fichiers

> Propriétés de QOpenDialog

Propriété	Type	L/E	Par défaut
Caption	STRING	L/E
FileName	STRING	L/E
Filter	STRING	L/E
FilterIndex	INTEGER	L/E	1
InitialDir	STRING	L/E

> Méthodes de QOpenDialog

Méthode	Type	Description	Params
Execute	FUNCTION	Retourne Vrai ou Faux	0

> Exemples de QOpenDialog

  '-- Simple demo

  DIM OpenDialog AS QOpenDialog

  IF OpenDialog.Execute THEN

    ShowMessage "You selected "+OpenDialog.FileName

  END IF

  '-- Using filters

  DIM OpenDialog AS QOpenDialog

  OpenDialog.Filter = "Picture files|*.BMP;*.ICO|All Files|*.*"

  OpenDialog.FilterIndex = 2    '' Use "All Files" as our default

  IF OpenDialog.Execute THEN

    ShowMessage "You selected "+OpenDialog.FileName

  END IF

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QOUTLINE
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QOUTLINE

Composant QOUTLINE

QOutLine propose la version Windows 3.1 de la boîte de liste arborescente de fichiers.

> Propriétés de QOutLine

Propriétés	Type	R/E	Par défaut
Align	INTEGER	L/E	alNone
BMPClosed	STRING	E
BMPLeaf	STRING	E
BMPMinus	STRING	E
BMPOpen	STRING	E
BMPPlus	STRING	E
BMPHandleClosed	RESOURCE	E
BMPHandleLeaf	RESOURCE	E
BMPHandleMinus	RESOURCE	E
BMPHandleOpen	RESOURCE	E
BMPHandlePlus	RESOURCE	E
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Hint	STRING	L/E
Item	ARRAY of STRING	L/E
ItemHeight	INTEGER	L/E	13
ItemIndex	INTEGER	L/E
ItemSeparator	STRING	L/E	\
Left	INTEGER	L/E	0
LineCount	INTEGER	L/E
OutLineStyle	INTEGER	L/E	osTreePictureText
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Row	INTEGER	L/E
ScrollBars	INTEGER	L/E	ssBoth
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Visible	INTEGER	L/E	Vrai
Width	INTEGER	L/E

> Méthodes de QOutLine

Méthodes	Type	Description	Paramètres
AddChild	SUB (Index%, String$)	Ajoute une ligne Enfant à l'Index%	2
AddLines	SUBI	Ajoute des lignes à Outline	STRING, Infinite
AddOptions	SUBI	Ajoute des options à Outline	INTEGER, Infinite
Clear	SUB	Efface tous les éléments	0
DelLines	SUBI	Supprime des lignes de Outline	INTEGER, Infinite
DelOptions	SUBI	Supprime des options à Outline	INTEGER, Infinite
Insert	SUB (Index%, String$)	Ajoute une arborescence à Index%	2

> Evénements de QOutLine

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur un élément	0
OnDblClick	VOID	L'utilisateur double-clique sur un élément	0

> Exemple de QOutLine

CREATE Form AS QForm

  CREATE OutLine AS QOutLine

    AddLines "Parent 1", _

             " Child of Parent 1", _

             "  Child of Child of Parent 1", _

             "Parent 2", _

             "Parent 3"

  END CREATE

  Center

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QOVALBTN
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QOVALBTN

Composant QOVALBTN

QOvalbtn est identique à QCoolBtn, la différence se situe dans ses formes arrondies (rondes/ovales).

> Propriétés de QOvalbtn

Propriétés	Type	L/E	Par défaut
BMP	STRING	E
BMPHandle	RESOURCE	E
Caption	STRING	L/E
Color	INTEGER	L/E
ColorHighLight	INTEGER	L/E
ColorShadow	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Down	INTEGER	L/E	Faux
Enabled	INTEGER	L/E	Vrai
Flat	INTEGER	L/E	Faux
Font	QFONT	E
GroupIndex	INTEGER	L/E	0
Height	INTEGER	L/E
Hint	STRING	L/E
Layout	INTEGER	L/E	blBMPLeft
Left	INTEGER	L/E	0
NumBMPs	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
ShowHint	INTEGER	L/E	Faux
Spacing	INTEGER	L/E
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Transparent	INTEGER	L/E	Faux
TransParentColor	INTEGER	L/E
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QOvalbtn

Méthode	Type	Description	Params
StartDrag	SUB	Permet au bouton d'être déplacé	0

> Evénements de QOvalbtn

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur le bouton	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste appuyé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4
> Exemple de QOvalbtn

CREATE Form AS QForm

  CREATE OvalBtn AS QOvalBtn

    Caption = "Oval Button"

    Color = &H00FF00

  END CREATE

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QPANEL
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QPANEL

Composant QPANEL

QPanel permet de créer un espace générique destiné à recevoir vos composants.

> Propriétés de QPanel

Propriétés	Type	L/E	Par défaut
Alignment	INTEGER	L/E	taCenter
BevelInner	INTEGER	L/E	bvNone
BevelOuter	INTEGER	L/E	bvRaised
BevelWidth	INTEGER	L/E	1
BorderStyle	INTEGER	L/E	bsNone
Caption	STRING	L/E
ClientHeight	INTEGER	L/E
ClientWidth	INTEGER	L/E
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Left	INTEGER	L/E	0
Parent	QFORM, QPANEL	E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Evénements de QPanel

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur une zone libre de Qpanel	0
OnDblClick	VOID	L'utilisateur double-clique sur une zone libre	0
OnMouseDown	SUB (Button%, X%, Y%)	Le bouton de la souris reste appuyé	3
OnMouseMove	SUB (X%, Y%)	La souris se déplace	2
OnMouseUp	SUB (Button%, X%, Y%)	Le bouton de la souris est relâché	3
> Exemple de QPanel

  DIM Form AS QForm

  DIM Button AS QButton

  DIM Panel AS QPanel

  Panel.Parent = Form

  Panel.Width = 100

  Button.Parent = Panel

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QPOPUPMENU
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QPOPUPMENU

Composant QPOPUPMENU

QPopupMenu propose une fenêtre de gestion de menus indépendante de la barre de menus.

> Propriétés de QPopupMenu

Propriétés	Type	L/E	Par défaut
Alignment	INTEGER	L/E

> Méthodes de QPopupMenu

Méthodes	Type	Description	Paramètres
AddItems	SUBI	Ajoute un élément au menu	QMENUITEMs, Infini
Insert	SUB (I%, Item AS QMENUITEM)	Insère un élément	2
Popup	SUB (X%, Y%)	Place le menu en X,Y	2
> Exemples de QPopupMenu

  DIM PopupMenu AS QPopupMenu

  DIM Item1 AS QMenuItem

  Item1.Caption = "Item 1"

  PopupMenu.AddItems Item1

  PopupMenu.Popup(100,100)

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QRADIOBUTTON
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QRADIOBUTTON

Composant QRADIOBUTTON

QRadioButton propose la gestion d'un simple bouton. Si vous voulez regrouper des boutons, utilisez un composant générique comme QPANEL

> Prppriétés de QRadioButton

Propriétés	Type	L/E	Par défaut
Checked	INTEGER	L/E	Faux
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Evénements de QRadioButton

Evénement	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur le bouton	0
> Exemple de QRadioButton

  DIM Form AS QForm

  DIM Radio1 as QRadioButton

  DIM Radio2 as QRadioButton

  DIM Radio3 as QRadioButton

  Radio1.Parent = Form

  Radio1.Top = 10

  Radio1.Caption = "Item 1"

  Radio2.Parent = Form

  Radio2.Top = 35

  Radio2.Caption = "Item 2"

  Radio3.Parent = Form

  Radio3.Top = 60

  Radio3.Caption = "Item 3"

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QRECT
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QRECT

Composant QRECT

QRect n'est pas un composant visible, c'est un type de données lié à une fenêtre

   TYPE QRect

     Top AS INTEGER

     Left AS STRING

     Right AS INTEGER

     Bottom as INTEGER

   END TYPE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QRICHEDIT
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QRICHEDIT

Composant QRICHEDIT

QRichedit propose un contrôle d'éditeur de texte très performant.

> Propriétés de QRichEdit

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Alignment	INTEGER	L/E	taLeftJustify
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Height	INTEGER	L/E
HideScrollBars	INTEGER	L/E	Vrai
HideSelection	INTEGER	L/E	Vrai
Hint	STRING	L/E
Icon	STRING	E
Left	INTEGER	L/E	0
Line	ARR_STRING	L/E
LineCount	INTEGER	L/E
Modified	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Plaintext	INTEGER	L/E	Faux
Readonly	INTEGER	L/E	Faux
ScrollBars	INTEGER	L/E	ssNone
SelAttributes	QFONT	E
SelLength	INTEGER	L/E
SelStart	INTEGER	L/E
SelText	STRING	L/E
ShowHint	INTEGER	L/E	Faux
Text	STRING	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
WhereX	INTEGER	L/E
WhereY	INTEGER	L/E
Wordwrap	INTEGER	L/E	Vrai
Visible	INTEGER	L/E	Vrai

> Méthodes de QRichedit

Méthode	Type	Description	Params
AddString	SUB (S$)	Ajoute une chaîne de caractères	1
AddStrings	SUBI	Ajoute jusqu'à 255 chaînes	STRING
Clear	SUB	Efface tout le texte	0
CopyToClipboard	SUB	Copie le texte sélectionné dans le presse-papiers	0
CutToClipboard	SUB	Supprime le texte sélectionné et le place dans le presse-papiers	0
LoadFromFile	SUB (FileName$)	Lit un fichier texte	1
LoadFromStream	SUB (Stream)	Lit un texte depuis une file de données	1
PasteFromClipboard	SUB	Colle un texte contenu dans le presse-papiers	0
SaveToFile	SUB (FileName$)	Enregistre un texte dans un fichier	1
SaveToStream	SUB (Stream)	Transfère un texte dans une file de données	1
SelectAll	SUB	Sélectionne tout le texte	0

> Evénements de QRichedit

Evénements	Type	Se produit quand…	Params
OnChange	VOID	Le texte a été modifié	0
OnKeyDown	SUB (Key AS WORD, Shift AS INTEGER)	Une touche reste pressée	2
OnKeyPress	SUB (Key AS BYTE)	L'utilisateur tape une touche	1
OnKeyUp	SUB (Key AS WORD, Shift AS INTEGER)	Une touche a été relâchée	2
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste pressé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	2
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4

> Exemple de QRichedit

  $INCLUDE "RAPIDQ.INC"

  DIM Form AS QForm

  DIM RichEdit AS QRichEdit

  RichEdit.Parent = Form

  RichEdit.Scrollbars = ssBoth

  RichEdit.AddString "Hello world!"

  Form.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Méthode QSAVEDIALOG
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSAVEDIALOG

Composant QSAVEDIALOG

QSaveDialog Affiche une boîte de dialogue spécialisée dans l'enregistrement de fichiers.

> Propriétés de QSaveDialog

Propriétés	Type	L/E	Par défaut
Caption	STRING	L/E
FileName	STRING	L/E
Filter	STRING	L/E
FilterIndex	INTEGER	L/E	1
InitialDir	STRING	L/E

> Méthodes de QSaveDialog

Méthode	Type	Description	Params
Execute	FUNCTION	Retourne Vrai ou Faux	0

> Exemple de QSaveDialog

  '-- Simple demo

  DIM SaveDialog AS QOpenDialog

  IF SaveDialog.Execute THEN

    ShowMessage "You want to save as "+SaveDialog.FileName

  END IF

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QSCROLLBAR
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSCROLLBAR

Composant QSCROLLBAR

QScrollBar est un ascenceur qui permet de faire défiler le contenu d'une fenêtre ou d'un contrôle. Elle peut être également utilisée pour faire défiler un élément pré-défini.

> Propriétés de QScrollBar

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Height	INTEGER	L/E
Hint	STRING	L/E
Kind	INTEGER	L/E	sbHorizontal
LargeChange	INTEGER	L/E	1
Left	INTEGER	L/E	0
Max	INTEGER	L/E	100
Min	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Position	INTEGER	L/E	0
ShowHint	INTEGER	L/E	Faux
SmallChange	INTEGER	L/E	1
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Evénements de QScrollBar

Evénements	Type	Se produit quand…	Params
OnChange	VOID	La position de défilement change	0

> Exemple de QScrollBar

' Color Palette for Rapid-Q by William Yu

DECLARE SUB ColorChange

DECLARE SUB Paint

CONST Faux = 0

CONST Vrai = NOT Faux

'' Here's something that will convert your standard RGB to Rapid-Q's BGR.

FUNCTION ConvertRGB(R AS INTEGER, G AS INTEGER, B AS INTEGER) AS INTEGER

  ConvertRGB = (B SHL 16) OR (G SHL 8) OR R

END FUNCTION

CREATE Form AS QForm

  CREATE LabelRed AS QLabel

    Left = 10

    Top = 22

    Caption = "Red:"

  END CREATE

  CREATE LabelGreen AS QLabel

    Left = 5

    Top = 52

    Caption = "Green:"

  END CREATE

  CREATE LabelBlue AS QLabel

    Left = 10

    Top = 82

    Caption = "Blue:"

  END CREATE

  CREATE LabelNum1 AS QLabel

    Left = 270

    Top = 22

    Caption = "0"

  END CREATE

  CREATE LabelNum2 AS QLabel

    Left = 270

    Top = 52

    Caption = "0"

  END CREATE

  CREATE LabelNum3 AS QLabel

    Left = 270

    Top = 82

    Caption = "0"

  END CREATE

  CREATE ScrollRed AS QScrollBar

    Left = 50

    Top = 20

    Width = 200

    Height = 20

    Min = 0: Max = 255

    ShowHint =  Vrai

    Hint = "Red Attribute"

    OnChange = ColorChange

  END CREATE

  CREATE ScrollGreen AS QScrollBar

    Left = 50

    Top = 50

    Width = 200

    Height = 20

    Min = 0: Max = 255

    ShowHint =  Vrai

    Hint = "Green Attribute"

    OnChange = ColorChange

  END CREATE

  CREATE ScrollBlue AS QScrollBar

    Left = 50

    Top = 80

    Width = 200

    Height = 20

    Min = 0: Max = 255

    ShowHint =  Vrai

    Hint = "Blue Attribute"

    OnChange = ColorChange

  END CREATE

  CREATE PaintBox AS QCanvas

    Left = 50

    Top = 110

    Height = 90

    Width = 200

    OnPaint = Paint

  END CREATE

  Caption = "Color Palette"

  Center

  ShowModal

END CREATE

SUB ColorChange

  LabelNum1.Caption = STR$(ScrollRed.Position)

  LabelNum2.Caption = STR$(ScrollGreen.Position)

  LabelNum3.Caption = STR$(ScrollBlue.Position)

  Paint

END SUB

SUB Paint

  PaintBox.Paint(0,0,ConvertRGB(ScrollRed.Position, ScrollGreen.Position, ScrollBlue.Position),&HFFFFFF)

END SUB

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QSCROLLBOX
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSCROLLBOX

Composant QSCROLLBOX

QScrollBox est un contrôle de fenêtre déroulante

> Propriétés de QScrollBox

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
AutoScroll	INTEGER	L/E	Vrai
BorderStyle	INTEGER	L/E	bsSingle
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Font	QFONT	E
Handle	INTEGER	L
Height	INTEGER	L/E
Hint	STRING	L/E
Horz.Increment	INTEGER	L/E	8
Horz.Margin	INTEGER	L/E	0
Horz.Position	INTEGER	L/E	0
Horz.Range	INTEGER	L/E	0
Horz.Tracking	INTEGER	L/E	Faux
Horz.Visible	INTEGER	L/E	Vrai
Left	INTEGER	L/E	0
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Vert.Increment	INTEGER	L/E	8
Vert.Margin	INTEGER	L/E	0
Vert.Position	INTEGER	L/E	0
Vert.Range	INTEGER	L/E	0
Vert.Tracking	INTEGER	L/E	Faux
Vert.Visible	INTEGER	L/E	Vrai
Visible	INTEGER	L/E	Vrai

> Méthodes de QScrollBox

Méthode	Type	Description	Params
Repaint	SUB	Redessine le contrôle	0

> Evénements de QscrollBox

Evénements	Type	Se produit quand…	Params
OnClick	VOID	L'utilisateur clique sur la fenêtre	0
OnDblClick	VOID	L'utilisateur double-clique sur la fenêtre	0
OnMouseDown	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris reste appuyé	4
OnMouseMove	SUB (X%, Y%, Shift%)	La souris se déplace	3
OnMouseUp	SUB (Button%, X%, Y%, Shift%)	Le bouton de la souris est relâché	4
OnResize	VOID	La fenêtre est redimensionnée	0
> Exemple de QScrollBox

CREATE Form AS QForm

  Center

  CREATE ScrollBox AS QScrollBox

    Left = 50

    CREATE Button AS QButton   '-- Create button inside scrollbox

    END CREATE

  END CREATE

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QSOCKET
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSOCKET

Composant QSOCKET

QSocket propose une interface simple de communication Client/Serveur.

> Propriétés de QSocket

Propriété	Type	L/E	Par défaut
Transferred	INTEGER	R
> Méthodes de QSocket

Méthode	Type	Description	Params
Accept	FUNCTION ClientSock%(Socket%)	Accepte la connexion d'un client	1
Close	SUB (Socket%)	Ferme le descripteur de fichier %Socket	1
Connect	FUNCTION Sock%(ServerName$, PortNum%)	Connexion au serveur sur PortNum%	2
ConnectionReady	FUNCTION Bool%(Sock%)	Vrai/Faux si connexion en attente	1
GetHostName	FUNCTION AS STRING	Retourne le nom de l'hôte	0
GetPeerName	FUNCTION GetPeerName$(Socket%)	Retourne le nom du poste	1
IsClientReady	FUNCTION Bool%(Sock%, ClientSock%)	Vrai/Faux si le client envoie des données	2
IsServerReady	FUNCTION Bool%(Sock%)	Vrai/Faux si le serveur envoie des données	1
Open	FUNCTION Sock%(PortNum%)	Ouvre un serveur TCP sur le port PortNum%	1
Read	FUNCTION Message$(Socket%, NumBytes%)	Lit un nombre d'octets NumBytes%	2
ReadLine	FUNCTION Message$(Socket%)	Lit une ligne complète	1
Write	SUB (Socket%, Message$, NumBytes%)	Envoie un nombre d'octets depuis Message$	3
WriteLine	FUNCTION Bytes%(Socket%, Message$)	Envoie le texte Message$	2

> Exemple de QSocket

Voir les programmes chatserver.bas and chatclient.bas inclus dans la version Linux de Rapid-Q. Etudiez également http.bas inclus dans la version Windows de Rapid-Q

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QSTATUS
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSTATUSBAR

Composant QSTATUSBAR

QStatusBar permet de créer une barre d'état.

> Propriétés de QStatusBar

Propriété	Type	L/E	Par défaut
Align	INTEGER	L/E	alBottom
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
Panel	ARRAY of PanelType	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ShowHint	INTEGER	L/E	Faux
SimplePanel	INTEGER	L/E	Faux
SimpleText	STRING	L/E
SizeGrip	INTEGER	L/E	Vrai
TabOrder	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QStatusBar

Méthodes	Type	Description	Params
AddPanels	SUBI	Ajoute une zone à la barre d'état	STRING, Infini
Clear	SUB	Efface les zones	0

> Evénements de QStatusBar

Evénement	Type	Se produit quand	Params
OnResize	VOID	La barre de statut est redimensionnée	0

> Exemple de QStatusBar

CREATE Form AS QForm

  Center

  CREATE StatusBar AS QStatusBar

    AddPanels "Panel 1", "Panel 2", "Panel 3"

    Panel(1).Width = 100  ' change width of Panel 2

  END CREATE

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QSTRINGGRID
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QSTRINGGRID

Composant QSTRINGGRID

QStringGrid vous permet de présenter vos données texte sous forme de tableau

> Propriétés de QStringGrid

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
BorderStyle	INTEGER	L/E	bsSingle
Cell	2D ARRAY of INTEGER	L/E
Col	INTEGER	L/E
ColCount	INTEGER	L/E	5
Color	INTEGER	L/E
ColWidths	ARRAY of INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
DefaultColWidth	INTEGER	L/E	64
DefaultRowHeight	INTEGER	L/E	24
EditorMode	INTEGER	L/E
Enabled	INTEGER	L/E	Vrai
FixedColor	INTEGER	L/E
FixedCols	INTEGER	L/E	1
FixedRows	INTEGER	L/E	1
Font	QFONT	E
GridHeight	INTEGER	L/E
GridLineWidth	INTEGER	L/E	1
GridWidth	INTEGER	L/E
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
LeftCol	INTEGER	L/E
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
Row	INTEGER	L/E
RowCount	INTEGER	L/E	5
RowHeights	ARRAY of INTEGER	L/E
ScrollBars	INTEGER	L/E	ssBoth
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
TabStops	ARRAY of INTEGER	L/E
Top	INTEGER	L/E	0
TopRow	INTEGER	L/E
Visible	INTEGER	L/E	Vrai
VisibleColCount	INTEGER	L
VisibleRowCount	INTEGER	L
Width	INTEGER	L/E

> Méthodes de QStringGrid

Méthodes	Type	Description	Params
AddOptions	SUBI	Ajoute des options à une grille	INTEGER, Infini
DelOptions	SUBI	Supprime des options à une grille	INTEGER, Infini

Exemple de QStringGrid

CREATE Form AS QForm

  CREATE Grid AS QStringGrid

    Cell(1,1) = "hello"

  END CREATE

  Center

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QTABCONTROL
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QTABCONTROL

Composant QTABCONTROL

QTabControl Permet de gérer plusieurs documents par un système d'onglets en ne proposant qu'une page d'affichage.

> Propriétés de QTabControl

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
ButtonStyle	INTEGER	L/E	Faux
ClientHeight	INTEGER	L/E
ClientWidth	INTEGER	L/E
Color	INTEGER	L/E
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
FlatButtons	INTEGER	L/E	Faux
FlatSeperators	INTEGER	L/E	Faux
FocusButtons	INTEGER	L/E	Faux
Font	QFONT	E
Height	INTEGER	L/E
Hint	STRING	L/E
HotTrack	INTEGER	L/E	Faux
Left	INTEGER	L/E	0
MultiLine	INTEGER	L/E	Faux
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
ScrollOpposite	INTEGER	L/E	Faux
ShowHint	INTEGER	L/E	Faux
Tab	ARRAY of STRING	L/E
TabHeight	INTEGER	L/E
TabInactiveColor	INTEGER	L/E
TabInactiveFont	QFONT	E
TabIndex	INTEGER	L/E
TabOrder	INTEGER	L/E
TabPosition	INTEGER	L/E
TabWidth	INTEGER	L/E
Top	INTEGER	L/E	0
Width	INTEGER	L/E
VerticalTabs	INTEGER	L/E	Faux
Visible	INTEGER	L/E	TVrai

> Méthodes de QTabControl

Méthodes	Type	Description	Params
AddTabs	SUBI	Ajoute des onglets au contrôle	STRING, Infinite
DelTabs	SUBI	Supprime des onglets au contrôle	INTEGER, Infinite
InsertTab	SUB (Index%, String$)	Insère un onglet à l'index Index%	2

> Controles QTabControl

Evénement	Type	Se produit quand…	Params
OnChange	VOID	Tabs change	0

> Exemple de QTabControl

'' Tab Control Example for Rapid-Q by William Yu

'' When you hide a container (like QFORM, QTABCONTROL, and QPANEL), all the

'' components within it are also hidden.

$INCLUDE "RAPIDQ.INC"

DECLARE SUB TabChange

CREATE MainForm AS QForm

  Center

  Height = 300

  Width = 350

  Caption = "Tab Control demo"

  CREATE Tab AS QTabControl

    AddTabs "Tab 1","Tab 2","Tab 3","Tab 4"

    Width = MainForm.ClientWidth

    Height = MainForm.ClientHeight

    OnChange = TabChange

    HotTrack = TVrai

    CREATE Panel0 AS QPanel

      Top = 40

      Left = 5

      Width = Tab.ClientWidth - 10

      Height = Tab.ClientHeight - 50

      Caption = "Panel 1"

      BevelInner = bvLowered

      CREATE Button1 AS QButton

        Caption = "Hello world!"

      END CREATE

    END CREATE

    CREATE Panel1 AS QPanel

      Top = 40

      Left = 5

      Width = Tab.ClientWidth - 10

      Height = Tab.ClientHeight - 50

      Caption = "Panel 2"

      BevelInner = bvLowered

      Visible = Faux

    END CREATE

    CREATE Panel2 AS QPanel

      Top = 40

      Left = 5

      Width = Tab.ClientWidth - 10

      Height = Tab.ClientHeight - 50

      Caption = "Panel 3"

      BevelInner = bvLowered

      Visible = Faux

    END CREATE

    CREATE Panel3 AS QPanel

      Top = 40

      Left = 5

      Width = Tab.ClientWidth - 10

      Height = Tab.ClientHeight - 50

      Caption = "Panel 4"

      BevelInner = bvLowered

      Visible = Faux

    END CREATE

  END CREATE

END CREATE

SUB TabChange

  SELECT CASE Tab.TabIndex

    CASE 0

      Panel0.Visible = TVrai

      Panel1.Visible = Faux

      Panel2.Visible = Faux

      Panel3.Visible = Faux

    CASE 1

      Panel1.Visible = TVrai

      Panel0.Visible = Faux

      Panel2.Visible = Faux

      Panel3.Visible = Faux

    CASE 2

      Panel2.Visible = TVrai

      Panel1.Visible = Faux

      Panel0.Visible = Faux

      Panel3.Visible = Faux

    CASE 3

      Panel3.Visible = TVrai

      Panel1.Visible = Faux

      Panel2.Visible = Faux

      Panel0.Visible = Faux

  END SELECT

END SUB

MainForm.ShowModal

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QTIMER
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QTIMER

Composant QTIMER

QTimer gère les fonctions d'horloge de Windows.

> Propriétés de QTimer

Propriétés	Type	L/E	Par défaut
Enabled	INTEGER	L/E	Vrai
Interval	INTEGER	L/E

> Evénements de QTimer

Evénement	Type	Se produit quand…	Params
OnTimer	VOID	Timer interval elaspes	0

> Exemple de QTimer

' Timer & OnKeyPress example for Rapid-Q by William Yu

'       If no form is visible, Timer will not function.

'       Not for PURE CONSOLE apps, but you're allowed to MIX.

DIM Timer AS QTimer, Timer2 AS QTimer

DIM Form AS QFORM

DIM Label1 AS QLABEL, Label2 AS QLABEL

DIM Label3 AS QLABEL

SUB TimerOver

  Timer.Interval = 100

  I = I + 1

  Label1.Caption = STR$(I)

END SUB

SUB Timer2Over

  Timer2.Interval = 1000

  J = J + 1

  Label2.Caption = STR$(J)

END SUB

SUB KeyPressed (Key AS BYTE)      '' Event returns one parameter

  IF UCASE$(CHR$(Key)) = "Q" THEN

    FORM.CLOSE

  END IF

END SUB

I = 0        ' Undeclared variables are automatically global!

J = 0

FORM.CAPTION = "Timer Example"

FORM.WIDTH = 150

FORM.HEIGHT = 120

FORM.CENTER

Label1.Parent = Form

Label1.Caption = STR$(I)

Label1.Left = FORM.WIDTH/2

Label2.Parent = Form

Label2.Caption = STR$(J)

Label2.Left = FORM.WIDTH/2

Label2.Top = 40

Label3.Parent = Form

Label3.Caption = "Press 'Q' to quit'

Label3.Top = 75

Timer.Interval = 100

Timer.Enabled = 1          ' True

Timer.OnTimer = TimerOver

Timer2.Interval = 1000

Timer2.Enabled = 1          ' True

Timer2.OnTimer = Timer2Over

FORM.OnKeyPress = KeyPressed

FORM.SHOWMODAL

Composant précédent	Annexes	Sommaire	Composant suivant


Composant QTRACKBAR
Documentation de Rapid-Q par William Yu (c)1999

Annexe A - Composant QTRACKBAR

Composant QTRACKBAR

QTrackBar est un contrôle prenant la forme d'un curseur qui peut être déplacé de manière continue et accompagné de coches de repérage.

> Propriétés de QTrackBar

Propriétés	Type	L/E	Par défaut
Align	INTEGER	L/E	alNone
Cursor	INTEGER	L/E	crDefault
Enabled	INTEGER	L/E	Vrai
Frequency	INTEGER	L/E
Height	INTEGER	L/E
Hint	STRING	L/E
Left	INTEGER	L/E	0
LineSize	INTEGER	L/E	1
Max	INTEGER	L/E	10
Min	INTEGER	L/E	0
Orientation	INTEGER	L/E	tbHorizontal
PageSize	INTEGER	L/E	2
Parent	QFORM/QPANEL/QTABCONTROL	E
PopupMenu	QPOPUPMENU	E
SelEnd	INTEGER	L/E
SelStart	INTEGER	L/E
ShowHint	INTEGER	L/E	Faux
TabOrder	INTEGER	L/E
TickMarks	INTEGER	L/E	tmBottomRight
TickStyle	INTEGER	L/E	tsAuto
Top	INTEGER	L/E	0
Width	INTEGER	L/E
Visible	INTEGER	L/E	Vrai

> Méthodes de QTrackBar

Méthode	Type	Description	Params
SetTick	SUB (Pos%)	Place une coche à l'emplacement Pos%	1

> Evénements QTrackBar

Evénement	Type	Se produit quand…	Params
OnChange	VOID	Le curseur se déplace	0

> Exemple de QTrackBar

CREATE Form AS QForm

  Center

  CREATE TrackBar AS QTrackBar

    ' Initialize track bar

  END CREATE

  ShowModal

END CREATE

Composant précédent	Annexes	Sommaire


Appendice C - Conditions
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - COMMANDES CONDITIONNELLES

Introduction aux commandes conditionnelles

Les commandes conditionnelles permettent d'exécuter des instructions si une condition est satisfaite. C'est certainement l'un des premiers concepts de programmation que l'on apprend.

IF .. THEN .. ELSE

Une seule particularité est à noter dans l'utilisation de la structure IF… en Rapid-Q. Cette forme est valide en Qbasic :

    IF I > 100 THEN PRINT "I est plus grand que 100"

Elle ne l'est pas en Rapid-Q qui vous enverra un message vous demandant de séparer les lignes. Vous devrez alors écrire cela :

    IF I > 100 THEN

      PRINT " I est plus grand que 100"

    END IF

Quand la condition I > 100 est satisfaite, le code situé entre IF et END IF est exécuté. Dans le cas contraire, le code est sauté, donc pas exécuté. Une condition est réputée satisfaite quand son résultat n'est pas égal à Zéro, ce qui veut dire que ce code est également valide :

   I = 100

   IF I THEN

     PRINT "Condition satisfaite"

   ELSE

     PRINT "Condition non satisfaite"

   END IF

Utilisez ELSEIF dès que vous souhaitez tester plusieurs conditions :

   IF I > 10 AND I < 20 THEN

      '' Faire ce qu'il faut

   ELSEIF I > 55 THEN

      '' Faire ce qu'il faut

   ELSE

      '' Faire ce qu'il faut

   END IF

Quelquefois, il est plus pratique d'utiliser la structure SELECT CASE au lieu d'une succession de ELSIFs. C'est ce que nous allons étudier maintenant.

SELECT CASE .. END SELECT

Cette structure est généralement employée quand vous devez tester un nombre important de conditions. Elle n'est pas très utile si vous n'avez que 2 ou 3 conditions, mais ne vous opposera aucune limitation dans des conditions multiples. Il n'y a rien de spécifique dans l'utilisation de SELECT CASE. Tout ce que vous avez appris en Qbasic peut donc être transposé en Rapid-Q, comme ceci :

    SELECT CASE Expression

      CASE 1

        '' Faire ce qu'il faut

      CASE 5

        '' Faire ce qu'il faut

      CASE ELSE

        '' La condition n'est pas satisfaite, faire ce qu'il faut

    END SELECT

Au delà de l'économie de frappe, cette structure offre de nombreux avantages et rend, par exemple, plus facile le traitement de gammes de données :

    SELECT CASE Expression

      CASE 1 TO 4, 10 TO 20

        '' Faire ce qu'il faut

      CASE 100 TO 150

        '' Faire ce qu'il faut

      CASE IS > 200

        '' Faire ce qu'il faut

    END SELECT

Comme vous pouvez le voir, vous pouvez utiliser des tests de condition multiples en les séparant par des virgules. Quant à la signification de IS… elle saute aux yeux.

Annexes	Sommaire	Chapitre suivant


Appendice C - Boucles
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - INTRODUCTION AUX BOUCLES

Introduction aux Boucles

Les boucles permettent d'exécuter une série d'instructions un certain nombre de fois. Un grand nombre de vos programmes intégreront des boucles. Les compilateurs traduisent les boucles en commandes GOTO, il vous est donc possible de créer vos boucles par des commandes GOTOs sans autre inconvénient qu'une mauvaise lisibilité de votre programme. Cependant, Rapid-Q n'utilise pas ce mécanisme dans les boucles FOR…TO, ce qui permet d'économiser quelques instructions. Vous pourrez ainsi remarquer que les boucles FOR…TO sont un peu plus rapides que les boucles WHILE et DO.

La boucle FOR .. NEXT

Quelques précisions dans l'utilisation de cette boucle, par exemple, ce cas particulier :

    FOR I(1) = 1 to 100

    NEXT

Il n'est pas autorisé en Rapid-Q. Pourquoi? Parce que I(1) est une variable tableau et que seules les variables simples, quel que soit leur type, sont acceptées. Dans ce cas, vous recevrez donc un message d'erreur du compilateur. L'incrément par défaut d'une boucle FOR…NEXT est 1. Si vous voulez utiliser un autre incrément, utilisez la commande STEP :

    FOR I = 1 TO 100 STEP 2

      PRINT I

    NEXT

La variable I ne prendra ici que des valeurs impaires : 1 3 5 7 9 …etc. Si vous souhaitez quitter une boucle en cours d'exécution, utilisez la commande EXIT FOR.

La boucle WHILE .. WEND

Si vous souhaitez tester une condition avant d'entrer dans une boucle, vous pouver alors utiliser la boucle WHILE…WEND. Il n'y a rien de particulier à ajouter sur cette boucle qui se comporte exactement comme dans Qbasic.

    WHILE I < 100

      I++          '-- Incrémente I

    WEND

Cela ressemble beaucoup à une boucle DO…LOOP à la différence qu'une expression est testée et conditionne l'entrée dans la boucle. Pour sortir de la boucle WHILE…WEND, utilisez la commande EXIT WHILE

La boucle DO .. LOOP

C'est une simple boucle sans aucun test qui peut s'exécuter indéfiniment :

    DO

      PRINT " Hello World! "

    LOOP

Pour sortir d'une boucle DO…LOOP, utilisez la commande EXIT DO. Les boucles infinies ne sont pas souvent utilisées sous Windows (bien que basé sur la gestion d'événements). Vos tests seront plus pratiques à utiliser dans une boucle WHILE…WEND, sauf dans le cas suivant :

    DO

      I++

    LOOP UNTIL I >= 100

A la différence de QBASIC ou d'autres versions de Basic, Rapid-Q ne propose pas le test DO WHILE ou LOOP WHILE qui n'ont d'autre utilité que d'augmenter inutilement le nombre d'options pour un même résultat. Par exemple, ceci est valide en QBasic :

   DO

   LOOP WHILE I < 100

Qui est équivalent à :

   DO

   LOOP UNTIL I >= 100

Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - METHODES
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - INTRODUCTION AUX METHODES

Introduction aux Méthodes

Bien que le mot "Méthode" ait de nombreuses définitions, c'est celui que j'ai employé pour définir les méthodes CONSTRUCTOR, CREATE et WITH. Utilisées seules, elles n'ont aucune utilité, vous allez donc apprendre à quoi elles servent et comment les utiliser.

CREATE .. END CREATE

L'utilisation de CREATE est exactement identique à celle de DIM.

    CREATE Fenetre AS QForm

    END CREATE

ou

    DIM Fenetre AS QForm

Cependant, la méthode CREATE vous offre bien plus. Elle vous économise de la frappe et rend votre code plus clair par l'imbrication de plusieurs CREATE. Tout le code saisi à l'intérieur de la méthode CREATE … END CREATE est automatiquement lié à l'objet créé. Le meilleur moyen de comprendre l'intérêt de cette méthode est d'étudier les exemples du Chapitre 5

WITH .. END WITH

La méthode WITH offre au programmeur un moyen plus facile de référencer les propriétés, méthodes et événementse de certains objets et permet d'économiser de la saisie :

    Form.Caption = "Hello"

    Form.ShowModal

    Avec WITH

    WITH Form

       .Caption = "Hello"

       .ShowModal

    END WITH

Vous pouvez également imbriquer des commandes WITH .. END WITH :

    Something.Another.Caption = "Hello"

Avec WITH

    WITH Something

       WITH Another

         .Caption = "Hello"

       END WITH

    END WITH

Dans cet exemple, la commande WITH imbriquée hérite de la déclaration précedente. Le point, au début de la déclaration, indique au compilateur d'imbriquer cette variable dans la déclaration WIITH de niveau supérieur. Tout ce qui ne commence pas par un point ne sera pas imbriqué, y compris, bien sûr, les nombres décimaux.

CONSTRUCTOR .. END CONSTRUCTOR

Cette méthode n'est utilisée qu'à l'intérieur d'une déclaration TYPE, lorsque vous défissez votre propre objet. Elle fournira les valeurs par défaut aux propriétés de votre composant dès que celui-ci sera créé (par DIM).

    TYPE NewObject EXTENDS QObject

      Left AS INTEGER

      CONSTRUCTOR

        Left = 50

      END CONSTRUCTOR

    END TYPE

Rien de plus, si ce n'est que cette méthode s'apparente à CREATE à la différence que votre objet est un objet personnalisé..

Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - Procedures
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - INTRODUCTION AUX PROCEDURES

Introduction aux  Procedures

En Basic-Q, une procédure peut être soit une FUNCTION, soit une SUB (ou une FUNCTIONI ou SUBI). Le principe est le même que pour GOSUB et RETURN, mais introduit en plus les concepts de paramètres et de valeurs de retour. A la différence de Qbasic, une FUNCTION peut être appelée de la même manière qu'une SUB, il vous suffit d'ignorer sa valeur de retour.

    DECLARE SUB

Utilisez DECLARE SUB à chaque fois que votre SUB est placée dans le programme après son appel.

    DECLARE SUB Test

    CALL Test

    SUB Test

      '' Do Stuff

    END SUB

L'utilisation de CALL pour appeler votre routine n'est pas obligatoire. Comme vous pouvez le voir, nous appelons une SUB placée plus loin dans le programme. Si cette SUB avait été placé avant la ligne d'appel nous aurions pu nous passer de DECLARE SUB :

    SUB Test

    END SUB

    Test

Dans ce cas, nous n'vons pas besoin de DECLARE SUB. Notez que les noms de paramètres de DECLARE SUB et ceux de votre SUB doivent être exactement identiques. Pour être sûr de bien comprendre, étudiez cet exemple :

    DECLARE SUB Test (A AS INTEGER, B AS INTEGER)

    SUB Test (X AS INTEGER, Y AS INTEGER)

       PRINT X;" ";Y

    END SUB

Ce qu'il ne faut pas faire! Changer les noms de variables, car celles-ci sont définitivement fixées quand vous définisser DECLARE SUB. Dans ce cas, A et B sont fixés, ce qui vous évite de les répéter dans la création de la SUB, comme ceci :

    DECLARE SUB Test (A AS INTEGER, B AS INTEGER)

    SUB Test

       PRINT A;" ";B

    END SUB

Cet exemple est valide à la condition que vous ayez préalablement déclaré votre routine avec les paramètres A et B. Vous n'avez dons pas à déclarer les paramètres de votre SUB si ceux-ci ont déjà été déclarés avant. Cette méthode n'est cependant pas recommandée car elle nuit à la lisibilité de votre programme.

Différences entre FUNCTIONs et SUBs

La seule différence entre une FUNCTION et une SUB est que la FUNCTION retourne une valeur.

   FUNCTION Test AS INTEGER

     Test = 123

     Result = 123

   END FUNCTION

   Rval% = Test

Notre FUNCTION Test retourne une valeur de type INTEGER dont la valeur est 123. Pour retourner une valeur, vous pouvez utiliser le nom de la fonction ou utiliser le mot-clé Result. Même si vous avez intégré une valeur de retour à votre fonction, celle-ci ne se terminera pas tant qu'elle n'aura pas rencontré END FUNCTION. Vous pouvez donc assigner autant de valeurs de retour que vous le souhaitez à l'intérieur d'une fonction. La dernière valeur assignée sera toujours celle qui est liée à son nom. Pour sortir d'une FUNCTION ou SUB avant la fin de son exécution, utiliser les commandes EXIT FUNCTION ou EXIT SUB. Il existe une limitation aux SUBs et FUNCTIONs de Rapid-Q : vous ne pouvez passer, au plus, que 10 paramètres. Seuls les types simples, les QObjects et les tableaux peuvent être passés, mais pas les TDUs (Types Définis par l' Utilisateur). Les QObjects et les tableaux sont passés par référence, les autres variables sont passées par valeur. Les piles STACK.INT et STACK.STR sont des tableaux (contenant 10 éléments), STACK.INT(0) fournissant la première valeur.

SUBI et FUNCTIONI

Un chapitre complet est consacré à ces deux types de procédures. Elles ne ne sont pas très compliquées et pratiques à utiliser. Elles permettent au programmeur de passer un nombre infini de paramètres sans vérification du type. Seuls, les types simples peuvent être passés (nombres et chaînes de caractères), à l'exception des TDU, tableaux et Qobjects.

Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - Variables Internes
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - VARIABLES INTERNES

Variables internes

Les variables internes sont en lecture seule (sauf SCREEN.CURSOR). Quand je fais référence à Unix, je comprends Linux et Unix

Variable	Support	Type	Description
Application.Handle	Windows	ENTIER	Retourne le numéro de votre application. Utile pour les appels API qui le réclament.
CommandCount	Windows Unix	ENTIER	Nombre de paramètres reçus de la ligne de commande.
Command$()	Windows Unix	TABLEAU	Tableau des commandes reçues (séparées par un espace) par la ligne de commande.
CurDir$	Windows Unix	ENTIER	Retourne le répertoire en cours de votre application.
IsConsole	Windows Unix	ENTIER	Retourne une valeur différente de Zéro s'il s'agit d'une application Console, 1 sinon.
MouseX	Windows	ENTIER	Retourne la coordonnée X du pointeur de la souris, relative à la fenêtre active.
MouseY	Windows	ENTIER	Retourne la coordonnée Y du pointeur de la souris, relative à la fenêtre active.
ParamStrCount	Windows Unix	ENTIER	Retourne le nombre de paramètres Chaîne reçus. La variable sera uniquement utilisée dans une SUBI ou FUNCTIONI.
ParamStr$()	Windows Unix	TABLEAU	Retourne la valeur des paramètres Chaîne. Le premier élément démarre à 0 . Uniquement utilisée dans une SUBI ou FUNCTIONI.
ParamVal()	Windows Unix	TABLEAU	Retourne la valeur des paramètres numériques. Le premier élément démarre à 0 . Uniquement utilisée dans une SUBI ou FUNCTIONI
ParamValCount	Windows Unix	ENTIER	Retourne le nombre de paramètres numériques reçus. La variable sera uniquement utilisée dans une SUBI ou FUNCTIONI.
Screen.ConsoleX	Windows Unix	ENTIER	Retourne le nombre maximum de colonnes du mode Console. Utile sous Unix.
Screen.ConsoleY	Windows Unix	ENTIER	Retourne le nombre maximum de lignes du mode Console. Utile sous Unix.
Screen.Cursor	Windows	ENTIER	Change le pointeur de souris
Screen.Height	Windows	ENTIER	Retourne la hauteur de l'écran Windows (Ne pas confondre avec Form Height)
Screen.Width	Windows	ENTIER	Retourne la largeur de l'écran Windows
Stack.Int()	Windows Unix	TABLEAU	Retourne la pile courante des paramètres entiers. Le premier élément démarre à 0.
Stack.Str()	Windows Unix	TABLEAU	Retourne la pile courante des paramètres chaînes. Le premier élément démarre à 0.
Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - MotsClé Console
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - MOTS-CLE DU MODE CONSOLE

Mots-Clé du mode console

A noter qu'il est possible d'utiliser certains mots-clé du mode Console sous Linux/Unix, même si vous compilez votre programme en mode GUI. Cela n'est cependant pas possible sous Windows. Les mots-clé utilisables sous Linux/Unix sans devoir utiliser le mode Console sont les suivants : CLS, PRINT, et INPUT. SLEEP peut également être utilisé sans problèmes.

Mots-Clé	Support	Description de l'utilisation.
CLS	Windows Unix	Efface l'écran Console
COLOR	Windows Unix	COLOR [Texte%][, Fond%] fixe les attributs de couleurs. Vous pouvez ignorer l'un des deux paramètres.
CSRLIN	Windows Unix	CurseurLigne% = CSRLIN Retourne le numéro de ligne où se trouve le curseur
INKEY$	Windows Unix	A$ = INKEY$ Retourne le code ASCII du caractère tapé
INPUT	Windows Unix	INPUT A$ Attend l'entrée d'une ligne de texte par l'utilisateur
LOCATE	Windows Unix	LOCATE [Y%][, X%] Déplace le curseur en Y%, X% (le coin supérieur gauche démarre en 1,1). Vous pouver n'utiliser qu'un des deux paramètres
PCOPY	Windows	PCOPY Source, Dest Copie une page écran depuis Source vers Dest. La page visible est la page 0. 7 pages écran sont disponibles.
PEEK	Windows	A% = PEEK([#NumPage,] Addresse) Retourne la valeur et les attributs de couleur d'un caractère situé à Adresse.
POKE	Windows	POKE [#NumPagee,] Addresse, Change la valeur ou les attributs d'un caractère situé à Adresse.
POS(0)	Windows Unix	CurPos% = POS(0) Retourne la valeur ASCII d'un caractère tapé au clavier.
PRINT	Windows Unix	PRINT [#NumPage[;|,]][stuff][;|,][...] Ecrit vers le périphérique standard de sortie (console). Pour écrire dans d'autres pages écran, utilisez #NumPage (valeurs 1 à 7). Ne fonctionne que sous Windows.
SETCONSOLETITLE	Windows	SetConsoleTitle(Titre$) Donne un titre à la fenêtre console.
SLEEP	Windows Unix	SLEEP nDelai pour n secondes. Peut être un fraction de seconde.
Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - MotsCle Réserves
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - MOTS-CLE RESERVES

Mots-Clé réservés

Ces mots-Clé ont, dans leur majorité, les mêmes caractéristiques qu'en Qbasic. Cette liste n'est donc qu'un rappel que vous pourrez consuter facilement et rapidement. A nouveau, quand je me réfère à Unix, je comprends Unix et Linux.

Mots-Clé	Support	Description / Utilisation
ABS	Windows Unix	ABS(ExpressionNumerique) Retourne la valeur absolue d'un nombre
ASC	Windows Unix	ASC(Car$) Retourne la valeur ASCII de Car$
Application.Terminate	Windows	Application.Terminate Termine votre application GUI
ATN	Windows Unix	ATN(ExpressionNumerique) Retourne l'Arc-Tangente de l'expression numérique
BIND	Windows Unix	BIND Num TO MaFonct  Lie une fonction à un pointeur
CALLFUNC	Windows Unix	CALLFUNC(Num, Param1, Param2, ...) Appelle un pointeur de fonction
CHDIR	Windows Unix	CHDIR Chemin$ Change de répertoire
CHR$	Windows Unix	CHR$(Octet) Retourne le caractère correspondant à la valeur ASCII Octet
CLNG	Windows Unix	CLNG(Expression numérique) Pour des raisons de compatibilité, utilisez plutôt ROUND.
CONST	Windows Unix	CONST Variable = ValeurDefinitive  Déclare une valeur constante
COS	Windows Unix	COS(ExpressionNumerique) Retourne le cosinus d'un angle donné en radians
DATE$	Windows Unix	DATE$ Retourne la date courante sous la forme JJ-MM-AAAA
DEC	Windows Unix	DEC(Variable [, DecVal]) Décremente une variable de 1, sauf si une autre valeur est spécifiée
DELETE$	Windows	DELETE$(S$, Index, NombreCar) Efface NombreCar caractères d'une chaîne S$, à partir du caractère Index
DIM	Windows Unix	DIM Variable AS DataType Initialise une variable de type DataType
DIREXISTS	Windows	DIREXISTS(Path$) Retourne 0 si le répertoire n'existe pas, une autre valeur dans le cas contraire
DOEVENTS	Windows	DOEVENTS Teste des événements. Utile quand vous êtes dans une longue boucle
END	Windows Unix	END Indique la fin d'un programme exécuté dans le mode Console. N'a aucun effet en mode GUI
EXP	Windows Unix	EXP(ExpressionNumerique) Calcule la fonction exponentielle de ExpressionNumerique
FILEEXISTS	Windows Unix	FILEEXISTS(NomFichier$)  Retourne 0 si le fichier n'existe pas, une autre valeur dans le cas contraire
HEX$	Windows	HEX$(ExpressionNumerique) Retourne la représentation HEXAdécimale sous forme de chaîne de ExpressionNumerique
INC	Windows Unix	INC(Variable [, DecVal]) Incrémente une variable de 1, sauf si une autre valeur est spécifiée
INSERT$	Windows	INSERT$(Source$, S$, Index) Insère la chaîne Source$ dans la chaine S$ à partir de l'index Index
INSTR	Windows Unix	INSTR([Debut,] ChaineCherchee, Chaine) Retourne la position de ChaineCherchee si elle a été trouvée dans Chaine, sinon retourne 0
INT	Windows Unix	INT(ExpressionNumerique) Convertit une valeur numérique en un entier 32 bits de type INTEGER et supprime les décimales.
KILL	Windows Unix	KILL NomFichier$ Efface le fichier NomFichier$
LCASE$	Windows Unix	LCASE$(Chaîne$) Les caractères de Chaine$ sont transformés en minuscules
LEFT$	Windows Unix	LEFT$(Chaine$, N) Retourne les N caractères de gauche de la chaîne
LEN	Windows Unix	LEN(Chaîne$) Retourne la longueur de Chaine$
LOG	Windows Unix	LOG(ExpressionNumerique) Retourne le logarithme naturel de ExpressionNumérique
LBOUND	Windows Unix	LBOUND(NomTableau[, Dimension])  Retourne la limite inférieure d'un tableau (La dimension démarre à 1)
LTRIM$	Windows Unix	LTRIM$(Chaine$) Retourne un chaîne où tous les espaces de gauche de Chaine$ ont été supprimés
MESSAGEDLG	Windows	MESSAGEDLG(Msg$, MsgType, MsgBoutons, HelpContext) Affiche une boîte de message. Voir RAPIDQ.INC pour les types et boutons appropriés.
MID$	Windows Unix	MID$(Chaine$, I, N) Retourne une chaîne extraite de chaîne$, depuis le caractère I, de longueur N
MKDIR	Windows Unix	MKDIR Dir$ Crée un nouveau répertoire
PLAYWAV	Windows	PLAYWAV NomFichier$, SndOption Joue un fichier WAV. Voir RAPIDQ.INC pour les options sndOptions
POSTMESSAGE	Windows	POSTMESSAGE(Handle, uMsg, wParam, lParam) Envoie un message vers une application sans interrompre l'application en cours. Voir votre guide préféré des API Windows pour plus d'informations
RANDOMIZE	Windows Unix	RANDOMIZE [Num] Utilisez randomize pour réinitialiser le générateur de nombres aléatoires
RENAME	Windows Unix	RENAME Fichier1$, Fichier2$ Renome Fichier1$ en Fichier2$
REPLACE$	Windows	REPLACE$(S$, R$, Index) Remplace une partie de la chaîne S$ par la chaîne R$ à partir du caractère Index
RIGHT$	Windows Unix	RIGHT$(Chaine$, N) Retourne les N caractères de droite de Chaine$
RMDIR	Windows Unix	RMDIR Rep$ Efface le répertoire Rep$
RND	Windows Unix	RND(ValeurMaxi) Retourne un nombre aléatoire. Si ValeurMaxi n'est pas spécifié, retourne un nombre décimal. Utilisez RANDOMIZE pour réinitialiser le générateur
ROUND	Windows Unix	ROUND(ExpressionNumerique) Arrondit une valeur à l'entier le plus proche
RTRIM$	Windows Unix	RTRIM$(Chaine$) Retourne un chaîne où tous les espaces de droite de Chaine$ ont été supprimés
RUN	Windows Unix	RUN command$ Exécute une commande sans créer d'interruption
SENDMESSAGE	Windows	SENDMESSAGE(Handle, uMsg, wParam, lParam) Envoie un message vers une application interrompt l'application en cours. Voir votre guide préféré des API Windows pour plus d'informations
SHELL	Windows Unix	SHELL command$ Execute une autre application ou commande et interrompt l'application jusqu'à la fin de la commande.
SHOWMESSAGE	Windows Unix	SHOWMESSAGE msg$ Affiche un message dans une boîte simple
SIN	Windows Unix	SIN(ExprNumerique)Retourne le sinus d'un angle donné en radians
SPACE$	Windows Unix	SPACE$(Num) Retourne une chaîne composée de Num espaces
SQR	Windows Unix	SQR(ExprNumerique) Retourne la racine carrée de ExprNumerique. Assurez-vous que l'expression n'est pas négative.
STR$	Windows Unix	STR$(ExprNumerique) Retourne une chaîne équivalente à l'expression numérique.
STRING$	Windows Unix	STRING$(m, n) or STRING$(m, Car$) Retourne une chaîne composée de m fois le caractère n ou car$
SWAP	Windows Unix	SWAP A, B Echange les valeurs de A et B, soit A=B, B=A
TAN	Windows Unix	TAN(ExprNumerique) Retourne la tangente d'un angle exprimé en radians
TIME$	Windows Unix	TIME$ Retourne l'heure courante sous la forme HH:MM:SS
TIMER	Windows Unix	T! = TIMER Retourne la valeur courante du TIMER
UBOUND	Windows Unix	UBOUND(NomTableau[, Dimension]) Retourne la limite supérieure du tableau (La dimension commence à 1)
UCASE$	Windows Unix	UCASE$(StringExpression) Les caractères de Chaine$ sont transformés en majuscules
VAL	Windows Unix	VAL(Chaine$) Retourne l'expression numérique la plus proche de chaîne
Chapitre précédent	Annexes	Sommaire	Chapitre suivant


Appendice C - Corriger vos programmes
Documentation de Rapid-Q par William Yu (c)1999

Annexe C - COMMENT CORRIGER VOS PROGRAMMES

Comment corriger vos programmes

Les erreurs les plus courantes sont, soit des erreurs de frappe, soit des tentatives d'utiliser des fonctions qui ne sont pas supportées par Rapid-Q. Cela arrive souvent quand vous n'utilisez pas l'option $TYPECHECK ON. Pour éviter tout stress inutile, j'encourage toute personne qui n'a pas acquis une bonne expérience dans la programmation de Rapid-Q à utiliser cette directive. Rapid-Q dispose d'un système de vérification très rudimentaire. Il est donc nécessaire que vous, le programmeur, ayez le souci constant d'écrire du code propre. Un exemple :

    PRINT SPC(10)

SPC n'est pa supporté par Rapid-Q (en Qbasic, SPC ajoute simplement des espaces). Si TYPECHECK est positionné sur OFF (ou omis), le code ci-dessus est parfaitement valide. SPC sera alors une variable initialisée à 0 et le (10) n'aura aucun effet (le nombre 10 sera placé dans la pile, mais ne subira aucun traitement). Cette ligne affichera donc un 0.

Passage des paramètres par référence

Seuls les QObjects et les tableaux sont passés par référence, toutes les autres variables sont passées par valeur. Si vous n'êtes pas accoutumé à ces notions, relisez le chapitre 3.5 et l'appendice C consacrés aux procédures. La vérification du type n'est effectuée que pour les tableaux et les QObjects. Comme vous ne pouvez pas passer un tableau d'INTEGERs à une SUB qui attend un tableau de DOUBLEs, vous recevrez alors un message d'erreur. Pour toutes les autres variables passées par valeur, AUCUNE vérification n'est effectuée. Cela veut dire que vous pouvez passer allègrement un INTEGER à une SUB qui attent une Chaîne. Vous devrez donc faire attention de bien connaître les types de paramètres acceptées par vos SUB/FUNCTIONS, car Rapid-Q ne vous signalera aucune erreur. Si vous avez des DECLARE SUBs, vérifiez également que les paramètres déclarés dans vos SUBs sont bien équivalents dans leurs types et dans leurs noms.

Utilisation de caractéristiques non documentées

Rapid-Q possède quelques caractéristiques non documentées. La majorité d'entre elles sont encore à l'état de test. Vous pouvez, par exemple, imbriquer des SUBs ou FUNCTIONs, mais avec un seul niveau d'imbrication et avec quelques particularités dans leur utilisation. Si vous voulez savoir à quoi ressemble une SUB imbriquée, regardez cet exemple :

    SUB MaSub

      DIM I AS INTEGER

      SUB MaSubImbriquee (X AS INTEGER)

        DIM N AS DOUBLE

        PRINT "Nous sommes dans une SUB imbriquée"

      END SUB

      CALL MaSubImbriquee(100)

    END SUB

Cet exemple mérite plusieurs commentaires, comme la gestion des variables locales à une SUB imbriquée. En clair, cela veut dire que la variable I est également locale à la SUB MaSubImbriquee. Comme Rapid-Q ne fait pas encore parfaitement le ménage dans ses variables, vous pouvez actuellement appeler la SUB imbriquée directement depuis votre programme principal. C'est une curiosité que je corrigerai quand j'en aurai le temps. Une autre caractéristique peut en interesser certains, il s'agit des suffixes ++ et -- :

    DIM I AS INTEGER

    I++           '-- identique à I = I + 1

    I--           '-- identique à I = I - 1

    I -= 10       '-- identique à DEC(I, 10)

    I += 15       '-- identique à INC(I, 15)

Toutes les variables peuvent ainsi être incrémentées / décrémentées sauf les tableaux qui constituent un cas à part. Rapid-Q n'effectue aucune optimisation de ces routines. La vitesse d'exécution est donc exactement la même pour les deux méthodes.

Les autres erreurs

Si vous n'avez aucune information sur la raison qui provoque la plantage de votre programme, votre seul espoir est d'insérer différentes commandes PRINT dans chaque bloc de votre programme et de les tester successivement pour procéder par élimination. Si vous utilisez Unix ou Linux, essayez d'utiliser gdb qui pourra quelquefois vous fournir quelques informations utiles, bien qu'il ne soit pas d'un grand secours dans le cas de Rapid-Q. Sous Unix/Linux, vos chaînes ne devront pas excéder 32000 caractères. Je n'ai pas dit qu'elles ne pouvaient pas excéder cette limite, mais dans ce cas, votre programme peut devenir instable. La longueur optimum se situe autour de 4 Ko., qui représente la valeur la plus stable pour Rapid-Q. Dans la version Windows, vos longueurs de chaînes sont illimitées et vous n'avez aucune inquiétude à vous faire à ce sujet.

Chapitre précédent	Annexes	Sommaire


About Help Express 3

This help file was made using an unregistered version of Help Express. If you register it, this window and the text that linked to this will disappear.

Please visit http://www.chainware.com for additional product information and pricings and other software.

Help Express © 1999-2000 Chainware, Sander van de Merwe (vandemerwe@caiw.nl), Pascal Krijnberg (pkrijnb@kabelfoon.nl), former Soft4All.