guide_fr

Guide complémentaire rapidq sur définition composants/objets.

UTILISATION DE FONCTIONS API WINDOW DANS UN TYPE OBJET.

PROPRIÉTÉ PARENT DE COMPOSANTS VISIBLE.

1) REDÉFINITION D'UN ÉVÉNEMENT HÉRITÉ.

Si un événement hérité est redéfini au sein d'un nouvel objet , son utilisation nécessite l'appel de l'événement avec le mot clé inherit dans la
routine attribué a cet événement comme indiqué dans la documentation d'origine.
Afin d'éviter l'utilisation de ce mot clé , qui peut être oublié lors de l'écriture d'un programme,on peut créer un événement
supplémentaire ayant la même fonction que celui qui est redéfini mais avec un nom diffèrent et appelé par l'événement redéfini.
De ce fait,les actions rajoutés dans l'événement redéfini seront exécutés sans avoir a rajouter l'appel de l'événement avec le mot clé inherit
dans la routine attribué a celui-ci.
Toutefois ,il n'est pas possible de masquer l'événement redéfini avec le mot clé Private dans la structure de l'objet pour l'utilisateur.
Dans l'exemple ci-dessous , l'événement OnClick hérité de l'objet QBUTTON est redéfini avec une action sur sa propriété Caption
avec un appel de routine associé au nouvel événement On_Click créé dans l'objet.

EXEMPLE:
$TYPECHECK ON
$Include "Rapidq.inc"

Declare Sub routine1
Declare Sub event_click

Type button extends QBUTTON
On_Click as EVENT(event_click)

          EVENT OnClick
            button.caption="check"
            if button.On_Click<>0 then CALLFUNC button.On_Click
          END EVENT
        End type

        CREATE Form AS QFORM
          Caption="Form1"
          Width=320
          Height=240
          Center
          CREATE Button1 AS button
           Caption="Button1"
           Left=34
           Top=41
           On_Click=routine1
         END CREATE
     END CREATE

Form.ShowModal

     sub routine1
      form.Caption = "check"
     end sub

2) UTILISATION DE FONCTIONS API WINDOW DANS UN TYPE OBJET.

Un objet utilisant des fonctions API peu appeler un fichier externe comportant la déclaration de toutes les fonctions API mais
cela augmenterait la taille du programme compilé au final.

La déclaration de fonctions API peut être inclus dans le fichier du composant objet ,mais comme plusieurs objet peuvent utiliser
des fonctions API commune ,il y a deux façon de procéder afin d'éviter une déclaration multiple pour une même fonction:

a) Utiliser les directives de compilation:
    $IFNDEF API_1
      $DEFINE API_1
      Declare Function GetDC Lib "user32" Alias "GetDC" (ByVal hwnd As Long) As Long
    $ENDIF

b) Utiliser des noms de fonction diffèrent pour la même fonction API:

Declare Function GetDC_ObjectName Lib "user32" Alias "GetDC" (ByVal hwnd As Long) As Long

l'exemple ci-dessus utilise le nom de l'objet en extension du nom de la fonction.
Les constantes nécessaires aux fonctions API peuvent être déclarés de la même manière.

3) PROPRIÉTÉ PARENT DE COMPOSANTS VISIBLE.

Un nouvel objet héritant d'un objet standard n'a pas besoin d'avoir sa propriété parent redéfini.
Par contre si l'on rajoute des composants visible en tant que nouveau champ de l'objet , il faudra effectuer l'affectation des propriétés
parent de chacun dans la routine constructor ou dans une méthode.

EXEMPLE:

   Type a extends QPanel
     bt as qbutton
     img as qimage

     constructor
       bt.parent=a
       img.parent=a
     end constructor
   end type

