Visual foxpro : présentation générale

Commenter

Contenu du snippet

Pour les développeurs venant d'autres langages et souhaitant découvrir Visual FoxPro, cet article tente d'en tracer les grandes lignes :
SYNTAXE DU LANGAGE
ENVIRONNEMENT DE DÉVELOPPEMENT ET D'EXECUTION
DONNÉES (Tables, Base de données, Vues locales et distantes)
CLASSES
ECRANS
ETATS
PROJET ET DÉPLOIEMENT
Il ne s'agit pas de code mais d'un texte en Français courant (j'espère)

Source / Exemple : 


Visual FoxPro : un aperçu général

Tout ce qui suit s'applique à VFP 7+
L'aide VFP citée ci-après est accessible en ligne dans la 'MSDN library'
http://msdn.microsoft.com/library/en-us/dv_foxhelp/html/vfp7startpage.asp
(merci de me signaler les liens obsolètes dans vos commentaires)

=============================================
SYNTAXE DU LANGAGE
=============================================

Dans l'aide VFP7, le chapitre "Visual FoxPro and Other Programming Languages" compare VFP à VB, C/C++, Pascal sur les thèmes  suivants :
http://msdn.microsoft.com/library/en-us/dv_foxhelp/html/refVisual_FoxPro_and_Other_Programming_Languages.asp

  Whether the language is case-sensitive
  How variables are declared
  How to insert comments in programs
  How to store values to variables
  The structure of IF statements
  The structure of CASE statements
  The structure of FOR loops
  The structure of WHILE loops
  How parameters are passed by value 
  How parameters are passed by reference

Petit complément utile sur la déclaration des variables :
VFP résoud les noms des variables à l'exécution et maintient une liste des variables "visibles" :

  Déclarée par LOCAL / LPARAMETER, elle n'est visible que dans le module de déclaration
  Non déclarée ou créée par PARAMETER, la variable est visible dans les modules appelés
  Déclarée par PUBLIC, elle est visible dans les modules appelés et appelant

=============================================
ENVIRONNEMENT DE DÉVELOPPEMENT (IDE)
=============================================

L'IDE VFP est très comparable à celui de VB :

  coloration de syntaxe,
  intellisense y compris sur objets COM
  fenêtres 'ancrables'
  gestionnaire de projet arborescent
  débogueur avec trace, call, watch, locals, points d'arrêts par clic
  liste de tâches
  intégration avec Visual Source Safe (icônes dans le gestionnaire de projet indiquant l'état de chaque document)
  mémorisation de la taille, position, présentation des fenêtres

Quelques particularités de VFP :

  l'intellisense est adaptable ; on peut par exemple y introduire ses propres fonctions et procédures (intellisense manager)
  la fenêtre Document View présente un sommaire complet des modules existant dans un fichier programme, une classe ou un écran (plus rapide que les combo box de la fenêtre code)
  la FAMEUSE Fenêtre de commande VFP :

	 toute commande ou groupe de commandes peut y être exécutée pour test avant intégration dans un programme en sélectionnant et en pressant la touche Enter
 	 intellisense complet
	 la plupart des commandes interactives y sont en écho

=============================================
DONNÉES - 1. TABLE
=============================================

VFP comporte un système de gestion de données propre, natif, et permet d'accéder en client / serveur aux bases de données compatibles ODBC (SQL Server, Oracle, etc.).
VFP permet de prototyper/démarrer une application sur une base de données VFP et, si nécessaire, la transférer sur une base SQL sans changer le code de l'interface utilisateur.
Signalons que la licence de développement VFP autorise une redistribution illimitée du code et du moteur de base de données VFP.

Création - Modification d'une table VFP
-------------------------------------------
Une table VFP (MaTable.dbf) peut comporter jusqu'à 255 champs et 1 milliard d'enregistrements. Chaque champ peut revêtir un des 12 types correspondants aux standards SQL.
On peut associer à une table un fichier d'indexes (MaTable.cdx) comportant des clés (tags) d'indexes en nombre illimité.
Une clé d'index peut être créée sur n'importe quelle expression pourvu que tous ses membres (champs, variables, fonctions) soient accessibles à l'ouverture de la table (sinon, avertissement).

Une table peut être créée / modifiée :

  interactivement : File - New|Open - Table
  par programmation : CREATE TABLE ..., ALTER TABLE ..., INDEX ON ...

Ouverture d'une table VFP
-----------------------------------
Les tables sont ouvertes (USE ...) dans une zone de travail (1,2, ...A, ...) d'une session de données, avec un ALIAS (par défaut la racine du nom du fichier).

La même table peut être ouverte plusieurs fois sous des alias différents (USE AGAIN ... ALIAS ...) dans une même session de données.
On peut ouvrir autant de sessions de données que nécessaire, chaque écran peut avoir sa session de données propre.
Une session de données peut être enregistrée dans un fichier et rétablie à partir de celui-ci (CREATE VIEW ...)

La fenêtre "session de données" (bouton sur barre d'outils) présente les aliases ouverts dans chaque sesssion, et les relations entre eux
On peut 'régler' un alias en lui assignant (bouton 'properties' de la fenêtre de session de données) :

  une clé d'index parmi celles contenues dans le CDX associé, qui ordonne les enregistrements
  un filtre de champs
  un filtre d'enregistrements
  une ou plusieurs relations

Les différents alias d'une même table ouverts dans une même session sont indépendants : position, index et filtre(s) actifs, relation(s)
On peut voir le contenu de l'Alias dans une grille en cliquant sur le bouton Browse de la fenêtre de session de données. 
Le format de la fenêtre Browse est entièrement paramétrable.

Accès aux données des tables
-----------------------------------
VFP offre deux méthodes d'accès aux tables : commandes VFP et SQL

Accès aux données par commandes natives VFP
--------------------------------------------
(Tout ce qui suit travaille sur l'ALIAS tel que défini ci-dessus)
PRINCIPES GÉNÉRAUX
La plupart des commandes peuvent travailler :

  sur l'alias couramment sélectionné
  sur un alias non sélectionné au moyen de la clause [IN Alias]

Les commandes acceptent 2 clauses de sélection des enregistrement :

  Clause d'étendue : tous, suivants, etc.
  Clause de Filtre : FOR  ou WHILE

APERÇU DES COMMANDES 

  Filtrer un alias : SET FILTER TO ... [IN Alias]
  Synchroniser deux aliases : SET RELATION TO ... INTO AliasFils ... [IN AliasPère] - l'alias père peut être en relation avec plusieurs fils.
  Sélectionner un alias : SELECT Alias
  Atteindre un enregistrement :

  Accès séquentiel : SCAN ... ENDSCAN (parcourt l'alias sélectionné)
  Accès direct :

      par le n° d'enr. GO ... [IN Alias]
      par recherche sur l'index actif : SEEK ... [IN Alias], SEEK(Valeur, Alias)
      par recherche  sur le contenu d'un ou plusieurs champs : LOCATE ...
  

	Mettre à jour le contenu d'un ou plusieurs enr. : REPLACE ... [IN Alias]
  Ajouter un/des enr. : APPEND ... [IN Alias]
  Extraire un/des enregistrements : COPY TO...
  Importer un/des enregistrements : APPEND FROM, IMPORT
  Supprimer un/des enr. : DELETE...[IN Alias]  /!\ Cette commande marque l'enr. pour suppression au moyen d'un sémaphore. Elle ne le supprime pas physiquement. Un réglage de VFP permet de "voir" ou "ignorer" les enregistrements "deletés" (SET DELETED ON/OFF)
  Rappeler un/des enr. supprimés : RECALL ...[IN Alias]
  Supprimer physiquement les enregistrements supprimés : PACK /!\ nécessite un accès exclusif à la table (un seul alias ouvert en exclusif)

Accès aux données par commandes SQL
-----------------------------------
Commandes SQL 92 classiques ... (cf. SQL Commands Overview dans l'aide VFP):

  Extraction : SELECT ...
  Mise à jour  du contenu de l'enr. : UPDATE ...
  Suppression de l'enr. : DELETE FROM (commentaire idem VFP)
  Ajout d'enr. : INSERT ...
  Importation : SELECT depuis les deux tables vers une troisième

Optimisation Rushmore
---------------------
Pour trouver plus rapidement le(s) enregistrement(s) répondant à une clause FOR (VFP) ou WHERE (SQL), VFP exploite les clés (tags) d'index.
Si l'expression suivant la clause FOR ou WHERE correspond à une ou plusieurs clés d'indexes, VFP exploite la technologie Rushmore.
L'optimisation Rushmore s'applique aussi bien aux commandes natives VFP qu'aux commandes SQL.
VFP optimise les requêtes SQL automatiquement (création d'indexes temporaires si approprié)

=============================================
DONNÉES - 2. BASE DE DONNÉES
=============================================
/!\ en construction

=============================================
DONNÉES - 3. VUES
=============================================
/!\ en construction

=============================================
CLASSES
=============================================

VFP permet de créer / modifier des classes à partir des classes de base par :

  DESIGNER Class library ...
  PROGRAMME pour toutes les classes, visuelles ou non : DEFINE CLASS ... AS ...

Le Designer est préférable pour les classes entrant dans l'aspect des écrans car il ne peut mettre en page les classes programmées. Il supporte pleinement l'intellisense.
La Définition par programme est plus souple, notamment pour renommer les Propriétés et Méthodes.
Chaque mode de création de classes (par programme / designer) a ses avantages et ses inconvénients récapitulés ici (en anglais) : http://fox.wikis.com/wc.dll?Wiki~PRGvsVCX

Aperçu des classes de base 
(il peut manquer les plus récentes ...)

Classes pouvant être sous-classées visuellement :

	Classes "visibles" à l'écran, à créer de préférence par Designer (contrôles)

		CheckBox
		ComboBox
		CommandGroup - conteneur (groupe de boutons)
		CommandButton
		Container - conteneur (peut contenir tout autre classe)
		EditBox
		FormSet - conteneur
		Form - conteneur
		Grid - conteneur
		-Grid Column - conteneur (visuelle à partir de VFP8)
		--Grid Column Header (visuelle à partir de VFP8)
		Hyperlink
		Image
		Label
		Line
		ListBox
		OLEControl
		OLEBoundControl
		OptionGroup - conteneur
		-OptionButton (visuellement à partir de VFP8)
		PageFrame - conteneur
		-Page - conteneur (visuelle à partir de VFP8)
		Spinner
		TextBox
		ToolBar

	Classes "non visibles" à l'écran

		Collection - conteneur
		Control - conteneur
		Custom - conteneur
		CursorAdapter
		DataEnvironment - conteneur
		-Cursor
		-Relation
		Empty
		ProjectHook
		ReportListener
		Timer
		XMLAdapter
		XMLField Class
		XMLTable Class
		ActiveDoc (obsolète)

Classes devant être sous-classées par programmation :

	Session
	Separator

Les classes signalées par [- conteneur] peuvent contenir d'autres classes :

	 La classe parent contient des propriétés controls et controlCount permettant d'accéder aux contrôles contenus
	 Les classes enfant référencent leur parent au moyen de la propriété Parent
	 Tout objet doit avoir un parent, l'ancêtre ultime étant _VFP lui-même

=============================================
 ECRAN (form)
=============================================

Un écran VFP est en fait une pseudo sous-classe de form :

	Sous-classe car on peut lui ajouter des propriétés et méthodes comme dans une classe ordinaire
	Pseudo car on ne peut le sous-classer

Un fichier d'écran porte l'extension SCX alors qu'une bibliothèque de classes visuelles porte l'extension VCX.
Il va de soi qu'on ne peut définir un écran par programmation, seulement par le Designer Visuel.
(Mais on peut définir une classe d'écran par programmation)

Un écran se dessine au moyen d'un form designer semblable au class designer.
Chaque objet peut être positionné par souris ou clavier, aligné ou centré sur une autre ou sur l'écran, dimensionné par souris ou clavier.
Les objets peuvent être alignés sur une grille magnétique à pas réglable.

Tout écran comporte nativement un objet environnement de données où il suffit de glisser-déplacer les tables ou les vues depuis la base de données.
Les relations figurant dans la base de données sont crées automatiquement.
L'environnement de données permet de régler le mode d'ouverture et de fermeture des curseurs, les relations et ordres de tri comme dans toute session de données (voir plus haut).
Pour ajouter à l'écran un contrôle lié (bound control) à un champ d'un curseur (table ou vue), il suffit de glisser-déplacer celui-ci depuis l'environnement de données jusqu'à l'endroit approprié de l'écran.
Bien entendu, tout ce que l'environnement de données fait automatiquement peut être modifié ou remplacé par une programmation de l'événement load() de l'écran.

Le modèle d'événement est assez riche pour répondre à la plupart des besoins :

	Vie de l'écran : Load(), Init(), Destroy(), Unload() - /!\ Load() et Init() sont inversés par rapport à VB
	Actions utilisateur : activate() / deactivate(), keypress(), MouseClick/Up/Down/MiddleClick/RightClick/Wheel/Move, etc.
	Drag and Drop : VFP (de-vers objets VFP) et OLE (de-vers objets ActiveX)

=============================================
 ETAT (report)
=============================================
/!\ en construction

=============================================
 ENVIRONNEMENT D'EXÉCUTION
=============================================
/!\ en construction

=============================================
 PROJET ET DÉPLOIEMENT
=============================================
/!\ en construction

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (AbaqueInside)