Si un nouvel objet est créé sans héritage et utilisant des fonctions API pour obtenir un composant visible , un champ parent doit être défini
dans celui-ci.
Ce champ parent doit être de type Long ou Integer et peut être défini comme propriété a l'aide des routines PROPERTY.
Cet objet pourra s'imbriquer dans une structure CREATE a condition d'effectuer l'affectation de la propriété parent par le handle de l'objet parent.

EXEMPLE:
Type a extends QObject
Parent as integer PROPERTY SET SetParent

    PROPERTY SET SetParent(parent as integer)
      a.Parent=parent
      'utilisation du handle parent pour une fonction API
    END PROPERTY
   end type

   CREATE Form as QFORM
     width=200
     height=100
     CREATE obj as a
       parent=form.handle
     END CREATE
   END CREATE

Form.ShowModal

Une autre méthode de définition existe mais ne permet pas l'imbrication avec CREATE , elle consiste a passer l'objet parent en paramètre
lors de la déclaration d'une variable de type objet personnalisé.
Le seul problème étant que l'on ne peut avoir que des objets d'un type unique identifié par le paramètre du type objet.
Dans l'exemple ci-dessous la propriété parent est initialisé dans la routine constructor de l'objet , de ce fait , il n'est pas nécessaire d'affecter
la propriété parent dans le programme puisque la variable Obj est déclaré avec la variable Form passé en paramètre.

EXEMPLE:

Type a<QFORM> extends QObject
parent as long

     constructor
       parent=QFORM.handle
     end constructor
   end type

   CREATE Form as QFORM
     width=200
     height=100
   END CREATE

dim obj as a<Form>

Form.ShowModal

4) PROTECTION DES CHAMPS D'OBJET

Si les champs d'un objet sont accessibles en lecture comme en écriture pour l'utilisateur , il est possible de limiter leur accès en lecture uniquement en les définissant en propriété.
Dans l'exemple ci-dessous , le champ parent est défini en propriété et peut être utilisé en lecture dans un programme.
lorsque l'utilisateur veut utilisé la propriété en écriture , le champ parent n'est pas modifié puisque son affectation n'est pas effectué dans
la routine PROPERTY et dans ce cas ,seules les méthodes de l'objet peuvent modifier l'état du champ parent.
On peut aussi mettre la routine PROPERTY en membre privé en ajoutant PRIVATE: avant celle-ci afin d'avoir une erreur de compilation si
tentative d'écriture du champ parent.

EXEMPLE:
Type a extends QObject
Parent as integer PROPERTY SET SetParent

   PRIVATE:
     PROPERTY SET SetParent(parent as integer)
     END PROPERTY
   end type

5) LIMITATIONS CONNUS.

a) l'héritage de composants personnalisé n'est pas supporté.

b) Certaines méthode redéfini d'un objet hérité nécessitent un ajout de paramètre afin d'éviter une erreur de compilation.
ceci est le cas pour les méthodes Show et ShowModal d'un objet QFORM comme le montre l'exemple ci-dessous.
EXEMPLE:

Type b extends qform

      sub Showmodal(title as string)
        b.caption =title
        Super.Showmodal
      end sub
    end type

    CREATE Form AS b
      Caption = "Rapid-Q Code Viewer"
      Width = 234
      Height = 251
      Center
      OnClick=show
    END CREATE

Form.ShowModal ("Check")

c) Si l'on utilise des variables locale de même nom dans les méthodes d'un objet personnalisé , l'objet ne peut pas être déclaré en variable
    locale d'une routine mais uniquement en global du programme.
    Ceci peut être résolu en ayant des variables locale de nom différents dans les méthodes d'un objet.
    De la même façon , deux objets ne peuvent pas avoir le même nom de variables locale dans leur méthodes si ils sont déclarés en variable
    locale d'une routine.
    La solution a ce dis fonctionnement sera de déclarer ces variables en champs privé de l'objet et de n'avoir aucune variables locale dans les
    méthodes de celui-ci.

d) Les composants personnalisé ne peuvent pas être passés en paramètres d'une routine.