Modification de Villes/Montluçon/sciences/FastGraph

== Introduction ==

===Qu'est-ce que Fastgraph?===

Fastgraph est une bibliothèque de plus de 275 routines hautement optimisées
sont appelable de haut niveau et des programmes de langues d'assemblage fonctionnant sous les systèmes d'exploitation MS-DOS ou PC-DOS. Cette collection de routines fournit un programmeur avec éprouvées, des outils puissants pour prendre le commandement du PC et PS / 2 environnement vidéo. En plus de son support vidéo, Fastgraph comprend également des routines pour effectuer le clavier, la souris, et le contrôle de la manette, ainsi que musique et de son capacités. Fastgraph est un outil de développement idéal pour le divertissement et les logiciels éducatifs, produits graphiques de présentation, les applications scientifiques et d'ingénierie, CAD / CAM, animation, ou toute autre application qui exige des graphiques robustes.

Comme son nom l'indique, la caractéristique la plus notable de Fastgraph est sa vitesse.
La quasi-totalité des Fastgraph est écrit en langage d'assemblage, et chaque routine a été optimisé à la main pour fournir une performance maximale. Les bibliothèques de mode protégé de Fastgraph tirer parti des fonctionnalités offertes par les jeux d'instructions 80286 et 80386.

Fastgraph supporte tous les modes de texte et de graphiques vidéo standard utilisés par
le PC IBM et les systèmes compatibles (PC, PC / XT, et PC / AT, 80386, 80486 et Pentium) et IBM PS / 2 famille. En outre, Fastgraph fournit un support pour six SuperVGA (SVGA) modes graphiques, quatre VGA étendu (XVGA) modes graphiques, et un mode graphique 16 couleurs unique pour Tandy 1000 ordinateurs de la série et la PCjr. Même si le mode de la carte graphique Hercules graphique est pas une norme IBM, sa popularité unique a fait un standard de facto, et pour cette raison Fastgraph soutient également. Au total, Fastgraph prend en charge 23 modes graphiques et 5 modes de texte. Une discussion complète de ces modes vidéo apparaît dans le chapitre suivant.


===Fastgraph / Light===

Fastgraph / Light est un sous-ensemble de Fastgraph. Il comprend l'ensemble des Fastgraph de
caractéristiques, sauf les routines de support de fichiers GIF, l'espace mondial redéfinissable système de coordonnées, et les routines relatives aux caractères de logiciels. Les programmes créés en utilisant Fastgraph / Light sont 100% code source compatible avec Fastgraph.

La différence la plus importante entre Fastgraph / Lumière et Fastgraph est
la méthode de l'exécution d'un programme créé avec les deux produits. Avec Fastgraph, l'une de ses routines utilisées dans votre programme sont liés directement dans le fichier EXE résultant. Avec Fastgraph / Lumière, cependant, ce n'est pas le cas. Au lieu de cela, les routines Fastgraph / lumière fournissent une interface à un pilote externe, appelé le pilote Fastgraph / Light Video, qui doit être chargé séparément avant d'exécuter des programmes qui appellent des routines Fastgraph / Lumière. Voir la dernière section de ce chapitre pour plus d'informations.

Une autre différence importante entre Fastgraph et Fastgraph / Light est le
le nom de la bibliothèque (LIB) fichiers. Toutes les bibliothèques Fastgraph commencent par les deux personnages FG, tandis que les bibliothèques Fastgraph / lumière équivalentes commencent par les trois personnages FGL. Par exemple, FGS.LIB est le petit modèle de bibliothèque Fastgraph utilisé avec la plupart des compilateurs C, mais FGLS.LIB est le nom équivalent bibliothèque Fastgraph / Light. Notez que les fichiers de l'unité Pascal commencent toujours par FG, si vous utilisez Fastgraph ou Fastgraph / Light.

Dans le Guide de l'utilisateur Fastgraph et l'accompagnement Fastgraph Référence
Manuel, les références à Fastgraph appliquent également à Fastgraph / Light, sauf indication contraire.


===connaissances requises===

Fastgraph est un outil de programmation, ce qui signifie que les programmeurs sont son but
public.Pour cette raison, le manuel Guide et Fastgraph Référence de l'utilisateur Fastgraph suppose que vous avez une connaissance de la programmation. En outre, une connaissance de convertir des nombres entre binaire, décimal et hexadécimal est supposé.

Pratiquement tous les exemples de ce manuel sont écrites dans le C
langage de programmation, donc une connaissance de C serait particulièrement utile. Les exemples évitent intentionnellement utilisant l'une des caractéristiques et des idiomes de C qui pourraient ne pas être évident pour un programmeur familier avec C. Si vous programmez en mode réel, ne pas être confondu par le fait que tous les exemples appellent la routine de fg_initpm de Fastgraph pour initialisation du mode protégé - en mode réel, fg_initpm retourne simplement à l'appelant. Enfin, nous aimerions souligner que les exemples doivent être lus pas par eux-mêmes, mais dans le cadre du texte qui l'entoure.


===compilateurs pris en charge===

Vous pouvez utiliser Fastgraph avec tous les compilateurs ou assembleurs qui utilisent le même
appel et les conventions de nommage que la petite, moyenne, grande ou modèles de mémoire plats des compilateurs pris en charge. la programmation en langue mixte est autorisée si soutenu par le traducteur de langue, éditeur de liens et d'extension DOS utilisé. Fastgraph prend en charge les compilateurs suivants:

* Borland C ++ (version 2.0 ou ultérieure)
* Borland Pascal (version 7.0 ou ultérieure)
* MetaWare haut C / C ++ (version 3.0 ou ultérieure)
* Système de développement professionnel BASIC Microsoft (version 7.0 ou 7.1)
* Microsoft C / C ++ (version 5.1 ou ultérieure)
* Microsoft FORTRAN (version 4.0 ou ultérieure)
* Microsoft FORTRAN PowerStation (version 1.0 ou ultérieure)
* Microsoft QuickBASIC (version 4.0 ou ultérieure)
* Microsoft QuickC (version 2.0 ou ultérieure)
* Microsoft Visual Basic pour DOS (version 1.0 ou ultérieure)
* Microsoft Visual C ++ (version 1.0 ou ultérieure)
* Microsoft Visual C ++ Edition 32 bits (version 1.0 ou ultérieure)
* Puissance C (version 2.0 ou ultérieure)
* Turbo C (version 2.0 ou ultérieure)
* Turbo C ++ (version 1.0 ou ultérieure)
* Turbo Pascal (version 6.0 ou ultérieure)
* WATCOM C / C ++ (version 9.5 ou ultérieure)
* WATCOM C32 pour DOS (version 9.5 ou ultérieure)
* Zortech C ++ (version 3.0 ou ultérieure)

Les numéros de version répertoriés sont les versions du compilateur sous lequel Fastgraph a été développé et testé. Fastgraph peut ou peut ne pas fonctionner avec les versions antérieures de ces compilateurs. Comme nous ajoutons constamment de soutien pour les nouveaux compilateurs, s'il vous plaît vérifier le fichier READ.ME dans le répertoire \ FG pour les ajouts possibles au Guide de l'utilisateur ci-dessus 4 Fastgraph
liste. L'utilisation de Fastgraph des programmes de langue d'assemblage est abordée dans l'annexe B.


===Mode réel, mode protégé, et DOS Extenders===

DOS est fondamentalement un système d'exploitation en mode réel. le mode réel est le natif
(Et seulement) le mode de fonctionnement des 8086 et 8088 microprocesseurs, sur lesquels étaient fondés les systèmes PC / XT IBM PC et. Bien que ces processeurs à condition que la capacité de traiter un mégaoctet de mémoire, IBM a réservé la 384K supérieure de cette adresse un espace de mégaoctet pour des choses telles que la mémoire vidéo et le BIOS ROM. Cela a laissé un maximum de 640K pour les applications DOS.
plus tard microprocesseurs (80286, 80386, 80486 et Pentium d'Intel) fournissent
un deuxième mode de fonctionnement appelé mode protégé. Peut-être l'aspect le plus important du mode protégé est sa capacité à utiliser beaucoup plus de mémoire. Lors de l'exécution en mode protégé, le processeur 16-bit 80286 a une adressabilité 16 méga-octets, tandis que les 32 bits 80386 et plus tard les processeurs peuvent répondre à quatre gigaoctets. services de mémoire étendue et étendue fournissent un accès limité à ce plus grand espace d'adresse, mais un programme doit fonctionner en mode protégé si elle veut traiter cette mémoire comme la mémoire DOS conventionnelle. Parce que DOS est un véritable système d'exploitation en mode, les applications DOS en cours d'exécution sur 80286 et plus tard les processeurs sont encore limités à ubiquitaire 640K barrière DOS. Dans ce cas, ces systèmes fonctionnent simplement comme plus rapides 8086 ou 8088 systèmes.

Quand un système compatible DOS protégé fonctionnement du mode ne semble pas, DOS
extendeurs sont arrivés à la place. Une extension DOS est un produit, un «système mini-exploitation" si vous voulez, qui peut exécuter des applications en mode protégé sous DOS. L'extension DOS accomplit cela en exécutant un programme stub en mode réel qui commute le processeur en mode protégé et passe le contrôle de votre programme. Votre programme continue à fonctionner en mode protégé jusqu'à ce qu'il délivre un service BIOS ou DOS comme un dossier de demande d'E / S. L'extenseur passe alors de nouveau en mode réel pour satisfaire la demande, et à la fin revient en mode protégé. Lorsque votre programme se termine, l'extension DOS repasse en mode réel et renvoie le contrôle au DOS. Ceci est bien sûr une simplification excessive de la façon dont une extension DOS fonctionne, mais ceux-ci derrière les tâches les scènes sont transparentes aux utilisateurs finaux de votre programme. De leur point de vue, une application DOS étendue exécute comme toute application ordinaire DOS.
extendeurs DOS viennent en deux saveurs: 16-bit et 32-bit. Programmes écrits
16-bit extendeurs DOS nécessitent au moins un système à base de 80286, tandis que ceux écrits pour extendeurs 32 bits nécessitent un 80386 ou mieux. Beaucoup de compilateurs en mode réel peuvent créer 16 bits étendu des applications DOS, mais vous aurez besoin des compilateurs spéciaux 32 bits pour créer 32 bits des applications DOS étendues. Fastgraph prend en charge les 16 bits extendeurs DOS suivants:

* Blinker
* Borland Pascal 7 (construit en extender DPMI)
* Borland PowerPack pour DOS
* Phar Lap 286 | Dos-Extender SDK
* Phar Lap 286 | Dos-Extender Lite
* Rational Systems DOS / 16M

Fastgraph prend en charge les 32 bits extendeurs DOS suivants:

* Borland PowerPack pour DOS
* Causeway
* DOSXMSF (fourni avec Microsoft FORTRAN PowerStation)   
* X 32 FlashTek
* Phar Lap SDK TNT Dos-Extender (anciennement 386 | Dos-Extender SDK)
* Phar Lap TNT Dos-Extender Lite
* Rational Systems DOS / 4G
* Rational Systems DOS / G4G (fourni avec 32 bits compilateurs Watcom)
* Rational Systems DOS / G4G Professional

S'il vous plaît vérifier le fichier READ.ME dans le répertoire \ FG pour les ajouts possibles aux listes ci-dessus.

Notez que certains extendeurs DOS exigent des frais de licence ou les paiements de redevances
avant que vous pouvez inclure ou lier leurs composants avec des applications que vous distribuez. Nous vous recommandons de vérifier vos manuels d'extension DOS ou contrat de licence pour plus de détails, ou si vous n'êtes pas sûr, contacter directement le fabricant d'extension DOS.

===Modèles de mémoire===

pris en charge en mode réel de C, C ++ et Fortran de Fastgraph compilateurs offrent
plusieurs modèles de mémoire. Un modèle de mémoire définit la façon dont la mémoire est mis en place pour le code et les données des segments d'un programme. Fastgraph comprend des bibliothèques réelles de mode pour les petites, moyennes et grandes modèles de mémoire et les bibliothèques en mode protégé pour les environnements 16 bits et 32 ??bits. Les bibliothèques protégées en mode 16 bits utilisent une extension du modèle de mémoire, tandis que les bibliothèques 32 bits utilisent un modèle de mémoire plat spécial.

Le petit modèle de mémoire permet un segment de code et un segment de données.
Les programmes qui utilisent le petit modèle peut ainsi avoir un maximum de 64K octets de code et 64K octets de données. Parce que le petit modèle met en œuvre des instructions d'appel et des références de données à travers près de pointeurs, il produit le code le plus efficace des trois modèles de mémoire en mode réel pris en charge. Le petit modèle de mémoire est spécifique aux véritables compilateurs de mode.

Le modèle de support de mémoire permet de multiples segments de code et une donnée
segment.Les programmes qui utilisent le modèle moyen ont donc aucune limite de compilateur imposée à la taille du code (bien que pas un segment peut dépasser 64K octets) et un maximum de 64K octets de données. Comme le petit modèle, le modèle moyen met en œuvre des références de données par le biais de près de pointeurs, mais il met en œuvre des instructions d'appel par le biais de pointeurs loin. L'utilisation de pointeurs far ajoute deux octets de code et 13 cycles d'horloge pour chaque appel de sous-programme. Le modèle moyen est un choix populaire pour les programmes en mode réel et est spécifique aux véritables compilateurs de mode.

Le grand modèle de mémoire prend en charge le code et de données multiples segments.  Programmes
qui utilisent le grand modèle ne pas avoir de limites du compilateur imposé pour code et de données de tailles. Toutefois, aucun segment de code ou de données unique peut dépasser 64K octets. Parce que le grand modèle met en œuvre des instructions d'appel et les références de données via les pointeurs loin, il produit le code moins efficace des trois modèles de mémoire pris en charge. En mode réel, la taille totale de tous les codes et les segments de données est limité par la barrière DOS 640K, mais en réalité, la vraie limite sera un peu moins en fonction de la configuration et les programmes résidents du système cible. En mode protégé 16 bits, la taille totale de tous les codes et les segments de données peut atteindre 16 mégaoctets, bien que personne ne peut dépasser le segment 64K octets.

Le modèle de mémoire plat permet un segment de code et un segment de données,
tout comme le petit modèle de mémoire. Le modèle plat diffère en ce que le Guide du secteur 6 Fastgraph utilisateur
tailles peuvent être jusqu'à quatre gigaoctets au lieu de 64K. Par défaut, le modèle plat implémente instructions d'appel et les références de données à 32 bits près de pointeurs, ce qui élimine pratiquement le besoin de segments. Le modèle de mémoire plat est spécifique à 32 bits compilateurs en mode protégé.

Pour plus d'informations sur les modèles de mémoire, s'il vous plaît se référer à l'utilisateur de
guide ou manuel de référence fourni avec votre compilateur.

===Installation Fastgraph===

Cette section explique comment utiliser le programme d'installation pour charger Fastgraph
(Ou Fastgraph / Light) et ses fichiers associés sur un disque dur. Le programme d'installation vous permet de sélectionner les compilateurs, les modèles de mémoire, et DOS extenders que vous souhaitez utiliser avec Fastgraph. Il vous donne également la possibilité de charger de nombreux exemples de programmes Fastgraph spécifiques aux compilateurs de votre choix.

Avant de commencer l'installation, nous vous recommandons d'utiliser les commandes DOS
COPY ou DISKCOPY de faire des copies de travail des disques de distribution Fastgraph (reportez-vous à votre manuel de référence DOS si vous n'êtes pas familier avec ces commandes). Une fois que vous avez créé les copies de travail, stocker les disques d'origine dans un endroit sûr. Installez Fastgraph des copies de travail que vous venez de créer.

Pour plus de simplicité, nous supposerons que vous installez Fastgraph du
lecteur de disquette A: le disque dur C :, mais bien sûr vous pouvez utiliser tous les disques disponibles. Le disque de distribution Fastgraph étiqueté Installation and Utilities contient INSTALLER programme de Fastgraph. Placez ce disque dans le lecteur A:, assurez-A: votre lecteur en cours, et entrez la commande INSTALLER, comme indiqué ici:

 C> A:
                                 A> INSTALLER

De ce point, il suffit de suivre les instructions sur chaque écran. A tout moment, vous pouvez appuyer sur la touche Echap pour annuler l'installation.

Le programme d'installation vous demandera les compilateurs, les modèles de mémoire, et
DOS extenders vous allez utiliser avec Fastgraph, ainsi que les noms de répertoires pour les services publics Fastgraph, les bibliothèques, et inclure des fichiers. Pour les services publics, le répertoire par défaut est C: \ FG. Pour les fichiers à inclure et les bibliothèques, nous vous recommandons d'utiliser des répertoires où le compilateur que vous avez choisi normalement recherches pour de tels fichiers. INSTALLER va essayer de déterminer automatiquement ces répertoires et les proposer comme valeurs par défaut.

Vous pouvez installer le support pour les compilateurs supplémentaires, des modèles de mémoire, ou DOS
extendeurs à tout moment. Si vous choisissez de le faire, vous devez utiliser la commande INSTALLER / L pour éviter la copie des fichiers communs à tous les environnements.

===Le fichier READ.ME===

Le fichier READ.ME contient des ajouts et des modifications qui peuvent avoir été faites
à Fastgraph depuis la publication des manuels. Nous vous encourageons à examiner le fichier READ.ME immédiatement après l'installation de Fastgraph. READ.ME est un fichier texte ASCII, adapté à une imprimante ou d'éditeur de texte. Le programme d'installation place le fichier READ.ME dans le répertoire des utilitaires Fastgraph (C: \ FG par défaut).

===Le fichier WHATS.NEW===

Le fichier WHATS.NEW contient des informations sur les nouvelles fonctionnalités ajoutées dans
Fastgraph version 4.0. Les programmeurs qui ont utilisé des versions antérieures de Fastgraph peuvent vouloir examiner le fichier WHATS.NEW apprendre de nouvelles modifications de fonctionnalités et possibles de Fastgraph nécessaires lors de la conversion des applications à la version 4.0. WHATS.NEW est un fichier texte ASCII, adapté à une imprimante ou d'éditeur de texte. Le programme d'installation place le fichier WHATS.NEW dans le répertoire des utilitaires Fastgraph (C: \ FG par défaut).

===Conventions de nommage Fastgraph===

Les noms de toutes les routines Fastgraph commencent par les trois caractères
"Fg_". Ce préfixe permet d'identifier les routines Fastgraph dans un programme, et il permet également de réduire les risques de conflits de noms qui pourraient autrement se produire entre Fastgraph et d'autres bibliothèques de tiers.

Parce que BASIC ne permet pas de soulignement dans les identificateurs, le BASIC
versions de routines Fastgraph commencent avec les deux caractères "FG". Par exemple, la routine est appelée fg_version FGversion dans les bibliothèques de base. Toutes les références futures routines Fastgraph dans le Guide de l'utilisateur Fastgraph et le Manuel de référence Fastgraph utiliseront la convention de nommage fg_ au lieu des noms BASIC.

===Compilation et liaison===

Pour construire un exécutable (EXE) pour un programme qui utilise Fastgraph
routines, d'abord compiler ou assembler le programme en utilisant l'un des modèles de mémoire pris en charge. Cette étape produit un fichier objet, qui vous liez puis avec une ou plusieurs bibliothèques Fastgraph (ou les fichiers de l'unité Pascal) et éventuellement d'autres bibliothèques pour produire un fichier exécutable. Lors de la création des exécutables en mode protégé, les étapes de liaison supplémentaires peuvent être nécessaires, comme décrit dans votre compilateur ou DOS manuels d'extension. Les bibliothèques Fastgraph ou les fichiers de l'unité Pascal doivent résider dans un répertoire où le lieur recherche normalement pour de tels fichiers.

Exemple 1-1 utilise la fg_version routine Fastgraph pour afficher la version
numéro de votre copie de Fastgraph. Il utilise également une autre routine Fastgraph, fg_initpm, de mettre en place la protection du noyau de mode de Fastgraph pour l'extension DOS sélectionné (en utilisant le mode réel bibliothèques Fastgraph, fg_initpm ne fait rien). Les versions de ce programme sont présentés pour chaque langage de haut niveau Fastgraph prend en charge: C / C ++, BASIC, FORTRAN et Pascal. Si vous avez chargé les programmes d'exemple lorsque vous avez installé Fastgraph, les fichiers \ FG \ EXAMPLES \ 01-01.C, 01-01.BAS, 01-01.FOR et 01-01.PAS contiennent le code source pour ces exemples. Vous pouvez les utiliser pour tester la compilation et le processus de liaison pour les compilateurs que vous allez utiliser avec Fastgraph.

 Exemple 1-1 (version C ++ / C).

  #include <fastgraf.h>
      #include <stdio.h>
      void main (void); 

  void main ()
      {
        int majeur;
        int mineur;

  fg_initpm ();
        fg_version (et majeur, et mineur);
        printf ( "Ceci est la version% d% 2.2d de Fastgraph \ n..", majeur, mineur);
      }


Le FASTGRAF.H de fichier d'en-tête contient les prototypes ++ C et C de fonction pour
chaque routine Fastgraph. Il doit résider dans un répertoire où le compilateur recherche normalement pour les autres fichiers d'en-tête. Lors de la création de 32 bits des applications en mode protégé, FASTGRAF.H définira le symbole FG32. Ce symbole est utile pour contrôler la compilation conditionnelle lors de la création d'applications qui fonctionnent dans les deux environnements 16 bits et 32 ??bits.

 Exemple 1-1 (version BASIC).

 REM $ INCLUDE: 'fastgraf.bi'

 DEFINT AZ

 FGversion Major, Minor
         Version! = Major + Minor * 0,01

PRINT UTILISATION "Ceci est la version # ## de Fastgraph.."; Version!

  FIN


Vous devez inclure les commandes DECLARE dans le fichier FASTGRAF.BI au
à partir de chaque module de base. Ce fichier doit résider dans un répertoire où le compilateur recherche normalement pour les fichiers de BI, ou dans l'un des répertoires spécifiés par la variable d'environnement INCLUDE. Les commandes DECLARE dans ce fichier fournissent automatiquement la convention d'appel et convention de dénomination pour chaque routine Fastgraph. En outre, ils soulagent le programmeur BASIC des arguments distinctifs passés par valeur de ceux qui sont passés par référence.

 Exemple 1-1 (version FORTRAN).

 $ INCLUDE: '\ FG \ FASTGRAF.FI'

 PROGRAMME PRINCIPAL

 ENTIER MAJOR
           ENTIER MINOR

 FG_INITPM CALL
           APPEL FG_VERSION (MAJOR, MINOR)

 WRITE (6,10) MAJOR, MINOR
     10 FORMAT ( 'Ceci est une version ", I1,'. ', I2.2,' de Fastgraph. ')

 ARRÊTEZ ' '   
  FIN


Vous devez inclure les états d'interface dans le fichier FASTGRAF.FI au
à partir de programmes FORTRAN (ce fichier doit résider dans le répertoire \ FG). Les états d'interface dans ce fichier fournissent automatiquement la convention d'appel et convention de dénomination pour chaque routine Fastgraph. En outre, ils soulagent le programmeur FORTRAN des arguments distinctifs passés par valeur de ceux qui sont passés par référence.

 Exemple 1-1 (version Pascal).

 programme principal;
      utilise fgmain;

 var
        Major: integer;
        Minor: integer;

 commencer
        fg_initpm;
        fg_version (Major, Minor);
        writeln ( 'Ceci est une version', Major, Minor: 2, 'de Fastgraph.' '.');
       fin.

programmes Pascal qui utilisent Fastgraph ou Fastgraph / Light doit inclure une utilisation
déclaration précisant les noms des fichiers d'unités (fichiers TPU ou TPP) nécessaires dans le programme. Cette liste doit toujours inclure l'unité de fgmain; pour les programmes en mode protégé qui appellent GlobalAllocPtr, GlobalFreePtr, ou d'autres fonctions dans WinAPI, il doit également inclure l'unité de WinAPI. Tous les fichiers de l'unité doivent résider dans un répertoire où le compilateur recherche normalement pour de tels fichiers. Annexe E énumère les fonctions Fastgraph dans chaque unité.

Les sections suivantes présentent les procédures les plus simples pour la compilation d'un
programme et de le lier avec Fastgraph. L'information est présentée pour chaque compilateur supporté, par ordre alphabétique du nom du compilateur. Dans ce qui suit, les éléments entre crochets d'angle, tels que <source_file>, sont des espaces réservés pour les paramètres que vous devez fournir (le nom d'un fichier dans ce cas). Articles entre crochets, comme [/ E], sont facultatifs. Pour plus de simplicité, nous ne montrons les noms de bibliothèques Fastgraph. Si vous utilisez Fastgraph / Light, les noms de bibliothèques vont commencer par "FGL" au lieu de "FG". Par exemple, FGS.LIB est le mode réel petit modèle Fastgraph pour la plupart des compilateurs C, tandis que FGLS.LIB est la bibliothèque équivalente pour Fastgraph / Lumière. Notez que Fastgraph / Light ne supporte pas les environnements de mode protégé. Guide de l'utilisateur 10 Fastgraph


====Borland C ++====

Borland C ++ peut créer en mode réel, en mode protégé 16 bits et 32 ??bits
applications en mode protégé (Borland C ++ 4.0 ou version ultérieure est nécessaire pour le mode protégé 32 bits). Vous pouvez compiler et lier les programmes directement à partir de la ligne de commande DOS ou de l'environnement de développement Borland C ++ intégré (IDE). Les bibliothèques Fastgraph suivants sont compatibles avec Borland C ++:

* FGS.LIB en mode réel petit modèle bibliothèque générale
* FGM.LIB en mode réel moyen modèle bibliothèque générale
* FGL.LIB en mode réel grand modèle bibliothèque générale
* FGTCS.LIB en mode réel petit modèle bibliothèque auxiliaire
* FGTCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
* FGTCL.LIB en mode réel grand modèle bibliothèque auxiliaire
* FG16.LIB 16 bits en mode protégé bibliothèque générale
* FG16BC.LIB 16 bits en mode protégé bibliothèque auxiliaire
* Bibliothèque de support d'extension FG16DPMI.LIB 16 bits DPMI compatible DOS
* FG16PHAR.LIB Phar Lap 286 | Dos-Extender Bibliothèque de support
* FG32.LIB 32 bits en mode protégé bibliothèque générale
* FG32BC.LIB 32 bits en mode protégé bibliothèque auxiliaire
* Bibliothèque de support d'extension FG32DPMI.LIB 32 bits DPMI compatible DOS
* FG32PHAR.LIB Phar Lap TNT | Bibliothèque de support Dos-Extender

Pour construire des applications en mode réel Fastgraph dans le Borland C ++ IDE, le
options de compilation doivent correspondre à l'un des modèles de mémoire disponibles de Fastgraph (petites, moyennes ou grandes). programmes protégés en mode 16 bits doivent utiliser le modèle de mémoire, tandis que les programmes protégés en mode 32 bits doivent être compilés comme des applications console. Dans tous les cas, vous devez également créer un fichier de projet qui comprend le nom de chaque C, CPP, et le fichier LIB requis par votre application (reportez-vous à vos manuels Borland C ++ pour obtenir des informations sur les fichiers de projet). Pour Borland C ++ 4.0 et au-dessus, le fichier de projet spécifie également la plate-forme: DOS pour les applications en mode réel, DOS (16-bit DPMI) pour des applications 16 bits en mode protégé, ou DOS (32-bit DPMI) pour le mode 32 bits protégé applications. Les dossiers de projet ne sont nécessaires que lorsque vous utilisez l'IDE.

Vous pouvez également compiler et lier les programmes de la ligne de commande DOS en utilisant
a BCC ou BCC32 commandes. Voici par exemple BCC et les commandes BCC32 pour compiler un programme Borland C ++ et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compiler- ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

 Mode réel, petit modèle de mémoire:
       <Source_file> FGS.LIB [FGTCS.LIB] BCC

 Mode réel, modèle de support de mémoire:
       <Source_file> FGM.LIB [FGTCM.LIB] BCC

 Mode réel, grand modèle de mémoire:
       BCC -ml <source_file> FGL.LIB [FGTCL.LIB]

 mode protégé 16 bits, extender Borland PowerPack DOS:
       BCC -ml -WX <source_file> FG16.LIB FG16DPMI.LIB [FG16BC.LIB]

 mode protégé 16 bits, Phar Lap 286 | Dos-Extender:
       BCC286 <source_file> FG16.LIB FG16PHAR.LIB [FG16BC.LIB]   

 mode protégé 32 bits, extender Borland PowerPack DOS:
       BCC32 -WX <source_file> FG32.LIB FG32DPMI.LIB [FG32BC.LIB]

Pour créer 16 bits protégées des programmes en mode de Borland C utilisant les systèmes DOS / 16M extender Rational, se référer au Guide de l'utilisateur DOS / 16M. Pour créer 32 bits protégées des programmes en mode de Borland C en utilisant le Phar Lap TNT | Dos-Extender, consulter le C de Phar Lap / Guide de l'utilisateur C de TNT Dos-Extender.

Pour plus d'informations sur les modèles de mémoire ou autre compilation et liaison
les options, consulter le Guide de l'utilisateur de Borland C, Borland PowerPack pour le Guide de l'utilisateur DOS, de Phar Lap Borland C ++ Guide de l'utilisateur à 286 Dos-Extender, ou le Guide de l'utilisateur DOS / 16M. Guide de l'utilisateur 12 Fastgraph


====Borland Pascal====

Borland Pascal peut créer en mode réel et en mode 16 bits protégé
applications.les applications en mode protégées peuvent être construites sans un tiers d'extension DOS, comme les extensions en mode protégé nécessaires sont mises en œuvre par le biais d'une interface en mode DOS protégé (DPMI) serveur et un gestionnaire d'exécution. Vous pouvez compiler en mode réel et les programmes en mode protégé directement à partir de la ligne de commande DOS ou à partir de l'environnement de développement intégré Borland Pascal (IDE).

Pour créer des applications Fastgraph dans le Borland Pascal IDE, il suffit de commencer la
IDE comme vous le feriez pour tout autre programme Pascal, en vérifiant que les fichiers d'unités Fastgraph résider dans l'un des répertoires listés dans "Unité Répertoires" l'option de l'IDE. Si vous créez une application en mode protégé de l'EDI, choisissez Compile | Target et sélectionnez «Application en mode protégé" de la boîte de dialogue Plate-forme cible.

Vous pouvez également compiler des programmes Borland Pascal de la ligne de commande DOS
en utilisant les BPC ou TPC commandes, comme indiqué ici. programmes en mode réel peuvent utiliser soit BPC ou PTC, alors que les programmes de mode protégé doivent utiliser BPC.

 Mode réel:
       BPC <source_file>
       TPC <source_file>

 16 bits en mode protégé:
       BPC / CP <source_file>

Pour plus d'informations sur la compilation et l'autre des options de liaison, s'il vous plaît
reportez-vous au Borland Pascal avec le Guide de l'utilisateur des objets.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour Borland Pascal, la procédure d'installation copie les versions Pascal des exemples de programmes dans le répertoire \ FG \ EXEMPLES.

====MetaWare haut C / C ++====

MetaWare haut C / C ++ est strictement un compilateur en mode protégé 32 bits.  Il
soutient le Phar Lap TNT | Dos-Extender SDK et l'extension des systèmes DOS / 4G Rational. Les bibliothèques Fastgraph suivants sont compatibles avec MetaWare haut C / C ++:

* FG32.LIB 32 bits en mode protégé bibliothèque générale
* FG32HC.LIB 32 bits en mode protégé bibliothèque auxiliaire  Bibliothèque de support d'extension FG32DPMI.LIB 32 bits DPMI compatible DOS
* FG32PHAR.LIB Phar Lap TNT | Bibliothèque de support Dos-Extender

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant la
commande HC386. Voici un exemple de commandes HC386 pour compiler un programme MetaWare haut C / C ++ et en le reliant avec Fastgraph. La bibliothèque auxiliaire spécifique au compilateur (FG32HC) ne doit être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

 mode protégé 32 bits, Phar Lap TNT | Dos-Extender:
       HC386 <source_file> -lFG32 -lFG32PHAR [-lFG32HC] -nomap -onecase

 32 bits en mode protégé, Rational extender Systems DOS / 4G:
       HC386 <source_file> -Hdos4g -lFG32 -lFG32DPMI [-lFG32HC]

Pour plus d'informations sur la compilation et l'autre des options de liaison, s'il vous plaît
consultez le Guide de l'MetaWare haut C / C ++ Programmer, le C de Phar Lap / C ++ Guide d'utilisation de TNT Dos-Extender, ou le manuel de l'utilisateur DOS / 4G. Guide de l'utilisateur 14 Fastgraph

====Système de développement professionnel BASIC Microsoft====

Vous pouvez compiler et lier système de développement professionnel BASIC Microsoft
(PDS) des programmes directement à partir de la ligne de commande DOS ou de l'environnement de programmation de PDS. Dans les deux cas, BASIC PDS crée toujours des programmes en mode réel. Les bibliothèques Fastgraph suivants sont compatibles avec PDS DE BASE:

* FGQBX.LIB bibliothèque autonome pour PDS DE BASE
* FGQBX.QLB bibliothèque rapide pour BASE PDS

Pour créer des applications Fastgraph dans le PDS environnement de programmation, juste
spécifier le nom de la bibliothèque rapide FGQBX lors du démarrage PDS DE BASE:

* QBX / LFGQBX [<source_file>]

Vous devez utiliser la valeur par défaut "Far Strings" mise dans l'environnement PDS. Il n'y a pas de bibliothèques Fastgraph de chaîne près de disponibles pour BASE PDS.

Pour compiler un programme BASIC PDS à partir de la ligne de commande DOS et le lien avec
Fastgraph, utilisez les commandes de la Colombie-Britannique et LINK:

  BC / Fs [/ O] <source_file>;
        LINK [/ E] <object_file> ,, NUL, FGQBX;

L'option / O sur la commande BC est recommandée car elle crée des fichiers EXE qui ne nécessitent pas le module run-time BASIC PDS. L'option de liaison / E est pas obligatoire mais va produire un fichier EXE plus petit si spécifié. Pour plus d'informations sur la compilation et l'autre des options de liaison, consulter le Guide de Microsoft BASIC Professional System Development Programmer.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour Microsoft BASIC PDS, la procédure d'installation copie les versions de base des exemples de programmes dans le répertoire \ FG \ EXEMPLES.

====Microsoft C / C ++====

Microsoft C / C ++ peut créer en mode réel et en mode 16 bits protégé
applications. Pour le mode protégé, il prend en charge le Phar Lap 286 | Dos-Extender (deux SDK et Lite versions) et les systèmes DOS / 16M extender Rational. Les bibliothèques Fastgraph suivants sont compatibles avec Microsoft C / C ++:

* FGS.LIB en mode réel petit modèle bibliothèque générale
* FGM.LIB en mode réel moyen modèle bibliothèque générale
* FGL.LIB en mode réel grand modèle bibliothèque générale
* FGMSCS.LIB en mode réel petit modèle bibliothèque auxiliaire
* FGMSCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
* FGMSCL.LIB en mode réel grand modèle bibliothèque auxiliaire
* FG16.LIB 16 bits en mode protégé bibliothèque générale
* FG16MSC.LIB 16 bits en mode protégé bibliothèque auxiliaire
* Bibliothèque de support d'extension FG16DPMI.LIB 16 bits DPMI compatible DOS
* FG16PHAR.LIB Phar Lap 286 | Dos-Extender Bibliothèque de support

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant la CL
commander. Voici des exemples de commandes CL pour compiler un programme Microsoft C / C ++ et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D. Dans les exemples de mode réel, l'option de liaison / E est pas obligatoire mais va produire un fichier EXE plus petit si spécifié.

  Mode réel, petit modèle de mémoire:
        CL / AS <source_file> / link FGS.LIB [FGMSCS.LIB] [/ E]

  Mode réel, modèle de support de mémoire:
        CL / AM <source_file> / lien FGM.LIB [FGMSCM.LIB] [/ E]

  Mode réel, grand modèle de mémoire:
        CL / AL <source_file> / link FGL.LIB [FGMSCL.LIB] [/ E]

  mode 16 bits protégé, Phar Lap 286 SDK ou extender Lite:
        CL / AL / Lp <source_file> / link FG16.LIB FG16PHAR.LIB [FG16MSC.LIB]

Pour créer des programmes en mode Microsoft C / C ++ protégées utilisant les systèmes DOS / 16M extender Rational, se référer au Guide de l'utilisateur DOS / 16M.

Pour plus d'informations sur les modèles de mémoire ou autre compilation et liaison
les options, se référer au Guide de l'utilisateur Microsoft C Optimisation du compilateur, Microsoft C & Guide de C de l'utilisateur 286 de Phar Lap | Dos-Extender, ou le Guide de l'utilisateur DOS / 16M. Guide de l'utilisateur 16 Fastgraph

====Microsoft FORTRAN====

Microsoft FORTRAN crée des applications en mode réel.  La Fastgraph suivante
bibliothèques sont compatibles avec Microsoft FORTRAN:

* FGM.LIB en mode réel moyen modèle bibliothèque générale
* FGL.LIB en mode réel grand modèle bibliothèque générale
* FGMSFM.LIB en mode réel moyen modèle bibliothèque auxiliaire
* FGMSFL.LIB en mode réel grand modèle bibliothèque auxiliaire

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant le FL
commander. Voici par exemple les commandes FL pour compiler un programme Microsoft FORTRAN et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D. L'option / E lieur ne sont pas nécessaires, mais produira un fichier EXE plus petit si spécifié.

  Moyen modèle de mémoire:
        FL / AM / FPi / 4I2 / 4NT <source_file> / lien FGM.LIB [FGMSFM.LIB] [/ E]

  Grand modèle de mémoire:
        FL / AL / FPi / 4I2 / 4NT <source_file> / link FGL.LIB [FGMSFL.LIB] [/ E]

Pour plus d'informations sur les modèles de mémoire ou autre compilation et liaison
les options, se référer au Guide de l'utilisateur Microsoft FORTRAN Optimisation du compilateur.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour le compilateur Microsoft FORTRAN, les versions procédure d'installation copie FORTRAN des exemples de programmes dans le répertoire \ FG \ EXEMPLES.

====Microsoft FORTRAN PowerStation====

Microsoft FORTRAN PowerStation est strictement un mode protégé 32 bits
compilateur. Il prend en charge l'extension DOSXMSF DOS inclus avec le compilateur et le Lap TNT Phar | Dos-Extender SDK (DOSXMSF est un sous-ensemble de la TNT | Dos-Extender). La bibliothèque Fastgraph suivante est compatible avec Microsoft FORTRAN PowerStation:

FG32MSF.LIB bibliothèque PM 32 bits pour Microsoft FORTRAN PowerStation

FG32MSF.LIB comprend Phar fonctions support Lap de Fastgraph normalement trouvés dans la bibliothèque FG32PHAR.LIB.

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant le FL32
commander:

  FL32 <source_file> FG32MSF.LIB

Cette commande appelle le compilateur PowerStation et Microsoft Portable Executable Linker (LINK32) pour créer un 32 bits en mode protégé exécutable.

Pour plus d'informations sur la compilation et l'autre des options de liaison, s'il vous plaît
consultez le Guide de l'utilisateur FORTRAN Guide ou Phar Lap du Microsoft FORTRAN PowerStation utilisateur TNT Dos-Extender. Guide de l'utilisateur 18 Fastgraph

====Microsoft QuickBASIC====

Vous pouvez compiler et lier les programmes Microsoft QuickBASIC directement à partir du
DOS ligne de commande ou de l'environnement de programmation QuickBASIC. Dans les deux cas, QuickBASIC crée toujours des programmes en mode réel. Les bibliothèques Fastgraph suivants sont compatibles avec QuickBASIC:

* FGQB.LIB bibliothèque autonome pour QuickBASIC
* FGQB.QLB bibliothèque rapide pour QuickBASIC

Pour créer des applications Fastgraph dans l'environnement de programmation de QuickBASIC,
il suffit de spécifier le nom de la bibliothèque rapide FGQB lors du démarrage QuickBASIC:

  QB / LFGQB [<source_file>]

Pour compiler un programme QuickBASIC à partir de la ligne de commande DOS et le lien avec Fastgraph, utilisez les commandes de la Colombie-Britannique et LINK:

  BC [/ O] <source_file>;
        LINK [/ E] <object_file> ,, NUL, FGQB;

L'option / O sur la commande BC est recommandée car elle crée des fichiers EXE qui ne nécessitent pas le module run-time QuickBASIC. L'option de liaison / E est pas obligatoire mais va produire un fichier EXE plus petit si spécifié. Pour plus d'informations sur la compilation et l'autre des options de liaison, se référer à la Microsoft QuickBASIC: Programmation dans le manuel BASIC.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour Microsoft QuickBASIC, la procédure d'installation copie les versions de base des exemples de programmes dans le répertoire \ FG \ EXEMPLES.

====Microsoft QuickC====

Vous pouvez compiler et lier les programmes Microsoft QuickC directement à partir du DOS
ligne de commande ou de l'environnement de programmation QuickC. Dans les deux cas, QuickC crée toujours des programmes en mode réel. Les bibliothèques Fastgraph suivants sont compatibles avec QuickC:

* FGS.LIB en mode réel petit modèle bibliothèque générale
* FGM.LIB en mode réel moyen modèle bibliothèque générale
* FGL.LIB en mode réel grand modèle bibliothèque générale
* FGMSCS.LIB en mode réel petit modèle bibliothèque auxiliaire
* FGMSCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
* FGMSCL.LIB en mode réel grand modèle bibliothèque auxiliaire

Pour créer des applications Fastgraph dans l'environnement de programmation QuickC,
vous devez vous assurer que les options de compilation correspondent à l'un des modèles de la mémoire disponible de Fastgraph (petites, moyennes ou grandes), puis créer un fichier make qui comprend les noms de bibliothèque Fastgraph correspondants.

Pour compiler un programme QuickC à partir de la ligne de commande DOS et le lien avec

Fastgraph, utilisez la commande QCL. Voici des exemples de commandes QCL pour compiler un programme QuickC et de le lier avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D. L'option / E lieur ne sont pas nécessaires, mais produira un fichier EXE plus petit si spécifié.

  Petit modèle de mémoire:
        QCL / AS <source_file> / link FGS.LIB [FGMSCS.LIB] [/ E]

  Moyen modèle de mémoire:
        QCL / AM <source_file> / link FGM.LIB [FGMSCM.LIB] [/ E]

  Grand modèle de mémoire:
        QCL / AL <source_file> / link FGL.LIB [FGMSCL.LIB] [/ E]

Pour plus d'informations sur les fichiers, faire des modèles de mémoire, ou d'autres
compilation et options de liens, consulter le manuel du kit Microsoft QuickC Tool. Guide de l'utilisateur 20 Fastgraph

====Microsoft Visual Basic pour DOS====

Vous pouvez compiler et lier Microsoft Visual Basic pour les programmes DOS directement
à partir de la ligne de commande DOS ou à partir de l'environnement de programmation Visual Basic. Dans les deux cas, Visual Basic crée toujours des programmes en mode réel. Les bibliothèques Fastgraph suivants sont compatibles avec Visual Basic:

*  FGVBDOS.LIB bibliothèque autonome pour Visual Basic
*  FGVBDOS.QLB bibliothèque rapide pour Visual Basic

Pour créer des applications Fastgraph dans la programmation Visual Basic
environnement, il suffit de spécifier le nom de la bibliothèque rapide FGVBDOS lors du démarrage de Visual Basic:

  VBDOS / LFGVBDOS [<source_file>]

Lors de l'utilisation de l'environnement de programmation, vous pouvez obtenir un message d'erreur "Out of Memory" ou "Out of String Space" en essayant de construire un fichier EXE ou exécuter une application dans l'environnement. Si cela se produit, vous devez spécifier l'option / S sur la ligne de commande VBDOS pour augmenter la quantité de mémoire disponible pour votre application. Si vous avez la mémoire EMS ou XMS installé sur votre système, il est également utile de préciser le / E ou / X options pour faire des portions du résident de l'environnement de programmation en EMS ou XMS. Pour plus d'informations sur ces options, reportez-vous à l'annexe B du Microsoft Guide du programmeur Visual Basic.

Pour compiler un programme Visual Basic à partir de la ligne de commande DOS et le lier
avec Fastgraph, utilisez les commandes de la Colombie-Britannique et LINK:

  BC [/ O] <source_file>;
        LINK [/ E] <object_file> ,, NUL, FGVBDOS;

L'option / O sur la commande BC est recommandée car elle crée des fichiers EXE qui ne nécessitent pas le module Visual Basic exécution. L'option de liaison / E est pas obligatoire mais va produire un fichier EXE plus petit si spécifié. Pour plus d'informations sur la compilation et l'autre des options de liaison, se référer à la Microsoft Guide du programmeur Visual Basic.

Lors de la liaison Visual Basic pour les programmes DOS qui appellent le monde Fastgraph
routines espace ou logiciel caractères (qui est, une des routines énumérées à l'annexe D), vous pouvez avoir besoin d'augmenter le nombre de segments disponibles à l'éditeur de liens. Utilisez le / SEG: n option sur la commande LINK pour ce faire. La valeur par défaut de n est de 128 segments; habituellement une valeur légèrement plus grande, comme 144, sera suffisant.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour Visual Basic, la procédure d'installation copie les versions de base des exemples de programmes dans le répertoire \ FG \ EXEMPLES.

====Microsoft Visual C ++====

Microsoft Visual C ++ peut créer en mode réel et en mode 16 bits protégé
applications. Pour le mode protégé, il prend en charge le Phar Lap 286 | Dos-Extender (deux SDK et Lite versions) et les systèmes DOS / 16M extender Rational. Les bibliothèques Fastgraph suivants sont compatibles avec Visual C ++:

*  FGS.LIB en mode réel petit modèle bibliothèque générale
*  FGM.LIB en mode réel moyen modèle bibliothèque générale
*  FGL.LIB en mode réel grand modèle bibliothèque générale
*  FGMSCS.LIB en mode réel petit modèle bibliothèque auxiliaire
*  FGMSCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
*  FGMSCL.LIB en mode réel grand modèle bibliothèque auxiliaire
*  FG16.LIB 16 bits en mode protégé bibliothèque générale
*  FG16MSC.LIB 16 bits en mode protégé bibliothèque auxiliaire
*  Bibliothèque de support d'extension FG16DPMI.LIB 16 bits DPMI compatible DOS
*  FG16PHAR.LIB Phar Lap 286 | Dos-Extender Bibliothèque de support

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant la CL
commander. Voici des exemples de commandes CL pour compiler un programme Visual C ++ et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D. Dans les exemples de mode réel, l'option de liaison / E est pas obligatoire mais va produire un fichier EXE plus petit si spécifié.

  Mode réel, petit modèle de mémoire:
        CL / AS <source_file> / link FGS.LIB [FGMSCS.LIB] [/ E]

  Mode réel, modèle de support de mémoire:
        CL / AM <source_file> / lien FGM.LIB [FGMSCM.LIB] [/ E]

  Mode réel, grand modèle de mémoire:
        CL / AL <source_file> / link FGL.LIB [FGMSCL.LIB] [/ E]

  mode 16 bits protégé, Phar Lap 286 SDK ou extender Lite:
        CL / AL / Lp <source_file> / link FG16.LIB FG16PHAR.LIB [FG16MSC.LIB]

Pour créer des programmes en mode C ++ protégé visuels utilisant les systèmes DOS / 16M extender Rational, se référer au Guide de l'utilisateur DOS / 16M.

Pour plus d'informations sur les modèles de mémoire ou autre compilation et liaison
les options, se référer au Guide de l'utilisateur Visual C ++ en ligne de commande Utilitaires, Guide de Microsoft C & C ++ User Phar Lap à 286 | Dos-Extender, ou le Guide de l'utilisateur DOS / 16M. Guide de l'utilisateur 22 Fastgraph


====32-bit Edition de Microsoft Visual C====

Comme son nom l'indique, 32-bit Edition de Microsoft Visual C est strictement
32 bits compilateur en mode protégé. Il prend en charge le Lap TNT Phar | Dos-Extender SDK et Phar Lap TNT | Dos-Extender Lite. La bibliothèque Fastgraph suivante est compatible avec l'édition 32 bits de Visual C ++:

* FG32VC.LIB bibliothèque PM 32-bit 32-bit Edition de Microsoft Visual C
* FG32VC.LIB comprend Phar fonctions support Lap de Fastgraph normalement trouvés dans la bibliothèque FG32PHAR.LIB.

Il existe deux méthodes de base de la création de 32 bits en mode protégé executables
avec 32-bit Edition de Visual C. La première méthode compile et lie le programme en une seule commande et utilise 32 bits linker Microsoft:

  CL <source_file> / link /stub:\TNT\BIN\GOTNT.EXE FG32VC.LIB

La deuxième méthode compile et lie le programme dans les commandes séparées et utilise de 386 Phar Lap | utilitaire lien:

  CL / c <source_file>
        386LINK <fichier_obj> @ MSVC32.DOS -lib FG32VC -nomap -onecase

Le Lap linker Phar a des problèmes avec le monde des routines spatiales Fastgraph. Si votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D, vous devez utiliser la version 32 bits linker Microsoft.

Pour plus d'informations sur la compilation et l'autre des options de liaison, s'il vous plaît
reportez-vous au C de Phar Lap / Guide de l'utilisateur C de TNT Dos-Extender.


====Puissance C====

Puissance C est un compilateur de ligne de commande en mode réel bon marché.  Le suivant
bibliothèques Fastgraph sont compatibles avec Power C:

*  FGS.MIX Petit modèle bibliothèque générale
*  FGM.MIX modèle moyen bibliothèque générale
*  FGL.MIX Grand modèle bibliothèque générale
*  FGPCS.MIX Petit modèle de bibliothèque auxiliaire
*  FGPCM.MIX modèle moyen bibliothèque auxiliaire
*  FGPCL.MIX Grand modèle de bibliothèque auxiliaire

Pour compiler un programme Power C à partir de la ligne de commande DOS et le lien avec
Fastgraph, utilisez le PC et les commandes PCL. Voici un exemple des séquences de commandes pour compiler un programme Power C et la liaison avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compiler- ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

  Petit modèle de mémoire:
        PC / ms <source_file>
        PCL <mix_file>; FGS [; FGPCS]

  Moyen modèle de mémoire:
        PC / mm <source_file>
        PCL <mix_file>; MGF [; FGPCM]

  Grand modèle de mémoire:
        PC / ml <source_file>
        PCL <mix_file>; FGL [; FGPCL]

Pour plus d'informations sur les modèles de mémoire ou autre compilation et options de liaison, se référer au manuel Power C, publié par Mix Software, Inc. Guide de l'utilisateur 24 Fastgraph


====Turbo C et C ++ turbo====

Turbo C et Turbo C ++ peuvent créer en mode réel et en mode 16 bits protégé
applications. Pour le mode protégé, seuls les systèmes DOS / 16M extender Rational est pris en charge. Vous pouvez compiler et lier les programmes directement à partir de la ligne de commande DOS ou de l'environnement de développement Turbo C / C ++ intégré (IDE). Les bibliothèques Fastgraph suivants sont compatibles avec Turbo C / C ++:

*  FGS.LIB en mode réel petit modèle bibliothèque générale
*  FGM.LIB en mode réel moyen modèle bibliothèque générale
*  FGL.LIB en mode réel grand modèle bibliothèque générale
*  FGTCS.LIB en mode réel petit modèle bibliothèque auxiliaire
*  FGTCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
*  FGTCL.LIB en mode réel grand modèle bibliothèque auxiliaire
*  FG16.LIB 16 bits en mode protégé bibliothèque générale
*  FG16BC.LIB 16 bits en mode protégé bibliothèque auxiliaire
*  Bibliothèque de support d'extension FG16DPMI.LIB 16 bits DPMI compatible DOS

Pour créer des applications Fastgraph dans le Turbo C / C ++ IDE, le compilateur
les options doivent correspondre à l'un des modèles de mémoire disponibles de Fastgraph (petites, moyennes ou grandes). Vous devez également créer un fichier de projet qui comprend le nom de chaque C, CPP, et le fichier LIB requis par votre application (reportez-vous à votre Turbo C ou Turbo C ++ manuels pour des informations sur les fichiers de projet). Les dossiers de projet ne sont nécessaires que lorsque vous utilisez l'IDE.

Vous pouvez également compiler et lier les programmes de la ligne de commande DOS en utilisant
la commande TCC. Voici des exemples de commandes TCC pour compiler un programme Turbo C ou Turbo C ++ et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

  Mode réel, petit modèle de mémoire:
        TCC -ms <source_file> FGS.LIB [FGTCS.LIB]

  Mode réel, modèle de support de mémoire:
        TCC -MM <source_file> FGM.LIB [FGTCM.LIB]

  Mode réel, grand modèle de mémoire:
        TCC -ml <source_file> FGL.LIB [FGTCL.LIB]

Pour créer des programmes en mode Turbo C / C ++ protégées utilisant les systèmes DOS / 16M extender Rational, se référer au Guide de l'utilisateur DOS / 16M.

Pour plus d'informations sur les modèles de mémoire ou autre compilation et liaison
les options, se référer au Guide de l'utilisateur Turbo C, Turbo Guide de référence C, ou le Guide de l'utilisateur DOS / 16M.

====Turbo Pascal====

Turbo Pascal peut construire des programmes en mode réel directement à partir de la commande DOS
ligne ou de l'environnement de développement intégré Turbo Pascal (IDE).

Pour créer des applications Fastgraph dans le Turbo Pascal IDE, il suffit de commencer la
IDE comme vous le feriez pour tout autre programme Pascal, en vérifiant que les fichiers d'unités Fastgraph résider dans l'un des répertoires listés dans "Unité Répertoires" l'option de l'IDE.

Vous pouvez également compiler des programmes Turbo Pascal de la ligne de commande DOS
en utilisant la commande TPC, comme indiqué ici:

  TPC <source_file>

Pour plus d'informations sur la compilation et l'autre des options de liaison, se référer au Guide de l'utilisateur Turbo Pascal.

Tous les exemples de programmes restants dans le Guide de l'utilisateur Fastgraph sont écrits
dans le langage de programmation C. Toutefois, lorsque vous installez Fastgraph pour Turbo Pascal, la procédure d'installation copie les versions Pascal des exemples de programmes dans le répertoire \ FG \ EXEMPLES. Guide de l'utilisateur 26 Fastgraph


====WATCOM C / C ++ WATCOM C32 pour DOS====

WATCOM C / C ++ et WATCOM C32 pour DOS les deux sont de 16 bits en mode réel et 32 ??bits
compilateurs en mode protégé (pour plus de simplicité, nous allons utiliser le WATCOM terme C / C ++ pour faire référence aux compilateur). Les deux compilateurs soutiennent le DOS / 4G, DOS / G4G et DOS / G4G Professional DOS extendeurs de Rational Systems (DOS / G4G est fourni avec les deux compilateurs), ainsi que le Lap TNT Phar | Dos-Extender SDK. Les bibliothèques Fastgraph suivantes sont compatibles avec les compilateurs Watcom:

*  FGS.LIB en mode réel petit modèle bibliothèque générale
*  FGM.LIB en mode réel moyen modèle bibliothèque générale
*  FGL.LIB en mode réel grand modèle bibliothèque générale
*  FGWCS.LIB en mode réel petit modèle bibliothèque auxiliaire
*  FGWCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
*  FGWCL.LIB en mode réel grand modèle bibliothèque auxiliaire
*  FG32.LIB 32 bits en mode protégé bibliothèque générale
*  FG32WC.LIB 32 bits en mode protégé bibliothèque auxiliaire
*  Bibliothèque de support d'extension FG32DPMI.LIB 32 bits DPMI compatible DOS
*  FG32PHAR.LIB Phar Lap TNT | Bibliothèque de support Dos-Extender

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant la WCL
ou commandes WCL386. Voici par exemple les commandes pour compiler un programme WATCOM C / C ++ et en le reliant avec Fastgraph. Les bibliothèques auxiliaires spécifiques compilateur (FGWCS, FGWCM, FGWCL et FG32WC) ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

Mode réel, petit modèle de mémoire:

  WCL / ms <source_file> FGS.LIB [FGWCS.LIB]

Mode réel, modèle de support de mémoire:

  WCL / mm <source_file> FGM.LIB [FGWCM.LIB]

Mode réel, grand modèle de mémoire:

  WCL / ml <source_file> FGL.LIB [FGWCL.LIB]

mode 32 bits protégé, tout extender Systems DOS / 4G Rational:

  WCL386 / l = dos4g <source_file> FG32.LIB FG32DPMI.LIB [FG32WC.LIB]

mode protégé 32 bits, Phar Lap TNT | Dos-Extender:

  WCL386 / l = PharLap <source_file> FG32.LIB FG32PHAR.LIB [FG32WC.LIB]

Pour plus d'informations sur la compilation et l'autre des options de liaison, s'il vous plaît
reportez-vous à la WATCOM C / C de Guide, Phar Lap de C de l'utilisateur / C ++ Guide d'utilisation de TNT Dos-Extender, ou le manuel de l'utilisateur DOS / 4G.

====Zortech C ++====

Zortech C ++ crée des applications en mode réel.  La Fastgraph suivante
bibliothèques sont compatibles avec Zortech C ++:

*  FGS.LIB en mode réel petit modèle bibliothèque générale
*  FGM.LIB en mode réel moyen modèle bibliothèque générale
*  FGL.LIB en mode réel grand modèle bibliothèque générale
*  FGZCS.LIB en mode réel petit modèle bibliothèque auxiliaire
*  FGZCM.LIB en mode réel moyen modèle bibliothèque auxiliaire
*  FGZCL.LIB en mode réel grand modèle bibliothèque auxiliaire

Les programmes sont compilés et liés à partir de la ligne de commande DOS en utilisant la ZTC
commander. Voici des exemples de commandes ZTC pour compiler un programme Zortech C ++ et en le reliant avec Fastgraph. Les noms de bibliothèques auxiliaires spécifiques compilateur ne doivent être inclus lorsque votre programme utilise l'une des routines Fastgraph énumérées à l'annexe D.

  Petit modèle de mémoire:
        ZTC -ms <source_file> FGS.LIB [FGZCS.LIB]

  Moyen modèle de mémoire:
        ZTC -MM <source_file> FGM.LIB [FGZCM.LIB]

  Grand modèle de mémoire:
        ZTC -ml <source_file> FGL.LIB [FGZCL.LIB]

Pour plus d'informations sur les modèles de mémoire ou autre compilation et options de liaison, se référer aux manuels fournis avec le compilateur de votre Zortech C. Guide de l'utilisateur 28 Fastgraph


===Fastgraph / Light Video Pilote===

Comme mentionné précédemment, l'exécution de tout programme créé avec Fastgraph / Light
exige un programme externe appelé le pilote Fastgraph / Light Vidéo. Le pilote vidéo est une fin et rester programme résident (TSR) qui fournit une interface entre votre programme et Fastgraph.

Pour charger le pilote vidéo, entrez la commande FGDRIVER à la commande DOS
prompt (en supposant que FGDRIVER.EXE est dans le répertoire courant, ou le répertoire \ FG est dans votre spécification de chemin DOS). Le pilote affichera un message indiquant si oui ou non il chargé avec succès. Après avoir chargé le pilote, il suffit d'exécuter un programme créé avec Fastgraph / Light comme vous le feriez pour tout autre programme. Si vous essayez d'exécuter un programme qui utilise Fastgraph / Light sans premier chargement du pilote vidéo, le message "pilote vidéo Fastgraph / Light pas installé" apparaît.

Vous ne devez pas charger le pilote avant d'exécuter chaque programme, juste une fois
par le démarrage du système (en fait, le pilote affichera un message "déjà chargé" si vous essayez de charger plus d'une fois). Si vous souhaitez décharger le pilote vidéo, il suffit d'entrer FGDRIVER / U à l'invite de commande DOS. L'opération de déchargement ne fonctionnera complètement que si le pilote vidéo a été le dernier TSR chargé. S'il n'a pas été le dernier TSR, le conducteur sera toujours décharger, mais la mémoire qu'il utilise ne seront pas relâchés au DOS.

==Guide de PC et PS / 2 Modes vidéo ==

Dans le PC et PS / 2 mondes, les modes vidéo déterminent la façon dont l'information
apparaît sur l'écran d'affichage de l'ordinateur. Les modes vidéo disponibles ont différentes résolutions, différents attributs de caractère ou pixel, différentes structures de mémoire vidéo, et d'autres différences matérielles inhérentes. Cependant, on n'a pas besoin d'une connaissance approfondie de ces internes de vidéo, parce Fastgraph gère les détails nécessaires.

Le PC et PS / 2 modes vidéo peuvent être séparés en deux classes principales: Texte
modes et modes graphiques. Dans les modes de texte, l'écran d'affichage est divisé en cellules de caractères. Par défaut, il y a 25 lignes et 40 ou 80 colonnes de cellules, et dans chaque cellule, nous pouvons stocker de 256 caractères dans le caractère de PC jeu IBM. Chaque personnage a un attribut associé qui détermine des choses telles que la couleur de premier plan, sa couleur de fond, et si le voyant de caractère ou non. Dans les modes graphiques, l'écran d'affichage est divisé en éléments d'image ou pixels. En fonction du mode vidéo, le nombre de rangées de pixels est compris entre 200 et 768, tandis que le nombre de colonnes varie entre 320 et 1.024. Chaque pixel a une valeur associée, qui détermine la couleur du pixel. Le nombre de cellules de caractères ou de pixels disponibles est appelé la résolution de l'écran.

L'adaptateur d'affichage (carte graphique) et l'affichage vidéo (moniteur)
qui lui est connecté à déterminer les modes vidéo disponibles sur un système donné. Le tableau suivant résume les caractéristiques du PC et PS / 2 modes vidéo qui Fastgraph soutient.

    Mode Nombre de Supporté Supporté
    No.  Type  Résolution Couleurs Adaptateurs Affiche

     0 T 40x25   16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     1 T 40x25   16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     2 T 80x25   16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     3 T 80x25   16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     4 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     5 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     6 G 640x200 2/16 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     7 T 80x25 b / w MDA, HGC, EGA, VGA, SVGA Monochrome
     9 G 320x200 16 Tandy 1000, PCjr RGB
    11 G 720x348 b / w HGC Monochrome
    12 G 320x200 b / w HGC Monochrome
    13 G 320x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
    14 G 640x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
    15 G 640x350 b / w EGA, VGA, SVGA Mono, VGA, SVGA
    16 G 640x350 16/64 EGA, VGA, SVGA ECD, VGA, SVGA
    17 G 640x480 2 / 256K VGA, MCGA, SVGA VGA, SVGA
    18 G 640x480 16 / 256K VGA, SVGA VGA, SVGA
    19 G 320x200 256 / 256K VGA, MCGA, SVGA VGA, SVGA
    20 G 320x200 256 / 256K VGA, SVGA VGA, SVGA
    21 G 320x400 256 / 256K VGA, SVGA VGA, SVGA
    22 G 320x240 256 / 256K VGA, SVGA VGA, SVGA
    23 G 320x480 256 / 256K VGA, SVGA VGA, SVGA
    24 G 640x400 256 / 256K SVGA SVGA
    25 G 640x480 256 / 256K SVGA SVGA
    26 G 800x600 256 / 256K SVGA SVGA
    27 G 1024x768 256 / 256K SVGA SVGA
    28 G 800x600 16 / 256K SVGA SVGA
    29 G 1024x768 16 / 256K SVGA SVGA

Quelques notes sur le format et les abréviations utilisées dans ce tableau sont en
commande. Dans la colonne "type", "T", un mode texte et "G" désigne un mode graphique. Une seule valeur dans la colonne "nombre de couleurs" désigne le nombre de couleurs disponibles en ce que le mode vidéo. Dans les modes de texte, une paire de nombres tels que 16/8 signifie que chaque caractère affiché peut avoir l'une des 16 couleurs de premier plan et l'un des 8 couleurs de fond. Dans les modes graphiques, une paire de nombres tels que 16/64 signifie 16 couleurs peuvent être affichées simultanément à partir d'une collection, ou une palette, de 64. Le "b / w" figurant dans les modes monochromes signifie "noir et blanc". Caractères ou pixels dans ces modes vidéo ne sont pas vraiment avoir des couleurs associées, mais plutôt avoir des attributs d'affichage tels que clignotant ou des intensités différentes.

La signification des abréviations dans les «cartes prises en charge» et

"Affiche" pris en charge les colonnes sont:

*  CGA Couleur Graphics Adapter
*  ECD écran couleur améliorée
*  EGA Adaptateur graphique amélioré
*  HGC Hercules Carte graphique
*  Tableau MCGA Graphics Multi-couleur
*  MDA Monochrome Display Adapter
*  Affichage RGB Rouge-Vert-Bleu Couleur
*  SVGA SuperVGA
*  Video Graphics Array VGA

L'utilisation du terme "VGA" dans la colonne "d'affichage supporté" fait référence à un affichage analogique, comme un moniteur VGA ou Multisync. Le terme «SVGA» se réfère explicitement à un moniteur SuperVGA ou un adaptateur.

Les IBM PS / 2 systèmes ne disposent pas d'un adaptateur et l'affichage traditionnel
combinaison. Au lieu de cela, le matériel vidéo dans ces systèmes est appelé le sous-système vidéo. Le modèle 25 et modèle 30 ont un sous-système vidéo basé sur MCGA, tandis que d'autres modèles disposent d'un sous-système vidéo basé VGA. Du point de vue de Fastgraph, le sous-système vidéo PS / 2 ne diffère pas d'une carte VGA ordinaire et moniteur.

Le reste de ce chapitre donne un aperçu des plus importants
caractéristiques et restrictions de chaque mode vidéo. La première section traite des modes de texte, tandis que la section suivante abordera les modes graphiques les.


===Modes de texte===

Il y a cinq modes texte vidéo dans le PC IBM et PS / 2 famille.  quatre d'entre
ces modes (0, 1, 2 et 3) sont conçus pour les écrans couleur, tandis que le mode (7) restant est conçu pour les écrans monochromes. Tous les modes de texte ont été introduites avec l'IBM PC.

Dans les modes de texte, l'écran est divisé en cellules de caractères.  Il y a deux
octets de mémoire vidéo associés à chaque cellule de caractère - un octet pour la valeur ASCII du caractère, et un autre pour l'attribut d'affichage du personnage. La quantité de mémoire vidéo nécessaire pour stocker un écran d'informations (appelée une page vidéo) est donc Guide de 32 Fastgraph utilisateur

  number_of_columns x NUMBER_OF_ROWS x 2

Tous les modes de texte utilisent 25 lignes, donc pour les modes 40 colonnes (0 et 1) la taille d'une page vidéo est de 2000 octets, et pour les modes 80 colonnes (2, 3 et 7) la taille d'une page vidéo est de 4000 octets.

  Mode Nombre de Supporté Supporté
  No. Type Résolution Couleurs Adaptateurs Affiche

  0 T 40x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
  1 T 40x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
  2 T 80x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
  3 T 80x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
  7 T 80x25 b / w MDA, HGC, EGA, VGA, SVGA Monochrome

Le reste de cette section décrit les modes texte vidéo dans plus
détail.

====Mode 0====

Mode 0 est un 40-colonne de 25 rangs en mode texte couleur.  Elle est souvent appelée

Mode incolore car il a été conçu pour être utilisé avec des écrans de télévision ou composites (par opposition aux écrans RVB). Lorsqu'il est utilisé avec ces types de moniteurs, les 16 disponibles "couleurs" apparaissent des nuances distinctes de gris. Lorsqu'il est utilisé avec un moniteur RGB, le mode 0 est identique à tous égards au mode 1. L'utilisation de moniteurs composites ou de télévision que PC écrans vidéo a pratiquement disparu aujourd'hui. En conséquence, le mode 0 est utilisé peu fréquemment.

====Mode 1====

Mode 1 est un 40-colonne de 25 rangs en mode texte couleur.  Il est pris en charge à travers
tous les adaptateurs vidéo et affichage couleur combinaisons dans le PC et PS / 2 familles. Caractères affichés en mode 1 ont un attribut d'affichage associé qui définit la couleur de premier plan du personnage, sa couleur de fond, et si oui ou non il clignote. Seize couleurs de premier plan et huit couleurs de fond sont disponibles.

====Mode 2====

Mode 2 est un 80-colonne de 25 rangs en mode texte couleur.  mode 0 Comme, il est
souvent appelé un mode incolore car il a été conçu pour être utilisé avec des écrans de télévision ou composites (par opposition aux écrans RVB). Lorsqu'il est utilisé avec ces types de moniteurs, les 16 disponibles "couleurs" apparaissent des nuances distinctes de gris. Lorsqu'il est utilisé avec un moniteur RGB, le mode 2 est identique à tous égards au mode 3. L'utilisation de moniteurs composites ou de télévision que PC écrans vidéo a pratiquement disparu aujourd'hui. En conséquence, le mode 2 est utilisé peu fréquemment.

====Mode 3====

Mode 3 est un 80-colonne de 25 rangs en mode texte couleur.  Il est la vidéo par défaut
mode pour les systèmes qui utilisent tout type d'écran couleur. Ce mode est supporté sur toutes les combinaisons de carte vidéo et d'affichage des couleurs dans le PC et PS / 2 familles. Les caractères affichés en mode 3 ont un attribut d'affichage associé qui définit la couleur de premier plan du personnage, sa couleur de fond, et
si oui ou non il clignote. Seize couleurs de premier plan et huit couleurs de fond sont disponibles.

====Mode 7====

Mode 7 est le 80-colonne de 25 rangs en mode texte monochrome. Il est la valeur par défaut
mode vidéo pour des systèmes qui utilisent un écran monochrome. Pour utiliser ce mode, vous devez disposer d'un adaptateur Monochrome Display (MDA), Hercules Carte graphique (HGC), ou un adaptateur graphique amélioré (EGA) connecté à un écran monochrome. La plupart des adaptateurs VGA et d'affichage SVGA fournissent également un mode d'émulation qui vous permet en mode 7 utiliser avec des écrans analogiques. Les caractères affichés en mode 7 ont un attribut d'affichage associé qui définit si le caractère est invisible, normal, gras, souligné, inversé, clignotant, ou une combinaison de ceux-ci.


===Modes graphiques===

Il y a 13 modes standards graphiques vidéo disponibles dans le PC IBM et
PS / 2 famille. Fastgraph fournit un support pour 11 des 13 modes (modes 8 et 10, spécifiques à la PCjr et Tandy 1000 systèmes, ne sont pas pris en charge). En plus de ces 13 modes, Fastgraph prend en charge six modes SuperVGA graphiques (modes 24 à 29), quatre modes VGA étendus (modes 20 à 23), et deux modes vidéo pour la carte graphique Hercules (modes 11 et 12). Les sections suivantes décrivent ces modes graphiques dans plus de détails. Les discussions comprennent un aperçu de l'organisation de la mémoire vidéo dans chaque mode, mais on n'a pas besoin d'une connaissance de ce sujet à utiliser Fastgraph.


====CGA Modes graphiques====

Modes 4, 5, et 6 sont conçus pour être utilisés avec l'adaptateur graphique couleur
(CGA) et pour cette raison sont appelés les modes CGA natifs. Ils étaient les seuls modes disponibles avec le PC IBM d'origine graphiques. adaptateurs plus récents graphiques (EGA, VGA, MCGA et SVGA) peuvent émuler le CGA, ce qui signifie que les modes les graphiques CGA sont disponibles sur un PC ou PS système / 2 équipé d'un écran couleur.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 4 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
 5 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
 6 G 640x200 2/16 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA

=====Mode 4=====

Mode 4 est un mode graphique CGA avec une résolution de 320 pixels horizontaux
par 200 pixels verticaux. Chaque pixel peut prendre l'une des quatre couleurs (les couleurs disponibles sont déterminées par lequel l'une des six palettes a été sélectionné), de sorte que chaque pixel nécessite deux bits de mémoire vidéo. Cela signifie que chaque octet de la mémoire vidéo représente quatre pixels. Guide de l'utilisateur 34 Fastgraph


=====Mode 5=====

Mode 5 est l'analogue incolore du mode 4. Il a été conçu pour être utilisé avec
moniteurs composites ou de télévision (par opposition aux moniteurs RVB). Lorsqu'il est utilisé avec ces types de moniteurs, les quatre couleurs apparaissent des nuances distinctes de gris. Lorsqu'il est utilisé avec un écran RVB, le mode 5 est essentiellement identique au mode 4. L'utilisation de moniteurs composites ou de télévision que PC écrans vidéo a pratiquement disparu aujourd'hui. En conséquence, le mode 5 est utilisé peu fréquemment.

=====Mode 6=====

Mode 6 est un mode graphique CGA avec une résolution de 640 pixels horizontaux
par 200 pixels verticaux. Chaque pixel peut prendre deux états - ou désactiver. La couleur dans laquelle le "sur" pixels apparaissent peut être choisi parmi une palette de 16 couleurs disponibles. Chaque pixel nécessite donc un bit de mémoire vidéo, ce qui signifie que chaque octet de la mémoire vidéo représente huit pixels.


====Tandy 1000 et PCjr Modes graphiques====


Modes 8, 9 et 10 ne sont disponibles que sur le PCjr et Tandy 1000 series
ordinateurs (ces systèmes prennent également en charge les modes 4, 5 et 6). Modes 8 et 10 ne sont pas largement utilisés, et pour cette raison Fastgraph ne les supporte pas.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 8 G 160x200 16 Tandy 1000, PCjr RGB
 9 G 320x200 16 Tandy 1000, PCjr RGB
 10 G 640x200 4 Tandy 1000, PCjr RGB

=====9 Mode=====

Mode 9 est un mode graphique et 1000 Tandy PCjr avec une résolution de 320
pixels horizontaux par 200 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs, de sorte que chaque pixel nécessite quatre bits de la mémoire vidéo. Cela signifie que chaque octet de la mémoire vidéo représente deux pixels. Le Tandy 1000 et PCjr utilisent de la mémoire à accès aléatoire standard (RAM) comme mémoire vidéo.


====Hercules Modes graphiques

Les modes 11 et 12 sont utilisés avec la carte graphique Hercules (HGC) et un
affichage monochrome. En tant que tel, ils ne sont pas de vrais modes vidéo IBM, mais à cause de la popularité de la HGC, Fastgraph fournit un support pour cet adaptateur.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 11 G 720x348 b / w HGC Monochrome
 12 G 320x200 b / w HGC Monochrome   
                                     Chapitre 2: PC et PS / 2 Modes vidéo 35


=====mode 11=====

Mode 11 est un vrai mode graphique Hercules avec une résolution de 720
pixels horizontaux par 348 pixels verticaux. Chaque pixel peut prendre deux états - ou désactiver. Chaque pixel nécessite donc un bit de mémoire vidéo, ce qui signifie que chaque octet de la mémoire vidéo représente huit pixels.

=====mode 12=====

Mode 12 est un mode graphique Hercules logiciel simulé avec une
résolution de 320 pixels horizontaux par 200 pixels verticaux. Son but est de fournir une résolution qui est disponible avec tous les autres adaptateurs d'affichage graphique.

Ce mode convertit toutes les coordonnées de l'espace 320x200 (appelé virtuelle
coordonnées) dans le système de coordonnées 720x348 (appelé coordonnées physiques). Il le fait en utilisant deux pixels physiques pour chaque pixel virtuel et scan de doubler les lignes virtuelles impaires. Enfin, les décalages sont ajoutés aux coordonnées physiques résultant de centrer la zone d'image sur l'écran. Cela crée une zone de l'image délimitée horizontalement par des coordonnées physiques et 40 679 et verticalement par les coordonnées physiques 24 et 323.


====EGA Modes graphiques====

Modes 13 à 16 ont été introduites avec l'adaptateur graphique amélioré
(EGA) et pour cette raison sont appelés les modes EGA natifs. adaptateurs VGA et SVGA apportent également un soutien pour ces modes, mais la MCGA ne fonctionne pas. L'EGA IBM originale ne contenait 64K octets de mémoire vidéo, mais la mémoire peut être ajoutée en 64K incréments pour remplir entièrement l'adaptateur avec 256K octets de mémoire vidéo.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 13 G 320x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
 14 G 640x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
 15 G 640x350 b / w EGA, VGA, SVGA Mono, VGA, SVGA
 16 G 640x350 16/64 EGA, VGA, SVGA ECD, VGA, SVGA

=====13 Mode=====

Mode 13 est un mode EGA graphique avec une résolution de 320 horizontale
pixels par 200 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs, de sorte que chaque pixel nécessite quatre bits de la mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo fait référence en fait quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion.

=====mode 14=====

Mode 14 est un mode EGA graphique avec une résolution de 640 horizontale
pixels par 200 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs, de sorte que chaque pixel nécessite quatre bits de la mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo référence fait Guide de l'utilisateur 36 Fastgraph
quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion.

=====mode 15=====

Mode 15 est un mode graphique monochrome EGA avec une résolution de 640
pixels horizontaux par 350 pixels verticaux. Chaque pixel peut prendre l'un des 4 attributs d'affichage, de sorte que chaque pixel nécessite deux bits de mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits, dont deux sont désactivés. Chaque adresse de mémoire vidéo fait référence en fait deux octets, un dans chaque plan est activé. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion.

=====16 Mode=====

Mode 16 est un mode EGA graphique avec une résolution de 640 horizontale
pixels par 350 pixels.1 vertical Chaque pixel peut supposer une des 16 couleurs (16 couleurs peuvent être sélectionnés à partir d'une palette de 64 couleurs), de sorte que chaque pixel nécessite quatre bits de mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo fait référence en fait quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion.

En mode 16, la taille de la page vidéo est en fait 640 par 400 pixels, bien que
la résolution d'écran est de 640 par 350. Les 50 dernières rangées de pixels (350 à 399) sur chaque page vidéo ne sont pas affichés, mais sont disponibles pour le stockage hors-écran.

====VGA et MCGA Modes graphiques====

Modes 17, 18, et 19 ont été introduits avec la vidéo MCGA et VGA
sous-systèmes des IBM PS / 2 ordinateurs. Depuis l'introduction du PS / 2, d'autres fabricants ont développé des cartes VGA qui peuvent être utilisés avec la famille de PC. adaptateurs VGA et SVGA supportent tous les trois de ces modes, mais le MCGA ne supporte pas le mode 18. Modes 17 et 18 sont appelés modes VGA natifs.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 17 G 640x480 2 / 256K VGA, MCGA, SVGA VGA, SVGA
 18 G 640x480 16 / 256K VGA, SVGA VGA, SVGA
 19 G 320x200 256 / 256K VGA, MCGA, SVGA VGA, SVGA

=====mode 17=====

Mode 17 est un connecteur VGA et le mode graphique MCGA avec une résolution de 640
pixels horizontaux par 480 pixels verticaux. Chaque pixel peut prendre deux états - ou désactiver. La couleur dans laquelle le "sur" et pixels "off" apparaissent peut être choisi parmi une palette de 262.144 couleurs disponibles. Chaque pixel nécessite donc un bit de mémoire vidéo, ce qui signifie que chaque octet de la mémoire vidéo représente huit pixels. Sur les systèmes VGA et SVGA, la mémoire vidéo est organisé comme quatre plans de bits et le mode 17 est mis en œuvre en permettant un de ces avions.

=====mode 18=====

Mode 18 est un mode graphique VGA natif avec une résolution de 640 horizontale
pixels par 480 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs (16 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite quatre bits de mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo fait référence en fait quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion.

=====mode 19=====

Mode 19 est un connecteur VGA et le mode graphique MCGA avec une résolution de 320
pixels horizontaux par 200 pixels verticaux. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de la mémoire vidéo représente un pixel.


====VGA étendue Modes (XVGA) Graphiques====

Modes 20 à 23 sont les modes VGA ou XVGA graphiques étendues.  Bien que
ces modes vidéo ne sont pas des modes VGA standard, ils vont travailler sur un VGA ou un adaptateur compatible SVGA registres ont. Ces modes vidéo sont particulièrement populaires pour le développement du jeu, car ils offrent la page redimensionnement vidéo, tandis que le mode 256 couleurs standard ne fonctionne pas. Mode 20 est la version XVGA du mode 19, tandis que le mode 21 utilisations scan doubler pour atteindre un affichage de 400 lignes. Mode 22 est ce qu'on appelle le mode "X" et est attrayante parce qu'il a un rapport 1: 1 d'aspect. Mode 23 est identique au mode 22, mais il utilise doublement scan pour obtenir un affichage de 480 lignes.

 Mode Nombre de Supporté Supporté
 No. Type Résolution Couleurs Adaptateurs Affiche

 20 G 320x200 256 / 256K VGA, SVGA VGA, SVGA
 21 G 320x400 256 / 256K VGA, SVGA VGA, SVGA
 22 G 320x240 256 / 256K VGA, SVGA VGA, SVGA
 23 G 320x480 256 / 256K VGA, SVGA VGA, SVGA

=====20 Mode=====

Mode 20 est un mode XVGA graphique avec une résolution de 320 horizontale
pixels par 200 pixels verticaux. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de la mémoire vidéo représente un pixel. Ce mode offre la même résolution et nombre de couleurs que le mode 19, mais sa mémoire vidéo est organisée comme une série de quatre plans de bits. Chaque quatrième pixel est stocké dans le même plan (soit un pixel dont la coordonnée horizontale x est dans le plan x réside modulo 4).

=====mode 21=====

Mode 21 est un mode graphique couleur XVGA avec une résolution de 320
pixels horizontaux par 400 pixels verticaux. À l'exception de la résolution, son organisation de mémoire vidéo est identique au mode 20. Guide de l'utilisateur 38 Fastgraph

=====mode 22=====

Mode 22 est un mode graphique couleur XVGA avec une résolution de 320
pixels horizontaux par 240 pixels verticaux. Ceci est la soi-disant mode "X" rendu célèbre par Michael Abrash dans le Journal de Dr. Dobb. À l'exception de la résolution, l'organisation de la mémoire vidéo est identique au mode 20.

=====mode 23=====

Mode 23 est un mode graphique couleur XVGA avec une résolution de 320
pixels horizontaux par 480 pixels verticaux. À l'exception de la résolution, l'organisation de la mémoire vidéo est identique au mode 20.


====SuperVGA Modes (SVGA) Graphiques====

Modes 24 à 29 sont les modes SuperVGA ou SVGA graphiques.  Si vous avez
fait du travail avec des cartes SVGA, vous savez probablement que différents fabricants utilisent des numéros différents pour référencer les modes SVGA vidéo. Par exemple, le numéro de mode 640x480 graphiques 256 couleurs est 62 hex sur les cartes ATI, 5D hex sur les cartes Trident et 2F hex sur Tseng Labs cartes. le noyau SVGA de Fastgraph, décrit en détail dans le chapitre suivant, gère les détails de SVGA générale des numéros de mode vidéo de cartographie Fastgraph (24 à 29) aux numéros des cartes SVGA pris en charge le mode vidéo spécifiques chipset.

  Mode Nombre de Supporté Supporté
  No. Type Résolution Couleurs Adaptateurs Affiche

  24 G 640x400 256 / 256K SVGA SVGA
  25 G 640x480 256 / 256K SVGA SVGA
  26 G 800x600 256 / 256K SVGA SVGA
  27 G 1024x768 256 / 256K SVGA SVGA
  28 G 800x600 16 / 256K SVGA SVGA
  29 G 1024x768 16 / 256K SVGA SVGA

=====mode 24=====

Mode 24 est un mode graphique SuperVGA avec une résolution de 640 horizontale
pixels par 400 pixels verticaux. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de mémoire vidéo représente un pixel, donc au moins 256K de mémoire vidéo est nécessaire pour ce mode. Notez qu'un bon nombre de cartes SVGA ne supportent pas ce mode vidéo.

=====mode 25=====

Mode 25 est un mode graphique SuperVGA avec une résolution de 640 horizontale
pixels par 480 pixels verticaux. Il est probablement le mode le plus populaire graphique SVGA. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de mémoire vidéo représente un pixel, donc au moins 512K de mémoire vidéo est nécessaire pour ce mode.

=====mode 26=====

Mode 26 est un mode graphique SuperVGA avec une résolution de 800 horizontale
pixels par 600 pixels verticaux. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de mémoire vidéo représente un pixel, donc au moins 512K de mémoire vidéo est nécessaire pour ce mode.

=====mode 27=====

Mode 27 est un mode graphique SuperVGA avec une résolution de 1024 horizontale
pixels par 768 pixels verticaux. Chaque pixel peut prendre l'une des 256 couleurs (256 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite huit bits de mémoire vidéo. Cela signifie que chaque octet de mémoire vidéo représente un pixel, donc au moins 768K de mémoire vidéo est nécessaire pour ce mode.

=====mode 28=====

Mode 28 est un mode graphique SuperVGA avec une résolution de 800 horizontale
pixels par 600 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs (16 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite quatre bits de mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo fait référence en fait quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion. Au moins 256K de mémoire vidéo est nécessaire pour utiliser ce mode.

=====mode 29=====

Mode 29 est un mode graphique SuperVGA avec une résolution de 1024 horizontale
pixels par 768 pixels verticaux. Chaque pixel peut prendre l'une des 16 couleurs (16 couleurs peuvent être sélectionnées à partir d'une palette de 262.144 couleurs), de sorte que chaque pixel nécessite quatre bits de mémoire vidéo. Dans ce mode, la mémoire vidéo est organisée en quatre plans de bits. Chaque adresse de mémoire vidéo fait référence en fait quatre octets, un dans chaque plan. En d'autres termes, chaque octet de mémoire vidéo fait référence à huit pixels, stockées un bit par avion. Au moins 512K de mémoire vidéo est nécessaire pour utiliser ce mode. Guide de l'utilisateur 40 Fastgraph


==Initialisation Guide de l'utilisateur Vidéo Environnement==

Avant Fastgraph peut effectuer toutes les opérations du texte ou des graphiques vidéo, vous
doit sélectionner un mode vidéo dans lequel votre programme sera exécuté. Une partie importante de cette sélection dépend de votre programme sera exécuté en mode texte, un mode graphique, ou les deux. Les deux premières sections de ce chapitre discutent de l'initialisation vidéo nécessaire pour les modes de texte et de graphiques standard, tandis que la dernière section traite de la configuration supplémentaire nécessaire pour SuperVGA (SVGA) modes graphiques.


===Mise en place d'un mode texte===

Lorsque vous écrivez un programme qui utilise uniquement des modes de texte, vous devez déterminer si
le programme sera exécuté sur les systèmes monochromes, des systèmes de couleurs, ou les deux. En général, il n'y a aucune raison d'exclure un type de système, car la programmation supplémentaire nécessaire pour soutenir à la fois est assez trivial.

La fg_setmode routine Fastgraph établit un mode vidéo et initialise
paramètres internes de Fastgraph pour ce mode. Cette routine a un seul argument entier dont la valeur est une vidéo numéro de mode entre 0 et 29. Sa valeur peut aussi être -1, ce qui indique Fastgraph d'utiliser le mode vidéo actuel. Spécification d'un argument fg_setmode de -1 est souvent utile dans les programmes qui utilisent uniquement les modes vidéo de texte.

Lorsque vous établissez un mode vidéo texte, la ROM BIOS curseur de texte est fait
visible, ce qui est souvent indésirable. La fg_cursor routine Fastgraph contrôle la visibilité du curseur de texte. La routine de fg_cursor a un seul argument entier qui spécifie la visibilité du curseur. Si sa valeur est 0, le curseur est rendu invisible; si sa valeur est 1, le curseur est rendu visible.

À ce stade, un exemple peut aider à clarifier les choses.  Nous allons commencer par un
variation célèbre "Bonjour, monde" programme de Kernighan et Ritchie qui montre comment initialiser Fastgraph pour les 80 colonnes en mode texte couleur (mode 3) et désactiver le curseur en mode texte. Il utilise deux routines Fastgraph que nous avons pas encore discuté, fg_setcolor et fg_text. Pour l'instant, il suffira de savoir que fg_setcolor (15) rend le texte ultérieur apparaissent en blanc, et fg_text affiche les caractères qui lui sont transmis.

  Exemple 3-1.

  #include <fastgraf.h>
                        void main (void);

  void main ()
                        {
                           fg_initpm ();
                           fg_setmode (3);
                           fg_cursor (0);

  fg_setcolor (15);
                           fg_text ( "Bonjour, monde.", 13);
                        }
                           Chapitre 3: Initialisation de l'environnement Vidéo 43


Si vous exécutez par exemple 3-1, notez le texte affiché par le programme apparaît
dans le coin supérieur gauche de l'écran. Sur la ligne ci-dessous présente, l'invite DOS apparaît, en attendant votre prochaine commande DOS. En outre, si votre système utilise le pilote ANSI.SYS pour définir les attributs de l'écran (par exemple avec le programme de SA de Norton), vous devriez également remarquer que l'invite DOS apparaît dans les couleurs définies par l'écran attributs - le reste de l'écran est vide .

Un retour plus gracieux au DOS est nécessaire.  Dans l'exemple 3-2, nous allons utiliser le
Fastgraph fg_reset routine. Cette routine efface l'écran, et si le pilote ANSI.SYS est chargé, fg_reset restaure également tous les attributs d'écran précédemment définis. Nous avons également inclus un appel à la routine fg_waitkey Fastgraph attendre une touche avant de quitter. Si nous ne faisons pas cela, nous ne serions jamais voir la sortie du programme.

  Exemple 3-2.

  #include <fastgraf.h>
                        void main (void);

  void main ()
                        {
                           fg_initpm ();
                           fg_setmode (3);
                           fg_cursor (0);

  fg_setcolor (15);
                           fg_text ( "Bonjour, monde.", 13);
                           fg_waitkey ();

  fg_reset ();
                        }


Depuis des exemples 3-1 et 3-2 utilisent spécifiquement mode vidéo 3, ils ne seraient pas
travailler sur un système monochrome. Idéalement, nous aimerions utiliser fg_setmode (3) pour les systèmes de couleurs et fg_setmode (7) pour les systèmes monochromes. Pour ce faire, nous avons besoin d'un moyen de déterminer si le programme est exécuté sur un système de couleur ou sur un système monochrome. L'exemple suivant illustre un moyen facile de faire cela.

  Exemple 3-3 utilise la routine fg_testmode Fastgraph pour déterminer si le

Le système de l'utilisateur appuiera le numéro de mode vidéo spécifié comme premier argument (le second argument est le nombre de pages vidéo nécessaire, qui sera 1 pour tous les exemples de cette section). La routine fg_testmode renvoie une valeur de 1 (comme valeur de fonction) si le mode vidéo demandé peut être utilisé, et il renvoie la valeur 0 sinon. Le programme voit d'abord si un mode texte couleur 80 colonnes est disponible (mode 3), et si oui, il sélectionne ce mode. Si le mode de couleur ne sont pas disponibles, il vérifie si le mode de texte monochrome est disponible (mode 7), et si oui, il choisit le mode monochrome. Si aucun mode est disponible, le programme suppose le système de l'utilisateur dispose d'un écran 40 colonnes, émet un message indiquant le programme nécessite un affichage de 80 colonnes, puis quitte.

  Exemple 3-3.

  #include <fastgraf.h>
                   #include <stdio.h>
                   #include <stdlib.h>

  void main (void);

  void main ()
                   {
                      int old_mode;

  fg_initpm ();
                      fg_getmode old_mode = ();

  if (fg_testmode (3,1))
                         fg_setmode (3);
                      else if (fg_testmode (7,1))
                         fg_setmode (7);
                      autre {
                         printf ( "Ce programme nécessite \ n");
                         printf ( "un affichage de 80 colonnes. \ n");
                         sortie (1);
                         }
                      fg_cursor (0);

  fg_setcolor (15);
                      fg_text ( "Bonjour, monde.", 13);
                      fg_waitkey ();

  fg_setmode (old_mode);
                      fg_reset ();
                   }


Exemple 3-3 illustre également une autre procédure utile.  C'est recommandé,
en particulier dans les modes graphiques, pour restaurer le mode vidéo d'origine et de l'écran des attributs avant qu'un programme retourne au DOS. Nous avons déjà vu comment la routine fg_reset restaure les attributs de l'écran, mais comment pouvons-nous restaurons le mode vidéo original? La fg_getmode routine Fastgraph renvoie le mode vidéo actuel comme valeur de fonction. Si nous appelons fg_getmode avant d'appeler fg_setmode, nous pouvons sauver la valeur de retour de fg_getmode et le transmettre à fg_setmode juste avant le programme se termine.

Vous pouvez également utiliser une autre Fastgraph routine, fg_bestmode, afin de déterminer si
un mode vidéo avec une résolution spécifique est disponible sur le système de l'utilisateur. La routine de fg_bestmode nécessite trois arguments entiers: une résolution horizontale, une résolution verticale, et le nombre de pages vidéo nécessaires. Comme sa valeur de fonction, fg_bestmode renvoie le numéro de mode vidéo qui offre le plus de capacités pour la résolution et le nombre de pages demandées. Il renvoie une valeur de -1 si aucun mode vidéo disponible offre aux critères demandés.

Par exemple, si nous avons besoin d'un mode texte 80x25, nous pouvons utiliser la fonction
appeler fg_bestmode (80,25,1) pour choisir le "meilleur" mode vidéo disponible qui offre cette capacité. Dans les modes de texte, le terme signifie mieux pour donner la préférence à un mode de texte de couleur sur un mode texte monochrome. Exemple 3-4 remplit la même fonction que dans l'exemple 3-3, mais elle utilise plutôt que fg_bestmode fg_testmode.

  Exemple 3-4.

  #include <fastgraf.h>
                   #include <stdio.h>

  #include <stdlib.h>
                   void main (void);

  void main ()
                   {
                      int old_mode;
                      int new_mode;

  fg_initpm ();
                      fg_getmode old_mode = ();
                      new_mode = fg_bestmode (80,25,1);

  if (new_mode <0) {
                         printf ( "Ce programme nécessite \ n");
                         printf ( "un affichage de 80 colonnes. \ n");
                         sortie (1);
                         }

  fg_setmode (new_mode);
                      fg_cursor (0);

  fg_setcolor (15);
                      fg_text ( "Bonjour, monde.", 13);
                      fg_waitkey ();

  fg_setmode (old_mode);
                      fg_reset ();
                   }


Modes de texte de 43 lignes et 50 lignes

Lors de l'utilisation d'un mode texte de 80 colonnes sur un système équipé d'un EGA, VGA,
MCGA, ou SVGA d'affichage vidéo et l'adaptateur, vous pouvez étendre la taille de l'écran de 25 lignes à 43 ou 50 lignes. Alors que tous les systèmes offrent des modes de texte 25 systèmes en ligne EGA, offrent également des modes 43 de ligne, les systèmes MCGA offrent également des modes de 50 lignes, et des systèmes VGA et SVGA offrent à la fois des modes de 43 lignes et de 50 lignes. Le mode 43-ligne ne sont pas disponibles sur les systèmes EGA équipés d'un affichage RGB. Si vous étendez la taille de l'écran à 43 ou 50 lignes, la taille des caractères physiques est réduit proportionnellement de façon toutes les lignes apparaissent à l'écran.

La routine de fg_setlines définit le nombre de lignes de texte par écran.  Il
a un seul argument entier dont la valeur doit être 25, 43 ou 50. Si vous passez toute autre valeur à fg_setlines, ou passez une valeur non prise en charge par la configuration vidéo du système hôte, fg_setlines ne fait rien. En outre, appelant fg_setlines rend le curseur de texte visible. Une autre routine Fastgraph, fg_getlines, retourne comme valeur de fonction du nombre de lignes de texte actuellement en vigueur. Vous pouvez également utiliser fg_getlines dans les modes graphiques vidéo.

Exemple 3-5 illustre l'utilisation des fg_setlines et fg_getlines
routines. Le programme établit d'abord le mode texte de couleur 80 colonnes (cela définit la taille de l'écran à sa 25 ligne par défaut) et rend le curseur de texte invisible. Il affiche ensuite les mots «première ligne» dans le coin supérieur gauche de l'écran. Ensuite, le programme vérifie si un EGA avec affichage amélioré est disponible, et si oui, change l'écran à 43 lignes (mode vidéo 16 est Guide de l'utilisateur seulement 46 Fastgraph
disponible sur les systèmes EGA équipés d'un affichage amélioré). Ensuite, le programme vérifie si un VGA, MCGA, ou SVGA est disponible, et si oui change l'écran à 50 lignes (mode vidéo 17 est disponible uniquement sur ces systèmes). Enfin, le programme restaure le mode vidéo original, restaure le nombre de lignes par écran à son réglage d'origine, et restaure l'écran d'origine attributs avant de quitter.

  Exemple 3-5.

  #include <fastgraf.h>
                         void main (void);

  void main ()
                         {
                            lignes int;
                            int old_lines;
                            int old_mode;

  fg_initpm ();
                            fg_getlines old_lines = ();
                            fg_getmode old_mode = ();
                            fg_setmode (3);
                            fg_cursor (0);

  fg_setcolor (15);
                            fg_text ( "première ligne", 10);
                            fg_waitkey ();

  if (fg_testmode (16,0)) {
                               fg_setlines (43);
                               fg_cursor (0);
                               fg_waitkey ();
                               }

  if (fg_testmode (17,0)) {
                               fg_setlines (50);
                               fg_cursor (0);
                               fg_waitkey ();
                               }

  fg_setmode (old_mode);
                            (fg_setlines old_lines);
                            fg_reset ();
                         }


===L'établissement d'un mode graphique===

Les étapes pour établir un mode graphique sont similaires à l'établissement d'un
mode texte. Cependant, il y a plus de restrictions depuis certains systèmes ne peuvent pas supporter tous les modes graphiques vidéo. Par exemple, un programme ne peut pas fonctionner en mode 13 sur un système CGA, ni une exécution du programme en mode 9 sur quoi que ce soit, sauf un système Tandy 1000 ou PCjr pouvait.

Pour les programmes graphiques, il peut suffire d'écrire un programme à exécuter dans un
mode vidéo spécifique, mais il est souvent plus souhaitable d'écrire un programme qui se déroulera dans l'un des plusieurs modes vidéo. Cela est particulièrement vrai pour les produits commerciaux, car ils devraient idéalement fonctionner sur autant de configurations vidéo différents que possible.

Fastgraph comprend une fg_automode nommée routine qui détermine la
graphiques mode vidéo qui offre le plus de fonctionnalités pour la configuration matérielle de la vidéo de l'utilisateur. Par exemple, les ordinateurs Tandy 1000 de la série prennent en charge les trois modes CGA (4, 5 et 6) et 16 couleurs Tandy en mode 320x200 1000 (9). Parmi ces modes, le mode 9 offre le plus de fonctionnalités à partir d'un point de vue graphique, donc fg_automode retournera une valeur de 9 lorsqu'il est exécuté sur un ordinateur Tandy 1000. Le tableau suivant résume les numéros de mode vidéo renvoyés par fg_automode pour les combinaisons adaptateur-affichage donné. Pour maintenir la compatibilité avec les versions antérieures de Fastgraph, fg_automode ne considère pas les modes graphiques VGA étendus (modes 20 à 23) ou les modes (modes 24 à 29) lors de la sélection d'un mode vidéo SVGA graphiques.


  afficher
                       adaptateur mono RGB ECD VGA

  MDA 7 0 7 7
                          HGC 11 0 0 11
                          CGA 0 4 0 0
                          EGA 15 13 16 0
                          VGA 17 17 17 18
                         MCGA 17 17 17 19
                        Tandy 7 9 0 0
                         PCjr 7 9 0 0


  Exemple 3-6 montre comment utiliser fg_automode pour déterminer les graphiques "meilleurs"

Mode pour le matériel vidéo de l'utilisateur. Dans un mode graphique, le terme signifie la meilleure résolution la plus élevée, suivie par le nombre de couleurs disponibles. Le programme affiche un message qui inclut le numéro de mode vidéo sélectionné.

  Exemple 3-6.

  #include <fastgraf.h>
                    #include <stdio.h>
                    void main (void);

  void main ()
                    {
                       int old_mode;
                       int new_mode;
                       chaîne char [4];

  fg_initpm ();
                       fg_getmode old_mode = ();
                       fg_automode new_mode = ();
                       fg_setmode (new_mode);

  fg_setcolor (15);
                       fg_text ( «Je suis en cours d'exécution en mode", 20); 

  sprintf (string, "% d.", new_mode);
                       fg_text (string, 3);
                       fg_waitkey ();

  fg_setmode (old_mode);
                       fg_reset ();
                    }

Pour les programmes simples comme par exemple 3-6, différentes résolutions d'écran peut
pas être un problème. Cependant, dans des programmes graphiques plus complexes, il est souvent souhaitable d'écrire un programme pour une résolution d'écran fixe. Une pratique courante consiste à élaborer des programmes graphiques pour exécuter en mode 4 (pour les CGA), 9 (Tandy 1000 ou PCjr), 12 (Hercules), 13 (EGA, VGA ou SVGA), et 19 ou 20 (MCGA, VGA, ou SVGA). La raison de la sélection de ces cinq modes est qu'ils utilisent tous la même résolution 320x200 et fonctionne sur tout PC IBM ou PS / 2 avec des capacités graphiques.

  Exemple 3-7 remplit la même fonction que dans l'exemple 3-6, mais il utilise

fg_bestmode au lieu de fg_automode de limiter le programme aux modes graphiques 320x200. Pour cette résolution, la routine de fg_bestmode va d'abord vérifier la disponibilité du mode 20, suivi de modes 19, 13, 9, 4 et 12. Si fg_bestmode détermine pas le mode 320x200 graphique est disponible (indiqué par une valeur de retour de -1), le programme imprime un message et des sorties d'information. Dans le cas contraire, il sélectionne le mode fg_bestmode vidéo propose et continue.

  Exemple 3-7.

  #include <fastgraf.h>
     #include <stdio.h>
     #include <stdlib.h>
     void main (void);

  void main ()
     {
        int old_mode;
        int new_mode;
        chaîne char [4];

  fg_initpm ();
        fg_getmode old_mode = ();
        new_mode = fg_bestmode (320,200,1);

  if (new_mode <0) {
           printf ( "Ce programme nécessite un mode 320 de 200 graphiques. \ n");
           sortie (1);
           }

  fg_setmode (new_mode);

  fg_setcolor (15);
        fg_text ( «Je suis en cours d'exécution en mode", 20);
        sprintf (string, "% d.", new_mode);
        fg_text (string, 3);
        fg_waitkey (); 

  fg_setmode (old_mode);
        fg_reset ();
     }


Si un programme se déroulera dans les modes vidéo spécifiques, vous pouvez envisager
en utilisant la routine de fg_testmode au lieu de fg_bestmode pour vérifier la disponibilité de ces modes vidéo. Vous pouvez également vouloir utiliser fg_testmode pour changer la priorité du mode vidéo utilisé par fg_bestmode. Par exemple, le mode 13 (EGA) est plus rapide que le mode 19 (MCGA), de sorte que vous voudrez peut-être envisager de donner la priorité EGA sur MCGA, surtout si votre programme ne pas utiliser plus de 16 couleurs.

  Exemple 3-8 est similaire à l'exemple 3-7, mais il ne fonctionnera que dans le

320x200 modes graphiques EGA, MCGA, et CGA (modes vidéo 13, 19 et 4, respectivement). Le programme utilise fg_testmode pour sélectionner son mode vidéo. Notez l'ordre des appels à fg_testmode donne la priorité EGA sur MCGA et MCGA préséance sur CGA.

  Exemple 3-8.

  #include <fastgraf.h>
        #include <stdio.h>
        #include <stdlib.h>
        void main (void);

  void main ()
        {
           int old_mode;
           chaîne char [4];

  fg_initpm ();
           fg_getmode old_mode = ();

  if (fg_testmode (13,1))
              fg_setmode (13);
           else if (fg_testmode (19,1))
              fg_setmode (19);
           else if (fg_testmode (4,1))
              fg_setmode (4);
           autre {
              printf ( "Ce programme nécessite un EGA, MCGA, CGA ou \ n.");
              sortie (1);
              }

  fg_setcolor (15);
           fg_text ( «Je suis en cours d'exécution en mode", 20);
           sprintf (string, "% d.", getMode ());
           fg_text (string, 3);
           fg_waitkey ();

  fg_setmode (old_mode);
           fg_reset ();
        }

===SuperVGA Modes graphiques===

Contrairement aux générations précédentes de cartes graphiques, il n'y avait pas de vidéo
norme en place lorsque différentes entreprises ont commencé à développer des cartes SVGA. En conséquence, ils ont mis en œuvre des fonctionnalités améliorées SVGA en fonction de leurs propres caractéristiques basées sur différentes puces de contrôleur vidéo. Chaque telle mise en œuvre est appelé un chipset. Bien que chaque chipset offre généralement la même organisation de mémoire vidéo et les résolutions d'écran courantes, les caractéristiques SVGA- tels que le mode d'initialisation, la commutation de banque, et réglage de l'adresse de début d'affichage diffèrent radicalement entre les chipsets. En d'autres termes, le code écrit pour un SVGA chipset spécifique ne fonctionnera pas sur un autre chipset, même à la même résolution. Voilà pourquoi de nombreux fournisseurs de logiciels offrent différents pilotes SVGA pour leurs produits.

le noyau SVGA intégré de Fastgraph rend ces différences obscures
entre SVGA chipsets transparent, sans la nécessité pour les conducteurs externes. Cela signifie, par exemple, si vous écrivez une application pour le 1024 768 256 couleurs en mode graphique SVGA, il fonctionnera sans modifications sur tout chipset SVGA soutenu qui offre cette résolution. Le noyau SVGA prend en charge les chipsets répertoriés dans le tableau ci-dessous. Une entrée "Y" signifie que le chipset supporte le mode vidéo, et un "N" signifie qu'il ne fait pas. Les deux dernières lignes du tableau montrent la quantité minimale de mémoire vidéo requis pour soutenir chaque mode et les numéros de mode vidéo correspondant de Fastgraph.

  -------- -------- 256 couleurs - 16 couleurs -

SVGA chipset 640x400 640x480 800x6001024x768 800x6001024x768 Ahead type "A" YYYNYY Ahead type "B" YYYYYY ARK Logic série 1000/2000 YYYYYY ATI 18800 YYYNYN ATI 18800-1 YYYNYY ATI 28800 / mach32 / mach64 YYYYYY Avance Logic 2000 série YYYYYY Chips & Technologies 82c451 YNNNYN Chips & technologies 82c452 YYNNYY Chips & technologies 82c453 YYYYYY Chips & Tech 64xxx / 655xx YYYYYY Cirrus Logic 5400/6200/7540 NYYYYY Cirrus Logic 6400 série YYYYYY Genoa 6000 YYYNYY Matrox MGA-2064W (Millennium) YYYYYN NCR 77C22 / 77C32 YYYYYY Oak OTI- 067 NYYNYY Oak OTI-077 NYYYYY Oak OTI-087 YYYNYY Paradise PVGA1a YYNNYN Paradise WD90C00 / 10/24 YYNNYY Paradise WD90C11 / 30 / 31/33 YYYYYY Realtek 3100 séries YYYYYY S3 NYYYYY SiS YYYYYY Trident 8800 YYYNYY Trident 8900/9000 YYYYYY Tseng ET3000 NYYNYY Tseng ET4000 YYYYYY Video7 YYYYYY vidéo RAM minimum nécessaire 256K 512K 512K 256K 512K 1MB Fastgraph de numéro de mode 24 25 26 27 28 29


Le noyau SVGA cartes des numéros de mode vidéo de Fastgraph (24 à 29) pour les numéros de mode spécifiques le chipset. Par exemple, le mode 256 couleurs SVGA 640x480 est 62 hex sur une carte ATI, 5D hex sur une carte Trident et 2F hex sur une carte Tseng, mais il est toujours en mode 25 du point de vue Fastgraph. Comme nous ajoutons constamment de soutien pour les nouveaux chipsets SVGA, consulter le fichier READ.ME de Fastgraph pour la liste de chipset actuel. Le fichier READ.ME répertorie également les problèmes connus et les limites avec les différents chipsets.

La Video Electronics Standards Association (VESA de) a pris la
tâche complexe d'améliorer la compatibilité des logiciels de cartes SVGA de différentes entreprises. La plupart des cartes SVGA vendus aujourd'hui comprennent la compatibilité VESA, soit directement dans la ROM ou par l'intermédiaire des pilotes logiciels chargeables fournis avec la carte. En plus de soutenir les chipsets spécifiques, SVGA le noyau de Fastgraph prend en charge toutes les cartes SVGA avec une compatibilité VESA. Notez que VESA est pas un chipset, mais une interface au niveau du BIOS entre une application (le noyau SVGA dans ce cas) et les fonctions spécifiques au chipset. Bien que la norme VESA actuelle couvre tous les modes graphiques six SVGA Fastgraph soutient, ces modes ne sont disponibles que si le chipset sous-jacent les prend en charge également.

Lorsque vous utilisez la compatibilité VESA, le BIOS VESA gère tout chipset spécifique
des fonctions telles que le changement de banque. Les frais généraux imposés par le BIOS rend généralement le VESA modes plus lent que d'utiliser directement des fonctions spécifiques du chipset. Pour cette raison, vous pouvez spécifier si vous voulez donner la priorité au code spécifique chipset ou le BIOS VESA. priorité spécifique à Chipset signifie que le noyau SVGA utilisera uniquement le BIOS VESA si aucun chipset SVGA pris en charge est trouvé. A l'inverse, VESA priorité signifie que le noyau utilisera uniquement les fonctions spécifiques si le chipset ne VESA BIOS est trouvé.

Avant d'utiliser un mode graphique SVGA, vous devez utiliser le fg_svgainit
routine pour initialiser le noyau SVGA (fg_svgainit doit être appelée avant fg_setmode, fg_bestmode ou fg_testmode). Il y a trois façons d'initialiser le noyau SVGA avec fg_svgainit:

* Code autodetect le chipset SVGA, priorité du chipset spécifique
* Autodetect le chipset SVGA, la priorité au BIOS VESA
* Utiliser un chipset SVGA désigné

L'argument de la routine fg_svgainit est une valeur entière entre 0 et 34 qui spécifie la méthode d'initialisation à utiliser. En passant de 0 à fg_svgainit utilise la première méthode, dans laquelle le noyau recherches SVGA pour tous pris en charge les chipsets avant de vérifier si un BIOS VESA est présent. Cela signifie que le noyau SVGA utilisera uniquement les fonctions VESA si fg_svgainit ne trouve pas l'un des chipsets pris en charge. Passant 1 à fg_svgainit effectue également une autodetect chipset, mais dans ce cas, le noyau sur SVGA recherche un BIOS VESA, puis à travers la liste des chipsets pris en charge. Cela signifie code spécifique chipset ne sera utilisée que lorsque aucun VESA BIOS est trouvé. Vous pouvez également initialiser le noyau SVGA pour un chipset spécifique en passant une valeur comprise entre 2 et 34 à fg_svgainit. Le tableau suivant résume les codes fg_svgainit d'initialisation.

          Code chipset
          0 autodetect (avec priorité spécifique au chipset)
          1 autodetect (avec VESA priorité)
          "A" type 2 Ahead
          "B" type 3 Ahead

          4 ATI 18800 5 ATI 18800-1 6 ATI 28800/38800 7 Chips & Technologies 82c451 / 455 / 456/457 8 Chips & technologies 82c452 9 Chips & Technologies 82c450 / 453 10 Gênes série 6000 11 Oak OTI-067 12 Paradise PVGA1a 13 Paradise WD90C00 / WD90C10 / WD90C24 14 Paradise WD90C11 / WD90C30 / WD90C31 / WD90C33 15 Trident 8800 16 Trident 8900/9000 17 Tseng ET3000 18 Tseng ET4000 19 Video7 20 Cirrus Logic 5400/6200/7540 série 21 S3 22 NCR 77C22 / 77C32 23 Oak OTI- 077 24 Oak OTI-087 25 Oak OTI-087 (Diamond Viper BIOS) 26 Cirrus Logic 6400 série 27 Avance Logic série 2000 28 ARK Logic 1000/2000 29 ATI 68800 (mach32) 30 ATI 88800 (mach64) 31 Chips & Technologies 64000 / 65500 série 32 Realtek 3100 série 33 Matrox MGA-2064W (Millennium) 34 SiS 

Pour les demandes de détection automatique, fg_svgainit retourne une valeur comprise entre 1 et 32
correspondant au chipset SVGA trouvé. Si la valeur de retour est 1, cela signifie un BIOS VESA sera utilisé. Une valeur comprise entre 2 et 32 ??signifie un chipset SVGA spécifique (comme indiqué dans le tableau ci-dessus) sera utilisée. Si aucun VESA BIOS ou soutenu chipset SVGA se trouve, fg_svgainit retourne zéro. Dans ce cas, les modes SVGA graphiques de Fastgraph ne sont pas disponibles.

Lorsque vous demandez l'initialisation d'un chipset spécifique, fg_svgainit
renvoie toujours la valeur qui lui est passé. Il ne vérifie pas si ce chipset est effectivement présent, cette fonction doit être utilisée judicieusement.

Exemple 3-9 est un programme simple qui vérifie si une carte SVGA est présent,
et si oui, affiche le nom du chipset SVGA. Il affiche également la façon dont la mémoire vidéo beaucoup est présent sur la carte SVGA et le numéro de version de SVGA le noyau de Fastgraph.

  Exemple 3-9.
            #include <fastgraf.h>
            #include <stdio.h>
            void main (void);
            char * Description [] = {
               "ne peut être déterminé",
               "VESA",
               "Ahead A",
               "Ahead B",
               "ATI 18800",
               "ATI 18800-1",
                           Chapitre 3: Initialisation de l'environnement Vidéo 53
               "ATI 28800/38800",
               "Chips & Technologies 82c451 / 455 / 456/457",
               "Chips & Technologies 82c452",
               "Chips & Technologies 82c450 / 453",
               "Gênes 6000",
               "Oak OTI-067",
               "Paradise PVGA1a",
               "Paradise WD90C00 / WD90C10",
               "Paradise WD90C11 / WD90C30 / WD90C31 / WD90C33",
               "Trident 8800",
               "Trident 8900/9000",
               "Tseng ET3000",
               "Tseng ET4000",
               "Video7",
               "Cirrus Logic 5400/6200/7540 série",
               "S3",
               "NCR 77C22 / 77C32",
               "Oak OTI-077",
               "Oak OTI-087",
               "Oak OTI-087 (Diamond Viper BIOS)",
               "Cirrus Logic 6400",
               "Avance Logic série 2000»,
               "ARK Logic 1000/2000",
               "ATI 68800 (mach32)",
               "ATI 88800 (mach64)",
               "Série Chips & Technologies 64000/65500",
               "Realtek série 3100",
               "Matrox MGA-2064W (Millennium)",
               "SiS"
            };
            void main ()
            {
               int id, majeur, mineur;
               fg_initpm ();
               id = fg_svgainit (0);
               printf ( "SVGA chipset:% s \ n", description [id]);
               printf ( "mémoire vidéo:% d kilooctets \ n", fg_memory ());
               fg_svgaver (et majeur, et mineur);
               printf ( ". SVGA Version:% d% 2.2d \ n", majeur, mineur);
            }

Cet exemple fg_svgainit utilise pour détecter SVGA chipset de l'utilisateur automatiquement. Il initialise le noyau SVGA donc code spécifique chipset est donné la priorité sur VESA (passant 1 au lieu de 0 à fg_svgainit donnerait VESA priorité). Notez que le programme ne crée pas un mode graphique SVGA - il utilise juste la valeur de retour de fg_svgainit pour identifier le chipset est présent.

Exemple 9.3 comporte également deux autres sous-programmes pertinents pour la Fastgraph
kernel SVGA. La fonction fg_memory renvoie la quantité de mémoire vidéo (en kilo-octets) résidant sur la carte vidéo de l'utilisateur. Par exemple, la valeur de retour fg_memory est de 1.024 pour une carte 1MB SVGA. Une autre routine, fg_svgaver, retourne les numéros majeurs et mineurs pour le noyau SVGA, similaire à la routine de fg_version mentionné au chapitre 1. Notez que le numéro de version du noyau SVGA est pas le même que le numéro de version Fastgraph.

Une autre fonction utile est fg_svgastat, qui renvoie des informations sur
l'état actuel de SVGA le noyau de Fastgraph. La fonction retourne un masque de bits dans lequel le bit 0 est défini si le noyau SVGA a été initialisé avec succès, et le bit 1 sera fixé si le noyau utilise le BIOS VESA. Guide de l'utilisateur Autres 54 Fastgraph
les bits fg_svgastat fournissent des informations sur la disponibilité des pages vidéo étendues et si oui ou non le chipset actif prend en charge lecture séparée et d'écrire les banques. Nous allons discuter de ces caractéristiques dans les chapitres suivants.

Notre prochain exemple, 3-10, est une version SVGA d'exemple 3-8.  Ce programme
initialise le noyau SVGA de sorte que VESA aura préséance sur le code spécifique le chipset. Il appelle ensuite fg_testmode pour trouver un mode graphique SVGA 256 couleurs pris en charge, premier mode 27 (1024 par 768), alors le mode 26 (800x600), et enfin le mode 25 (640x480) essayer. Vérification des modes dans cette séquence assure le programme utilisera la plus haute résolution disponible, étant donné SVGA chipset de l'utilisateur (pas tous les chipsets supportent toutes les résolutions) et la quantité de mémoire vidéo présente (mode 27 nécessite 1MB de RAM vidéo, les modes 26 et 25 nécessité 512K ).

Si les trois appels fg_testmode échouent dans l'exemple 3-10, le programme affiche
un message et sort approprié. Ce serait le cas si le programme était exécuté sur un système non-SVGA, exécuter sur un SVGA chipset non pris en charge sans compatibilité VESA, ou si la carte SVGA n'a pas au moins 512K de mémoire vidéo (modes 25, 26, et 27 ont tous besoin d'au moins 512K). Dans les deux premiers cas, la fonction fg_svgainit aurait pas initialisé le noyau SVGA, donc fg_testmode échouerait lors de la vérification de la disponibilité d'un mode graphique SVGA. Voilà pourquoi il est pas nécessaire de vérifier la valeur de retour de fg_svgainit dans ce cas.

  Exemple 3-10.

  #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
              void main (void);

  void main ()
              {
                 int old_mode;
                 chaîne char [4];

  fg_initpm ();
                 fg_getmode old_mode = ();
                 fg_svgainit (1);

  if (fg_testmode (27,1))
                    fg_setmode (27);
                 else if (fg_testmode (26,1))
                    fg_setmode (26);
                 else if (fg_testmode (25,1))
                    fg_setmode (25);
                 autre {
                    printf ( "Ce programme nécessite un SVGA»);
                    printf ( "avec au moins 512K de mémoire vidéo \ n.");
                    sortie (1);
                    }

  fg_setcolor (15);
                 fg_text ( «Je suis en cours d'exécution en mode", 20);
                 sprintf (string, "% d.", fg_getmode ());
                 fg_text (string, 3);
                 fg_waitkey (); 
                           Chapitre 3: Initialisation de l'environnement Vidéo 55


  fg_setmode (old_mode);
                 fg_reset ();
              }


Bien que la spécification VESA définit une interface de programmation commune pour
fonctions SVGA spécifiques chipset, nous devons nous rappeler que VESA est juste que - une spécification. Certains fabricants fournissent des pilotes VESA ou implémentations de BIOS qui réalisent la spécification complète VESA avec seulement de légères dégradations de performance. D'autres ne sont pas aussi bien, avoir des problèmes avec quoi que ce soit au-delà des fonctions rudimentaires de mode de l'initialisation et la commutation de la banque, sans parler des problèmes de performance.

D'autres problèmes peuvent se produire avec les quelques cartes SVGA qui ne sont pas complètement
suivre les numéros de mode vidéo prédéfinis par le fabricant du chipset et enregistrer des définitions. Bien que le noyau SVGA permet à ces problèmes lorsqu'ils sont connus, il est tout simplement pas possible de soutenir toutes les cartes SVGA problématique. Pour compliquer les choses, certaines de ces cartes vidéo gênants ne présentent des problèmes dans certaines révisions, ce qui signifie deux cartes apparemment identiques se comporter différemment. Heureusement, ces cartes problématiques sont de loin l'exception.

Si vous développez un produit SVGA pour la distribution générale, nous
recommandons d'utiliser le code spécifique de chipset Fastgraph par défaut, mais aussi de fournir un moyen de remplacer le code spécifique à chipset et utiliser le support VESA. Le plus souvent, cela se fait par la reconnaissance d'un commutateur de ligne de commande ou en utilisant un fichier de configuration spécifique à l'application. Certains programmeurs même prendre un peu plus loin en incluant un moyen d'éviter la procédure de autodetection SVGA et initialiser SVGA le noyau de Fastgraph pour un chipset spécifique. Cela pourrait être important si votre produit fonctionnera sur les systèmes portables, qui ont parfois SVGA sous-systèmes vidéo qui ne répondent pas aux demandes de autodetection aussi fiable que leurs homologues de bureau.

Un autre point important à considérer lors de l'écriture d'applications SVGA est le
la compatibilité entre la carte vidéo et le moniteur. Pratiquement tous les moniteurs SVGA prises aujourd'hui ne pose aucun problème à l'appui de la bande passante requise par l'un des modes graphiques SVGA de Fastgraph. Cependant, certains moniteurs (plus particulièrement anciens moniteurs de multisync) ne peuvent pas supporter les modes de résolution supérieurs tels que 800x600 et 1024 par 768. Les contrôles du noyau SVGA si la carte SVGA prend en charge la résolution demandée, mais il ne vérifie pas si la combinaison carte / moniteur ne .


===Résumé de la vidéo Initialisation Routines===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_AUTOMODE détermine le mode graphique vidéo qui offre le plus
fonctionnalités pour la configuration de l'affichage et l'adaptateur de l'utilisateur. La valeur retourne permet de déterminer une valeur appropriée pour passer à la routine de fg_setmode.

FG_BESTMODE est similaire à fg_automode, mais il exclut les modes vidéo que
ne proposent pas les exigences de résolution et page vidéo spécifiées. Guide de l'utilisateur 56 Fastgraph

FG_CURSOR rend le texte en mode curseur visible ou invisible.  Cette routine
n'a aucun effet lorsqu'il est utilisé dans un mode graphique.

FG_GETLINES retourne le nombre de lignes de texte par écran pour le courant
mode vidéo.

FG_GETMODE renvoie le mode vidéo actuel.  Il est généralement l'un des
premières routines Fastgraph appelé dans un programme. La valeur retournée par fg_getmode peut être utilisé pour restaurer le mode vidéo original lorsqu'un programme transfère le contrôle de retour au DOS.

FG_MEMORY renvoie la quantité de mémoire vidéo présente (en kilo-octets) sur
La carte SVGA de l'utilisateur. Cette routine est significative seulement après initialisation avec succès le noyau SVGA avec fg_svgainit.

FG_RESET est généralement la dernière routine Fastgraph appelé dans un programme.  Il
fonctionne uniquement en mode texte vidéo. Lorsque le pilote ANSI.SYS est pas chargé, fg_reset efface simplement l'écran. Lorsque ANSI.SYS est chargé, fg_reset restaure également tous les attributs d'écran précédemment définis.

FG_SETLINES étend un mode 80 colonnes texte à 25, 43, ou 50 lignes par
écran. Cette routine est seulement significatif lors de l'exécution de 80 colonnes modes de texte sur EGA, VGA ou MCGA systèmes (dans d'autres cas, il ne fait rien).

FG_SETMODE établit un mode vidéo et initialise Fastgraph INTERNE
paramètres pour ce mode vidéo. Il doit être appelé avant toute routine Fastgraph qui effectue une sortie vidéo. Un programme peut appeler fg_setmode autant de fois que nécessaire pour basculer entre les différents modes vidéo.

FG_SVGAINIT initialise SVGA le noyau de Fastgraph et exécute le chipset
initialisation SVGA spécifique. Cette routine doit être appelée avant l'établissement d'un mode graphique SVGA avec fg_setmode.

FG_SVGASTAT renvoie des informations sur l'état actuel de Fastgraph de
kernel SVGA.

FG_SVGAVER retourne majeurs et mineurs numéros de version du noyau SVGA.

FG_TESTMODE détermine si oui ou non un mode vidéo spécifié (avec
nombre donné de pages vidéo) est disponible sur le système de l'utilisateur.

==Guide de systèmes de coordonnées==

Fastgraph utilise trois systèmes de coordonnées pour effectuer le texte et les graphiques
sortie - espace de caractère, l'espace de l'écran, et de l'espace mondial. l'espace de caractères est utilisé en mode texte et éventuellement pour l'affichage des chaînes de caractères dans les modes graphiques. l'espace de l'écran est le système de coordonnées de base pour graphiques modes vidéo et utilise les coordonnées de périphériques physiques de l'écran. Viewports sont une extension de l'espace de l'écran qui vous permettent d'affecter un système basé entier coordonnée alternative à rectangulaire sous-ensembles de l'écran. Enfin, l'espace du monde est un user- définissable système de coordonnées pour les modes graphiques qui utilise des valeurs flottantes. L'espace de système de coordonnées ne sont pas disponibles dans Fastgraph / Lumière.

===Espace de caractères===

Le système de coordonnées utilisé pour les caractères d'affichage est appelé caractère
espace. Fastgraph utilise l'espace de caractères pour afficher des caractères dans les deux modes texte et des graphiques vidéo (vous pouvez également utiliser l'espace de l'écran pour afficher les caractères dans les modes graphiques). un espace de caractère peut être considéré comme une grille de rangées et de colonnes, chaque cellule de la grille de maintien d'un caractère. Chaque cellule est identifiée par ses propres coordonnées (ligne, colonne) entiers. Les lignes et les colonnes sont numérotées à partir de zéro; l'origine est toujours le coin supérieur gauche de l'écran. Par exemple, dans le 80-colonne en modes 25 rangs texte (2, 3 et 7), la valeur par défaut (ligne, colonne) les coordonnées de l'écran coins sont présentés dans le schéma suivant.


  (0,0) (0,79)


  (24,0) (24,79)


Le nombre de lignes et de colonnes dépend du mode vidéo, comme indiqué dans le tableau suivant. Pour les modes graphiques, le tableau comprend également la largeur et la hauteur en pixels d'une cellule de caractère.

  Mode de Nombre de Nombre de Char.  Carboniser.
  Colonnes Nombre de lignes Widthheight

  0 40 25
  1 40 25
  2 80 25
  3 80 25
  4 40 25 8 8
  5 40 25 8 8
  6 80 25 8 8
  7 80 25
  9 40 25 8 8
  11 80 25 9 14
  12 40 25 8 8
  13 40 25 8 8
  14 80 25 8 8
  15 80 25 8 14
  16 80 25 8 14
  17 80 30 8 16
  18 80 30 8 16
  19 40 25 8 8
  20 40 25 8 8
  21 40 50 8 8
  22 40 30 8 8
  23 40 60 8 8
  24 80 25 8 16
  25 80 30 8 16
  26 100 37 8 16
  27 128 48 8 16
  28 100 37 8 16
  29 128 48 8 16

Fastgraph comporte deux routines, et fg_getmaxx fg_getmaxy que,
retournent respectivement le nombre maximum de colonnes et de lignes en mode texte. Exemple 4-1 montre ces deux routines dans un mode texte. Le programme utilise fg_getmaxx et fg_getmaxy pour obtenir les colonnes et de lignes nombre maximum en mode 3. Il affiche ensuite ces valeurs (79 et 24).

  Exemple 4-1.

  #include <fastgraf.h>
                     #include <stdio.h>
                     void main (void);

  void main ()
                     {
                        int max_col;
                        int max_row;
                        Mode int;

  fg_initpm ();
                        mode = fg_getmode ();
                        fg_setmode (3);

  fg_getmaxx max_col = ();
                        fg_getmaxy max_row = ();

  fg_setmode (mode);
                        fg_reset ();

  printf ( "Last col =% d \ n", max_col);
                        printf ( "Dernière rangée =% d \ n", max_row);
                     }


===Espace d'écran===

L'espace de l'écran est l'un des deux systèmes de coordonnées disponibles dans les graphiques
modes. Il utilise les coordonnées physiques de l'appareil. L'espace écran peut être considérée comme une grille de rangées et de colonnes, chaque unité de la grille de maintien d'un pixel. Chaque pixel est identifié par ses propres coordonnées (x, y) entiers. Les rangées de pixels et les colonnes sont numérotées à partir de zéro; l'origine est toujours le guide de l'utilisateur supérieure 60 Fastgraph
coin gauche de l'écran. Par exemple, dans les modes les graphiques 320x200, le (x, y) les coordonnées de l'écran coins sont présentés dans le schéma suivant.


  (0,0) (319,0)


  (0199) (319199)


Le Fastgraph routines fg_getmaxx et fg_getmaxy reviennent le maximum x et
Y coordonnées écran lorsqu'il est utilisé dans un mode graphique, comme le montre l'exemple 4-2. Le programme utilise fg_getmaxx et fg_getmaxy pour obtenir le maximum de coordonnées x et y dans le mode 256 couleurs graphique standard VGA / MCGA (mode 19). Il affiche ensuite ces valeurs (319 et 199).

  Exemple 4-2.

  #include <fastgraf.h>
                       #include <stdio.h>
                       void main (void);

  void main ()
                       {
                          int maxx;
                          int maxy;
                          Mode int;

  fg_initpm ();
                          mode = fg_getmode ();
                          fg_setmode (19);

  maxx = fg_getmaxx ();
                          maxy = fg_getmaxy ();

  fg_setmode (mode);
                          fg_reset ();

  printf ( "(% d,% d) \ n", maxx, maxy);
                       }


===viewports===

Viewports fournissent système de coordonnées pour un autre entier non
le référencement de pixels. Fastgraph comprend des routines pour créer une fenêtre, retourner les limites de viewport, et convertir les coordonnées viewport à leurs valeurs d'espace d'écran.

Une définition de la fenêtre se compose de ses extrêmes dans «l'espace de la fenêtre» et
les limites dans l'espace de l'écran correspondant. La routine fg_setview définit une fenêtre. Ses quatre premiers paramètres représentent le minimum x, maximum x, y au minimum, et les coordonnées maximales de viewport y, et ses quatre derniers paramètres représentent les valeurs d'espace d'écran de pixels correspondants définissant la taille et l'emplacement physique de la fenêtre. Par exemple, l'appel

  fg_setview (100,739,100,499,0,159,0,99);

créerait une fenêtre 640x400 dans le coin supérieur gauche d'un écran 320x200. Les coordonnées du viewport varieraient 100-739 horizontalement et 100-499 verticalement. En d'autres termes, la fenêtre de coordonnées (100,100) tracerait au pixel de l'espace de l'écran (0,0). Le schéma suivant illustre cette fenêtre. Les coordonnées de l'espace de la fenêtre apparaissent en caractères gras, tandis que les autres valeurs sont les coordonnées équivalentes de l'espace de l'écran.

  (100,100) (739,100)

  (0,0) (159,0) (319,0)


  (0,99) (159,99)

  (100,499) (739,499)


  (0199) (319199)


La routine de fg_getview de Fastgraph renvoie les limites de la fenêtre actuelle et les limites de l'espace de l'écran correspondant, tel que défini dans l'appel le plus récent à fg_setview.

Une fois que vous avez défini une fenêtre, l'fg_xview et les fonctions de fg_yview
traduire les coordonnées viewport à leurs équivalents de l'espace de l'écran. Les valeurs traduites peuvent ensuite être transmis à toute routine Fastgraph qui attend les coordonnées de l'espace de l'écran. Par exemple, la routine de fg_rect de Fastgraph dessine un rectangle rempli dans l'espace de l'écran. Si vous voulez remplir la fenêtre définie ci-dessus avec la couleur 10 pixels, vous pouvez le faire comme suit:

  fg_setcolor (10);
       fg_rect (fg_xview (100), fg_xview (739), fg_yview (100) fg_yview (499));

  Exemple 4-3 montre une simple utilisation de fenêtres dans la norme

/ MCGA mode 256 graphiques couleur 320x200 VGA. Après avoir rempli l'écran avec blanc (couleur 15) pixels, il met en place une fenêtre dans le quadrant supérieur gauche de l'écran et fg_rect utilise pour le remplir avec bleu clair (couleur 9) pixels. Il définit ensuite trois nouvelles fenêtres dans les autres quadrants de l'écran, le remplissage de même le quadrant supérieur droit avec vert clair (couleur 10) de pixels, le quadrant inférieur gauche avec cyan clair (couleur 11) de pixels, et enfin le quadrant inférieur droit avec la lumière rouge ( 12) la couleur des pixels. Notez comment les mêmes coordonnées de viewport sont utilisés pour remplir la fenêtre dans chaque cas; seuls les changements de position de la fenêtre.

  Exemple 4-3.

  #include <fastgraf.h>
       void main (void);

  void main ()
       {
          Mode int; 

  fg_initpm ();
          mode = fg_getmode ();
          fg_setmode (19);
          fg_setcolor (15);
          fg_rect (0,319,0,199);
          fg_waitkey ();

  fg_setview (0,639,0,399,0,159,0,99);
          fg_setcolor (9);
          fg_rect (fg_xview (0), fg_xview (639), fg_yview (0), fg_yview (399));
          fg_waitkey ();

  fg_setview (0,639,0,399,160,319,0,99);
          fg_setcolor (10);
          fg_rect (fg_xview (0), fg_xview (639), fg_yview (0), fg_yview (399));
          fg_waitkey ();

  fg_setview (0,639,0,399,0,159,100,199);
          fg_setcolor (11);
          fg_rect (fg_xview (0), fg_xview (639), fg_yview (0), fg_yview (399));
          fg_waitkey ();

  fg_setview (0,639,0,399,160,319,100,199);
          fg_setcolor (12);
          fg_rect (fg_xview (0), fg_xview (639), fg_yview (0), fg_yview (399));
          fg_waitkey ();

  fg_setmode (mode);
          fg_reset ();
       }


Pour faire un viewport un "vrai" viewport, il est souvent souhaitable d'établir
écrêtage des limites à des extrêmes de la viewport. De cette façon, les fonctions de Fastgraph qui prennent en charge l'écrêtage dessinera seulement au sein de la fenêtre elle-même. L'appel suivant à fg_setclip établira les limites d'écrêtage souhaitées:

  fg_setclip (fg_xview (100), fg_xview (739), fg_yview (100) fg_yview (499));

La routine fg_setclip sera décrite plus en détail dans le chapitre 6.


===World Space===

L'espace du monde est l'autre disponible système de coordonnées dans les modes graphiques.

Il utilise les coordonnées de virgule flottante définis par l'utilisateur. Fastgraph traduit coordonne l'espace du monde en coordonnées de périphériques physiques (espace de l'écran), et à cause de cela, il est un peu plus lent que d'utiliser l'espace de l'écran. l'espace du monde peut être considéré comme un plan cartésien norme étendant à partir du coin inférieur gauche de l'écran. L'espace mondial orientation verticale est donc inversé par rapport à l'espace de l'écran et les fenêtres.

Tout programme qui utilise les coordonnées de l'espace mondial doit d'abord initialiser
internes paramètres spatiaux mondiaux de Fastgraph. La fg_initw routine Fastgraph est
prévue à cet effet. La routine de fg_initw n'a pas d'arguments et doit être appelée avant toute autre routine qui utilise les coordonnées spatiales du monde.

La prochaine étape dans l'utilisation de l'espace mondial est d'utiliser la routine Fastgraph
fg_setworld pour définir les coordonnées de l'espace mondial des bords de l'écran. La routine de fg_setworld a quatre arguments en virgule flottante - le minimum coordonnée x (bord gauche), le maximum coordonnée x (bord droit), le minimum coordonnée y (bord inférieur), et le maximum coordonnée y (bord supérieur). Par exemple, si vous définissez les coordonnées de l'espace du monde avec la déclaration

  fg_setworld (-10.0,10.0,0.0,2.5);

(x, y) les coordonnées des coins de l'écran seraient définis comme indiqué dans le schéma suivant.


  (-10.0,2.5) (10.0,2.5)


  (-10.0,0.0) (10.0,0.0)


Fastgraph comprend une fg_getworld routine qui renvoie les extrêmes de l'espace du monde, tels que définis dans l'appel le plus récent à fg_setworld.

  Exemple 4-4 utilise fg_setworld et fg_getworld pour illustrer un intéressant

application de l'espace mondial. Ce programme appelle un autre rafraîchissement routine nommée (non représenté) qui efface l'écran et en tire une certaine image en utilisant les coordonnées spatiales du monde. Le programme dessine l'image, attend une frappe, réduit l'espace du monde par un facteur de deux dans chaque direction, puis attire à nouveau l'image. Cela produit un effet de zoom dans lequel l'image apparaît deux fois plus grande que l'on était à l'origine.

  Exemple 4-4.

  #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
              void main (void);
              redraw void (void);

  void main ()
              {
                 int new_mode, old_mode;
                 à double xmin, xmax, ymin, ymax;

  fg_initpm ();
                 fg_getmode old_mode = ();
                 fg_automode new_mode = ();

  if (new_mode == 0) {
                    printf ( "Ce programme nécessite des graphiques \ n.");
                    sortie (1);
                    }

  fg_setmode (new_mode);
                 fg_initw ();

  fg_setworld (0.0,40.0,0.0,30.0);
                 redessiner ();
                 fg_waitkey ();

  fg_getworld (& xmin, & xmax, & ymin, ymax &);
                 fg_setworld (0.0, 0.5,0.0 * xmax, ymax * 0,5);
                 redessiner ();
                 fg_waitkey ();

  fg_setmode (old_mode);
                 fg_reset ();
              }


===Routines de conversion===

Parfois, il est nécessaire de convertir les coordonnées entre l'espace de caractère,
l'espace de l'écran, et de l'espace mondial. Fastgraph comprend huit routines de conversion, quatre pour les coordonnées x et quatre pour les coordonnées y, pour effectuer ces conversions. Ces routines renvoient la traduction de coordonnées que leur valeur de fonction.

Les fg_xalpha et fg_yalpha routines convertissent les coordonnées de l'espace écran pour
espace de caractère. La routine de fg_xalpha convertit un espace de coordonnées x écran à la colonne d'espace de caractère qui contient les coordonnées. De même, la routine de fg_yalpha convertit un espace d'écran coordonnée y à l'espace rangée de caractères qui contient les coordonnées.

Les fg_xconvert et fg_yconvert routines convertissent espace de caractère
coordonnées à l'espace de l'écran. La routine de fg_xconvert convertit une colonne d'espace de caractère à l'espace de l'écran de coordonnées de son pixel gauche. De même, la routine de fg_yconvert convertit un espace rangée de caractères à l'espace de l'écran de coordonnées de son sommet (numéro le plus bas) pixel.

Les fg_xscreen et fg_yscreen routines convertir les coordonnées de l'espace monde
l'espace de l'écran. La routine de fg_xscreen translatés coordonnées x, tandis que la routine fg_yscreen traduit les coordonnées y. A l'inverse, les fg_xworld et fg_yworld routines convertir les coordonnées d'espace d'écran à l'espace mondial. La routine de fg_xworld translatés coordonnées x, tandis que la routine fg_yworld traduit les coordonnées y.


===Résumé de coordonner Routines===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_GETMAXX retourne le maximum coordonnée x dans l'espace de l'écran lorsqu'il est utilisé dans
un mode graphique. Elle retourne le numéro de colonne maximale dans l'espace de caractère lorsqu'il est utilisé dans un mode texte.

FG_GETMAXY retourne le maximum coordonnée y dans l'espace de l'écran lorsqu'il est utilisé dans
un mode graphique. Il retourne le numéro de ligne maximale dans l'espace de caractère lorsqu'il est utilisé dans un mode texte.

FG_GETVIEW renvoie les limites de la fenêtre actuelle et leur espace d'écran
équivalents, tel que défini dans l'appel le plus récent à fg_setview.

FG_GETWORLD renvoie les limites de l'espace mondial actuel, tel que défini dans la
plus récent appel à fg_setworld.

FG_INITW initialise paramètres internes de Fastgraph pour l'espace mondial.
Cette routine doit être appelée une fois, avant toute autre routine qui utilise coordonnées du monde.

FG_SETVIEW définit une fenêtre avec les extrêmes spécifiées au
position spécifiée de l'espace de l'écran.

FG_SETWORLD définit les coordonnées d'espace du monde qui correspondent à la
bords physiques de l'écran.

Coordonnées FG_XALPHA et FG_YALPHA convertir l'espace de l'écran à caractère
espace.

FG_XCONVERT et FG_YCONVERT convertir les coordonnées d'espace de caractères à l'écran
espace.

Coordonnées FG_XSCREEN et FG_YSCREEN convertir l'espace du monde à l'écran
espace.

Coordonnées FG_XVIEW et FG_YVIEW converti viewport à l'espace de l'écran.

Coordonnées FG_XWORLD et FG_YWORLD convertir l'espace de l'écran à l'espace mondial.


==L'utilisation du Guide de couleur==

L'utilisation de la couleur est un élément important de tout texte ou des graphiques
application. Ce chapitre explique la couleur qu'il applique au texte et les modes graphiques. Il décrit également les palettes et la vidéo DAC enregistre pour les modes graphiques vidéo qui offrent cette fonctionnalité. Enfin, une explication de couleurs virtuelles de Fastgraph est fourni.


===Modes de texte===

La couleur à long terme ne sont pas vraiment correct en mode texte, car chaque caractère
la cellule a un attribut associé qui contrôle l'apparence du personnage dans cette cellule. La signification de l'attribut diffère de couleur et monochrome mode texte.


====Modes de texte Couleur====

En couleur mode texte (modes 0, 1, 2 et 3), l'attribut détermine un
couleur de premier plan de caractère (la couleur du personnage lui-même), sa couleur d'arrière-plan (la couleur de cette partie de la cellule de caractère non couvert par le caractère), et si oui ou non il clignote. Seize couleurs de premier plan (numérotés de 0 à 15) sont disponibles, mais seulement huit couleurs de fond (numérotés de 0 à 7) sont disponibles. Les couleurs attribuées à ces valeurs sont répertoriées dans le tableau suivant.

  le numéro de couleur couleur

  0 noir 8 gris foncé
  1 bleu 9 bleu clair
  2 vert 10 vert clair
  3 cyan cyan clair 11
  4 rouge 12 rouge clair
  5 magenta 13 magenta clair
  6 brun 14 jaune
  7 gris 15 blanc

Au début, il peut sembler que les chiffres ont été arbitrairement assignés aux couleurs. Après vérification, cependant, il devient évident que c'est pas le cas. Chaque numéro de couleur est une quantité de quatre bits de la forme IRGB, avec I représentant l'intensité, R la composante rouge, G la composante verte, et B la composante bleue. Si le bit correspondant est égal à 1, cela signifie que l'intensité ou la composante de couleur est réglée. Par exemple, rouge normale serait représenté par le motif binaire IRGB 0100, qui est de 4 décimales, le nombre de couleurs pour le rouge.

La routine fg_setattr définit l'attribut de texte actuel.  Une seul fois
fg_setattr est appelé, Fastgraph affiche tout le texte ultérieur utilisant cet attribut. Le premier argument de fg_setattr définit la couleur de premier plan, qui doit être un entier compris entre 0 et 15. Son second argument définit la couleur d'arrière-plan, qui doit être compris entre 0 et 7. Son troisième argument détermine si le voyant de couleur de premier plan (1 signifie qu'il clignote , 0 signifie qu'il ne fait pas). Par exemple, la déclaration

  fg_setattr (14,1,0); 

spécifie le texte qui suit sera affiché avec un premier plan jaune (14) sur un fond bleu (1) et ne clignote pas (0).

Une autre routine Fastgraph, fg_setcolor, peut également définir des attributs de texte.

La routine fg_setcolor emballe les trois valeurs passées à fg_setattr en un seul argument, comme indiqué ici:

  les bits d'attribut

  0-3 couleur de premier plan
  la couleur d'arrière-plan 4-6
  7 clignotant

Par exemple, appeler fg_setcolor avec un argument de 30 (1E hex) équivaut à appeler fg_setattr avec des arguments de 14, 1 et 0.

La routine Fastgraph fg_getcolor renvoie l'attribut de texte actuel, comme
définis dans l'appel le plus récent à fg_setattr ou fg_setcolor. La routine de fg_getcolor n'a pas d'arguments et renvoie l'attribut comme valeur de fonction. La valeur retournée est codée en utilisant le même schéma pour faire passer un attribut de texte à fg_setcolor.


====Mode texte Monochrome====

Dans le mode de texte monochrome (mode 7), les couleurs ne sont évidemment pas disponibles.

L'attribut détermine la place si un caractère est invisible, normal, bold, inversé, ou certaines combinaisons de ceux-ci. Le tableau suivant montre les valeurs attribuées aux caractéristiques d'affichage disponibles.

  fond plan caractéristique

  0 0 invisible
                         0 7 renversé
                         1 0 souligné
                         7 0 normale
                         9 0 souligné gras
                        15 0 gras

En outre, vous pouvez activer ou désactiver à clignoter pour chacune de ces combinaisons. Toute combinaison de valeurs de premier plan et d'arrière-plan qui ne figurent pas dans le tableau ci-dessus donne une caractéristique d'affichage normal.

Comme dans les modes de couleur, la Fastgraph routines fg_setattr et fg_setcolor
définir l'attribut de texte actuel. Par exemple, la déclaration

  fg_setattr (0,7,1);

spécifie le texte qui suit sera affiché en vidéo inverse (0,7) et clignote (1). Le même attribut peut être défini en appelant fg_setcolor avec un argument de 240 (F0 hex). La routine de fg_getcolor est également disponible et fonctionne comme il le fait dans les modes de texte de couleur. Guide de l'utilisateur 70 Fastgraph


===Modes graphiques===

Dans un mode graphique, chaque pixel a une valeur de couleur associée que
détermine la couleur dans laquelle le pixel est affiché. Le nombre de couleurs disponibles dépend du mode vidéo et peut être obtenue grâce à la fonction fg_colors. Certains modes graphiques ont aussi des registres ou vidéo palette DAC enregistre pour fournir des capacités de couleurs supplémentaires, telles que le choix d'un ensemble de couleurs à partir d'une plus grande palette de couleurs. Les exemples de programmes présentés dans cette section montrent l'utilisation de la couleur dans les modes graphiques vidéo spécifiques.

Les paragraphes suivants discuteront de l'utilisation de la couleur dans chaque graphique
mode vidéo. Dans ces discussions, il y aura plusieurs références à un groupe de couleurs appelé le jeu de couleurs standard. Ceci est un ensemble de 16 couleurs communes à un grand nombre des modes graphiques vidéo (et aux modes de texte de couleur). Les couleurs du jeu de couleurs standard sont listés dans le tableau suivant.

  le numéro de couleur couleur

  0 noir 8 gris foncé
  1 bleu 9 bleu clair
  2 vert 10 vert clair
  3 cyan cyan clair 11
  4 rouge 12 rouge clair
  5 magenta 13 magenta clair
  6 brun 14 jaune
  7 gris 15 blanc

À ce stade, nous devons comprendre la différence entre la couleur des termes
nombre et valeur de couleur. Numéro de couleur se réfère au nombre qui définit une couleur dans le jeu de couleurs standard (par exemple, le vert est le numéro de la couleur 2). La valeur de couleur correspond à la valeur réelle d'un pixel dans la mémoire vidéo, qui détermine finalement la couleur dans laquelle le pixel est affiché. La valeur de couleur est parfois juste appelé la couleur.

Dans chaque mode graphique, mémoire vidéo est effacée lorsque la fg_setmode
routine est appelée. Cela signifie que tous les pixels sont initialement configurés pour la valeur de couleur 0, qui par défaut est noir. Pour cette raison, la valeur de la couleur 0 est souvent appelée la couleur de fond dans les modes graphiques vidéo.

La routine de fg_setcolor de Fastgraph définit la couleur dans laquelle la suite
les opérations graphiques sont effectuées. Cette couleur est appelée la couleur actuelle. Selon le mode vidéo, la couleur actuelle peut faire référence à une valeur de couleur (en modes graphiques CGA et Hercules), un registre de palette (en Tandy, EGA et modes graphiques VGA), ou un registre vidéo DAC (en modes 256 couleurs) . La routine fg_setcolor prend un seul argument entier qui spécifie la couleur. Lorsque fg_setmode est appelée, elle définit la couleur actuelle à 0. La Fastgraph fg_getcolor routine retourne la couleur courante, tel que défini dans l'appel le plus récent à fg_setcolor. La routine de fg_getcolor n'a pas d'arguments et retourne la couleur actuelle comme valeur de fonction.


====Modes couleur CGA====

Les modes de couleur CGA (modes 4 et 5) ont six ensembles de couleurs disponibles,
appelées palettes, numérotées de 0 à 5. Chaque palette se compose de quatre couleurs,
numérotés de 0 à 3. Dans chaque palette, la couleur de fond (valeur de couleur 0) peut être choisi parmi le jeu de couleurs standard, mais les 3 autres couleurs sont fixes. Le tableau suivant indique les couleurs fixes attribuées à chaque palette.


  palette 0 palette 1 palette 2

  couleur cyan 1 lumière de lumière cyan lumineux vert
  couleur 2 lumière lumière rouge rouge magenta clair
  couleur 3 jaune blanc blanc
  palette 3 palette 4 palette 5

 Couleur 1 cyan cyan vert
           couleur 2 rouge rouge magenta
           couleur 3 gris brun gris


Palette 1, avec un fond noir, est la palette par défaut lorsque vous sélectionnez le mode 4. Palette 2, avec un fond noir, est la palette par défaut lorsque vous sélectionnez le mode 5.

Les modes de couleur CGA ont une zone frontalière appelée overscan entre la
espace de pixel adressable et les bords physiques de l'écran. La zone overscan est toujours affiché dans la couleur de fond, quelle que soit la CGA palette est utilisée.

Dans les modes de couleur CGA, fg_setcolor définit la couleur actuelle en faisant référence
une des quatre valeurs de couleur. La routine fg_palette sélectionne l'un des six palettes et définit la couleur de fond de cette palette. Le premier argument de fg_palette est un nombre entier compris entre 0 et 5 qui indique le numéro de la palette. Le second argument est un entier compris entre 0 et 15 qui définit la couleur d'arrière-plan, en utilisant les numéros de couleurs dans le jeu de couleurs standard.

Exemple 5-1 illustre l'utilisation de fg_palette et fg_setcolor en mode 4.

Après avoir établi le mode vidéo, le programme sélectionne la palette 0 et rend la couleur bleue de fond (numéro de couleur 1). Il fait alors la couleur dans la palette 3 0 (jaune) la couleur actuelle et affiche le mot «Bonjour». Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-1.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (4);

 fg_palette (0,1);
                              fg_setcolor (3);
                              fg_text ( "Bonjour", 5); 

 fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                            }


====Mode de CGA Deux-Color====

Le CGA mode deux couleurs (mode 6) a une couleur d'arrière-plan fixe (valeur de couleur
0) et une couleur de premier plan (valeur de couleur définie par l'utilisateur 1). La couleur de fond est toujours noir. La couleur de premier plan est blanc par défaut, mais peut être modifiée à l'une des couleurs dans le jeu de couleurs standard. Il convient de mentionner que le changement de couleur de premier plan fonctionne sur de véritables adaptateurs CGA, mais il y a très peu d'adaptateurs EGA, VGA, SVGA et qui mettent en œuvre correctement changeant la couleur de premier plan dans leur mode d'émulation 6.

En mode 6, fg_setcolor définit la couleur actuelle en faisant référence à l'un des
les deux valeurs de couleur. La routine fg_palette définit la couleur de premier plan réel (qui est, la couleur des pixels dont la couleur est la valeur 1). Par souci de cohérence avec les autres modes graphiques, fg_palette a deux arguments, mais le premier est pas utilisé. Le second argument est un entier compris entre 0 et 15 qui définit la couleur de premier plan, en utilisant les numéros de couleurs dans le jeu de couleurs standard.

 Exemple 5-2 illustre l'utilisation de fg_palette et fg_setcolor en mode 6.

Après avoir établi le mode vidéo, le programme rend le jaune de couleur de premier plan (numéro de couleur 14). Il fait alors la couleur 1 la couleur actuelle et affiche le mot «Bonjour». Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-2.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (6);

 fg_palette (0,14);
                              fg_setcolor (1);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                           }   

====Tandy et modes PCjr====

Le mode PCjr graphique supporté Tandy 1000 ou (mode 9) a 16 couleurs
valeurs, numérotées de 0 à 15. Chaque valeur de couleur fait référence à l'un des 16 registres palette définissables par l'utilisateur, souvent simplement appelé palettes, également numérotées de 0 à 15. Les valeurs attribuées aux registres de palette déterminer les couleurs dans lesquelles les pixels sont affichés. Par exemple, si vous affectez palette registre 2 la valeur de rouge, puis pixels dont la couleur est la valeur 2 sera rouge.

Chaque palette peut prendre l'une des couleurs 16 dans le jeu de couleurs standard.

Par défaut, les valeurs attribuées aux 16 palettes correspondent aux couleurs de même numéro dans le jeu de couleurs standard. En d'autres termes, la palette 0 est attribuée la valeur pour le noir, la palette 1 est affectée à la valeur pour le bleu, et ainsi de suite.

En mode 9, fg_setcolor définit la couleur actuelle en faisant référence à l'un des
les 16 registres de palette. La routine fg_palette définit la couleur réelle affectée à un registre spécifique de la palette. Le premier argument de fg_palette est un nombre entier compris entre 0 et 15 indiquant le numéro de la palette. Le second argument est un entier compris entre 0 et 15 qui définit la valeur de la palette (la couleur attribuée à la palette), en utilisant les numéros de couleurs IRGB dans le jeu de couleurs standard.

Vous pouvez également utiliser la fg_setrgb routine Fastgraph pour définir la couleur
affecté à un registre spécifique de la palette. Alors que fg_palette fait cela en utilisant un certain nombre de couleurs à partir du jeu de couleurs standard, fg_setrgb définit un registre de palette en utilisant des composants de couleur rouge, vert et bleu, plus une composante d'intensité. Le premier argument de fg_setrgb est un entier compris entre 0 et 15 qui spécifie le numéro de registre de palette. Les trois arguments restants sont chacun des nombres entiers compris entre -1 et 1, respectivement, qui spécifient les composantes de couleur rouge, vert et bleu pour ce registre de palette. Les significations des composantes de couleur sont les suivantes:

 -1 = Bit de couleur et peu d'intensité sont fixés
  0 = bit de couleur est remise à zéro
  1 = bit de couleur est réglé

Comme il n'y a qu'un seul bit d'intensité dans les valeurs en mode 9 couleurs, en spécifiant -1 pour l'un des composants de couleur RVB produit une couleur intense. Par exemple, le cyan clair de couleur est le numéro de la couleur 11 dans le jeu de couleurs standard, et il est produit en combinant le vert et le bleu et le réglage du bit d'intensité. Cela signifie l'une de ces quatre états


 fg_palette (1,11);
 fg_setrgb (1,0, -1,1);
 fg_setrgb (1,0,1, -1);
 fg_setrgb (1,0, -1, -1);


pourrait être utilisé pour définir la palette registre 1 cyan clair en mode 9.

Exemple 5-3 illustre l'utilisation de fg_palette et fg_setcolor en mode 9.

Après avoir établi le mode vidéo, le programme définit la palette 0 à être bleu (1) et la palette 1 à être jaune (14). Notez que la définition de la palette 0 modifie le Guide de l'utilisateur 74 Fastgraph

Couleur de fond. Il fait alors la couleur 1 la couleur actuelle et affiche le mot «Bonjour». Après avoir attendu pendant une séquence de touches, le programme change la couleur de "Bonjour" en changeant la palette 1 à blanc (15). Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-3.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (9);

 fg_palette (0,1);
                              fg_palette (1,14);

 fg_setcolor (1);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_palette (1,15);
                              fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                            }


====mode de Hercules====

Le mode graphique Hercules (mode 11) a une couleur d'arrière-plan fixe (couleur
valeur 0) et une couleur de premier plan fixe (valeur de couleur 1). La couleur de fond est toujours noir, et la couleur de premier plan dépend de l'affichage monochrome utilisé (généralement il est vert, ambre ou blanc).

La routine fg_setcolor définit la valeur de couleur actuelle en faisant référence
une des deux valeurs de couleur. La routine de fg_palette n'a aucun effet en mode 11.

Exemple 5-4 illustre l'utilisation de fg_setcolor en mode 11. Après
établir le mode vidéo, le programme rend la couleur 1, la couleur actuelle et affiche le mot «Bonjour». Il restaure ensuite le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-4.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                           {   

 Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (11);

 fg_setcolor (1);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                            }


Hercules mode basse résolution

Le Hercules (mode 12) graphiques basse résolution a quatre couleurs
valeurs, numérotées de 0 à 3. La couleur de fond est toujours noir, les couleurs 1 et 2 sont une intensité normale, et la couleur 3 est pleine intensité. Couleurs 1 et 2 à la fois produire des couleurs d'intensité normale, mais ils le font avec des motifs de pixels différents - couleur 1 tourne sur les pixels physiques impaires, tandis que la couleur 2 tourne sur les pixels physiques paires. L'aspect des couleurs 1 à 3 dépend de l'affichage monochrome utilisé (en général, il est vert, ambre ou blanc).

La routine fg_setcolor définit la valeur de couleur actuelle en faisant référence
une des quatre valeurs de couleur. La routine de fg_palette n'a aucun effet en mode 12.

Exemple 5.5 démontre l'utilisation de fg_setcolor en mode 12. Après
établir le mode vidéo, le programme rend la couleur 3 la couleur actuelle et affiche le mot «Bonjour». Il restaure ensuite le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-5.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (12);

 fg_setcolor (3);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                           }   

====EGA Modes 200-Line====

Les modes 200 en ligne EGA graphiques (modes 13 et 14) ont 16 valeurs de couleur,
numérotés de 0 à 15. Chaque valeur de couleur fait référence à l'un des 16 registres palette définissables par l'utilisateur, souvent appelé simplement palettes, également numérotées de 0 à 15. Les valeurs attribuées aux registres de palette déterminent les couleurs dans lesquelles les pixels sont affichés. Par exemple, si vous affectez palette registre 2 la valeur de rouge, puis pixels dont la couleur est la valeur 2 sera rouge.

Chaque palette peut prendre l'une des couleurs 16 dans le jeu de couleurs standard.
Par défaut, les valeurs attribuées aux 16 palettes correspondent aux couleurs de même numéro dans le jeu de couleurs standard. En d'autres termes, la palette 0 est attribuée la valeur pour le noir, la palette 1 est affectée à la valeur pour le bleu, et ainsi de suite.

Dans les modes 13 et 14, fg_setcolor définit la couleur actuelle en faisant référence
l'un des 16 registres de palette disponibles. La routine fg_palette définit la couleur réelle affectée à un registre spécifique de la palette. Le premier argument de fg_palette est un nombre entier compris entre 0 et 15 indiquant le numéro de la palette. Le second argument est un entier qui définit la valeur de la palette (la couleur attribuée à la palette). Bien que les couleurs réelles sont prises à partir du jeu de couleurs standard, la structure binaire d'une valeur de palette est différent du format IRGB utilisé dans le jeu de couleurs standard. Dans les modes 13 et 14, la structure binaire d'une valeur de palette est IxRGB; bit 3 est ignoré. Les valeurs de la palette en mode 13 et le mode 14 qui correspondent à l'ensemble de couleurs standard sont donc:

 couleur de valeur de couleur de valeur

 0 noir 16 gris foncé
 1 bleu 17 bleu clair
 2 vert 18 vert clair
 3 cyan cyan 19 lumière
 4 rouge 20 rouge clair
 5 magenta 21 magenta clair
 6 brun 22 jaune
 7 gris 23 blanc

Vous pouvez également utiliser la fg_setrgb routine Fastgraph pour définir la couleur
affecté à un registre spécifique de la palette. Alors que fg_palette fait cela en utilisant un certain nombre de couleurs à partir du jeu de couleurs standard, fg_setrgb définit un registre de la palette en utilisant rouge, vert et bleu des composantes de couleur, plus une composante d'intensité. Le premier argument de fg_setrgb est un entier compris entre 0 et 15 qui spécifie le numéro de registre de palette. Les trois arguments restants sont chacun des nombres entiers compris entre -1 et 1, respectivement, qui spécifient les composantes de couleur rouge, vert et bleu pour ce registre de palette. Les significations des composantes de couleur sont les suivantes:

 -1 = Bit de couleur et peu d'intensité sont fixés
  0 = bit de couleur est remise à zéro
  1 = bit de couleur est réglé

Comme il n'y a qu'un seul bit d'intensité en mode 13 et 14 des valeurs de couleur spécifiant -1 pour l'une des composantes de couleur RVB produit une couleur intense. Par exemple, le cyan clair est représenté par la valeur de couleur 19, et il est
produit en combinant le vert et le bleu et le réglage du bit d'intensité. Cela signifie l'une de ces quatre états

 fg_palette (1,19);
                            fg_setrgb (1,0, -1,1);
                            fg_setrgb (1,0,1, -1);
                            fg_setrgb (1,0, -1, -1);


pourrait être utilisé pour définir la palette registre 1 cyan clair dans les modes 13 et 14.

La fg_setcolor routine Fastgraph définit la valeur de couleur (qui est, le
numéro de palette) dans lequel les opérations graphiques qui suivent sont réalisées. La routine fg_setcolor prend un seul argument entier qui spécifie cette couleur. Lorsque fg_setmode est appelée, elle définit la valeur de couleur à 0. La Fastgraph fg_getcolor routine renvoie la valeur de couleur actuelle, tel que défini dans l'appel le plus récent à fg_setcolor. La routine de fg_getcolor n'a pas d'arguments et retourne la couleur actuelle comme valeur de la fonction.

 Exemple 6.5 démontre l'utilisation de fg_palette et en mode fg_setcolor

13. Après avoir établi le mode vidéo, le programme définit la palette 0 à être bleu (1) et la palette 1 à être jaune (22). Notez que la définition de la palette 0 change la couleur de fond. Il fait alors la couleur 1 la couleur actuelle et affiche le mot «Bonjour». Après avoir attendu pendant une séquence de touches, le programme change la couleur de "Bonjour" en changeant la palette 1 à blanc (23). Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-6.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (13);

 fg_palette (0,1);
                              fg_palette (1,22);

 fg_setcolor (1);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_palette (1,23);
                              fg_waitkey ();

 fg_setmode (mode);
                              fg_reset ();
                           }   

====Monochrome Mode EGA====

Le mode (mode 15) monochrome EGA graphique assigne les attributs d'affichage à
ses quatre valeurs de couleurs, numérotées de 0 à 3. Chaque valeur de couleur fait référence à l'un des quatre registres de palette définies par l'utilisateur, souvent appelées simplement palettes, numérotées 0, 1, 4, et 5. Cette étrange résultats de numérotation à partir de la désactivation de deux des quatre vidéo plans de bits de mémoire en mode 15. les valeurs attribuées aux registres de palette déterminent l'attribut d'affichage de pixel. Par exemple, si vous affectez palette registre 1 la valeur de gras, puis pixels dont la valeur est 1 sera en gras.

En mode 15, fg_setcolor définit la couleur actuelle (en fait, un affichage
attribuer) en faisant référence à l'une des quatre entrées de la palette. La routine fg_palette définit l'attribut d'affichage réel attribué à un registre spécifique à une palette. Le premier argument de fg_palette est un entier qui spécifie le numéro de palette. Le second argument est un entier qui définit la valeur de la palette (l'attribut d'affichage attribué à la palette). Pour chaque registre de la palette, le tableau suivant indique la valeur de la palette par défaut et son attribut d'affichage associé.

 affichage de la palette de la palette
 attribut de valeur numérique

 0 0 invisible
                             1 8 normale
                             4 24 gras
                             5 24 gras

 Exemple 5-7 illustre l'utilisation de fg_palette et en mode fg_setcolor

15. Après avoir établi le mode vidéo, le programme fait la couleur 4 (en fait, la palette 4, qui est en gras par défaut) la couleur actuelle et affiche le mot «Bonjour». Après avoir attendu pendant une séquence de touches, le programme change l'attribut d'affichage de "Bonjour" en changeant la palette 4 à intensité normale (valeur de la palette 8). Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-7.

 #include <fastgraf.h>
                           void main (void);

 void main ()
                            {
                              Mode int;

 fg_initpm ();
                              mode = fg_getmode ();
                              fg_setmode (15);

 fg_setcolor (4);
                              fg_text ( "Bonjour", 5);
                              fg_waitkey ();

 fg_palette (4,8);
                              fg_waitkey (); 

 fg_setmode (mode);
                              fg_reset ();
                            }


====Enhanced Mode EGA====

L'EGA mode amélioré (mode 16) graphique a 16 valeurs de couleurs, numérotées de 0
à 15. Chaque valeur de couleur fait référence à l'un des 16 registres définissables par l'utilisateur palette, souvent simplement appelés palettes, également numérotées de 0 à 15. Les valeurs attribuées aux registres de palette déterminer les couleurs dans lesquelles les pixels sont affichés. Par exemple, si vous affectez palette registre 2 la valeur de rouge, puis pixels dont la couleur est la valeur 2 sera rouge.

Chaque palette peut prendre l'une des 64 couleurs disponibles.  Par défaut, le
valeurs attribuées aux 16 palettes correspondent aux couleurs de même numéro dans le jeu de couleurs standard. En d'autres termes, la palette 0 est attribuée la valeur pour le noir, la palette 1 est affectée à la valeur pour le bleu, et ainsi de suite. Il y a quelques adaptateurs EGA-compatibles qui ne correctement assignent pas les couleurs par défaut pour les 16 registres de la palette, il est donc une bonne pratique de le faire explicitement en mode 16.

En mode 16, fg_setcolor définit la valeur de couleur actuelle en faisant référence
l'un des 16 registres de palette. La routine fg_palette définit la couleur réelle affectée à un registre spécifique de la palette. Le premier argument de fg_palette est un nombre entier compris entre 0 et 15 indiquant le numéro de la palette. Le second argument est un entier qui définit la valeur de la palette (la couleur attribuée à la palette). La structure binaire d'une valeur de palette est différent du format IRGB utilisé dans le jeu de couleurs standard. En mode 16, la structure binaire d'une valeur de palette est une quantité de 6 bits de la forme RGBRGB, où les lettres minuscules représentent les faible intensité (1/3 intensité) des composantes de couleur, et les lettres majuscules représentent l'intensité normale ( 2/3 intensité) des composants de couleur. Le mode 16 valeurs de la palette qui correspondent à l'ensemble de couleurs standard sont:

 couleur de valeur de couleur de valeur

 0 noir 56 gris foncé
 1 bleu 57 bleu clair
 2 vert 58 vert clair
 3 cyan cyan clair 59
 4 rouge 60 rouge clair
 5 magenta 61 magenta clair
 20 brun 62 jaune
 7 gris 63 blanc

Les composantes d'intensité normale en mode 16 produisent la même normale
couleurs d'intensité que dans les autres modes graphiques 16 couleurs. De même, la combinaison des intensités faibles et normales en mode 16 produit les couleurs de haute intensité des autres modes. La seule exception à cette règle est le brun par défaut, formé à partir du motif de bits 010100 (20 décimal). Cette valeur produit un plus vrai brun que la valeur 6 décimales, ce qui est vraiment un vert olive. Guide de l'utilisateur 80 Fastgraph

Les valeurs de la palette utilisées en mode 16 sont des quantités de 6 bits, ce qui signifie
il y a 64 couleurs différentes disponibles en mode 16. Ce groupe de 64 couleurs se compose des couleurs 16 dans le jeu de couleur standard plus 48 couleurs supplémentaires qui ne sont pas disponibles dans tous les autres modes EGA. Cependant, parce que les registres de palette EGA détiennent des quantités de 4 bits, seuls 16 de ces couleurs peuvent être affichées en même temps. En d'autres termes, le mode EGA amélioré offre la possibilité d'afficher 16 couleurs simultanées à partir d'un groupe de 64.

Vous pouvez également utiliser la fg_setrgb routine Fastgraph pour définir la couleur
affecté à un registre spécifique de la palette. Alors que fg_palette fait cela en utilisant une valeur comprise entre 0 et 63, fg_setrgb définit un registre de la palette en utilisant rouge, vert et bleu des composantes de couleur. Le premier argument de fg_setrgb est un entier compris entre 0 et 15 qui spécifie le numéro de registre de palette. Les trois arguments restants sont chacun des nombres entiers compris entre 0 et 3 qui indiquent respectivement les intensités tiers des composantes de couleur rouge, vert et bleu pour ce registre de palette. Par exemple, la couleur cyan est représenté par la valeur dans le tableau 3 ci-dessus, et il est produit en combinant une intensité normale (2/3 intensité) vert et bleu. Cela signifie soit des états


 fg_palette (1,3);
 fg_setrgb (1,0,2,2);

pourraient être utilisés pour définir la palette 1 en tant que registre cyan.

 Exemple 5-8 illustre l'utilisation de fg_palette et en mode fg_setcolor

16. Il utilise la routine fg_rect Fastgraph (discuté dans le chapitre suivant) pour dessiner des rectangles d'une taille spécifiée. Après avoir établi le mode vidéo, le programme utilise une boucle pour dessiner 16 rectangles de taille égale, un dans chacune des valeurs de couleur 16. Dans la même boucle, le programme fg_palette utilise pour changer chaque palette au noir. La boucle while qui suit effectue quatre itérations. Les premiers changements d'itération 0-0 palette, la palette 1: 1, et ainsi de suite. Par conséquent, les 16 rectangles apparaissent dans les valeurs de la palette 0 à 15. Les rectangles restent dans ces couleurs jusqu'à ce que est la clé est enfoncée pour commencer la prochaine itération. Les deuxièmes variations d'itération 0-16 palette, la palette 1 à 17, et ainsi de suite. Cela rend les 16 rectangles apparaissent dans les valeurs de la palette 16 à 31. Iterations trois et quatre sont similaires, de sorte que l'effet global du programme est d'afficher toutes les 64 couleurs, 16 à la fois. Enfin, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-8.

 #include <fastgraf.h>
               void main (void);

 COULEURS #define 16
               #define WIDTH 40

 void main ()
                {
                   la base int;
                  Couleur int;
                  int minx, maxx;
                  Mode int; 

 fg_initpm ();
                  mode = fg_getmode ();
                  fg_setmode (16);

 base = 0;
                  minx = 0;
                  maxx = WIDTH - 1;

 pour (couleur = 0; couleur <COLORS; couleur ++) {
                     fg_palette (couleur, 0);
                     fg_setcolor (couleur);
                     fg_rect (minx, maxx, 0349);
                     minx = maxx + 1;
                     maxx = maxx + WIDTH;
                      }

 tandis que (base <COLORS * 4) {
                     pour (couleur = 0; color <COLORS; couleur ++)
                        fg_palette (couleur, base + couleur);
                     base + = COULEURS;
                     fg_waitkey ();
                      }

 fg_setmode (mode);
                  fg_reset ();
                }


====VGA et MCGA Two-Mode couleur====

Le VGA et le mode MCGA deux couleurs (mode 17) a une couleur d'arrière-plan (couleur
valeur 0) et une couleur de premier plan (valeur de couleur 1). Chaque valeur de couleur fait référence à l'un des deux registres de palette définissables par l'utilisateur, souvent simplement appelés palettes, également numérotées 0 et 1. Chaque registre de la palette à son tour fait référence à l'un des 16 18 bits registres vidéo CAD définissables par l'utilisateur, numérotés de 0 à 15. Les valeurs affecté aux registres de palette et vidéo registres CAD déterminer les couleurs dans lesquelles les pixels sont affichés. Par exemple, si la palette registre 1 contient la valeur 3, et la vidéo registre DAC 3 contient la valeur de couleur pour le rouge, puis pixels dont la valeur est la couleur 1 (qui est, les pixels de premier plan) sera rouge.

Par défaut, la palette registre 0 références vidéo CAD inscrivez 0, et
palette registre 1 références de registre vidéo DAC 1. En outre, la vidéo DAC registre 0 contient initialement la valeur de couleur pour le noir, tandis que les autres registres du CAD 15 vidéo (1 à 15) contiennent la valeur de couleur pour le blanc. Cela signifie des pixels de fond (valeur de couleur 0) sont en noir par défaut, tandis que les pixels de premier plan (valeur de couleur 1) sont blancs.

Les valeurs vidéo DAC 18 bits se composent de trois 6-bit rouge, vert et bleu
des composantes de couleur. Par conséquent, chaque composante de couleur est un nombre entier compris entre 0 et 63; valeurs croissantes produisent des couleurs plus intenses. Les composantes de couleur par défaut pour les DAC enregistrent 0 sont rouges = 0, bleu = 0, et vert = 0, ce qui produit du noir. Les valeurs par défaut pour les autres registres du CAD sont rouge = 63, bleu = 63, et vert = 63, qui produit du blanc. Étant donné que les registres vidéo DAC 18 bits sont longues, chaque DAC peut spécifier l'un des 262.144 (2 ** 18) couleurs. Cependant, parce que les registres de palette détiennent des quantités de 1 bit, seulement deux de ces couleurs peuvent être affichées au Guide de l'utilisateur 82 Fastgraph
le même temps. En d'autres termes, le mode 17 fournit la possibilité d'afficher simultanément deux couleurs à partir d'un groupe de 262.144.

En mode 17, fg_setcolor définit la couleur actuelle en faisant référence à l'un des
les deux registres de palette. La routine fg_palette définit la valeur d'un registre de la palette en faisant référence à l'un des 16 registres vidéo du CAD. Autrement dit, fg_palette spécifie la vidéo DAC registre qu'une palette registre des références. Le premier argument de fg_palette est soit 0 ou 1 et indique le numéro de palette. Le second argument est un entier compris entre 0 et 15 qui spécifie la vidéo registre DAC pour cette palette.

La fg_setrgb routine Fastgraph définit la valeur d'une vidéo registre DAC
en mode 17. Le premier argument de fg_setrgb est un entier compris entre 0 et 15 qui spécifie le numéro de registre du CAD. Les trois arguments restants sont chacun des nombres entiers compris entre 0 et 63 qui indiquent respectivement les composantes de couleur rouge, vert et bleu pour ce registre DAC.

Exemple 5-9 illustre l'utilisation de fg_palette, fg_setrgb, et
fg_setcolor en mode 17. Après avoir établi le mode vidéo, le programme définit DAC registre 0 à être bleu (rouge = 0, vert = 0, bleu = 42) et le registre DAC 1 à être jaune (rouge = 63, vert = 63, bleu = 21). Notez que la définition du CAD registre 0 change la couleur de fond, car la palette 0 références DAC registre 0. Le programme fait alors la couleur 1 la couleur actuelle (palette 1 références encore DAC registre 1) et affiche le mot «Bonjour» en jaune. Après avoir attendu pendant une séquence de touches, le programme change la couleur de "Bonjour" en faisant référence palette 1 DAC registre 15 (qui contient encore sa valeur par défaut, blanc). Enfin, il restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-9.

 #include <fastgraf.h>
                          void main (void);

 void main ()
                           {
                             Mode int;

 fg_initpm ();
                             mode = fg_getmode ();
                             fg_setmode (17);

 fg_setrgb (0,0,0,42);
                             fg_setrgb (1,63,63,21);

 fg_setcolor (1);
                             fg_text ( "Bonjour", 5);
                             fg_waitkey ();

 fg_palette (1,15);
                             fg_waitkey ();

 fg_setmode (mode);
                             fg_reset ();
                          }   
                                            Chapitre 5: L'utilisation de la couleur 83



====VGA / SVGA Modes 16-Color====

Les modes 16 couleurs VGA et SVGA (modes 18, 28 et 29) ont 16 couleurs
valeurs, numérotées de 0 à 15. Chaque valeur de couleur fait référence à l'un des 16 palettes registres définissables par l'utilisateur, souvent simplement appelés palettes, également numérotées de 0 à 15. Chaque registre de palette à son tour fait référence à l'un des 16 18 bits registres vidéo CAD définissables par l'utilisateur, également numérotés de 0 à 15. les valeurs attribuées aux registres de palette et vidéo registres CAD déterminent les couleurs dans lesquelles les pixels sont affichés. Par exemple, si la palette registre 1 contient la valeur 3, et la vidéo registre DAC 3 contient la valeur de couleur pour le rouge, puis pixels dont la valeur est la couleur 1 sera rouge.

Par défaut, chacun des 16 registres de palette des références de la vidéo DAC
inscrivez-vous du même nombre. En outre, le 16 DAC vidéo enregistre respectivement contiennent les valeurs de couleur pour les couleurs 16 dans le jeu de couleurs standard.

Les valeurs vidéo DAC 18 bits se composent de trois 6-bit rouge, vert et bleu
des composantes de couleur. Par conséquent, chaque composante de couleur est un nombre entier compris entre 0 et 63; valeurs croissantes produisent des couleurs plus intenses. La valeur par défaut RGB composantes de couleur pour les 16 registres vidéo du CAD sont:

couleur couleurs RVB DAC DAC RGB

 0 0 0 0 noir 8 21 21 21 gris foncé
 blue 1 0 0 42 bleu 9 21 21 63 lumière
 2 0 42 0 vert 10 21 63 21 vert clair
 3 0 42 42 cyan cyan clair 11 21 63 63
 4 42 0 0 rouge 12 63 21 21 lumière rouge
 5 42 0 42 magenta 13 63 21 63 magenta clair
 6 42 21 0 brun 14 63 63 21 jaune
 7 42 42 42 gris 15 63 63 63 blanc

Étant donné que les registres vidéo DAC 18 bits sont longues, chaque DAC peut spécifier l'un des 262.144 (2 ** 18) couleurs. Cependant, parce que les registres de palette détiennent des quantités de 4 bits, seuls 16 de ces couleurs peuvent être affichées en même temps. En d'autres termes, le mode 18 fournit la possibilité d'afficher 16 couleurs simultanées à partir d'un groupe de 262.144.

Dans la couleur 16 modes VGA et SVGA, fg_setcolor, fg_palette, et
fg_setrgb se comportent exactement comme dans le mode 17 à une exception près: il y a 16 registres de palette au lieu de seulement deux. Exemple 5-9 illustre l'utilisation de ces routines en mode 17, mais il serait également fonctionner en mode 18, 28, ou 29 si l'appel à fg_setmode ont été modifiés en conséquence.


====Modes de 256 couleurs====

 Les modes 256 couleurs (modes 19 à 27) ont 256 valeurs de couleur, numérotée

0 à 255. Chaque valeur de couleur références directement l'un des 256 utilisateur-définissable 18- bits registres vidéo du CAD, également numérotés de 0 à 255. Les valeurs attribuées aux registres vidéo du CAD déterminer les couleurs dans lesquelles les pixels sont affichés. Par exemple, si la vidéo registre DAC 3 contient la valeur de couleur pour le rouge, puis pixels dont la valeur est la couleur 3 sera rouge. Guide de l'utilisateur 84 Fastgraph


 Par défaut, les 16 premiers registres vidéo DAC (0 à 15) contiennent la couleur

valeurs pour le jeu de couleurs standard. Les 16 prochains registres du CAD (16 à 31) contiennent les valeurs de couleur pour une échelle de gris d'intensité augmente progressivement. Les prochaines 216 registres du CAD (32 à 247) contiennent trois groupes de 72 couleurs chacune, avec le premier groupe (32 à 103) à haute intensité, le deuxième groupe (104 à 175) à une intensité modérée, et le troisième groupe (176 à 247) à faible intensité. Chaque groupe se compose de trois gammes de réduction de la saturation (blancheur croissante), chaque plage variant de teinte du bleu au rouge au vert. Enfin, les 8 derniers registres du CAD (248 à 255) de alternent entre noir et blanc. Ces données sont résumées dans le tableau suivant.

 DACs valeurs par défaut de couleur

 0 à 15 jeu de couleur standard
 16-31 échelle de gris d'intensité augmentant progressivement
 32-55 saturation élevée, les couleurs de haute intensité
 56-79 saturation modérée, les couleurs de haute intensité
 80-103 faible saturation, couleurs de haute intensité
 104-127 saturation élevée, les couleurs d'intensité modérée
 128-151 saturation modérée, les couleurs d'intensité modérée
 152-175 faible saturation, couleurs d'intensité modérée
 176-199 saturation élevée, les couleurs de faible intensité
 200-223 saturation modérée, les couleurs de faible intensité
 224-247 faible saturation, couleurs de faible intensité
 248-255 alternent entre noir et blanc

Les valeurs vidéo DAC 18 bits se composent de trois 6-bit rouge, vert et bleu
des composantes de couleur. Par conséquent, chaque composante de couleur est un nombre entier compris entre 0 et 63; valeurs croissantes produisent des couleurs plus intenses. Étant donné que les registres vidéo DAC 18 bits sont longues, chaque DAC peut spécifier l'un des 262.144 (2 ** 18) couleurs. Cependant, parce que les valeurs de couleur sont des quantités de 8 bits, seulement 256 de ces couleurs peuvent être affichées en même temps. En d'autres termes, les modes 19 à 27 fournissent la capacité d'afficher 256 couleurs simultanées à partir d'un groupe de 262.144.

Dans les modes graphiques 256 couleurs, fg_setcolor définit la couleur actuelle par
référençant l'un des 256 registres vidéo du CAD. La routine fg_setrgb définit la couleur réelle d'un registre vidéo DAC. Le premier argument de fg_setrgb est un entier compris entre 0 et 255 qui spécifie le DAC numéro de registre. Les trois arguments restants sont chacun des nombres entiers compris entre 0 et 63 qui indiquent respectivement les composantes de couleur rouge, vert et bleu pour ce registre DAC. Une autre routine Fastgraph, fg_getrgb, renvoie les composantes de couleur pour un registre DAC spécifié. Ses arguments sont les mêmes que pour fg_setrgb, à l'exception des trois derniers arguments (les valeurs de retour) sont passés par référence plutôt que par valeur.

Vous pouvez également utiliser la fg_palette routine Fastgraph pour définir la valeur de
une vidéo registre DAC dans les modes 19 à 27. Le premier argument de fg_palette est un entier compris entre 0 et 255 qui indique le numéro de registre du CAD. Le second argument est un entier compris entre 0 et 63 qui spécifie la valeur de couleur pour ce registre vidéo DAC, en utilisant les mêmes 64 valeurs comme dans le mode amélioré de EGA (mode 16).

Exemple 5-10 illustre l'utilisation de fg_setcolor en mode 19. Le programme
utilise la routine fg_rect Fastgraph pour tracer des lignes verticales. Après avoir établi le mode vidéo, le programme utilise une boucle pour dessiner 256 lignes verticales, une en
chacune des 256 couleurs (en utilisant les valeurs par défaut du CAD). Enfin, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-10.

 #include <fastgraf.h>
                void main (void);

 COULEURS #define 256

 void main ()
                 {
                    la base int;
                   Couleur int;
                   Mode int;
                   int x;

 fg_initpm ();
                   mode = fg_getmode ();
                   fg_setmode (19);

 x = 0;

 pour (couleur = 0; couleur <COLORS; couleur ++) {
                      fg_setcolor (couleur);
                      fg_rect (x, x, 0199);
                       x ++;
                       }
                   fg_waitkey ();

 fg_setmode (mode);
                   fg_reset ();
                 }


Exemple 5-11 montre un effet intéressant disponible dans les modes vidéo qui
soutenir les registres du CAD. Le programme utilise la routine fg_waitfor Fastgraph (voir le chapitre 16) pour retarder l'exécution du programme. Après avoir établi le mode vidéo, le programme affiche le mot "Bonjour" dans la couleur 103, qui par défaut est un bleu pastel. Il fg_getrgb utilise ensuite pour récupérer les composants de couleur pour cette couleur. La boucle while diminue progressivement les composantes de couleur jusqu'à ce que les trois composantes sont nulles, ce qui rend le mot "Bonjour" en douceur fondu au noir. Enfin, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 5-11.

 #include <fastgraf.h>
                    void main (void);

 void main ()
                     {
                       int old_mode;
                       int rouge, vert, bleu; 

 fg_initpm ();
                       fg_getmode old_mode = ();
                       fg_setmode (19);

 fg_setcolor (103);
                       fg_text ( "Bonjour", 5);
                       fg_waitfor (18);

 fg_getrgb (103, & rouge, et vert, et bleu);

 tandis que (rouge + vert + bleu> 0) {
                          si (rouge> 0) red--;
                          si (vert> 0) green--;
                          si (bleu> 0) blue--;
                          fg_setrgb (103, rouge, vert, bleu);
                          fg_waitfor (1);
                           }

 fg_setmode (old_mode);
                       fg_reset ();
                     }


Les fg_setrgb et fg_getrgb routines travaillent avec des registres du CAD.

Si vous souhaitez définir ou récupérer un bloc de registres, consécutifs CAD fg_setdacs et fg_getdacs sont plus efficaces. La routine de fg_setdacs définit les valeurs d'un bloc de registres DAC consécutifs. Son premier argument est l'indice du premier DAC registre pour définir (entre 0 et 255), et son second argument est le nombre de DAC enregistre pour définir (entre 1 et 256). Le troisième argument est un tableau d'octets contenant les composants de couleur RVB pour les registres du CAD étant défini. trois premiers octets du tableau contiennent les composantes rouge, vert et bleu pour la première DAC, les trois suivants pour le deuxième DAC, et ainsi de suite. La taille de ce tableau doit être au moins trois fois la valeur du second argument. Les arguments de fg_getdacs sont les mêmes que ceux pour fg_setdacs, mais le tableau RGB reçoit plutôt les valeurs actuelles des registres du CAD spécifiés. Les deux routines traitent les numéros de registre du CAD d'une manière circulaire (par exemple, la définition de quatre DACs commençant par le numéro 254 va définir DACs 254, 255, 0 et 1).

Exemple 5-12 est similaire à l'exemple 5-11, mais il efface beaucoup de couleurs
en même temps. Le programme affiche sept astérisques, une dans chacune des couleurs 9 à 15. Il utilise fg_getdacs pour obtenir les paramètres actuels des registres du CAD correspondant; ces valeurs sont stockées dans les RGBvalues ??de tableau. La boucle while disparaît progressivement les composantes RGB à zéro, à l'aide fg_setdacs pour mettre à jour leurs valeurs, similaire à la méthode de l'exemple 5-11. Cela illustre une façon attrayante de transformer une image en un écran vide.

  Exemple 5-12.

  #include <fastgraf.h>
                       void main (void);

  void main ()
                       {
                          int diminue;
                          int i; 
                                             Chapitre 5: L'utilisation de la couleur 87


  int old_mode;
                          RGBvalues ??char [21];

  fg_initpm ();
                          fg_getmode old_mode = ();
                          fg_setmode (19);

  for (i = 9; i <= 15; i ++) {
                             fg_setcolor (i);
                             fg_text ( "*", 1);
                             }

  fg_getdacs (9,7, RGBvalues);
                          fg_waitfor (18);

  faire {
                             = Diminution 0;
                             for (i = 0; i <21; i ++)
                                if (RGBvalues ??[i] 0>) {
                                   RGBvalues ??[i] -;
                                   = Diminution 1;
                                   }
                             fg_setdacs (9,7, RGBvalues);
                             fg_waitfor (1);
                             }
                          tandis que (diminution);

  fg_setmode (old_mode);
                          fg_reset ();
                       }


Notez que les exemples 5-11 et 5-12 serait également travailler en VGA 16 couleurs et les modes vidéo SVGA aussi longtemps que vous venez d'utiliser les 16 premiers registres vidéo du CAD.


Utilisation de la vidéo Registres du CAD en modes EGA

Les fg_getdacs et fg_setdacs routines travaillent aussi dans les modes 13, 14, et 16
lorsqu'il est utilisé sur un écran VGA ou SVGA système. Cela vous permet de choisir 16 couleurs à partir d'une palette de 262.144 couleurs, comme dans le mode 18. Si vous essayez d'utiliser ces routines sur un système EGA, les résultats sont imprévisibles. Les applications qui utilisent ces routines doivent donc d'abord assurer qu'ils sont en cours d'exécution sur un VGA ou SVGA système en vérifiant si fg_testmode (18,0) renvoie une valeur non nulle.

Avant d'essayer d'utiliser fg_getdacs et fg_setdacs dans les modes 13, 14, et 16,
vous devez d'abord être conscient de la relation entre les palettes VGA et registres du CAD. Sur l'EGA, les valeurs de la palette déterminent directement la couleur affichée. Sur le VGA et SVGA, cependant, il existe un niveau supplémentaire d'indirection. VGA et SVGA registres de palette peuvent être considérés comme des pointeurs vers vidéo DAC registres dont les composantes RVB détermine la couleur affichée.

Chaque registre de la palette dans le 640x480 mode graphique 16 couleurs VGA (mode 18)
souligne d'abord au registre du même numéro de DAC. Nous pouvons donc prétendre n'existe pas indirection car la modification de registre DAC n affecte les pixels dont la valeur de couleur est n (à moins, bien sûr, nous avons changé la valeur du Guide 88 Fastgraph utilisateur
palette registre n). Dans les modes 13, 14, et 16, nous ne pouvons pas ignorer le indirection parce que les registres de palette contiennent des valeurs différentes. En mode 13, par exemple, la palette registre 8 contient la valeur 16 par défaut, et non pas la valeur 8 comme en mode 18.

La meilleure façon de contourner cette incompatibilité est de définir la palette et le CAD
enregistre explicitement afin qu'ils correspondent aux valeurs de Mode 18. par défaut Il y a deux cas à considérer - l'un pour les modes 13 et 14, et l'autre pour le mode 16.

Dans les modes 13 et 14, les palettes de 0 à 7 contiennent les valeurs 0 à 7, mais
palettes 8 à 15 contiennent les valeurs 16 à 23. Par conséquent, si vous souhaitez utiliser fg_getdacs et fg_setdacs dans ces modes, vous devez inclure le code suivant après avoir appelé fg_setmode.


  RGBvalues ??char [3];
                        int i;

  for (i = 8; i <16; i ++) {
                           fg_getdacs (i + 8,1, RGBvalues);
                           fg_setdacs (i, 1, RGBvalues);
                           fg_palette (i, i);
                        }


Ce code va définir les valeurs de DACs 8 à 15 aux valeurs de DACs 16 à 23. Il définit également les palettes 8 à 15 pour pointer vers DACs 8 à 15. Vous pouvez alors ignorer la indirection palette-DAC parce réglage DAC registre n affecte pixels de couleur n.

En mode 16, la palette 6 est d'abord affecté la valeur 20, et les palettes 8
à 15 sont affectées les valeurs 56 à 63. Tous les autres palettes pointent vers le DAC du même nombre. Par conséquent, si vous souhaitez utiliser fg_getdacs et fg_setdacs en mode 16, vous devez inclure le code suivant après avoir appelé fg_setmode.


  RGBvalues ??char [3];
                        int i;

  fg_getdacs (20,1, RGBvalues);
                        fg_setdacs (6,1, RGBvalues);
                        fg_palette (6,6);

  for (i = 8; i <16; i ++) {
                           fg_getdacs (i + 48,1, RGBvalues);
                           fg_setdacs (i, 1, RGBvalues);
                           fg_palette (i, i);
                        }


Ce code va définir les valeurs de DAC 6 aux valeurs de DAC 20, et également DACs 8 à 15 aux valeurs de DACs 56 à 63. Il définit également les palettes 6 et 8-15 pour pointer vers les DACs identiquement numérotées. Vous pouvez alors ignorer la indirection palette-DAC parce réglage DAC registre n affecte pixels de couleur n.

Bien que cela puisse sembler tout compliqué au premier abord, il est vraiment pas une fois que vous
comprendre la relation entre les palettes et les DACs. La possibilité de sélectionner des couleurs à partir d'une palette de couleurs 256K au lieu de 16 ou 64 est généralement bien vaut l'effort supplémentaire.


===Cartographie couleur RVB===

Si vous développez une application qui fonctionne en 256 couleurs et 16 couleurs
modes graphiques, vous avez probablement remarqué les différences inhérentes à la définition des valeurs de couleur. En fait, les valeurs du registre de la palette même utiliser différentes structures au sein des différents modes 16 couleurs. La fg_maprgb routine Fastgraph permet de simplifier ces différences. Il mappe trois composantes de couleur RVB (chacune entre 0 et 63) en une valeur de palette de 16 couleurs appropriée pour le mode vidéo en cours. Bien sûr, la gamme de couleurs disponibles est beaucoup plus limitée dans les modes 16 couleurs que dans les modes 256 couleurs, de sorte que fg_maprgb doit cartographier les composantes RVB de la couleur disponible la plus proche.

Exemple 5-13 fonctionne dans un mode graphique 16 couleurs ou 256 couleurs et
illustre l'utilisation de la routine de fg_maprgb. Dans les modes 256 couleurs, le programme utilise simplement fg_setrgb pour définir DAC 1 registre à un bleu pastel (rouge = 45, vert = 49, bleu = 63). Dans les modes de 16 couleurs, cependant, le programme appelle fg_maprgb pour convertir les composantes de couleur en une valeur de la palette dans IRGB, IxRGB ou le format RGBRGB (en fonction du mode vidéo en cours). La valeur de retour de fg_maprgb est passé à fg_palette pour définir la palette registre 1 à la plus proche couleur disponible définie par les composantes RVB spécifiées.

  Exemple 5-13.

  #include <fastgraf.h>
           #include <stdio.h>
           #include <stdlib.h>
           void main (void);

  void main ()
           {
              int new_mode, old_mode;

  fg_initpm ();
              new_mode = fg_bestmode (320,200,1);
              if (new_mode <0 || new_mode == 4 || new_mode == 12) {
                 printf ( "Ce programme nécessite un 320 x 200»);
                 printf ( "graphiques 16 couleurs ou 256 couleurs en mode \ n.");
                 sortie (1);
                 }
              fg_getmode old_mode = ();
              fg_setmode (new_mode);

  fg_setcolor (1);
              if (new_mode <= 16)
                 fg_palette (1, fg_maprgb (45,49,63));
              autre
                 fg_setrgb (1,45,49,63);
              fg_text ( "Bonjour", 5);
              fg_waitkey (); 

  fg_setmode (old_mode);
              fg_reset ();
           }

===Définition de tous les registres de la palette===

Fastgraph comprend un fg_palettes de routine qui définit toutes les 16 palette
registres dans les modes graphiques 16 couleurs. Vous pouvez également utiliser fg_palettes pour définir les premières 16 vidéo registres du CAD dans les modes 256 couleurs. Il n'a pas d'effet dans d'autres modes vidéo.

Utilisation de fg_palettes est beaucoup plus rapide que d'appeler fg_palette 16 fois.  le
argument fg_palettes est un entier tableau 16 de l'élément qui contient les valeurs de couleurs attribuées respectivement aux registres de la palette (ou registres vidéo DAC) 0 à 15. Exemple 5-14 montre comment mettre à zéro les registres de palette (qui est, tous changer au noir ) en mode 13.

  Exemple 5-14.

  #include <fastgraf.h>
               void main (void);

  zéros int [] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

  void main ()
               {
                  Mode int;

  fg_initpm ();
                  mode = fg_getmode ();
                  fg_setmode (13);

  fg_palettes (zéros);

  fg_setmode (mode);
                  fg_reset ();
               }


Bien sûr, comme cet exemple est écrit, il semble ne rien faire plus de vider l'écran. Son but est de montrer un exemple de la routine fg_palettes.


===Couleurs virtuels===

A cette époque, il devrait être clair que l'utilisation de la couleur est assez spécifique à
chaque mode graphique vidéo. L'une des différences les plus évidentes est le nombre de couleurs disponibles dans chaque mode; elle va de 2 à 256. Par couleurs disponibles, nous entendons le nombre de couleurs qui peuvent être affichées simultanément.

Pour simplifier la programmation dans les modes graphiques, Fastgraph fournit 256 virtuel
les couleurs. Les couleurs virtuelles sont utilisées dans les modes graphiques vidéo ayant moins de 256 couleurs disponibles. couleurs virtuelles vous permettent d'utiliser 256 indices de couleur

  Chapitre 5: L'utilisation de la couleur 91


dans tous les modes graphiques, même si un mode particulier n'a pas 256 couleurs disponibles.

Lorsque vous établissez un mode vidéo avec fg_setmode, Fastgraph initialise
tous les indices de couleur virtuels. Elle le fait en reproduisant la couleur des valeurs du mode vidéo à travers les 256 indices de couleur virtuels. Par exemple, les modes de couleurs CGA (4 et 5) présentent des quatre valeurs de couleurs, numérotées de 0 à 3. Dans ces modes, fg_setmode initialise indices de couleur 0, 4, 8, ..., 252-0; des indices de couleur 1, 5, 9, ..., 253-1; des indices de couleur 2, 6, 10, ..., 254-2; et des indices de couleur 3, 7, 11, ..., 255 à 3. De même, dans 16 couleurs modes graphiques les indices de couleur 0, 16, 32, ..., 240 sont mis à 0, et ainsi de suite. En mode vidéo monochrome EGA graphiques (mode 15), les valeurs de couleur sont numérotées de 0, 1, 4, et 5, donc fg_setmode réplique les indices de couleur en groupes de huit, même si il y a seulement quatre couleurs disponibles. Une analyse des séquences de valeurs de couleur révèle une caractéristique souvent utile: par défaut, la couleur virtuelle 0 est des couleurs noires et virtuelles 15 et 255 sont blancs dans tous les modes graphiques vidéo.

Il est ainsi possible d'écrire un programme multi-mode à l'aide de la même couleur
indices pour chaque mode graphique. Par exemple, un programme qui contient le fg_setcolor de déclaration (5) produirait graphiques ultérieures de couleur 5 (magenta par défaut) lors de l'exécution dans un mode graphique de 16 couleurs. Il serait produire des graphiques suivants dans la couleur 1 (cyan clair par défaut) lors de l'exécution dans un mode couleur CGA. En effet, 1 est la valeur par défaut attribuée à l'index de couleur virtuelle 5 dans les modes de couleur CGA.

La routine fg_setmode établit des valeurs par défaut pour le 256 virtuel
indices de couleur, mais il pourrait être souhaitable d'affecter d'autres couleurs disponibles pour eux. Pour en revenir à la discussion dans le paragraphe précédent, le numéro de la couleur 2 est magenta clair dans le mode CGA 4 de la palette par défaut. Il serait plus logique si la valeur de la couleur 2 ont été affectés à l'index de couleur virtuelle 5, car cela rendrait les graphiques dessinés dans la couleur 5 de la même couleur en mode 4 comme dans d'autres modes de couleur. La routine fg_defcolor Fastgraph est prévu à cet effet.

La routine fg_defcolor attribue une valeur de couleur à un indice de couleur virtuelle.

Il dispose de deux arguments: le premier indique l'indice de couleur virtuel (entre 0 et 255), et la seconde spécifie la valeur de couleur (entre 0 et un de moins que le nombre de couleurs disponibles dans le mode vidéo actuel). Par exemple, la déclaration

  fg_defcolor (5,2);

attribuerait la valeur de couleur 2 à l'indice de couleur 5. Une autre routine Fastgraph, fg_getindex, renvoie la valeur actuelle attribuée à un indice de couleur spécifiée. Après l'exécution de l'appel ci-dessus pour fg_defcolor, la déclaration

  color = fg_getindex (5);

stockerait la valeur 2 (la valeur actuelle de l'indice de couleur 5) dans l'entier de couleur variable.

Nous devons être sûrs de comprendre la différence entre les couleurs et virtuelles
registres de palette. Modification de la valeur d'un registre de la palette change la couleur de tous les pixels déjà dessiné en utilisant cette palette. Modification d'un index de couleur virtuelle ne le fait pas; il ne spécifie pas de graphiques dessinés dans cette couleur à partir de ce point apparaîtra dans la nouvelle couleur. Guide de l'utilisateur 92 Fastgraph

Exemple 5-15 montre des couleurs virtuelles en mode 4. Après avoir établi
le mode vidéo, le programme utilise fg_defcolor pour définir des indices de couleur virtuels 0 et 255 à 1, qui par défaut est cyan clair en mode 4. Il tire ensuite les caractères en utilisant des indices de couleur 0, 1 et 255, et dans chaque cas, les caractères apparaître dans cyan clair. Enfin, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

  Exemple 5-15.

  #include <fastgraf.h>
                            void main (void);

  void main ()
                            {
                               Mode int;

  fg_initpm ();
                               mode = fg_getmode ();
                               fg_setmode (4);

  fg_defcolor (0,1);
                               fg_defcolor (255,1);

  fg_setcolor (0);
                               fg_text ( "0", 1);
                               fg_setcolor (1);
                               fg_text ( "1", 2);
                               fg_setcolor (255);
                               fg_text ( "255", 4);
                               fg_waitkey ();

  fg_setmode (mode);
                               fg_reset ();
                            }


===A Multiple Mode-exemple===

Bien que les capacités de couleur diffèrent entre les modes vidéo pris en charge,

Fastgraph, il est facile d'écrire un programme qui tourne dans de nombreux modes vidéo. Cette section présente un exemple d'un tel programme.

Exemple 5-16 illustre un programme qui se déroulera dans l'un des Fastgraph de
modes vidéo pris en charge. Le programme demande d'abord le numéro de mode vidéo, vérifie si le numéro de mode est valide, puis vérifie si le mode demandé est disponible sur le système de l'utilisateur. Après avoir fait cela, le programme établit le mode vidéo et exécute son code spécifique en mode. Il affiche ensuite un bref message qui comprend le numéro de mode vidéo dans lequel le programme est en cours d'exécution. Cette information reste à l'écran jusqu'à ce qu'une touche est enfoncée, au moment où le programme restaure les attributs d'origine en mode vidéo et écran avant de revenir à DOS.

  Exemple 5-16.

  #include <fastgraf.h>
                                             Chapitre 5: L'utilisation de la couleur 93


  #include <stdio.h>
       #include <stdlib.h>
       void main (void);

  void main ()
       {
          int mode, old_mode;
          chaîne char [5];

  / * Demandez le numéro de mode vidéo * /
          printf ( "mode vidéo qui?");
          scanf ( "% d", et le mode);

  / * Assurez-vous que la valeur saisie est valide * /
          si (mode <0 || Mode> 29) {
             printf ( "% d est pas un numéro de mode vidéo valide \ n"., mode);
             sortie (1);
             }

  / * Assurez-vous que le mode vidéo demandé est disponible * /
          fg_initpm ();
          if (Mode> 23) fg_svgainit (0);
          if (fg_testmode (mode, 1) == 0) {
             printf ( "Mode d% ne sont pas disponibles sur ce système. \ n", mode);
             sortie (1);
             }

  / * Mettre en place le mode vidéo * /
          fg_getmode old_mode = ();
          fg_setmode (mode);

  / * Effectuer les initialisations spécifiques au mode * /
          if (mode = 3 Mode <|| == 7) / * modes de texte * /
             fg_cursor (0);

  else if (mode == 4 || Mode == 5) {/ * modes de couleur CGA * /
             fg_palette (0,0);
             fg_defcolor (14,3);
             }

  else if (mode == 6) {/ * CGA mode deux couleurs * /
             fg_palette (0,14);
             fg_defcolor (14,1);
             }

  else if (mode == 11) / * Hercules Mode * /
             fg_defcolor (14,1);

  else if (mode == 12) / * Hercules basse résolution en mode * /
             fg_defcolor (14,3);

  else if (mode == 17) {/ * VGA deux couleurs en mode * /
             fg_palette (1,14);
             fg_setrgb (14,63,63,21);
             fg_defcolor (14,1);
             }

  / * Affiche un message qui inclut le numéro de mode vidéo * /
          fg_setcolor (14);
          fg_text ( «Je suis en cours d'exécution en mode", 20);
          sprintf (string, "% d.", mode);
          fg_text (string, 3);

  / * Attendre une touche * /
          fg_waitkey ();

  / * Restaurer le mode vidéo original et attributs de l'écran * /
          fg_setmode (old_mode);
          fg_reset ();
       }


Exemple 5-16 affiche son message en jaune pour les modes vidéo qui
offrir la couleur. Dans les modes vidéo monochromes, il affiche le message d'intensité normale. Le programme utilise la couleur virtuelle 14, qui par défaut est jaune dans de nombreux modes vidéo; le code spécifique mode dans l'exemple 5-16 rend la couleur jaune 14 dans d'autres modes vidéo. Dans le texte vidéo modes (modes 0 à 3 et 7), le programme utilise fg_cursor pour rendre le curseur invisible. Dans les modes de couleur CGA (modes 4 et 5), le programme utilise fg_palette pour sélectionner une palette CGA qui contient jaune comme la couleur 3 et utilise ensuite fg_defcolor pour affecter la couleur 3 à la couleur virtuelle 14. En CGA mode deux couleurs (mode 6), le programme utilise fg_palette pour faire la couleur 1 jaune, puis utilise fg_defcolor pour affecter la couleur 1 à la couleur virtuelle 14. Dans les modes Hercules (modes 11 et 12), le programme utilise fg_defcolor pour affecter la valeur des pixels d'intensité normale à la couleur 14. Dans VGA mode deux couleurs (mode 17), le programme utilise fg_palette pour affecter la vidéo DAC registre 14 à palette registre 1. Il définit ensuite la vidéo DAC registre 14 pour être jaune avec fg_setrgb et enfin utilise fg_defcolor pour affecter la couleur 1 (qui est, la palette inscrivez-1) à la couleur virtuelle 14. Dans tous les autres modes vidéo, aucune manipulation de couleur est nécessaire parce que la couleur 14 est jaune par défaut.


===Résumé des Routines de couleur liés===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_COLORS renvoie le nombre de couleurs disponibles simultanément dans le
mode vidéo actuel. Dans les modes vidéo texte, fg_colors retourne zéro.

FG_DEFCOLOR attribue une valeur de couleur à un indice de couleur virtuelle.  Cette routine
n'a de sens que dans les modes graphiques vidéo qui ont moins de 256 couleurs disponibles.

FG_GETCOLOR renvoie l'attribut courant de texte (en mode texte) ou de couleur
index (dans les modes graphiques), tel que spécifié dans l'appel le plus récent à fg_setattr ou fg_setcolor.

FG_GETDACS extrait les composantes de couleur rouge, vert et bleu pour une
bloc de registres numérotés consécutivement vidéo du CAD. Cette routine est seulement modes significatifs qui utilisent des registres du CAD.

FG_GETINDEX renvoie la valeur de couleur associée à une couleur virtuelle spécifiée
indice. Dans les modes de texte et dans les modes graphiques qui ont 256 couleurs disponibles, cette routine renvoie la valeur qui lui est passé.

FG_GETRGB renvoie les composantes de couleur rouge, vert et bleu pour une
vidéo spécifié registre DAC. Cette routine n'a de sens que dans les modes qui utilisent des registres du CAD.

FG_MAPRGB cartes à six bits rouge, vert et bleu des composantes de couleur en un

La valeur de la palette appropriée pour le mode vidéo en cours. Vous pouvez ensuite transmettre cette valeur à fg_palette. Cette routine n'a de sens que dans les modes graphiques vidéo 16 couleurs.

FG_PALETTE a des fonctions différentes selon les graphiques actuels
mode vidéo. Pour les modes de quatre couleurs CGA, il établit la palette actuelle (de six disponibles) et définit la couleur de fond pour cette palette. Dans le mode deux couleurs CGA, il définit la couleur de premier plan. Pour le Tandy / PCjr, EGA et modes graphiques VGA, il définit la valeur d'un registre unique de la palette. Pour les modes graphiques 256 couleurs, il définit la valeur d'un seul registre vidéo DAC. La routine de fg_palette n'a aucun effet en mode texte ou les modes graphiques Hercules.

FG_PALETTES définit tous les registres 16 de la palette (en 16 couleurs graphiques
modes) ou les 16 premiers registres vidéo du CAD (en modes graphiques 256 couleurs). La routine de fg_palettes n'a aucun effet en mode texte, les modes graphiques CGA, ou les modes graphiques Hercules.

FG_SETATTR établit le courant attribut de texte en mode texte vidéo.
Cette routine n'a pas d'effet dans les modes graphiques.

FG_SETCOLOR établit l'indice de couleur actuelle (qui peut être un virtuel
indice de couleur dans les modes graphiques). En mode texte, fg_setcolor propose une autre méthode pour établir l'attribut texte actuel.

FG_SETDACS définit les valeurs d'un bloc de vidéo numérotés consécutivement
DAC enregistre en spécifiant leurs rouges, verts et bleus composantes de couleur. Cette routine n'a de sens que dans les modes qui utilisent des registres du CAD.

FG_SETRGB définit la valeur d'un registre unique de la palette (en Tandy / PCjr
et les modes graphiques EGA) ou registre vidéo DAC (VGA, MCGA et modes SVGA) en spécifiant ses rouges, verts et bleus composantes de couleur. La routine de fg_setrgb n'a aucun effet en mode texte, les modes graphiques CGA, ou les modes graphiques Hercules. Guide de l'utilisateur 96 Fastgraph


==Guide Fundamentals graphiques==

Ce chapitre décrit les routines graphiques fondamentales de Fastgraph,
parfois appelée primitives graphiques. Ces routines exécutent des fonctions telles que la compensation de l'écran, le dessin des points, le dessin des lignes pleines et pointillées, le dessin des formes (polygones, cercles, et ellipses) fermé, dessin rectangles (solides, creux et tramé), et le remplissage des régions arbitraires. La plupart de ces routines ont aucun effet en mode texte vidéo, mais il y a quelques exceptions près, et ils seront notées dans les descriptions de ces routines.


===Effacement de l'écran===

La fg_erase routine Fastgraph efface la totalité de l'écran dans toute vidéo
mode. En mode texte, fg_erase stocke un caractère d'espace (ASCII 32) avec un attribut de premier plan gris dans chaque cellule de caractère. Dans les modes graphiques, fg_erase définit chaque pixel à zéro. Bien sûr, cela amène chaque pixel à afficher la couleur d'arrière-plan. La routine de fg_erase n'a pas d'arguments.

La routine de fg_erase définit toujours l'ensemble de l'écran à l'arrière-plan

Couleur. Une autre routine, fg_fillpage, remplit l'écran avec la couleur actuelle. En mode texte, fg_fillpage stocke un caractère solide bloc (ASCII 219) avec l'attribut d'affichage actuel (tel que défini dans l'appel le plus récent à fg_setcolor ou fg_setattr). Dans les modes graphiques, fg_fillpage définit chaque pixel à la couleur actuelle (tel que défini dans l'appel le plus récent à fg_setcolor). Comme fg_erase, fg_fillpage n'a pas d'arguments.


===Coupure===

La suppression des graphiques en dehors d'une zone prédéfinie est appelée
coupure. Beaucoup de routines graphiques orientées-de Fastgraph fournissent écrêtage, soit automatiquement, soit par le biais d'une version spéciale de la routine.

Fastgraph comprend deux routines, fg_setclip et fg_setclipw, pour définir un
région de découpage rectangulaire. La routine fg_setclip définit la zone de découpage dans l'espace de l'écran, tandis que fg_setclipw remplit la même fonction dans l'espace mondial. Chaque routine prend quatre arguments: les x minimum, le maximum de x, le minimum y, et le maximum coordonnée y de la zone de découpage. Les arguments sont des quantités entières pour fg_setclip et flottant quantités de points pour fg_setclipw. Par exemple, la déclaration

  fg_setclip (0,159,0,99);

définirait le quadrant supérieur gauche de l'écran comme la zone de découpage en mode graphique 320x200. La routine de fg_getclip de Fastgraph renvoie les limites d'écrêtage actuels, tels que définis dans l'appel le plus récent à fg_setclip.

Une zone de découpage implicite égale à la totalité de l'écran est définie dans le cadre
des initialisations de la routine de fg_setmode. Clipping est pas pris en charge pour les modes de texte.


===Points===

La fg_point routine Fastgraph fournit le plus de graphiques de base
opération - la fixation d'un pixel à une couleur spécifiée. La routine de fg_point a deux arguments entiers. Le premier spécifie les x du pixel de coordonnées, et la seconde de sa coordonnée y. Le pixel est dessiné en utilisant la valeur de couleur en cours, tel que spécifié dans l'appel le plus récent à fg_setcolor. Il existe également une version mondiale de l'espace de cette routine, fg_pointw, qui utilise des arguments flottants de point. Les deux routines affichent le pixel que si elle se situe dans la zone de découpage actuel.

Une autre routine Fastgraph est disponible pour la lecture de la valeur d'un pixel de couleur.

La routine de fg_getpixel a deux arguments entiers qui spécifient le (x, y) les coordonnées du pixel d'intérêt. Si le (x, y) les coordonnées se trouvent en dehors de la zone de découpage, fg_getpixel renvoie -1. Il n'y a pas de version de fg_getpixel mondiale de l'espace, mais vous pouvez lire la valeur de la couleur d'un pixel dans l'espace du monde en appliquant les fonctions de fg_xscreen et fg_yscreen aux coordonnées spatiales du monde et en passant les valeurs obtenues à fg_getpixel.

Exemple 6-1 utilise fg_point pour dessiner 100 points aléatoires dans des couleurs aléatoires.  Il
utilise également fg_getpixel pour assurer sans deux points sont adjacents. Le programme établit un mode vidéo de graphiques avec fg_automode et fg_setmode. Ensuite, il appelle fg_colors pour déterminer la valeur de couleur maximale pour le mode vidéo sélectionné, puis appelle fg_getmaxx et fg_getmaxy pour obtenir la résolution horizontale et verticale. La partie principale du programme est une boucle while qui génère d'abord une paire aléatoire de coordonnées (x, y) écran. Il appelle ensuite fg_getpixel de vérifier les pixels à (x, y) et les huit positions adjacentes. Si aucune de ces pixels sont fixés, le programme génère une valeur de couleur aléatoire et dessine un point dans cette couleur. Après avoir fait ce 100 fois, le programme attend une touche, restaure les attributs d'origine en mode vidéo et d'écran, puis retourne à DOS.

  Exemple 6-1.

  #include <fastgraf.h>
           #include <stdlib.h>
           void main (void);

  void main ()
           {
              zone int;
              int couleur, couleurs;
              int gauche;
              int new_mode, old_mode;
              int x_range, y_range;
              int x, y;

  fg_initpm ();
              fg_getmode old_mode = ();
              fg_automode new_mode = ();
              fg_setmode (new_mode);

  couleurs = fg_colors ();
              fg_getmaxx x_range = () - 1;
              fg_getmaxy y_range = () - 1;
              gauche = 100; 


  tandis que (à gauche> 0)
              {
                 x = (rand ()% x_range) + 1;
                 y = (rand ()% y_range) + 1;

  surface = fg_getpixel (x-1, y-1) + fg_getpixel (x, y-1) +
                        fg_getpixel (x + 1, y-1) + fg_getpixel (x-1, y) +
                        fg_getpixel (x, y) + fg_getpixel (x + 1, y) +
                        fg_getpixel (x-1, y + 1) + fg_getpixel (x, y + 1) +
                        fg_getpixel (x + 1, y + 1);
                 if (zone == 0)
                 {
                    color = rand ()% des couleurs;
                    fg_setcolor (couleur);
                    fg_point (x, y);
                    à gauche--;
                 }
              }
              fg_waitkey ();

  fg_setmode (old_mode);
              fg_reset ();
           }


Parfois, vous voudrez peut-être afficher un pixel en utilisant un "ou exclusif"
opération (habituellement appelée XOR) pour garantir sa visibilité. La couleur d'un pixel dessiné en mode XOR sera c xor p, où c est la couleur courante et p est la couleur du pixel déjà à cette position. Cela signifie une nouvelle couleur du pixel sera différent de l'arrière-plan aussi longtemps que la couleur actuelle est non nul. La fg_pointx routine Fastgraph affiche un pixel de l'espace de l'écran en mode XOR, tandis que fg_pointxw fait la même chose dans l'espace mondial. Leurs paramètres respectifs sont les mêmes que pour fg_point et fg_pointw.


===Le Cursor Graphics===

Un grand nombre de routines de graphiques de Fastgraph dépendent de la position du
graphiques curseur comme point de référence. Par exemple, Fastgraph comprend des routines pour tracer des lignes de la position graphique du curseur à une position spécifiée, et les routines d'affichage d'image bitmap discuté au chapitre 10 affichage ou récupérer une image par rapport à la position du curseur graphique. Le curseur graphique est pas un curseur dans le vrai sens; il est tout simplement une paire de (x, y) les coordonnées avec une signification particulière. La routine fg_setmode définit la position graphique curseur sur les coordonnées de l'espace de l'écran (0,0), et fg_initw définit sur les coordonnées spatiales du monde (0.0,0.0).

Fastgraph comprend quatre routines pour modifier le curseur graphique
position. Les ensembles de routine fg_move elle à une position de l'espace écran absolu, tandis que fg_movew fixe à une position mondiale de l'espace absolu. La routine fg_moverel définit la position graphique du curseur à une position espace de l'écran par rapport à sa position actuelle. La routine de fg_moverw fait la même chose dans l'espace mondial. Chacun de ces routines a deux arguments qui spécifient le (x, y) les coordonnées de la nouvelle position. Pour les routines de l'espace de l'écran, les arguments sont des nombres entiers
quantités. Pour les routines spatiales du monde, les arguments sont flottants quantités ponctuelles.

Vous pouvez obtenir les coordonnées de l'espace de l'écran du curseur graphique
position avec les fg_getxpos et fg_getypos routines. Ces routines ont pas d'arguments et respectivement retourner les coordonnées x et y de la position du curseur graphique que la valeur de la fonction. Pour obtenir les coordonnées de l'espace mondial de la position du curseur graphique, appliquer les fonctions de fg_xworld et fg_yworld aux valeurs de fg_getxpos et fg_getypos retour.


===Lignes solides===

Fastgraph comprend huit routines pour tracer des lignes solides.  Tous
tracer des lignes dans la valeur de la couleur actuelle et respecter les limites d'écrêtage. La routine de fg_draw dessine une ligne de la position actuelle du curseur graphique à une position d'espace d'écran absolu, tandis que fg_draww dessine une ligne à une position mondiale de l'espace absolu. La routine de fg_drawrel dessine une ligne de la position actuelle du curseur graphique à une position de l'espace de l'écran par rapport à lui. La routine de fg_drawrw fait la même chose dans l'espace mondial. Vous pouvez dessiner des lignes absolues en mode XOR avec fg_drawx et XOR par rapport lignes avec fg_drawrelx, ou avec leur monde homologues de l'espace fg_drawxw et fg_drawrxw. lignes XOR sont souvent utilisés lors de l'élaboration des curseurs (comme réticule) ou des boîtes rubberband pour assurer qu'ils sont visibles sur un fond de couleur. Une autre propriété utile de lignes XOR est que le dessin de la même ligne deux fois restaure ce qui était à l'origine sous la ligne.

Chacun de ces sous-programmes comporte deux arguments qui spécifient les valeurs (x, y)
les coordonnées de la position de destination. Pour les routines de l'espace de l'écran, les arguments sont des quantités entières. Pour les routines spatiales du monde, les arguments sont flottants quantités ponctuelles. Dans les deux cas, la position de destination devient la nouvelle position du curseur graphique. Cela permet de tracer des lignes connectées sans appeler un mouvement de routine graphiques du curseur entre les appels successifs à une routine de dessin au trait.

Exemples 6-2 et 6-3 chaque dessiner une paire de lignes croisées qui divisent le
écran en quadrants. Exemple 6-2 fait cela en utilisant fg_move et fg_draw, tandis que l'exemple 6-3 utilise fg_moverel et fg_drawrel. Les deux exemples dessinent les lignes en blanc, la valeur par défaut pour la couleur 15 dans tous les modes graphiques vidéo.

  Exemple 6-2.  Exemple 6-3.

  #include <fastgraf.h> #include <fastgraf.h>
      void main (void);  void main (void);

  void main () void main ()
      {{
         int max_x, max_y;  int max_x, max_y;
         int mid_x, mid_y;  int mid_x, mid_y;
         int new_mode, old_mode;  int new_mode, old_mode;

  fg_initpm ();  fg_initpm ();
         fg_getmode old_mode = ();  fg_getmode old_mode = ();
         fg_automode new_mode = ();  fg_automode new_mode = ();
         fg_setmode (new_mode);  fg_setmode (new_mode); 
         fg_getmaxx max_x = ();  fg_getmaxx max_x = ();  fg_getmaxy max_y = ();  fg_getmaxy max_y = ();  mid_x = max_x / 2;  mid_x = max_x / 2;  mid_y = max_y / 2;  mid_y = max_y / 2; 

  fg_setcolor (15);  fg_setcolor (15);
         fg_move (mid_x, 0);  fg_move (mid_x, 0);
         fg_draw (mid_x, max_y);  fg_drawrel (0, max_y);
         fg_move (0, mid_y);  fg_moverel (-mid_x, -mid_y);
         fg_draw (max_x, mid_y);  fg_drawrel (max_x, 0);
         fg_waitkey ();  fg_waitkey ();

  fg_setmode (old_mode);  fg_setmode (old_mode);
         fg_reset ();  fg_reset ();
      }}


Exemples 6-4 et 6-5 sont des variantes de l'exemple 6-2.  Exemple 6-4 utilise
l'espace du monde plutôt que de l'espace de l'écran pour dessiner les lignes croisées. Exemple 6-5 est le même que l'exemple 6-2 sauf qu'il définit une zone d'écrêtage pour restreindre le dessin dans le quadrant supérieur gauche de l'écran. La coupure supprime la moitié droite de la ligne horizontale et la moitié inférieure de la ligne verticale.

  Exemple 6-4.  Exemple 6-5.

  #include <fastgraf.h> #include <fastgraf.h>
   void main (void);  void main (void);

  void main () void main ()
   {{
      int new_mode, old_mode;  int max_x, max_y;
                                                int mid_x, mid_y;
      fg_initpm ();  int new_mode, old_mode;
      fg_getmode old_mode = ();
      fg_automode new_mode = ();  fg_initpm ();
      fg_setmode (new_mode);  fg_getmode old_mode = ();
      fg_initw ();  fg_automode new_mode = ();
      fg_setworld (-10.0,10.0, -10.0,10.0);  fg_setmode (new_mode);

  fg_setcolor (15);  fg_getmaxx max_x = ();
      fg_movew (0.0,10.0);  fg_getmaxy max_y = ();
      fg_draww (0,0, -10,0);  mid_x = max_x / 2;
      fg_movew (-10.0,0.0);  mid_y = max_y / 2;
      fg_draww (10.0,0.0);
      fg_waitkey ();  fg_setclip (0, mid_x, 0, mid_y);

  fg_setmode (old_mode);  fg_setcolor (15);
      fg_reset ();  fg_move (mid_x, 0);
   } Fg_draw (mid_x, max_y);
                                                fg_move (0, mid_y);
                                                fg_draw (max_x, mid_y);
                                                fg_waitkey ();

  fg_setmode (old_mode);
                                                fg_reset ();
                                             }
                                       Chapitre 6: Fundamentals graphiques 103



===Lignes en pointillé===

Fastgraph comprend quatre routines pour tracer des lignes en pointillés.  Tous
tracer des lignes dans la valeur de la couleur actuelle et respecter les limites d'écrêtage. La routine de fg_dash dessine une ligne en pointillés de la position actuelle du curseur graphique à une position d'espace d'écran absolu, tandis que fg_dashw dessine une ligne en pointillés à une position mondiale de l'espace absolu. La routine fg_dashrel dessine une ligne en pointillés de la position actuelle du curseur graphique à une position d'espace de l'écran par rapport à lui. La routine de fg_dashrw fait la même chose dans l'espace mondial.

Chacun de ces routines a trois arguments.  Les deux premiers spécifiez le
(X, y) les coordonnées de la position de destination. Pour les routines de l'espace de l'écran, ces arguments sont des quantités entières. Pour les routines spatiales du monde, ces arguments sont flottantes quantités ponctuelles. Le troisième argument est un modèle 16 bits qui définit l'apparence de la ligne en pointillés. Les bits qui sont définis dans le modèle produisent la partie visible de la ligne, alors que bits qui sont zéro produisent la partie invisible. Ce schéma est répété comme nécessaire d'attirer l'ensemble de la ligne. Par exemple, la valeur hexadécimale de modèle 3333 produirait une ligne en pointillés avec les deux premiers pixels au large, les deux suivants sur, les deux suivants au large, et ainsi de suite. De même, la valeur de motif FFFF hex produirait une ligne solide.

La position de destination est passé à une des routines de la ligne en pointillés
devient la nouvelle position du curseur graphique. Cela permet de tracer des lignes en pointillés connectés sans appeler un mouvement de routine graphiques du curseur entre les appels successifs à une routine de dessin au trait.

Exemple 6-6 dessine une paire de lignes pointillées croisées qui divisent l'écran
en quadrants. Il le fait en utilisant fg_move et fg_dash et dessine les lignes en blanc, la valeur par défaut pour la couleur 15 dans tous les modes graphiques vidéo. Le modèle de tableau de bord pour chaque ligne est 3333 hex, qui alterne deux pixels et hors tension.

  Exemple 6-6.

  #include <fastgraf.h>
                        void main (void);

  void main ()
                        {
                           int max_x, max_y;
                           int mid_x, mid_y;
                           int new_mode, old_mode;

  fg_initpm ();
                           fg_getmode old_mode = ();
                           fg_automode new_mode = ();
                           fg_setmode (new_mode);

  fg_getmaxx max_x = ();
                           fg_getmaxy max_y = ();
                           mid_x = max_x / 2;
                           mid_y = max_y / 2;

  fg_setcolor (15); 

  fg_move (mid_x, 0);
                           fg_dash (mid_x, max_y, 0x3333);
                           fg_move (0, mid_y);
                           fg_dash (max_x, mid_y, 0x3333);
                           fg_waitkey ();

  fg_setmode (old_mode);
                           fg_reset ();
                        }


===Polygones===

Fastgraph comprend des routines pour dessiner des polygones chargés et non chargés, comme
et une routine pour déterminer si un point donné est à l'intérieur d'un polygone convexe. Toutes les routines de polygone observent les limites d'écrêtage.

La routine de fg_polygon dessine un polygone vide dans l'espace de l'écran.  Il
nécessite un tableau de nombre entier x coordonnées comme premier argument, et un tableau de nombre entier y coordonne comme second argument. Chaque (x, y) paire de coordonnées à partir des deux réseaux est traité comme un sommet du polygone. En d'autres termes, la coordonnée x du premier sommet du polygone est le premier élément du tableau de coordonnées x et la coordonnée y du premier sommet est le premier élément de la matrice coordonnée y. De même, les seconds éléments de chaque réseau définissent le deuxième sommet, et ainsi de suite. Le troisième argument pour fg_polygon est une quantité entière qui indique le nombre d'éléments dans les deux coordonnées des tableaux (qui est, le nombre de sommets du polygone).

Une autre routine, fg_polygonw, dessine un polygone dans l'espace non rempli de monde.

La routine de fg_polygonw est la même que la routine de fg_polygon, à l'exception de son coordonnées x et y doivent contenir des tableaux valeurs à virgule flottante à la place des nombres entiers.
dessin polygonal commence au niveau du premier sommet de coordonnées spécifié dans la
tableaux. Les routines de polygones, puis tracer une ligne solide pour le second sommet, puis au troisième sommet, et continuent de cette manière par le dernier sommet. Si nécessaire, ils ferment alors le polygone en traçant une ligne reliant le dernier sommet et le premier sommet. Exemple 6-7 illustre le dessin de polygone non rempli en utilisant fg_polygon dans le monochrome EGA ou modes (modes 15 et 16) améliorés. Le programme se termine si aucun de ces modes vidéo sont disponibles.

  Exemple 6-7.

  #include <fastgraf.h>
             #include <stdio.h>
             #include <stdlib.h>
             void main (void);

  #define vertices 10

  int x [] = {200.300.400.400.300.240.160.160.200.210};
             int y [] = {100, 80.100.220.320.320.240.200.160.150};

  void main ()
             {

  int old_mode;

  fg_initpm ();
                fg_getmode old_mode = ();
                if (fg_testmode (16,1))
                   fg_setmode (16);
                else if (fg_testmode (15,1))
                   fg_setmode (15);
                autre {
                   printf ( "Ce programme nécessite un 640 x 350»);
                   ( "mode graphique EGA \ n".) printf;
                   sortie (1);
                   }

  fg_setcolor (1);
                fg_polygon (x, y, VERTICES);
                fg_waitkey ();

  fg_setmode (old_mode);
                fg_reset ();
             }


Comme le montre cet exemple, fg_polygon prévoit que les composantes x et y
définissant les sommets du polygone d'être dans des tableaux distincts. Une autre routine, fg_polyline, dessine un polygone non rempli de sommets du polygone dans un tableau d'entiers. Fg_polyline avec le premier élément de tableau est la composante x du premier sommet, le second élément est la composante y du premier sommet, le troisième élément est la composante x du deuxième sommet, et ainsi de suite. Le premier argument de fg_polyline est le sommet de coordonnées tableau de composantes x et y en alternance, et le second argument spécifie le nombre de sommets. À d'autres égards, est identique à celui fg_polyline fg_polygon.

Une caractéristique supplémentaire disponible avec fg_polyline mais pas fg_polygon est
la possibilité de spécifier des décalages vertex. deux arguments entiers de la routine de fg_polyoff respectivement définir les valeurs de décalage qui sont ajoutés à chaque sommet de fg_polyline. Ceci permet de définir des sommets du polygone en tant que valeurs relatives, qui lorsqu'ils sont combinés avec des décalages, de déterminer la position absolue du polygone.

Peut-être le plus important programme d'affichage de polygones est fg_polyfill, qui
affiche un polygone convexe rempli dans l'espace de l'écran (le polygone est rempli de pixels de la couleur actuelle). Son premier argument est un tableau de vertex dans le même format utilisé par fg_polyline. L'argument suivant est un tableau de travail utilisé en interne. La taille en octets du tableau de travail doit être d'au moins quatre fois la hauteur de polygone. Le dernier argument spécifie le nombre de sommets du polygone.

Exemple 6-8 illustre l'utilisation de fg_polyline, fg_polyoff et
fg_polyfill. Le programme dessine d'abord un polygone non rempli, centré dans la moitié gauche de l'écran. Il tire alors une version remplie du même polygone, centré dans la moitié droite de l'écran. Dans chaque cas, le centrage est réalisé en faisant passer les valeurs appropriées pour fg_polyoff. Après avoir attendu pendant une séquence de touches, le programme établit une zone de découpage dans le coin inférieur droit et redessine le polygone rempli à la même position, mais dans une couleur différente. Des résultats de ce parcours dans seulement une partie du polygone rempli en cours d'élaboration. Comme exemple 6-7, cet exemple requiert un mode 640x350 graphique. Guide de l'utilisateur 106 Fastgraph


  Exemple 6-8.

  #include <fastgraf.h>
           #include <stdio.h>
           #include <stdlib.h>
           void main (void);

  #define vertices 10

  int xy [] = {200,100, 300, 80, 400100, 400220, 300320,
                       240320, 160240, 160200, 200160, 210150};
           int work_array [700];

  void main ()
           {
              int old_mode;

  fg_initpm ();
              fg_getmode old_mode = ();
              if (fg_testmode (16,1))
                 fg_setmode (16);
              else if (fg_testmode (15,1))
                 fg_setmode (15);
              autre {
                 printf ( "Ce programme nécessite un 640 x 350»);
                 ( "mode graphique EGA \ n".) printf;
                 sortie (1);
                 }

  fg_setcolor (1);
              fg_polyoff (-120, -25);
              fg_polyline (xy, VERTICES);
              fg_polyoff (200, -25);
              fg_polyfill (xy, work_array, VERTICES);
              fg_waitkey ();

  fg_setcolor (2);
              fg_setclip (480,639,175,349);
              fg_polyfill (xy, work_array, VERTICES);
              fg_waitkey ();

  fg_setmode (old_mode);
              fg_reset ();
           }


La routine de fg_polyfill remplit les polygones convexes.  De Fastgraph de
perspective, un polygone est convexe si une ligne horizontale tracée à travers le polygone traverse le bord gauche exactement une fois et le bord droit exactement une fois (à l'exclusion des segments de bord horizontal et de longueur nulle). A noter que cette définition inclut des formes qui ne sont pas convexe dans le sens traditionnel. En outre, tout polygone non convexe peut être décomposée en deux ou plusieurs polygones convexes. Tous les triangles (qui est, les polygones de trois sommets) sont par leur nature convexe.

Le polygone convexe rempli est un outil de base de l'ordinateur en trois dimensions
graphique. Une pratique courante consiste à construire une image ou d'un objet à partir de plusieurs polygones adjacents ou de connexion. Ces polygones se chevauchent généralement à un ou plusieurs bords. Par exemple, les coordonnées définissant le bord droit d'un polygone peut également définir le bord gauche d'un autre polygone immédiatement à sa droite. Pour une image globale apparaisse correcte, ses polygones de composants doivent correspondre ensemble correctement. Par défaut, fg_polyfill applique les règles suivantes pour gérer chevaucher les bords du polygone:

* Points situés exactement sur les bords non horizontaux
              sont dessinés uniquement si l'intérieur du polygone est
               directement à droite.

* Points situés exactement sur les bords horizontaux sont
              dessiné que si l'intérieur du polygone est directement
               en dessous.

* Un sommet est établi que si toutes les lignes se terminant à
               ce point satisfait les deux conditions ci-dessus.

Ces trois règles assurent qu'aucun pixel est tiré plus d'une fois lors du remplissage de polygones adjacents. Toutefois, ce comportement peut ne pas être adapté à l'affichage des polygones qui ne sont pas adjacents, parce que certains ou tous les pixels sur les bords droit et inférieur du polygone seront exclus. Si cela est un problème, vous pouvez utiliser fg_polyedge pour forcer fg_polyfill pour inclure tous les pixels de bord. La routine fg_polyedge attend un paramètre entier unique. Si elle est nulle, fg_polyfill comprendra tous les pixels de bord lors de l'élaboration des polygones convexes. Passant toute autre valeur à fg_polyedge restaure le comportement par défaut d'exclure les pixels qui répondent aux critères décrits ci-dessus.

La routine finale Fastgraph relatives aux polygones est fg_inside, qui
vérifie si un point spécifié se situe à l'intérieur d'un polygone convexe. Son premier argument est un tableau de vertex dans le même format utilisé par fg_polyline et fg_polyfill. Le second argument est le nombre de sommets du polygone, tandis que les deux derniers arguments spécifient l'espace écran coordonnées x et y du point mis à l'essai. Les fg_inside routine renvoie 1 si le point se trouve à l'intérieur du polygone et 0 sinon. Si le tableau de vertex ne définit pas un polygone convexe, la valeur de retour est indéfinie. Les décalages de fg_polyoff sont appliqués à la fg_inside tableau de vertex, mais pas au point de test.


===Cercles et Ellipses===

Fastgraph comprend des routines pour le dessin rempli et les cercles non remplis et
ellipses. Les deux versions de l'espace de l'écran et de l'espace du monde de ces routines sont disponibles, et chacun d'entre eux observent les limites d'écrêtage.

La routine de fg_circle dessine un cercle vide dans l'espace de l'écran, centrée
à la position du curseur graphique, en utilisant la couleur actuelle. Son seul argument spécifie le rayon du cercle dans horizontales unités de l'espace de l'écran. Une autre routine, fg_circlew, dessine un cercle non rempli où le rayon est mesuré en unités horizontales spatiales mondiales. Les routines analogues pour les cercles de dessin rempli sont fg_circlef et fg_circlefw. Les quatre cercles de dessin routines quittent la position du curseur graphique inchangé. Guide de l'utilisateur 108 Fastgraph

La routine de fg_ellipse dessine une ellipse non remplie dans l'espace de l'écran,
centré sur la position du curseur graphique, en utilisant la couleur actuelle. La routine requiert deux arguments qui indiquent respectivement la longueur de ses demi-axes horizontaux et verticaux. En d'autres termes, le premier argument est la distance absolue à partir du centre de l'ellipse à son extrémité horizontale et le second argument est la distance absolue du centre à l'extrémité verticale. Une autre routine, fg_ellipsew, dessine une ellipse non remplie dans l'espace mondial. Les routines analogues pour dessiner des ellipses remplies sont fg_ellipsef et fg_ellipsfw. Les quatre routines de dessin ellipse quittent la position du curseur graphique inchangé.

Exemple 6-9 illustre l'utilisation de la fg_circlew et fg_ellipsew
routines. Le programme utilise d'abord fg_automode de proposer un mode vidéo de graphiques et utilise ensuite fg_setmode pour sélectionner ce mode vidéo. Il fait alors la couleur 15 la couleur actuelle, qui par défaut est blanc dans tous les modes graphiques couleur et "on" dans les modes les monochromes graphiques. Ensuite, il établit un espace de 200x200 système de coordonnées. Le programme fg_ellipsew utilise ensuite pour dessiner une ellipse et fg_circlew pour dessiner un cercle, à la fois centré au milieu de l'écran (ce qui est à l'origine de notre espace mondial du système de coordonnées). Le cercle a un rayon de 1/16 de la largeur de l'écran (12,5 horizontales unités spatiales du monde), et l'ellipse est inscrite horizontalement à l'intérieur du cercle.

Exemple 6-10 illustre l'utilisation de la fg_circle et fg_ellipse
routines. Il est fonctionnellement identique à l'exemple 6-9, mais il utilise l'espace de l'écran plutôt que l'espace de coordonnées du monde pour dessiner le cercle et une ellipse. Notez les arguments à fg_circle et fg_ellipse dépendent du maximum de coordonnées x et y du mode vidéo sélectionné. Si l'on ne calcule ces arguments de cette manière, la taille réelle du cercle et une ellipse serait proportionnel à la résolution de pixel du mode vidéo. Aucune telle dépendance existe lorsque vous utilisez l'espace du monde, mais nous payons un prix pour cette fonction dans un peu plus lente vitesse d'exécution.

  Exemple 6-9.  Exemple 6-10.

  #include <fastgraf.h> #include <fastgraf.h>
       void main (void);  void main (void);

  void main () void main ()
       {{
          int old_mode;  int mid_x, mid_y;
                                              int old_mode;
          fg_initpm ();  int x, y;
          fg_getmode old_mode = ();
          fg_setmode (fg_automode ());  fg_initpm ();
          fg_setcolor (15);  fg_getmode old_mode = ();
                                              fg_setmode (fg_automode ());
          fg_initw ();  fg_setcolor (15);
          fg_setworld (-100.0,100.0,
                      -100.0,100.0);  mid_x = fg_getmaxx () / 2;
                                              mid_y = fg_getmaxy () / 2;
          fg_movew (0.0,0.0);  x = mid_x / 8;
          fg_ellipsew (12.5,12.5);  y = mid_y / 8;
          fg_circlew (12,5);
          fg_waitkey ();  fg_move (mid_x, mid_y);
                                              fg_ellipse (x, y);
          fg_setmode (old_mode);  fg_circle (x); 
                                       Chapitre 6: Fundamentals graphiques 109


  fg_reset ();  fg_waitkey ();
       }
                                              fg_setmode (old_mode);
                                              fg_reset ();
                                           }


===Rectangles solides===

Fastgraph comprend quatre routines pour dessiner des rectangles solides, deux pour
l'espace de l'écran et deux pour l'espace du monde, avec et sans écrêtage. Aucun de ces routines affectent la position du curseur graphique.

La routine de fg_rect dessine un rectangle solide dans l'espace de l'écran, sans
ce qui concerne les limites d'écrêtage, en utilisant la couleur actuelle. Il nécessite quatre arguments entiers qui définissent respectivement le minimum x, x maximale, y minimum, et y coordonnées maximales de l'espace de l'écran du rectangle. Les coordonnées minimales doivent être inférieures ou égales aux coordonnées maximales, ou bien les résultats sont imprévisibles. La routine de fg_clprect est identique en tous points à fg_rect, sauf qu'il respecte les limites d'écrêtage.

Les versions de l'espace mondial des solides routines de dessin de rectangle sont
fg_rectw et fg_clprectw. Comme fg_rect et fg_clprect, ils nécessitent quatre arguments qui définissent les extrémités du rectangle, mais les arguments sont coordonnées spatiales points du monde flottant.

Vous pouvez également utiliser fg_rect en mode texte.  Lorsqu'il est utilisé dans un mode texte, fg_rect
prévoit que ses quatre arguments pour être exprimés dans l'espace de caractères (qui est, lignes et colonnes) plutôt que l'espace de l'écran. Cela signifie que les quatre arguments spécifient respectivement la colonne minimum, colonne maximale, ligne minimale et ligne maximale du rectangle. Fastgraph construit le rectangle en stockant le solide caractère de bloc (ASCII valeur décimale 219) dans chaque cellule de caractère comprenant rectangle. Le rectangle est dessiné en utilisant l'attribut de caractère en cours, mais parce que le caractère de bloc solide occupe la cellule de caractère entier, le composant de base de l'attribut est essentiellement dépourvue de sens.

Exemple 6-11 illustre l'utilisation de fg_rect en tirant 200 aléatoire de taille
rectangles aux couleurs aléatoires. Le programme utilise fg_automode premier à proposer un mode vidéo de graphiques, puis utilise la routine de fg_setmode pour sélectionner ce mode vidéo. Ensuite, il détermine la résolution d'écran horizontal et vertical pour le mode vidéo sélectionné, en utilisant fg_getmaxx et fg_getmaxy. La partie principale du programme est une boucle qui génère un rectangle aléatoire dans chaque itération. A l'intérieur de la boucle, la fonction de bibliothèque rand C est utilisé pour générer les extrémités du rectangle. Si nécessaire, le programme échange alors les coordonnées pour rendre minimum les coordonnées inférieures ou égales aux coordonnées maximales. Enfin, il utilise à nouveau rand pour générer un numéro de couleur aléatoire entre 0 et 15, puis dessine le rectangle dans cette couleur. Après avoir dessiné les 200 rectangles, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

  Exemple 6-11.

  #include <fastgraf.h>
             void main (void); 


  #define RECTANGLES 200
             #define SWAP (a, b, temp) {temp = a;  a = b;  b = température;  }

  void main ()
             {
                int i;
                int minx, maxx, Miny, maxy;
                int old_mode;
                int température;
                xres int, yres;

  fg_initpm ();
                fg_getmode old_mode = ();
                fg_setmode (fg_automode ());

  xres = fg_getmaxx () + 1;
                yres = fg_getmaxy () + 1;

  for (i = 0; i <RECTANGLES; i ++) {
                   minx = rand ()% xres;
                   maxx = rand ()% xres;
                   Miny = rand ()% yres;
                   maxy = rand ()% yres;
                   if (minx> maxx)
                      SWAP (minx, maxx, temp);
                   if (Miny> maxy)
                      SWAP (Miny, Maxy, temp);
                   fg_setcolor (rand ()% 16);
                   fg_rect (minx, maxx, Miny, maxy);
                   }

  fg_setmode (old_mode);
                fg_reset ();
             }


===Rectangles carnet===

Fastgraph comprend quatre routines pour dessiner des rectangles non remplis.  le
routine fg_box dessine un rectangle vide dans l'espace de l'écran, en ce qui concerne les limites d'écrêtage, en utilisant la couleur actuelle. Les arguments à fg_box sont les mêmes que ceux pour fg_rect. La profondeur des bords du rectangle est un pixel par défaut, mais vous pouvez modifier la profondeur en appelant fg_boxdepth. La routine fg_boxdepth attend deux arguments. Le premier argument est la largeur des côtés gauche et droit du rectangle, tandis que le second est la hauteur de ses faces supérieure et inférieure. Une fois que vous appelez fg_boxdepth, fg_box attire tous les rectangles non remplis en utilisant les valeurs de profondeur spécifiées dans l'appel le plus récent à fg_boxdepth. Les fonctions de fg_getxbox et fg_getybox renvoient respectivement les réglages de profondeur de la boîte horizontale et verticale, tel que défini dans l'appel le plus récent à fg_boxdepth. Contrairement à fg_rect, fg_box n'a aucun effet en mode vidéo de texte. L'analogue de routine de l'espace du monde est fg_boxw.

Exemple 6-12 est le même que l'exemple 11.06, mais non rempli à la place tire
rectangles de solides. Le programme utilise fg_box pour dessiner le rectangle et chaque fg_boxdepth pour définir la profondeur de rectangle en trois pixels dans chaque direction.

Notez que vous ne devez pas appeler fg_boxdepth pour chaque rectangle si vous voulez tous avoir la même profondeur.

  Exemple 6-12.

  #include <fastgraf.h>
             void main (void);

  #define RECTANGLES 200
             #define SWAP (a, b, temp) {temp = a;  a = b;  b = température;  }

  void main ()
             {
                int i;
                int minx, maxx, Miny, maxy;
                int old_mode;
                int température;
                xres int, yres;

  fg_initpm ();
                fg_getmode old_mode = ();
                fg_setmode (fg_automode ());
                fg_boxdepth (3,3);

  xres = fg_getmaxx () + 1;
                yres = fg_getmaxy () + 1;

  for (i = 0; i <RECTANGLES; i ++) {
                   minx = rand ()% xres;
                   maxx = rand ()% xres;
                   Miny = rand ()% yres;
                   maxy = rand ()% yres;
                   if (minx> maxx)
                      SWAP (minx, maxx, temp);
                   if (Miny> maxy)
                      SWAP (Miny, Maxy, temp);
                   fg_setcolor (rand ()% 16);
                   fg_box (minx, maxx, Miny, maxy);
                   }

  fg_setmode (old_mode);
                fg_reset ();
             }


Les fg_boxx et fg_boxxw routines sont l'espace de l'écran et de l'espace du monde
versions "exclusives ou" des routines boîte de dessin. Ils simplifient l'affichage des boîtes rubberband (rectangles creux qui se déplacent en réponse à des frappes ou des mouvements de la souris) parce que le dessin d'un objet en mode XOR fait apparaître, mais le dessin à nouveau dans la même position et la même couleur restaure ce qui était sous l'objet à l'origine. Compte tenu de cette propriété utile, voici un aperçu de ce qui est nécessaire pour dessiner une zone de rubberband:

  1. Dessinez la boîte dans sa position initiale avec
               fg_boxx ou fg_boxxw. 

  2. Attendez une réponse utilisateur qui signifie boîte
               mouvement.
         3. Utilisez fg_boxx ou fg_boxxw pour redessiner la case dans la
               même position que dans l'étape 1. Ceci restaure ce
               il était à l'origine.
         4. Dessinez la boîte dans sa nouvelle position avec fg_boxx ou
               fg_boxxw.
         5. Répétez les étapes 2, 3 et 4 jusqu'à ce que la boîte est pas
               plus nécessaire.

Exemple 6-13 montre une simple utilisation de fg_boxx dans le 320x200 MCGA / VGA 256-
mode couleur (mode 19). Le programme remplit les moitiés gauche et droite de l'écran avec différentes couleurs, puis affiche une boîte XOR qui chevauche chaque moitié. Même si la boîte est dessinée dans la même couleur que la moitié droite, il est encore visible, car le dessin quelque chose dans un mode XOR (sauf dans la couleur 0) garantit qu'il sera visible sur son fond. Après une séquence de touches, le programme redessine la même boîte, ce qui bien sûr restaure ce qui était là en premier lieu.

  Exemple 6-13.

  #include <fastgraf.h>
                          void main (void);

  void main ()
                          {
                             int old_mode;

  fg_initpm ();
                             fg_getmode old_mode = ();
                             fg_setmode (19);
                             fg_setcolor (9);
                             fg_rect (0,159,0,199);
                             fg_setcolor (15);
                             fg_rect (160,319,0,199);
                             fg_waitkey ();

  fg_boxx (80,239,50,149);
                             fg_waitkey ();
                             fg_boxx (80,239,50,149);
                             fg_waitkey ();

  fg_setmode (old_mode);
                             fg_reset ();
                          }


===Dithered Rectangles===

Procédé selon l'une alternance de pixels de couleurs différentes dans une région de la
zone d'affichage est appelé tramage. Cette technique est particulièrement utile dans les modes avec peu de couleurs, tels que les modes CGA et Hercules graphiques, parce que vous pouvez simuler des couleurs supplémentaires grâce à des utilisations efficaces de tramage. Fastgraph comprend deux routines pour dessiner des rectangles tramées, l'un pour l'espace de l'écran
et un pour l'espace mondial. Ni routine observe les limites d'écrêtage, ni n'affectent la position du curseur graphique.

La routine de fg_drect dessine un rectangle tramé dans l'espace de l'écran.  Comme le
routine fg_rect, fg_drect requiert des arguments quatre entiers qui définissent respectivement le minimum x, maximum x, y minimum, et y coordonnées maximales de l'espace de l'écran du rectangle. Les coordonnées minimales doivent être inférieures ou égales aux coordonnées maximales, ou bien les résultats sont imprévisibles. Cependant, fg_drect nécessite également un cinquième argument qui définit la matrice de tramage, qui à son tour détermine le motif de pixels utilisé pour construire le rectangle tramé. La taille et la forme de la matrice de tramage dépendent du mode vidéo.

La version de l'espace mondial de la routine tramée de dessin rectangle est
fg_drectw. Comme fg_drect, il nécessite quatre arguments qui définissent les extrémités du rectangle, et un cinquième argument qui définit la matrice de tramage.

Comme mentionné précédemment, la taille et le format de la matrice de tramage sont
en fonction du mode vidéo. La matrice de tramage est un tableau de quatre octets dans tous les modes vidéo, à l'exception des modes 256 graphiques couleur (modes 19 à 27), où il est un tableau de huit octets. Ce tableau contient un motif de pixels qui fg_drect ou fg_drectw reproduit dans la zone du rectangle. La structure de la matrice de tramage imite étroitement la structure de mémoire vidéo dans chaque mode graphique.

Le reste de cette section présentera quelques-unes spécifique en mode simple

Des exemples pour illustrer la structure de la matrice de tramage dans différents modes graphiques. Supposons que nous aimerions produire un «damier» de la lumière bleue et blanche pixels. Autrement dit, dans une ligne donnée d'un rectangle, pixels consécutifs alterne entre ces deux couleurs. En outre, le motif de rangées adjacentes sera décalée de sorte qu'il y aura toujours un pixel blanc au-dessus et au-dessous d'un pixel bleu clair, et vice versa. D'où ce modèle de pixel ressemblerait à quelque chose comme

  BWBW
                                    wbwb
                                    BWBW
                                    wbwb

où chaque B représente un pixel bleu clair, et chaque W représente un pixel blanc. Les exemples suivants décrivent la matrice de tramage qui pourrait être utilisé pour produire un motif de pixels dans chaque mode graphique.

====CGA quatre couleurs Modes graphiques====

Les CGA-quatre couleurs graphiques modes (modes 4 et 5) utilisent quatre octets
tramage matrice qui Fastgraph traite comme un quatre-ligne par tableau à une colonne. Etant donné que chaque pixel dans ces modes nécessite deux bits de mémoire vidéo, chaque octet de la matrice de tramage contient quatre pixels. Ainsi, la représentation des pixels de la matrice de tramage apparaîtraient comme illustré sur la gauche; sa traduction en valeurs numériques apparaît à droite.


  [3] BWBW [3] 01 11 01 11

  [2] wbwb [2] 11 01 11 01

  [1] BWBW [1] 01 11 01 11

  [0] wbwb [0] 11 01 11 01


Parce que ces modes ne proposent pas une couleur bleu clair, nous avons utilisé cyan clair (valeur de couleur 1 dans la palette 1) pour approcher bleu clair. Les pixels B traduisent ainsi la valeur de couleur 1, ou 01 binaire. Blanc est disponible en tant que valeur de couleur 3 dans la palette 1, de sorte que les pixels W traduisent la valeur de couleur 3, ou 11 binaire. Le hexadécimal équivalent de la valeur binaire 11011101 (pour les éléments de tableau [0] et [2]) est DD, et l'équivalent hexadécimal de la valeur binaire 01110111 (pour les éléments de tableau [1] et [3]) est 77. Comme le montre la exemple 6-12, ce sont précisément les valeurs attribuées aux éléments de la matrice de tramage.

Exemple 6-14 mode 4 utilise pour afficher 50 pixels par 50 pixels tramée
rectangle dans le coin supérieur gauche de l'écran. La matrice de tramage représente le motif en damier bleu et blanc discuté dans le paragraphe précédent.

  Exemple 6-14.

  #include <fastgraf.h>
                       void main (void);

  void main ()
                       {
                          matrice char [4];
                          int old_mode;

  fg_initpm ();
                          fg_getmode old_mode = ();
                          fg_setmode (4);

  la matrice [0] = matrice [2] = 0xDD;
                          la matrice [1] = matrice [3] = 0x77;
                          fg_drect (0,49,0,49, matrice);
                          fg_waitkey ();

  fg_setmode (old_mode);
                          fg_reset ();
                       }


====CGA Two-Color Mode graphique====

Le CGA (mode 6) en deux couleurs graphiques utilise un dithering de quatre octets
matrice qui Fastgraph traite comme un tableau à quatre rangées par une colonne, comme dans les autres modes CGA-quatre couleurs. Cependant, chaque pixel dans ce mode ne nécessite qu'un seul bit de mémoire vidéo, de sorte que chaque octet de la matrice de tramage contient huit pixels. Ainsi, la représentation des pixels de la matrice de tramage apparaîtraient comme illustré sur la gauche; sa traduction en valeurs numériques apparaît à droite.


  [3] BWBWBWBW [3] 1 0 1 0 0 1 0 1

  [2] WBWBWBWB [2] 1 0 1 0 1 0 1 0

  [1] BWBWBWBW [1] 0 1 0 1 0 1 0 1

  [0] WBWBWBWB [0] 1 0 1 0 1 0 1 0


Mode 6 évidemment ne propose pas de couleur bleu clair, nous avons donc utilisé le noir (valeur de couleur 0) à sa place. Les B pixels se traduisent donc à la valeur de couleur 0. Blanc est disponible en tant que valeur de couleur 1, de sorte que les pixels W traduisent la valeur de couleur 1. L'équivalent hexadécimal de la valeur binaire 10101010 (pour les éléments de tableau [0] et [2]) est AA et l'équivalent hexadécimal de la valeur binaire 01010101 (pour les éléments de tableau [1] et [3]) est de 55. Ainsi, pour faire exemple 6-14 run en mode 6, nous avons seulement besoin de changer l'argument fg_setmode 4-6 et modifier les valeurs de la matrice de tramage comme montré ici:


  la matrice [0] = matrice [2] = 0xAA;
                         la matrice [1] = matrice [3] = 0x55;


====Tandy / PCjr 16-Color Mode graphique====

Le mode 16 couleurs graphique Tandy / PCjr (mode 9) utilise également quatre octets
tramage matrice qui Fastgraph traite comme un quatre-ligne par tableau à une colonne. Chaque pixel dans ce mode nécessite quatre bits de mémoire vidéo, de sorte que chaque octet de la matrice de tramage contient deux pixels seulement. Ainsi, la représentation des pixels de la matrice de tramage apparaîtraient comme illustré sur la gauche; sa traduction en valeurs numériques apparaît à droite.


  [3] BW [3] 1001 1111

  [2] WB [2] 1111 1001

  [1] BW [1] 1001 1111

  [0] WB [0] 1111 1001


Les B pixels se traduisent par une valeur de couleur 9 (bleu clair), ou 1001 binaire, et les pixels W traduisent la valeur de couleur 15 (blanc), ou 1111 binaire. L'équivalent hexadécimal de la valeur binaire 11111001 (pour les éléments de tableau [0] et [2]) est F9, et l'équivalent hexadécimal de la valeur binaire 10011111 (pour les éléments de tableau [1] et [3]) est 9F. Ainsi, pour faire exemple 6-14 run en mode 9, nous avons seulement besoin de changer l'argument fg_setmode 4-9 et modifier les valeurs de la matrice de tramage comme montré ici:


  la matrice [0] = matrice [2] = 0xF9;
                         la matrice [1] = matrice [3] = 0x9F; 

====Mode graphique Hercules====

La taille et le format de la matrice de tramage dans le mode graphique Hercules
(Mode 11) sont les mêmes que dans le mode à deux couleurs CGA (mode 6).

====Hercules Low-Resolution Mode graphique====

La taille et le format de la matrice de tramage dans le bas Hercules
résolution graphique (mode 12) sont les mêmes que dans les CGA modes de quatre couleurs (modes 4 et 5). En ce qui concerne notre exemple en damier va, nous allons utiliser le noir (valeur de couleur 0) à la place de la lumière bleue, et en gras (valeur de couleur 3) au lieu de blanc. Ainsi, les B pixels se traduisent par 00 binaire, tandis que les pixels W traduisent à 11 binaire. Le hexadécimal équivalent de la valeur binaire 11001100 (pour les éléments de tableau [0] et [2]) est CC, et l'équivalent hexadécimal de la valeur binaire 00110011 (pour les éléments de tableau [1] et [3]) est 33. Ainsi, pour faire exemple 6-14 run en mode 12, nous avons seulement besoin de changer l'argument fg_setmode 4-12 et modifier les valeurs de la matrice de tramage comme montré ici:


  la matrice [0] = matrice [2] = 0xCC;
                         la matrice [1] = matrice [3] = 0x33;


====EGA / VGA / SVGA 16 couleurs Modes graphiques====

Les modes EGA / VGA / SVGA 16 couleurs graphiques (modes 13 à 18, 28 et
29) utilisent une matrice de tramage de quatre octets qui Fastgraph traite comme un quatre-ligne par tableau à une colonne. Contrairement aux autres modes graphiques qui vous permettent de stocker des pixels de plusieurs couleurs dans la matrice de tramage, ces modes traitent la matrice de tramage comme un bitmap pour une couleur spécifique. Étant donné que chaque couleur dans le motif de tramage doit être stocké dans un bitmap séparé (qui est, dans une matrice de tramage séparée), vous devez appeler fg_drect une fois pour chaque couleur. En outre, vous devez utiliser fg_setcolor avant chaque appel à fg_drect pour définir la couleur utilisée avec la matrice de tramage.

Dans tous les modes graphiques EGA / VGA / SVGA, chaque octet de la matrice de tramage est
un bitmap qui représente huit pixels. En utilisant notre exemple en damier familier, la représentation de pixel de la matrice de tramage apparaîtrait comme indiqué ici:


  [3] BWBWBWBW

  [2] WBWBWBWB

  [1] BWBWBWBW

  [0] WBWBWBWB


Traduire ce modèle à des valeurs numériques est simple. Il suffit de construire une matrice de tramage pour chaque couleur dans le motif (il y a deux couleurs dans cet exemple), où les pixels de la couleur actuelle se traduisent à 1, et d'autres pixels traduisent à 0. Dans notre exemple, la traduction pour les B pixels apparaît ci-dessous sur la gauche, tandis que la traduction pour les pixels W apparaît sur la droite.

  [3] 1 0 1 0 1 0 1 0 [3] 1 0 1 0 0 1 0 1

  [2] 0 1 0 1 0 1 0 1 [2] 1 0 1 0 1 0 1 0

  [1] 1 0 1 0 1 0 1 0 [1] 0 1 0 1 0 1 0 1

  [0] 0 1 0 1 0 1 0 1 [0] 1 0 1 0 1 0 1 0


L'équivalent hexadécimal de la valeur binaire 01010101 est de 55, et l'équivalent hexadécimal de la valeur binaire 10101010 est AA. Comme on le voit dans l'exemple 15.06, ce sont précisément les valeurs attribuées aux éléments des matrices de tramage.

Exemple 6-15 mode 13 utilise pour afficher le bleu notre lumière et blanc
motif damier. Notez que vous devez appeler fg_drect deux fois - une fois pour les pixels bleu clair (valeur de couleur 9), et encore pour les pixels blancs (valeur de couleur 15). Notez également comment fg_setcolor est utilisé avant chaque appel à fg_drect pour définir la couleur des pixels fg_drect affichera.

  Exemple 6-15.

  #include <fastgraf.h>
                       void main (void);

  void main ()
                       {
                          matrice char [4];
                          int old_mode;

  fg_initpm ();
                          fg_getmode old_mode = ();
                          fg_setmode (13);

  la matrice [0] = matrice [2] = 0x55;
                          la matrice [1] = matrice [3] = 0xAA;
                          fg_setcolor (9);
                          fg_drect (0,49,0,49, matrice);

  la matrice [0] = matrice [2] = 0xAA;
                          la matrice [1] = matrice [3] = 0x55;
                          fg_setcolor (15);
                          fg_drect (0,49,0,49, matrice);
                          fg_waitkey ();

  fg_setmode (old_mode);
                          fg_reset ();
                       }

====256 Couleur Modes graphiques====

Les modes graphiques 256 couleurs (modes 19 à 27) utilisent huit octets
tramage matrice qui Fastgraph traite comme un quatre-ligne par tableau à deux colonnes. Chaque pixel dans ces modes nécessite huit bits de mémoire vidéo, de sorte que chaque octet de la matrice de tramage contient qu'un seul pixel. Nous devons donc la matrice de tramage à deux colonnes pour produire un motif de tramage significatif. La représentation de pixel de la matrice de tramage apparaîtrait comme indiqué sur la gauche; sa traduction en valeurs numériques apparaît à droite.


  [6] BW [7], [6] 9 15 [7]

  [4] WB [5] [4] 15 9 [5]

  [2] BW [3] [2] 9 15 [3]

  [0] WB [1] [0] 15 9 [1]


Les B pixels se traduisent par une valeur de couleur 9 (bleu clair), et les pixels W traduisent la valeur de couleur 15 (blanc). Exemple 6-16 en mode 19 utilise pour dessiner notre motif en damier bleu clair et blanc.

  Exemple 6-16.

  #include <fastgraf.h>
            void main (void);

  void main ()
            {
               matrice char [8];
               int old_mode;

  fg_initpm ();
               fg_getmode old_mode = ();
               fg_setmode (19);

  la matrice [0] = matrice [3] = matrice [4] = matrice [7] = 15;
               la matrice [1] = matrice [2] = matrice [5] = matrice [6] = 9;
               fg_drect (0,49,0,49, matrice);
               fg_waitkey ();

  fg_setmode (old_mode);
               fg_reset ();
            }


====Discours de clôture====

Il y a deux autres éléments importants relatifs à fg_drect et fg_drectw.

Ces articles appliquent quel que soit le mode graphique vidéo est utilisé.

Tout d'abord, la matrice de tramage ne peut pas contenir des valeurs de couleurs virtuelles.  Cette
est, les valeurs de couleurs de pixels stockées dans la matrice de tramage doit être entre 0 et la valeur maximale de couleur correspondant au mode vidéo en cours. Si une valeur de couleur est
redéfini en utilisant fg_defcolor, Fastgraph ignore toujours la redéfinition et utilise plutôt la valeur réelle de la couleur. Notez que ce ne concerne pas les registres de palette ou vidéo registres du CAD, parce que dans ces cas, nous redéfinissons la couleur associée à une valeur de couleur et non la valeur de couleur elle-même.

Deuxièmement, Fastgraph aligne la matrice de tramage à des lignes spécifiques de pixels.
Fastgraph dessine le rectangle tramé en commençant par la rangée de pixels spécifié par la limite inférieure du rectangle (le maximum coordonnée y fg_drect, ou le minimum coordonnée y fg_drectw) et procède à la hausse jusqu'à atteindre la limite supérieure du rectangle. Dans tous les cas la matrice de tramage utilisée par fg_drect et fg_drectw contient quatre lignes. Si nous laissons r représentent la ligne de pixel correspondant à la limite inférieure du rectangle, puis la première rangée utilisée dans la matrice de tramage est r modulo 4 (en supposant que les lignes de la matrice de tramage sont numérotés de 0 à 3). Cet alignement vous permet d'utiliser la même matrice de tramage dans de multiples appels à fg_drect et fg_drectw pour la construction d'un objet de rectangles tramées adjacents (par exemple, une zone en forme de L) et ont encore le match de motif de tramage où les rectangles se croisent.


===Région Fill===

Fastgraph comprend des routines pour le remplissage des régions arbitraires.  Le fg_flood
et les routines de fg_paint remplissent une région avec la valeur de couleur actuelle en spécifiant un point dans l'intérieur de la région de l'espace de l'écran. La routine de fg_floodw et fg_paintw remplir aussi une région, mais ils exigent le point intérieur à exprimer dans l'espace mondial. Toutes les régions remplir routines ont deux arguments qui spécifient le (x, y) les coordonnées du point intérieur. Pour fg_flood et fg_paint, les arguments sont des quantités entières. Pour fg_floodw et fg_paintw, ils flottent des quantités ponctuelles. Aucun d'entre eux changer la position du curseur graphique. La différence entre la «inondation» et les versions "de peinture" de ces routines est simple: fg_flood et fg_floodw ne prolongeront pas la région de remplissage au-delà des limites d'écrêtage, tandis que fg_paint et fg_paintw ignorer les limites d'écrêtage. Par conséquent, fg_paint et fg_paintw sont nettement plus rapides.

La région étant rempli doit être un polygone fermé dont la couleur limite est
différent de celui du point intérieur spécifié. La région peut contenir des trous (zones intérieures qui ne seront pas remplis). Fastgraph remplit la région en changeant chaque pixel intérieur dont la couleur est le même que le point intérieur spécifié, à la couleur actuelle. Si le point intérieur est déjà la couleur actuelle, la région de remplissage routines ne font rien. Il est important de noter fg_paint et fg_paintw ne pas traiter les bords de l'écran que les limites des polygones. Remplissage d'un polygone ouvert provoquera ces routines à se comporter de façon imprévisible. Ce n'est pas le cas avec fg_flood et fg_floodw aussi longtemps que les limites d'écrêtage ne sont pas au-delà des bords de l'écran.

Exemple 6-17 illustre une utilisation simple de fg_paint dans un 320x200 graphiques
mode. Le programme fg_bestmode utilise pour sélectionner un mode vidéo disponible (si aucun mode graphique de 320x200 est disponible, le programme se termine). Après avoir établi le mode vidéo sélectionné, le programme utilise fg_move et fg_drawrel pour dessiner un rectangle creux de couleur 10 et un diamant creux de couleur 9. Le diamant est tracé au milieu du rectangle, ce qui en fait un trou par rapport au rectangle . Le programme laisse ces formes sur l'écran jusqu'à ce qu'une touche est enfoncée. Il appelle ensuite fg_paint pour remplir cette partie du rectangle à l'extérieur du diamant avec la couleur 10. Après avoir attendu une autre touche, le programme utilise à nouveau fg_paint pour remplir l'intérieur du diamant avec la couleur 15. Enfin, le Guide de l'utilisateur 120 Fastgraph
programme attend une autre touche, rétablit le mode vidéo original et attributs de l'écran, et retourne à DOS.

  Exemple 6-17.

  #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
              void main (void);

  void main ()
              {
                 int old_mode, new_mode;

  fg_initpm ();
                 new_mode = fg_bestmode (320,200,1);
                 if (new_mode <0) {
                    printf ( "Ce programme nécessite un 320 x 200»);
                    ( "mode graphique \ n".) printf;
                    sortie (1);
                    }

  fg_getmode old_mode = ();
                 fg_setmode (new_mode);

  fg_setcolor (10);
                 fg_move (100,50);
                 fg_drawrel (120,0);
                 fg_drawrel (0100);
                 fg_drawrel (-120,0);
                 fg_drawrel (0, -100);

  fg_setcolor (9);
                 fg_move (160,80);
                 fg_drawrel (30,20);
                 fg_drawrel (-30,20);
                 fg_drawrel (-30, -20);
                 fg_drawrel (30, -20);
                 fg_waitkey ();

  fg_setcolor (10);
                 fg_paint (160,70);
                 fg_waitkey ();

  fg_setcolor (15);
                 fg_paint (160,100);
                 fg_waitkey ();

  fg_setmode (old_mode);
                 fg_reset ();
              }

===Résumé des fondamentaux Routines graphiques===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_BOX dessine un rectangle vide dans l'espace de l'écran, par rapport à la
zone de découpage. La largeur des bords du rectangle est un pixel à moins changé avec la routine de fg_boxdepth.

FG_BOXDEPTH définit la profondeur des rectangles dessinés avec l'affichage de la boîte
routines. La routine de fg_setmode initialise la profondeur de la boîte à un pixel.

FG_BOXW dessine un rectangle vide dans l'espace du monde, par rapport à la
zone de découpage. La largeur des bords du rectangle est un pixel à moins changé avec la routine de fg_boxdepth.

FG_BOXX dessine un rectangle vide dans l'espace de l'écran, par rapport à la
zone de découpage, en mode "ou exclusif". La largeur des bords du rectangle est un pixel à moins changé avec la routine de fg_boxdepth.

FG_BOXXW dessine un rectangle vide dans l'espace du monde, par rapport à la
zone de découpage, en mode "ou exclusif". La largeur des bords du rectangle est un pixel à moins changé avec la routine de fg_boxdepth.

FG_CIRCLE dessine un cercle vide dans l'espace de l'écran.  Le cercle est
centré sur la position du curseur graphique.

FG_CIRCLEF dessine un cercle rempli dans l'espace de l'écran.  Le cercle est centré
à la position du curseur graphique.

FG_CIRCLEFW dessine un cercle rempli dans l'espace mondial.  Le cercle est centré
à la position du curseur graphique.

FG_CIRCLEW dessine un cercle vide dans l'espace mondial.  Le cercle est
centré sur la position du curseur graphique.

FG_CLPRECT dessine un (rempli) rectangle solide dans l'espace de l'écran, en ce qui concerne
à la zone de découpage.

FG_CLPRECTW dessine un (rempli) rectangle solide dans l'espace mondial, en ce qui concerne
à la zone de découpage.

FG_DASH dessine une ligne en pointillés des graphiques position du curseur à un
position absolue de l'espace de l'écran. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DASHREL dessine une ligne en pointillés des graphiques curseur position à une
position de l'espace de l'écran par rapport à lui. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DASHRW dessine une ligne en pointillés des graphiques curseur position à une
la position mondiale de l'espace par rapport à lui. Il permet également la position de destination de la nouvelle position du curseur graphique. Guide de l'utilisateur 122 Fastgraph

FG_DASHW dessine une ligne en pointillés des graphiques position du curseur à un
position absolue de l'espace mondial. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAW dessine une ligne solide des graphiques position du curseur à un
position absolue de l'espace de l'écran. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWREL dessine une ligne solide des graphiques curseur position à une
position de l'espace de l'écran par rapport à lui. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWRELX dessine une ligne solide en mode "ou exclusif" des graphiques
la position du curseur vers une position d'espace de l'écran par rapport à lui. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWRW dessine une ligne solide à partir de la position du curseur graphique à un monde
l'espace position par rapport à elle. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWRXW dessine une ligne solide en mode "ou exclusif" des graphiques
la position du curseur à une position de l'espace du monde par rapport à lui. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWW dessine une ligne solide des graphiques position du curseur à un
position absolue de l'espace mondial. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWX dessine une ligne solide en mode "ou exclusif" des graphiques
la position du curseur à une position d'espace d'écran absolu. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRAWXW dessine une ligne solide en mode "ou exclusif" des graphiques
la position du curseur à une position mondiale de l'espace absolu. Il permet également la position de destination de la nouvelle position du curseur graphique.

FG_DRECT dessine un rectangle tramé dans l'espace de l'écran, sans tenir compte de
la zone de découpage. Le motif de tramage du rectangle est défini par une matrice de tramage dont le format dépend du mode vidéo utilisé.

FG_DRECTW dessine un rectangle tramé dans l'espace du monde, sans tenir compte de
la zone de découpage. Le motif de tramage du rectangle est défini par une matrice de tramage dont le format dépend du mode vidéo utilisé.

FG_ELLIPSE dessine une ellipse non remplie dans l'espace de l'écran.  L'ellipse est
centrée sur la position du curseur graphique, et sa taille est déterminée par les longueurs spécifiées des demi-axes.

FG_ELLIPSEF dessine une ellipse remplie dans l'espace de l'écran.  L'ellipse est
centrée sur la position du curseur graphique, et sa taille est déterminée par les longueurs spécifiées des demi-axes.

FG_ELLIPSEW dessine une ellipse non remplie dans l'espace mondial.  L'ellipse est
centrée sur la position du curseur graphique, et sa taille est déterminée par les longueurs spécifiées des demi-axes.

FG_ELLIPSFW dessine une ellipse remplie dans l'espace mondial.  L'ellipse est
centrée sur la position du curseur graphique, et sa taille est déterminée par les longueurs spécifiées des demi-axes.

FG_ERASE efface l'écran dans le texte ou les modes graphiques.

FG_FILLPAGE remplit l'écran avec la couleur actuelle dans le texte ou
les modes graphiques

FG_FLOOD remplit une région fermée arbitraire avec la valeur de couleur actuelle,
en ce qui concerne les limites d'écrêtage. La région est définie en spécifiant un point de l'espace de l'écran dans son intérieur.

FG_FLOODW remplit une région arbitraire fermée avec la valeur de couleur actuelle,
en ce qui concerne les limites d'écrêtage. La région est définie en spécifiant un point de l'espace mondial dans son intérieur.

FG_GETCLIP renvoie les limites d'écrêtage de courant, tel que défini dans le plus
appel récent à fg_setclip.

FG_GETPIXEL renvoie la valeur de la couleur d'un pixel spécifié.

FG_GETXBOX retourne la largeur en pixels pour les bords gauche et droit de
rectangles creux dessinés avec des routines d'affichage de la boîte de Fastgraph.

FG_GETXPOS retourne l'espace x écran de coordonnées du curseur graphique
position.

FG_GETYBOX retourne la largeur en pixels pour les bords supérieur et inférieur de
rectangles creux dessinés avec des routines d'affichage de la boîte de Fastgraph.

FG_GETYPOS renvoie l'espace de l'écran coordonnée y du curseur graphique
position.

FG_INSIDE détermine si le point spécifié est à l'intérieur convexe donnée
polygone.

FG_MOVE établit la position du curseur graphique à un écran absolu
point de l'espace.

FG_MOVEREL établit la position du curseur graphique à un espace d'écran
point par rapport à la position actuelle.

FG_MOVERW établit la position du curseur graphique à un point de l'espace mondial
par rapport à la position actuelle.

FG_MOVEW établit la position du curseur graphique à un monde absolu
point de l'espace.

FG_PAINT remplit une région arbitraire fermée avec la valeur de couleur actuelle,
sans respect des limites d'écrêtage. La région est définie en spécifiant un point de l'espace de l'écran dans son intérieur. Guide de l'utilisateur 124 Fastgraph

FG_PAINTW remplit une région arbitraire fermée avec la valeur de couleur actuelle,
sans respect des limites d'écrêtage. La région est définie en spécifiant un point de l'espace mondial dans son intérieur.

FG_POINT dessine un point (qui est, affiche un pixel) dans l'espace de l'écran.

FG_POINTW dessine un point dans l'espace mondial.

FG_POINTX dessine un point en mode "ou exclusif" dans l'espace de l'écran.

FG_POINTXW dessine un point en mode "ou exclusif" dans l'espace mondial.

FG_POLYEDGE définit si oui ou non comprend fg_polyfill tous les pixels situés
sur les bords droit et inférieur d'un polygone lors de l'élaboration des polygones convexes remplis.

FG_POLYFILL dessine un polygone convexe rempli dans l'espace de l'écran.  Le polygone est
fermé si nécessaire. Par défaut, les pixels se trouvant sur les bords droit et inférieur du polygone ne sont pas inclus lors de l'élaboration du polygone. Ce comportement peut être modifié avec fg_polyedge.

FG_POLYGON dessine un polygone vide dans l'espace de l'écran, en utilisant deux
coordonner des réseaux pour définir les sommets du polygone. Le polygone est fermé si nécessaire.

FG_POLYGONW dessine un polygone dans l'espace non rempli de monde.  Il est le même que
fg_polygon, à l'exception de la coordination des tableaux contiennent des valeurs spatiales du monde.

FG_POLYLINE dessine un polygone vide dans l'espace de l'écran, en utilisant un seul
coordonner ensemble pour définir les sommets du polygone. Le polygone est fermé si nécessaire.

FG_POLYOFF définit l'espace de l'écran de décalage appliqué à chaque sommet pour
polygones dessinés avec fg_polyfill ou fg_polyline.

FG_RECT dessine un (rempli) rectangle solide dans l'espace de l'écran ou de caractère
l'espace, sans tenir compte de la zone de découpage.

FG_RECTW dessine un (rempli) rectangle solide dans l'espace du monde, sans égard
à la zone de découpage.

FG_SETCLIP définit la zone de découpage dans l'espace de l'écran.  La coupure
la région est une zone rectangulaire à l'extérieur de laquelle certains graphiques sont supprimés.

FG_SETCLIPW définit la zone de découpage dans l'espace mondial.


==Affichage des caractères Routines==

Une partie importante de tout programme est la capacité d'afficher du texte ou
d'autres caractères à l'écran. Fastgraph prend en charge deux jeux de caractères: le caractère matériel ou BIOS fixés disponibles avec chaque mode vidéo et caractère propre logiciel de Fastgraph défini pour les modes graphiques vidéo. Fastgraph / Light ne supporte pas le jeu de caractères du logiciel.

Nous commencerons ce chapitre par un examen de l'espace de caractère, puis
discuter des détails au sujet des caractères matériels et logiciels. A la fin du chapitre, nous allons expliquer brièvement comment implémenter des caractères bitmap dans un programme. Pour simplifier les choses, les exemples de programmes présentés dans ce chapitre sont des exemples spécifiques au mode, et aucun test est effectué pour vérifier si le mode vidéo est disponible sur le système de l'utilisateur.


===Espace de caractères===

Le système de coordonnées utilisé pour afficher des caractères matériels est appelé
espace de caractère. Il est le seul système de coordonnées disponibles dans les modes vidéo de texte, mais il est un système complémentaire de coordonnées que vous pouvez utiliser soit avec l'espace de l'écran ou de l'espace mondial dans les modes graphiques vidéo. un espace de caractère peut être considéré comme une grille de rangées et de colonnes, chaque cellule de la grille de maintien d'un caractère. Chaque cellule est identifiée par ses propres coordonnées (ligne, colonne) entiers. Les lignes et les colonnes sont numérotées à partir de zéro; l'origine est toujours le coin supérieur gauche de l'écran. Par exemple, dans le 80-colonne en mode vidéo 25-ligne, la (ligne, colonne) les coordonnées de l'écran coins sont présentés dans le schéma suivant.


  (0,0) (0,79)


  (24,0) (24,79)


Le numéro par défaut de lignes et de colonnes dépend du mode vidéo, comme indiqué dans le tableau suivant. Pour les modes graphiques, le tableau comprend également la largeur par défaut et la hauteur en pixels d'une cellule de caractère.

  Mode de Nombre de Nombre de Char.  Carboniser.
  Colonnes Nombre de lignes Widthheight

  0 40 25
                             1 40 25
                             2 80 25
                             3 80 25
                             4 40 25 8 8
                             5 40 25 8 8
                             6 80 25 8 8
                             7 80 25
                             9 40 25 8 8
                            11 80 25 9 14
                            12 40 25 8 8
  13 40 25 8 8
                            14 80 25 8 8
                            15 80 25 8 14
                            16 80 25 8 14
                            17 80 30 8 16
                            18 80 30 8 16
                            19 40 25 8 8
                            20 40 25 8 8
                            21 40 50 8 8
                            22 40 30 8 8
                            23 40 60 8 8
                            24 80 25 8 16
                            25 80 30 8 16
                            26 100 37 8 16
                            27 128 48 8 16
                            28 100 37 8 16
                            29 128 48 8 16


===Hardware caractères===

caractères matériels sont disponibles dans tous les modes vidéo pris en charge.  Comme
expliqué dans le chapitre 5, les caractères en mode texte ont un attribut d'affichage qui définit leur couleur de premier plan, leur couleur de fond, et si elles clignotent ou non. caractères en mode graphique apparaissent dans une seule couleur, tel que déterminé par l'indice de couleur actuelle. Chapitre 5 a également expliqué comment fg_setattr et fg_setcolor les routines de Fastgraph définissent l'attribut ou de l'indice de couleur dans lequel les caractères matériels suivants apparaissent.

Il est évidemment important de définir la couleur ou de l'attribut pour le matériel
caractères, mais il est tout aussi important de définir leur emplacement sur l'écran. Fastgraph dessine des caractères matériels à la position définie par le curseur de texte. Comme le curseur graphique, le curseur de texte ne sont pas un curseur dans le vrai sens, mais est tout simplement une paire d'espace de caractères (ligne, colonne) coordonne avec une signification particulière. La routine fg_setmode définit la position du curseur de texte sur les coordonnées spatiales de caractères (0,0), qui est bien sûr le coin supérieur gauche de la écran.2

La fg_locate routine Fastgraph modifie la position du curseur de texte.  Il a
deux arguments entiers qui spécifient la (ligne, colonne) espace de caractère coordonnées de la nouvelle position. Les valeurs de ligne doit être comprise entre 0 et un de moins que le nombre de lignes de caractères disponibles. Les valeurs de la colonne doit être comprise entre 0 et un de moins que le nombre de colonnes de caractères disponibles.

La routine fg_text est basique routine d'affichage de caractères de Fastgraph.  Il
affiche une chaîne de caractères de matériel, à partir de la position du curseur de texte, en utilisant l'attribut de couleur en cours (pour les modes de texte) ou indice de couleur (pour les modes graphiques). Si la chaîne atteint la dernière colonne dans une ligne, fg_text va envelopper la chaîne à la première colonne de la ligne suivante. En outre, fg_text laisse le curseur d'une colonne à droite du dernier caractère affiché (ou la première colonne de la ligne suivante si le dernier caractère apparaît ____________________

(2) En réalité, il y a huit curseurs de texte, une pour chaque page vidéo.  le
routine fg_setmode initialise chaque position du curseur de texte à (0,0). Le chapitre suivant décrit plus en détail. Guide de l'utilisateur 128 Fastgraph
à la fin d'une rangée). Cette fonctionnalité permet aux appels successifs à fg_text pour afficher les chaînes adjacentes. Le premier argument de la routine fg_text est une chaîne de caractères de longueur arbitraire, et le second argument est une valeur entière qui spécifie le nombre de caractères à afficher à partir de cette chaîne.

Exemple 7-1 illustre l'utilisation de fg_locate et fg_text dans le 80x25
mode texte de couleur (mode 3). Après avoir établi le mode vidéo et en faisant le curseur du BIOS invisible, le programme affiche quatre cordes avec des attributs différents. Les attributs sont sélectionnés en utilisant fg_setattr, et les cordes sont affichées par fg_text. La première chaîne apparaît en jaune (attributs 14,0,0) dans le coin supérieur gauche de l'écran; fg_locate est pas nécessaire parce que (0,0) est la position du curseur de texte par défaut établi par fg_setmode. La deuxième chaîne apparaît en vert clair (10,0,0) un espace vers la droite de la première chaîne. Sa position repose sur le fait fg_text laisse le curseur de texte placé un espace vers la droite du dernier caractère affiché (après le "w" de "jaune" dans ce cas). L'espace de premier plan dans «vert» laisse un espace entre les première et deuxième chaînes. De même, la troisième chaîne apparaît en clignotant rouge (12,0,1) un espace vers la droite de la deuxième chaîne.

Le programme utilise ensuite fg_locate pour déplacer le curseur de texte à la partie inférieure gauche
coin de l'écran et affiche le "Appuyez sur une touche" chaîne. Cette chaîne est affichée avec une avant-plan rouge clair sur un fond gris (12,7,0). Les espaces supplémentaires autour de la chaîne prolongent la couleur de fond d'une position de caractère à gauche et à droite et font la chaîne plus attrayant visuellement. Enfin, une fois que vous appuyez sur une touche, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

  Exemple 7-1.

  #include <fastgraf.h>
                      void main (void);

  void main ()
                      {
                         int old_mode;

  fg_initpm ();
                         fg_getmode old_mode = ();
                         fg_setmode (3);
                         fg_cursor (0);

  fg_setattr (14,0,0);
                         fg_text ( "jaune", 6);

  fg_setattr (10,0,0);
                         fg_text ( "vert", 6);

  fg_setattr (12,0,1);
                         fg_text ( "clignotant", 9);

  fg_setattr (12,7,0);
                         fg_locate (24,0);
                         fg_text ( «Appuyez sur une touche.", 16);
                         fg_waitkey (); 
                                  Chapitre 7: Affichage des caractères Routines 129


  fg_setmode (old_mode);
                         fg_reset ();
                      }


La routine fg_where récupère la position du curseur de texte dans ses deux
arguments entiers. Cette routine n'est pas utilisé aussi souvent que fg_locate et fg_text parce que plus souvent qu'autrement, votre programme sera connaître la position du curseur de texte implicitement, ou vous saurez à l'avance les endroits où le texte sera affiché. La routine fg_where prend deux arguments entiers passés par référence, et ces deux arguments reçoivent respectivement la position de la ligne et de la colonne actuelle du curseur de texte.

Exemple 7-2 produit les mêmes résultats que l'exemple 7-1, mais il le fait d'une
peu différemment. Il utilise sa propre routine, put_string, pour afficher une chaîne à une ligne et la colonne spécifiée.La routine de put_string appelle simplement fg_locate pour établir la position du curseur de texte et appelle fg_text pour afficher la chaîne alors. Notez l'utilisation de la fonction de la bibliothèque C strlen pour déterminer la longueur de chaîne passée à fg_text. Exemple 7-2 fg_where utilise également pour récupérer les nouvelles positions du texte du curseur, qui sont ensuite transmis à put_string.

 Exemple 7-2.

 #include <fastgraf.h>
                    #include <string.h>
                   void main (void);
                   put_string void (char *, int, int);

 void main ()
                    {
                      int old_mode;
                      int ligne, colonne;

 fg_initpm ();
                      fg_getmode old_mode = ();
                      fg_setmode (3);
                      fg_cursor (0);

 fg_setattr (14,0,0);
                      put_string ( "jaune", 0,0);

 fg_setattr (10,0,0);
                      fg_where (et rangée, et colonne);
                      put_string ( «vert», ligne, colonne + 1);

 fg_setattr (12,0,1);
                      fg_where (et rangée, et colonne);
                      put_string ( "clignotant", ligne, colonne + 1);

 fg_setattr (12,7,0);
                      put_string ( «Appuyez sur une touche.", 24,0);
                      fg_waitkey ();

 fg_setmode (old_mode);
                      fg_reset (); 

  }

 put_string void (string, ligne, colonne)
                   * String char;
                   int ligne, colonne;
                    {
                      fg_locate (ligne, colonne);
                      fg_text (string, strlen (string));
                    }
Parfois, vous voudrez peut-être changer l'attribut d'affichage du texte existant,
tels que lors de la création d'une ombre sur les bords d'une fenêtre pop-up. La fg_chgattr routine Fastgraph remplit cette fonction. Il applique l'attribut d'affichage de texte actuel (tel que défini dans l'appel le plus récent à fg_setattr ou fg_setcolor) à un certain nombre de caractères, à partir de la position du curseur de texte. Il laisse le curseur de texte d'une colonne à droite du dernier caractère modifié (ou la première colonne de la ligne suivante si le dernier caractère est à la fin d'une rangée). L'argument de la routine fg_chgattr spécifie le nombre de caractères à changer. Cette routine n'a pas d'effet dans les modes graphiques vidéo.

La fg_chgtext routine Fastgraph effectue quelque peu la fonction inverse
de fg_chgattr. Il affiche un nouveau texte, mais utilise les attributs d'affichage déjà affectés aux cellules de caractère où le texte apparaîtra. La routine de fg_chgtext prend les deux mêmes arguments que fg_text, affiche les caractères à partir de la position du curseur de texte, et laisse le curseur d'une colonne à droite du dernier caractère affiché. Comme fg_chgattr, fg_chgtext n'a pas d'effet dans les modes graphiques vidéo.

Exemple 7-3 illustre les fg_chgattr et fg_chgtext routines. Il fonctionne
dans le 80 colonnes en mode texte de couleur (mode 3), mais si nous changeons l'argument fg_setmode elle aussi irait dans le mode texte monochrome (mode 7). Le programme affiche d'abord le mot «bonjour» dans le coin supérieur gauche de l'écran, en utilisant un premier plan gris et attribut de fond noir. Après avoir attendu pendant une séquence de touches, le programme appelle fg_chgattr pour rendre le mot «bonjour» apparaît en vidéo inverse (qui est, un premier plan noir et gris attribut de fond). Après une deuxième séquence de touches, le programme fg_chgtext utilise pour changer le "h" de "bonjour" en majuscules. Suite à cela, le programme revient à DOS.

 Exemple 7-3.

 #include <fastgraf.h>
                         void main (void);

 void main ()
                          {
                            int old_mode;

 fg_initpm ();
                            fg_getmode old_mode = ();
                            fg_setmode (3);
                            fg_cursor (0);

 fg_setattr (7,0,0);
                            fg_text ( "bonjour", 5); 
                                 Chapitre 7: Affichage des caractères Routines 131


 fg_waitkey ();

 fg_locate (0,0);
                            fg_setattr (0,7,0);
                            fg_chgattr (5);
                            fg_waitkey ();

 fg_locate (0,0);
                            fg_chgtext ( "H", 1);
                            fg_waitkey ();

 fg_setmode (old_mode);
                            fg_reset ();
                          }


Vous pouvez également récupérer le caractère ou attribut stocké dans un spécifique
cellule de caractère. La fg_getchar routine Fastgraph récupère les valeurs de caractères, tandis que fg_getattr récupère les attributs de caractère. Les deux routines ont deux arguments entiers qui spécifient la (ligne, colonne) coordonnées de la cellule de caractère d'intérêt. Exemple 7-4 utilise fg_getchar et fg_getattr à lire le caractère et l'attribut stocké à la ligne 24, la colonne 0. Juste avant la sortie du programme, il affiche ces valeurs.

 Exemple 7-4.

 #include <fastgraf.h>
                      #include <stdio.h>
                     void main (void);

 void main ()
                      {
                        int attr, la valeur;
                        int old_mode;

 fg_initpm ();
                        fg_getmode old_mode = ();
                        fg_setmode (3);
                        fg_cursor (0);

 fg_setattr (9,7,0);
                        fg_locate (24,0);
                        fg_text ( "Test", 4);
                        value = fg_getchar (24,0);
                        attr = fg_getattr (24,0);
                        fg_waitkey ();

 fg_setmode (old_mode);
                        fg_reset ();
                        printf ( "% c% 2.2X \ n", la valeur, attr);
                      }


Si vous avez besoin de récupérer les caractères et les attributs d'un rectangle
domaine, il est plus efficace d'utiliser la routine de fg_getimage (décrit dans le chapitre 10) que d'appeler fg_getchar et fg_getattr à plusieurs reprises. Guide de l'utilisateur 132 Fastgraph


Affichage des caractères matériels en graphiques modes vidéo est différent de
faire en mode texte. Comme mode texte, nous pouvons toujours utiliser fg_text pour afficher les chaînes dans l'espace de caractère, ce qui bien sûr limite les endroits où les chaînes peuvent apparaître. modes graphiques offrent la possibilité d'afficher les chaînes par rapport à un pixel, et non pas seulement des cellules de caractères. Le fg_print et routines fg_justify sont prévus à cet effet. Pour comparer les deux méthodes d'affichage des chaînes dans les modes graphiques, commençons par un exemple de le faire avec fg_text.

Exemple 7-5 est similaire à l'exemple 7-1, mais il fonctionne dans le EGA amélioré
mode graphique (mode 16), au lieu d'un mode texte. Dans les modes graphiques, fg_cursor n'a aucun effet, donc nous avons omis à partir du programme. En outre, les caractères ne peuvent pas être affichés avec un attribut clignotant, donc nous avons omis les caractères clignotantes (on pourrait simuler clignoter par répétitivement afficher et de les effacer, mais cela dépasse le cadre de cet exemple). Parce que les caractères en mode graphique ont seulement une couleur de premier plan, nous avons eu pour simuler le fond gris de la «Appuyez sur une touche" chaîne en dessinant d'abord un rectangle où cette chaîne apparaît. Les différences entre les exemples 7-5 et 7-1 attente pour tout mode graphique vidéo, et pas seulement le mode 16.

 Exemple 7-5.

 #include <fastgraf.h>
                     void main (void);

 void main ()
                      {
                        int old_mode;

 fg_initpm ();
                        fg_getmode old_mode = ();
                        fg_setmode (16);

 fg_setcolor (14);
                        fg_text ( "jaune", 6);

 fg_setcolor (10);
                        fg_text ( "vert", 6);

 fg_setcolor (7);
                        fg_rect (0127336349);
                        fg_setcolor (12);
                        fg_locate (24,0);
                        fg_text ( «Appuyez sur une touche.", 16);
                        fg_waitkey ();

 fg_setmode (old_mode);
                        fg_reset ();
                      }


Maintenant, nous allons montrer comment afficher les graphiques des chaînes de mode en utilisant le plus
espace écran flexible système de coordonnées. La routine est identique à celui fg_print fg_text, mais il affiche une chaîne par rapport à la position du curseur graphique (qui est, dans l'espace de l'écran), plutôt que la position de l'espace de caractère établi avec fg_locate. Par défaut, fg_print affiche des chaînes de sorte que leur

 Chapitre 7: Affichage des caractères Routines 133


coin inférieur gauche est à la position du curseur graphique. La routine fg_justify vous permet de modifier cette justification par défaut. Ses deux paramètres, et xjust yjust, contrôlent le positionnement de la chaîne autour de la position actuelle de graphiques, tels que résumés dans le tableau suivant:

 la valeur de la valeur de la verticale horizontale
                 xjust justification justification yjust

 -1 -1 Inférieur gauche
                  -1 0 centre gauche
                  -1 1 en haut à gauche
                   0 -1 centre inférieur
                   Centre 0 0 centre
                   0 1 centre supérieur
                   1 -1 en bas à droite
                   1 0 centre-droit
                   1 1 en haut à droite

Toutes les autres valeurs de justification produisent des résultats indéfinis. Dans le contexte de la justification verticale, des moyens de justification inférieure du fond de chaque caractère sera à la position graphique y actuelle. justification supérieure signifie que le haut de chaque personnage sera à la position graphique y, tandis que la justification du centre signifie caractères seront centrés sur la situation graphique y. Les paramètres de justification par défaut (établies par fg_setmode) sont xjust = -1 et yjust = -1, et vous pouvez récupérer les paramètres de justification en cours avec les fonctions de fg_getxjust et fg_getyjust de Fastgraph. Comme fg_text, fg_print laisse le curseur graphique positionné juste au-delà du coin inférieur droit du dernier caractère affiché.

Ni fg_print ni fg_text effectue écrêtage. Il peut y avoir des moments,
cependant, lors de l'affichage des chaînes écrêtés est souhaitable, par exemple lors de l'affichage du texte dans une fenêtre fixe. Lorsque l'écrêtage est nécessaire, utiliser fg_printc ou fg_textc pour afficher des chaînes. Ces deux routines sont identiques en tous points à fg_print et fg_text, mais ils ne présentent pas de caractères se trouvant en dehors de la zone de découpage établi par fg_setclip ou fg_setclipw. En outre, si une partie d'un personnage est en dehors de la zone de découpage, fg_printc et fg_textc affichage seulement qu'une partie du personnage qui se situe dans la zone de découpage. Parce que l'écrêtage est uniquement pris en charge dans les modes graphiques vidéo, fg_textc est équivalente à fg_text lorsqu'il est utilisé en mode texte vidéo.

Exemple 7-6 illustre l'utilisation de fg_print et fg_justify pour afficher
texte justifié dans le mode graphique 640x480 16 couleurs VGA (mode 18). La première série d'appels à fg_move, fg_justify et fg_print afficher la chaîne "Fastgraph" justifié à gauche, centré, et justifié à droite contre la rangée supérieure de l'écran. La deuxième série de ces appels affiche également la chaîne dans ces positions, mais chacun est centré verticalement dans le milieu de l'écran. La dernière série affiche les cordes contre la rangée du bas de l'écran. Les neuf appels à fg_justify dans l'exemple 7-6 représentent tous les paramètres possibles de justification pour les chaînes affichées avec fg_print.

 Exemple 7-6.

 #include <fastgraf.h>
                         void main (void);

 void main ()   


  {
                            int old_mode;

 fg_initpm ();
                            fg_getmode old_mode = ();
                            fg_setmode (18);
                            fg_setcolor (9);
                            fg_fillpage ();
                            fg_setcolor (14);

 fg_move (0,0);
                            fg_justify (-1,1);
                            fg_print ( «Fastgraph», 9);
                            fg_move (320,0);
                            fg_justify (0,1);
                            fg_print ( «Fastgraph», 9);
                            fg_move (639,0);
                            fg_justify (1,1);
                            fg_print ( «Fastgraph», 9);

 fg_move (0240);
                            fg_justify (-1,0);
                            fg_print ( «Fastgraph», 9);
                            fg_move (320,240);
                            fg_justify (0,0);
                            fg_print ( «Fastgraph», 9);
                            fg_move (639,240);
                            fg_justify (1,0);
                            fg_print ( «Fastgraph», 9);

 fg_move (0479);
                            fg_justify (-1, -1);
                            fg_print ( «Fastgraph», 9);
                            fg_move (320,479);
                            fg_justify (0, -1);
                            fg_print ( «Fastgraph», 9);
                            fg_move (639,479);
                            fg_justify (1, -1);
                            fg_print ( «Fastgraph», 9);
                            fg_waitkey ();

 fg_setmode (old_mode);
                            fg_reset ();
                          }


Exemple 7-7 montre un effet secondaire qui se produit lors de l'affichage
caractères dans les modes graphiques. Cet exemple utilise le mode graphique MCGA (mode 19) et affiche les deux chaînes de caractères dans le même emplacement. Si nous devions le faire en mode texte, la première chaîne disparaîtrait une fois nous avons affiché la deuxième chaîne (en supposant que la deuxième chaîne est pas plus courte que la première). Dans les modes graphiques, cependant, les parties de la première chaîne de caractères ne sont pas couverts par des caractères de la deuxième chaîne sont encore visibles. La raison pour laquelle cela peut ne pas être clair au début, mais rappelez-vous quand nous affichons des caractères dans les modes graphiques, nous ne sommes pas vraiment affichons des caractères, mais simplement une représentation de pixels des caractères. Fastgraph n'a aucun moyen de distinguer cette
pixels de tous les autres pixels, peu importe ce que la routine que nous utilisons pour l'affichage de la chaîne.

 Exemple 7-7.

 #include <fastgraf.h>
                         void main (void);

 void main ()
                          {
                            int old_mode;

 fg_initpm ();
                            fg_getmode old_mode = ();
                            fg_setmode (19);

 fg_setcolor (14);
                            fg_text ( "jaune", 6);
                            fg_locate (0,0);
                            fg_setcolor (10);
                            fg_text ( "vert", 6);
                            fg_waitkey ();

 fg_setmode (old_mode);
                            fg_reset ();
                          }

Pour éviter ce problème, la procédure recommandée pour l'affichage
caractères dans les modes graphiques est d'abord effacer la zone où le texte apparaîtra. La meilleure façon de le faire est d'utiliser fg_rect pour dessiner un rectangle dans la couleur de fond. Dans l'exemple 7-7, nous pourrions le faire en insérant les déclarations


 fg_setcolor (0);
                             fg_rect (0,47,0,7);


immédiatement avant l'appel à fg_locate. Les paramètres passés à la routine de fg_rect représentent la région 48 de 8 pixel qui correspond aux premières cellules à six caractères de la ligne 0 dans les modes les graphiques 320x200.


===Hauteur des caractères===

En VGA et SVGA graphiques modes (modes 17 à 29), il est possible de changer
la hauteur des caractères affichée avec fg_print, fg_printc, fg_text et fg_textc. Par défaut, les caractères sont 16 pixels de haut dans les modes les graphiques VGA et SVGA (17, 18, 24 à 29) et 8 pixels de haut dans les modes graphiques MCGA et XVGA (19 à 23). La routine de fg_fontsize vous permet d'afficher les caractères du 8x8 du BIOS, 8x14 ou 8x16 polices dans l'un de ces modes. Son seul paramètre spécifie la hauteur de caractère en pixels; il doit être 8, 14 ou 16. Si la hauteur de caractère est une autre valeur ou si fg_fontsize est utilisé dans un mode vidéo numérotée 16 ou moins (qui est, dans un mode non VGA), rien ne se passe. Guide de l'utilisateur 136 Fastgraph

Lorsque nous changeons la hauteur de caractère avec fg_fontsize, le nombre de texte
lignes sur l'écran change en conséquence. Le tableau suivant indique le nombre de lignes de texte disponibles dans chaque mode vidéo pris en charge lorsque vous utilisez les différentes tailles de caractères. Les valeurs en gras représentent la taille de caractères par défaut et le nombre de lignes pour ce mode vidéo.

 Mode Nombre de lignes avec
                               Nombre 8x8 8x14 8x16

 17 60 34 30
                                 18 60 34 30
                                 19 25 14 12
                                 20 25 14 12
                                 21 50 28 25
                                 22 30 17 15
                                 23 60 34 30
                                 24 50 28 25
                                 25 60 34 30
                                 26 75 42 37
                                 27 96 54 48
                                 28 75 42 37
                                 29 96 54 48

Exemple 7-8 montre comment utiliser fg_fontsize pour activer le caractère 8x8
police dans le 640x480 mode graphique VGA 16-couleur (mode 18). Dans ce mode, les caractères sont normalement 16 pixels de haut, ce qui donne 30 lignes de caractères par écran. Lorsque nous utilisons la police de 8x8, ce qui augmente à 60 lignes parce que les personnages sont maintenant la moitié aussi grand qu'avant. Le programme d'exemple fg_text utilise pour afficher la chaîne "police 8x8 ROM" 60 fois, une fois dans chaque ligne.

 Exemple 7-8.

 #include <fastgraf.h>
                     void main (void);

 void main ()
                      {
                        int old_mode;
                        int rangée;

 fg_initpm ();
                        fg_getmode old_mode = ();
                        fg_setmode (18);

 fg_setcolor (9);
                        fg_fillpage ();
                        fg_setcolor (15);
                        fg_fontsize (8);

 pour (rang = 0; rangée <60; rangée ++) {
                           fg_locate (ligne, 34);
                           fg_text ( «ROM de polices 8x8", 12);
                            }
                        fg_waitkey ();

 fg_setmode (old_mode); 
                                 Chapitre 7: Affichage des caractères Routines 137


 fg_reset ();
                      }


===Routines de conversion===

Dans le chapitre 4, nous avons introduit les routines de Fastgraph pour convertir
coordonnées entre le caractère d'espace et de l'espace de l'écran. Dans cette section, nous passerons en revue ces routines et présentons un exemple qui utilise certains d'entre eux.

Les fg_xalpha et fg_yalpha routines convertissent les coordonnées de l'espace écran pour
espace de caractère. La routine de fg_xalpha convertit un espace de coordonnées x écran à la colonne d'espace de caractère qui contient les coordonnées. De même, fg_yalpha convertit un espace d'écran coordonnée y à l'espace rangée de caractères qui contient les coordonnées.

Les fg_xconvert et fg_yconvert routines convertissent espace de caractère
coordonnées à l'espace de l'écran. La routine de fg_xconvert convertit une colonne d'espace de caractère à l'espace de l'écran de coordonnées de son pixel gauche. De même, fg_yconvert convertit un espace rangée de caractères à l'espace de l'écran de coordonnées de son sommet (numéro le plus bas) pixel.

Exemple 05.07 a montré comment afficher des caractères dans un mode graphique.

Parce que les personnages ne sont pas une couleur de fond dans les modes graphiques, cet exemple utilisé fg_rect pour simuler une couleur de fond en dessinant un rectangle gris avant d'afficher le texte. Il était nécessaire de déterminer les coordonnées d'écran des cellules de caractères afin que nous puissions passer les paramètres corrects pour fg_rect. En utilisant fg_xconvert et fg_yconvert, nous pouvons laisser Fastgraph calculer les coordonnées nécessaires à l'écran. Cette méthode a l'avantage supplémentaire de travailler dans un mode graphique, tandis que les coordonnées transmises à fg_rect dans l'exemple 7-5 ne fonctionnerait correctement dans un mode graphique 640x350. Exemple 7-9 montre comment nous pourrions étendre exemple 7-5 en utilisant fg_xconvert et fg_yconvert.

 Exemple 7-9.

 #include <fastgraf.h>
                     void main (void);

 void main ()
                      {
                        int old_mode;
                        int minx, maxx, Miny, maxy;

 fg_initpm ();
                        fg_getmode fg_old_mode = ();
                        fg_setmode (16);

 fg_setcolor (14);
                        fg_text ( "jaune", 6);

 fg_setcolor (10);
                        fg_text ( "vert", 6);

 fg_setcolor (7);
                        minx = fg_xconvert (0); 

 maxx = fg_xconvert (16) - 1;
                        miny = fg_yconvert (24);
                        maxy = fg_yconvert (25) - 1;
                        fg_rect (minx, maxx, Miny, maxy);
                        fg_setcolor (12);
                        fg_locate (24,0);
                        fg_text ( «Appuyez sur une touche.", 16);
                        fg_waitkey ();

 fg_setmode (old_mode);
                        fg_reset ();
                      }


===logiciels caractères===

caractères de logiciels, également appelés caractères d'AVC ou de caractères vectoriels
dans d'autres documents, ne sont sont disponibles dans les modes graphiques vidéo. Contrairement aux caractères matériels de taille fixe, vous pouvez afficher les caractères de logiciels dans toutes les dimensions, à un angle quelconque, et à une position quelconque. En outre, les caractères de logiciels sont espacés proportionnellement. Cependant, les caractères de logiciels prennent plus de temps pour dessiner que des caractères matériels font.

Fastgraph comprend deux polices de caractères du logiciel, appelé la police primaire
et la police de remplacement. La police primaire contient des lettres majuscules et minuscules, des nombres, la ponctuation et la plupart des autres caractères ASCII imprimables. La police alternative contient majuscules et minuscules lettres grecques et d'autres symboles mathématiques et scientifiques.

La routine Fastgraph fg_swchar affiche une chaîne de caractères de logiciels
dans l'index de couleur courante (tel que défini par l'appel le plus récent à fg_setcolor). La chaîne peut contenir tous les caractères de la police primaire, la police de remplacement, ou les deux. Vous pouvez afficher les caractères justifiés à gauche, centré ou justifié à droite par rapport à la position du curseur graphique. Tout comme fg_text met à jour la position du curseur de texte, fg_swchar définit la position graphique du curseur juste à droite du dernier caractère dessiné. Les caractères sont coupées en fonction de la zone de découpage de courant. En plus des caractères, la chaîne passée à fg_swchar peuvent également contenir des opérateurs pour la commutation des polices, soulignant, subscripting, ou en exposant caractères. Parce que fg_swchar utilise en interne les coordonnées spatiales du monde, vous devez appeler la routine de fg_initw à un certain point dans votre programme avant le premier appel à fg_swchar. Vous devez également créer un espace de système de coordonnées avec la routine de fg_setworld.

La routine de fg_swchar a trois arguments. Le premier argument est le
chaîne de caractères à afficher. Le second argument est une valeur entière qui spécifie le nombre de caractères dans la chaîne, y compris les caractères utilisés comme opérateurs spéciaux. Le troisième argument est une valeur entière qui détermine la position de la chaîne par rapport à la position du curseur graphique. Si cette valeur est négative, le coin en bas à gauche du premier caractère sera à la position du curseur graphique. Si elle est positive, le coin inférieur droit du dernier caractère sera à la position du curseur graphique. Si elle est nulle, la chaîne sera centrée horizontalement à la position du curseur graphique.

La taille des caractères du logiciel est déterminée par les valeurs passées à
fg_setsize, fg_setsizew et fg_setratio. La routine fg_setsize a un seul argument entier qui définit la hauteur des caractères de logiciels dans les unités spatiales de l'écran, tandis que fg_setsizew a un seul argument flottant point qui définit la hauteur dans les unités spatiales du monde. Si aucune de ces routines est appelé, Fastgraph utilisera sa hauteur de caractères par défaut d'une unité mondiale de l'espace. La routine de fg_setratio a un seul argument à virgule flottante qui définit le rapport d'aspect pour les personnages de logiciels. Le rapport d'aspect est le rapport de la largeur à la hauteur de caractère du caractère. Par exemple, un rapport d'aspect de 2,0 signifie que les caractères sont deux fois plus larges que hautes. Si fg_setratio est pas appelée, Fastgraph utilise son rapport d'aspect par défaut de 1.

Exemple 7-10 affiche tous les caractères dans les deux polices de caractères de logiciels.

Le programme utilise le mode EGA graphique amélioré (mode 16), mais il pourrait fonctionner dans un mode graphique en changeant l'argument fg_setmode. Après avoir établi le mode vidéo, le programme appelle fg_initw pour initialiser les paramètres de l'espace mondial de Fastgraph; cela est nécessaire puisque les logiciels routines de dessin de caractères utilisent en interne les coordonnées spatiales du monde. La déclaration suivante est un appel à fg_setworld qui établit un espace de système de coordonnées avec 0,01 monde unités d'espace par pixel. Suite à cela est un appel à fg_setsizew qui définit la hauteur de caractère 0,21 unités spatiales du monde, ou 21 pixels. Notez que nous aurions pu plutôt utilisé fg_setsize ici avec un argument entier de 21.

La prochaine partie du programme dessine les caractères de la police primaire sur
la moitié supérieure de l'écran. Après avoir fait cela, le programme dessine les polices de caractères de substitution sur la moitié inférieure. Dans chaque cas, il le fait avec fg_swchar. Par défaut, la chaîne passée à fg_swchar va produire des caractères de la police primaire. Cependant, vous pouvez insérer un caractère de retour de barre oblique (\) dans la chaîne pour basculer entre les deux polices. Ne pas oublier C et C ++ appliquer une signification particulière pour le caractère de retour de barre dans les chaînes, vous devez donc utiliser deux barres obliques inverses consécutives pour insérer une seule barre oblique inverse dans la chaîne.

 Exemple 7-10.

 #include <fastgraf.h>
            void main (void);

 void main ()
             {
               int old_mode;

 fg_initpm ();
               fg_getmode old_mode = ();
               fg_setmode (16);
               fg_initw ();
               fg_setworld (0.0,6.39,0.0,3.49);
               fg_setsizew (0,21);

 fg_setcolor (15);
               fg_locate (0,26);
               fg_text ( "caractères de logiciels - police 1", 28);

 fg_setcolor (10);
               fg_movew (0.0,3.1);
               fg_swchar ( "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 26, -1);
               fg_movew (0.0,2.8); 

 fg_swchar ( "abcdefghijklmnopqrstuvwxyz", 26, -1);
               fg_movew (0.0,2.5);
               fg_swchar ( "0123456789", 10, -1);
               fg_movew (0.0,2.2);
               fg_swchar ( "! \" # $% & '() * +, - / :; <=> [] ^ `{|} ~", 29, -1.?);

 fg_setcolor (15);
               fg_locate (12,26);
               fg_text ( "caractères de logiciels - police 2", 28);

 fg_setcolor (10);
               fg_movew (0.0,1.4);
               fg_swchar ( "\\ ABCDEFGHIJKLMNOPRSTUWXYZ", 25, -1);
               fg_movew (0.0,1.1);
               fg_swchar ( "\\ abcdefghijklmnoprstuwxyz", 25, -1);
               fg_movew (0.0,0.4);
               fg_swchar ( "\\ 012345678 # $% & () * + / <=> [] {}?", 27, -1);
               fg_waitkey ();

 fg_setmode (old_mode);
               fg_reset ();
             }


Si vous comparez les chaînes de police primaires avec les chaînes de police de remplacement, vous verrez la police alternative contient moins de caractères. Par exemple, les lettres Q et V (soit majuscules ou minuscules) ont aucun caractère correspondant dans la police alternative. Vous pourriez avoir également remarqué la police primaire ne supporte pas l'ensemble de caractères ASCII imprimable. Tout caractère dans une chaîne passée à fg_swchar qui n'a pas un caractère correspondant dans la police courante affiche un caractère blanc.

En plus de l'opérateur de changement de police (le caractère de retour de barre oblique),
fg_swchar reconnaît trois autres opérateurs. L'opérateur superscript est une barre oblique inverse suivie d'un caret (\ ^). Il provoque le caractère suivant à apparaître comme un exposant. De même, l'opérateur d'indexation est une barre oblique inverse suivie d'un cas v inférieur (\ v); il provoque le caractère suivant à apparaître comme un indice. La taille des caractères en exposant et en indice est une moitié de la hauteur des autres caractères. L'opérateur de soulignement est le caractère de soulignement (_). Il provoque tous les caractères suivants dans la chaîne à être soulignés jusqu'à ce qu'un autre caractère de soulignement est trouvé, ou jusqu'à la fin de la chaîne. Lors de l'utilisation de ces opérateurs, assurez-vous de les inclure dans le cadre du compte de longueur de chaîne passée à fg_swchar.

Exemple 7-11 illustre l'utilisation de la sélection de la police, exposant,
indice, et de souligner les opérateurs avec fg_swchar. Encore une fois, parce que le caractère de retour de barre a une signification particulière en C et C ++, il faut utiliser deux barres obliques arrière consécutives pour représenter une seule barre oblique inverse dans la chaîne. Le programme affiche quatre cordes:

 cos2 + sin2 = 1
                                      H2O
                                    U232
                           Un mot est souligné. 

Le symbole de thêta dans la première chaîne est produite par l'affichage du caractère "h" dans la police de remplacement. Notez un autre opérateur de sélection de police (\) apparaît immédiatement après le "h" pour revenir à la police primaire. La première chaîne comprend également les opérateurs en exposant (\ ^) pour afficher les exposants dans l'équation. La deuxième chaîne comprend un caractère indicé unique, tandis que la troisième chaîne montre comment afficher trois caractères indicés consécutifs. Enfin, la quatrième chaîne montre comment souligner les caractères.

Notez par exemple 7-11 utilise également fg_setratio. Les trois premières cordes sont
dessiné avec un rapport d'aspect de 2, ce qui en fait deux fois plus larges que hautes. La quatrième corde est tirée avec un rapport d'aspect de 1 (le rapport d'aspect par défaut pour les caractères Fastgraph logiciels), de sorte que la hauteur des caractères est la même que la largeur de caractère. En outre, les chaînes sont centrées au lieu de justifiés à gauche comme dans l'exemple précédent.

 Exemple 7-11.

 #include <fastgraf.h>
            void main (void);

 void main ()
             {
               int old_mode;

 fg_initpm ();
               fg_getmode old_mode = ();
               fg_setmode (16);
               fg_setcolor (10);
               fg_initw ();
               fg_setworld (0.0,6.39,0.0,3.49);
               fg_setratio (2.0);
               fg_setsizew (0,21);

 fg_movew (3.2,3.0);
               fg_swchar ( "cos \\ ^ 2 \\ h \\ + sin \\ ^ 2 \\ h \\ = 1", 25,0);

 fg_movew (3.2,2.0);
               fg_swchar ( "H \\ V2O U \\ v2 \\ v3 \\ v2", 18,0);

 fg_movew (3.2,1.0);
               fg_setratio (1,0);
               fg_swchar ( "One _word_ est souligné.", 25,0);
               fg_waitkey ();

 fg_setmode (old_mode);
               fg_reset ();
             }


La routine fg_setangle définit l'angle de rotation à laquelle le logiciel
caractères sont affichés. Son seul argument est une valeur en virgule flottante spécifiant l'angle, mesuré en degrés dans le sens antihoraire à partir de l'axe x positif. Si un programme dessine les personnages de logiciels avant d'appeler fg_setangle, Fastgraph utilisera son angle par défaut de zéro degré (qui est, les caractères seront orientés horizontalement). Guide de l'utilisateur 142 Fastgraph


Dans la plupart des programmes, la police de remplacement est pas nécessaire. Toutefois, si vous utilisez
la routine fg_swchar, Fastgraph comprendra les définitions de ces caractères dans le segment de données de votre programme. Pour éviter de gaspiller cet espace, Fastgraph comprend la routine de fg_swtext. La routine de fg_swtext est identique fg_swchar, sauf qu'il ne comprend pas la police de remplacement. Comme l'opérateur de sélection de police ne s'applique pas lorsque vous utilisez fg_swtext, la routine ignore tout simplement. Vous ne devez utiliser fg_swtext si ne pas utiliser fg_swchar. Si vous utilisez les deux routines, votre programme ne fonctionne toujours correctement, mais son segment de données contiendra une copie supplémentaire des définitions de polices primaires.

Exemple 7-12 illustre l'utilisation de fg_setangle et fg_swtext.  le
programme dessine une série de chaînes de la forme "degrés" nnn, où nnn est un multiple de 15, rayonnant à partir du centre de l'écran. Chaque chaîne apparaît à l'angle spécifié. Par exemple, la chaîne "15 degrés" est tiré à un angle de 15 degrés.

 Exemple 7-12.

 #include <fastgraf.h>
                #include <stdio.h>
               void main (void);

 void main ()
                {
                  chaîne char [24];
                  angle int;
                  int old_mode;

 fg_initpm ();
                  fg_getmode old_mode = ();
                  fg_setmode (16);
                  fg_setcolor (10);
                  fg_initw ();
                  fg_setworld (0.0,6.39,0.0,3.49);
                  fg_setsizew (0,21);

 pour (angle = 0; angle <360; angle + = 15) {
                     fg_movew (3.2,1.75);
                     fg_setangle ((double) angle);
                     sprintf (string, "% 3d" degrés, angle);
                     fg_swtext (string, 16, -1);
                      }
                  fg_waitkey ();

 fg_setmode (old_mode);
                  fg_reset ();
                }


La routine finale concernant les personnages de logiciels est fg_swlength, qui
retourne la longueur d'une chaîne de caractères spécifiée de logiciels dans les unités spatiales du monde. La longueur est retourné comme variable la valeur de fonction de point de la routine. La routine de fg_swlength a deux arguments - une chaîne de caractères de logiciels, et une valeur d'entier spécifiant le nombre de caractères dans la chaîne. Comme fg_swchar et fg_swtext, le nombre inclut les caractères spéciaux de l'opérateur.

Exemple 7-13 montre une utilisation typique de la routine de fg_swlength.  le
programme affiche la chaîne "bonjour là." en vert clair sur un fond gris au milieu de l'écran. Comme dans nos exemples de caractères de logiciels précédents, le programme utilise le mode 16 et effectue les initialisations nécessaires pour utiliser des caractères de logiciels en premier. À la suite de cela, le programme fg_swlength utilise pour calculer la longueur de monde unités spatiales de la chaîne. Notez que nous avons ajouté des caractères blancs à chaque extrémité de la chaîne passée à fg_swlength; ce qui augmente la longueur de la chaîne réelle et donnera effectivement le rectangle gris une frontière étendue sur ses côtés gauche et droit. La longueur de la chaîne renvoyée par fg_swlength est multiplié par 0,5, ce qui donne la distance par rapport au centre de l'écran de chaque côté du rectangle. Le programme utilise ensuite cette valeur pour calculer le minimum et le maximum x coordonnées transmises à fg_rectw. Après avoir dessiné le rectangle gris, le programme fg_swtext utilise pour dessiner la chaîne de caractères de logiciels dans le milieu de l'écran. Il attend ensuite une touche avant de restaurer les attributs d'origine en mode vidéo et d'écran et de revenir à DOS.

 Exemple 7-13.

 #include <fastgraf.h>
              void main (void);

 void main ()
               {
                 int old_mode;
                 deux demi;

 fg_initpm ();
                 fg_getmode old_mode = ();
                 fg_setmode (16);
                 fg_initw ();
                 fg_setworld (0.0,6.39,0.0,3.49);
                 fg_setsizew (0,21);

 fg_setcolor (7);
                 moitié = fg_swlength ( «Bonjour»., 14) * 0,5;
                 fg_rectw (3,2-moitié, 3,2 + moitié, 1.6,1.9);

 fg_setcolor (10);
                 fg_movew (3.2,1.65);
                 fg_swtext ( «Bonjour»., 12,0);
                 fg_waitkey ();

 fg_setmode (old_mode);
                 fg_reset ();
               }


Personnages bitmap

caractères bitmap combinent les propriétés du matériel et des logiciels
personnages.Comme les caractères matériels, ils sont d'une taille fixe, mais ils sont presque toujours plus attrayant. Parce qu'ils ne sont pas évolutifs, ils font 144 Guide de l'utilisateur Fastgraph
pas besoin d'arithmétique en virgule flottante, et donc ils sont beaucoup plus rapides que les caractères de logiciels.

Fastgraph ne fait aucune disposition spéciale pour les caractères bitmap parce qu'il
les traite comme si elles étaient une autre image bitmap. Par exemple, pour utiliser un cinq-pixel par pixel cinq police bitmap, vous pouvez construire des caractères comme montré ici, puis stocker ces représentations dans un tableau d'image.

 * * * * * * * * *
                         * * * * *
                       * * * * * * * * * *
                       * * * * *
                       * * * * * * * * * *

La routine d'affichage d'image fg_drawmap et fg_drwimage, discuté dans le chapitre 10, pourraient alors être utilisés pour afficher des caractères spécifiques de la matrice d'image. En outre, les Fastgraph / Fonts add-on produit simplifie grandement l'ajout du support de police bitmap aux applications Fastgraph.


===Résumé de l'affichage de caractères Routines===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_CHGATTR applique l'attribut d'affichage de texte en cours à un nombre donné
de caractères démarrant à la position du curseur de texte. Cette routine laisse le curseur de texte d'une colonne à droite du dernier caractère modifié (ou la première colonne de la ligne suivante si le dernier caractère est à la fin d'une rangée). Elle n'a aucun effet dans les modes graphiques vidéo.

FG_CHGTEXT affiche une chaîne de caractères de matériel, à partir du texte
la position du curseur, en utilisant les attributs d'affichage de texte existants. Cette routine laisse le curseur de texte d'une colonne à droite du dernier caractère affiché (ou la première colonne de la ligne suivante si le dernier caractère est à la fin d'une rangée). Elle n'a aucun effet dans les modes graphiques vidéo.

FG_FONTSIZE permet au 8x8, 8x14, ou la police de caractères BIOS 8x16 ROM pour
chaînes affichées avec fg_print et fg_text. Cette routine n'a de sens que dans les modes VGA et SVGA graphiques vidéo.

FG_GETATTR renvoie l'attribut de caractère stockée à la valeur spécifiée 
position sur la page vidéo active. Elle n'a aucun effet dans les modes graphiques vidéo.

FG_GETCHAR renvoie la valeur de caractères stockée à la position spécifiée
sur la page de la vidéo active. Elle n'a aucun effet dans les modes graphiques vidéo.

FG_GETXJUST renvoie la justification horizontale actuelle pour la mise en
chaînes affichées avec fg_print ou fg_printc.

FG_GETYJUST renvoie la justification verticale réglage actuel pour
chaînes affichées avec fg_print ou fg_printc.

FG_JUSTIFY définit les paramètres de justification horizontale et verticale pour
chaînes affichées avec fg_print ou fg_printc.

FG_LOCATE établit la position du curseur de texte pour la page de la vidéo active.

FG_PRINT affiche une chaîne de caractères de matériel, par rapport à la
graphiques position du curseur, en utilisant l'indice de couleur actuelle. Par défaut, les chaînes sont affichées de telle sorte que la rangée du bas du premier caractère est à la position graphique actuelle. Au retour, le curseur graphique est positionné juste à droite du dernier caractère affiché.

FG_PRINTC est une version de fg_print qui effectue écrêtage.

FG_SETANGLE définit l'angle ou l'orientation à laquelle les caractères de logiciels
sont affichés. L'angle est mesuré en degrés dans le sens antihoraire à partir de l'axe x positif.

FG_SETATTR établit le courant attribut d'affichage de texte en texte vidéo
modes. Cette routine n'a pas d'effet dans les modes graphiques vidéo.

FG_SETCOLOR établit l'indice de couleur actuelle (qui peut être un virtuel
indice de couleur dans les modes graphiques). Dans les modes de texte, la routine fg_setcolor propose une autre méthode pour établir l'attribut d'affichage de texte en cours.

FG_SETRATIO définit le rapport d'aspect pour les caractères de logiciel.  l'aspect
le rapport est le rapport de la largeur à la hauteur de caractère du caractère.

FG_SETSIZE définit la hauteur des caractères de logiciels dans l'espace de l'écran
unités.

FG_SETSIZEW définit la hauteur des caractères de logiciels dans l'espace mondial
unités.

FG_SWCHAR affiche une chaîne de caractères de logiciels utilisant le courant
indice de couleur. La chaîne peut être justifié à gauche, centré ou justifié à droite par rapport à la position du curseur graphique. La chaîne passée à fg_swchar peut contenir des opérateurs spéciaux qui permettent la commutation entre les polices, le soulignement, en exposant, ou subscripting. Cette routine n'a aucun effet en mode texte vidéo.

FG_SWLENGTH retourne la longueur en monde unités spatiales d'une chaîne de
caractères de logiciels.

FG_SWTEXT est une version réduite de la routine de fg_swchar.  Ce ne est pas
inclure les définitions de caractères de police de remplacement et nécessite donc moins de mémoire que fg_swchar.

FG_TEXT affiche une chaîne de caractères de matériel, à partir du texte
la position du curseur, en utilisant l'attribut de couleur en cours (pour les modes de texte) ou indice de couleur (pour les modes graphiques). Cette routine laisse le curseur de texte d'une colonne à droite du dernier caractère affiché (ou la première colonne de la ligne suivante si le dernier caractère est à la fin d'une rangée).

FG_TEXTC est une version de fg_text qui effectue écrêtage lorsqu'il est exécuté dans
graphiques modes vidéo. En mode texte, fg_textc équivaut à fg_text. Guide de l'utilisateur 146 Fastgraph

FG_WHERE récupère les numéros de ligne et de colonne du curseur de texte
position.

Coordonnées FG_XALPHA et FG_YALPHA convertir l'espace de l'écran à caractère
espace.

FG_XCONVERT et FG_YCONVERT convertir les coordonnées d'espace de caractères à l'écran
espace.


==Pages vidéo et le Guide virtuel Tampons==

La quantité de mémoire nécessaire pour stocker un plein écran d'information est
appelé une page vidéo (ou parfois tout simplement une page). Fastgraph offre une variété de types de pages, y compris les pages physiques, pages virtuelles, des pages étendues et pages logiques. En outre, les tampons virtuels vous permettent de définir des blocs arbitraires de la mémoire conventionnelle et les traiter comme si elles étaient de mémoire vidéo. Ce chapitre discutera pages vidéo et les tampons virtuels en détail, ainsi que les routines Fastgraph pour les gérer.


===Pages physiques et virtuelles Pages===

Pages qui utilisent la mémoire qui se trouve sur la carte vidéo sont appelés
pages physiques ou vraies pages. Le nombre de pages physiques disponibles dépend du mode vidéo et la quantité de mémoire résidente sur la carte vidéo de l'utilisateur. Tous les modes vidéo ont au moins une page physique. Dans certains modes vidéo, Fastgraph peut allouer disponible mémoire vive (RAM) et de traiter cette mémoire comme une page vidéo. Pages qui utilisent RAM standard dans ce sens sont appelés pages virtuelles. Du point de vue d'un programmeur, pages virtuelles sont essentiellement identiques aux pages physiques.

Le tableau suivant indique le nombre de pages physiques dans chaque vidéo
mode. Il indique également si oui ou non les modes vidéo spécifiques prennent en charge les pages virtuelles.

       Page Mode Taille physique virtuelle
       Description Numéro dans Bytes Pages Pages

       0 40 colonne texte de couleur 2000 8 no
       1 40 colonne texte de couleur 2000 8 no
       2 80 colonne texte de couleur 4000 4 pas
       3 80 colonne texte de couleur 4000 4 pas
       4 320x200x4 CGA graphiques 16.000 1 oui
       5 320x200x4 CGA graphiques 16.000 1 oui
       6 640x200x2 CGA graphiques 16.000 1 oui
       7 80 colonnes texte monochrome 4000 1 oui
       9 320x200x16 Tandy graphiques 32.000 1 oui
       11 720x348 Hercules graphiques 31,320 2 oui
       12 320x200 Hercules graphiques 31,320 2 oui
       13 320x200x16 graphiques EGA 32000 8 pas
       14 640x200x16 graphiques EGA 64.000 4 pas
       15 640x350 EGA mono graphiques 56.000 2 pas
       16 640x350x16 graphiques EGA 112.000 2 pas
       17 640x480x2 MCGA / VGA graphiques 38.400 1+ pas
       18 640x480x16 graphiques VGA 153,600 1+ pas
       19 320x200x256 MCGA graphiques 64.000 1 oui
       20 320x200x256 XVGA graphiques 64.000 4 pas
       21 320x400x256 XVGA graphiques 128.000 2 pas
       22 320x240x256 XVGA graphiques 76.800 3+ pas
       23 320x480x256 XVGA graphiques 153,600 1+ pas
       24 640x400x256 graphique SVGA 256.000 4 pas
       25 640x480x256 graphique SVGA 307.200 2 pas
       26 800x600x256 SVGA graphiques 480.000 2 pas
       27 1024x768x256 graphique SVGA 786.432 1+ pas
       28 800x600x16 graphique SVGA 240.000 4 pas
       29 1024x768x16 graphique SVGA 393,216 2 pas

Ce tableau suppose l'adaptateur vidéo a 256K de mémoire vidéo installée pour les modes EGA et VGA, et 1 Mo de mémoire vidéo pour les modes SVGA. Pour les cartes de mémoire vidéo moins, le nombre de pages physiques est réduit proportionnellement. En d'autres termes, un 64K EGA a deux pages vidéo disponibles au lieu de huit en mode 13. De même, un 512K SVGA a une page au lieu de deux dans les modes 25 et 26, et ne serait pas en charge le mode 27. Le tableau suivant résume le nombre des pages vidéo disponibles en modes graphiques SVGA pour les cartes vidéo avec 256K, 512K, 768K et 1 Mo de mémoire vidéo installés.

  Mode Nombre de pages avec ...
                      Résolution numéro 256K 512K 768K 1MB

  24 640x400x256 1 + 2 3 4
                        25 640x480x256 0 1+ 1+ 2
                        26 800x600x256 0 1+ 1+ 2
                        27 1024x768x256 0 0 1 1+
                        28 800x600x16 1+ 2 3 4
                        29 1024x768x16 0 1+ 1+ 2

Dans les deux tableaux précédents, notez que le nombre de pages physiques
certains modes vidéo est suivie par un symbole plus. Dans ces modes, il y a une page vidéo partielle supplémentaire disponible. Pour les modes 17, 18, et 23, il y a une page entière (page 0) plus une page partielle de 320 rangées de pixels (page 1). Pour le mode 22, il y a trois pages pleines physiques (numérotés de 0 à 2), plus une page partielle de 80 rangées de pixels (page 3). Pour le mode 27, il y a une page entière (page 0) plus une page partielle de 256 rangées de pixels (page 1) sur une carte 1MB SVGA. Vous pouvez utiliser en toute sécurité les pages partielles aussi longtemps que vous ne référencez pas de lignes de pixels au-delà de leur dernière ligne disponible. Cependant, vous ne pouvez pas faire une page vidéo partielle de la page visuelle.

Dans SVGA graphiques modes (modes 24 à 29), les pages vidéo doivent commencer à 256K
limites pour maintenir la compatibilité entre les différents chipsets SVGA. Il en résulte dans la mémoire vidéo non utilisé à la fin d'une page. Par exemple, les pages en mode 26 nécessitent 480.000 octets de mémoire vidéo. Sur une carte 1MB SVGA, les deux pages commenceront à 0 et 524.288 (512K). Ainsi, il y a 44,288 (524,288 moins 480,000) de mémoire vidéo utilisé octets à la fin de chaque page. Avec 800 pixels (et donc 800 octets) par ligne de l'écran, cela signifie que chaque page a un supplément de 55 rangées de pixels par page. La taille réelle de la page est donc 800x655, avec les 600 premières lignes affichées. De même, la taille de la page en mode 25 est 640x819, les 480 premières lignes affichées.
pages physiques sont numérotées à partir de zéro.  Par exemple, il y a quatre
pages vidéo physiques disponibles en mode 3, et ils sont numérotés de 0 à 3. Les pages virtuelles sont numérotées à 63 n, où n est le nombre de pages physiques dans ce mode. Par exemple, il y a deux pages physiques (numérotées de 0 et 1) et 62 pages virtuelles (numérotées 2 à 63) en mode 11. Remarque seuls modes 4 à 12 et le mode 19 offre des pages virtuelles, et la quantité de mémoire conventionnelle dans le mode de système limite généralement le nombre de pages virtuelles disponibles (ceci est particulièrement vrai en mode 19 en raison de la grande taille de la page). Guide de l'utilisateur 150 Fastgraph


===Pages ayant une signification particulière===

Il y a trois pages de vidéo qui ont une signification particulière à Fastgraph.  le
la page visuelle, comme on peut le deviner, est la page vidéo visible sur l'écran de l'utilisateur. La page active est la page de vidéo à laquelle Fastgraph écrit du texte ou des informations graphiques. La page cachée n'a de sens que pour quelques routines de Fastgraph et sera discuté spécifiquement dans le contexte de ces routines. Les fg_setmode ensembles de routine tous les trois de ces pages à la page 0, et il n'a pas d'importance si ces pages sont physiques ou virtuels.

L'une des caractéristiques les plus utiles de multiples pages de vidéo (soit physique
ou virtuel) est la capacité à construire une image de texte ou des graphiques hors de l'écran (qui est, sur une page vidéo en plus la page visuelle). Puis, une fois l'image est prête, nous pouvons soit le transférer à la page visuelle, ou faire la page sur laquelle l'image réside la page visuelle. Cette fonctionnalité est particulièrement utile dans l'animation, car il affiche une image instantanément au lieu de mettre à jour visiblement l'écran tout en produisant l'image.


===Quelques exemples simples===

Dans cette section, nous allons présenter six variantes d'un programme simple qui
utilise quatre pages vidéo. Le programme remplit chaque page de la vidéo avec un rectangle, puis affiche le texte contenant le numéro de page de la vidéo dans le centre de chaque page. Les deux premiers exemples exécuter en mode texte ou des graphiques vidéo spécifique et utilisent uniquement des pages physiques. Les deux exemples suivants fonctionnent également en mode texte ou des graphiques vidéo spécifique, mais ils utilisent aussi des pages virtuelles. Les deux derniers exemples sont plus généraux et courir dans plusieurs modes vidéo. Vous pouvez bien sûr écrire un programme qui fait essentiellement la même chose que les exemples de cette section sans utiliser plusieurs pages vidéo. Toutefois, pour utiliser l'affichage d'image et d'animation des routines de Fastgraph efficacement, vous devez d'abord comprendre le concept de pages vidéo.

Avant de poursuivre, nous devons introduire la Fastgraph routines fg_setpage
et fg_setvpage. La routine fg_setpage définit la page vidéo active, ce qui provoque Fastgraph pour mettre du texte suivant et sortie graphique sur cette page. La routine fg_setvpage définit la page vidéo visuel affiché sur l'écran. Les deux routines prennent un seul argument entier entre 0 et 63 qui spécifie le numéro de la page vidéo. Il n'a pas d'importance si la page vidéo de référence est une page physique ou une page virtuelle. Comme mentionné précédemment, fg_setmode rend la page 0 la page de la vidéo active et visuelle.

Exemple 8-1 utilise quatre pages vidéo (numérotés de 0 à 3) dans les 40 colonnes
mode texte couleur (mode 1). Le programme des premiers appels fg_testmode pour vérifier la disponibilité du mode vidéo demandé lorsqu'il est utilisé avec quatre pages vidéo. Si elle est disponible, le programme appelle fg_setmode pour établir que le mode vidéo. La première boucle remplit chacune des quatre pages avec différents rectangles de couleurs et affiche le texte noir contenant le numéro de page de la vidéo dans le centre de chaque page. Elle le fait en appelant fg_setpage pour définir la page de vidéo active, fg_setcolor et fg_rect pour dessiner les rectangles colorés, et enfin fg_setattr, fg_locate et fg_text pour afficher le texte. Le programme doit appeler fg_locate intérieur de la boucle parce que chaque page vidéo a sa propre position du curseur de texte. La deuxième boucle fait successivement chaque page vidéo la page visuelle; la page reste affichée jusqu'à ce que vous appuyez sur une touche. après
afficher toutes les quatre pages vidéo, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

  Exemple 8-1.

  #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
                void main (void);

  PAGES #define 4

  void main ()
                {
                   Couleur int;
                   int old_mode;
                   Page int;
                   chaîne char [8];

  fg_initpm ();
                   if (fg_testmode (1, PAGES) == 0) {
                      printf ( "Ce programme nécessite la couleur. \ n");
                      sortie (1);
                      }

  fg_getmode old_mode = ();
                   fg_setmode (1);

  pour (page = 0; Page <PAGES; Page ++) {
                      fg_setpage (page);
                      color = Page + 1;
                      fg_setcolor (couleur);
                      fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                      fg_setattr (0, couleur, 0);
                      fg_locate (12,17);
                      sprintf (string, "la page% d", la page);
                      fg_text (string, 6);
                      }

  pour (page = 0; Page <PAGES; Page ++) {
                      fg_setvpage (page);
                      fg_waitkey ();
                      }

  fg_setmode (old_mode);
                   fg_reset ();
                }

Exemple 8-2 est similaire à l'exemple 8-1, mais il utilise le EGA 320x200
mode graphique (mode 13), au lieu d'un mode texte. Notez que la seule différence réelle entre ce programme et la version en mode texte est l'utilisation de fg_setcolor au lieu de fg_setattr pour faire apparaître le texte en noir.

  Exemple 8-2. 

  #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
                void main (void);

  PAGES #define 4

  void main ()
                {
                   Couleur int;
                   int old_mode;
                   Page int;
                   chaîne char [8];

  fg_initpm ();
                   if (fg_testmode (13, PAGES) == 0) {
                      printf ( "Ce programme nécessite une");
                      ( "en mode 320 x 200 graphiques EGA \ n".) printf;
                      sortie (1);
                      }

  fg_getmode old_mode = ();
                   fg_setmode (13);

  pour (page = 0; Page <PAGES; Page ++) {
                      fg_setpage (page);
                      color = Page + 1;
                      fg_setcolor (couleur);
                      fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                      fg_setcolor (0);
                      fg_locate (12,17);
                      sprintf (string, "la page% d", la page);
                      fg_text (string, 6);
                      }

  pour (page = 0; Page <PAGES; Page ++) {
                      fg_setvpage (page);
                      fg_waitkey ();
                      }

  fg_setmode (old_mode);
                   fg_reset ();
                }

pages vidéo virtuels sont créés avec la routine de fg_allocate de Fastgraph.  le
réserves de routine fg_allocate mémoire conventionnelle à accès aléatoire (RAM) qui Fastgraph traite alors comme une page vidéo. La quantité de mémoire requise dépend du mode vidéo actuel. La routine fg_allocate prend un seul argument entier qui spécifie le numéro de la page par laquelle la page virtuelle sera référencé. Cette valeur doit être comprise entre 1 et 63.

Si vous essayez de créer une page virtuelle avec un numéro de page déjà attribué
à une page physique, fg_allocate ne fait rien. Par exemple, dans les graphiques modes Hercules (modes 11 et 12), il y a deux pages physiques numérotées 0 et 1. pages virtuelles dans les modes les graphiques Hercules doit donc avoir des numéros de page
entre 2 et 63. Si vous dites fg_allocate pour créer une page virtuelle Hercules numérotés de 0 ou 1, il ne fait rien parce que ces pages vidéo existent sous forme de pages physiques. De même, si vous utilisez fg_allocate dans un mode vidéo qui ne supporte pas les pages vidéo virtuelles, il retourne simplement sans rien faire.

Un problème possible avec fg_allocate peut se produire quand il n'y a pas assez
mémoire disponible pour la création d'une page virtuelle en mode vidéo en cours. La routine renvoie fg_allocate que sa valeur de fonction d'un code d'état indiquant si oui ou non il a réussi. Les valeurs possibles du code d'état sont les suivants:
sens de la valeur

*  0 page virtuelle créée
*  1 numéro de page spécifié est une page physique
*  7 page virtuelle créé, mais les blocs de contrôle de mémoire ont été détruits
*  8 mémoire insuffisante pour créer la page virtuelle

Si vous utilisez fg_testmode ou fg_bestmode pour vérifier si le nombre requis de pages vidéo sont disponibles lorsque vous utilisez le mode vidéo sur demande, vous ne devriez pas avoir besoin de surveiller le code de statut retourné par fg_allocate.

La routine de fg_freepage libère la mémoire pour une page virtuelle créée
avec fg_allocate. Elle exige un seul argument entier qui identifie le numéro de page virtuelle pour libérer. Cette valeur doit être comprise entre 0 et 63. Si vous essayez de libérer une page vidéo physique, ou libérer une page virtuelle qui n'a jamais été créé, fg_freepage ne fait rien. Il est une bonne idée d'utiliser fg_freepage pour libérer toutes les pages vidéo virtuelles avant qu'un programme retourne le contrôle DOS, ou juste avant un programme sélectionne un nouveau mode vidéo.

Exemple 8-3 est également similaire à l'exemple 8-1, mais il utilise le monochrome
en mode texte (mode 7). Parce que le mode texte monochrome ne dispose que d'une seule page vidéo physique, nous devons utiliser des pages vidéo virtuelles pour les numéros de page 1, 2 et 3. Notez comment fg_allocate et fg_freepage sont utilisés pour créer et libérer les pages vidéo virtuelles dans cet exemple.

  Exemple 8-3.

  #include <fastgraf.h>
             #include <stdio.h>
             #include <stdlib.h>
             void main (void);

  PAGES #define 4

  void main ()
             {
                int old_mode;
                Page int;
                chaîne char [8];

  fg_initpm ();
                if (fg_testmode (7, PAGES) == 0) {
                   printf ( "Ce programme nécessite monochrome. \ n");
                   sortie (1);
                   }

  fg_getmode old_mode = ();
                fg_setmode (7);
                fg_cursor (0);

  pour (page = 0; Page <PAGES; Page ++) {
                   fg_allocate (page);
                   fg_setpage (page);
                   fg_setcolor (7);
                   fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                   fg_setattr (0,7,0);
                   fg_locate (12,37);
                   sprintf (string, "la page% d", la page);
                   fg_text (string, 6);
                   }

  pour (page = 0; Page <PAGES; Page ++) {
                   fg_setvpage (page);
                   fg_waitkey ();
                   fg_freepage (page);
                   }

  fg_setmode (old_mode);
                fg_reset ();
             }


Exemple 8-4 est similaire à l'exemple 8-3, mais il utilise le Hercules norme
mode graphique (mode 11) au lieu du mode texte monochrome. Parce que les modes les graphiques Hercules ont deux pages vidéo physiques, nous devons utiliser des pages vidéo virtuelles pour les numéros de page 2 et 3. Notez la seule vraie différence entre ce programme et la version en mode texte est l'utilisation de fg_setcolor au lieu de fg_setattr pour faire apparaître le texte en noir.

  Exemple 8-4.

  #include <fastgraf.h>
               #include <stdio.h>
               #include <stdlib.h>
               void main (void);

  PAGES #define 4

  void main ()
               {
                  int old_mode;
                  Page int;
                  chaîne char [8];

  fg_initpm ();
                  if (fg_testmode (11, PAGES) == 0) {
                     printf ( "Ce programme nécessite Hercules");
                     printf ( "graphiques monochromes \ n.");
                     sortie (1);
                     }

  fg_getmode old_mode = (); 

  fg_setmode (11);

  pour (page = 0; Page <PAGES; Page ++) {
                     fg_allocate (page);
                     fg_setpage (page);
                     fg_setcolor (7);
                     fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                     fg_setcolor (0);
                     fg_locate (12,37);
                     sprintf (string, "la page% d", la page);
                     fg_text (string, 6);
                     }

  pour (page = 0; Page <PAGES; Page ++) {
                     fg_setvpage (page);
                     fg_waitkey ();
                     fg_freepage (page);
                     }

  fg_setmode (old_mode);
                  fg_reset ();
               }


Exemple 8-5 est une version généralisée d'exemples 8-1 et 8-3 qui fonctionne dans
tout mode texte vidéo 80 colonnes. Afin de simplifier le programme, chaque page vidéo est remplie avec des rectangles de la même couleur. Notez que fg_allocate et fg_freepage sont utilisés pour gérer les pages vidéo virtuelles en cas fg_bestmode sélectionne le mode texte monochrome (mode 7). Si fg_bestmode sélectionne une des couleurs mode texte de 80 colonnes (qui ont quatre pages vidéo physiques), fg_allocate et fg_freepage vont tout simplement revenir sans rien faire.

  Exemple 8-5.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  PAGES #define 4

  void main ()
                 {
                    int old_mode, new_mode;
                    Page int;
                    chaîne char [8];

  fg_initpm ();
                    new_mode = fg_bestmode (80,25, PAGES);
                    if (new_mode <0) {
                       printf ( "Ce programme nécessite");
                       printf ( "un affichage de 80 colonnes. \ n");
                       sortie (1);
                       }

  fg_getmode old_mode = (); 

  fg_setmode (new_mode);
                    fg_cursor (0);

  pour (page = 0; Page <PAGES; Page ++) {
                       fg_allocate (page);
                       fg_setpage (page);
                       fg_setcolor (7);
                       fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                       fg_setattr (0,7,0);
                       fg_locate (12,37);
                       sprintf (string, "la page% d", la page);
                       fg_text (string, 6);
                       }

  pour (page = 0; Page <PAGES; Page ++) {
                       fg_setvpage (page);
                       fg_waitkey ();
                       fg_freepage (page);
                       }

  fg_setmode (old_mode);
                    fg_reset ();
                 }

Exemple 8-6 est une version généralisée d'exemples 8-2 et 8-4 qui fonctionne dans
tout mode vidéo 320x200 graphique. Afin de simplifier le programme, chaque page vidéo est remplie avec des rectangles de la même couleur. Comme dans l'exemple 8-5, fg_allocate et fg_freepage sont utilisés pour gérer les pages vidéo virtuelles en cas fg_bestmode sélectionne un mode vidéo avec moins de quatre pages vidéo physiques. Notez que la seule différence réelle entre ce programme et la version en mode texte est l'utilisation de fg_setcolor au lieu de fg_setattr pour faire apparaître le texte en noir.

  Exemple 8-6.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  PAGES #define 4

  void main ()
                 {
                    int old_mode, new_mode;
                    Page int;
                    chaîne char [8];

  fg_initpm ();
                    new_mode = fg_bestmode (320.200, PAGES);
                    if (new_mode <0) {
                       printf ( "Ce programme nécessite une");
                       ( "en mode 320 x 200 graphiques \ n".) printf;
                       sortie (1);
                       }

  fg_getmode old_mode = ();
                    fg_setmode (new_mode);

  pour (page = 0; Page <PAGES; Page ++) {
                       fg_allocate (page);
                       fg_setpage (page);
                       fg_setcolor (15);
                       fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                       fg_setcolor (0);
                       fg_locate (12,17);
                       sprintf (string, "la page% d", la page);
                       fg_text (string, 6);
                       }

  pour (page = 0; Page <PAGES; Page ++) {
                       fg_setvpage (page);
                       fg_waitkey ();
                       fg_freepage (page);
                       }

  fg_setmode (old_mode);
                    fg_reset ();
                 }


===Curseurs de texte===

Comme mentionné dans le chapitre précédent, Fastgraph dessine des caractères matériels
à la position définie par le curseur de texte. Comme le curseur graphique, le curseur de texte ne sont pas un curseur dans le vrai sens, mais est tout simplement une paire d'espace de caractères (ligne, colonne) coordonne avec une signification particulière. Les 8 premières pages vidéo (qui est, pages 0 à 7) ont chacune leur propre curseur de texte. Chaque groupe ultérieur de 8 pages vidéo (pages 8 à 15, pages 16 à 23, et ainsi de suite) partagent respectivement les mêmes positions texte du curseur que les 8 premières pages. Cela signifie fg_locate mettra à jour l'un des 8 curseurs de texte différents en fonction de la page vidéo active. De même, fg_where retourne la position du curseur de texte pour la page active. Les fg_setmode de routine tous les ensembles de positions de curseur 8 texte aux coordonnées spatiales de caractères (0,0).

Exemple 8-7 illustre l'utilisation de différents curseurs de texte dans un 80-
en mode texte, couleur de colonne (mode 3). Le programme affiche d'abord le texte "Page" à la page vidéo 0 (la page visible) et attend une touche. Il fait alors la page 1 de la page vidéo active, modifie l'emplacement du curseur de texte pour cette page, et affiche le texte «Page 1» à la page vidéo 1. Ensuite, il ajoute le caractère "0" au texte initialement affiché à la page 0. Notez que nous ne devons rétablir la position du curseur de texte pour la page 0, car il est affecté en changeant le curseur de texte pour la page 1. Après avoir attendu une autre touche, le programme fait Page vidéo 1 la page visuelle et attend encore un autre touches activées avant de retourner à DOS.

  Exemple 8-7.

  #include <fastgraf.h>
                          void main (void); 

  void main ()
                          {
                             int old_mode;

  fg_initpm ();
                             fg_getmode old_mode = ();
                             fg_setmode (3);
                             fg_cursor (0);
                             fg_setattr (10,0,0);

  fg_locate (1,0);
                             fg_text ( "Page", 5);
                             fg_waitkey ();

  fg_setpage (1);
                             fg_locate (23,0);
                             fg_text ( "Page 1", 6);

  fg_setpage (0);
                             fg_text ( "0", 1);
                             fg_waitkey ();

  fg_setvpage (1);
                             fg_waitkey ();

  fg_setmode (old_mode);
                             fg_reset ();
                          }


===Obtention vidéo Informations sur la page===

Fastgraph comporte deux routines, et fg_getpage fg_getvpage que,
retour respectivement le nombre actif ou visuelle Page vidéo. Chaque routine retourne la vidéo numéro de page en tant que valeur de la fonction, et ni routine nécessite aucun argument.

Lors de la création de pages virtuelles ou logiques, vous devez choisir un numéro de page
qui ne fait pas référence une page physique ou une page virtuelle ou logique précédemment créé. Alors qu'il est bien sûr possible de garder la trace des numéros de page seront disponibles dans un mode vidéo donné, la fonction de fg_findpage de Fastgraph peut rendre le travail plus facile. Elle retourne un numéro de page utilisé, que vous pouvez ensuite passer à l'une des routines d'allocation de pages virtuelles ou logiques de Fastgraph. S'il n'y a plus disponibles (soit les 64 entrées dans les tables de pages internes sont en cours d'utilisation), fg_findpage renvoie zéro.

La routine de fg_getaddr est parfois utile lors de l'utilisation des pages virtuelles.  Il
retours que sa valeur de la fonction d'adresse de segment (en mode réel) ou le sélecteur de segment (en mode protégé) pour le début de la page vidéo active. Il ne nécessite pas d'arguments. Bien que fg_getaddr est plus utile lors de l'utilisation des pages vidéo virtuelles, il fonctionne aussi bien avec des pages vidéo physiques.

Exemple 8-9 illustre l'utilisation de fg_getpage, fg_getvpage, fg_findpage,
et fg_getaddr dans le VGA standard / MCGA mode 256 couleurs graphiques (mode 19). Ce mode vidéo offre une seule page physique, de sorte que le programme utilise fg_findpage
de trouver un numéro de page utilisé (qui sera page 1 en mode 19), puis appelle fg_allocate pour créer une page vidéo virtuelle. Après la création de la page virtuelle, le programme rend la page vidéo active; Page 0 reste la page vidéo visuelle. La routine de fg_getpage retourne ensuite le numéro de page active, suivie d'un appel à fg_getvpage pour retourner le numéro de page visuelle (0). Ensuite, le programme fg_getaddr utilise pour retourner l'adresse de segment / sélecteur pour les deux pages vidéo. Enfin, il restaure les attributs d'origine en mode vidéo et écran, affiche les valeurs retournées, et retourne au DOS.

  Exemple 8-9.

  #include <fastgraf.h>
               #include <stdio.h>
               void main (void);

  void main ()
               {
                  int old_mode;
                  int active visuelle;
                  int page page0, page1;

  fg_initpm ();
                  fg_getmode old_mode = ();
                  fg_setmode (19);
                  page = fg_findpage ();
                  fg_allocate (page);
                  fg_setpage (page);

  active = fg_getpage ();
                  fg_getvpage visuel = ();

  fg_setpage (0);
                  page0 = fg_getaddr ();
                  fg_setpage (page);
                  page1 = fg_getaddr ();

  fg_freepage (page);
                  fg_setmode (old_mode);
                  fg_reset ();

  printf ( "la page active est% d \ n"., actif);
                  printf ( "la page visuelle est% d \ n"., visuel);
                  printf ( "Page 0 adresse% 4X \ n", page0);
                  printf ( "page adresse% d est 4X% \ n", page, page1);
               }


===Considérations pour les pages virtuelles===

Si vous utilisez Puissance C, tout compilateur BASIC pris en charge, Borland Pascal, ou
Turbo Pascal et le besoin de créer des pages virtuelles, vous devez réduire la taille du tas loin. Normalement, ces compilateurs allouer toute la mémoire restante pour le tas, ce qui signifie fg_allocate ne sera pas en mesure d'allouer de la mémoire pour la page virtuelle. Guide de l'utilisateur 160 Fastgraph


Dans les programmes de base, la fonction SETMEM réduit la taille du tas loin.

Les versions de base des exemples de programmes Fastgraph comprennent la déclaration

  SetMemStatus & = SETMEM (-n)

avant d'appeler FGallocate. Ceci réduit la taille du segment loin de n octets. Pour un mode vidéo donné, la diminution réelle nécessaire est le nombre de pages virtuelles, multiplié par la taille de page dans ce mode. Page tailles sont répertoriés au début de ce chapitre, ou vous pouvez utiliser fg_pagesize pour déterminer la taille de la page pour le mode vidéo actuel.

En Borland Pascal et Turbo Pascal, la directive du compilateur $ M définit la
taille de tas maximale en octets. Les versions Pascal des exemples de programmes Fastgraph comprennent la déclaration

  {$ M 16384,0,16384}

au début des exemples qui font appel fg_allocate. La troisième valeur dans cette liste définit la taille maximale du tas à 16K octets. Ceci est approprié pour la plupart des applications, mais si votre programme utilise les nouvelles procédures ou GetMem pour créer des variables dynamiques qui nécessitent plus d'espace de tas, vous aurez besoin d'augmenter la taille au-delà de 16K.

La taille bien tas pour les programmes d'alimentation C est défini au moment de la liaison.  Vous devez
remplacer la taille de segment par défaut en incluant l'option [,, 16K] sur la commande PCL lorsque vous liez un programme d'alimentation C qui utilise fg_allocate. La valeur 16K est adapté pour la plupart des applications, mais si votre programme appelle les fonctions farcalloc ou farmalloc (ou calloc ou des fonctions malloc lorsque vous utilisez le modèle de mémoire), vous devrez peut-être augmenter la taille bien au-delà de tas 16K.

Lorsque vous utilisez des pages virtuelles, vous devriez éviter d'utiliser le fg_setvpage
routine dans les sections du programme qui nécessitent des mises à jour d'écran rapides ou des séquences d'animation. En effet, le PC et PS / 2 BIOS vidéo ne sont capables d'afficher des pages physiques. Pour compenser cette restriction, Fastgraph échange le contenu d'une page physique à la page virtuelle demandée. En d'autres termes, si la page 1 est une page virtuelle et vous rendre la page visuelle, Fastgraph va échanger le contenu de la page 1 avec ce que la page était auparavant la page visuelle. Cela ne signifie pas les numéros de page du changement de Fastgraph parce Fastgraph maintient également une table interne contenant des adresses de pages vidéo et échange les deux entrées de table correspondantes. Comme précédemment, vous feriez page 1 de la page vidéo active si vous voulez écrire quelque chose à la page visuelle.

A propos de la seule autre problème potentiel lors de l'utilisation des pages virtuelles est ce que
qui se produit lorsque vous essayez d'écrire à une page vidéo inexistante (par exemple, si vous écrivez à la page vidéo virtuelle 1 avant de créer avec fg_allocate). Dans ce cas, Fastgraph redirige simplement la sortie vidéo à la page visuelle.


===Considérations pour Pages SuperVGA===

Si un programme en cours d'exécution en mode graphique SVGA retourne en mode texte lorsque
la page visuelle est pas la page 0, certains chipsets SVGA ont des problèmes la prochaine fois que vous essayez d'exécuter une application SVGA. Nous recommandons donc d'appeler fg_setvpage (0) juste avant de restaurer le mode vidéo d'origine si une application effectue un changement de page dans les modes graphiques SVGA. Par exemple:

  fg_getmode old_mode = ();
          fg_svgainit (0);
          fg_setmode (25);
                  .
                  .
                  .
          fg_setvpage (1);
                  .
                  .
                  .
          fg_setvpage (0);  / * Ajouter cette ligne pour être sûr * /
          fg_setmode (old_mode);

Quelques chipsets SVGA ne peuvent pas définir l'adresse de début d'affichage au-delà du 16-
capacité de bits fourni par le contrôleur CRT, rendant fg_setvpage sens. se référer au fichier READ.ME pour plus de détails.


===Pages logiques===

En plus des pages vidéo physiques et virtuels, Fastgraph offre une autre
classe de pages vidéo, appelé pages logiques. Vous pouvez créer des pages logiques dans un mode vidéo. Ils peuvent exister dans la mémoire conventionnelle, mémoire paginée (EMS), ou mémoire étendue (XMS). Cependant, ils ne sont pas aussi polyvalent que les pages physiques ou virtuels parce que les seules opérations que vous pouvez effectuer avec des pages logiques sont:

* Copiez toute une page virtuelle ou physique à une page logique
* Copiez toute une page logique à une page physique ou virtuel
* Copiez toute une page logique à une autre page logique

Trois routines Fastgraph - fg_alloccms, fg_allocems et fg_allocxms - créer des pages logiques dans la mémoire conventionnelle, mémoire étendue, et la mémoire étendue, respectivement. Les trois routines ont un seul argument entier qui spécifie le numéro de page par lequel la page logique sera référencé. Le numéro de page doit être comprise entre 1 et 63 et ne doit pas faire référence à une page physique ou virtuelle. Leur valeur de retour est 0 si la page logique est créé, et négatif autrement (voir les descriptions de ces routines dans le Manuel de référence Fastgraph pour une liste complète des valeurs de retour). Comme pages virtuelles, utilisez fg_freepage pour libérer une page logique.

Avant de pouvoir créer des pages logiques en mémoire étendue ou prolongée, vous
doit initialiser ces ressources pour une utilisation avec Fastgraph. Les fg_initems initialise routine mémoire paginée. Pour utiliser la mémoire paginée, vous devez avoir un gestionnaire de mémoire paginée (EMM) qui est conforme à l'étendue Lotus / Intel / Microsoft Spécification de la mémoire (LIM-EMS) version 3.2 ou ultérieure. Sur 80386 et 80486 systèmes, le pilote de périphérique EMM386.EXE fourni avec DOS 5.0 peut être utilisé pour traiter une partie ou l'ensemble de la mémoire étendue que la mémoire paginée. La routine de fg_initxms initialise la mémoire étendue pour une utilisation avec Fastgraph. Pour utiliser la mémoire étendue, vous devez avoir un pilote XMS conforme à la Lotus / Intel / Microsoft / AST eXtended Memory Specification version 2.0 ou ultérieure, tels que HIMEM.SYS. pilotes XMS nécessitent un système 80286, 80386 ou 80486. Les fg_initems et fg_initxms routines ont pas d'arguments et doivent être appelées après fg_setmode. Leur valeur de retour est 0 en cas de succès, et -1 si le conducteur et les ressources nécessaires ne sont pas présents. Guide de l'utilisateur 162 Fastgraph

En mode protégé, la distinction entre classique, élargi, et
mémoire étendue disparaît parce que DOS extenders essentiellement traiter toute la mémoire système comme mémoire conventionnelle. Pour cette raison, fg_initems et fg_initxms ne sont pas significatifs et donc toujours revenir -1 en mode protégé bibliothèques Fastgraph. Cela désactive efficacement les fg_allocems et fg_allocxms routines, vous devez donc créer des pages logiques avec fg_alloccms en mode protégé.

Exemple 8-10 illustre l'utilisation de pages logiques dans une couleur 320x200
le mode graphique. Le programme tente d'abord de créer une page logique dans la mémoire étendue en appelant fg_initxms et fg_allocxms. Si la création d'initialisation ou de la page échoue, il tente alors de créer la page en mémoire étendue avec fg_initems et fg_allocems. En cas d'échec, le programme appelle fg_alloccms pour essayer de créer la page en mémoire conventionnelle. Si elle ne peut pas créer la page logique du tout, le programme affiche un message d'erreur et sort.

Une fois la page logique est créé, par exemple 8-10 affiche le mot "test"
au milieu de la page visuelle (page 0) puis fg_copypage utilise pour transférer le contenu des pages visuelles à la page logique. Parce que ce programme fonctionne dans l'un de plusieurs modes graphiques différents, nous utilisons fg_findpage pour choisir le numéro de page logique. Après avoir attendu pendant une séquence de touches, le programme efface la page visuelle, attend une autre touche, et copie les pages de contenu logiques retour à la page visuelle. Il libère alors la page et les sorties logiques.

  Exemple 8-10.

  #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
              void main (void);

  void main ()
              {
                 int new_mode, old_mode;
                 int page statut;

  fg_initpm ();
                 new_mode = fg_bestmode (320,200,1);
                 if (new_mode <0 || new_mode == 12) {
                    printf ( "Ce programme nécessite une 320");
                    ( "le mode x 200 graphiques couleur \ n".) printf;
                    sortie (1);
                    }
                 fg_getmode old_mode = ();
                 fg_setmode (new_mode);

  page = fg_findpage ();
                 status = fg_initxms ();
                 if (état == 0) status = fg_allocxms (page);
                 si (état <0) {
                    status = fg_initems ();
                    if (état == 0) status = fg_allocems (page);
                    }
                 si (état <0) état = fg_alloccms (page);

  si (état <0) {
                             Chapitre 8: Pages vidéo et Virtual Tampons 163


  fg_setmode (old_mode);
                    fg_reset ();
                    printf ( "Impossible de créer la page logique. \ n");
                    sortie (1);
                    }

  fg_setcolor (7);
                 fg_rect (0,319,0,199);
                 fg_setcolor (9);
                 fg_locate (12,18);
                 fg_text ( "test", 4);
                 fg_waitkey ();

  fg_copypage (0, p);
                 fg_erase ();
                 fg_waitkey ();

  fg_copypage (page, 0);
                 fg_waitkey ();

  fg_freepage (page);
                 fg_setmode (old_mode);
                 fg_reset ();
              }

Comme mentionné précédemment, les seules fonctions que vous pouvez effectuer avec logique
pages sont la copie des pages physiques / virtuelles vers des pages logiques, pages logiques aux pages physiques / virtuels, ou la copie d'une page logique à un autre. La routine fg_copypage fournit la seule façon de le faire pour des pages logiques. Voir le chapitre 11 pour plus d'informations sur fg_copypage.


===Extended Pages Vidéo===

L'une des questions de support technique plus fréquentes que nous recevons est "I
?. Avoir un mégaoctet de mémoire sur ma carte vidéo, pourquoi ne puis-je utiliser seulement la première 256K "La réponse est simple: les modes du EGA standard et VGA graphiques ont aucun moyen de répondre à la mémoire vidéo au-delà de 256K Accès plus de mémoire nécessite le changement de banque SVGA. techniques. Ceci est analogue au fait que vous pourriez avoir quatre mégaoctets de RAM sur votre système, mais sans un gestionnaire EMS / XMS mémoire, une extension DOS, ou similaire, tout ce que la mémoire ne sera pas faire beaucoup de bien.

Malheureusement, tous les chipsets SVGA permettent la commutation de banque non-SVGA
modes vidéo. Pour ceux qui le font, cependant, Fastgraph comprend une fonctionnalité appelée pages vidéo étendues. pages étendues permettent d'accéder à toute la mémoire vidéo dans les modes 13 à 18 et les modes 20 à 23 au lieu de restreindre l'accès à la première 256K. Cela signifie, par exemple, qu'une carte 1MB permettra SVGA 32 pages physiques dans le mode 13 plutôt que sur les 8 pages habituelles. pages étendues sont disponibles avec les chipsets SVGA suivants:

* Ahead B
* Avance Logic série 2000
* ATI 28800 / mach32 / mach64
* Avance Logic série 2000
* NCR 77C22 / 77C32
* Oak OTI-067
* Oak OTI-077
* Oak OTI-087
* Paradise WD90C11 / WD90C30 / WD90C31 / WD90C33
* Tseng ET4000

Bien que les pages étendues sont utilisées dans les modes graphiques non-SVGA, la méthode
d'accès à la mémoire vidéo au-dessus de 256K est spécifique à chaque puce SVGA. Ainsi, vous devez initialiser le noyau SVGA de Fastgraph (avec fg_svgainit) avant de pouvoir utiliser les pages étendues. On n'a pas encore trouvé une application VESA qui prend en charge les pages étendues, vous aurez donc besoin d'initialiser le noyau SVGA pour un soutien spécifique le chipset.

Lors de l'écriture des applications qui utilisent des pages vidéo étendues, vous devez vous
que SVGA chipset de l'utilisateur prend en charge les pages étendues et qu'il ya suffisamment de mémoire vidéo pour le nombre de pages nécessaires. Tout d'abord, assurez-vous que fg_svgainit initialise avec succès le noyau SVGA. Si oui, vérifier le bit 2 de la valeur de retour de fg_svgastat pour voir si le chipset prend en charge les pages étendues. Enfin, utilisez fg_memory pour assurer que la mémoire vidéo suffisante est disponible pour le nombre de pages vidéo nécessaires.

Le tableau suivant indique le nombre de pages vidéo disponibles dans le
modes graphiques qui prennent en charge les pages étendues.

  Nombre de pages Avec
                              Mode de 256K 512K 1MB

  13 8 16 32
                               14 4 8 16
                               15 2 4 8
                               16 2 4 8
                               17 2 4 8
                               18 2 4 8
                               20 4 8 16
                               21 2 4 8
                               22 4 8 16
                               23 2 4 8

Notez que lorsque les pages étendues ne sont pas activés, le mode vidéo a le nombre de pages vidéo physiques figurant dans la colonne 256K.

Certains modes vidéo ne fournissent pas le nombre indiqué de pages vidéo complètes.

Par exemple, les modes 17 et 18 ont normalement deux pages vidéo - une complète 640x480 page (0) et une partielle 640x320 page (1). Pour les pages étendues, Fastgraph utilise une page système de numérotation qui maintient la cohérence avec sa numérotation de page standard. Autrement dit, lorsque les pages étendues sont disponibles et le mode 17 ou 18 est utilisé sur une carte vidéo de 1MB, les numéros de page vont de 0 à 7, avec les pages paires étant pleines pages et les pages impaires étant partielles 640x320 pages . De même, dans le mode de 22 pages 3, 7, 11 et 15 sont partielles (320x80); en mode 23 pages impaires sont partielles (320x320).

Lorsque vous utilisez de Fastgraph routines de transfert de bloc (le fg_copypage,
fg_restore, fg_save, fg_tcxfer et fg_transfer) avec des pages étendues, vous devez passer les numéros de source et de la page de destination pour fg_defpages. Cela est nécessaire parce que les deux pages peuvent résider dans différentes banques SVGA, et le changement de banque est pas effectuée dans le code non-SVGA de Fastgraph. La charge supplémentaire d'avoir les routines de transfert de bloc déterminer les numéros de banque auraient un impact sur la
bloquer les routines de transfert lorsque les pages étendues ne sont pas utilisés. La routine de fg_defpages détermine les numéros de banque SVGA dans laquelle les pages de source et de destination résident et permet aux banques correspondantes pour la lecture et l'écriture. Ces banques restent en vigueur jusqu'à ce que vous définissez de nouveaux avec fg_defpages ou fg_setpage, donc vous ne pouvez pas besoin d'appeler fg_defpages avant chaque appel à une routine de transfert de bloc. La routine de fg_defpages n'a aucun effet sauf si les pages étendues sont activées. Le tableau suivant indique les numéros de banque pour chaque page vidéo dans chaque mode graphique qui prend en charge les pages étendues.

  Banque 0 Banque 1 Banque 2 Banque 3
                           Mode de pages Pages Pages Pages

  13 0-7 8-15 16-23 24-31
                            14 0-3 4-7 8-11 12-15
                            15 0-1 2-3 4-5 6-7
                            16 0-1 2-3 4-5 6-7
                            17 0-1 2-3 4-5 6-7
                            18 0-1 2-3 4-5 6-7
                            20 0-3 4-7 8-11 12-15
                            21 0-1 2-3 4-5 6-7
                            22 0-3 4-7 8-11 12-15
                            23 0-1 2-3 4-5 6-7

Ensuite, nous allons présenter une séquence de code court qui appelle fg_defpages uniquement lorsque
nécessaire en mode 13, où chaque groupe de 8 pages réside dans sa propre banque de SVGA. fg_setmode appel permet la banque 0 pour la lecture et l'écriture, donc on n'a pas besoin d'appeler fg_defpages jusqu'à ce que nous référençons une page dans l'une des autres banques (qui est, une page numérotée 8 ou au-dessus).

  fg_svgainit (0);
     fg_setmode (13);  / * Permet la banque 0 pour la lecture et l'écriture * /
     fg_copypage (0,1);
     fg_copypage (0,2);
     fg_defpages (0,1);  / * Page 10 est dans la banque 1 * /
     fg_copypage (2,10);
     fg_defpages (1,1);  / * Page 15 est dans la banque 1 * /
     fg_copypage (10,15);
     fg_setpage (0);  / * Permet la banque 0 pour la lecture et l'écriture * /
     fg_erase ();
     fg_copypage (0,3);
     fg_defpages (1,0);  / * Page 15 est dans la banque 1 * /
     fg_copypage (15,4);

La plupart des pilotes de souris ne savent rien de changer de banque SVGA et non
modes vidéo standard (qui est pourquoi Fastgraph doit accrocher ses propres gestionnaires de contrôle du curseur de la souris dans le pilote de la souris dans les modes XVGA et SVGA). Comme Fastgraph repose sur le pilote de la souris pour le contrôle du curseur dans les modes 13 à 18, il est seulement possible d'afficher le curseur de la souris sur les pages vidéo dans la première banque de SVGA (banque 0) dans ces modes. Notez que cela ne vaut pas aux modes 20 à 23, où Fastgraph contrôle le curseur de la souris par le biais de son propre gestionnaire.

Certains chipsets SVGA ne réinitialisent pas la lecture et d'écriture des numéros de banque retour à
zéro lors de l'établissement d'un mode vidéo non-SVGA. Lorsqu'une opération de réglage du mode efface la mémoire vidéo, ces chipsets effacer la première page de la vidéo dans la dernière banque d'écriture sélectionnée. Alors que fg_setmode ne fixe les banques lire et écrire à zéro lorsque les pages étendues sont disponibles, il ne peut pas le faire avant le réglage du mode vidéo, Guide de l'utilisateur 166 Fastgraph
qui est ce qui serait normalement effacer l'écran. Cela peut entraîner des artefacts à la page 0 après avoir appelé fg_setmode. La meilleure façon de contourner ce problème est d'appeler fg_defpages (0,0) avant de restaurer le mode vidéo d'origine dans les programmes qui utilisent les pages étendues. Même cela, cependant, ne fait pas de mémoire vidéo clair après un jeu de mode lorsque vous utilisez les pages étendues avec certains chipsets SVGA. Nous recommandons donc d'appeler immédiatement fg_erase après la restauration du mode vidéo d'origine lors de l'utilisation des pages étendues.


===Vidéo page Redimensionnement===

Redimensionnement est le processus de modification des dimensions de la page vidéo.  C'est
disponible uniquement dans les modes natifs EGA graphiques (modes 13 à 16), les modes natifs graphiques VGA (17 et 18), les modes VGA étendus (20 à 23), et les modes SVGA (24 à 29). Redimensionnement ne change pas la résolution de l'écran, mais augmente plutôt la page vidéo taille de sorte qu'une partie de la page est visible. Pour l'instant, nous allons simplement présenter le redimensionnement avec un exemple simple, mais dans le chapitre 13, nous verrons sa puissance réelle lorsque nous effectuons un panoramique lisse.

La fg_resize routine Fastgraph modifie les dimensions de la page vidéo.

Ses deux arguments entiers définissent la largeur de la page et hauteur de page, à la fois en pixels. Exemple 11.08 fonctionne dans le mode graphique EGA 320x200 (mode 13). Après avoir établi le mode vidéo, il affiche le mot "resize" à partir de la colonne 38 de la ligne 0. Parce que les personnages vont au-delà de la dernière colonne de la ligne, ils enveloppent à la ligne suivante. Le programme continue l'affichage jusqu'à ce que vous appuyez sur une touche. Ensuite, il efface l'écran et fg_resize appelle à faire de la taille de la page 640x200 pixels. Encore une fois, le programme affiche le mot "resize" à partir de la colonne 38 de la ligne 0, mais cette fois il ne revient pas à la ligne suivante. En effet, le redimensionnement a doublé la largeur de la page, ce qui a augmenté le nombre de cellules de caractères par ligne de 40 à 80. Les caractères qui autrefois enveloppées à la ligne suivante continuent maintenant sur une partie hors de l'écran de la même ligne.

  Exemple 8-11.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  void main ()
                 {
                    int old_mode;

  fg_initpm ();
                    if (fg_testmode (13,1) == 0) {
                       printf ( "Ce programme nécessite une 320");
                       ( "le mode x 200 graphiques EGA \ n".) printf;
                       sortie (1);
                       }

  fg_getmode old_mode = ();
                    fg_setmode (13);

  fg_setcolor (9);
                    fg_locate (0,38);
                    fg_text ( "resize", 6); 
                             Chapitre 8: Pages vidéo et Virtual Tampons 167


  fg_waitkey ();

  fg_erase ();
                    fg_resize (640,200);
                    fg_setcolor (10);
                    fg_locate (0,38);
                    fg_text ( "resize", 6);
                    fg_waitkey ();

  fg_setmode (old_mode);
                    fg_reset ();
                 }


La taille d'une page vidéo est limitée seulement par la quantité de données vidéo
mémoire disponible et la capacité d'adressage du mode vidéo. L'augmentation de la taille de la page vidéo réduit le nombre de pages physiques disponibles proportionnellement. En mode 13, par exemple, en augmentant la taille de la page de 320x200 à 640x400 réduit le nombre de pages vidéo de 8 à 2. Lorsque vous appelez fg_resize, la page visuelle doit être la page 0. Si vous avez créé des pages vidéo logiques, vous devez les libérer avec fg_freepage avant d'appeler fg_resize, puis créer à nouveau par la suite. Si vous avez initialisé la souris (avec fg_mouseini), joysticks (avec fg_initjoy), la mémoire (avec fg_initems) élargie, ou de la mémoire (avec fg_initxms) prolongée, vous devez réinitialiser ces ressources après avoir appelé fg_resize. Dans les modes 13 à 18, la plupart des pilotes de souris attendent un fixe largeur de la page vidéo, de sorte que le curseur de la souris peut être déformé après le redimensionnement des pages vidéo dans ces modes. Lorsque vous appelez fg_resize, Fastgraph définit la zone de découpage à la nouvelle page limites. La fg_setmode routine rétablit les dimensions d'une page vidéo à la résolution d'écran par défaut pour le mode vidéo sélectionné. La routine de fg_resize n'a pas d'effet quand un tampon virtuel est actif.

Selon les dimensions passées à fg_resize, vous pouvez vous retrouver avec un

Page vidéo partielle. Encore une fois, supposons que nous utilisons le mode 13 et avons changé la taille de la page à 960x400 (ce qui est six fois la taille de page par défaut). Les pages originales de 0 à 5 représentent maintenant la page 0, et les pages originales 6 et 7 font maintenant la page 1. Cependant, il n'y a pas assez de mémoire vidéo à gauche sur la page 1 pour une pleine 960x400 page. Dans ce cas, le nombre de lignes de pixels disponibles à la page 1 serait tiers de la taille de la page complète à un, ou 133 lignes. En effet, le stockage total requis par les pages de l'original 6 et 7 est un tiers du total requis pour les pages de l'original 0 à 5.
pages vidéo étendues peuvent être redimensionnées dans les modes 13-18 et 20-23, mais le
pages résultantes ne doivent pas franchir les limites de la banque SVGA. En mode 20, par exemple, vous avez normalement quatre 320x200 pages dans chaque banque. Vous pouvez changer la taille de la page vidéo de 640x400, ayant ainsi quatre pages plus grandes, un dans chaque banque. On ne pouvait pas, cependant, redimensionner la mémoire vidéo à deux 640x800 pages, que chaque page serait étendre sur deux banques.

Préserver la vidéo Contenu de la page À travers les commutateurs de mode

Parfois, un programme graphique peut temporairement besoin de passer à une autre
mode vidéo. Un exemple de cela pourrait être une interface utilisateur (GUI) système de menuing graphique qui comprend "shell DOS" comme l'une de ses options. Lorsque l'utilisateur sélectionne cette option, le programme doit revenir à un mode texte vidéo pour le Guide de l'utilisateur 168 Fastgraph
utilisateur verra l'invite DOS familier lorsque le shell exécute. A la sortie du shell DOS, le programme revient à un mode graphique et devrait idéalement revenir à l'écran ce qu'il était à l'origine.

Lorsque vous établissez un mode vidéo avec fg_setmode, Fastgraph efface toutes les
pages vidéo physiques et initialise ses tables de pages internes comme si aucune des pages virtuelles ou logiques ont été créées. Bien qu'il soit impossible de préserver le contenu de la page physique à travers les commutateurs de mode vidéo, vous pouvez utiliser fg_getentry et fg_setentry les routines de Fastgraph pour enregistrer le contenu des pages virtuelles ou logiques. L'astuce, pour ainsi dire, est d'utiliser fg_getentry pour enregistrer l'adresse de page virtuelle ou logique et le type avant de passer les modes vidéo. Ensuite, lorsque vous retournez sur le même mode vidéo, vous pouvez utiliser fg_setentry pour restaurer les tables de pages internes à leur état précédent. Cela rend effectivement la page virtuelle ou logique nouveau accessible.

  Exemple 8-12 illustre ce processus.  Ce programme fonctionne en mode vidéo

18, le mode graphique 640x480 VGA 16-couleur. Après avoir établi ce mode vidéo, le programme appelle fg_alloccms pour créer une page logique dans la mémoire conventionnelle. Ensuite, il appelle fg_getentry pour enregistrer l'adresse et le type de la page logique vient d'être créé. Le premier argument de fg_getentry spécifie le numéro de page (déterminé par fg_findpage); les deux arguments suivants reçoivent l'adresse de la page et le type. codes de type de page utilisés par fg_getentry et fg_setentry sont:

  0 page = non alloué
     1 page = physique
     2 = page virtuelle
     3 page = logique dans la mémoire paginée (EMS)
     4 = page logique dans la mémoire étendue (XMS)
     5 = page logique dans la mémoire conventionnelle

Après ce travail d'installation, par exemple 8-12 remplit l'écran avec bleu clair
pixels, dessine une boîte blanche autour du bord, puis attend une touche. Avant de revenir au mode vidéo original (supposé être le mode 3), le programme utilise fg_copypage pour copier le contenu des pages visuelles à la page logique. Cela est nécessaire parce que nous ne pouvons enregistrer le contenu de la page virtuels ou logiques à travers les changements de mode vidéo, pas de pages physiques. En mode 3, le programme invite à entrer une combinaison de touches avant de revenir en mode 18.

Maintenant, nous sommes prêts à restaurer le contenu précédent de la page visuelle.

Parce que l'exemple de programme n'a pas communiqué la page logique, la mémoire est toujours allouée; Fastgraph juste ne peut pas y accéder. Pour résoudre ce problème, le programme appelle fg_setentry pour restaurer les entrées de tables de pages internes de Fastgraph pour le numéro logique de la page originale à ce qu'ils étaient auparavant. Notez comment nous utilisons la même adresse de la page et le type de valeurs dans l'appel à fg_setentry qui ont été retournés plus tôt par fg_getentry. Maintenant que la page logique est de nouveau accessible, le programme peut fg_copypage utiliser pour copier son contenu revenir à la page visuelle. Avec cette explication derrière nous, voici par exemple 8-12.

  Exemple 8-12.

  #include <fastgraf.h>
                  void main (void);

  void main ()
                  {
                     int old_mode; 
                             Chapitre 8: Pages vidéo et Virtual Tampons 169


  int page page_addr, page_type;

  fg_initpm ();
                     fg_getmode old_mode = ();
                     fg_setmode (18);
                     page = fg_findpage ();
                     fg_alloccms (page);
                     fg_getentry (page, & page_addr, & page_type);

  fg_setcolor (9);
                     fg_fillpage ();
                     fg_setcolor (15);
                     fg_box (0,639,0,479);
                     fg_waitkey ();

  fg_copypage (0, p);
                     fg_setmode (old_mode);
                     fg_cursor (0);
                     fg_setcolor (15);
                     fg_text ( «Appuyez sur une touche.", 14);
                     fg_waitkey ();

  fg_setmode (18);
                     fg_setentry (page, page_addr, page_type);
                     fg_copypage (page, 0);
                     fg_waitkey ();

  fg_freepage (page);
                     fg_setmode (old_mode);
                     fg_reset ();
                  }


Pour garder l'exemple le plus simple possible, il ne teste pas
disponibilité des modes vidéo, ni vérifier si la création de la page logique a réussi. Dans une application réelle, bien sûr, en omettant ces contrôles est pas recommandé. Voir l'exemple 8-17 pour une version de ce programme qui utilise des tampons virtuels au lieu de pages logiques.


===Contrôle de la page Allocation===

Lorsque Fastgraph crée des pages virtuelles ou logiques en mémoire conventionnelle
avec fg_allocate ou fg_alloccms, il utilise le DOS allouer service de mémoire (fonction 48 hex d'interruption 21 hex). Certains compilateurs allouer tout ou partie de la mémoire conventionnelle disponible pour une structure de données appelée le tas ou tas loin. fonctions d'allocation de mémoire tels que malloc gérer leurs demandes par l'intermédiaire d'un gestionnaire de tas associé plutôt que par les services DOS. Si le gestionnaire de tas contrôle la mémoire tous disponibles, le DOS allouer service de mémoire est essentiellement désactivé parce qu'il n'y aura pas de mémoire disponible pour satisfaire les demandes d'allocation. Si le gestionnaire de tas contrôle certains, mais toute la mémoire non disponible, un conflit peut survenir entre le gestionnaire de tas et le DOS allouer service de mémoire.

Pour résoudre ce problème, vous pouvez utiliser allouer de la mémoire loin du compilateur
fonction pour réserver la mémoire de la page virtuelle ou logique et ensuite faire le Guide de l'utilisateur 170 Fastgraph


Page connue Fastgraph avec fg_setentry. La meilleure façon de déterminer la quantité de mémoire à allouer est par la fonction fg_pagesize, qui renvoie la taille de page en octets (comme un entier long) pour le mode vidéo actuel. Pour libérer la page, utilisez fg_setentry avec un type de zéro page pour marquer la page comme non alloué avant de réellement libérer la mémoire. Les pages créées de cette façon ne sont pas initialement effacées parce que le contenu de blocs de mémoire alloués ne sont pas définis. Nous vous recommandons d'utiliser fg_erase pour définir le contenu des pages à la couleur de fond.

Exemple 8-13 montre comment créer une page virtuelle dans les programmes en mode réel
l'utilisation de ces techniques au lieu de fg_allocate. Il utilise les fonctions farmalloc et farfree de la bibliothèque d'exécution C pour les compilateurs Borland (les fonctions Microsoft analogues sont _fmalloc et _ffree). Exemple 8-13 utilise fg_pagesize et Borland run-time fonction de bibliothèque farmalloc pour créer une page virtuelle dans le / MCGA mode 256 graphiques couleur 320x200 VGA. Après attribution de la mémoire, le programme appelle fg_setentry, en lui transmettant le numéro de page (1), la partie de segment de l'adresse du bloc de mémoire (en utilisant la macro FP_SEG de la bibliothèque run-time), et le code d'une page virtuelle (2) . Une fois la page virtuelle est mis en place, le programme écrit un texte sur la page virtuelle puis fg_copypage utilise pour afficher le contenu des pages virtuelles sur la page visuelle. Enfin, il libère la page en appelant fg_setentry (donc Fastgraph sait la page virtuelle est parti) et la fonction de bibliothèque run-time farfree (pour réellement libérer la mémoire). L'appel à fg_setentry est pas vraiment nécessaire dans ce cas, car aucune autre fait référence à la page 1.

  Exemple 8-13.

  #include <fastgraf.h>
            #include <dos.h>
            #ifdef __TURBOC__
            #include <alloc.h>
            #autre
            #include <malloc.h>
            #define farfree (p) _ffree (p)
            #define farmalloc (n) _fmalloc (n)
            #fin si

  void main (void);

  void main ()
            {
               int old_mode;
               page_addr unsigned;
               carboniser loin * buffer;

  fg_getmode old_mode = ();
               fg_setmode (19);
               buffer = farmalloc (fg_pagesize () + 16);
               page_addr = FP_SEG (tampon) + (FP_OFF ??(tampon) +15) / 16;
               fg_setentry (1, page_addr, 2);

  fg_setpage (1);
               fg_erase ();
               fg_setcolor (9);
               fg_text ( "Ceci est la page 1.", 15);
               fg_waitkey (); 
                             Chapitre 8: Pages vidéo et Virtual Tampons 171


  fg_copypage (1,0);
               fg_setentry (1,0,0);
               fg_waitkey ();

  farfree (tampon);
               fg_setmode (old_mode);
               fg_reset ();
            }


===tampons virtuels===

tampons virtuels sont des blocs de mémoire conventionnelle que vous pouvez traiter comme
la mémoire vidéo. Ils sont beaucoup plus grand que les pages virtuelles, car ils sont pris en charge dans tous les modes vidéographique et peut être plus petite ou plus grande que la taille réelle de la page. Une demande peut avoir jusqu'à 32 tampons virtuels ouvrent simultanément. Chaque tampon virtuel a ses propres limites d'écrêtage indépendants, qui par défaut à l'ensemble du tampon virtuel. Tout programme qui utilise des tampons virtuels doit initialiser l'environnement de tampon virtuel en appelant fg_vbinit une fois, avant d'appeler l'un des autres routines tampons virtuels Fastgraph. La routine de fg_vbinit n'a pas d'arguments et aucune valeur de retour.

En mode protégé, et lors de l'utilisation des compilateurs en mode réel qui prennent en charge énorme
tableaux (tableaux lointains dont la taille peut dépasser 64 Ko), utiliser fg_vbdefine pour créer des tampons virtuels. La routine fg_vbdefine définit un bloc de mémoire allouée précédemment en tant que mémoire virtuelle. Habituellement, cette mémoire est allouée dynamiquement avec les fonctions malloc ou farmalloc en C ou C ++, la fonction GlobalAllocPtr en mode protégé Pascal, ou l'instruction ALLOCATE en FORTRAN protégées de mode. La routine fg_vbdefine renvoie une poignée par laquelle le tampon virtuel est référencé dans d'autres routines Fastgraph. Deux routines virtuelles connexes tampons sont fg_vbundef, qui libère une poignée de tampon virtuel, et fg_vbhandle, qui retourne la poignée de la mémoire tampon virtuelle active (ou -1 si aucun tampon virtuel est actif).

Le nombre d'octets nécessaires pour un buffer virtuel est simplement sa largeur
pixels multiplié par sa hauteur en pixels, quel que soit le mode vidéo actuel. La mise en page de mémoire virtuelle est tout aussi simple. Par exemple, un tampon virtuel 320x200 nécessite 64,000 octets. Les 320 premiers octets représentent la première ligne de la mémoire virtuelle, les 320 octets suivants représentent la deuxième rangée, et ainsi de suite. Dans chacune des 200 ces lignes, chacune des 320 octets représente un pixel. Cela signifie, par exemple, le (0,0) pixel dans la mémoire tampon virtuelle serait à l'offset 0, le (2,0) pixel serait à l'offset 2, et (2,1) pixel serait à l'offset 322. d'une manière générale, le décalage de la position (x, y) pixel est donnée par la formule y * virtual_buffer_width + x.

La méthode de l'allocation de mémoire dynamique appropriée pour les tampons virtuels
est compilateur et dépendant de l'environnement. Lorsque vous utilisez le mode protégé 32 bits, la mémoire tampon virtuelle réside dans le segment de données par défaut du programme et est référencé par un pointeur près standard. Dans les environnements 16 bits, la mémoire tampon virtuelle est un choix énorme et est référencé par un pointeur loin. Les exemples suivants illustrent la façon d'allouer de la mémoire pour un tampon virtuel 640x400 pour chaque compilateur qui prend en charge l'allocation dynamique des énormes blocs de mémoire. Guide de l'utilisateur 172 Fastgraph

Pour Borland C ++ (16-bit), Turbo C ++, Turbo C:

  carboniser énorme tampon *;
     buffer = (char énorme *) farmalloc (640L * 400L);

Pour Microsoft C / C ++, QuickC, Visual C ++, 16-bit WATCOM C / C ++:

  carboniser énorme tampon *;
     buffer = (char énorme *) halloc (640L * 400L, 1);

Pour les compilateurs C 32-bit / C ++:

  char * tampon;
     buffer = (char *) malloc (640 * 400);

Pour Borland Pascal 7 (mode protégé):

  tampon var: pointeur;
     tampon: = GlobalAllocPtr (GMEM_FIXED, Longint (640) * Longint (400));

Pour Microsoft FORTRAN PowerStation:

  ENTIER * 1 TAMPON [ALLOCATABLE] (:)
     ENTIER STATUS
     ALLOCATE (TAMPON (640 * 400), STAT = STATUS)

Mode réel BASIC, Pascal, et les compilateurs Fortran ont limité, le cas échéant,
soutien aux énormes tableaux. Dans ces environnements, utilisez fg_vballoc pour créer des tampons virtuels. La routine de fg_vballoc utilise le DOS allouer service de mémoire à réserver la mémoire tampon virtuelle. Les compilateurs BASIC pris en charge et le mode réel Turbo Pascal assignent normalement toute la mémoire classique utilisé à une zone appelée le tas loin. Au mieux, cela va provoquer DOS demandes d'allocation de mémoire à l'échec, mais le plus souvent, il crée des conflits de mémoire qui se manifestent plus tard dans votre application. Pour résoudre ce problème, vous devez dire au compilateur de réduire la taille du tas loin.

Mode réel programmeurs Pascal doivent utiliser la directive $ M pour réduire l'extrême
taille tas par l'espace total nécessaire pour tous les tampons virtuels. Si vous voulez utiliser un tampon virtuel 640x400, par exemple, la directive $ M suivante réduirait la taille loin tas par 256.000 octets:

  {$ M 16384,0,256000}

les programmeurs de base doivent utiliser la fonction SETMEM pour réduire le tas loin
la taille de l'espace total nécessaire pour tous les tampons virtuels, plus 16 octets par tampon virtuel. Si vous voulez utiliser un tampon virtuel 640x400 dans un programme BASIC, l'appel SETMEM suivante réduirait la taille loin tas par 256,016 octets:

  SetMemStatus & = SETMEM (-256.016)

Une fois que vous avez terminé avec un tampon virtuel, sa mémoire peut être libérée
en utilisant fg_vbfree. Vous devez utiliser fg_vbfree uniquement avec des tampons virtuels créés avec fg_vballoc et non ceux créés avec fg_vbdefine, et vous ne pouvez pas l'utiliser sur le tampon virtuel actif. Comme fg_vballoc et fg_vbfree sont nécessaires pour le mode réel uniquement, ils ne sont pas présents dans les bibliothèques de mode Fastgraph protégées. pour
tampons virtuels créés avec fg_vbdefine, il suffit d'utiliser la méthode standard de votre compilateur pour libérer des blocs de mémoire dynamique.

Une fois un tampon virtuel est défini, vous pouvez l'activer avec fg_vbopen.

Quand un buffer virtuel est actif, la plupart des routines Fastgraph qui fonctionnent sur un tampon virtuel au lieu de la mémoire vidéo. Cela va continuer jusqu'à ce que vous appelez fg_vbclose, qui redirige les opérations graphiques revenir à la page de la vidéo active. Si vous voulez plus tard pour activer à nouveau le tampon virtuel, ou si vous voulez passer à un autre tampon virtuel précédemment créé avec fg_vbdefine, vous pouvez utiliser fg_vbopen à cet effet.

Deux des plus importantes routines de tampons virtuels sont Fastgraph fg_vbpaste
et fg_vbcut. Ces routines se déplacent des zones rectangulaires entre la mémoire tampon virtuelle active et la page de la vidéo active. Les fg_vbcut copies de routine un de la zone de la page vidéo active à la mémoire tampon virtuelle active. De même, des copies fg_vbpaste un de la zone de la mémoire tampon virtuelle active à la page de la vidéo active. Une propriété particulièrement utile de fg_vbcut et fg_vbpaste est que chacun se souviennent de la page la plus récente de la mémoire tampon et la vidéo virtuelle active. Cette fonction permet de déplacer les zones avant et en arrière entre un tampon virtuel et la mémoire vidéo sans en continu l'ouverture et la fermeture de la mémoire virtuelle.

La routine fg_vbpaste effectue une simple traduction des valeurs de pixels
plus grand que le nombre de couleurs disponibles en mode vidéo en cours. Cela pourrait se produire, par exemple, si vous avez utilisé fg_vbcut dans un mode graphique 256 couleurs et plus tard utilisé fg_vbpaste pour afficher le contenu du tampon virtuel dans un mode graphique de 16 couleurs. Si cela se produit, fg_vbpaste affiche des pixels de couleur c dans la couleur c modulo n, où n est le nombre de couleurs disponibles dans le mode vidéo actuel.

À ce stade, certains exemples de programmes devraient permettre de clarifier l'utilisation de
tampons virtuels.Notre premier exemple, 8-14, fonctionne dans le VGA standard / MCGA 320x200 mode graphique 256 couleurs (mode 19) et crée un tampon virtuel deux fois plus élevée et deux fois plus large que la taille de l'écran. Cela signifie que nous allons créer un tampon virtuel 640x400 nécessitant 256.000 octets de mémoire conventionnelle (séquences de compilation conditionnelle montrent comment allouer la mémoire tampon virtuelle pour différents compilateurs). Si le tampon virtuel a été créé avec succès, le programme appelle fg_vbopen pour activer la mémoire virtuelle, puis dessine quatre 320x200 rectangles de couleurs différentes, un dans chaque quadrant de la mémoire virtuelle. Il fg_vbpaste utilise ensuite pour copier chaque rectangle sur la page vidéo active, suivie d'un autre appel pour montrer la partie centrale 320x200 du buffer virtuel (cela affichera des parties égales des quatre rectangles).

 Exemple 8-14.

 #include <fastgraf.h>
       #include <stdio.h>
       #include <stdlib.h>
      #ifdef __TURBOC__
      #include <alloc.h>
       #autre
      #include <malloc.h>
       #fin si

 #define WIDTH 640
      #define HAUTEUR 400   

 void main (void);

 void main ()
       {
         poignée int;
         int old_mode;
      #ifdef FG32
          char * tampon;
       #autre
         carboniser énorme tampon *;
       #fin si

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
         fg_getmode old_mode = ();
         fg_setmode (19);
         fg_vbinit ();

 / * Mettre en place un 640x400 tampon virtuel * /

 #ifdef FG32
         buffer = (char *) malloc (WIDTH * HEIGHT);
      #elif défini (__ TURBOC__)
         buffer = (char énorme *) farmalloc ((long) WIDTH * (long) HAUTEUR);
       #autre
         buffer = (char énorme *) halloc ((long) WIDTH * (long) HAUTEUR, 1);
       #fin si
         if (tampon == NULL) {
            fg_setmode (old_mode);
            fg_reset ();
            printf ( "Impossible de créer la mémoire virtuelle. \ n");
            sortie (1);
             }
         handle = fg_vbdefine (buffer, largeur, hauteur);
         fg_vbopen (poignée);

 / * Dessiner un rectangle 320x200 dans chaque quadrant de tampon virtuel * /

 fg_setcolor (9);
         fg_rect (0,319,0,199);
         fg_setcolor (10);
         fg_rect (320,639,0,199);
         fg_setcolor (11);
         fg_rect (0319200399);
         fg_setcolor (12);
         fg_rect (320,639,200,399);

 / * Coller chaque rectangle sur la page vidéo active 320x200 * /

 fg_vbpaste (0,319,0,199,0,199);
         fg_waitkey ();
         fg_vbpaste (320,639,0,199,0,199);
         fg_waitkey ();
         fg_vbpaste (0,319,200,399,0,199);
         fg_waitkey (); 
                            Chapitre 8: Pages vidéo et Virtual Tampons 175


 fg_vbpaste (320,639,200,399,0,199);
         fg_waitkey ();

 / * Coller le centre 320x200 sous-ensemble de la mémoire virtuelle * /

 fg_vbpaste (160,479,100,299,0,199);
         fg_waitkey ();

 / * Fermer le tampon virtuel * /

 fg_vbclose ();

 / * Rétablir le mode de la vidéo originale et la sortie * /

 fg_setmode (old_mode);
         fg_reset ();
       }


Appel fg_vbclose avant l'appel de fg_setmode final est nécessaire parce que
fg_setmode n'a pas d'effet quand un tampon virtuel est actif. Si nous n'appelons fg_vbclose, le programme de retour au DOS en mode 19 au lieu du mode vidéo original.

Si vous vouliez au lieu d'allouer la mémoire tampon virtuelle avec
fg_vballoc dans l'exemple 8-14, les étapes pour créer la mémoire virtuelle allait changer la façon suivante:

 / * Mettre en place un 640x400 tampon virtuel * /

 handle = fg_vballoc (largeur, hauteur);
 si (poignée <0) {
    fg_setmode (old_mode);
    fg_reset ();
    printf ( "Impossible de créer la mémoire virtuelle. \ n");
    sortie (1);
     }
 fg_vbopen (poignée);

Si vous créez le tampon virtuel avec fg_vballoc, vous devez également utiliser fg_vbfree pour libérer la mémoire tampon virtuelle quand il est plus nécessaire:

 / * Fermer le tampon virtuel * /

 fg_vbclose ();
 fg_vbfree (poignée);

Encore une fois, nous vous recommandons d'utiliser fg_vballoc et fg_vbfree seulement avec les compilateurs 16 bits qui ne fournissent pas des méthodes faciles pour créer d'énormes tableaux.

Exemple 8-15 illustre l'utilisation de la routine de fg_vbcut, qui
réalise essentiellement l'opération inverse de fg_vbpaste. Autrement dit, fg_vbcut copie une zone rectangulaire de la page vidéo active à la mémoire tampon virtuelle active. Le programme commence par dessiner un rectangle bleu 20x20 avec une bordure blanche dans le coin supérieur gauche de la page de la vidéo active. Après une séquence de touches, il met en place un tampon virtuel 20x20 et appelle fg_vbcut pour copier le rectangle pour le Guide de l'utilisateur 176 Fastgraph
la mémoire virtuelle. Le programme appelle ensuite fg_vbpaste dans une boucle pour afficher 16 copies du contenu de tampons virtuels à travers le fond de l'écran. Notez que par exemple 8-15 utilise un tampon virtuel qui est juste 20 pixels carrés, ou 400 octets au total. Parce qu'il est si petit, nous avons choisi de déclarer un tableau de 400 octets pour le tampon virtuel au lieu d'allouer dynamiquement la mémoire comme dans l'exemple précédent. Notez également que parce que la taille virtuelle de réseau de tampon est inférieure à 64K octets, nous pouvons déclarer ce loin au lieu d'énorme dans les environnements 16 bits (énormes tableaux moins de 64K sont fonctionnellement équivalents à des tableaux loin).

 Exemple 8-15.

 #include <fastgraf.h>

 #define WIDTH 20
                #define HAUTEUR 20

 void main (void);

 #ifdef FG32
                char buffer [WIDTH * HEIGHT];
                 #autre
                carboniser loin tampon [WIDTH * HEIGHT];
                 #fin si

 void main ()
                 {
                   poignée int;
                   int old_mode;
                   int x;

 fg_initpm ();
                   fg_getmode old_mode = ();
                   fg_setmode (19);
                   fg_vbinit ();

 fg_setcolor (15);
                   fg_rect (0, WIDTH-1,0, HAUTEUR-1);
                   fg_setcolor (9);
                   fg_rect (1, WIDTH-2,1, HAUTEUR-2);
                   fg_waitkey ();

 handle = fg_vbdefine (buffer, largeur, hauteur);
                   fg_vbopen (poignée);
                   fg_vbcut (0, WIDTH-1,0, HAUTEUR 1,0, HAUTEUR-1);

 for (x = 0; x <= 320 Width = x + WIDTH)
                      fg_vbpaste (0, WIDTH-1,0, HAUTEUR-1, x, 199);
                   fg_waitkey ();

 fg_vbclose ();
                   fg_setmode (old_mode);
                   fg_reset ();
                }   
                            Chapitre 8: Pages vidéo et Virtual Tampons 177


Si vous créez un tampon virtuel qui est plus grand ou plus large que la taille de la page
(Ou peut-être à la fois plus grand et plus large), il est possible d'effectuer un défilement de tampon virtuel. Pour obtenir un effet de défilement, vous généralement juste appeler fg_vbpaste itérative de telle sorte que la région de source dans les incréments de tampons virtuels progressivement, tandis que la région de destination sur la page vidéo actif reste le même. Selon le mode vidéo et la taille de la zone de défilement, vous pouvez avoir besoin d'inclure un facteur de retard entre fg_vbpaste appelle donc la zone à défilement ne semble pas sauter immédiatement à sa destination finale.

Exemple 8-16 effectue le défilement de la mémoire tampon virtuelle. Cet exemple fonctionne dans le
XVGA 320x200 mode graphique 256 couleurs (mode 20) et crée un buffer virtuel 1000x50 en utilisant la méthode de l'exemple 8-14. Le programme remplit la mémoire tampon virtuelle avec une série d'un seul pixel de largeur des rectangles, chacun 50 pixels en hauteur et en couleurs alternées. Le défilement réel a lieu dans la boucle contenant les deux appels fg_vbpaste. Nous allons définir une zone 100x50 dans le milieu de la page visuelle, avec des extrêmes horizontaux entre 110 et 209, et les extrêmes verticales entre 75 et 124, que notre région de défilement. Nous allons faire défiler la moitié supérieure (25 pixels) du buffer virtuel de droite à gauche tout en faisant défiler la moitié inférieure de gauche à droite. En d'autres termes, nous allons déplaçons deux 100x25 sous-ensembles de la mémoire tampon virtuelle à travers la zone de défilement.

Le premier appel de fg_vbpaste fait défiler la moitié supérieure de la mémoire virtuelle.  le
à partir de coordonnées x définissant la zone de transfert à partir des plages tampons virtuels 0-900 par incréments d'un pixel, et la largeur de la zone de transfert est toujours 100 pixels. La hauteur de la zone de transfert reste constante à 25 pixels (lignes de mémoire tampon virtuel 0 à 24). La position de la destination est la moitié supérieure de la zone de défilement de la page visuelle; son coin inférieur gauche est à x = 110 et y = 99.

Le deuxième appel de fg_vbpaste, qui fait défiler la moitié inférieure du virtuel
tampon, mais dans le sens opposé, se comporte de manière similaire. Dans ce cas, le x de départ de coordonnées dans le tampon virtuel diminue 900-0 dans les étapes d'une durée d'pixel, et sa largeur est toujours 100 pixels. La hauteur de la zone de transfert est à nouveau 25 pixels, mais cette fois-ci utilise des lignes 25-49 dans la mémoire tampon virtuelle. La position de la destination est la moitié inférieure de la zone de défilement de la page visuelle; son coin inférieur gauche est à x = 110 et y = 124.

 Exemple 8-16.

 #include <fastgraf.h>
      #include <stdio.h>
      #include <stdlib.h>
     #ifdef __TURBOC__
     #include <alloc.h>
      #autre
     #include <malloc.h>
      #fin si

 WIDTH #define 1000
     #define HAUTEUR 50

 void main (void);

 void main ()
      {
        poignée int; 

 int old_mode;
        int x;
     #ifdef FG32
         char * tampon;
      #autre
        carboniser énorme tampon *;
      #fin si

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
        fg_getmode old_mode = ();
        fg_setmode (20);
        fg_vbinit ();

 / * Remplir l'écran avec la lumière pixels bleus * /

 fg_setcolor (9);
        fg_fillpage ();

 / * Mettre en place le tampon virtuel * /

 #ifdef FG32
        buffer = (char *) malloc (WIDTH * HEIGHT);
     #elif défini (__ TURBOC__)
        buffer = (char énorme *) farmalloc ((long) WIDTH * (long) HAUTEUR);
      #autre
        buffer = (char énorme *) halloc ((long) WIDTH * (long) HAUTEUR, 1);
      #fin si
        if (tampon == NULL) {
           fg_setmode (old_mode);
           fg_reset ();
           printf ( "Impossible de créer la mémoire virtuelle. \ n");
           sortie (1);
            }
        handle = fg_vbdefine (buffer, largeur, hauteur);
        fg_vbopen (poignée);

 / * Remplir le tampon virtuel avec une série de rectangles étroits * /

 for (x = 0; x <WIDTH; x ++) {
           fg_setcolor (x);
           fg_rect (x, x, 0, HAUTEUR-1);
            }

 / * Faire défiler le tampon virtuel à travers une fenêtre 100x50 sur le * /
        / * La page visuelle, de telle sorte que les rouleaux de la moitié en haut à gauche et le * /
        / * Défile demi bas à droite * /

 for (x = 0, x largeur <99; x ++) {
           fg_vbpaste (x, x + 99,0,24,110,99);
           fg_vbpaste (WIDTH-100-x, WIDTH-1-x, 25,49,110,124);
            }
        fg_waitkey ();

 / * Fermer le tampon virtuel * /   
                            Chapitre 8: Pages vidéo et Virtual Tampons 179


 fg_vbclose ();

 / * Rétablir le mode de la vidéo originale et la sortie * /

 fg_setmode (old_mode);
        fg_reset ();
      }


Le dernier exemple virtuel tampon programme que nous allons présenter dans ce chapitre est
une version de l'exemple 8-12 modifié pour fonctionner avec des tampons virtuels. Exemple 8-12 utilisé une page logique dans la mémoire conventionnelle pour préserver le contenu de la page visuelle à travers les commutateurs de mode vidéo, avec l'aide de fg_getentry et fg_setentry les routines de Fastgraph. Exemple 8-17 illustre comment vous pouvez accomplir la même chose avec un tampon virtuel. Il fonctionne dans le mode 320x240 256- graphique couleur (mode 22) et utilise un tampon virtuel dont la taille est identique à la résolution de l'écran. Après la création de la mémoire virtuelle, le programme remplit la page visuelle avec des pixels bleus et dessine une bordure blanche autour de lui. Il utilise ensuite fg_vbcut pour copier le contenu de l'écran dans la mémoire tampon virtuelle. Comme exemple 8-12, le programme passe temporairement revenir au mode vidéo original et attend une touche. Il passe ensuite en mode 22 et fg_vbpaste utilise pour restaurer le contenu de l'écran.

 Exemple 8-17.

 #include <fastgraf.h>
            #include <stdio.h>
            #include <stdlib.h>
           #ifdef __TURBOC__
           #include <alloc.h>
            #autre
           #include <malloc.h>
            #fin si

 void main (void);

 void main ()
            {
              poignée int;
              int old_mode;
           #ifdef FG32
               char * tampon;
            #autre
              carboniser énorme tampon *;
            #fin si

 fg_initpm ();
              fg_getmode old_mode = ();
              fg_setmode (22);
              fg_vbinit ();

 #ifdef FG32
              buffer = (char *) malloc (320 * 240);
           #elif défini (__ TURBOC__)
              buffer = (char énorme *) farmalloc (320L * 240L); 

  #autre
              buffer = (char énorme *) halloc (320L * 240L, 1);
            #fin si
              if (tampon == NULL) {
                 fg_setmode (old_mode);
                 fg_reset ();
                 printf ( "Impossible de créer la mémoire virtuelle. \ n");
                 sortie (1);
                  }
              handle = fg_vbdefine (tampon, 320240);

 fg_setcolor (9);
              fg_fillpage ();
              fg_setcolor (15);
              fg_box (0,319,0,239);
              fg_vbopen (poignée);
              fg_vbcut (0,319,0,239,0,239);
              fg_vbclose ();
              fg_waitkey ();

 fg_setmode (old_mode);
              fg_cursor (0);
              fg_setcolor (15);
              fg_text ( «Appuyez sur une touche.", 14);
              fg_waitkey ();

 fg_setmode (22);
              fg_vbopen (poignée);
              fg_vbpaste (0,319,0,239,0,239);
              fg_waitkey ();

 fg_vbclose ();
              fg_setmode (old_mode);
              fg_reset ();
            }


Fastgraph comprend d'autres fonctions pour travailler avec des tampons virtuels, mais
nous reportons notre discussion sur eux jusqu'à ce que les chapitres suivants.


===Résumé de la vidéo et de la page Routines tampons virtuels===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_ALLOCATE crée une page vidéo virtuelle. La quantité de mémoire requise
dépend du mode vidéo en cours. Cette routine n'a pas d'effet si elle fait référence à une page vidéo physique ou logique.

FG_ALLOCEMS crée une page logique dans la mémoire paginée (EMS). Le montant
de mémoire requise dépend des dimensions du mode vidéo et tampon vidéo actuels. Cette routine n'a pas d'effet si elle fait référence à un physique ou virtuel
Page vidéo. En mode protégé, fg_initems toujours échoue, alors fg_allocems est effectivement désactivé.

FG_ALLOCXMS crée une page logique dans la mémoire étendue (XMS). Le montant
de mémoire requise dépend des dimensions du mode vidéo et tampon vidéo actuels. Cette routine n'a pas d'effet si elle fait référence à une page vidéo physique ou virtuel. En mode protégé, fg_initxms toujours échoue, alors fg_allocxms est effectivement désactivé.

FG_COPYPAGE transfère le contenu d'une page vidéo à un autre.  le
pages peuvent être des pages vidéo physiques, virtuels ou logiques. Si les deux pages sont des pages logiques, ils doivent exister dans le même type de mémoire. Cette routine applique toujours les pages vidéo, même quand un tampon virtuel est actif.

FG_DEFPAGES définit les banques SVGA pour la page source et de destination
numéros lorsque vous utilisez les routines de transfert de bloc de Fastgraph avec des pages vidéo étendues.

FG_FINDPAGE trouve un numéro de page de vidéo disponible pour un virtuel ou logique
page.

FG_FREEPAGE publie une page vidéo virtuelle ou logique créé avec
fg_allocate, fg_alloccms, ou fg_allocems fg_allocxms. Cette routine n'a pas d'effet si elle fait référence à une page vidéo physique, ou une page virtuelle qui n'a jamais été créé.

FG_GETADDR retourne l'adresse de segment en mode réel ou en mode protégé
sélecteur de segment pour la page de la vidéo active.

FG_GETENTRY récupère le type et l'adresse d'un physique, virtuel ou
Page vidéo logique. Cette routine est utile pour sauvegarder le contenu de la page virtuelles ou logiques à travers les changements de mode vidéo.

FG_GETPAGE renvoie le nombre actif de Page vidéo.

FG_GETVPAGE renvoie le numéro visuel de la page vidéo.

FG_INITEMS initialise la mémoire paginée pour une utilisation avec Fastgraph de logique
pages. En mode protégé, l'initialisation de la mémoire paginée échouera toujours.

FG_INITXMS initialise la mémoire étendue pour une utilisation avec Fastgraph de logique
pages. En mode protégé, l'initialisation de la mémoire étendue échouera toujours.

FG_PAGESIZE renvoie la page vidéo taille en octets pour la vidéo en cours
mode. La taille de la page est toujours la taille de la page vidéo, même quand un tampon virtuel est actif.

FG_RESIZE modifie les dimensions d'une page vidéo EGA et VGA graphiques
modes. Cette fonction n'a pas d'effet quand un tampon virtuel est actif.

FG_SETENTRY spécifie le type et l'adresse d'un physique, virtuel ou
Page vidéo logique. Pour les pages logiques, il précise en outre si la page réside dans la mémoire conventionnelle, étendue ou prolongée. Cette routine est utile pour sauvegarder le contenu de la page virtuelles ou logiques à travers les changements de mode vidéo, ou pour la création manuelle des pages virtuelles et logiques. Guide de l'utilisateur 182 Fastgraph

FG_SETPAGE établit la page vidéo active. Il peut être une personne physique ou
page virtuelle.

FG_SETVPAGE établit la page vidéo visuelle. Il peut être une personne physique ou
page virtuelle.

FG_VBALLOC crée un tampon virtuel de la taille spécifiée. La mémoire pour
la mémoire virtuelle est attribuée automatiquement. Cette routine doit être utilisé au lieu de fg_vbdefine pour les compilateurs en mode réel qui ne supportent pas d'énormes blocs de mémoire (qui est, blocs loin supérieur à 64K octets). La routine de fg_vballoc est pas présent dans les bibliothèques en mode protégé de Fastgraph.

FG_VBCLOSE ferme le tampon virtuel actif et dirige la production graphique
retour à la page de la vidéo active.

FG_VBCUT copies d'une région rectangulaire de la page vidéo active à la
tampon virtuel actif.

FG_VBDEFINE crée un tampon virtuel de la taille spécifiée.

FG_VBFREE libère la poignée d'un tampon virtuel et libère la mémoire
attribué à un tampon virtuel créé avec fg_vballoc. La routine de fg_vbfree est pas présent dans les bibliothèques en mode protégé de Fastgraph.

FG_VBHANDLE retourne la poignée pour le tampon virtuel actif, ou -1 si aucune
tampon virtuel est actif.

FG_VBINIT initialise environnement tampon virtuel Fastgraph.  Ce
routine doit être appelée une fois, avant que d'autres routines qui font référence à des tampons virtuels.

FG_VBOPEN fait un tampon virtuel existant du tampon virtuelle active.
copies FG_VBPASTE une région rectangulaire de la mémoire tampon virtuelle active à
la page de la vidéo active.

FG_VBUNDEF relâche la poignée associée à un tampon virtuel.


Guide de l'image Fichiers

Dans le contexte de Fastgraph, une image est une zone rectangulaire
contenant un certain type d'image. Une image peut-être quelque chose d'aussi simple que d'une icône de la main de pointage, ou aussi détaillée que le tableau de bord d'une voiture de sport. Fastgraph comprend plusieurs routines pour afficher, récupérer et manipuler des images. Dans ce chapitre, nous allons commencer notre discussion sur les images en regardant le PCX, GIF, FLI / FLC, et les formats de fichiers d'image pixel d'exécution Fastgraph supports, ainsi que les routines disponibles pour l'affichage et la création de fichiers d'images dans ces formats.


===fichiers PCX===

Le format de fichier PCX a été initialement développé par ZSoft Corporation pour
leur programme de peinture commerciale, PC Paintbrush. Il a évolué pour devenir l'un des formats de fichier d'image les plus populaires parce que de nombreux produits peuvent lire et écrire des fichiers PCX au moins dans une certaine mesure. Fastgraph comprend des routines pour l'affichage et la création de fichiers PCX, ainsi que d'autres fonctions de soutien PCX.

La routine fg_showpcx affiche une image stockée dans un fichier PCX.  Ça peut
positionner l'image en utilisant les informations contenues dans l'en-tête de PCX de coordonnées, ou de telle sorte que son coin supérieur gauche est à la position graphique du curseur sur la page vidéo active. Le premier argument de fg_showpcx est le nom du fichier PCX (il peut inclure un nom de chemin), et son second argument est un masque de bits qui contrôle la façon dont l'image est affichée. Le nom du fichier doit se terminer par un caractère nul, donc les programmeurs BASIC, FORTRAN et Pascal auront besoin de stocker un octet nul comme le dernier caractère de la chaîne de nom de fichier. La routine de fg_showpcx ne peut pas afficher les images PCX dans les tampons virtuels. Une routine séparée, fg_loadpcx, est prévu à cet effet et sera décrit plus loin dans cette section.

Dans la version actuelle de Fastgraph, seule la faible commande trois bits (bits
0 à 2) de l'argument de masque de bits sont significatifs. Le tableau suivant résume la signification de ces bits.

 Bit Valeur Signification

 0 0 Utiliser les valeurs de palette stockées dans le fichier PCX
              0 1 Utilisez les paramètres de la palette en cours
              1 0 image d'affichage à la position indiquée en tête PCX
              1 1 Afficher l'image à la position graphique actuelle
              2 0 données d'image d'affichage à partir du fichier PCX
              2 1 données d'image d'affichage de la mémoire tampon de fg_imagebuf

Tous les autres bits sont réservés et doivent être zéro pour garantir la compatibilité avec les futures versions. La routine fg_showpcx renvoie une valeur de 0 en cas de succès, 1 si le fichier spécifié n'a pas été trouvé, et 2 si le fichier est pas un fichier PCX.

La routine de fg_makepcx crée un fichier PCX à partir du rectangle spécifié
région de la page vidéo active ou tampon virtuel. Ses quatre premiers arguments définissent le minimum x, maximum x, y au minimum, et y coordonnées d'espace d'écran maximale de la région (les x minimales coordonnées est réduite à une limite d'octet si nécessaire). Son cinquième argument est le nom du fichier PCX pour créer (il peut inclure un nom de chemin). Comme fg_showpcx, le nom du fichier doit se terminer par un caractère nul. Si un fichier portant le même nom existe, il est
écrasé. La routine fg_makepcx renvoie une valeur de 0 en cas de succès, et 1 si le fichier PCX n'a ??pas été créé.

Exemple 9-1 utilise fg_showpcx et fg_makepcx pour créer un nouveau fichier PCX à partir
lignes sélectionnées d'un fichier existant 320x200 PCX 256 couleurs. Comme il est écrit, le programme utilise le fichier CORAL.PCX pour créer NEW.PCX, mais il pourrait facilement être étendu à travailler avec tous les fichiers PCX. L'appel à fg_showpcx affiche l'image en CORAL.PCX en utilisant la position de l'écran et les paramètres de la palette définie dans le fichier PCX. Après avoir attendu pendant une séquence de touches, le programme appelle fg_makepcx pour créer un fichier PCX nommé NEW.PCX de rangées de pixels 80 à 99 de l'image originale. Dans le cas où le programme rencontre des problèmes, il affiche un message d'erreur avant de quitter.

 Exemple 9-1.

 #include <fastgraf.h>
            #include <stdio.h>
            #include <stdlib.h>
           void main (void);

 void main ()
            {
              int old_mode;
              int READ_STATUS, write_status;

 fg_initpm ();
              if (fg_testmode (19,1) == 0) {
                 printf ( "Ce programme nécessite une 320");
                 ( "le mode x 200 graphiques MCGA \ n".) printf;
                 sortie (1);
                  }
              fg_getmode old_mode = ();
              fg_setmode (19);

 READ_STATUS = fg_showpcx ( "CORAL.PCX", 0);
              fg_waitkey ();
              si (== READ_STATUS 0)
                 write_status = fg_makepcx (0,319,80,99, "NEW.PCX");
               autre
                 write_status = 1;

 fg_setmode (old_mode);
              fg_reset ();

 si (== READ_STATUS 1)
                 printf ( "CORAL.PCX introuvable. \ n");
              else if (READ_STATUS == 2)
                 printf ( "CORAL.PCX est pas un fichier PCX. \ n");
              if (write_status == 1)
                 printf ( "NEW.PCX pas créé. \ n");
            }


Dans le mode 16-graphique couleur Tandy / PCjr (mode 9) et l'EGA native
modes graphiques (modes 13 à 16), les registres de la palette ne sont pas lisibles. Par conséquent, fg_makepcx utilisera les paramètres de la palette par défaut lorsqu'il est utilisé dans le guide de ces 186 Fastgraph utilisateur
modes vidéo sur Tandy et systèmes EGA. Affichage d'un fichier PCX à une résolution inférieure (par exemple, un fichier 640x480 PCX à 320x200) tronque l'affichage sur la droite et sur le fond. Cette affiche effectivement le coin supérieur gauche de l'image. Les fg_showpcx et fg_makepcx routines ont aucun effet en mode vidéo de texte ou en mode graphique basse résolution Hercules.

Si vous voulez afficher un fichier PCX dans un tampon virtuel, vous devez utiliser
fg_loadpcx la routine de Fastgraph au lieu de fg_showpcx. Les paramètres de fg_loadpcx et les valeurs de retour sont identiques à ceux de fg_showpcx, mais la destination de l'image virtuelle est une mémoire tampon et non de mémoire vidéo. Nous avons trouvé qu'il est préférable de créer une fonction distincte pour le chargement des images PCX dans des tampons virtuels car PCX fichiers de ressembler étroitement à la structure de la mémoire vidéo. La routine fg_showpcx est optimisée pour tirer profit de ce fait, alors que fg_loadpcx doit exécuter la tâche supplémentaire consistant à convertir les données de pixel au format de mémoire virtuelle.

Exemple 9-2 montre comment afficher une image PCX dans un tampon virtuel avec
fg_loadpcx. Le fichier CORAL.PCX utilisé dans cet exemple est une image 320x200, donc la taille de la mémoire tampon virtuelle requise est de 64.000 octets. Après la création et l'ouverture de la mémoire virtuelle, le programme appelle fg_loadpcx pour afficher l'image dans la mémoire tampon virtuelle. En cas de succès, il est l'image visible en copiant le contenu du tampon virtuel à la page visuelle utilisant fg_vbpaste.

 Exemple 9-2.

 #include <fastgraf.h>
            #include <stdio.h>
            #include <stdlib.h>
           #ifdef __TURBOC__
           #include <alloc.h>
            #autre
           #include <malloc.h>
            #fin si
           void main (void);

 void main ()
            {
              poignée int;
              int old_mode;
              statut int;
           #ifdef FG32
               char * tampon;
            #autre
              carboniser énorme tampon *;
            #fin si

 fg_initpm ();
              if (fg_testmode (19,1) == 0) {
                 printf ( "Ce programme nécessite une 320");
                 ( "le mode x 200 graphiques MCGA \ n".) printf;
                 sortie (1);
                  }
              fg_getmode old_mode = ();
              fg_setmode (19);
              fg_vbinit (); 

 #ifdef FG32
              buffer = (char *) malloc (64000);
           #elif défini (__ TURBOC__)
              buffer = (char énorme *) farmalloc (64000L);
            #autre
              buffer = (char énorme *) halloc (64000L, 1);
            #fin si
              if (tampon == NULL) {
                 fg_setmode (old_mode);
                 fg_reset ();
                 printf ( "Impossible de créer la mémoire virtuelle. \ n");
                 sortie (1);
                  }
              handle = fg_vbdefine (tampon, 320200);
              fg_vbopen (poignée);

 status = fg_loadpcx ( "CORAL.PCX", 0);
              if (état == 0) {
                 fg_vbpaste (0,319,0,199,0,199);
                 fg_waitkey ();
                  }

 fg_vbclose ();
              fg_setmode (old_mode);
              fg_reset ();

 if (état == 1)
                 printf ( "CORAL.PCX introuvable. \ n");
              else if (status == 2)
                 printf ( "CORAL.PCX est pas un fichier PCX. \ n");
            }


Parce que leur structure parallèle à celle de la mémoire vidéo, fichiers PCX sont
spécifiques à certains modes vidéo. Si vous essayez d'afficher un fichier PCX dans un mode vidéo incompatible, fg_showpcx sera toujours afficher quelque chose, mais il sera tronqué. Le tableau suivant résume les modes vidéo compatibles pour les fichiers PCX.

 Si le fichier PCX était Vous pouvez afficher
                   créé en mode dans ces modes

 4, 5 4, 5
                   6, 11 6, 11, 13-18, 28, 29
                   9 9
                   13-18 13-18, 28, 29
                   19-27 19-27
                   28-29 13-18, 28, 29

Contrairement à fg_showpcx, fg_loadpcx ne montre pas une image PCX directement à
la mémoire vidéo. La routine fg_loadpcx convertit au lieu de la structure spécifique de mode du fichier PCX au format du buffer virtuel en mode indépendant comme il décompresse les données d'image. Cette surcharge signifie fg_showpcx est plus rapide que fg_loadpcx, mais fg_loadpcx permet d'afficher tous les fichiers PCX dans tous les modes graphiques vidéo. Le seul problème se produit lors de l'affichage d'une image PCX avec plus de couleurs que les supports actuels en mode vidéo (par exemple, afficher le Guide de l'utilisateur 188 Fastgraph
PCX 256 couleurs dans un mode 16 couleurs). Dans ce cas, fg_vbpaste affichera des pixels de couleur c dans la couleur c modulo n, où n est le nombre de couleurs disponibles dans le mode vidéo actuel.

La routine fg_pcxpal extrait la palette d'une image stockée dans un PCX
fichier.Son premier argument est un nom de fichier PCX, terminé par un octet nul comme fg_showpcx. Son second argument est l'adresse du tableau qui va recevoir les valeurs de la palette PCX. Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chacune entre 0 et 63. Les trois premiers octets de ce tableau contiendra les valeurs RVB pour la couleur 0, les trois suivants pour la couleur 1, et ainsi de suite. La taille du tableau en octets doit être au moins trois fois le nombre de couleurs dans l'image PCX. En cas de succès, la valeur de retour de la fonction fg_pcxpal est le nombre de couleurs dans la palette PCX, 16 ou 256. Les valeurs possibles de retour d'erreur sont -1 (fichier non trouvé) et -2 (le fichier est pas un fichier PCX).

Pour les modes vidéo 18 et au-dessus, les valeurs de la palette fg_pcxpal conviennent
pour une utilisation avec fg_setdacs. Pour les modes graphiques EGA natifs (13 à 16), les valeurs de la palette doivent être converties en valeurs spécifiques au mode (avec fg_maprgb) avant d'être utilisé avec fg_palette ou fg_palettes. Si le fichier PCX comprend un (256 couleurs) palette étendue, fg_pcxpal retourne les valeurs dans la palette étendue. Sinon, elle retourne les valeurs de la palette de 16 couleurs dans l'en-tête de PCX.

La fonction de fg_pcxmode de Fastgraph détermine le mode vidéo optimal pour
l'affichage d'un fichier PCX. Par optimal, on entend le mode vidéo compatible ayant la plus basse résolution est supérieure ou égale aux dimensions de l'image. La routine de fg_pcxmode a un seul argument - l'adresse d'un tampon qui contient un en-tête de fichier PCX 128 octets. Des valeurs spécifiques définies dans certains domaines de l'en-tête de PCX déterminer quel mode vidéo est optimal. Une valeur de rendement positif de fg_pcxmode représente le nombre optimal de mode vidéo. Les retours d'erreurs sont -1 si le tampon ne contient pas un en-tête de PCX valide et -2 si fg_pcxmode ne peut pas trouver un mode vidéo compatible.

Une autre fonction utile de support PCX est fg_pcxrange, qui renvoie la
une information de position d'image à partir de l'en-tête PCX. Le premier argument de fg_pcxrange est l'adresse d'un tampon contenant un en-tête de fichier PCX 128 octets. Les quatre arguments restants reçoivent le minimum x, maximum x, y au minimum, et les valeurs y maximales de l'image PCX correspondante. Vous pouvez utiliser les extensions d'image pour déterminer les dimensions de l'image - par exemple, la largeur d'une image PCX serait maximum_x - minimum_x + 1.

Comment pouvons-nous l'en-tête d'un fichier PCX dans le tampon passé à
fg_pcxmode ou fg_pcxrange? Le plus simple est avec la fonction fg_pcxhead. Son premier argument est le nom du fichier PCX à partir duquel récupérer l'en-tête (comme avant, le nom du fichier doit être terminée par NULL). Le second argument est l'adresse de la mémoire tampon qui recevra l'en-tête de PCX. La taille de ce tampon doit être d'au moins 128 octets. En cas de succès, retourne fg_pcxhead zéro. Sinon, la valeur de retour est -1 si le fichier spécifié n'a pas pu être ouvert, ou -2 si le fichier est pas un fichier PCX. Après avoir lu avec succès l'en-tête PCX, vous pouvez passer à fg_pcxmode pour déterminer le mode vidéo optimal pour le fichier PCX. Des informations complètes sur l'en-tête de fichier PCX 128 octets figure à l'Annexe H.

Exemple 03.09 utilise fg_pcxhead, fg_pcxmode, fg_pcxpal de Fastgraph et
routines fg_pcxrange pour obtenir des informations sur le fichier CORAL.PCX. Il
affiche le numéro de mode vidéo optimal pour afficher l'image, les dimensions de l'image, et 16 premières valeurs de palette de couleurs de l'image.

 Exemple 9-3.

 #include <fastgraf.h>
    #include <stdio.h>
    #include <stdlib.h>
   void main (void);

 void main ()
    {
      int i, j;
      int mode, le statut;
      int minx, maxx, Miny, maxy;
      unsigned char PCXpal [768];
      tête unsigned char [128];

 fg_initpm ();
      status = fg_pcxhead ( "CORAL.PCX", en-tête);
      if (état == -1) {
         printf ( "Impossible de CORAL.PCX open \ n.");
         sortie (1);
          }
      else if (status == -2) {
         printf ( "CORAL.PCX est pas un fichier PCX. \ n");
         sortie (1);
          }

 mode = fg_pcxmode (tête);
      printf ( "mode d'affichage optimal est% d \ n"., mode);

 fg_pcxrange (en-tête, et mijaurée, & maxx, & Miny, & maxy);
      printf ( "Taille de l'image est de% d par% d pixels. \ n", maxx-minx + 1, Maxy-Miny + 1);

 fg_pcxpal ( «CORAL.PCX», PCXpal);
      printf ( "16 premières valeurs de la palette sont: \ n");
       j = 0;
       for (i = 0; i <16; i ++) {
         printf ( "couleur% 2d: R =% 2d G =% 2d B =% 2d \ n",
            i, PCXpal [j], PCXpal [j + 1], PCXpal [j + 2]);
         j + = 3;
          }
    }


===fichiers GIF===

Le format de fichier GIF a été créé par CompuServe, Inc., en tant que transmission
format pour les images et les données graphiques sur le réseau CompuServe. Il a évolué dans ce qui est probablement le format de fichier d'image le plus populaire en usage aujourd'hui. les fichiers GIF sont particulièrement répandus sur les babillards et les réseaux de données électroniques parce que leurs résultats de compression d'image efficace dans moins d'espace de stockage et les temps de transmission plus rapides que d'autres formats de fichiers image. GIF, prononcé "JIF", est un acronyme de Graphics Interchange Format. Le format est le Guide de l'utilisateur 190 Fastgraph
la propriété de CompuServe, Inc., dont le GIF spécification "accorde une licence libre de redevance limitée, non exclusive pour l'utilisation du Graphics Interchange Format dans le logiciel informatique droit d'auteur; les logiciels informatiques utilisant GIF doit reconnaître la propriété du Graphics Interchange Format et sa marque de service par CompuServe, Inc., l'utilisateur et la documentation technique ".

Deux spécifications GIF, publié en 1987 et 1989, sont définis. En 1989,
spécification (connue sous le nom "89a") est un surensemble de la spécification originale 1987 (connu sous le nom "87a"). fichier GIF la routine d'affichage de Fastgraph peut gérer soit 87a ou 89a fichiers. Pour une portabilité maximale, la routine de création de fichier GIF produit toujours des fichiers conformes à la spécification 87a.

La routine fg_showgif affiche une image stockée dans un fichier GIF.  Ça peut
positionner l'image en utilisant les informations contenues dans l'en-tête de GIF de coordonnées, ou de telle sorte que son coin supérieur gauche est à la position graphique du curseur sur la page vidéo active ou tampon virtuel. Les arguments de fg_showgif sont les mêmes que pour les fg_showpcx, à l'exception du nom du fichier doit bien sûr référence à un fichier GIF plutôt que d'un fichier PCX. De même, les valeurs de retour fg_showgif sont analogues à celles de fg_showpcx.

La routine de fg_makegif crée un fichier GIF à partir du rectangle spécifié
région de la page vidéo active ou tampon virtuel. Ses arguments et la valeur de retour sont analogues à celles des fg_makepcx.

Exemple 9-4 utilise fg_showgif et fg_makegif pour créer un nouveau fichier GIF à partir
lignes sélectionnées d'un fichier existant 320x200 GIF 256 couleurs. Similaire à l'exemple 9-1, le programme utilise le fichier CORAL.GIF pour créer new.gif, mais il pourrait facilement être étendu à travailler avec tous les fichiers GIF. L'appel à fg_showgif affiche l'image en CORAL.GIF en utilisant la position de l'écran et les paramètres de la palette définie dans le fichier GIF. Après avoir attendu pendant une séquence de touches, le programme appelle fg_makegif pour créer un fichier GIF nommé new.gif de rangées de pixels 80 à 99 de l'image originale. Dans le cas où le programme rencontre des problèmes, il affiche un message d'erreur avant de quitter.

 Exemple 9-4.

 #include <fastgraf.h>
            #include <stdio.h>
            #include <stdlib.h>
           void main (void);

 void main ()
            {
              int old_mode;
              int READ_STATUS, write_status;

 fg_initpm ();
              if (fg_testmode (19,1) == 0) {
                 printf ( "Ce programme nécessite une 320");
                 ( "le mode x 200 graphiques MCGA \ n".) printf;
                 sortie (1);
                  }
              fg_getmode old_mode = ();
              fg_setmode (19);

 READ_STATUS = fg_showgif ( "CORAL.GIF", 0); 

 fg_waitkey ();
              si (== READ_STATUS 0)
                 write_status = fg_makegif (0,319,80,99, "new.gif");
               autre
                 write_status = 1;

 fg_setmode (old_mode);
              fg_reset ();

 si (== READ_STATUS 1)
                 printf ( "CORAL.GIF introuvable. \ n");
              else if (READ_STATUS == 2)
                 printf ( "CORAL.GIF est pas un fichier GIF. \ n");
              if (write_status == 1)
                 printf ( "new.gif pas créé. \ n");
            }

Comme fg_makepcx, la routine fg_makegif utilisera la palette par défaut
les paramètres lors de l'exécution sur Tandy et systèmes EGA. Affichage d'un fichier GIF à une résolution inférieure (par exemple, un fichier 640x480 GIF à 320x200) tronque l'affichage sur la droite et sur le fond. Cette affiche effectivement le coin supérieur gauche de l'image. Contrairement aux fichiers PCX, les fichiers GIF ne présentent pas de problèmes de compatibilité entre les modes graphiques 16 couleurs et 256 couleurs. Lorsque fg_showgif affiche un GIF 256 couleurs dans un mode 16 couleurs, il affiche des pixels de couleur c dans la couleur c modulo 16. Les fg_showgif et fg_makegif routines ont aucun effet en mode texte vidéo, ou dans les modes graphiques CGA et Hercules.

Fastgraph inclut des routines de support GIF supplémentaires analogues à celles pour
fichiers PCX. La routine fg_gifpal récupère la palette d'une image stockée dans un fichier GIF. Si le fichier GIF comprend une palette locale pour la première image, fg_gifpal retourne les valeurs de la palette locale. Sinon, fg_gifpal retourne les valeurs de la palette globale du fichier GIF. La fonction fg_gifmode détermine le mode vidéo optimal pour l'affichage d'un fichier GIF. La routine fg_gifrange renvoie l'information de position d'image à partir de l'en-tête du format GIF. La routine de fg_gifhead lit tête global d'un fichier GIF et premier en-tête locale dans un tableau de 23 octets (informations complètes sur les en-têtes apparaît à l'annexe H). Les paramètres et les valeurs de retour de ces routines sont les mêmes que pour leurs homologues PCX.

Exemple 9-5 utilise fg_gifhead, fg_gifmode, fg_gifpal de Fastgraph et
routines fg_gifrange pour obtenir des informations sur le fichier CORAL.GIF. Il affiche le numéro de mode vidéo optimal pour afficher l'image, les dimensions de l'image, et 16 premières valeurs de la palette de l'image.

 Exemple 9-5.

 #include <fastgraf.h>
    #include <stdio.h>
    #include <stdlib.h>
   void main (void);

 void main ()
    {
      int i, j;
      int mode, le statut; 

 int minx, maxx, Miny, maxy;
      unsigned char GIFpal [768];
      tête unsigned char [23];

 fg_initpm ();
      status = fg_gifhead ( "CORAL.GIF", en-tête);
      if (état == -1) {
         printf ( "Impossible de CORAL.GIF open \ n.");
         sortie (1);
          }
      else if (status == -2) {
         printf ( "CORAL.GIF est pas un fichier GIF. \ n");
         sortie (1);
          }

 mode = fg_gifmode (tête);
      printf ( "mode d'affichage optimal est% d \ n"., mode);

 fg_gifrange (en-tête, et mijaurée, & maxx, & Miny, & maxy);
      printf ( "Taille de l'image est de% d par% d pixels. \ n", maxx-minx + 1, Maxy-Miny + 1);

 fg_gifpal ( «CORAL.GIF», GIFpal);
      printf ( "16 premières valeurs de la palette sont: \ n");
       j = 0;
       for (i = 0; i <16; i ++) {
         printf ( "couleur% 2d: R =% 2d G =% 2d B =% 2d \ n",
            i, GIFpal [j], GIFpal [j + 1], GIFpal [j + 2]);
         j + = 3;
          }
    }


===fichiers FLI et FLC===

Les fichiers FLI et FLC (fichiers appelés collectivement CIDF) contiennent des séquences de
trames d'image qui peuvent être affichées en succession rapide pour atteindre l'illusion du mouvement (ce qu'on appelle la lecture d'un fichier flac). Les fichiers FLI sont produites par Autodesk Animator et toujours avoir une résolution 320x200, tandis que les fichiers FLC sont produites par Autodesk Animator Pro et peuvent avoir une résolution. routines de fichiers de flic Fastgraph fonctionnent à la fois avec FLI et FLC fichiers, mais ils sont limités aux modes graphiques 256 couleurs parce que les fichiers contiennent toujours des images flic 256 couleurs. La première image d'un fichier flac est généralement une version compressée de l'image entière, tandis que les cadres ultérieurs sont des versions compressées des différences entre ce cadre et l'image précédente. Ce schéma de compression est souvent appelé compression delta dans la littérature de fichier flac.

Fastgraph inclut à la fois de haut niveau et bas niveau routines pour le travail
avec des fichiers flic. Le plus important de routine de haut niveau, fg_showflic, joue tout le contenu d'un fichier flac un certain nombre de fois. Il peut positionner l'image de telle sorte que son coin supérieur gauche est à l'origine de l'écran ou à la position graphique du curseur sur la page vidéo active ou tampon vitual. La routine fg_showflic attend trois arguments. Le premier est le nom du fichier flac, ce qui peut inclure un nom de chemin, mais il doit être mis fin null-. La seconde spécifie le nombre de fois pour lire le fichier flac. Si le nombre de jeu est nul, fg_showflic va jouer en continu. La routine fg_showflic va arrêter la lecture du FLIC
fichier si la touche Echap est enfoncée. Notez que ceci est le seul moyen d'arrêter la lecture du fichier flac si le nombre de jeu est égale à zéro (lecture continue).

Le troisième argument fg_showflic est un masque de bits qui contrôle comment l'image
est affiché.Dans la version actuelle de Fastgraph, seule la faible commande trois bits (0 à 2) de l'argument de masque de bits sont significatifs. Le tableau suivant résume la signification de ces bits.

 Bit Valeur Signification
              0 0 Délai entre les trames comme indiqué dans l'entête FLIC
              0 1 Pas de retard entre les images
              1 0 Affichage image par rapport à l'origine de l'écran
              1 1 Affichage image par rapport à la position graphique actuelle
              2 0 données d'image d'affichage à partir du fichier spécifié FLIC
              2 1 données d'image d'affichage de la mémoire tampon de fg_imagebuf
              4 0 Utiliser les données de la palette dans le fichier flac
              4 1 Ignorer les données de la palette dans le fichier flac

Tous les autres bits sont réservés et doivent être zéro pour garantir la compatibilité avec les futures versions. La routine fg_showflic renvoie une valeur de 0 en cas de succès, 1 si le fichier spécifié n'a pas été trouvé, et 2 si le fichier est pas un fichier flac.

Exemple 9-6 est un lecteur de fichiers flac simple. Il utilise le standard VGA / MCGA
mode graphique 256 couleurs (mode 19) pour lire le fichier flac GLASS.FLI, l'un des exemples fournis avec Autodesk Animator. Le coin supérieur gauche du fichier flac sera à l'origine de l'écran, avec un retard entre les images tel que défini dans l'en-tête du fichier flac.

 Exemple 9-6.
           #include <fastgraf.h>
            #include <stdio.h>
           void main (void);

 void main (void)
            {
              statut int;

 fg_initpm ();
              fg_setmode (19);

 status = fg_showflic ( "GLASS.FLI", 1,0);
              if (état == 0) fg_waitkey ();

 fg_setmode (3);
              fg_reset ();

 if (état == 1)
                 printf ( "GLASS.FLI introuvable. \ n");
              else if (status == 2)
                 printf ( "GLASS.FLI est pas un FLI ou d'un fichier FLC. \ n");
            }


Fastgraph inclut des routines supplémentaires de soutien de FLIC similaires à ceux pour
fichiers PCX et GIF. La routine de fg_flichead lit le fichier spécifié de FLIC
tête de 128 octets (informations complètes sur l'en-tête apparaît à l'annexe H). La fonction fg_flicmode détermine le mode vidéo optimal pour la lecture d'un fichier flac. Son seul argument est un tableau de 128 octets contenant un en-tête de fichier flac retourné par fg_flichead. En cas de succès, elle renvoie le numéro de mode vidéo optimal pour jouer l'image flac. Si le tableau ne contient pas un en-tête de fichier flac valide, fg_flicmode renvoie -1. La routine fg_flicsize renvoie les dimensions de l'image de l'en-tête flac. Son premier argument est un 128-byte-tête FLIC tableau, et deux autres arguments reçoivent la largeur de l'image et la taille en pixels. Exemple 9-7 utilise ces trois routines pour obtenir des informations sur le fichier GLASS.FLI. Il affiche le nombre optimal de mode vidéo pour la lecture du fichier flac, ainsi que les dimensions de l'image.

 Exemple 9-7.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()
          {
            int mode, le statut;
            Largeur int, hauteur;
            tête unsigned char [128];

 fg_initpm ();
            status = fg_flichead ( "GLASS.FLI", en-tête);
            if (état == -1) {
               printf ( "Impossible d'ouvrir GLASS.FLI \ n.");
               sortie (1);
                }
            else if (status == -2) {
               printf ( "GLASS.FLI est pas un FLI ou d'un fichier FLC. \ n");
               sortie (1);
                }

 mode = fg_flicmode (tête);
            printf ( "mode d'affichage optimal est% d \ n"., mode);

 fg_flicsize (en-tête, et la largeur, et hauteur);
            printf ( "Taille de l'image est de% d par% d pixels. \ n", largeur, hauteur);
          }


bas niveau des routines de Fastgraph fournissent flic la possibilité d'afficher FLIC
fichiers d'une image à la fois. Ceci est souhaitable lorsque votre programme doit effectuer d'autres tâches entre les images, ou pour jouer deux ou plusieurs fichiers flic en même temps. Pour utiliser bas niveau des routines de Fastgraph flic, appelez fg_flicopen pour chaque fichier flac. Le premier argument fg_flicopen est le nom du fichier flac. Le second argument est un tableau de 16 octets qui recevra un descripteur de contexte pour le fichier flac. Vous devez créer un descripteur de contexte avec fg_flicopen pour chaque fichier flac vous accéderez avec les routines de fichiers flic bas niveau (le nombre de fichiers flic vous pouvez avoir ouvert à un moment donné est limité par le spécificateur FICHIERS dans votre fichier CONFIG.SYS ). Le descripteur de contexte est ensuite transmis à d'autres routines pour accéder au fichier flac. En cas de succès, fg_flicopen remplit le descripteur de contexte, positionne le fichier flac à la première image, et renvoie zéro. le
les valeurs possibles de retour d'erreur sont -1 (fichier non trouvé) et -2 (le fichier est pas un FLI ou d'un fichier FLC).

La routine de fg_flicplay joue un ou plusieurs cadres à partir d'un fichier flac et
laisse le fichier placé au début de la trame suivante. Ses trois arguments sont les mêmes que pour fg_showflic sauf le premier argument est un descripteur de contexte au lieu d'un nom de fichier flac. Les progrès de routine fg_flicskip plus de cadres de fichiers. Flic Son premier argument est le contexte descripteur de fichier flac, et son second argument est le nombre d'images à sauter (si le nombre d'images est négative, la position du fichier est remis à la première image). Les deux routines renvoient le nombre d'images joué, ce qui peut être inférieur au nombre d'images demandées si le fichier de fin d'atteinte. dernière bas niveau FLIC routine, fg_flicdone de Fastgraph, ferme un fichier flac précédemment ouvert avec fg_flicopen. Son seul argument est le contexte descripteur du fichier flac.

Exemple 9-8 est similaire à l'exemple 9-6, mais il joue le fichier GLASS.FLI
une image à la fois à l'aide de bas niveau des routines de Fastgraph flic. Il ouvre le fichier flac avec fg_flicopen, qui renvoie un contexte descriptif de 16 octets pour le fichier. Si le fichier a été ouvert avec succès, le programme joue chaque trame en appelant fg_flicplay dans une boucle, en attente d'une frappe entre chaque trame (à noter que le masque de bits transmis à fg_flicplay a bit 0 ensemble, car il est généralement pas trop de sens pour retarder entre les cadres lors de la lecture des cadres individuellement). Finalement, nous arrivons à la fin de fichier, indiqué par une valeur de retour de fg_flicplay de zéro. Lorsque cela se produit, le programme appelle fg_flicdone et sort.

 Exemple 9-8.

 #include <fastgraf.h>
            #include <stdio.h>
           void main (void);

 void main (void)
            {
              int trames;
              statut int;
              contexte de char [16];

 fg_initpm ();
              fg_setmode (19);

 status = fg_flicopen ( "GLASS.FLI", contexte);
              if (état == 0) {
                  faire {
                    images = fg_flicplay (contexte, 1,1);
                    fg_waitkey ();
                     }
                 tandis que (cadres> 0);
                 fg_flicdone (contexte);
                  }

 fg_setmode (3);
              fg_reset ();

 if (état == -1)
                 printf ( "GLASS.FLI introuvable. \ n");
              else if (status == -2)   

 printf ( "GLASS.FLI est pas un FLI ou d'un fichier FLC. \ n");
            }


===Pixel Fichiers Run===

Fastgraph fournit également son propre format de fichier d'image en mode indépendant appelé
pixel Format exécuté. fichiers Pixel exécuter sont utiles dans les programmes qui doivent fonctionner dans différents modes vidéo (mais avec la même résolution) car vous pouvez utiliser les mêmes fichiers d'image pour les modes deux couleurs que pour les modes 256 couleurs. Deux variantes du format pixel d'exécution existent - fichiers standard pixel d'exécution (fichiers SPR) et les fichiers compressés de pixels exécuter (fichiers PPR). Le format pixel d'exécution emballé ne supporte pas les 256 images couleur mais produira un fichier plus petit si l'image a 16 couleurs ou moins. les fichiers de pixels exécuter ne comprennent pas un en-tête ou toute autre information de palette de couleurs.

La meilleure façon d'illustrer le format de fichier d'exécution de pixel est un exemple.
Supposons que nous voulons afficher un petit triangle dont le périmètre est une couleur différente de celle de son intérieur. Pour créer l'équivalent pixel d'exécution standard de cette image, nous devons inscrire le triangle dans une zone rectangulaire. Par conséquent, la représentation de pixel de notre triangle pourrait se présenter comme suit:

  .  .  .  . *.  .  .  .
                               .  .  . * X * .  .  .
                               .  . * Xxx *.  .
                               . * Xxxxx *.
                               * * * * * * * * *

Comme le montre ce diagramme, l'image de notre triangle est neuf pixels de large à son
base et cinq pixels de haut. Les pixels indiqués par un astérisque (*) sont le périmètre du triangle, tandis que celles qui sont indiquées par un x représentent ses points intérieurs. Les pixels affichés comme des périodes (.) Ne font pas partie du triangle lui-même, mais ils font partie de l'image. Dans cet exemple, nous pouvons les traiter comme des pixels de fond.

Si nous commençons dans le coin inférieur gauche de l'image et de passer à la
droit, nous pourrions représenter la première rangée de l'image comme neuf pixels de couleur "astérisque". Un tel groupe de pixels consécutifs de même couleur est appelé une course de pixels, donc un seul passage de pixel décrit la première ligne de l'image. La ligne ci-dessus celui-ci est un peu plus complexe. Il se compose de cinq points de pixels: un pixel de couleur "période", suivie par l'une des couleurs "astérisque", puis cinq de la couleur "x", l'une des couleurs "astérisque", et enfin l'une des couleurs «période».

Alors que nous pourrions construire séries de pixels séparés pour chaque ligne de l'image,
notez que trois des cinq lignes dans notre triangle commencent avec le même pixel de couleur que le pixel plus à droite de la rangée précédente. Les formats pixel d'exécution de Fastgraph vous permettent de tirer parti de cette propriété en permettant pixel pistes pour envelopper d'une rangée à l'autre. Cela signifie que nous pouvons représenter la course de pixel de couleur «période» étendant à partir du côté droit de la deuxième rangée sur le côté gauche de la troisième rangée en une seule série de trois pixels.

Une course de pixel standard (SPR) fichier est rien de plus qu'une telle séquence de
(Couleur, compter) paires, comme le montre le schéma ci-dessous.

 octet 0 couleur pour la course 1

 1 chef d'accusation pour la course 1

 2 couleurs pour la course 2

 3 compte pour la course 2



 2n-2 couleurs pour la course n

 2n-1 chef d'accusation pour la course n


Chaque couleur est une valeur entre 0 et 255 spécifiant l'index de couleur pour ce pixel terme. Chaque chef d'accusation est une valeur entre 0 et 255 spécifiant la longueur en pixels de ce pixel terme. Si un seul passage dépasse 255 pixels, il doit être divisé en deux ou plusieurs pistes. Par exemple, nous pourrions représenter une course de pixels de longueur 265 comme une course de longueur 255 suivie d'une course de longueur 10 de la même couleur. Notez que l'espace en octets nécessaires pour stocker une image SPR est deux fois le nombre de pistes.
fg_showspr affiche de routine de Fastgraph un fichier SPR. Son premier argument
est le nom du fichier contenant l'image (il peut inclure un nom de chemin). Le nom du fichier doit se terminer par un caractère nul, donc les programmeurs BASIC, FORTRAN et Pascal auront besoin de stocker un octet nul comme le dernier caractère de la chaîne de nom de fichier. Le second argument est la largeur en pixels de l'image. Les affichages de routine fg_showspr l'image de telle sorte que son coin inférieur gauche est à la position du curseur graphique. Les valeurs de retour possibles pour fg_showspr sont succès (0) et fichier non trouvé (1). Pour créer un fichier SPR, utilisez la routine fg_makespr. Ses arguments et les valeurs de retour sont les mêmes que pour fg_makepcx et fg_makegif.

Exemple 9-9 utilise fg_showspr et fg_makespr pour créer un nouveau fichier SPR à partir
lignes sélectionnées d'un 16-couleur fichier 320x200 SPR existant. Semblable à des exemples 9-1 et 9-4, le programme utilise le fichier CORAL.SPR pour créer NEW.SPR, mais il pourrait facilement être étendu à travailler avec tous les fichiers SPR. L'appel à fg_move établit le coin inférieur gauche de l'écran que la position du curseur graphique (contraste avec le coin supérieur gauche étant le point PCX, GIF et flic référence). Le programme appelle ensuite fg_showspr pour afficher l'image. Après avoir attendu pendant une séquence de touches, le programme appelle fg_makespr pour créer un fichier SPR nommé NEW.SPR de rangées de pixels 80 à 99 de l'image originale. Dans le cas où le programme rencontre des problèmes, il affiche un message d'erreur avant de quitter.

 Exemple 09.09.

 #include <fastgraf.h>
            #include <stdio.h>
            #include <stdlib.h>
           void main (void);

 void main ()   

  {
              int new_mode, old_mode;
              int READ_STATUS, write_status;

 fg_initpm ();
              new_mode = fg_bestmode (320,200,1);
              if (new_mode <0 || new_mode == 12) {
                 printf ( "Ce programme nécessite une 320");
                 ( "le mode x 200 graphiques couleur \ n".) printf;
                 sortie (1);
                  }
              fg_getmode old_mode = ();
              fg_setmode (new_mode);
              fg_move (0199);

 READ_STATUS = fg_showspr ( "CORAL.SPR", 320);
              fg_waitkey ();
              si (== READ_STATUS 0)
                 write_status = fg_makespr (0,319,80,99, "NEW.SPR");
               autre
                 write_status = 1;

 fg_setmode (old_mode);
              fg_reset ();

 si (== READ_STATUS 1)
                 printf ( "CORAL.SPR introuvable. \ n");
              if (write_status == 1)
                 printf ( "NEW.SPR pas créé. \ n");
            }


Si vous avez une image qui utilise uniquement les 16 premiers indices de couleur (0 à 15),
vous pouvez utiliser emballés piste de pixel (PPR) le format d'image de Fastgraph. Ce format emballe deux valeurs de couleur dans chaque octet de couleur, donc il faut trois octets au lieu de quatre pour représenter deux séries de pixels. Cela signifie un fichier PPR est 25% plus petit que son équivalent de SPR. Dans chaque série de trois octets, les quatre bits de poids fort du premier octet contiennent la couleur de la première manche, et les quatre bits de poids faible contiennent la couleur de la deuxième manche. Le deuxième octet contient la longueur de la première manche, et le troisième octet contient la longueur de la deuxième manche.

Le schéma suivant illustre la structure du fichier de pixel emballé.

Dans cet exemple, le fichier est supposé contenir n pixels pistes, où n est un nombre pair. Si n est impair, l'octet de décalage pour le dernier élément est 3n / 2 (tronquée) au lieu de 3n / 2-1, et les quatre bits de poids faible du dernier octet de couleur (qui est, la couleur de pixel run n + 1) sont ignorés.

 7 4 3 0

 octet 0 couleur pour la course 1 couleur pour la course 2

 1 chef d'accusation pour la course 1

 2 compte pour la course 2

 3 couleurs pour la course 3 couleurs pour la course 4   
                                                Chapitre 9: Image Fichiers 199


 4 compte pour la course 3

 5 compte pour la course 4



 3n 2-3 couleur / pour la course n-1 couleur pour la course n

 3n 2-2 comte / pour la course n-1

 3n count / 2-1 pour la course n


La structure du fichier PPR permet des valeurs de couleur entre 0 et 15,
et exécuter des longueurs entre 0 et 255. L'espace en octets nécessaires pour stocker une image au format PPR est de 1,5 fois le nombre de pistes, par rapport à deux fois le nombre de pistes pour le format SPR.

L'affichage fg_showppr et fg_makeppr routines et créer des fichiers PPR,
respectivement.Leurs arguments et les valeurs de retour sont les mêmes que celles de fg_showspr et fg_makespr. Si nous voulions afficher les fichiers PPR au lieu de fichiers SPR dans l'exemple 9-9, tout ce qui est nécessaire est en train de changer le fg_showspr et fg_makespr appelle à fg_showppr et fg_makeppr.

fg_dispfile affiche de routine à la fois SPR et PPR dossiers de Fastgraph.  le
premier de ses trois arguments est le nom du fichier image (il peut inclure un nom de chemin). Le nom du fichier doit se terminer par un caractère nul, donc les programmeurs BASIC, FORTRAN et Pascal auront besoin de stocker un octet nul comme le dernier caractère de la chaîne de nom de fichier. Le second argument est la largeur de l'image en pixels, et le troisième argument définit le format d'image (qui est, SPR ou PPR). Comme avec d'autres routines d'affichage pixel de l'exécution, fg_dispfile affiche l'image de telle sorte que son coin inférieur gauche est à la position du curseur graphique.

Exemple 9-10 montre comment utiliser fg_dispfile pour afficher une image
stockée dans un fichier pixel de l'exécution. Le programme affiche deux images identiques, l'un dans un fichier SPR et l'autre dans un fichier PPR. Chaque image est une image du fond de la mer et certains coraux, comme on pourrait être utilisé pour l'arrière-plan dans un aquarium. Le programme fonctionne dans un mode graphique 320x200, et les images de remplir tout l'écran.

L'image SPR est dans le fichier CORAL.SPR. Le programme fg_move utilise pour établir
le coin inférieur gauche de l'écran comme la position graphique du curseur et appelle ensuite fg_dispfile pour afficher l'image. La valeur du troisième argument de fg_dispfile dit Fastgraph le format d'image. Une valeur de 0 indique que le fichier contient une image au format SPR, tandis qu'une valeur de 1 indique une image au format PPR. Comme mentionné précédemment, l'image remplit tout l'écran, de sorte que sa largeur est de 320 pixels.

Après avoir attendu pendant une séquence de touches, le programme efface l'image précédente de
l'écran et appelle ensuite fg_dispfile pour afficher l'image PPR à partir du fichier CORAL.PPR. Le programme laisse la deuxième image sur l'écran jusqu'à ce qu'un autre keypress, au moment où il restaure le mode vidéo et écran attributs et retours originaux à DOS. Guide de l'utilisateur 200 Fastgraph


 Exemple 9-10.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int old_mode, new_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_move (0199);
                   fg_dispfile ( "CORAL.SPR", 320,0);
                   fg_waitkey ();

 fg_erase ();
                   fg_dispfile ( "CORAL.PPR", 320,1);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


L'utilitaire INSTANTANÉ distribué avec Fastgraph est une fin et rester
programme résident (TSR) qui peut capturer des images d'écran en mode graphique et de les enregistrer dans des fichiers SPR. Ainsi, vous pouvez facilement créer des fichiers avec INSTANTANÉ et les afficher avec fg_showspr ou fg_dispfile. Un autre utilitaire TSR, GrabRGB, est utile pour capturer les valeurs des couleurs RVB à partir d'images de 256 couleurs. L'annexe A contient une description complète des utilitaires INSTANTANÉ et GrabRGB.


===Afficher Patterns===

Exemple 9-10 fonctionne bien dans les modes graphiques vidéo avec 16 ou 256
couleurs disponibles. Cependant, dans les quatre couleurs CGA graphiques modes de l'image résultante est pas trop bon à cause de nos choix de couleurs limitées, et ce sera encore pire dans le mode graphique Hercules. La fg_pattern routine Fastgraph vous permet d'associer un motif de tramage (en fait, toute séquence de pixels) avec l'un des 256 indices de couleur de Fastgraph apparaissant dans une carte pixel de l'exécution. Lors de l'affichage d'un fichier SPR ou PPR, Fastgraph utilisera le modèle associé à cet indice de couleur au lieu d'afficher la couleur elle-même.

La routine fg_pattern nécessite deux arguments entiers - un indice de couleur
(Entre 0 et 255) et le motif d'affichage défini pour que l'indice de couleur. La structure d'un motif d'affichage ressemble à la structure de la mémoire vidéo, et est donc dépendant du mode vidéo en cours. Les sections suivantes répertorient les modes d'affichage initiaux et expliquent comment construire de nouveaux modèles d'affichage pour différents modes graphiques vidéo.
modes quatre couleurs graphiques CGA

Dans les modes graphiques quatre couleurs CGA (modes 4 et 5), le motif d'affichage
se compose d'un compteur de décalage de 8 bits suivi d'un motif de pixels de 8 bits. Chaque pixel prend une valeur comprise entre 0 et 3, de sorte que le motif représente quatre pixels. En rangées de pixels numérotées paires, Fastgraph utilise le motif de pixel lui-même. Dans impaires rangées de pixels, Fastgraph fait tourner le modèle original à la gauche du nombre de bits spécifié par le nombre de changement de vitesse.

Par exemple, si nous utilisons la valeur par défaut CGA palette de couleurs, nous pourrions
créer une teinte plus foncée de cyan en alternant pixels cyan (couleur 1, 01 binaire) avec des pixels blancs (couleur 3, 11 binaires), comme indiqué ici:


  01 11 01 11


Si nous convertissons ce modèle de pixel à son équivalent hexadécimal, on obtient la valeur 77.

Pour compléter le modèle d'affichage, il faut déterminer le nombre de changement de vitesse.  Si
nous utilisons un compte de décalage de zéro, l'affichage résultant sera simplement une série de cyan et des lignes verticales blanches. Ce que nous avons vraiment besoin est un effet de damier où un pixel blanc est au-dessus et en dessous de chaque pixel cyan, et vice versa.Si nous faisons tourner le motif d'un pixel (deux bits) vers la gauche, nous allons obtenir l'effet désiré. Autrement dit, un compteur de décalage de deux produit des motifs de pixels suivants:

 lignes paires 01 11 01 11
                       lignes impaires 11 01 11 01

Combinant le compte de décalage avec le motif de pixels donne le motif d'affichage 0277 hex. Le comptage de décalage est normalement un multiple de deux; Notez qu'un zéro des résultats de comptage de décalage dans le même motif étant appliqué à toutes les lignes de pixels.

Pour les modes de quatre couleurs graphiques les CGA, fg_setmode établit la
motifs d'affichage initiaux suivants:

 couleur compte de décalage hexadécimal
                      index et modèle équivalent

 0 0 00000000 0000
                        1 0 01010101 0055
                        2 0 10101010 00AA
                        3 0 11111111 00FF

Ces valeurs sont répétées comme nécessaire de définir des indices de couleur 4 à 255. Autrement dit, couleurs 4, 8, 12, ..., 252 utilisent les mêmes valeurs par défaut que la couleur 0. Couleurs 5, 9, 13, ..., 253 utilisation les mêmes défauts que la couleur 1, et ainsi de suite. A noter également que le Guide 202 Fastgraph utilisateur
modèle 0000 représente quatre pixels de couleur 0, 0055 représente quatre pixels de couleur 1, 00AA représente quatre pixels de couleur 2, et 00FF représente quatre pixels de couleur 3.

====CGA mode deux graphiques en couleur====

Dans le mode graphique en deux couleurs CGA (mode 6), le motif d'affichage aussi
se compose d'un compteur de décalage de 8 bits suivi d'un motif de pixels de 8 bits. Chaque pixel prend la valeur 0 ou 1, de sorte que le motif représente huit pixels. En rangées de pixels numérotées paires, Fastgraph utilise le motif de pixel lui-même. Dans impaires rangées de pixels, Fastgraph fait tourner le modèle original à la gauche du nombre de bits spécifié par le nombre de changement de vitesse.

Par exemple, nous pourrions créer une nuance de blanc en alternant
pixels noirs (couleur 0) avec des pixels blancs (couleur 1), comme montré ici:


 0 1 0 1 0 1 0 1


Si nous convertissons ce modèle de pixel à son équivalent hexadécimal, on obtient la valeur 55.

Pour compléter le modèle d'affichage, il faut déterminer le nombre de changement de vitesse.  nous
doit faire pivoter le motif d'un pixel (un bit) vers la gauche pour obtenir l'effet de damier, comme dans les modes graphiques CGA quatre couleurs. Autrement dit, un nombre de décalage d'un produit des motifs de pixels suivants:

 lignes paires 0 1 0 1 0 1 0 1
                     lignes impaires 1 0 1 0 1 0 1 0

Combinant le compte de décalage avec le motif de pixels donne le motif d'affichage 0155 hex.

Pour le mode deux couleurs graphiques CGA, fg_setmode établit la première
motifs d'affichage de telle sorte que tous les indices de couleur à numérotation paire sont affectées à la valeur 0000, alors que tous les indices de rang impair couleur sont affectés de la valeur 00FF. Notez que modèle 0000 représente huit pixels de couleur 0, et 00FF représente huit pixels de couleur 1.
mode 16 graphique couleur Tandy / PCjr

Dans le mode 16-graphique couleur Tandy / PCjr (mode 9), le motif d'affichage
consiste également en un compteur à décalage à 8 bits suivi d'un motif de pixels de 8 bits. Chaque pixel prend une valeur comprise entre 0 et 15, de sorte que le motif représente deux pixels. En rangées de pixels numérotées paires, Fastgraph utilise le motif de pixel lui-même. Dans impaires rangées de pixels, Fastgraph fait tourner le modèle original à la gauche du nombre de bits spécifié par le nombre de changement de vitesse.

Par exemple, nous pourrions créer une nuance de bleu en alternant bleu
pixels (couleur 1, 0001 binaire) avec des pixels blancs (couleur 15, 1111 binaires), comme indiqué ici:


 0001 1111   
                                                Chapitre 9: Image Fichiers 203


Si nous convertissons ce modèle de pixel à son équivalent hexadécimal, nous obtenons la valeur 1F.

Pour compléter le modèle d'affichage, il faut déterminer le nombre de changement de vitesse.
en utilisant le même processus que dans les modes les graphiques CGA, il faut faire pivoter le motif d'un pixel (quatre bits) vers la gauche pour obtenir l'effet de damier. Autrement dit, un compteur de décalage de quatre donne les motifs de pixels suivants:

 lignes paires 0001 1111
                        lignes impaires 1111 0001

Combinant le compte de décalage avec le motif de pixels donne le motif d'affichage 041F hex. Le nombre de changement de vitesse est normalement zéro ou quatre; Notez qu'un zéro des résultats de comptage de décalage dans le même motif étant appliqué à toutes les lignes de pixels.

Pour les modes graphiques 16-couleur Tandy / PCjr, fg_setmode établit la
motifs initiaux d'affichage de telle sorte que la couleur 0 est attribuée la valeur 0000 (deux pixels de couleur 0), la couleur 1 reçoit la valeur 0011 (deux pixels de couleur 1), la couleur 2 reçoit la valeur 0022 (deux pixels de 2 couleurs), et ainsi de suite. Ces valeurs sont répétées comme nécessaire de définir des indices de couleur 16 à 255. C'est, les couleurs 0, 16, 32, ..., 240 utilisent les mêmes valeurs par défaut que la couleur 0. Couleurs 1, 17, 33, ..., 241 utilisation les mêmes défauts que la couleur 1, et ainsi de suite.
modes graphiques Hercules

La structure des modèles d'affichage pour les modes les graphiques Hercules
(modes 11 et 12) est le même que deux des modes les graphiques CGA. Pour le mode graphique Hercules standard (mode 11), se référer à la discussion des CGA deux couleurs (mode 6) des modèles d'affichage. Pour le Hercules mode graphique basse résolution (mode 12), se référer à la discussion des quatre couleurs CGA (mode 4) des modèles d'affichage.
modes / VGA / SVGA 16 couleurs graphiques EGA

Dans les modes les EGA / VGA / SVGA 16 couleurs graphiques (modes 13 à 16, 18, 28 et
29), le motif d'affichage se compose de deux valeurs de couleur de 4 bits (par souci de cohérence avec les autres modes vidéo, nous passons toujours le motif d'affichage comme une quantité de 16 bits ou 32 bits). Chaque pixel prend une valeur comprise entre 0 et 15 (0 et 5 en mode graphique monochrome EGA), de sorte que le motif représente deux pixels. En même- rangées de pixels numérotées, Fastgraph utilise le motif de pixel lui-même. Dans les lignes de pixels impaires, Fastgraph fait pivoter le motif initial d'un pixel (quatre bits) vers la gauche.

Par exemple, nous pourrions créer une nuance de bleu en alternant bleu
pixels (couleur 1, 0001 binaire) avec des pixels blancs (couleur 15, 1111 binaires), comme indiqué ici:


 0001 1111


Si nous convertissons ce modèle de pixel à son équivalent hexadécimal, nous obtenons la valeur 1F. Le compte de décalage à quatre bits implicite produit les motifs de pixels suivants: Guide de l'utilisateur 204 Fastgraph


 lignes paires 0001 1111
                        lignes impaires 1111 0001

Extension du motif de pixels à une quantité de 16 bits ou 32 bits donne le motif d'affichage 001F hex.

Pour les modes graphiques 16 couleurs les EGA / VGA / SVGA, fg_setmode établit la
motifs initiaux d'affichage de telle sorte que la couleur 0 est attribuée la valeur 0000 (deux pixels de couleur 0), la couleur 1 reçoit la valeur 0011 (deux pixels de couleur 1), la couleur 2 reçoit la valeur 0022 (deux pixels de 2 couleurs), et ainsi de suite. Ces valeurs sont répétées comme nécessaire de définir des indices de couleur 16 à 255. C'est, les couleurs 0, 16, 32, ..., 240 utilisent les mêmes valeurs par défaut que la couleur 0. Couleurs 1, 17, 33, ..., 241 utilisation les mêmes défauts que la couleur 1, et ainsi de suite.

====MCGA / VGA mode graphique 2 couleurs====

Dans le MCGA / mode graphique VGA à deux couleurs (mode 17), le motif d'affichage
se compose de deux valeurs de couleur de 1 bit (par souci de cohérence avec les autres modes vidéo, nous passons toujours le motif d'affichage comme une quantité de 16 bits ou 32 bits). Chaque pixel prend la valeur 0 ou 1, de sorte que le motif représente deux pixels. En même- rangées de pixels numérotées, Fastgraph utilise le motif de pixel lui-même. Dans les lignes de pixels impaires, Fastgraph fait tourner le modèle original d'un pixel (un bit) vers la gauche.

Par exemple, nous pourrions créer une nuance de blanc en alternant
pixels noirs (couleur 0) avec des pixels blancs (couleur 1), comme montré ici:


 0 1


Si nous convertissons ce modèle de pixel à son équivalent hexadécimal, nous obtenons la valeur 01. Le nombre de décalage d'un bit implicite produit les motifs de pixels suivants:

 lignes paires 0 1
                           lignes impaires 1 0

Extension du motif de pixels à une quantité de 16 bits ou 32 bits donne le motif d'affichage 0001 hex.

Pour le mode deux couleurs graphique VGA / MCGA, fg_setmode établit la
les modèles d'affichage initiaux de telle sorte que tous les indices de couleur à numérotation paire sont affectées à la valeur 0000 (deux pixels de couleur 0), tandis que tous les indices de rang impair couleur sont affectés de la valeur 0003 (11 binaire ou deux pixels de la couleur 1).

====modes graphiques 256 couleurs====

Les modes graphiques 256 couleurs (modes 19 à 27) offrent 262144
couleurs différentes, de sorte que le tramage est rarement (voire jamais) nécessaires. Pour cette raison, fg_pattern n'a pas d'effet dans ces modes vidéo.

Un exemple

Exemple 9-11 illustre l'utilisation de motifs d'affichage dans plusieurs graphiques
modes. Ce programme fonctionne dans un mode graphique couleur 320x200 et affiche l'image CORAL.PPR avec un ou plusieurs des indices de couleur redéfinie. Si le programme fonctionne dans le CGA mode quatre couleurs standard (mode 4), il redéfinit les 16 premiers motifs d'affichage en utilisant la routine fg_pattern et les valeurs dans le tableau CGApatterns. Dans le mode Tandy / PCjr 16 couleurs graphiques (mode 9) et le mode graphique basse résolution EGA (mode 13), le programme redéfinit l'indice de couleur 15 pour produire un motif de tramage gris et blanc en alternance. Dans le MCGA 256- mode couleur (mode 19), les modèles d'affichage ne sont pas disponibles, de sorte que le programme fg_setrgb utilise pour définir l'indice de couleur 15 comme légèrement teinte plus foncée de gris que la valeur par défaut pour la couleur 7.

 Exemple 9-11.

 #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
               void main (void);

 int CGApatterns [] = {
                  0x0000,0x00FF, 0x00FF, 0x00FF,
                  0x02BB, 0x0000,0x0222,0x0255,
                  0x00FF, 0x00FF, 0x00FF, 0x0055,
                  0x00AA, 0x00AA, 0x00FF, 0x0277
                   };

 void main ()
                {
                  Couleur int;
                  int old_mode, new_mode;

 fg_initpm ();
                  new_mode = fg_bestmode (320,200,1);
                  if (new_mode <0 || new_mode == 12) {
                     printf ( "Ce programme nécessite une 320");
                     ( "le mode x 200 graphiques couleur \ n".) printf;
                     sortie (1);
                      }

 fg_getmode old_mode = ();
                  fg_setmode (new_mode);

 if (new_mode == 4) {
                     fg_palette (0,0);
                     pour (couleur = 0; couleur <16; couleur ++)
                        fg_pattern (couleur, CGApatterns [color]);
                      }
                  else if (new_mode == 9 || new_mode == 13)
                     fg_pattern (15,0x04F7);
                   autre
                     fg_setrgb (15,38,38,38);

 fg_move (0199);
                  fg_showppr ( «CORAL.PPR», 320); 

 fg_waitkey ();

 fg_setmode (old_mode);
                  fg_reset ();
                }


===Contrôle de l'image Buffer Size===

Par défaut, tous affichage du fichier image et de création de routines de Fastgraph
utiliser un tampon 4096 octets interne. Ce tampon fournit une zone de stockage intermédiaire, ce qui permet d'effectuer plus efficace tamponnée I / O lors de la lecture ou l'écriture des fichiers d'image. La routine de fg_imagebuf vous permet de définir votre propre tampon à cet effet (la taille du tampon est limitée à 64K octets en mode réel et en mode protégé 16 bits). Grandes tampons font généralement l'affichage de l'image et la création plus rapide. Cela est particulièrement vrai en mode protégé et lors de la lecture des fichiers flic. Appel fg_setmode réinitialise le tampon de fg_imagebuf à sa taille 4K par défaut.

La routine de fg_imagebuf ne pas allouer le stockage de l'interne
tampon. Au contraire, il définit simplement le tableau ou allouée dynamiquement bloc de mémoire à utiliser comme tampon. Le premier argument passé à fg_imagebuf est l'adresse de ce bloc de tableau ou de la mémoire, et le second argument est la taille de la mémoire tampon interne en octets, représentée comme un entier non signé. Dans les modes 32 bits, l'adresse est passé comme un proche de pointeur ordinaire, tandis que dans les modes 16 bits, il est passé comme un pointeur loin (segmenté). Fastgraph utilise un pointeur loin dans les modes 16 bits pour éviter de gaspiller l'espace précieux dans le segment de données par défaut, et il entraîne presque toujours la possibilité d'utiliser un tampon plus grand. Dans les programmes Pascal en mode réel, l'espace pour le buffer interne doit être allouée de façon dynamique à la procédure GetMem car elle fournit la seule façon de transmettre quelque chose par référence loin dans Pascal. programmes Pascal en mode protégé peuvent utiliser GetMem ou la fonction GlobalAllocPtr d'allouer la mémoire tampon. programmes BASIC doivent passer le tampon d'image en tant que chaîne de longueur fixe.

Exemple 9-12 montre comment utiliser fg_imagebuf pour définir un tampon plus grand lorsque
afficher le fichier CORAL.PCX. Dans cet exemple, nous allons utiliser un tableau statique 20,000 octets comme le tampon d'image. Cette taille a été choisie car elle est plus grande que la taille du fichier PCX, alors fg_showpcx peut lire le fichier PCX ensemble en une seule passe.

 Exemple 9-12.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 #ifdef FG32
                char buffer [20000];
                 #autre
                carboniser loin tampon [20000];
                 #fin si

 void main ()
                 {
                   int old_mode; 
                                                Chapitre 9: Image Fichiers 207


 fg_initpm ();
                   if (fg_testmode (19,1) == 0) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques MCGA \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (19);
                   fg_imagebuf (tampon, 20000);
                   fg_showpcx ( "CORAL.PCX", 0);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


Vous ne devez pas créer des tampons séparés pour chaque image que vous affichez ou

Créer. Une fois que vous définissez un tampon d'image interne avec fg_imagebuf, Fastgraph utilisera ce tampon jusqu'à ce que votre programme se termine, ou jusqu'à ce que vous appelez fg_imagebuf avec une taille de tampon égal à zéro.

Il est également possible d'afficher PCX, GIF et images FLI / FLC directement à partir de
le tampon pointé par fg_imagebuf. Cela peut être très utile, par exemple, lorsque nous avons besoin d'afficher plusieurs fois le même fichier d'image parce que nous ne lisons le fichier à partir du disque une fois. Pour ce faire, le bit 2 du paramètre flags lors de l'utilisation PCX, GIF, ou FLI / FLC routines d'affichage d'image de Fastgraph. Ceci indique Fastgraph pour récupérer les données d'image provenant de la mémoire tampon de fg_imagebuf plutôt qu'à partir du fichier lui-même. Dans les applications en mode protégé, en utilisant cette méthode fournit habituellement de meilleures performances, en particulier lors de l'affichage des fichiers FLI ou FLC. Exemple 9-13 montre comment afficher une image PCX stockée dans la mémoire tampon de fg_imagebuf.

 Exemple 9-13.

 #include <fastgraf.h>
              #include <io.h>
               #include <stdio.h>
               #include <stdlib.h>
              void main (void);

 #ifdef FG32
              char buffer [20000];
               #autre
              carboniser loin tampon [20000];
               #fin si

 void main ()
               {
                 int file_size;
                 int old_mode;
                  * FILE stream;

 fg_initpm ();
                 if (fg_testmode (19,1) == 0) {   

 printf ( "Ce programme nécessite une 320");
                    ( "le mode x 200 graphiques MCGA \ n".) printf;
                    sortie (1);
                     }

 flux = fopen ( "CORAL.PCX", "rb");
                 file_size = (int) (filelength (fileno (flux)));
                 fread (tampon, 1, file_size, flux);
                 fclose (flux);

 fg_getmode old_mode = ();
                 fg_setmode (19);

 fg_imagebuf (tampon, file_size);
                 fg_showpcx ( "", 4);
                 fg_waitkey ();

 fg_setmode (old_mode);
                 fg_reset ();
               }


Dans l'exemple 9-13, nous utilisons un tableau de 20.000 octets pour le tampon de fg_imagebuf.

Le réseau utilisé avec fg_imagebuf doit être suffisante pour maintenir le fichier image toute grande. Notez que nous passons la taille réelle du fichier à fg_imagebuf (dans cet exemple, nous supposons que la taille du fichier ne dépasse pas 20.000 octets). Il est crucial que vous spécifiez la taille réelle du fichier lors de l'affichage de 256 couleurs fichiers PCX donc Fastgraph peut localiser l'étendue (256 couleurs) les données de la palette qui pourraient suivre les données d'image. Vous devez également spécifier la taille réelle du fichier lors de l'utilisation de bas niveau des routines de soutien de Fastgraph flic jouer images flic de la mémoire tampon de fg_imagebuf. Pour les autres types de fichiers d'images, nous pouvons spécifier la taille du fichier ou la taille du tampon.

Il est pas nécessaire de passer un nom de fichier pour les routines d'affichage d'image si
les données d'image réside dans le tampon de fg_imagebuf. En d'autres termes, les routines d'affichage d'image ignorer l'argument de nom de fichier lorsque le bit 2 de l'argument flags est réglé. Cependant, vous devez toujours inclure un argument "lieu de titulaire", où l'on pourrait attendre d'un nom de fichier. Nous vous recommandons d'utiliser la chaîne vide comme dans l'appel fg_showpcx d'exemple 9-13, bien que toute chaîne peut être utilisée à la place.

La taille maximale du fichier d'image, nous pouvons afficher à partir du fg_imagebuf
le tampon est bien sûr limitée à la taille du tampon. Bien que ce soit pas en cause dans le mode 32 bits protégé, il n'impose une restriction importante en mode réel et en mode protégé 16 bits. La taille de la mémoire tampon de fg_imagebuf est limitée à 64K octets dans des environnements 16 bits, ce qui signifie cette fonction ne concerne que les fichiers d'image qui sont 64K ou moins si vous utilisez le mode réel ou en mode protégé 16 bits.


===Résumé des Routines de fichier image===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph. Les fonctions d'affichage d'image et de création appliquent uniquement aux modes graphiques vidéo.

FG_DISPFILE affiche une image stockée dans une course de pixel standard ou emballé
fichier. L'image est positionnée de sorte que son coin inférieur gauche est à la position graphique actuelle.

FG_FLICDONE ferme le fichier flac associé au contexte spécifié
descripteur.

FG_FLICHEAD lit un en-tête de fichier flac dans un tampon de 128 octets.

FG_FLICMODE détermine le mode vidéo optimal pour l'image FLIC
associé à l'en-tête de fichier flac spécifié. Le mode optimal est le mode 256- graphique de couleur ayant la plus basse résolution est supérieure ou égale aux dimensions de l'image.

FG_FLICOPEN ouvre un fichier flac pour un traitement ultérieur par Fastgraph de
autres bas niveau fichier flac routines de soutien. En cas de succès, le pointeur de fichier sera positionné au début de la première image.

FG_FLICPLAY affiche les prochains un ou plusieurs images dans un fichier flac
précédemment ouvert avec fg_flicopen.

FG_FLICSIZE renvoie les dimensions de l'image associée à la FLIC
spécifiée tête du fichier flac.

FG_FLICSKIP avance un ou plusieurs cadres dans un fichier flac précédemment ouvert
avec fg_flicopen. Si la dernière image joué par fg_flicplay affiche le cadre de la mémoire tampon de fg_imagebuf, la position du cadre sera ajusté dans le tampon de fg_imagebuf. Dans le cas contraire, la position du fichier flac lui-même sera ajusté.

FG_GIFHEAD lit tête global du fichier GIF et premier en-tête locale en
un tampon de 23 octets.

FG_GIFMODE détermine le mode vidéo optimal pour l'affichage d'un fichier GIF.
Le mode optimal est le mode vidéo ayant la résolution la plus basse est supérieure ou égale aux dimensions de l'image.

FG_GIFPAL récupère la palette d'une image stockée dans un fichier GIF.  le
les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chaque entre 0 et 63. Si le fichier GIF comprend une palette locale pour la première image, fg_gifpal retourne les valeurs de la palette locale. Sinon, fg_gifpal retourne les valeurs de la palette globale du fichier GIF.

FG_GIFRANGE retourne les étendues d'image pour l'image GIF associée à
l'en-tête de fichier GIF spécifié.

FG_IMAGEBUF spécifie la taille et l'adresse du tampon utilisé en interne
lors de la création ou l'affichage GIF, les fichiers PCX, FLI / FLC ou SPR / PPR. interne par défaut tampon taille Fastgraph est 4096 octets. l'affichage ou la création image est généralement plus rapide quand un tampon plus grand est utilisé, en particulier en mode protégé ou lors de la lecture des fichiers flic. Dans des environnements de 16 bits, la taille de la mémoire tampon de fg_imagebuf est limitée à 64K octets.

FG_LOADPCX charge une image PCX dans la mémoire tampon virtuelle active. 
Guide de l'utilisateur 210 Fastgraph

FG_MAKEGIF crée un fichier GIF à partir de la zone rectangulaire spécifiée
la page vidéo active ou tampon virtuel. Les extrêmes de la région sont exprimés en unités d'espace d'écran. Cette routine est significatif que dans 16 couleurs et 256- modes graphiques de couleurs.

FG_MAKEPCX crée un fichier PCX de la région rectangulaire spécifiée
la page vidéo active ou tampon virtuel. Les extrêmes de la région sont exprimés en unités d'espace d'écran.

FG_MAKEPPR crée un fichier pixel d'exécution emballé à partir de la forme rectangulaire spécifiée
région de la page vidéo active ou tampon virtuel. Les extrêmes de la région sont exprimés en unités d'espace d'écran.

FG_MAKESPR crée un fichier standard pixel de l'exécution de la spécifiée
zone rectangulaire de la page vidéo active ou tampon virtuel. Les extrêmes de la région sont exprimés en unités d'espace d'écran.

FG_PATTERN définit un modèle d'affichage pour une utilisation lors de l'affichage pixel run
fichiers en mode vidéo qui offrent 16 ou moins de couleurs.

FG_PCXHEAD lit un en-tête de fichier PCX dans un tampon de 128 octets.

FG_PCXMODE détermine le mode vidéo optimal pour l'affichage d'un fichier PCX.
Le mode optimal est le mode vidéo compatible avec la résolution la plus basse est supérieure ou égale aux dimensions de l'image.

FG_PCXPAL extrait la palette d'une image stockée dans un fichier PCX, et
nombre de couleurs dans la palette. Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chaque entre 0 et 63. Si le fichier PCX comprend un (256 couleurs) palette étendue, fg_pcxpal retourne les valeurs dans la palette étendue. Sinon, fg_pcxpal retourne les valeurs de la palette de 16 couleurs dans l'en-tête de PCX.

FG_PCXRANGE retourne les étendues d'image pour l'image PCX associée à
l'en-tête de fichier PCX spécifié.

FG_SHOWGIF affiche une image stockée dans un fichier GIF.

FG_SHOWFLIC affiche une image stockée dans un FLI ou d'un fichier FLC (collectivement
appelé fichiers CIDF).

FG_SHOWPCX affiche une image stockée dans un fichier PCX.

FG_SHOWPPR affiche une image stockée dans un fichier pixel d'exécution emballé. L'image
sera positionné de sorte que son coin inférieur gauche est à la position du curseur graphique de la page vidéo active ou tampon virtuel.

FG_SHOWSPR affiche une image stockée dans un fichier pixel d'exécution standard.  le
image sera positionnée de sorte que son coin inférieur gauche est à la position du curseur graphique de la page vidéo active ou tampon virtuel.


==Images bitmap==

Dans ce chapitre, nous allons continuer notre discussion sur les images en se concentrant
sur une classe importante d'images appelées images bitmap. Fastgraph comprend des routines pour afficher, récupérer et manipuler des images bitmap dans des formats mode- spécifiques et en mode indépendant. Ce chapitre traitera des routines Fastgraph qui traitent avec les deux catégories d'images bitmap.

Affichage des images bitmap est un élément essentiel de l'animation avec
Fastgraph. Alors que les fichiers d'image décrits dans le chapitre précédent sont utiles pour l'affichage de milieux ou d'importer des images à partir d'autres sources, une séquence d'animation ne peut atteindre sa vitesse à travers les routines d'affichage d'image bitmap décrites dans ce chapitre, ainsi que les programmes de transfert de bloc du chapitre suivant .


===Mode indépendant Images bitmap===

Cette section discutera des routines d'affichage d'image qui utilisent le même
format d'image bitmap pour tous les modes graphiques vidéo. Une autre classe de routines, décrit dans la section suivante, utilisez des formats différents pour différents modes vidéo. Bien que ces routines d'affichage d'image en mode indépendant sont plus généraux, ils atteignent cette généralité à la cause de la vitesse d'exécution. Cela peut notamment être un problème si l'image est grande, ou si la vitesse est essentielle dans une application (comme dans les graphiques de style arcade). Pour de nombreux programmes, cependant, les routines de mode indépendant offrent toutes les capacités d'affichage d'image est nécessaire.
    
Commençons par revenir à un exemple d'une image très simple - la
triangle introduit dans le chapitre précédent:

  .  .  .  . *.  .  .  .
                               .  .  . * X * .  .  .
                               .  . * Xxx *.  .
                               . * Xxxxx *.
                               * * * * * * * * *

Rappelons que le périmètre du triangle est une couleur différente de celle de ses pixels intérieurs, et d'utiliser cette image avec Fastgraph, nous devons inscrire le triangle dans une zone rectangulaire. Comme précédemment, notre triangle est neuf pixels de large à sa base et de cinq pixels de haut. Les pixels indiqués par un astérisque (*) sont le périmètre du triangle, tandis que celles qui sont indiquées par un x représentent ses points intérieurs. Nous devons faire la distinction entre ces pixels, car ils seront différentes couleurs. Les pixels affichés comme des périodes (.) Ne font pas partie du triangle lui-même. Ils sont nécessaires pour rendre l'image rectangulaire, donc du point de vue Fastgraph ils sont en effet partie de l'image.

La fg_drawmap routine Fastgraph est une routine appropriée pour attirer notre
triangle.Pour utiliser fg_drawmap, nous devons créer des bitmaps séparés pour chaque couleur dans l'image (à l'exception des points utilisés pour remplir la zone rectangulaire, qui sont considérées comme transparentes). Dans cet exemple, nous allons donc besoin de deux bitmaps - un pour les points de périmètre, et un pour les points intérieurs. Brisons l'image dans ces deux bitmaps.

  .  .  .  . *.  .  .  .  .  .  .  .  .  .  .  .  .
                  .  .  .*. *. .  .  .  .  .  . X .  .  .  .
                  .  . *.  .  . *.  .  .  .  . xxx.  .  .
                  . *.  .  .  .  . *.  .  . xxxxx.  .
                 * * * * * * * * *.  .  .  .  .  .  .  .  .

 souligne périmètre points intérieurs

L'étape suivante consiste à convertir ces deux bitmaps dans leur binaire
représentations.Tout comme il y a huit bits dans un octet, nous allons créer une structure de données (un tableau dans ce cas) avec chaque octet de maintien huit pixels. Les bits qui sont fixés (1) indiquent le pixel correspondant apparaîtra affichée dans la couleur associée à ce bitmap. Les bits sont remis à zéro (0) quittent le pixel correspondant inchangé. La taille de chaque tableau bitmap doit être d'au moins 10 octets car chaque bitmap contient cinq lignes avec neuf pixels dans chaque rangée (qui est, deux octets sont nécessaires pour chaque ligne de l'image). Par conséquent, lorsque nous convertissons ces bitmaps à leurs représentations binaires, et par la suite à leur équivalent hexadécimal, les résultats apparaîtront comme indiqué ici. Les bits de caractères gras représentent l'image réelle; les autres bits sont des bits de remplissage nécessaires pour compléter chaque ligne des bitmaps après le neuvième pixel. Tous les bits de remplissage doivent être nuls.


 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 08 00

 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 14 00

 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 22 00

 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 41 00

 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 80 FF

 bitmap périmètre


 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 00

 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 08 00

 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1C 00

 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 3E 00

 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 00

 bitmap intérieur

 La question suivante est l'ordre dans lequel les bitmaps sont stockés dans la

les structures de données correspondantes. Étant donné que notre structure de données est un tableau, il est seulement nécessaire de montrer la relation entre les indices des structures bitmap ci-dessus. Le schéma suivant montre l'ordre de l'indice pour le cas d'une à deux colonnes par cinq rangées bitmap.


 [8] [9]   

 [6] [7]

 [4] [5]

 [2] [3]

 [0] [1]


A partir de ce diagramme, on voit le premier élément de la matrice (à savoir la
élément avec l'indice [0]) représente le coin inférieur gauche de l'image. La progression de l'indice continue ensuite à droite jusqu'à la fin de la première rangée. Il reprend alors à l'élément le plus à gauche de la deuxième rangée et continue vers la droite jusqu'à la fin de cette ligne. Elle se poursuit de cette manière pour toutes les lignes restantes.

Nous sommes maintenant prêts à présenter un exemple de programme pour afficher notre triangle.

Le programme utilisera la fg_drawmap routine Fastgraph, qui attend trois arguments. Le premier argument est le tableau bitmap (transmis par référence), le second est la largeur de l'image bitmap en octets, et le dernier est la hauteur de l'image bitmap en rangées de pixels. Le fg_drawmap affiche de routine l'image de telle sorte que son coin inférieur gauche est à la position graphique du curseur sur la page vidéo active. La routine n'a pas d'effet dans les modes texte vidéo. En outre, fg_drawmap affiche l'image en utilisant l'indice de couleur actuelle, ce qui signifie que nous aurons besoin d'appeler fg_drawmap une fois pour chaque couleur dans l'image.

Exemple 10-1 fonctionne dans un mode graphique 320x200 de couleur (il pourrait être fait pour
exécuté en mode 12 aussi, mais cela irait à l'encontre de l'objectif de l'exemple). Après avoir établi le mode vidéo, le programme fg_rect utilise pour remplir tout l'écran avec un rectangle gris (blanc CGA). Ensuite, le programme établit (156,101) comme étant la position du curseur graphique; ce qui provoque le triangle centré sur l'écran. Les deux appels à fg_drawmap, une pour chaque couleur dans l'image, en fait afficher le triangle. Notez surtout comment fg_setcolor est utilisé avant chaque appel à fg_drawmap pour définir l'indice de couleur actuelle. Le résultat est un triangle avec un périmètre bleu (cyan dans ACG) et l'intérieur vert (magenta CGA).

 Exemple 10-1.

 #include <fastgraf.h>
             #include <stdio.h>
             #include <stdlib.h>
            void main (void);

 carboniser périmètre [] = {
               0xFF, 0x80,0x41,0x00,0x22,0x00,0x14,0x00,0x08,0x00
                };
            omble intérieur [] = {
               0x00,0x00,0x3E, 0x00,0x1C, 0x00,0x08,0x00,0x00,0x00
                };

 void main ()
             {
               int old_mode, new_mode; 
                                          Chapitre 10: Bitmap Images 215


 fg_initpm ();
               new_mode = fg_bestmode (320,200,1);
               if (new_mode <0 || new_mode == 12) {
                  printf ( "Ce programme nécessite une 320");
                  ( "le mode x 200 graphiques couleur \ n".) printf;
                  sortie (1);
                   }

 fg_getmode old_mode = ();
               fg_setmode (new_mode);

 fg_setcolor (7);
               fg_rect (0,319,0,199);

 fg_move (156,101);
               fg_setcolor (1);
               fg_drawmap (périmètre, 2,5);
               fg_setcolor (2);
               fg_drawmap (intérieur, 2,5);
               fg_waitkey ();

 fg_setmode (old_mode);
               fg_reset ();
             }


Il convient de mentionner que fg_drawmap ne réalise pas l'écrêtage lorsque
afficher une image. Si vous voulez que l'image soit contraint par les limites d'écrêtage actuelles, utilisez fg_clipmap au lieu de fg_drawmap. La routine de fg_clipmap prend les trois mêmes arguments que fg_drawmap, mais il est pas aussi rapide que fg_drawmap en raison de la charge supplémentaire requise lors de l'exécution de l'image écrêtage.

Les différents bitmaps de couleurs utilisées par fg_drawmap n'ont pas tous être le
même taille.Dans notre exemple de triangle, le périmètre est de 9 pixels de large par 5 pixels de haut, mais l'intérieur est à seulement 5 pixels de large par 3 pixels de haut. Par conséquent, le bitmap pour les pixels intérieurs ne nécessite qu'un seul octet pour chacun de ses trois rangées, de sorte que nous pouvons stocker dans un tableau à trois octets. Sa structure serait:


 [2] 08

 [1] 1C

 [0] 3E


Exemple 10-2 est similaire à l'exemple 10-1, mais il utilise un tableau à trois octets
pour le bitmap intérieur. Notez le deuxième appel à fg_move dans cet exemple. Il est nécessaire parce que la rangée du bas de l'image bitmap intérieur plus petit correspond à la deuxième ligne de la plus grande périmètre bitmap. En d'autres termes, le bitmap intérieur doit être affiché une ligne au-dessus du bitmap de périmètre.

 Exemple 10-2.

 #include <fastgraf.h>   

Guide de 216 Fastgraph utilisateur


 #include <stdio.h>
             #include <stdlib.h>
            void main (void);

 carboniser périmètre [] = {
               0xFF, 0x80,0x41,0x00,0x22,0x00,0x14,0x00,0x08,0x00
                };
            omble intérieur [] = {
               0x3E, 0x1C, 0x08
                };

 void main ()
             {
               int old_mode, new_mode;

 fg_initpm ();
               new_mode = fg_bestmode (320,200,1);
               if (new_mode <0 || new_mode == 12) {
                  printf ( "Ce programme nécessite une 320");
                  ( "le mode x 200 graphiques couleur \ n".) printf;
                  sortie (1);
                   }

 fg_getmode old_mode = ();
               fg_setmode (new_mode);

 fg_setcolor (7);
               fg_rect (0,319,0,199);

 fg_move (156,101);
               fg_setcolor (1);
               fg_drawmap (périmètre, 2,5);
               fg_move (156,100);
               fg_setcolor (2);
               fg_drawmap (intérieur, 1,3);
               fg_waitkey ();

 fg_setmode (old_mode);
               fg_reset ();
             }


Dans l'exemple 10-2, le temps nécessaire pour exécuter le deuxième appel à fg_move
peut ne pas être vaut le gain de 7 octets. Lorsque l'espace du tableau est critique, ou lorsque les images sont plus grandes, l'utilisation de petits bitmaps pour certaines couleurs peut être plus précieux.

Pourtant, une autre possibilité, par exemple 10-2 serait de déplacer les éléments
du bitmap intérieur de deux pixels vers la gauche. De cette manière, le bitmap soit aligné sur le côté gauche de la matrice, comme le bitmap de périmètre est. Les trois valeurs composant le bitmap intérieur deviendraient alors F8, 70 et 20. Nous aimerions aussi avoir besoin de changer la coordonnée x dans le deuxième appel à fg_move 156-158.

===Spécifiques à chaque mode Images bitmap===

Cette section discutera des routines d'affichage d'image qui utilisent pixelisée
formats d'image spécifiques à chaque mode vidéo texte et des graphiques. Les différents formats d'image ressemblent étroitement à la structure de mémoire vidéo dans chaque mode, de sorte que ces routines sont beaucoup plus rapides que d'afficher bitmaps en mode indépendant avec fg_drawmap. Si vous utilisez les bitmaps spécifiques au mode dans un programme qui prend en charge plusieurs modes vidéo, il y aura une programmation supplémentaire qui ne soit pas nécessaire lors de l'utilisation des bitmaps en mode indépendant. Habituellement, cependant, vos efforts seront récompensés avec des graphismes nettement plus rapides.

Nous démontrons l'utilisation des bitmaps spécifiques au mode dans les modes avec graphiques
le familier triangle deux couleurs dont la représentation pixel apparaît ci-dessous.

  .  .  .  . *.  .  .  .
                               .  .  . * X * .  .  .
                               .  . * Xxx *.  .
                               . * Xxxxx *.
                               * * * * * * * * *

Comme précédemment, notre triangle est neuf pixels de large à sa base et cinq pixels
haute.Les pixels indiqués par un astérisque (*) sont le périmètre du triangle, tandis que celles qui sont indiquées par un x représentent ses points intérieurs. Nous devons faire la distinction entre ces pixels, car ils seront différentes couleurs. Les pixels affichés comme des périodes (.) Ne font pas partie du triangle lui-même. Ils sont nécessaires pour rendre l'image rectangulaire, donc du point de vue Fastgraph ils sont en effet partie de l'image.


====Images régulières====

La fg_drwimage routine Fastgraph affiche spécifique en mode régulier
images bitmap (par régulière, nous entendons une image qui est ni coupé, ni tourné). Ses arguments et l'ordre de l'indice de la matrice bitmap sont les mêmes que pour fg_drawmap. La différence majeure est la structure bitmap - nous combinons les informations pour toutes les couleurs en un seul bitmap, d'une manière compatible avec la structure de mémoire vidéo pour les différents modes. Comme avec les autres routines d'affichage d'image, fg_drwimage affiche l'image sur la page vidéo active ou tampon virtuel avec son coin inférieur gauche à la position graphique du curseur (ou la position du curseur de texte pour les modes de texte). Nous allons maintenant examiner l'utilisation de fg_drwimage dans plusieurs modes vidéo.

=====modes quatre couleurs graphiques CGA=====

Dans les modes graphiques quatre couleurs CGA (modes 4 et 5), chaque pixel peut
supposons une valeur comprise entre 0 et 3. Cela signifie qu'il faut deux bits pour représenter un pixel, ou en d'autres termes, chaque octet de mémoire vidéo contient quatre pixels. Notre image de triangle est neuf pixels de large, de sorte que trois octets sont nécessaires pour chaque ligne de l'image. Parce que l'image est de cinq pixels de haut, nous avons besoin d'un réseau de bitmap d'au moins 15 octets (cinq lignes fois trois octets par ligne) pour contenir l'image.
représentation binaire de l'image et son équivalent hexadécimal pour la
modes graphiques quatre couleurs CGA sont présentés ici. Les valeurs binaires en gras représentent l'image réelle; les autres sont les bits de remplissage nécessaires pour compléter chaque ligne de l'image bitmap après le neuvième pixel. Nous avons codé le périmètre Guide 218 Fastgraph utilisateur
pixels pour être la couleur 1 (01 binaire) et les pixels intérieurs à être de couleur 2 (10 binaire). Tout pixel dont la valeur est égale à zéro (00 binaire) est transparent et laisser ainsi le contenu de la mémoire vidéo à cette position inchangée.


 00 00 00 00 01 00 00 00 00 00 00 00 00 40 00

 00 00 00 01 10 01 00 00 00 00 00 00 01 90 00

 00 00 01 10 10 10 01 00 00 00 00 00 06 00 A4

 00 01 10 10 10 10 10 01 00 00 00 00 1A A9 00

 01 01 01 01 01 01 01 01 01 00 00 00 55 55 40


Exemple 10-3 utilise ce bitmap mode spécifique pour afficher le triangle
le mode standard CGA-quatre couleurs graphiques (mode 4). Après avoir établi le mode vidéo, le programme fg_rect utilise pour remplir tout l'écran avec un rectangle blanc. Ensuite, le programme établit (156,101) comme étant la position du curseur graphique; ce qui provoque le triangle centré sur l'écran. L'appel à fg_drwimage produit un triangle avec un périmètre de cyan (couleur 1) et un intérieur magenta (couleur 2).

 Exemple 10-3.

 #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
             void main (void);

 omble triangle [] = {
                0x55,0x55,0x40, 0x1A, 0xA9,0x00, 0x06,0xA4,0x00,
                0x01,0x90,0x00, 0x00,0x40,0x00
                 };

 void main ()
              {
                int old_mode;

 fg_initpm ();
                if (fg_testmode (4,1) == 0) {
                   printf ( "Ce programme nécessite une 320");
                   ( "le mode x 200 graphiques CGA \ n".) printf;
                    sortie (1);
                    }

 fg_getmode old_mode = ();
                fg_setmode (4);

 fg_setcolor (7);
                fg_rect (0,319,0,199);

 fg_move (156,101);
                fg_drwimage (triangle, 3,5);
                fg_waitkey (); 
                                          Chapitre 10: Bitmap Images 219


 fg_setmode (old_mode);
                fg_reset ();
              }


=====CGA mode deux graphiques en couleur=====

Dans les deux couleurs CGA Mode (mode 6) graphique, chaque pixel peut prendre la
les valeurs 0 ou 1. Cela signifie qu'il suffit d'un seul bit pour représenter un pixel, de sorte que chaque octet de la mémoire vidéo contient huit pixels. Notre image de triangle est neuf pixels de large, de sorte que deux octets sont nécessaires pour chaque ligne de l'image. Parce que l'image est de cinq pixels de haut, nous avons besoin d'un réseau de bitmap d'au moins 10 octets (cinq lignes fois deux octets par ligne) pour contenir l'image.

représentation binaire de l'image et son équivalent hexadécimal pour la
deux couleurs mode graphique CGA sont présentés ici. Les valeurs binaires en gras représentent l'image réelle; les autres sont les bits de remplissage nécessaires pour compléter chaque ligne de l'image bitmap après le neuvième pixel. Nous avons codé les deux pixels de périmètre et les pixels intérieurs à être de couleur 1. Tout pixel dont la valeur est zéro est transparente et va donc laisser le contenu de la mémoire vidéo à cette position inchangée.


 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 08 00

 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1C 00

 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 3E 00

 0 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 00 7F

 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 80 FF


Exemple 10-4 utilise ce bitmap mode spécifique pour afficher le triangle
le mode deux couleurs graphiques CGA (mode 6). Après avoir établi le mode vidéo, le programme établit (316.101) que la position du curseur graphiques; ce qui provoque le triangle centré sur l'écran. L'appel à fg_drwimage produit un triangle solide.

 Exemple 04.10.

 #include <fastgraf.h>
                   #include <stdio.h>
                   #include <stdlib.h>
                  void main (void);

 omble triangle [] = {
                     0xFF, 0x80, 0x7F, 0x00, 0x3E, 0x00,
                     0x1C, 0x00, 0x08,0x00
                      };

 void main ()
                   {
                     int old_mode; 

 fg_initpm ();
                     if (fg_testmode (6,1) == 0) {
                        printf ( "Ce programme nécessite une");
                        ( «mode graphique CGA \ n".) printf;
                         sortie (1);
                         }

 fg_getmode old_mode = ();
                     fg_setmode (6);

 fg_move (316,101);
                     fg_drwimage (triangle, 2,5);
                     fg_waitkey ();

 fg_setmode (old_mode);
                     fg_reset ();
                   }


=====mode 16 graphique couleur Tandy / PCjr=====

La structure de bitmaps spécifique en mode pour les 16 couleurs Tandy / PCjr
Mode (mode 9) graphique est la même que la structure bitmap mode spécifique pour la / / SVGA modes EGA-VGA 16 graphiques couleur discutées plus loin dans cette section.

=====modes graphiques Hercules=====

La structure de bitmaps spécifique en mode pour les modes les graphiques Hercules
(modes 11 et 12) est le même que deux des modes les graphiques CGA. Pour le mode graphique Hercules standard (mode 11), se référer à la discussion des CGA deux couleurs (mode 6) bitmaps. Pour le Hercules mode graphique basse résolution (mode 12), se référer à la discussion des quatre couleurs CGA (mode 4) bitmaps.

=====modes / VGA / SVGA 16 couleurs graphiques EGA=====

Dans les modes les natifs EGA et VGA graphiques (modes 13 à 18) et le
modes graphiques SVGA 16 couleurs (modes 28 et 29), chaque pixel peut prendre une valeur entre 0 et 15. Cela signifie qu'il faut quatre bits pour représenter un pixel, de sorte que chaque octet du bitmap détient deux pixels. Notre image de triangle est neuf pixels de large, de sorte que cinq octets sont nécessaires pour chaque ligne de l'image. Parce que l'image est de cinq pixels de haut, nous avons besoin d'un réseau de bitmap d'au moins 25 octets (cinq lignes fois cinq octets par ligne) pour contenir l'image.

Dans ces modes, il est facile d'élaborer la représentation hexadécimale d'une
bitmap sans produire d'abord son équivalent binaire. En effet, une valeur de pixel et un chiffre hexadécimal occupent chacune quatre bits. représentation hexadécimale du triangle pour ces modes vidéo est montré ici. Les pixels en gras représentent l'image réelle; les autres sont les valeurs de charge nécessaires pour compléter chaque ligne de l'image bitmap après le neuvième pixel. Nous avons choisi d'afficher les pixels périphériques de couleur 1 et les pixels intérieurs de couleur 2. Tout pixel dont la valeur est zéro est transparente et va donc laisser le contenu de la mémoire vidéo à cette position inchangée.


 00 00 10 00 00

 00 01 21 00 00

 00 12 22 10 00

 01 22 22 21 00

 11 11 11 11 10


Exemple 10-5 est similaire à l'exemple 10-3, mais il utilise le EGA 320x200
mode graphique (mode 13) et du bitmap mode spécifique juste construit pour afficher le triangle. L'appel à fg_drwimage produit un triangle avec un périmètre bleu (couleur 1) et un intérieur vert (couleur 2).

 Exemple 10-5.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 omble triangle [] = {
                   0x11,0x11,0x11,0x11,0x10,
                   0x01,0x22,0x22,0x21,0x00,
                   0x00,0x12,0x22,0x10,0x00,
                   0x00,0x01,0x21,0x00,0x00,
                   0x00,0x00,0x10,0x00,0x00
                    };

 void main ()
                 {
                   int old_mode;

 fg_initpm ();
                   if (fg_testmode (13,1) == 0) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques EGA \ n".) printf;
                       sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (13);

 fg_setcolor (7);
                   fg_rect (0,319,0,199);

 fg_move (156,101);
                   fg_drwimage (triangle, 5,5);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                }   

=====modes graphiques 256 couleurs=====

Dans les modes graphiques 256 couleurs (modes 19 à 27), chaque pixel peut prendre
une valeur comprise entre 0 et 255 (FF hex). Cela signifie qu'il faut huit bits pour représenter un pixel ou chaque octet de la mémoire vidéo contient un pixel. Notre image de triangle est neuf pixels de large, de sorte que neuf octets sont nécessaires pour chaque ligne de l'image. Parce que l'image est de cinq pixels de haut, nous avons besoin d'un réseau de bitmap d'au moins 45 octets (cinq lignes fois neuf octets par ligne) pour contenir l'image. Notez que nous aurons jamais besoin des bits de remplissage dans les modes vidéo 256 couleurs.

Il est particulièrement simple à développer le bitmap pour une image dans le 256-
modes de couleurs, car chaque octet détient exactement un pixel. représentation hexadécimale du triangle pour les modes graphiques de 256 couleurs est montré ici. Comme précédemment, nous avons codé les pixels périphériques comme la couleur 1 (01 hex) et les pixels intérieurs à être de couleur 2 (02 hex). Tout pixel dont la valeur est égale à zéro est transparente et laisser ainsi le contenu de la mémoire vidéo à cette position inchangée.


 00 00 00 00 01 00 00 00 00

 00 00 00 01 02 01 00 00 00

 00 00 01 02 02 02 01 00 00

 00 01 02 02 02 02 02 01 00

 01 01 01 01 01 01 01 01 01


Exemple 10-6 est également similaire à l'exemple 10-3, mais il utilise la MCGA 256-
le mode graphique couleur (mode 19) et du bitmap mode spécifique juste construit pour afficher le triangle. L'appel à fg_drwimage produit un triangle avec un périmètre bleu (couleur 1) et un intérieur vert (couleur 2).

 Exemple 10-6.

 #include <fastgraf.h>
               #include <stdio.h>
               #include <stdlib.h>
              void main (void);

 omble triangle [] = {
                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                 0x00,0x01,0x02,0x02,0x02,0x02,0x02,0x01,0x00,
                 0x00,0x00,0x01,0x02,0x02,0x02,0x01,0x00,0x00,
                 0x00,0x00,0x00,0x01,0x02,0x01,0x00,0x00,0x00,
                 0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00
                  };

 void main ()
               {
                 int old_mode;

 fg_initpm (); 
                                          Chapitre 10: Bitmap Images 223


 if (fg_testmode (19,1) == 0) {
                    printf ( "Ce programme nécessite une 320");
                    ( "le mode x 200 graphiques MCGA \ n".) printf;
                     sortie (1);
                     }

 fg_getmode old_mode = ();
                 fg_setmode (19);

 fg_setcolor (7);
                 fg_rect (0,319,0,199);

 fg_move (156,101);
                 fg_drwimage (triangle, 9,5);
                 fg_waitkey ();

 fg_setmode (old_mode);
                 fg_reset ();
               }


Parfois, vous devrez peut-être inclure des pixels noirs qui ne sont pas transparents
dans une image bitmap mode spécifique. La meilleure façon de le faire est d'utiliser fg_putimage, que nous allons décrire brièvement. Une autre possibilité est d'utiliser fg_palette ou fg_setrgb pour faire un index utilisé de couleur noire et ensuite utiliser cet indice de couleur pour les non-transparents pixels noirs. Par exemple, fg_palette appelant (8,0) dans un mode graphique 16 couleurs affichera la couleur 8 pixels que le noir. De même, fg_setrgb (248,0,0,0) dans un mode graphique 256 couleurs affichera la couleur 248 pixels que le noir. Le choix des couleurs et 8 248 dans ces exemples est arbitraire; toute couleur utilisé fera. Une autre possibilité est d'utiliser les cartes de masquage discutés plus loin dans ce chapitre.

====tampons virtuels====

La structure de bitmaps spécifique en mode pour les tampons virtuels est le
identique à la structure bitmap mode spécifique pour les modes graphiques de 256 couleurs discutés dans la section précédente.

=====Modes de texte=====

Vous pouvez également utiliser la routine de fg_drwimage pour afficher des images en texte vidéo
Modes (modes 0, 1, 2, 3 et 7). Comme on pouvait s'y attendre, la structure de l'image dans les modes de texte est assez différent de modes graphiques les. Dans le chapitre 5, nous avons vu que chaque cellule de caractère sur l'écran est en fait constitué d'un caractère et un attribut. La valeur de caractère détermine ce caractère est affiché, tandis que la valeur d'attribut contrôle l'apparence du personnage. La structure de l'attribut est la suivante:

 les bits d'attribut

 0-3 couleur de premier plan
                       la couleur d'arrière-plan 4-6
                        7 clignotant

La structure de l'image en mode texte utilisé avec fg_drwimage se compose également d'un
série de caractères et attributs. Par exemple, le Guide de la figure suivante 224 Fastgraph utilisateur
illustre la structure d'une image qui est de trois caractères de large et deux personnages de haut.


 omble attr omble attr omble attr

 omble attr omble attr omble attr


Pour illustrer l'utilisation de fg_drwimage en mode texte vidéo, nous affichons
l'expression "bonjour là" sur deux lignes différentes dans le centre de l'écran. En outre, supposons que nous aimerions que le premier caractère de chaque mot à apparaître dans la couleur de premier plan 1, la deuxième couleur 2, et ainsi de suite. Notre image se composera de deux lignes chacune contenant cinq caractères, et chaque caractère nécessite deux octets de stockage (un pour le caractère et l'autre pour son attribut), donc nous allons avoir besoin d'un tableau de 20 octets pour la tenue de l'image. Le tableau ne tient pas vraiment une image bitmap comme dans les modes graphiques les, de sorte que dans le texte Modes le premier argument passé à fg_drwimage est plutôt appelé le réseau d'image. Dans notre exemple, la structure de la matrice d'image est la suivante:


 'H' 1 'e' 2 'l' 3 'l' 4 'o' 5

 'T' 1 'h' 2 'e' 3 'r' 4 'e' 5


L'ordre de l'indice que fg_drwimage utilise des modes de texte est le même que pour les modes graphiques les. Pour nos cinq rangs image en deux colonnes par, cela signifie que les indices de tableau seront numérotées comme suit:


 [10] [11] [12] [13] [14] [15] [16] [17] [18] [19]

 [0] [1] [2] [3] [4] [5] [6] [7] [8] [9]


En fonction des valeurs de caractère et d'attribut dans la matrice d'image,
fg_drwimage peut afficher de nouveaux personnages et attributs, de nouveaux personnages en laissant les attributs existants inchangés, de nouveaux attributs laissant le caractère existant inchangé, ou de laisser à la fois le caractère existant et attribuer inchangé dans la mémoire vidéo. Pour garder un caractère ou attribut existant, il suffit de spécifier une valeur de 0 dans l'élément correspondant de la matrice d'image. Cette capacité est analogue au fait que de valeur zéro pixels en mode graphique bitmaps laissent mémoire vidéo inchangé.

 Exemple 10-7 illustre l'utilisation de fg_drwimage dans la couleur 80 colonnes

en mode texte (mode 3). Après avoir établi le mode vidéo et en faisant le curseur invisible, le programme appelle fg_drwimage pour afficher le "bonjour là" image juste discuté (noter que nous passons les dimensions de la matrice d'image que le nombre d'octets, et non pas le nombre de caractères). Le programme attend une frappe et appelle ensuite à nouveau fg_drwimage, le passage d'un réseau d'image différente (appelée "image") de la même taille. Ce tableau change la première lettre des deux mots de minuscules en majuscules (en laissant l'attribut inchangé), et il rend les caractères restants ont le même attribut que le premier caractère. Cela se fait en partie en utilisant des caractères de valeur zéro et les attributs de quitter la mémoire vidéo inchangée. Après avoir attendu une autre touche, le programme sort.

 Exemple 10-7.

 #include <fastgraf.h>
                    void main (void);

 carboniser bonjour [] = {
                       'T', 1, 'h', 2, 'e', ??3, 'r', 4, 'e', ??5,
                       'H', 1, 'e', ??2, 'l', 3, 'l', 4, 'o', 5
                        };

 l'image char [] = {
                       'T', 0, 0,1, 0,1, 0,1, 0,1,
                       'H', 0, 0,1, 0,1, 0,1, 0,1
                        };

 void main ()
                     {
                       int old_mode;

 fg_initpm ();
                       fg_getmode old_mode = ();
                       fg_setmode (3);
                       fg_cursor (0);

 fg_locate (12,37);
                       fg_drwimage (bonjour, 10,2);
                       fg_waitkey ();

 fg_drwimage (image, 10,2);
                       fg_waitkey ();

 fg_setmode (old_mode);
                       fg_reset ();
                     }


====Images détourées====

La routine de fg_drwimage ne fonctionne pas écrêtage lors de l'affichage d'un
image. Si vous voulez que l'image soit contraint par les limites d'écrêtage (tel qu'établi par l'appel le plus récent à fg_setclip), utilisez fg_clpimage au lieu de fg_drwimage. La routine prend fg_clpimage les trois mêmes arguments que fg_drwimage et affiche également l'image de telle sorte que son coin inférieur gauche est à la position du curseur graphique. Contrairement à fg_drwimage, la routine de fg_clpimage n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte. En raison de la charge supplémentaire impliqué dans la vérification des limites d'écrêtage, fg_clpimage est pas aussi rapide que fg_drwimage.


====Images inversée====

La routine de fg_revimage affiche une image inversée (qui est, en miroir
autour de l'axe-y) sans écrêtage. Il prend les trois mêmes arguments que fg_drwimage et affiche également l'image de telle sorte que son coin inférieur gauche est au Guide de l'utilisateur 226 Fastgraph
les graphiques position du curseur. La routine de fg_revimage n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.


====Inversée Images détourées====

La routine fg_flpimage combine les effets de la fg_revimage et
routines fg_clpimage - il affiche une image inversée contraint par les limites d'écrêtage actuelles. Il faut environ les trois mêmes arguments que fg_drwimage et affiche également l'image de telle sorte que son coin inférieur gauche est à la position du curseur graphique. Comme la routine fg_clpimage, fg_flpimage n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.


====Images Sans pixels transparents====

La routine de fg_putimage est le même que celui fg_drwimage sauf qu'il ne
considérer la couleur 0 pixels pour être transparent. Parce qu'il n'a pas besoin de vérifier les pixels transparents, fg_putimage est plus rapide que fg_drwimage. Utilisation de fg_putimage est recommandé pour les cas où la transparence est pas un problème.


====Quelques exemples====

Exemple 10-8 illustre l'utilisation de fg_drwimage, fg_clpimage,
fg_revimage, fg_flpimage et fg_putimage en mode quatre couleurs graphique standard CGA (mode 4). Le programme utilise chacune de ces routines pour afficher une petite flèche blanche, comme illustré sur cette carte de pixels:

  .  .  .  .  .  . *.  .  .
                              .  .  .  .  .  . * *.  .
                             * * * * * * * * *.
                              * * * * * * * * * *
                             * * * * * * * * *.
                              .  .  .  .  .  . * *.  .
                              .  .  .  .  .  . *.  .  .

Comme précédemment, nous devons d'abord convertir cette image à un bitmap. L'image est de dix pixels de large et sept de haut. En mode 4, chaque pixel occupe deux bits, donc nous avons besoin d'un réseau de 21 octets (7 lignes par 3 colonnes) pour stocker l'image. Puisque nous voulons faire de la flèche blanche, chaque pixel sera affiché dans la couleur 3 (11 binaire). Voici le bitmap et son équivalent hexadécimal pour l'image de la flèche en mode 4 (l'image réelle est en gras).


 00 00 00 00 00 00 11 00 00 00 00 00 00 00 0C

 00 00 00 00 00 00 11 11 00 00 00 00 00 00 0F

 11 11 11 11 11 11 11 11 11 00 00 00 FF FF C0

 11 11 11 11 11 11 11 11 11 11 00 00 FF FF F0

 11 11 11 11 11 11 11 11 11 00 00 00 FF FF C0

 00 00 00 00 00 00 11 11 00 00 00 00 00 00 0F   
                                          Chapitre 10: Bitmap Images 227


 00 00 00 00 00 00 11 00 00 00 00 00 00 00 0C


Après avoir établi le mode vidéo, le programme remplit l'écran avec
Couleur 1 pixels et définit une zone de découpage. Il fg_drwimage utilise ensuite pour afficher la flèche pointant vers la droite et fg_clpimage de faire la même chose, mais en ce qui concerne les limites d'écrêtage. Parce que le bord gauche de la flèche est affichée à x = 10 et le droit d'écrêtage limite est à x = 15, l'appel à fg_clpimage ne tire les six premières colonnes de la flèche (qui est, il ne tire pas la tête de flèche).

Ensuite, par exemple 10-8 fg_revimage utilise pour afficher la flèche pointant vers la
à gauche.Pour permettre la charge des pixels, nous devons établir la position graphique du curseur deux pixels vers la gauche de la position utilisée par fg_drwimage si nous voulons que la pointe de la flèche pointant vers la gauche pour l'aligner sur la queue de la flèche pointant vers le droite. Le programme fg_flpimage utilise ensuite pour afficher une flèche pointant vers la gauche en ce qui concerne les limites d'écrêtage. L'appel à fg_flpimage affiche la tête de flèche et les deux premières colonnes de l'arbre de flèche. Enfin, le programme fg_putimage utilise pour afficher la flèche pointant vers la droite écrêté sans pixels transparents (ce qui produit une bordure noire autour de la flèche).

 Exemple 10-8.

 #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
             void main (void);

 omble flèche [] = {
                0x00,0x0C, 0x00, 0x00,0x0F, 0x00, 0xFF, 0xFF, 0xC0,
                0xFF, 0xFF, 0xF0, 0xFF, 0xFF, 0xC0, 0x00,0x0F, 0x00,
                0x00,0x0C, 0x00
                 };

 void main ()
              {
                int old_mode;

 fg_initpm ();
                if (fg_testmode (4,1) == 0) {
                   printf ( "Ce programme nécessite une 320");
                   ( "le mode x 200 graphiques CGA \ n".) printf;
                    sortie (1);
                    }

 fg_getmode old_mode = ();
                fg_setmode (4);
                fg_setcolor (1);
                fg_fillpage ();
                fg_setclip (0,15,0,199);

 fg_move (10,10);
                fg_drwimage (flèche, 3,7);
                fg_move (10,20);
                fg_clpimage (flèche, 3,7); 

 fg_move (8,30);
                fg_revimage (flèche, 3,7);
                fg_move (8,40);
                fg_flpimage (flèche, 3,7);
                fg_move (8,50);
                fg_putimage (flèche, 3,7);
                fg_waitkey ();

 fg_setmode (old_mode);
                fg_reset ();
              }


Exemple 10-9 est identique à l'exemple 10-8, mais on utilise la basse résolution,
mode graphique EGA (mode 13). Si nous avons changé le numéro de mode spécifié dans les appels à fg_testmode et fg_setmode, le programme serait également fonctionner dans un mode graphique couleur 16-. Dans ces modes, nous stockons deux pixels par octet dans le tableau bitmap, donc nous avons besoin d'un réseau de 35 octets (7 lignes par 5 colonnes) pour stocker l'image. Voici équivalent hexadécimal du bitmap pour l'image de la flèche en mode 13, suivi par le programme pour l'afficher.


 00 00 00 00 F0

 00 00 00 00 FF

 FF FF FF FF F0

 FF FF FF FF FF

 FF FF FF FF F0

 00 00 00 00 FF

 00 00 00 00 F0


 Exemple 10-9.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 omble flèche [] = {
                   0x00,0x00,0x00,0xF0,0x00,
                   0x00,0x00,0x00,0xFF, 0x00,
                   0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
                   0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                   0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
                   0x00,0x00,0x00,0xFF, 0x00,
                   0x00,0x00,0x00,0xF0,0x00
                    };

 void main ()
                {   
                                          Chapitre 10: Bitmap Images 229


 int old_mode;

 fg_initpm ();
                   if (fg_testmode (13,1) == 0) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques EGA \ n".) printf;
                       sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (13);
                   fg_setcolor (1);
                   fg_fillpage ();
                   fg_setclip (0,15,0,199);

 fg_move (10,10);
                   fg_drwimage (flèche, 5,7);
                   fg_move (10,20);
                   fg_clpimage (flèche, 5,7);
                   fg_move (8,30);
                   fg_revimage (flèche, 5,7);
                   fg_move (8,40);
                   fg_flpimage (flèche, 5,7);
                   fg_move (8,50);
                   fg_putimage (flèche, 5,7);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


===Récupération d'images===

Parfois, il est nécessaire de récupérer une image de la mémoire vidéo et un magasin
dans un ou plusieurs tableaux sous forme d'image bitmap. Fastgraph comprend deux routines, fg_getmap et fg_getimage, à cette fin. La routine de fg_getmap récupère pixels de l'indice de couleur actuelle et les stocke dans le format bitmap indépendante mode- utilisée par fg_drawmap. La routine de fg_getimage récupère une image et le stocke dans le format spécifique en mode bitmap utilisé par fg_drwimage, fg_clpimage, fg_revimage, fg_flpimage et fg_putimage. Les arguments à fg_getmap et fg_getimage sont respectivement analogues à celles des fg_drawmap et fg_drwimage: le premier est un tableau (transmis par référence) pour recevoir le bitmap, le second est la largeur de l'image bitmap en octets, et la dernière est la hauteur de la bitmap en rangées de pixels. Avec soit la routine, la position graphique du curseur sur la page vidéo active définit le coin inférieur gauche de l'image à récupérer.

Si nous voulons utiliser fg_getmap pour récupérer une image contenant plus d'un
la couleur, il faut appeler la routine une fois par couleur. Dans ce cas, nous voulons habituellement passer différents tableaux bitmap à fg_getmap (ou peut-être différents décalages dans le même tableau). Cela peut sembler inhabituel au début, mais il est parallèle le comportement de la routine de fg_drawmap. Autrement dit, pour afficher une image multicolore en utilisant fg_drawmap, nous devons l'appeler une fois pour chaque couleur dans l'image. Guide de l'utilisateur 230 Fastgraph


Exemple 10-10 montre une utilisation typique de la routine de fg_getmap.  le
programme affiche le mot «texte» dans le coin supérieur gauche de l'écran en utilisant un mode 320x200 graphique. Il utilise fg_getmap pour récupérer le mot comme une image, puis l'affiche dans une nouvelle position avec la routine de fg_drawmap. Regardons maintenant le programme, et ensuite nous allons examiner de plus près les coordonnées de l'écran et la structure de la matrice bitmap.

 Exemple 10-10.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   omble bitmap [32];
                   int old_mode, new_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (9);
                   fg_text ( "text", 4);
                   fg_waitkey ();

 fg_move (0,7);
                   fg_getmap (bitmap, 4,8);
                   fg_move (4,15);
                   fg_drawmap (bitmap, 4,8);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


Dans tous les graphiques 320x200 modes vidéo, les caractères individuels sont 8 pixels
de large et 8 pixels de haut. Cela signifie que le coin inférieur gauche de la cellule (0,0) de caractère est référencé par les coordonnées d'écran (0,7). Par conséquent, ce sont les coordonnées du premier appel à fg_move. L'image récupérée dans l'exemple 10-10 est de quatre caractères (32 pixels de large), donc nous avons besoin d'un réseau de bitmap capable de contenir 8 rangées de 32 pixels (4 octets) chacun. Notre réseau de bitmap est donc un tableau de 32 octets, logiquement structuré pour avoir 4 colonnes et 8 lignes. Ces valeurs sont la largeur et la hauteur des arguments passés à fg_getmap et fg_drawmap.


Après il récupère l'image, par exemple 10-10 affiche une ligne ci-dessous
et une cellule de caractère de la moitié (quatre pixels) à droite de sa position initiale. En d'autres termes, le programme affiche l'image de quatre pixels à droite de la cellule (1,0) de caractère. Le coin inférieur gauche de cette cellule est référencée par les coordonnées d'écran (0.15), de sorte que l'image doit apparaître à la position (4,15). Ceux-ci sont les coordonnées du deuxième appel à fg_move.

Par exemple 10 à 11 illustre l'utilisation de fg_getmap et pour récupérer fg_drawmap
et afficher une image en deux couleurs. Cet exemple est similaire à l'exemple 10-10, mais ce programme dessine d'abord un rectangle dans le coin supérieur gauche de l'écran, puis affiche le mot "texte" sur le dessus du rectangle dans une couleur différente. Chaque personnage dans un mode vidéo 320x200 graphique est de 8 pixels de large et 8 pixels de haut, de sorte que le rectangle doit être de 32 pixels de large (4 caractères fois 8 pixels par caractère) et 8 pixels de haut. L'image de récupérer sera la même taille que le rectangle.

L'image récupérée dans l'exemple 10-10 exigeait un tableau de 32 octets, logiquement
structuré pour avoir 4 colonnes et 8 lignes. Exemple 10-11 récupère une image de la même structure, mais l'image contient deux couleurs au lieu d'un seul. Cela signifie que nous devons deux tableaux de 32 octets, une pour chaque couleur, pour contenir l'image. Nous pourrions utiliser à la place un seul tableau de 64 octets et transmettre un décalage dans ce tableau (en particulier, et bitmap [32]) pour le traitement de la deuxième couleur.

 Exemple 10-11.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   omble bitmap1 [32], bitmap2 [32];
                   int old_mode, new_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (7);
                   fg_rect (0,31,0,7);
                   fg_setcolor (9);
                   fg_text ( "text", 4);
                   fg_waitkey ();

 fg_move (0,7);
                   fg_setcolor (7);
                   fg_getmap (bitmap1,4,8);
                   fg_setcolor (9); 

 fg_getmap (bitmap2,4,8);

 fg_move (4,15);
                   fg_setcolor (7);
                   fg_drawmap (bitmap1,4,8);
                   fg_setcolor (9);
                   fg_drawmap (bitmap2,4,8);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


Exemple 10-12 est similaire à l'exemple 10-11, mais il utilise fg_getimage et
fg_drwimage au lieu de fg_getmap et fg_drawmap pour récupérer et afficher l'image. C'est, il utilise le lieu de la recherche d'images et d'affichage des routines de mode indépendant mode spécifique. Lors de l'utilisation des routines propres à chaque mode, la taille de l'image bitmap nécessaire pour maintenir l'image dépend du mode vidéo. Pour les programmes qui fonctionnent dans un seul mode vidéo, les largeurs de bitmap sont constantes, mais quand un programme doit être exécuté dans plusieurs modes vidéo, la largeur est variable. La fg_imagesiz routine Fastgraph calcule le nombre d'octets nécessaires pour stocker une image bitmap de dimensions spécifiées mode spécifique. Ses deux arguments entiers spécifient la largeur de l'image et la taille en pixels.

Le programme calcule la largeur d'image en octets par passage d'une hauteur de 1 à
fg_imagesiz. La taille du tableau bitmap dans l'exemple 10-12 est de 256 octets, la taille requise dans les modes graphiques 256 couleurs (32 octets fois 8 octets). D'autres modes vidéo nécessitent moins de mémoire, de sorte que dans ces modes seulement une partie de la matrice bitmap seront effectivement utilisées. La largeur de l'image est ensuite utilisée dans les appels à la fois fg_getimage et fg_drwimage.

 Exemple 10-12.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   omble bitmap [256];
                   int old_mode, new_mode;
                   Largeur int;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

                    fg_getmode old_mode = ();  fg_setmode (new_mode);  width = (int) fg_imagesiz (32,1);  Chapitre 10: Bitmap Images 233 


  fg_setcolor (7);
                    fg_rect (0,31,0,7);
                    fg_setcolor (9);
                    fg_text ( "text", 4);
                    fg_waitkey ();

  fg_move (0,7);
                    fg_getimage (bitmap, largeur, 8);
                    fg_move (4,15);
                    fg_drwimage (bitmap, largeur, 8);
                    fg_waitkey ();

  fg_setmode (old_mode);
                    fg_reset ();
                 }


Bien que cet exemple utilise un tableau pour stocker l'image, il est généralement préférable d'allouer de la mémoire dynamique à cette fin. Nous aurions pu faire cela dans l'exemple 10-12 en appelant fg_imagesiz avec des arguments de 32 (largeur) et 8 (hauteur). La valeur de retour de la routine serait alors nous dire le nombre d'octets que nous aurions besoin d'allouer.

Nous pouvons également utiliser fg_getimage pour récupérer des images dans les modes texte vidéo.  Dans
modes de texte, cependant, il y a quelques différences que nous devons prendre en considération lors de l'utilisation fg_getimage. En premier lieu, la position du curseur de texte, et non la position du curseur graphique définit le coin inférieur gauche de l'image. Par conséquent, nous devons utiliser fg_locate au lieu de fg_move pour définir l'emplacement de l'image. Deuxièmement, la largeur de l'image est toujours deux fois le nombre de caractères par ligne d'image (ce qui est, pour chaque personnage, nous avons un octet de caractère et un octet d'attribut). La routine de fg_getmap n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

Exemple 10-13 montre une simple utilisation de fg_getimage en mode texte.  Ce
programme est similaire à l'exemple 10-12, mais il fonctionne dans un mode texte de 80 colonnes au lieu d'un mode 320x200 graphique. Comme précédemment, le programme permettra de récupérer les quatre caractères "texte" comme une image à partir du coin supérieur gauche de l'écran, puis l'afficher dans un endroit différent. Parce que l'image se compose de quatre caractères dans une rangée, la largeur de l'image est de 8 octets et la hauteur de l'image est 1.

  Exemple 10-13.

  #include <fastgraf.h>
                   #include <stdio.h>
                   #include <stdlib.h>
                   void main (void);

  void main ()
                   {
                      int old_mode;
                      l'image char [8];

  fg_initpm ();
                      fg_getmode old_mode = (); 

  if (fg_testmode (3,1))
                         fg_setmode (3);
                      else if (fg_testmode (7,1))
                         fg_setmode (7);
                      autre {
                         printf ( "Ce programme nécessite \ n");
                         printf ( "un affichage de 80 colonnes. \ n");
                         sortie (1);
                         }
                      fg_cursor (0);

  fg_setattr (9,7,0);
                      fg_text ( "text", 4);
                      fg_waitkey ();

  fg_locate (0,0);
                      fg_getimage (image, 8,1);
                      fg_locate (1,1);
                      fg_drwimage (image, 8,1);
                      fg_waitkey ();

  fg_setmode (old_mode);
                      fg_reset ();
                   }


Enfin, voici une astuce qui est à retenir.  Dans le EGA et VGA natif
modes graphiques (13 à 18) et les modes 16 couleurs SVGA graphiques (28 et 29), les routines pour l'affichage et la récupération de bitmaps spécifique en mode peut varier de 10% à 20% plus rapide si les graphismes actuels position x est encore nombre. En effet, ces routines doivent effectuer un alignement bitmap supplémentaire lors de l'affichage ou de la récupération des images à partir de pixels impairs.


===Inversant bitmaps===

affichage spécifique en mode de Fastgraph mode indépendant et image pixelisée
routines attendent les images pour être stockées en commençant par la rangée du bas et poursuivre vers le haut. Cette convention est souvent contraire à la "haut en bas" ordre des lignes utilisées dans d'autres bibliothèques graphiques. La routine fg_invert inverse l'ordre des lignes d'images bitmap, donc un "haut en bas" image devient un "bas en haut" image, ou vice versa. Ce sera souvent plus facile d'importer ces images à partir d'autres sources pour une utilisation avec bitmaps routines d'affichage d'image de Fastgraph. Notez que fg_invert ne modifie pas l'orientation pour les bitmaps routines d'affichage d'image de Fastgraph; il renverse simplement l'ordre des lignes de l'image elle-même.

La routine de fg_invert nécessite trois arguments.  La première est l'adresse
du tableau contenant les données d'image bitmap spécifique en mode en mode indépendant ou. L'image inversée résultant est stocké dans ce même tableau. Les deuxième et troisième arguments indiquent respectivement la largeur et la hauteur bitmap en octets.

Exemple 10 à 14 est une version modifiée de l'exemple 10-6 qui définit la

Les données bitmap de triangle commençant par la rangée supérieure et se rendant vers le bas. Pour afficher cette image avec la routine de fg_drwimage de Fastgraph, nous devons
traduire l'image bitmap du "bas vers le haut" le format. Le programme effectue cette traduction avec fg_invert immédiatement après le réglage du mode vidéo (bien que cela pourrait être fait à tout moment avant d'appeler fg_drwimage). Autre que l'appel fg_invert supplémentaire et l'ordre des données bitmap, par exemple 10-14 est le même que l'exemple 10-6.

  Exemple 10-14.

  #include <fastgraf.h>
               #include <stdio.h>
               #include <stdlib.h>
               void main (void);

  omble triangle [] = {
                  0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
                  0x00,0x00,0x00,0x01,0x02,0x01,0x00,0x00,0x00,
                  0x00,0x00,0x01,0x02,0x02,0x02,0x01,0x00,0x00,
                  0x00,0x01,0x02,0x02,0x02,0x02,0x02,0x01,0x00,
                  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01
                  };

  void main ()
               {
                  int old_mode;

  fg_initpm ();
                  if (fg_testmode (19,1) == 0) {
                     printf ( "Ce programme nécessite une 320");
                     ( "le mode x 200 graphiques MCGA \ n".) printf;
                     sortie (1);
                     }

  fg_getmode old_mode = ();
                  fg_setmode (19);
                  fg_invert (triangle, 9,5);

  fg_setcolor (7);
                  fg_rect (0,319,0,199);

  fg_move (156,101);
                  fg_drwimage (triangle, 9,5);
                  fg_waitkey ();

  fg_setmode (old_mode);
                  fg_reset ();
               }


On notera que fg_invert peut également être utilisé pour créer des versions inversées de toute
mode indépendant ou image bitmap mode spécifique. Cela signifie que vous pouvez créer des versions de bitmaps en miroir autour de l'axe x, un peu analogue à la façon dont fg_revimage affiche des images en miroir autour de l'axe-y. Guide de l'utilisateur 236 Fastgraph


===Conversion de bitmaps spécifiques à chaque mode===

Plus tôt dans ce chapitre, nous avons présenté un format d'image bitmap qui était
indépendamment du mode vidéo (ces images sont affichées avec fg_drawmap ou fg_clipmap). Bien que ce format fonctionne bien pour les images avec une ou deux couleurs, la performance peut se dégrader de manière significative si l'image contient beaucoup de couleurs. Dans cette section, nous montrons comment "un pixel par octet" mode spécifique bitmap format de Fastgraph utilisé avec les modes graphiques 256 couleurs et des tampons virtuels peut fournir une autre façon d'utiliser les mêmes données d'image dans les modes vidéo multiples.

La base de ce système est de stocker tous les bitmaps dans le "un pixel par
byte "le format. Lorsque vous utilisez les modes graphiques 256 couleurs ou des tampons virtuels, nous utilisons simplement le" un pixel par octet "bitmaps avec la famille de fg_drwimage des routines parce que les bitmaps sont déjà dans le format attendu. Cependant, lorsque vous utilisez les modes graphiques avec moins couleurs, nous devons traduire les bitmaps à un format adapté à ces modes de routine fg_pack de Fastgraph fournit un moyen facile de le faire. il convertit les images bitmap dans le format "un pixel par octet" au format bitmap mode spécifique pour la vidéo en cours Mode. les bitmaps convertis peut alors être affiché avec la famille de fg_drwimage.

deux premiers arguments de la routine de fg_pack sont les adresses de la source
et les tableaux destination bitmap. Le tableau source contient le "un pixel par octet" image bitmap, et le réseau de destination recevra l'image spécifique en mode converti (il est important de vous assurer que le réseau de destination est assez grand pour contenir l'image convertie). Les deux derniers arguments de fg_pack spécifient la largeur et la hauteur en pixels de l'image source. Dans les modes graphiques 256 couleurs, ou quand un tampon virtuel est actif, fg_pack simplement des copies des sources tableau contenu au tableau de destination.

Exemple 10-15 montre comment vous pouvez utiliser les mêmes données bitmap en 256 couleurs et
modes graphiques 16 couleurs. Nous définissons notre triangle bitmap familière dans le format spécifique en mode couleur 256-, comme dans l'exemple 10-6. Le programme affiche d'abord le bitmap de triangle dans le VGA standard / MCGA 320x200 mode graphique 256 couleurs (mode 19) sur un fond gris. Après une séquence de touches, le programme passe au mode graphique 320x200 16 couleurs EGA / VGA (mode 13). Dans ce mode, fg_drwimage attend deux pixels par octet bitmap, donc nous devons appeler fg_pack pour convertir les données bitmap à ce format. Nous stockons le bitmap résultant dans le tableau de triangle16 et encore utiliser fg_drwimage pour afficher le bitmap de triangle.

  Exemple 10-15.

  #include <fastgraf.h>
               void main (void);

  omble triangle [] = {
                  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                  0x00,0x01,0x02,0x02,0x02,0x02,0x02,0x01,0x00,
                  0x00,0x00,0x01,0x02,0x02,0x02,0x01,0x00,0x00,
                  0x00,0x00,0x00,0x01,0x02,0x01,0x00,0x00,0x00,
                  0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00
                  };
               omble triangle16 [25];

  void main ()
               {
                                           Chapitre 10: Bitmap Images 237


  int old_mode;

  fg_initpm ();
                  fg_getmode old_mode = ();

  fg_setmode (19);
                  fg_setcolor (7);
                  fg_fillpage ();
                  fg_move (156,101);
                  fg_drwimage (triangle, 9,5);
                  fg_waitkey ();

  fg_setmode (13);
                  fg_setcolor (7);
                  fg_fillpage ();
                  fg_pack (triangle, triangle16,9,5);
                  fg_move (156,101);
                  fg_drwimage (triangle16,5,5);
                  fg_waitkey ();

  fg_setmode (old_mode);
                  fg_reset ();
               }


Notez que le bitmap 256 couleurs est neuf octets de large et cinq octets de hauteur. Lorsque nous convertissons l'image au format spécifique au mode 16 couleurs, la largeur de la bitmap est réduite à cinq octets parce que deux pixels sont emballés dans chaque octet. Le second pixel dans le dernier octet de chaque ligne devient une charge pixel transparent (qui est, sa valeur est égale à zéro).

Comme vous pouvez le deviner, la routine de fg_unpack de Fastgraph effectue le contraire
fonction de fg_pack. Autrement dit, il convertit une image bitmap à partir du format spécifique au mode de fonctionnement du mode vidéo actuel au format "un pixel par octet". La routine de fg_unpack est conçu comme une fonction d'assistance pour l'affichage mode- images spécifiques dans des tampons virtuels lors de l'utilisation des modes vidéo avec moins de 256 couleurs. Quand un tampon virtuel est actif, fg_drwimage attend toujours le bitmap pour être dans le format «un pixel par octet", quel que soit le mode vidéo actuel. La routine de fg_unpack il est facile de convertir des images à ce format avant de les afficher dans un tampon virtuel.
deux premiers arguments de la routine de fg_unpack sont les adresses de la
la source et la destination des tableaux bitmap. Le tableau source contient l'image bitmap mode- spécifique, et le réseau de destination recevra l'image convertie "un pixel par octet". Le dernier argument de fg_unpack spécifie la taille de la matrice source en octets. Comme fg_pack, fg_unpack simplement copie les sources tableau contenu au tableau de destination dans les modes graphiques 256 couleurs ou quand un tampon virtuel est actif.

Exemple 10-16 illustre comment utiliser fg_unpack à mode spécifique convertir
bitmaps au format de mémoire virtuelle. Le programme utilise le 10-pixel par pixel 7-flèche bitmap d'exemple 10-9 et fonctionne dans le mode graphique 320x200 16 couleurs EGA / VGA (mode 13). Dans ce mode, deux pixels sont emballés dans chaque octet bitmap, de sorte que la taille de la matrice d'une image bitmap 5x7, soit 35 octets. L'appel à fg_unpack convertit l'image spécifique en mode dans le 35-octet flèche tableau dans une image "d'un pixel par octet" format, stocker le résultat dans le 70 tableau d'octets arrow256. Guide de l'utilisateur 238 Fastgraph


Nous allons créer un tampon virtuel de 70 octets - juste assez grand pour contenir le 10x7 flèche bitmap - et afficher le bitmap arrow256 en elle contre un bleu clair (couleur 9) fond. Enfin, nous allons utiliser fg_vbpaste pour afficher le contenu du tampon virtuel dans le milieu de l'écran.

  Exemple 10-16.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  omble flèche [] = {
                    0x00,0x00,0x00,0xF0,0x00,
                    0x00,0x00,0x00,0xFF, 0x00,
                    0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
                    0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                    0xFF, 0xFF, 0xFF, 0xFF, 0xF0,
                    0x00,0x00,0x00,0xFF, 0x00,
                    0x00,0x00,0x00,0xF0,0x00
                    };
                 arrow256 char [70];

  #ifdef FG32
                 char buffer [70];
                 #autre
                 carboniser loin tampon [70];
                 #fin si

  void main ()
                 {
                    poignée int;
                    int old_mode;

  fg_initpm ();
                    if (fg_testmode (13,1) == 0) {
                       printf ( "Ce programme nécessite une 320");
                       ( "le mode x 200 graphiques EGA \ n".) printf;
                       sortie (1);
                       }

  fg_getmode old_mode = ();
                    fg_setmode (13);
                    fg_unpack (flèche, arrow256,35);

  fg_vbinit ();
                    handle = fg_vbdefine (tampon, 10,7);
                    fg_vbopen (poignée);
                    fg_setcolor (9);
                    fg_fillpage ();
                    fg_move (0,6);
                    fg_drwimage (arrow256,10,7);

  fg_vbpaste (0,9,0,6,156,101);
                    fg_waitkey (); 
                                           Chapitre 10: Bitmap Images 239


  fg_vbclose ();
                    fg_setmode (old_mode);
                    fg_reset ();
                 }


===Bitmap Scaling et Shearing===

La routine de fg_scale de Fastgraph exécute mise à l'échelle horizontale et verticale
images bitmap. Il attend une bitmap source stockée dans le format "un pixel par octet" des modes 256 couleurs de Fastgraph, et il renvoie un bitmap élargi ou réduit dans le même format. Pour redimensionner des images dans les modes graphiques avec moins de 256 couleurs, vous devez d'abord utiliser fg_unpack pour convertir le bitmap au format attendu par fg_scale, effectuer la mise à l'échelle, et enfin utiliser fg_pack pour convertir l'image à l'échelle vers le format spécifique en mode. Parce que les tampons virtuels de Fastgraph utilisent également le pixel par format d'octet, vous pouvez également utiliser fg_scale à l'échelle des images stockées dans des tampons virtuels.

La routine de fg_scale a six arguments.  Les deux premiers spécifiez le
les adresses de source et de destination des tableaux bitmap. Le tableau source contient la (unscaled) image bitmap d'origine; le tableau de destination recevra le (échelle) bitmap élargie ou réduite. Les deux bitmaps sont stockés dans le format "un pixel par octet". Les troisième et quatrième arguments spécifient la largeur et la hauteur en pixels de l'image unscaled, tandis que les cinquième et sixième arguments font la même chose pour l'image à l'échelle résultant.

Exemple 10-17 montre comment développer et réduire les images bitmap avec
fg_scale. Le programme affiche un rectangle bleu 64x40 lumière avec une bordure blanche et le mot SCALE centrée à l'intérieur, dans le coin supérieur gauche de l'écran. Il récupère le contenu du rectangle en tant que bitmap mode spécifique en utilisant fg_getimage. Le premier appel de fg_scale augmente la taille de ce bitmap en 10 pixels dans les deux directions, ce qui signifie l'image de 64x40 devient une image de 74x50. Le programme affiche ensuite le bitmap étendu dans le coin inférieur gauche de l'écran en utilisant fg_putimage. Le deuxième appel de fg_scale réduit le bitmap d'origine par un facteur de deux pour créer une image bitmap 32x20. Le bitmap réduit est ensuite affiché dans le coin en bas à droite, à nouveau en utilisant fg_putimage. Notez que par exemple 10-17 fonctionne en mode 19, qui est un mode graphique 256 couleurs, de sorte que fg_getimage enregistre automatiquement l'image d'origine dans le format "un pixel par octet" attendu par fg_scale.

  Exemple 10-17.

  #include <fastgraf.h>
       void main (void);

  source de char [64 * 40], dest [74 * 50];

  void main ()
       {
          / * Initialisation de l'environnement vidéo * /

  fg_initpm ();
          fg_setmode (19);

  / * Dessiner un rectangle bleu avec une bordure blanche épaisse * /

  fg_setcolor (9);
          fg_rect (0,63,0,39);
          fg_setcolor (15);
          fg_boxdepth (5,5);
          fg_box (0,63,0,39);
          fg_move (32,20);
          fg_justify (0,0);
          fg_print ( "SCALE", 5);

  / * Récupérer le rectangle comme un mode spécifique bitmap * /

  fg_move (0,39);
          fg_getimage (source, 64,40);
          fg_waitkey ();

  / * Étendre le bitmap de 10 pixels dans chaque direction et * /
          / * Puis l'afficher dans le coin inférieur gauche de l'écran * /

  fg_move (0199);
          fg_scale (source, dest, 64,40,74,50);
          fg_putimage (dest, 74,50);
          fg_waitkey ();

  / * Réduire le bitmap d'origine de 50% dans chaque direction et * /
          / * Puis l'afficher dans le coin inférieur droit de l'écran * /

  fg_move (288,199);
          fg_scale (source, dest, 64,40,32,20);
          fg_putimage (dest, 32,20);
          fg_waitkey ();

  / * Restauration 80x25 mode texte et la sortie * /

  fg_setmode (3);
          fg_reset ();
       }

Shearing peut être considéré comme ancrage un coin d'un rectangle
région et en étirant le coin opposé horizontalement ou verticalement. Par exemple, bitmaps contenant du texte ou d'autres caractères peuvent être cisaillés horizontalement vers la droite pour un effet italiques. Une image cisaillée sera toujours plus grande que l'image d'origine, et il contiendra des zones vides triangulaires au niveau de ses coins. Les zones vides seront remplis de couleurs 0 pixels, ce qui signifie qu'ils seront transparents lorsque vous affichez une image cisaillée avec la famille de fg_drwimage de routines. Comme fg_scale, fg_shear attend bitmaps dans le format "un pixel par octet» et peut également être utilisé avec des images stockées dans des tampons virtuels.

La routine de fg_shear a six arguments.  Les deux premiers spécifiez le
les adresses de source et de destination des tableaux bitmap. Le tableau source contient l'image bitmap d'origine; le réseau de destination recevra le bitmap cisaillé. Les deux bitmaps sont stockés dans le format "un pixel par octet". Les troisième et quatrième arguments spécifient la largeur et la hauteur en pixels de l'image originale. Pour cisailles horizontales, le cinquième argument spécifie le
largeur en pixels de l'image bitmap cisaillé résultant. Pour ciseaux verticaux, il spécifie la hauteur résultante.

L'argument fg_shear finale définit le type de cisaillement.  Quatre cisaillement distinctes
types sont disponibles:

* Cisaillement horizontal gauche (bord inférieur de la région est tendue vers la droite)
* Cisaillement horizontal droit (bord supérieur de la région est tendue vers la droite)
* Cisaillement vertical gauche (bord gauche de la région est tendue vers le haut)
* Cisaillement vertical droit (bord droit de la région est tendue vers le haut)

Le type est sélectionné par une valeur comprise entre 0 et 3, correspondant respectivement aux quatre types de cisaillement ci-dessus. Par exemple, le type de cisaillement 2 représente un cisaillement vertical gauche.

Exemple 10-18 affiche un rectangle bleu 64x40 lumière avec une bordure blanche
et le mot CISAILLEMENT centré à l'intérieur, dans le coin supérieur gauche de l'écran. Il récupère le contenu du rectangle en tant que bitmap mode spécifique en utilisant fg_getimage. Le programme appelle ensuite fg_shear pour effectuer une 16-pixel cisaillement droite horizontale, qui étend le bord supérieur de l'image 16 pixels vers la droite. Cela produit une image bitmap 80x40, qui est ensuite affichée dans le coin inférieur gauche de l'écran avec fg_putimage. Parce que cet exemple fonctionne en mode 19, qui est un mode graphique 256 couleurs, fg_getimage enregistre automatiquement l'image d'origine dans le format "un pixel par octet" attendu par fg_shear.

  Exemple 10-18.

  #include <fastgraf.h>
       void main (void);

  source de char [64 * 40], dest [80 * 40];

  void main ()
       {
          / * Initialisation de l'environnement vidéo * /

  fg_initpm ();
          fg_setmode (19);

  / * Dessiner un rectangle bleu avec une bordure blanche épaisse * /

  fg_setcolor (9);
          fg_rect (0,63,0,39);
          fg_setcolor (15);
          fg_boxdepth (5,5);
          fg_box (0,63,0,39);
          fg_move (32,20);
          fg_justify (0,0);
          fg_print ( "CISAILLEMENT", 5);

  / * Récupérer le rectangle comme un mode spécifique bitmap * /

  fg_move (0,39);
          fg_getimage (source, 64,40);
          fg_waitkey (); 

  / * Bitmap de cisaillement horizontale et à droite 16 pixels * /
          / * Puis l'afficher dans le coin inférieur gauche de l'écran * /

  fg_move (0199);
          fg_shear (source, dest, 64,40,80,1);
          fg_putimage (dest, 80,40);
          fg_waitkey ();

  / * Restauration 80x25 mode texte et la sortie * /

  fg_setmode (3);
          fg_reset ();
       }


Il est possible d'utiliser fg_shear pour rudimentaire rotation bitmap.  Tonte
une image à gauche horizontalement puis verticalement à droite par le même montant faire pivoter une image dans le sens antihoraire. De même, le cisaillement horizontal à droite et puis à gauche verticalement va tourner dans le sens horaire.

tampons virtuels utilisent le même format "un pixel par octet" attendu par
fg_scale et fg_shear. Cela signifie que vous pouvez passer des adresses de tampon virtuelles à ces fonctions et d'appliquer les opérations de mise à l'échelle et de cisaillement sur les tampons virtuels. Notez toutefois que les modes 16 bits limitent la taille des tableaux passés à fg_scale et fg_shear à 64K octets, ce qui signifie que vous ne pouvez pas appliquer ces fonctions pour les tampons virtuels plus grandes. En outre, l'adresse d'un tampon virtuel en mode réel est un segment: paire offset, vous devez donc utiliser le modèle de mémoire à grande échelle ou des images de cisaillement résidant dans des tampons virtuels dans des programmes en mode réel.

Exemple 10-19 montre comment à l'échelle le contenu d'un tampon virtuel.

Le programme crée deux tampons virtuelles - l'un est 320x200 pixels et l'autre est un quart de cette taille, ou 80x50 pixels. L'image CORAL.PCX est chargé dans le tampon virtuel 320x200 en utilisant la routine de fg_loadpcx puis copié dans la page visuelle. Le programme appelle ensuite fg_scale, en lui passant les deux adresses de tampons virtuels, pour réduire l'image à un quart de sa taille originale. L'image résultante est stockée dans le tampon virtuel 80x50 et finalement copié dans le coin inférieur gauche de la page visuelle.

  Exemple 10-19.

  #include <fastgraf.h>
           #include <stdio.h>
           #include <stdlib.h>
           #if defined (__ TURBOC__)
           #include <alloc.h>
           #autre
           #include <malloc.h>
           #fin si
           void main (void);

  void main ()
           {
              int handle1, handle2;
           #if defined (__ WATCOMC__) ||  défini (__ HIGHC__)
              char * buffer1, * buffer2;
           #else
                                           Chapitre 10: Bitmap Images 243


  carboniser loin * buffer1, loin * buffer2;
           #fin si

  fg_initpm ();
              fg_setmode (19);
              fg_vbinit ();

  #if defined (__ WATCOMC__) ||  défini (__ HIGHC__)
              buffer1 = (char *) malloc (320 * 200);
              buffer2 = (char *) malloc (80 * 50);
           #elif défini (__ TURBOC__)
              buffer1 = (char loin *) farmalloc (320L * 200L);
              buffer2 = (char loin *) farmalloc (80L * 50L);
           #autre
              buffer1 = (char loin *) halloc (320L * 200L, 1);
              buffer2 = (char loin *) halloc (80L * 50L, 1);
           #fin si
              if (buffer1 == NULL || buffer2 == NULL)
              {
                 fg_setmode (3);
                 fg_reset ();
                 printf ( "Impossible de créer les tampons virtuels. \ n");
                 sortie (1);
              }
              handle1 = fg_vbdefine (buffer1,320,200);
              handle2 = fg_vbdefine (buffer2,80,50);

  fg_vbopen (handle1);
              fg_loadpcx ( "CORAL.PCX", 0);
              fg_vbpaste (0,319,0,199,0,199);
              fg_waitkey ();

  fg_scale (buffer1, buffer2,320,200,80,50);
              fg_vbopen (handle2);
              fg_vbpaste (0,79,0,49,0,199);
              fg_waitkey ();

  fg_vbclose ();
              fg_setmode (3);
              fg_reset ();
           }


Dans l'exemple 10-19, nous avons créé les tampons virtuels avec fg_vbdefine, donc nous
connaissait leurs adresses. Que faire si nous étions en utilisant le mode BASIC ou réel Pascal et les avons créés avec fg_vballoc? Dans ce cas, les adresses tampons virtuels ne seraient pas immédiatement disponibles pour le programme. Heureusement, il existe une solution facile. La fonction de fg_vbaddr de Fastgraph renvoie l'adresse de la mémoire tampon virtuelle spécifiée; son seul argument est la poignée de tampon virtuel. Dans les modes 16 bits, l'adresse sera un véritable segment des modes: paire offset ou sélecteur de mode protégé: paire offset. Dans les modes de 32 bits, ce sera un décalage dans le segment de données par défaut. Si vous utilisez fg_vballoc dans l'exemple 10-19, la création et l'adresse de la mémoire tampon de récupération virtuelle pourrait se faire comme suit:

carboniser loin * buffer1, loin * buffer2; 

  handle1 = fg_vballoc (320,200);
     handle2 = fg_vballoc (80,50);
     if (handle1 <0 || handle2 <0) {
        fg_setmode (3);
        fg_reset ();
        printf ( "Impossible de créer les tampons virtuels. \ n");
        sortie (1);
        }
     buffer1 = (char loin *) fg_vbaddr (handle1);
     buffer2 = (char loin *) fg_vbaddr (handle2);

Les états de libérer la mémoire allouée aux tampons virtuels serait:

  fg_vbclose ();
     fg_vbfree (handle1);
     fg_vbfree (handle2);


===Pixel Plans Run===

Les bitmaps utilisés avec le fg_drawmap, fg_drwimage et routines connexes
peut consommer de l'espace de tableau assez rapidement. Cela est particulièrement vrai si l'image est grande ou contient beaucoup de couleurs. Par exemple, une image en mode indépendant pixelisée qui occupe la totalité de l'écran en mode graphique 320x200 nécessite 8000 octets d'espace par couleur. Fastgraph fournit un autre appelé cartes de pixels exécuter de format d'image en mode indépendant, qui sont plus efficaces en termes d'espace. cartes de pixels exécuter sont structurées comme les fichiers de pixels exécuter introduits dans le chapitre précédent, mais l'image réside dans un tableau à la place d'un fichier.

Revenons à notre exemple de triangle familier et montrent comment nous pourrions utiliser un
pixel carte pour afficher fonctionner.

  .  .  .  .  *.  .  .  .
                               .  .  .  * X * .  .  .
                               .  .  * Xxx *.  .
                               .  * Xxxxx *.
                               * * * * * * * * *

Comme précédemment, les pixels indiqués par un astérisque (*) sont le périmètre du triangle, tandis que celles qui sont indiquées par un x représentent ses points intérieurs. Les pixels affichés comme des périodes (.) Ne font pas partie du triangle lui-même, mais ils font partie de la carte pixel de l'exécution.

En utilisant le format standard pixel d'exécution introduite dans le chapitre précédent,
nous voyons qu'il faut 16 pixels pistes pour stocker l'image de notre triangle comme une carte pixel de l'exécution. Si nous voulons afficher les pixels périphériques de couleur 1, les pixels intérieurs de couleur 2, et la zone de remplissage de couleur 7, la carte pixel d'exécution devrait contenir 16 ensembles de (couleur, count) paires: (1,9), ( 7,1), (1,1), (2,5), (1,1), (7,3), (1,1), (2,3), (1,1), (7, 5), (1,1), (2,1), (1,1), (7,7), (1,1) et (7,4). Contrairement aux formats d'image bitmap déjà discuté, cartes de pixels exécuter ne comportent aucune disposition pour les couleurs transparentes.

La fg_display routine Fastgraph affiche une image stockée comme une course de pixel
carte. La routine fg_display attend trois arguments. Le premier est un tableau contenant les pistes de pixels (transmis par référence), le second est le nombre de
pixel fonctionne dans le réseau, et la troisième est la largeur en pixels de l'image. Comme avec les autres routines d'affichage d'image, fg_display affiche l'image de telle sorte que son coin inférieur gauche est à la position graphique du curseur sur la page vidéo active ou tampon virtuel. Encore une fois, le format de la carte pixel d'exécution est le même que celui d'un fichier pixel d'exécution standard. En outre, tous les motifs d'affichage définis par fg_pattern sont également valables pour fg_display.

Exemple 10-20 utilise la routine de fg_display pour afficher le triangle en tant que
pixel carte de l'exécution dans un mode graphique 320x200. Le programme affiche le triangle sur un fond de couleur 7, de sorte que le choix de la couleur 7 pour la zone de remplissage était important. Si une autre couleur ont été choisis, la zone de remplissage ne se fondre dans l'arrière-plan.

  Exemple 10-20.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  omble triangle [] = {
                    1,9, 7,1, 1,1, 2,5, 1,1, 7,3, 1,1, 2,3,
                    1,1, 7,5, 1,1, 2,1, 1,1, 7,7, 1,1, 7,4
                    };

  void main ()
                 {
                    int old_mode, new_mode;

  fg_initpm ();
                    new_mode = fg_bestmode (320,200,1);
                    if (new_mode <0 || new_mode == 12) {
                       printf ( "Ce programme nécessite une 320");
                       ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

  fg_getmode old_mode = ();
                    fg_setmode (new_mode);

  fg_setcolor (7);
                    fg_rect (0,319,0,199);

  fg_move (156,101);
                    fg_display (triangle, 16,9);
                    fg_waitkey ();

  fg_setmode (old_mode);
                    fg_reset ();
                 }


Comme vous pouvez le deviner, Fastgraph offre également un pixel d'image emballé run carte
le format analogue au format de fichier d'exécution de pixel emballé introduit dans le chapitre précédent. Exemple 10 à 21 est identique à l'exemple 10-20, mais elle utilise plutôt que fg_displayp fg_display pour afficher l'image. Notez l'utilisation du Guide 246 Fastgraph utilisateur


nombres hexadécimaux pour définir les valeurs de couleur emballés, ce qui est évidemment pas nécessaire, mais certainement plus facile à lire que d'exprimer les quantités que les nombres décimaux. Comme fg_display, tous les motifs d'affichage définis par fg_pattern appliquent également à fg_displayp.

  Exemple 10-21.

  #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                 void main (void);

  omble triangle [] = {
                    0x17,9,1, 0x12,1,5, 0x17,1,3, 0x12,1,3,
                    0x17,1,5, 0x12,1,1, 0x17,1,7, 0x17,1,4
                    };

  void main ()
                 {
                    int old_mode, new_mode;

  fg_initpm ();
                    new_mode = fg_bestmode (320,200,1);
                    if (new_mode <0 || new_mode == 12) {
                       printf ( "Ce programme nécessite une 320");
                       ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }

  fg_getmode old_mode = ();
                    fg_setmode (new_mode);

  fg_setcolor (7);
                    fg_rect (0,319,0,199);

  fg_move (156,101);
                    fg_displayp (triangle, 16,9);
                    fg_waitkey ();

  fg_setmode (old_mode);
                    fg_reset ();
                 }


Les deux fg_display et fg_displayp nécessitent l'image pixel de l'exécution pour être stocké
dans un tableau. Dans les exemples 10-20 et 10-21, l'image est définie dans le programme lui-même. Nous pouvons également utiliser ces routines en place de fg_dispfile lorsque l'image est stockée dans un fichier si on lit d'abord le contenu du fichier dans un tableau. Exemple 10-22 démontre cette procédure. Le programme affiche deux images identiques stockées dans des fichiers, un au format pixel de fonctionnement standard et l'autre au format pixel de course emballé.

La première image, au format pixel de l'exécution standard, est dans le fichier CORAL.SPR.

Notez le programme doit ouvrir le fichier pour la lecture en mode binaire ( "rb" dans l'appel à fopen). Le programme lit tout le contenu du fichier dans le tableau pixel_runs, dont la taille doit être au moins aussi grande que la taille du fichier.

Parce que l'image est stockée au format pixel d'exécution standard, le nombre de pixels pistes est la moitié de la taille du fichier. Le programme utilise ensuite fg_move pour établir le coin inférieur gauche de l'écran comme la position graphique du curseur et appelle ensuite fg_display pour afficher l'image. L'image remplit tout l'écran, de sorte que sa largeur est de 320 pixels.

Après avoir attendu pendant une séquence de touches, le programme affiche la même manière la seconde
image. Cette image est dans le fichier CORAL.PPR et sont stockées au format pixel d'exécution emballés. Parce que l'image est emballé, le nombre de pixels pistes est de deux tiers la taille du fichier. Le programme efface alors l'image précédente de l'écran et des appels fg_displayp pour afficher l'image. Après une autre touche, le programme restaure le mode vidéo et écran attributs et retours originaux à DOS.

  Exemple 10-22.

  #include <fastgraf.h>
              #include <io.h>
              #include <stdio.h>
              #include <stdlib.h>
              void main (void);

  pixel_runs char [20000];

  void main ()
              {
                 * FILE stream;
                 int file_size, run_count;
                 int old_mode, new_mode;

  fg_initpm ();
                 new_mode = fg_bestmode (320,200,1);
                 if (new_mode <0 || new_mode == 12) {
                    printf ( "Ce programme nécessite une 320");
                    ( "le mode x 200 graphiques couleur \ n".) printf;
                    sortie (1);
                    }

  fg_getmode old_mode = ();
                 fg_setmode (new_mode);

  flux = fopen ( "CORAL.SPR", "rb");
                 file_size = (int) (filelength (fileno (flux)));
                 fread (pixel_runs, sizeof (char), file_size, flux);
                 fclose (flux);
                 run_count = file_size / 2;
                 fg_move (0199);
                 (fg_display pixel_runs, run_count, 320);
                 fg_waitkey ();

  flux = fopen ( "CORAL.PPR", "rb");
                 file_size = (int) (filelength (fileno (flux)));
                 fread (pixel_runs, sizeof (char), file_size, flux);
                 fclose (flux);
                 run_count = file_size / 3 * 2;
                 fg_erase ();
                 (fg_displayp pixel_runs, run_count, 320); 

  fg_waitkey ();

  fg_setmode (old_mode);
                 fg_reset ();
              }


===Cartes masquants===

Il est impossible d'inclure la couleur 0 pixels dans une image affichée avec
fg_drwimage, fg_clpimage, fg_revimage ou fg_flpimage. En effet, ces routines considèrent la couleur 0 pixels pour être transparent, ce qui signifie ces pixels ne modifient pas les pixels correspondants dans la mémoire vidéo. Il y a des moments, cependant, quand vous voulez couleur 0 pixels pour être destructeur, ou remplacer le contenu de la mémoire vidéo.

Considérons à nouveau l'image de la flèche de l'exemple 10-8.  Dans cet exemple, nous
affiché un blanc (couleur 3) du contre un noir (couleur 0) fond en mode quatre couleurs graphique standard CGA. Supposons, cependant, que nous voulons faire tout le contraire - afficher un noir (couleur 0) flèche contre un blanc (couleur 3) fond. Nous pourrions de l'utilisation des cours fg_putimage, fg_drawmap, ou l'une des routines pour l'affichage des cartes de pixels courir, mais ces méthodes ne prennent pas en charge l'écrêtage ou inverser une image. Il y a, cependant, quatre routines Fastgraph conçus spécialement à cet effet. Ces routines sont fg_drawmask, fg_clipmask, fg_revmask et fg_flipmask.

Chacune de ces routines utilise une structure de données appelée une carte de masquage.  UNE
masquage carte est une structure similaire à une carte pixel de l'exécution, mais il ne comprend pas les informations sur les couleurs. Au lieu de cela, il se compose d'une série de pixels court qui alternent entre des pixels protégés et non protégés. Un exemple pourrait mieux clarifier ce point.

  Encore une fois, voici l'image de la flèche de l'exemple 10-8.

  .  .  .  .  .  .  *.  .  .
                              .  .  .  .  .  .  * *.  .
                              * * * * * * * * *.
                              * * * * * * * * * *
                              * * * * * * * * *.
                              .  .  .  .  .  .  * *.  .
                              .  .  .  .  .  .  *.  .  .

Cette fois, cependant, nous voulons que la flèche apparaisse dans la couleur 0. En d'autres termes, nous avons besoin des pixels "période" (.) Pour protéger la mémoire vidéo, alors que nous voulons que les pixels "astérisque" (*) à la mémoire de zéro vidéo. En regardant ce problème du point de vue d'un pixel de carte de course, nous avons une série alternée de «protéger» et «zéro» fonctionne. On n'a pas besoin des informations sur les couleurs de pixels, juste que ce soit pour protéger ou mettre à zéro la mémoire vidéo.

Telle est précisément la structure d'une carte de masquage.  A partir de la partie inférieure
coin gauche de l'image et de passer à la droite, enveloppant à la ligne suivante en cas de besoin, nous pourrions représenter cette image comme une carte de masquage avec 6 pixels protégés, 1 pixel mis à zéro, 9 pixels protégées, 2 remises à zéro pixels, et ainsi de suite. D'une manière générale, la structure d'une feuille de masquage se présente comme suit.

  Chapitre 10: Bitmap Images 249


  [1] longueur de 1ère manche de protection

  [2] longueur du 1er zéro run

  [3] longueur du 2ème manche de protection

  [4] longueur de 2ème manche zéro

  .
                                         .
                                         .

  [N-2] longueur de course finale de protection

  [N-1] longueur de course finale zéro


En regardant ce diagramme, nous voyons les éléments de tableau paires détiennent la
longueur des «protéger» fonctionne, et les éléments impairs détiennent la longueur des «zéro» fonctionne. Si vous avez besoin de la première manche pour être une course "zéro", il suffit d'inclure une "protection" run de longueur zéro comme le premier élément du tableau. Si la course finale est une course «protéger», vous ne devez inclure une longueur de zéro "zéro" de l'exécution à la fin du tableau.Enfin, si les deux types d'exécution dépasse 255 pixels, vous devez diviser cela en deux ou plusieurs séries de pixels. Dans ce cas, assurez-vous d'inclure une course de longueur nulle de l'autre type entre les deux éléments du tableau.

Exemple 10-23 illustre l'utilisation d'une carte de masquage par fg_drawmask,
fg_clipmask, fg_revmask et fg_flipmask en mode quatre couleurs graphique standard CGA (mode 4) pour dessiner un noir (couleur 0) flèche sur un fond blanc. Ces quatre routines sont respectivement analogues aux fg_drwimage, fg_clpimage, fg_revimage et fg_flpimage, mais ils utilisent des cartes de masquage plutôt que bitmaps. Le premier argument de chaque routine est le masquage carte réseau (passé par référence), le second argument est le nombre de pistes (qui est, le nombre d'éléments) dans le masquage carte réseau, et le troisième argument est la largeur en pixels de l'image.

 Exemple 10-23.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 omble flèche [] = {6,1,9,2,2,9,1,19,7,2,8,1};

 void main ()
                 {
                   int old_mode;

 fg_initpm ();
                   if (fg_testmode (4,1) == 0) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques CGA \ n".) printf;
                       sortie (1);
                      }   

 fg_getmode old_mode = ();
                   fg_setmode (4);
                   fg_setclip (0,15,0,199);

 fg_setcolor (3);
                   fg_rect (0,319,0,199);

 fg_move (10,10);
                   fg_drawmask (flèche, 12,10);
                   fg_move (10,20);
                   fg_clipmask (flèche, 12,10);
                   fg_move (10,30);
                   fg_revmask (flèche, 12,10);
                   fg_move (10,40);
                   fg_flipmask (flèche, 12,10);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


L'une des caractéristiques les plus utiles de cartes de masquage est leur capacité à effacer
une partie de mémoire vidéo avant de placer une image là. Cette technique fournit un moyen simple efficace pour inclure la couleur 0 pixels dans une image. Il est particulièrement efficace lors de l'affichage des images tramées de grande taille ou parce que la carte de masquage est généralement beaucoup plus faible que le bitmap requis par fg_drawmap ou de ses routines associées. Exemple 10-24 illustre ce processus dans le CGA mode quatre couleurs graphiques standard (mode 4) en affichant l'image de notre flèche sur un fond coloré. Dans cet exemple, la flèche a un blanc (couleur 3) périmètre et un noir (couleur 0) intérieur.

Le programme affiche la flèche en deux étapes. Il utilise d'abord fg_drawmask à
effacer la mémoire vidéo où la flèche sera affichée. Il tire ensuite le périmètre de la flèche à l'aide fg_drwimage. Les pixels intérieurs dans le bitmap de périmètre sont transparents, mais étant donné que nous venons concentrions que la mémoire vidéo, ils apparaissent en couleur 0. Notez que nous pourrions améliorer cet exemple en créant une carte de masquage plus petit qui ne vaut que pour le rectangle d'inscrire l'intérieur de la flèche. Autrement dit, on n'a pas besoin à zéro la mémoire vidéo dans le périmètre de la flèche parce que nous allons immédiatement afficher d'autres pixels là.

 Exemple 10-24.

 #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
             void main (void);

 carboniser Arrow_white [] = {
                0x00,0x0C, 0x00, 0x00,0x0F, 0x00, 0xFF, 0xFC, 0xC0,
                0xC0,0x00,0x30, 0xFF, 0xFC, 0xC0, 0x00,0x0F, 0x00,
                0x00,0x0C, 0x00
                 };

 carboniser arrow_black [] = {6,1,9,2,2,9,1,19,7,2,8,1}; 
                                          Chapitre 10: Bitmap Images 251


 void main ()
              {
                int old_mode;

 fg_initpm ();
                if (fg_testmode (4,1) == 0) {
                   printf ( "Ce programme nécessite une 320");
                   ( "le mode x 200 graphiques CGA \ n".) printf;
                    sortie (1);
                    }

 fg_getmode old_mode = ();
                fg_setmode (4);

 fg_setcolor (2);
                fg_rect (0,319,0,199);

 fg_move (10,10);
                fg_drawmask (arrow_black, 12,10);
                fg_drwimage (Arrow_white, 3,7);
                fg_waitkey ();

 fg_setmode (old_mode);
                fg_reset ();
              }


===Résumé de l'image bitmap d'affichage Routines===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

Pour toutes les routines d'image bitmap, les images sont affichées ou extraites afin
leur coin inférieur gauche est à la position du curseur graphique (ou de la position du curseur de texte pour les routines qui fonctionnent également en mode texte vidéo). Dans des environnements de 16 bits, la taille des éventuels tableaux transmis à ces routines est limitée à 64K octets.

FG_CLIPMAP affiche une image rognée stockée sous forme de bitmap en mode indépendant.
Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_CLIPMASK affiche une image rognée stockée sous forme de carte de masquage.  Ce
routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_CLPIMAGE affiche une image rognée stockée sous forme de bitmap mode spécifique.
Couleur 0 pixels sont considérés comme transparents. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_DISPLAY affiche une image stockée dans l'exécution de pixel standard Fastgraph
le format, où l'image se trouve dans un tableau. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte. Guide de l'utilisateur 252 Fastgraph

FG_DISPLAYP affiche une image stockée dans emballés piste de pixel de Fastgraph
le format, où l'image se trouve dans un tableau. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_DRAWMAP affiche une image stockée sous forme de bitmap en mode indépendant.  Ce
routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_DRAWMASK affiche une image stockée sous forme de carte de masquage. Cette routine a
aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_DRWIMAGE affiche une image stockée sous forme de bitmap mode spécifique. Couleur 0
les pixels sont considérés comme transparents.

FG_FLIPMASK affiche une image écrêté inversée stockée sous forme de carte de masquage.
Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_FLPIMAGE affiche une image écrêté inversée stockée comme un mode spécifique
bitmap. Couleur 0 pixels sont considérés comme transparents. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_GETIMAGE récupère une image en tant que bitmap mode spécifique.

FG_GETMAP récupère une image en tant que bitmap en mode indépendant. Cette routine
n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_IMAGESIZ détermine le nombre d'octets requis pour stocker un mode-
image bitmap spécifique des dimensions spécifiées.

FG_INVERT intervertit l'ordre des lignes d'un mode spécifique ou en mode indépendant
image bitmap, donc un "haut en bas" image devient un "bas en haut" image, ou vice versa.

FG_PACK convertit un bitmap dans le format "un pixel par octet" utilisé dans
modes graphiques 256 couleurs et des tampons virtuels au format spécifique en mode bitmap pour le mode vidéo actuel.

FG_PUTIMAGE affiche une image stockée sous forme de bitmap mode spécifique.  Non
le soutien est prévu pour les pixels transparents.

FG_REVIMAGE affiche une image inversée stockée sous forme de bitmap mode spécifique.
Couleur 0 pixels sont considérés comme transparents. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_REVMASK affiche une image inversée stockée sous forme de carte de masquage.  Ce
routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_SCALE agrandit ou réduit une image bitmap stockée dans le "un pixel
par octet format ".

FG_SHEAR cisaille une image bitmap stockée dans le "un pixel par octet"
format.

FG_UNPACK convertit une image bitmap mode spécifique à la "un pixel par
octet format "utilisé dans les modes graphiques 256 couleurs et des tampons virtuels.

FG_VBADDR renvoie l'adresse de la mémoire tampon virtuelle spécifiée. En 16 bits
modes, l'adresse sera un véritable segment des modes: paire offset ou sélecteur de mode protégé: paire offset. Dans les modes de 32 bits, ce sera un décalage dans le segment de données par défaut. Guide de l'utilisateur 254 Fastgraph


==Bloc-transfert Routines==

Les routines Fastgraph décrites dans ce chapitre copier des blocs rectangulaires
entre les zones de mémoire vidéo, entre les tampons virtuels, entre la mémoire conventionnelle et la mémoire vidéo, ou entre la mémoire conventionnelle et les tampons virtuels. Ces routines sont parfois appelés Blit ou BitBlt routines dans d'autres documents. Les blocs-transferts sont utiles dans de nombreuses applications graphiques, mais ils sont particulièrement importants dans l'animation.

astgraph fournit plusieurs types de routines de transfert de bloc, chaque
optimisé pour son but spécifique. Du fait que ces routines sont souvent utilisés dans des contextes de vitesse critique, ils ne remplissent pas écrêtage. Si nécessaire, l'écrêtage peut généralement être fait au niveau de l'application en ajustant le bloc coordonnées pour tenir dans la zone de découpage.

Ce chapitre discutera des routines de transfert de bloc de Fastgraph en détail.

Les informations présentées ici, combinée à la page vidéo, mémoire virtuelle, et les routines de gestion de l'image des trois chapitres précédents, fournira les outils dont nous avons besoin pour les techniques d'animation présentés dans le chapitre suivant.


===Plein transfert===

simple routine de transfert de blocs de Fastgraph est fg_copypage, introduit en
Chapitre 8. Les transferts de routine fg_copypage l'ensemble de contenu d'une page vidéo à un autre. Le premier argument est le numéro de la page vidéo source, et le second argument est le numéro de la page de destination vidéo. Les pages peuvent être des pages vidéo physiques, virtuels ou logiques. Si les pages à la fois la source et la destination sont des pages logiques, les pages doivent exister dans le même type de mémoire. Par exemple, vous ne pouvez pas copier une page logique dans la mémoire étendue à une page logique dans la mémoire conventionnelle. La routine de fg_copypage travaille toujours avec des pages vidéo, même si un tampon virtuel est actif.

Exemple 11-1 illustre l'utilisation de fg_copypage dans une couleur 320x200
le mode graphique. Le programme affiche le mot «test» dans le milieu de la page visuelle (page 0) puis fg_allocate utilise pour créer une page vidéo virtuel (page 1). La page virtuelle est nécessaire dans le cas où le programme est en cours d'exécution dans un mode vidéo avec une seule page physique. Ensuite, le programme fg_copypage utilise pour transférer le contenu des pages visuelles à la page 1. Après avoir attendu pendant une séquence de touches, le programme efface la page visuelle, attend une autre touche, et copie le contenu de la page 1 retour à la page visuelle. Il libère alors la page et sorties virtuelles.

 Exemple 11-1.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode;

 fg_initpm (); 
                                   Chapitre 11: Bloc-transfert Routines 257


 new_mode = fg_bestmode (320,200,2);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (7);
                   fg_rect (0,319,0,199);
                   fg_setcolor (9);
                   fg_locate (12,18);
                   fg_text ( "test", 4);
                   fg_waitkey ();

 fg_allocate (1);
                   fg_copypage (0,1);
                   fg_erase ();
                   fg_waitkey ();

 fg_copypage (1,0);
                   fg_waitkey ();

 fg_freepage (1);
                   fg_setmode (old_mode);
                   fg_reset ();
                 }


===Limites d'octets===

La mémoire vidéo, comme la mémoire vive standard, est divisé en unités
appelés octets. En mode texte, chaque octet détient soit un caractère ou un attribut. Dans les modes graphiques, chaque octet de mémoire vidéo détient un ou plusieurs pixels horizontalement contigus. Si deux pixels adjacents horizontaux sont stockés dans différents octets, nous disons une limite d'octet existe entre les deux pixels.

Le nombre de pixels par octet dépend du mode vidéo étant utilisé, de sorte que
l'emplacement des limites d'octets dépend également du mode vidéo. Autrement dit, une limite d'octet dans un mode graphique CGA est pas nécessairement une limite d'octet dans un mode graphique VGA. Le tableau suivant résume le nombre de pixels par octet de mémoire vidéo et les octets des séquences limites pour chaque mode graphique vidéo pris en charge. Notez que toute coordonnée horizontale dont la valeur est un multiple de 8 est toujours une limite d'octet, quel que soit le mode vidéo.

 Mode pixels coordonnées horizontales
                     nombre par octet de limites d'octet

 4 4 0, 4, 8, 12, ..., 316
                        5 4 0, 4, 8, 12, ..., 316
                        6 8 0, 8, 16, 24, ..., 632
                        9 2 0, 2, 4, 6, ..., 318
                       11 8 0, 8, 16, 24, ..., 712
                       12 4 0, 4, 8, 12, ..., 316   

Guide de l'utilisateur 258 Fastgraph


 13 8 0, 8, 16, 24, ..., 312
                       14 8 0, 8, 16, 24, ..., 632
                       15 8 0, 8, 16, 24, ..., 632
                       16 8 0, 8, 16, 24, ..., 632
                       17 8 0, 8, 16, 24, ..., 632
                       18 8 0, 8, 16, 24, ..., 632
                       19 1 0, 1, 2, 3, ..., 319
                       20 1 0, 4, 8, 12, ..., 316
                       21 1 0, 4, 8, 12, ..., 316
                       22 1 0, 4, 8, 12, ..., 316
                       23 1 0, 4, 8, 12, ..., 316
                       24 1 0, 1, 2, 3, ..., 639
                       25 1 0, 1, 2, 3, ..., 639
                       26 1 0, 1, 2, 3, ..., 799
                       27 1 0, 1, 2, 3, ..., 1023
                       28 8 0, 8, 16, 24, ..., 792
                       29 8 0, 8, 16, 24, ..., 1 016

routines de transfert de bloc sont souvent utilisés dans des séquences d'animation nécessitant
graphiques de haute performance, de sorte que ces routines doivent être aussi efficaces que possible. À cette fin, Fastgraph va forcer leurs coordonnées pixel horizontal octet frontières, ce qui élimine la nécessité de traiter tous les pixels individuellement. Fastgraph accomplit ceci en réduisant les coordonnées minimales horizontales à une limite d'octet et étendant les coordonnées maximales horizontales au dernier pixel dans un octet de mémoire vidéo. Puisque nous parlons de coordonnées de pixels et non pas des cellules de caractères, l'ajustement de coordonnées se produit uniquement dans les modes graphiques vidéo. Concevoir une application pour des transferts de blocs se produisent sur les limites d'octet peut prendre une planification supplémentaire, mais ce sera du temps bien dépensé.

Un exemple pourrait mieux contribuer à expliquer cette caractéristique importante.  dans le
modes graphiques 16 couleurs EGA / VGA / SVGA (modes 13 à 18, 28 et 29), les limites d'octet se produisent à chaque huitième pixel. Ainsi, lorsque vous utilisez les routines de transfert de bloc dans ces modes, Fastgraph réduit au minimum x coordonnées au multiple inférieur de huit. De même, il étend leur maximum x coordonnées au multiple supérieur de huit ans, moins un pixel. Autrement dit, si un minimum coordonnée x est de 10 et un maximum de coordonnée x est 30, Fastgraph ajustera ces valeurs à 8 et 31 respectivement. Si les coordonnées x étaient à l'origine 8 et 31, Fastgraph serait de les laisser inchangés.

Dans les modes graphiques 256 couleurs les MCGA et SVGA (modes 19 et 24 à 27)
chaque pixel occupe un octet distinct de la mémoire vidéo, de sorte Fastgraph n'a pas besoin d'ajuster les coordonnées horizontales. Cependant, dans les modes les XVGA graphiques (modes 20 à 23), un certain ajustement de coordonnées peut être nécessaire. Les modes de XVGA stocker quatre pixels à chaque adresse de mémoire vidéo, un dans chacun des quatre plans de bits. Le numéro de plan de bits pour un pixel dont la coordonnée horizontale est x est donnée par la quantité x modulo 4. Dans les modes de XVGA, la source et la destination minimum coordonnées x doit faire référence à des pixels dans le même plan de bits. Autrement dit, la relation

xmin_source modulo 4 = 4 modulo xmin_destination
doit être vrai. Dans le cas contraire, Fastgraph réduit la valeur x destination minimale au même plan de bits que la valeur x source minimale.


===Banks double SVGA===

L'accès à la mémoire vidéo en mode graphique SVGA est contrôlée par un
système bancaire qui mappe des blocs de 64Ko contigus de mémoire vidéo dans un espace d'adressage segmenté. En d'autres termes, le référencement d'un octet spécifique dans la mémoire vidéo nécessite un numéro de banque et une adresse dans cette banque. Certains chipsets SVGA fournissent séparé lire et écrire des registres bancaires, tandis que d'autres effectuent les opérations à travers le même registre de la banque.

Si un chipset prend en charge lecture et d'écriture séparées banques, bloc de Fastgraph
des routines de transfert peuvent copier la zone de source directement à la région de destination. Cependant, les chipsets qui emploient un registre bancaire unique exigent que ces routines copient la région de source à un tampon intermédiaire et puis copiez le contenu du tampon à la destination. Cela rend évidemment une opération de transfert de bloc plus lent sur les chipsets mono-bancaires. Bit 3 de la valeur de retour de fg_svgastat sera réglé si le SVGA chipset actif prend en charge lecture séparée et écrire les banques.


===La vidéo "Hidden" page===

Certaines des routines de transfert de bloc de Fastgraph référencer une page vidéo appelé
la page cachée. La fg_sethpage routine Fastgraph définit quelle page vidéo sera utilisé comme page cachée. Cette routine prend comme seul argument une valeur entière spécifiant le numéro de page cachée. Si vous utilisez une page vidéo virtuel pour la page cachée, vous devez appeler fg_sethpage après l'attribution de cette page. Il y a aussi une routine fg_gethpage nommée qui renvoie le numéro de page cachée, comme spécifié dans l'appel le plus récent à fg_sethpage, comme sa valeur de fonction. La routine de fg_gethpage ne prend aucun argument.


===Sauvegarde et restauration de blocs===

Les deux prochaines routines de transfert de bloc, nous allons discuter sont fg_save et
fg_restore. Les transferts fg_save de routine d'une région rectangulaire de la page vidéo actif (tel que défini dans l'appel le plus récent à fg_setpage) à la même position sur la page vidéo cachée (tels que définis dans l'appel le plus récent à fg_sethpage). La routine de fg_restore exécute la tâche complémentaire - elle transfère une région rectangulaire de la page cachée à la page active. Chacun de ces routines nécessite quatre arguments qui définissent les coordonnées du bloc à transférer, dans l'ordre minimum x, maximum x, y minimum et maximum de y. Dans les modes de texte, les coordonnées sont exprimées en quantités d'espace de caractères (lignes et colonnes). Dans les modes graphiques, ils sont exprimés en valeurs (pixels) de l'espace de l'écran, avec le x coordonnées étendu aux limites d'octet si nécessaire. Il existe également des versions de l'espace mondial de ces routines nommées fg_savew et fg_restorew disponible dans les modes graphiques. Les routines fg_restore, fg_restorew, fg_save et fg_savew travaillent toujours avec des pages vidéo, même si un tampon virtuel est actif.

Exemple 11-2 illustre l'utilisation de fg_save, fg_restore et fg_sethpage
en mode texte vidéo 80 colonnes. Après avoir établi le mode vidéo (notez les appels à fg_testmode précisent que deux pages vidéo sont nécessaires), le programme remplit l'écran avec le texte, puis attend une touche. Suite à cela, le programme affiche une petite fenêtre pop-up invitant à une autre touche. Après avoir attendu la seconde frappe, le programme efface la fenêtre pop-up par le Guide de l'utilisateur 260 Fastgraph
restaurer le contenu de l'écran d'origine, puis attend encore une autre touche avant de revenir à DOS. Nous présenterons le programme maintenant, et ensuite l'analyser en détail.

 Exemple 11-2.

 #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
               void main (void);

 void main ()
                {
                  int rangée;
                  int old_mode;
                  chaîne char [17];

 fg_initpm ();
                  fg_getmode old_mode = ();

 if (fg_testmode (3,2))
                     fg_setmode (3);
                  else if (fg_testmode (7,2))
                     fg_setmode (7);
                   autre {
                     printf ( "Ce programme nécessite \ n");
                     printf ( "un affichage de 80 colonnes. \ n");
                      sortie (1);
                      }
                  fg_cursor (0);
                  fg_setattr (9,7,0);

 pour (rang = 0; rangée <25; rangée ++) {
                     sprintf (string, "Ceci est la ligne% 2d", rangée);
                     fg_locate (ligne, 0);
                     fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                      }
                  fg_waitkey ();

 fg_allocate (1);
                  fg_sethpage (1);
                  fg_save (32,47,11,13);
                  fg_setcolor (1);
                  fg_rect (32,47,11,13);
                  fg_setattr (15,1,0);
                  fg_locate (12,33);
                  fg_text ( «Appuyez sur une touche.", 14);
                  fg_waitkey ();

 fg_restore (32,47,11,13);
                  fg_waitkey (); 
                                   Chapitre 11: Bloc-transfert Routines 261


 fg_freepage (1);
                  fg_setmode (old_mode);
                  fg_reset ();
                }


Exemple 11-2 établit d'abord le mode vidéo et fg_cursor utilise pour faire
le curseur du BIOS invisible. Il exécute ensuite une boucle qui remplit chaque ligne de l'écran avec la phrase "Ceci est la ligne n", où n est le numéro de ligne (entre 0 et 24). Ensuite, le programme utilise fg_allocate pour créer Page vidéo 1 comme une page vidéo virtuelle. Ceci est nécessaire dans le cas où le programme est en cours d'exécution en mode 7, qui n'a qu'une seule vraie la page (si le programme est en cours d'exécution en mode 3, fg_allocate n'a pas d'effet). Le programme fait alors la page 1, la page cachée en appelant fg_sethpage.

Après avoir configuré la page vidéo cachée, mais avant d'afficher le pop-up
fenêtre, par exemple 11-2 fg_save utilise pour enregistrer le contenu actuel de la zone que la fenêtre pop-up va remplacer. Les copies de routine fg_save cette région à la page cachée. Le programme affiche alors la fenêtre pop-up dans le milieu de l'écran et laisse là jusqu'à ce qu'une touche est enfoncée. À la suite de cela, le programme fg_restore utilise pour remplacer la fenêtre pop-up avec le contenu original de cette région. Ceci efface efficacement la fenêtre pop-up et restaure l'écran d'origine. Le programme attend ensuite une autre touche, après quoi il libère la page virtuelle et retourne au DOS.

L'exemple suivant, 11-3, est similaire à l'exemple 11-2, mais il fonctionne dans un
320x200 en mode au lieu d'un mode texte graphique couleur. Les principales différences entre ce programme et l'exemple 11-2 sont l'utilisation du texte de 40 colonnes et l'utilisation de l'espace de l'écran des coordonnées au lieu de caractère coordonne l'espace dans les appels à fg_save, fg_restore et fg_rect. Notez que l'appel à fg_allocate crée une page virtuelle si le programme est en cours d'exécution en mode 4, 9 ou 19. Dans les modes 13 et 20, qui ont respectivement quatre et huit pages physiques, fg_allocate ne fait rien.

 Exemple 11-3.

 #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
             void main (void);

 void main ()
              {
                int rangée;
                int new_mode, old_mode;
                chaîne char [21];

 fg_initpm ();
                new_mode = fg_bestmode (320,200,2);
                if (new_mode <0 || new_mode == 12) {
                   printf ( "Ce programme nécessite une 320");
                   ( "le mode x 200 graphiques couleur \ n".) printf;
                    sortie (1);
                    }
                fg_getmode old_mode = ();
                fg_setmode (new_mode); 

 fg_setcolor (7);
                fg_rect (0,319,0,199);
                fg_setcolor (9);

 pour (rang = 0; rangée <25; rangée ++) {
                   sprintf (string, "Ceci est la ligne% 2d", rangée);
                   fg_locate (ligne, 0);
                   fg_text (string, 20);
                   fg_text (string, 20);
                    }
                fg_waitkey ();

 fg_allocate (1);
                fg_sethpage (1);
                fg_save (96,223,88,111);
                fg_setcolor (1);
                fg_rect (96,223,88,111);
                fg_setcolor (15);
                fg_locate (12,13);
                fg_text ( «Appuyez sur une touche.", 14);
                fg_waitkey ();

 fg_restore (96,223,88,111);
                fg_waitkey ();

 fg_freepage (1);
                fg_setmode (old_mode);
                fg_reset ();
              }


===A Plus Routine Block Transfer général===

Les fg_save et fg_restore routines chaque copie une zone rectangulaire à partir
une seule page vidéo sur la même position sur une autre page vidéo. Que faire si vous devez copier la région à une position différente sur une autre page de la vidéo, ou le copier ailleurs sur la page vidéo même? Fastgraph fournit une routine plus générale de transfert de bloc nommé fg_transfer. La fg_transfer copies de routine d'une région rectangulaire sur une page vidéo à une position quelconque sur une page vidéo (cependant, il ne peut pas copier chevauchement des blocs sur la page vidéo même). Comme fg_save et fg_restore, fg_transfer fonctionne en mode texte et des graphiques vidéo. Dans les modes graphiques, fg_transfer étend ses coordonnées x aux limites d'octet si nécessaire. La routine de fg_transfer travaille toujours avec des pages vidéo, même si un tampon virtuel est actif (utilisation fg_vbcut et fg_vbpaste pour copier des blocs entre les tampons virtuels et des pages vidéo ou fg_vbcopy pour copier des blocs entre les tampons virtuels).

La routine de fg_transfer nécessite huit arguments entiers. Les quatre premiers
arguments définissent la région à copier, dans le même ordre que prévu par fg_save et fg_restore. Les deux arguments suivants définissent le coin inférieur gauche de la destination du bloc, tandis que les deux derniers arguments spécifient respectivement la source et la destination des numéros de page vidéo. En bref, des copies de fg_transfer la région spécifiée à partir de la page source à la position indiquée sur la page de destination.

Exemple 11-4 est identique à l'exemple 11-2, mais elle utilise plutôt fg_transfer
que fg_save et fg_restore. Nous avons arbitrairement choisi de copier la région écrasée par la fenêtre pop-up dans le coin inférieur gauche de la page cachée (page 1). Lorsque nous copions cette région revenir à la page visuelle, nous copions à partir du coin inférieur gauche de la page cachée à la position originale sur la page visuelle (page 0). Cette séquence est représentée dans le schéma suivant.

 (11,32) (11,47) (22,0) (22,15)
                                 premier appel
               Ceci est la ligne 11 ------------> Ceci est la ligne 11
               Ceci est la ligne 12 Ceci est la ligne 12
               Ceci est la ligne 13 <------------ Ceci est la ligne 13
                                   deuxième appel
             (13,32) (13,47) (24,0) (24,15)

 Page visuelle (0) page cachée (1)

Pour copier une région à une nouvelle position, puis revenir à sa position initiale, notons la façon dont nous faisons les cinquième et sixième arguments dans le premier appel à fg_transfer les mêmes valeurs que les premier et quatrième arguments dans le second appel. De même, les cinquième et sixième arguments dans le deuxième appel doivent être les mêmes que les premier et quatrième arguments dans le premier appel. Avec tout ce que hors de la voie, voici par exemple 11-4.

 Exemple 11-4.

 #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
               void main (void);

 void main ()
                {
                  int rangée;
                  int old_mode;
                  chaîne char [17];

 fg_initpm ();
                  fg_getmode old_mode = ();

 if (fg_testmode (3,2))
                     fg_setmode (3);
                  else if (fg_testmode (7,2))
                     fg_setmode (7);
                   autre {
                     printf ( "Ce programme nécessite \ n");
                     printf ( "un affichage de 80 colonnes. \ n");
                      sortie (1);
                      }
                  fg_cursor (0);
                  fg_setattr (9,7,0);

 pour (rang = 0; rangée <25; rangée ++) {
                     sprintf (string, "Ceci est la ligne% 2d", rangée);
                     fg_locate (ligne, 0); 

 fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                     fg_text (string, 16);
                      }
                  fg_waitkey ();

 fg_allocate (1);
                  fg_transfer (32,47,11,13,0,24,0,1);
                  fg_setcolor (1);
                  fg_rect (32,47,11,13);
                  fg_setattr (15,1,0);
                  fg_locate (12,33);
                  fg_text ( «Appuyez sur une touche.", 14);
                  fg_waitkey ();

 fg_transfer (0,15,22,24,32,13,1,0);
                  fg_fg_waitkey ();

 fg_freepage (1);
                  fg_setmode (old_mode);
                  fg_reset ();
                }


Exemple 11-5 illustre une autre utilisation de la routine de fg_transfer.  Ce
exemple est fonctionnellement identique à l'exemple 10-10, mais il utilise au lieu de fg_transfer fg_getmap et fg_drawmap. Avec la routine de fg_transfer, nous éliminons les appels à fg_getmap et fg_drawmap, les deux appels à fg_move, et le tableau de 32 octets besoin pour récupérer le bloc. Comme un bonus supplémentaire, en utilisant fg_transfer est beaucoup plus rapide que la technique de l'exemple 10-10, bien que nous ne remarquerez probablement pas ce gain avec un tel petit bloc.

Le bloc copié dans l'exemple 11-5 est une rangée de quatre personnages, de sorte que son
largeur dans l'espace de l'écran est de 32 pixels et sa hauteur est de 8 pixels. Parce que le bloc est dans le coin supérieur gauche de l'écran, les limites des blocs sont Xmin = 0, xmax = 31, ymin = 0, et ymax = 7. Nous voulons passer d'une demi-cellule de caractère de bloc (4 pixels) à droite et une rangée (8 pixels) vers le bas, de sorte que nos coordonnées de destination sont x = 4 (xmin + 4) et y = 15 (ymax + 8). Notez comment le programme se limite aux modes 19 et 20 pour assurer la copie de bloc ne soit pas affectée par les limites d'octet. En outre, nous copions le bloc d'une position à une autre sur la page visuelle, de sorte que la source et les pages de destination sont 0.

 Exemple 11-5.

 #include <fastgraf.h>
                  #include <stdio.h>
                  #include <stdlib.h>
                 void main (void);

 void main ()
                  {
                    int old_mode, new_mode;

 fg_initpm (); 
                                   Chapitre 11: Bloc-transfert Routines 265


 new_mode = fg_bestmode (320,200,1);
                    if (new_mode <19) {
                       printf ( "Ce programme nécessite une");
                       ( «mode graphique 256 couleurs. \ n") printf;
                        sortie (1);
                        }

 fg_getmode old_mode = ();
                    fg_setmode (new_mode);

 fg_setcolor (9);
                    fg_text ( "text", 4);
                    fg_waitkey ();

 fg_transfer (0,31,0,7,4,15,0,0);
                    fg_waitkey ();

 fg_setmode (old_mode);
                    fg_reset ();
                  }


Exemple 11-6 montre encore une autre application de fg_transfer dans un graphisme
mode vidéo. Le programme affiche un rectangle dans le quadrant supérieur gauche de l'écran, puis centre le mot «quadrant» à l'intérieur du rectangle. Après avoir attendu pendant une séquence de touches, le programme utilise fg_transfer d'abord copier le quadrant supérieur gauche au quadrant supérieur droit. Il utilise ensuite à nouveau fg_transfer pour copier la moitié supérieure de l'écran à la moitié inférieure. Le résultat de ceci est l'écran étant rempli de ce qui était initialement dans le quadrant supérieur gauche.

 Exemple 11-6.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                       sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (7);
                   fg_rect (0,159,0,99);
                   fg_setcolor (9);
                   fg_locate (6,6);
                   fg_text ( "quadrant", 8); 

 fg_waitkey ();

 fg_transfer (0,159,0,99,160, 99,0,0);
                   fg_transfer (0,319,0,99, 0,199,0,0);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


===Routines Bloc de transfert pour Tampons Virtuels===

fg_restore, fg_save et routines fg_transfer de Fastgraph copie blocs
entre les pages vidéo physiques ou virtuels. D'autres routines sont fournies pour les transferts de blocs entre les tampons virtuels et des pages vidéo, ou entre les tampons virtuels. Dans notre discussion de tampons virtuels dans le chapitre 8, nous avons décrit fg_vbcut et fg_vbpaste les routines de Fastgraph. Rappelons que fg_vbcut copies d'un bloc de la page vidéo active à la mémoire tampon virtuelle active, tandis que les copies fg_vbpaste un bloc de la mémoire tampon virtuelle active à la page de la vidéo active.

Nous allons maintenant présenter une autre routine de transfert de blocs, fg_vbcopy, pour
blocs de copie entre deux tampons virtuels, ou à une position non-chevauchement dans le même tampon virtuel. Les arguments fg_vbcopy sont exactement les mêmes que celles de fg_transfer, à l'exception des deux derniers arguments de référence du tampon de source et la destination virtuelle gère la place des numéros de page vidéo. Exemple 11-7 est analogue à l'exemple 11-6, mais il fg_vbcopy utilise pour effectuer les deux opérations de copie de blocs dans une mémoire tampon virtuelle 320x200 (ceux-ci ont été effectués avec fg_transfer dans l'exemple 06.11). Après cela, il appelle fg_vbpaste pour afficher le contenu du tampon virtuel.

  Exemple 11-7.

  #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
                void main (void);

  #ifdef FG32
                char buffer [64000];
                #autre
                carboniser loin tampon [64000];
                #fin si

  void main ()
                {
                   poignée int;
                   int new_mode, old_mode;

  fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1); 
                                    Chapitre 11: Bloc-transfert Routines 267


  }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

  fg_vbinit ();
                   handle = fg_vbdefine (tampon, 320200);
                   fg_vbopen (poignée);

  fg_setcolor (7);
                   fg_rect (0,159,0,99);
                   fg_setcolor (9);
                   fg_locate (6,6);
                   fg_text ( "quadrant", 8);

  fg_vbcopy (0,159,0,99,160, 99, poignée, poignée);
                   fg_vbcopy (0,319,0,99, 0199, poignée, poignée);
                   fg_vbpaste (0,319,0,199,0,199);
                   fg_waitkey ();

  fg_vbclose ();
                   fg_setmode (old_mode);
                   fg_reset ();


===Blocks avec les couleurs transparentes===

Les routines suivante de transfert de bloc, nous allons discuter sont fg_tcxfer, fg_tcmask,
et fg_tcdefine. La routine de fg_tcxfer est similaire à fg_transfer en ce qu'il copie une zone rectangulaire d'une position à une autre, mais fg_tcxfer vous permet de traiter une ou plusieurs couleurs comme transparent (le nom fg_tcxfer signifie le transfert de couleur transparente). En d'autres termes, tout pixel dont la couleur valeur est définie pour être transparent ne sont pas copiées vers la zone de destination. Les arguments de la routine de fg_tcxfer sont les mêmes que pour la routine de fg_transfer, mais fg_tcxfer n'a aucun effet en mode vidéo de texte. Parce que fg_tcxfer doit examiner la couleur des pixels individuels, il est presque aussi rapide que fg_transfer. La routine de fg_tcxfer travaille toujours avec des pages vidéo, même si un tampon virtuel est actif (routine de fg_vbtcxfer, décrite dans la section suivante, fournit des transparents les transferts de blocs de couleur pour les tampons virtuels).

Vous pouvez utiliser fg_tcmask ou fg_tcdefine pour définir les couleurs qui sont
considéré comme transparent dans les appels ultérieurs à fg_tcxfer.L'argument de la routine fg_tcmask est un masque de bits entier (plus précisément, un masque de 16 bits) où chaque bit indique si oui ou non la couleur est transparente. Par exemple, si le bit 0 (le bit de droite) est situé dans le masque, puis la couleur 0 sera transparent; si le bit 0 est remis à zéro, la couleur 0 ne sera pas transparent. Parce que la taille de masque de bits est de 16 bits, seules les 16 premières valeurs de couleur peuvent être définis comme transparent en utilisant fg_tcmask.

Exemple 8.11 illustre l'utilisation des fg_tcxfer et fg_tcmask routines.
Ce programme est similaire à l'exemple 11-6, sauf la couleur du mot «quadrant» (couleur 9) est défini comme étant transparent, et fg_tcxfer est utilisé à la place de fg_transfer. Parce que la couleur 9 cartes à colorier 1 en mode quatre couleurs graphiques CGA (mode 4), nous devons définir les deux couleurs 1 et 9 pour être transparent (rappelez-vous, fg_tcmask considère les valeurs de couleurs réelles transparentes, et non pas des indices de couleur). Le masque de bits transmis à fg_tcmask ainsi sera 0000 0010 0000 0010 Guide de l'utilisateur 268 Fastgraph
binaire ou 0202 hex. Cela provoque le mot «quadrant» pour apparaître dans la couleur de fond (couleur 0) au lieu de la couleur 9 en haut à droite, en bas à gauche et en bas à droite quadrants.

 Exemple 11-8.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (7);
                   fg_rect (0,159,0,99);
                   fg_setcolor (9);
                   fg_locate (6,6);
                   fg_text ( "quadrant", 8);
                   fg_waitkey ();

 fg_tcmask (0x0202);
                   fg_tcxfer (0,159,0,99,160, 99,0,0);
                   fg_tcxfer (0,319,0,99, 0,199,0,0);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


La routine fg_tcdefine attend deux arguments entiers - une définition de la
numéro de couleur (entre 0 et 255) et une autre définition de l'état de la transparence associée à cette couleur. Si l'état est égal à zéro, la couleur spécifiée sera opaque (non transparent). S'il est une autre valeur, la couleur sera transparente. Dans l'exemple précédent, nous pourrions utiliser fg_tcdefine au lieu de fg_tcmask pour rendre les couleurs 1 et 9 transparent en remplaçant l'appel à fg_tcmask ce qui suit:


 fg_tcdefine (1,1);
                              fg_tcdefine (9,1); 
                                   Chapitre 11: Bloc-transfert Routines 269


Si vous ne l'appelez fg_tcmask ou fg_tcdefine, la routine de fg_tcxfer considère pas de couleurs transparentes.


===Transferts de blocs transparents pour Tampons virtuels===

fg_vbtcxfer routine transfère des blocs de Fastgraph avec des couleurs transparentes
de la mémoire tampon virtuelle active à la page de la vidéo active. Ses arguments identiques à ceux de fg_vbpaste, mais il ne copie pas les pixels dont les couleurs sont transparentes. Les fg_tcdefine ou fg_tcmask routines définissent quelles couleurs sont transparentes, comme lors de l'utilisation fg_tcxfer.

Exemple 11-9 donne le même résultat que l'exemple 11-8, mais il le fait
en utilisant des tampons virtuels. Plutôt que de créer un tampon virtuel en plein écran, cependant, cet exemple crée un tampon d'un quart virtuel de la taille de l'écran et transfère le contenu du tampon virtuel pour chaque quadrant de la page visuelle dans quatre opérations distinctes. Dans le quadrant supérieur gauche, nous appelons simplement fg_vbpaste pour afficher le contenu du tampon virtuel. Les trois appels fg_vbtcxfer emplissent les autres quadrants, mais avec la couleur 9 pixels étant transparent. Cette séquence d'opérations de copie de bloc de la mémoire tampon virtuelle crée le même affichage résultant comme exemple 11-8. Notez que cet exemple fg_tcdefine utilise pour faire la couleur 9 transparent; nous pourrions tout aussi bien avoir fg_tcmask utilisé.

 Exemple 11-9.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 #ifdef FG32
                char buffer [16000];
                 #autre
                carboniser loin tampon [16000];
                 #fin si

 void main ()
                 {
                   poignée int;
                   int new_mode, old_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_vbinit ();
                   handle = fg_vbdefine (tampon, 160100);
                   fg_vbopen (poignée);

 fg_setcolor (7); 

 fg_fillpage ();
                   fg_setcolor (9);
                   fg_locate (6,6);
                   fg_text ( "quadrant", 8);
                   fg_vbpaste (0,159,0,99,0,99);
                   fg_waitkey ();

 fg_tcdefine (9,1);
                   fg_vbtcxfer (0,159,0,99,160,99);
                   fg_vbtcxfer (0,159,0,99,0,199);
                   fg_vbtcxfer (0,159,0,99,160,199);
                   fg_waitkey ();

 fg_vbclose ();
                   fg_setmode (old_mode);
                   fg_reset ();
                 }


===Transfert de blocs vers et depuis la mémoire conventionnelle===

Les deux dernières routines de transfert de bloc, nous allons discuter sont fg_getblock et
fg_putblock. Les fg_getblock transferts de routine d'une région rectangulaire de la page vidéo active ou tampon virtuel à un tableau (vous pouvez utiliser fg_imagesiz pour déterminer la taille du tableau nécessaire pour stocker le bloc). Le fg_putblock transferts de routine d'un bloc précédemment récupéré avec fg_getblock à la page active ou tampon virtuel. Bien que ces deux routines sont plus rapides que fg_getimage et fg_putimage, ils ne sont pas aussi vite que fg_restore, fg_save et fg_transfer.

Chacun de ces routines nécessite cinq arguments. La première est l'adresse
du tableau qui va recevoir ou qui contient le bloc. Les quatre autres arguments définissent la position du bloc sur la page active ou tampon virtuel, dans l'ordre minimum x, maximum x, y minimum et maximum de y. Dans les modes de texte, les coordonnées sont exprimées en quantités d'espace de caractères (lignes et colonnes). Dans les modes graphiques, ils sont exprimés en valeurs (pixels) de l'espace de l'écran, avec le x coordonnées étendu aux limites d'octet si nécessaire.

Notez que les deux fg_getblock et fg_putblock attendent l'adresse de réseau pour être
passé par référence, sauf dans la mesure BASIC. Cela signifie que les programmes Pascal en mode réel doivent utiliser la procédure GetMem pour allouer le stockage de la mémoire tampon, comme cela est le seul moyen de passer quelque chose par référence loin en mode réel Pascal. Dans les environnements 16 bits, la taille maximale d'un bloc est 64K octets, quel que soit le compilateur que vous utilisez.

Exemple 11-10 est similaire à l'exemple 11-5 et montre fg_getblock et
fg_putblock en action dans un mode graphique 320x200. Le programme affiche le mot «texte» et récupère dans un bloc de pixels 32 par 8. Après une séquence de touches, il affiche le bloc de 8 pixels ci-dessous et 8 pixels à la droite de sa position initiale. La taille de la mémoire tampon a été choisi pour être de 256 octets pour tenir compte de la plus grande taille requise pour un 32 bloc de 8 (qui se produit dans les modes graphiques de 256 couleurs). Notez également comment la source et de destination horizontales extrêmes de blocs ont été choisis pour l'alignement de la limite d'octet dans le cas où fg_bestmode sélectionné un mode graphique de 16 couleurs.

 Exemple 11-10. 
                                   Chapitre 11: Bloc-transfert Routines 271


 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 #ifdef FG32
                char buffer [256];
                 #autre
                CHAR loin tampon [256];
                 #fin si

 void main ()
                 {
                   int old_mode, new_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }

 fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (9);
                   fg_text ( "text", 4);
                   fg_getblock (tampon, 0,31,0,7);
                   fg_waitkey ();

 fg_putblock (tampon, 8,39,8,15);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


===Résumé des programmes de transfert de bloc===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

Pour toutes les routines de transfert de bloc, Fastgraph étend le pixel horizontal
les coordonnées à une limite d'octet lorsque les routines sont utilisées dans un mode vidéo graphique.

FG_COPYPAGE transfère le contenu d'une page vidéo à un autre.  le
pages peuvent être des pages vidéo physiques, virtuels ou logiques. Si les deux pages sont des pages logiques, ils doivent exister dans le même type de mémoire. La routine de fg_copypage ne fonctionne pas avec des tampons virtuels. Guide de l'utilisateur 272 Fastgraph

FG_GETBLOCK récupère le bloc (pour l'affichage plus tard avec fg_putblock) à
la position spécifiée sur la page vidéo active ou tampon virtuel. Dans les modes de texte, les extrêmes de blocs sont définis dans l'espace de caractère; dans les modes graphiques, ils sont définis dans l'espace de l'écran.

FG_GETHPAGE renvoie le numéro de page cachée, tel que défini dans le plus récent
appeler à fg_sethpage.

FG_PUTBLOCK affiche le bloc (précédemment obtenu avec fg_getblock) à
la position spécifiée sur la page vidéo active ou tampon virtuel. Dans les modes de texte, les extrêmes de blocs sont définis dans l'espace de caractère; dans les modes graphiques, ils sont définis dans l'espace de l'écran.

FG_RESTORE copies d'un bloc de la page vidéo cachée à la même position
sur la page de la vidéo active. La routine de fg_restore ne fonctionne pas avec des tampons virtuels.

FG_RESTOREW est identique à celle fg_restore, mais les extrémités du bloc sont
spécifié en tant que coordonnées de l'espace mondial. La routine de fg_restorew ne fonctionne pas avec des tampons virtuels.

FG_SAVE copies d'un bloc de la page vidéo active à la même position sur
la page vidéo cachée. La routine de fg_save ne fonctionne pas avec des tampons virtuels.

FG_SAVEW est identique à celle fg_save, mais les extrémités du bloc sont spécifiés comme
coordonne l'espace mondial. La routine fg_savew ne fonctionne pas avec des tampons virtuels.

FG_SETHPAGE définit la page vidéo cachée (utilisée par fg_restore,
fg_restorew, fg_save et fg_savew).

FG_TCDEFINE définit l'attribut transparent d'un indice de couleur pour une utilisation
avec la routine de fg_tcxfer. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_TCMASK définit lequel des 16 premières couleurs du fg_tcxfer de volonté de routine
envisager transparent. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode vidéo texte.

FG_TCXFER copies d'un bloc de toutes les positions sur une page vidéo à tout
position sur une page vidéo, à l'exclusion des pixels dont la valeur de couleur est transparente. Cette routine n'a aucun effet lorsqu'il est utilisé dans un mode texte et vidéo ne fonctionne pas avec des tampons virtuels.

FG_TRANSFER copies d'un bloc de toutes les positions sur une page vidéo à tout
position sur une page vidéo. Il est le plus grand bloc de routine de transfert de Fastgraph. La routine de fg_transfer ne fonctionne pas avec des tampons virtuels.

FG_VBCOPY copies d'une région rectangulaire d'un tampon virtuel à un autre,
ou à une position sans chevauchement à l'intérieur de la même mémoire tampon virtuelle.

FG_VBTCXFER copies d'une région rectangulaire de la mémoire tampon virtuelle active à
la page de la vidéo active, à l'exclusion des pixels transparents.


==Techniques d'animation==

Contrairement à d'autres micro-ordinateurs, le PC IBM et PS / 2 famille de systèmes ne sont pas
avoir un matériel spécial graphique ou firmware pour aider dans l'exécution de l'animation. Cela signifie toute animation fait sur ces systèmes doit être entièrement mis en oeuvre par le logiciel. Ce chapitre montre comment faire en utilisant la gestion des pages vidéo de Fastgraph, affichage de l'image, et de bloquer les routines de transfert. Les méthodes décrites dans ce chapitre ne sont pas destinés à être tout compris, car ce serait lui-même remplir un volume distinct au moins aussi grand que ce manuel. Cependant, les techniques d'animation présentés ici devraient fournir une base que vous pouvez facilement étendre à développer des utilisations plus sophistiquées de l'animation. Les exemples de ce chapitre sont limitées aux modes graphiques vidéo.


===Animations simple===

Le premier type d'animation que nous allons examiner est appelée animation simple.  Dans
animation simple, nous affichons un objet, l'effacer, puis l'afficher dans une nouvelle position. Lorsque nous effectuons cette «effacer et réafficher" séquence répétitive, l'objet se déplace. Ce procédé présente cependant deux inconvénients. Tout d'abord, à moins que l'objet est plutôt petit, il scintillement parce que l'effacement et l'affichage de l'objet ne coïncide pas avec le taux de l'affichage vidéo de rafraîchissement. Deuxièmement, et peut-être plus important encore, quoi que ce soit sous l'objet n'a pas été enregistré en tant que l'objet se déplace à travers elle. Malgré ces limites, l'animation simple est parfois utile, et il est un bon endroit pour commencer notre discussion sur les techniques d'animation.

Exemple 12-1 déplace un petit rectangle vert clair (magenta dans CGA) de
de gauche à droite sur l'écran dans un mode graphique 320x200 couleur. Le programme se déplace le rectangle, 20 pixels de large et 10 pixels de haut, en utilisant une boucle for. Cette boucle fg_clprect utilise d'abord pour afficher le rectangle, puis fg_waitfor utilise pour laisser l'objet sur l'écran momentanément, et fg_clprect utilise enfin à nouveau pour effacer le rectangle en réafficher dans la couleur de fond d'origine (fg_waitfor est décrit au chapitre 16). Nous utilisons fg_clprect plutôt que fg_rect parce que les premières et dernières quelques itérations de la boucle aboutissent à au moins une partie du rectangle étant hors de l'écran. Chaque itération de boucle successive affiche le rectangle cinq pixels à droite de sa position précédente.

 Exemple 12-1.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()
          {
            int new_mode, old_mode;
            int x;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
            new_mode = fg_bestmode (320,200,1); 
                                      Chapitre 12: Techniques d'animation 275


 if (new_mode <0 || new_mode == 12) {
               printf ( "Ce programme nécessite une 320");
               ( "le mode x 200 graphiques couleur \ n".) printf;
               sortie (1);
                }
            fg_getmode old_mode = ();
            fg_setmode (new_mode);

 / * Déplacer l'objet à travers l'écran * /

 for (x = -20; x <320; x + = 5) {
               fg_setcolor (10);
               fg_clprect (x, x + 19,95,104);
               fg_waitfor (1);
               fg_setcolor (0);
               fg_clprect (x, x + 19,95,104);
                }

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_setmode (old_mode);
            fg_reset ();
          }


Exemple 12-2 est identique à l'exemple 12-1, mais il montre ce qui arrive quand
on déplace le rectangle sur un arrière-plan existant (dans ce cas, le fond est blanc solide). Si vous exécutez ce programme, vous verrez que le rectangle laisse une traînée de couleur 0 pixels derrière elle. Bien que cela puisse être parfois utile, il démontre que l'animation simple est destructive car il ne conserve pas l'arrière-plan. Dans cet exemple, si nous avons changé le deuxième appel à fg_setcolor au sein de la boucle pour revenir à la couleur 15 au lieu de la couleur 0, l'arrière-plan serait rétabli. En général, cependant, il peut ne pas être aussi facile de remplacer l'arrière-plan, nous devons donc compter sur une autre méthode pour la préserver.

 Exemple 12-2.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()
          {
            int new_mode, old_mode;
            int x;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
            new_mode = fg_bestmode (320,200,1);
            if (new_mode <0 || new_mode == 12) {
               printf ( "Ce programme nécessite une 320");
               ( "le mode x 200 graphiques couleur \ n".) printf;
               sortie (1); 

  }
            fg_getmode old_mode = ();
            fg_setmode (new_mode);

 / * Tirer un certain type de fond * /

 fg_setcolor (15);
            fg_rect (0,319,0,199);

 / * Déplacer l'objet à travers l'écran * /

 for (x = -20; x <320; x + = 5) {
               fg_setcolor (10);
               fg_clprect (x, x + 19,95,104);
               fg_waitfor (1);
               fg_setcolor (0);
               fg_clprect (x, x + 19,95,104);
                }

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_setmode (old_mode);
            fg_reset ();
          }


Pour résumer, nous avons vu que l'animation simple est facile à mettre en œuvre, mais
il est destructeur et provoque généralement l'objet animé de scintillement. Pour toutes ces raisons, il n'a pas été utilisé trop fréquemment.


===XOR Animations===

animation "Exclusive ou" animation, ou XOR pour faire court, est un intéressant
extension de l'animation simple et est très utile lors de l'animation d'un objet d'une seule couleur sur un fond d'une seule couleur. Comme animation simple, il utilise la technique "effacer et réafficher" pour déplacer un objet, mais il le fait différemment. Au lieu d'effacer l'objet en l'affichant dans la couleur de fond, l'animation XOR fait à l'aide de la même couleur en utilisant un ou exclusif, ou XOR, opération. Cette méthode repose sur une propriété spécifique de l'opérateur ou exclusif:

 (Objet XOR fond) objet XOR = fond

En d'autres termes, si quelque chose XOR deux fois dans la même position, le résultat est le même que celui de l'image originale dans cette position.

Exemple 12-3 montre animation XOR. Ce programme est similaire à
exemple 12-2, mais il ne fonctionne que dans le mode graphique EGA 320x200 (mode 13). Après avoir établi le mode vidéo, il utilise la routine fg_setfunc Fastgraph pour sélectionner le mode XOR. Cela provoque aucune sortie graphique ultérieure à XORed avec le contenu de la mémoire vidéo au lieu de simplement remplacer. La routine de fg_setfunc est décrite plus loin dans le chapitre 17.

Les autres différences entre les exemples 12-3 et 12-2 sont que l'appel à
fg_setcolor a été déplacé en dehors de la boucle, et que fg_setcolor prend une
valeur différente. Depuis l'arrière-plan existant est blanc brillant (couleur 15), nous ne pouvons pas utiliser la couleur 10 si l'on veut afficher un objet vert vif. La valeur désirée est celle qui quand XORed avec la couleur 15 produit de couleur 10; la meilleure manière d'obtenir cette valeur est de XOR ces deux nombres. L'appel à fg_setcolor peut être déplacé en dehors de la boucle parce que nous affichons l'objet en utilisant le même indice de couleur tout au long.

 Exemple 12-3.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()
          {
            int old_mode;
            int x;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
            if (fg_testmode (13,1) == 0) {
               printf ( "Ce programme nécessite EGA. \ n");
               sortie (1);
                }
            fg_getmode old_mode = ();
            fg_setmode (13);
            fg_setfunc (3);

 / * Tirer un certain type de fond * /

 fg_setcolor (15);
            fg_rect (0,319,0,199);

 / * Déplacer l'objet à travers l'écran * /

 fg_setcolor (10 ^ 15);
            for (x = -20; x <320; x + = 5) {
               fg_clprect (x, x + 19,95,104);
               fg_waitfor (1);
               fg_clprect (x, x + 19,95,104);
                }

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_setmode (old_mode);
            fg_reset ();
          }


Fastgraph ne supporte que l'opération XOR de pixel dans le EGA et VGA natif
modes graphiques vidéo (modes 13 à 18) et 16 couleurs modes (28 et 29) SVGA. Ainsi, vous ne pouvez pas utiliser l'animation XOR dans CGA, Tandy / PCjr, Hercules, ou 256- modes graphiques de couleurs. Guide de l'utilisateur 278 Fastgraph

Tandis que l'animation XOR est non destructive (qui est, elle restaure l'original
arrière-plan), il souffre encore du scintillement rencontré dans une animation simple. En dépit de cela, il peut être utile lors de l'animation d'un objet d'une seule couleur sur un fond d'une seule couleur.


===Animation cadre statique===

animation cadre statique utilise une stratégie différente de celle animation simple ou
animation XOR. Le régime général de cette méthode est de créer la séquence d'animation entière hors de l'écran, puis afficher successivement chaque élément, ou un cadre, dans cette séquence sur une position de la page vidéo visuelle. Il en résulte une animation visuellement attrayant qui est non destructive et ne comprend pas le scintillement associé à une animation simple et animation XOR. animation cadre statique nécessite la page visuelle de vidéo et une ou plusieurs pages supplémentaires (ou les tampons virtuels) à mettre en œuvre. Le nombre de pages nécessaires dépend du nombre d'images et la taille de chaque trame.

 Exemple 12-4 fonctionne dans tous les modes graphiques vidéo 320x200 de couleur et

illustre une utilisation simple de l'animation d'image statique. Le programme affiche une séquence d'animation contenant 12 images; il affiche cette séquence trois fois. La séquence d'animation se compose d'un rectangle vert clair (magenta dans CGA) se déplaçant de gauche à droite à travers le centre du cadre. Chaque cadre est de 96 pixels de large et 50 pixels de haut. Les 12 cadres sont mis en place sur une page vidéo hors de l'écran, comme indiqué ici:

 0 95 96 191 192 287

  0
                         cadre 1 cadre 2 cadre 3
                     49

  50
                         cadre 4 cadre 5 cadre 6
                     99

 100
                         cadre 7 cadre 8 cadre 9
                    149

 150
                         frame 10 frame 11 frame 12
                    199


Exemple 12-4 établit d'abord le mode vidéo et alloue la
Page vidéo supplémentaire (nécessaire si vous utilisez un mode vidéo dans lequel la page 1 est une page vidéo virtuelle). Le programme génère alors l'arrière-plan pour l'image 1; l'arrière-plan est un rectangle bleu (cyan dans CGA) avec une ellipse blanche centrée sur elle. Après l'appel à fg_ellipse, la première image est prêt.

L'étape suivante consiste à créer les 11 images restantes. Dans le cadre 2, le droit
la moitié des 20 pixels de large rectangle va entrer dans le bord gauche du cadre. Dans le cadre 3, le rectangle sera dix pixels plus à droite, ou alignés contre le bord gauche du cadre. Dans les cadres 4 à 12, le rectangle sera dix pixels plus loin à droite dans chaque trame, de sorte que par image 12, seule la moitié gauche de la
rectangle apparaît sur le bord droit du cadre. La première boucle dans le programme construit des trames 2 à 12 en copiant l'arrière-plan de l'image 1, puis afficher le rectangle (qui est, l'objet animé) dans la bonne position pour cette trame.

La seconde boucle exécute la séquence d'animation. Pour afficher le 12-
séquence de trame à trois reprises, il doit effectuer 36 itérations. La boucle copie simplement chaque image de la bonne position sur la page vidéo 1 au milieu de la page vidéo visuelle. Notez comment fg_waitfor est utilisé pour faire une pause momentanée entre les images.

 Exemple 12-4.

 #include <fastgraf.h>
        #include <stdio.h>
        #include <stdlib.h>
       void main (void);

 #define VISUAL 0
       #define HIDDEN 1

 int xmin [] = {0, 96192, 0, 96192, 0, 96192, 0, 96192};
       int ymax [] = {49, 49, 49, 99, 99, 99.149.149.149.199.199.199};

 void main ()
        {
          int new_mode, old_mode;
          cadre int, offset;
          int i, x, y;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
          new_mode = fg_bestmode (320,200,2);
          if (new_mode <0 || new_mode == 12) {
             printf ( "Ce programme nécessite une 320");
             ( "le mode x 200 graphiques couleur \ n".) printf;
             sortie (1);
              }
          fg_getmode old_mode = ();
          fg_setmode (new_mode);
          fg_allocate (HIDDEN);

 / * Dessiner l'arrière-plan dans le coin supérieur gauche * /

 fg_setpage (HIDDEN);
          fg_setcolor (1);
          fg_rect (0,95,0,49);
          fg_setcolor (15);
          fg_move (48,25);
          fg_ellipse (20,20);

 / * Afficher l'objet animé contre chaque fond * /

 fg_setcolor (10);
          offset = -10; 

Guide de l'utilisateur 280 Fastgraph


 for (i = 1; i <12; i ++) {
             x = xmin [i];
             y = ymax [i];
             fg_transfer (0,95,0,49, x, y, HIDDEN, HIDDEN);
             fg_setclip (x, x + 95,0,199);
             fg_clprect (x + offset, x + offset + 19, y-29, y-20);
             offset + = 10;
              }

 / * Glisser l'objet à travers le fond trois fois * /

 for (i = 0; i <36; i ++) {
             frame = i% 12;
             x = xmin [cadre];
             y = ymax [cadre];
             fg_transfer (x, x + 95, y-49, y, 112124, HIDDEN, VISUAL);
             fg_waitfor (2);
              }

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_freepage (HIDDEN);
          fg_setmode (old_mode);
          fg_reset ();
        }



===Animation Dynamic Frame===

animation d'images dynamique est similaire à l'animation d'image statique, mais tout le
trames d'animation sont construites selon les besoins au cours de la séquence d'animation au lieu de l'avance. En utilisant cette méthode, vous devez d'abord stocker une copie de l'arrière-plan sur une page vidéo hors écran. Ensuite, pour construire un cadre, créer une autre copie (appelé l'espace de travail) de l'arrière-plan ailleurs sur la page hors de l'écran (ou même à une autre page hors de l'écran) et afficher l'objet sur cette copie. Enfin, transférer l'espace de travail à la page visuelle. Comme animation d'images statiques, cette méthode produit une séquence d'animation sans scintillement non destructif.

Exemple 12-5 est fonctionnellement identique à l'exemple 12-4, mais il utilise
dynamique plutôt que statique animation d'images. Comme précédemment, le programme construit l'arrière-plan dans le coin supérieur gauche de la page vidéo 1, mais il fg_transfer utilise ensuite pour le copier dans le centre de la page vidéo visuelle. La boucle for construit chaque image comme elle est nécessaire et aussi des copies au centre de la page visuelle. Encore une fois, fg_waitfor crée la pause nécessaire entre les cadres.

 Exemple 12-5.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 #define VISUAL 0   

 #define HIDDEN 1

 void main ()
          {
            int new_mode, old_mode;
            cadre int, offset;
             int i;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
            new_mode = fg_bestmode (320,200,2);
            if (new_mode <0 || new_mode == 12) {
               printf ( "Ce programme nécessite une 320");
               ( "le mode x 200 graphiques couleur \ n".) printf;
               sortie (1);
                }
            fg_getmode old_mode = ();
            fg_setmode (new_mode);
            fg_allocate (HIDDEN);

 / * Dessiner l'arrière-plan dans le coin supérieur gauche * /

 fg_setpage (HIDDEN);
            fg_setcolor (1);
            fg_rect (0,95,0,49);
            fg_setcolor (15);
            fg_move (48,25);
            fg_ellipse (20,20);

 / * Copier dans le centre de la page visuelle * /

 fg_transfer (0,95,0,49,112,124, HIDDEN, VISUAL);

 / * Glisser l'objet à travers le fond trois fois * /

 fg_setcolor (10);
            for (i = 0; i <36; i ++) {
               frame = i% 12;
               offset = 10 * frame - 10;
               fg_transfer (0,95,20,29,112,105, HIDDEN, HIDDEN);
               fg_rect (112 + offset, 131 + offset, 96105);
               fg_transfer (112,207,96,105,112,105, HIDDEN, VISUAL);
               fg_waitfor (2);
                }

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_freepage (HIDDEN);
            fg_setmode (old_mode);
            fg_reset ();
          }


Deux articles dans l'exemple 12-5 méritent un examen plus approfondi. Tout d'abord, nous avons choisi
notre espace de travail à la page 1, il utilise donc les mêmes coordonnées d'espace d'écran comme le Guide de l'utilisateur 282 Fastgraph
zone d'image sur la page visuelle. Ce n'est pas nécessaire, sauf si vous utilisez fg_restore au lieu de fg_transfer. Deuxièmement, le programme peut utiliser la routine fg_rect plus rapidement à la place de fg_clprect. Elle peut le faire parce que même si l'objet va au-delà des limites de l'espace de travail, nous ne transférons l'espace de travail lui-même. Cependant, pour que cela fonctionne correctement, les limites horizontales de l'espace de travail doivent tomber sur les limites d'octet.

Notez aussi que nous ne devons pas transférer la totalité du cadre pendant la
séquence d'animation. Dans l'exemple 12-5, nous savons que les extrêmes verticales de l'image en mouvement sont y = 96 et y = 105, de sorte que nous ne transférons 10 lignes au lieu de l'image entière. On pourrait de même calculer les x extrêmes pour chaque trame et seulement transférer la partie nécessaire. Rappelons, cependant, que fg_transfer étend les coordonnées horizontales octet frontières, afin que nous puissions copier quelques pixels supplémentaires ainsi. Cela peut ou peut ne pas affecter la séquence d'animation. Encore une fois, le problème est éliminé si vous alignez votre espace de travail sur les limites d'octet.

Lorsque nous utilisons l'animation de cadre dynamique, il est facile de modifier le nombre de
trames dans la séquence d'animation. Supposons que nous voulions produire une animation plus fluide en augmentant le nombre de trames de 12 à 24. Cela signifie que l'objet se déplace par incréments de cinq pixels au lieu de dix. Les seules modifications nécessaires sont de doubler le nombre d'itérations de la boucle, modifier les calculs pour le numéro de l'image et les valeurs de décalage comme indiqué ici, et de réduire la pause de fg_waitfor 2-1.


 frame = i% 24;
                          offset = 5 * frame - 10;


Comparez cela à tous les changements qui seraient nécessaires si nous utilisions l'animation du cadre statique.


===page Flipping===

Page flipping est une variation de l'animation de cadre dans lequel vous construire
les images des pages vidéo hors écran et ensuite faire répétitivement ces pages la page visuelle. Nous pouvons diviser davantage la page technique de retournement dans les variantes statiques et dynamiques, comme nous l'avons fait avec l'animation du cadre.

En page statique retournement, nous construisons la séquence d'animation entière dans
avancer, avec une image par page vidéo. Une fois cela fait, nous pouvons afficher chaque image en utilisant fg_setvpage pour passer instantanément d'une page vidéo à un autre. Bien que ce produit une animation fluide, sans scintillement, nous ne pouvons pas réaliser la séquence très loin avant de manquer de pages vidéo (et donc des images d'animation).

En page dynamique de retournement, on construit chaque trame d'animation quand il est
nécessaire.Comme dans la page statique retournement, nous construisons chaque image sur une page vidéo séparée. Toutefois, à titre d'exemple 12-6 montre, nous avons seulement besoin de trois pages vidéo pour produire la séquence d'animation, quel que soit le nombre d'images dans la séquence. Deux des trois pages vidéo alterneront comme la page visuelle, tandis que la page vidéo restante conserve une copie de l'arrière-plan.

Exemple 12-6, qui exécute une séquence d'animation similaire aux exemples
12-4 et 12-5, illustre l'animation de cadre dynamique dans les 320x200 graphiques EGA
mode vidéo (mode 13). Le programme commence par l'affichage de l'arrière-plan sur la vidéo la page 2. pages vidéo 0 et 1 alterneront comme la page visuelle; la page qui est pas la page visuelle est appelée la page cachée. Nous commençons par la page 0 comme la page visuelle, et donc la page 1 de la page cachée. Pour construire chaque image, le programme utilise fg_transfer pour copier l'arrière-plan de la page 2 à la page cachée, puis fg_clprect utilise pour afficher l'objet animé à la bonne position sur la page cachée. Après cela, il affiche l'image suivante en utilisant fg_setvpage pour rendre la page cachée de la page visuelle. Avant de commencer la prochaine itération, le programme permet de basculer le numéro de page cachée dans la préparation pour la trame suivante.

 Exemple 12-6.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()
          {
            int old_mode;
            int caché;
            int x;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
            if (testmode (fg_13,3) == 0) {
               printf ( "Ce programme nécessite EGA. \ n");
               sortie (1);
                }
            fg_getmode old_mode = ();
            fg_setmode (13);

 / * Dessiner l'arrière-plan à la page deux * /

 fg_setpage (2);
            fg_setcolor (1);
            fg_rect (0,319,0,199);
            fg_setcolor (15);
            fg_move (160,100);
            fg_ellipse (20,20);

 / * Glisser l'objet sur l'écran * /

 = Cachés 1;
            setcolor (10);
            for (x = -10; x <320; x + = 4) {
               fg_setpage (caché);
               fg_transfer (0,319,0,199,0,199,2, caché);
               fg_clprect (x, x + 19,96,105);
               fg_setvpage (caché);
               caché = 1 - caché;
               fg_waitfor (1);
               }   

 / * Rétablir le mode vidéo original et revenir à DOS * /

 fg_setmode (old_mode);
            fg_reset ();
          }


Un problème avec une ou l'autre technique page flipping se pose si nous utilisons virtuelle
pages vidéo. Page flipping repose sur le fait que le changement de numéro de page visuelle se produit instantanément, ce qui est exactement ce qui se passe lorsque nous utilisons les pages vidéo physiques. Cependant, ce n'est pas le cas avec des pages virtuelles ou logiques, car Fastgraph doit copier le contenu des pages entières dans la mémoire vidéo. Bien que cela se produit très rapidement, il est pas instantanée, et ses effets sont immédiatement visibles sur l'animation.


===Une animation Exemple: Le Fastgraph Fish Tank===

Si vous avez installé les exemples de programmes lorsque vous avez installé Fastgraph, la

Exemples sous-répertoire comprendra un programme entièrement commenté appelé le réservoir de poissons qui illustre l'animation de cadre dynamique. Le réservoir de poissons est un excellent exemple de multi-objet animation non-destructive dans laquelle plusieurs types de poissons tropicaux nagent en arrière contre un récif corallien de fond. Comme une image vaut 1.024 mots, nous vous suggérons d'étudier le code source de réservoir de poissons pour certaines techniques utiles dans l'élaboration d'un programme d'animation complet. Le code source pour le programme de réservoir de poissons est en FISHTANK.C, FISHTANK.BAS, FISHTANK.FOR ou FISHTANK.PAS, selon ce que le soutien langue que vous avez installé avec Fastgraph.


===Résumé des Techniques d'animation===

Ce chapitre a présenté cinq techniques d'animation: animation simple,
animation XOR, animation d'images statiques, animation d'images dynamiques, et page flipping. Le tableau suivant résume leur comportement.

technique destructrice? sans scintillement?

 simple, oui non
              XOR no no
              cadre statique non oui
              cadre dynamique non oui
              Page flipping non oui

animation simple et animation XOR sont des techniques élémentaires qui sont rarement utilisés une fois que vous maîtrisez l'animation de trame et la page flipping.

Comme indiqué au début de ce chapitre, les exemples simples présentés
ici servir de base pour la compréhension de la mécanique des techniques d'animation dont nous avons discuté. Dans les programmes du "monde réel", vous aurez généralement à afficher une image en utilisant la famille des routines à la place en utilisant des images rudimentaires fg_drwimage ou fg_drawmap tels que les rectangles dans nos exemples. Une règle utile est d'utiliser des fichiers pixel run PCX, GIF, ou pour les deux milieux et des objets en mouvement, puis utilisez fg_getimage ou fg_getmap pour récupérer les objets en mouvement comme des images bitmap pour l'affichage plus tard. Bien sûr, il est souhaitable de faire ce travail "dans les coulisses" sur les pages vidéo autres que la page visuelle. Ce
est précisément la technique utilisée dans l'aquarium Fastgraph. Guide de l'utilisateur 286 Fastgraph


==Effets spéciaux==

Ce chapitre traitera des routines Fastgraph qui aident à produire
effets visuels spéciaux. Ceux-ci incluent la possibilité de dissoudre le contenu de l'écran par petits incréments, faites défiler les zones de l'écran, changer l'origine physique de l'écran, et mettre en place un environnement d'écran divisé. Les exemples de programmes d'accompagnement illustrent comment utiliser ces routines pour produire des effets intéressants.


===Dissoudre écran===

dissolution de l'écran est le processus de remplacement du contenu de l'écran entier
en petits incréments aléatoires au lieu de tout à la fois. Fastgraph comprend deux routines, fg_fadeout et fg_fadein, à cette fin. La routine fg_fadeout remplace incrémentielle contenu de la page visuelle avec des pixels de la couleur actuelle, alors que fg_fadein remplace incrémentielle le contenu des pages visuelles avec le contenu des pages cachées (qui est, la page définie dans l'appel le plus récent à fg_sethpage). Les deux routines acceptent un argument entier qui définit le délai entre chaque remplacement progressif. Une valeur de zéro signifie que pour effectuer le remplacement le plus rapidement possible, alors que 1 est légèrement plus lent, 2 est plus lente encore, et ainsi de suite. Les fg_fadeout et fg_fadein routines ont aucun effet en mode vidéo texte et travaillent toujours avec des pages vidéo, même si un tampon virtuel est actif.

Exemple 13-1 montre comment utiliser fg_fadeout. Le programme, qui se déroule en tout
mode vidéo graphique, remplit d'abord l'écran avec un rectangle de couleur 2. Après avoir attendu pendant une séquence de touches, le programme remplace incrémentielle le contenu de l'écran avec des pixels de couleur 15 (l'indice de couleur courant lorsque fg_fadeout est appelé). Après une autre touche, le programme sort gracieusement.

 Exemple 13-1.

 #include <fastgraf.h>
                 void main (void);

 void main ()
                  {
                    int old_mode;

 fg_initpm ();
                    fg_getmode old_mode = ();
                    fg_setmode (fg_automode ());

 fg_setcolor (2);
                    fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                    fg_waitkey ();

 fg_setcolor (15);
                    fg_fadeout (0);
                    fg_waitkey ();

 fg_setmode (old_mode);
                    fg_reset ();
                 }   

 Exemple 13-2 montre comment utiliser fg_fadein dans tous les graphiques couleur 320x200

mode vidéo. Le programme remplit d'abord l'écran avec un rectangle de couleur 2, puis remplit Page vidéo 1 avec un rectangle de couleur 1. Après avoir attendu pendant une séquence de touches, le programme transfère incrémentielle le contenu de la page 1 à la page visuelle. Après l'appel à fg_fadein, à la fois la page 0 (la page visuelle) et la page 1 (page cachée) contiennent des rectangles de couleur 1 qui remplissent la page vidéo dans son intégralité. Enfin, le programme attend une autre touche avant de revenir à DOS.

 Exemple 13-2.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,2);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);
                   fg_allocate (1);
                   fg_sethpage (1);

 fg_setcolor (2);
                   fg_rect (0,319,0,199);
                   fg_setpage (1);
                   fg_setcolor (1);
                   fg_rect (0,319,0,199);
                   fg_waitkey ();

 fg_fadein (0);
                   fg_waitkey ();

 fg_freepage (1);
                   fg_setmode (old_mode);
                   fg_reset ();
                 }

Vous pouvez également produire des effets visuels attrayants en remplaçant le
contenu de l'écran d'une manière non aléatoire en utilisant les fg_restore ou fg_transfer routines. Par exemple, vous pouvez copier le contenu des pages cachées à la page visuelle à travers une série de zones rectangulaires concentriques, chacune légèrement plus grande que la précédente, jusqu'à ce que l'ensemble de l'écran est copié. Un autre effet intéressant est de commencer autour du périmètre de l'écran et procéder vers le Guide de l'écran 290 Fastgraph utilisateur
centre, produisant ainsi un effet de "serpent". Expérimenter avec de telles techniques peut révéler d'autres effets qui conviennent à votre application.


===Défilement===

Un autre effet utile défile, et Fastgraph fournit une routine qui
effectue le défilement vertical dans une région donnée de la page vidéo active. Les rouleaux de routine de fg_scroll une région définie dans l'espace de l'écran ou de l'espace de caractère. Il peut faire défiler vers le haut ou vers le bas et offre deux types de défilement: circulaire et à la fin-off. Dans le défilement circulaire, lignes qui défilent hors un bord de la zone définie apparaissent à son bord opposé. En bout de défilement, ces lignes vent simplement au-dessus ou au-dessous de la zone de défilement. Les schémas suivants illustrent les deux types de défilement.

 fin-off défilement défilement circulaire

 avant après avant après

 CB
                  AA

 AA
                  BB


Dans ces diagrammes, la zone délimitée par les lignes doubles est le défilement
région, tel que spécifié dans l'appel à fg_scroll. En outre, le sens de défilement est supposé être vers le bas (qui est, vers le bas de l'écran), et le nombre de lignes pour faire défiler est la hauteur de la zone désignée B. Le nombre de lignes pour faire défiler est souvent appelé l'incrément de défilement .

Pour l'exemple de fin de défilement, le défilement des transferts d'opération
région A la baisse de sorte qu'une partie de celui-ci est copié dans la zone B. La zone C (qui est la même taille que la zone B) en haut de la zone de défilement est rempli avec des pixels de l'indice de couleur courante (tels que définis dans l'appel le plus récent à fg_setcolor), et le contenu original de la zone B sont perdus. L'exemple de défilement circulaire copie également la région A vers le bas dans la zone B. originale Contrairement fin de défilement, cependant, le défilement circulaire préserve la zone B en le copiant sur le bord opposé de la zone de défilement.

La routine de fg_scroll prend six arguments. Les quatre premiers définissent la
défilement région dans le minimum de commande coordonnée x, maximum coordonnée x, y minimale coordonnée et maximale coordonnée y. Dans les modes graphiques vidéo, les coordonnées x sont étendues aux limites d'octets si nécessaire. Le cinquième argument est l'incrément de défilement. Il spécifie le nombre de lignes à faire défiler. Si elle est positive, le sens de défilement est vers le bas de l'écran; si elle est négative, la direction de défilement est vers le haut de l'écran. Le sixième et dernier argument spécifie le type de défilement. Si cette valeur est zéro, le défilement sera circulaire; si elle est une autre valeur, le défilement sera fin-off. Si le type de défilement est circulaire, Fastgraph utilisera la page cachée (tel que défini dans l'appel le plus récent à fg_sethpage) comme un espace de travail (plus précisément, la zone délimitée par la région extrêmes de défilement sur la page cachée sera utilisée). La routine de fg_scroll est désactivé quand un tampon virtuel est actif.

Nous allons maintenant présenter trois exemples de programmes qui utilisent la routine fg_scroll.

Exemple 13-3 fonctionne dans un mode vidéo 320x200 graphique. Le programme affiche deux lignes de texte ( «une ligne» et «aligner deux») dans le coin supérieur gauche de l'écran sur un fond blanc. Il utilise ensuite fg_scroll pour déplacer la deuxième ligne vers le bas quatre rangées de pixels en utilisant un rouleau fin-off. Après avoir attendu pendant une séquence de touches, le programme fg_scroll utilise à nouveau pour déplacer le texte à sa position d'origine. Remarque surtout comment fg_setcolor est utilisé avant le premier appel à fg_scroll pour remplacer le "off" défiler les lignes avec des pixels de couleur 15, préservant ainsi le fond blanc.

 Exemple 13-3.

 #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode;

 fg_initpm ();
                   new_mode = fg_bestmode (320,200,1);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);

 fg_setcolor (15);
                   fg_rect (0,319,0,199);
                   fg_setcolor (10);
                   fg_text ( "une ligne", 8);
                   fg_locate (1,0);
                   fg_text ( "aligner deux", 8);
                   fg_waitkey ();

 fg_setcolor (15);
                   fg_scroll (0,63,8,15,4,1);
                   fg_waitkey ();
                   fg_scroll (0,63,12,19, -4,1);
                   fg_waitkey ();

 fg_setmode (old_mode);
                   fg_reset ();
                 }


Exemple 13-4 est similaire à l'exemple 13-3, mais il court dans la colonne 80
mode texte de couleur (mode 3). En mode texte, nous ne pouvons pas faire défiler une demi-rangée de caractères comme dans l'exemple 13-3, de sorte que les rouleaux de programme d'une ligne minimale à la place.

 Exemple 13-4. 

 #include <fastgraf.h>
                         void main (void);

 void main ()
                          {
                            int old_mode;

 fg_initpm ();
                            fg_getmode old_mode = ();
                            fg_setmode (3);
                            fg_cursor (0);

 fg_setcolor (7);
                            fg_rect (0,79,0,24);
                            fg_setattr (10,7,0);
                            fg_text ( "une ligne", 8);
                            fg_locate (1,0);
                            fg_text ( "aligner deux", 8);
                            fg_waitkey ();

 fg_setcolor (7);
                            fg_scroll (0,7,1,1,1,1);
                            fg_waitkey ();
                            fg_scroll (0,7,2,2, -1,1);
                            fg_waitkey ();

 fg_setmode (old_mode);
                            fg_reset ();
                          }


Exemple 13-5, l'exemple de défilement finale, démontre une circulaire
faire défiler.Le programme fonctionne dans tous les modes graphiques vidéo 320x200 en couleurs; notez l'utilisation de la page vidéo 1 pour l'espace de travail requis lors de fg_scroll effectue un défilement circulaire. Le programme remplit d'abord l'écran avec un rectangle bleu clair (cyan dans CGA), affiche un rectangle blanc plus petit dans le centre de l'écran, puis utilise fg_move, fg_draw et fg_paint pour afficher une étoile verte lumière (magenta CGA) dans le rectangle blanc. Le programme exécute une boucle while pour faire défiler l'étoile vers le haut par incréments de quatre pixels. Parce que le défilement est circulaire, les lignes de l'étoile qui "Scroll off" le bord supérieur du rectangle blanc (dont la hauteur est la même que la zone de défilement) reparaître à son bord inférieur. L'utilisation de fg_waitfor dans la boucle ralentit simplement vers le bas du rouleau. Le défilement se poursuit jusqu'à ce qu'une touche est enfoncée.

 Exemple 13-5.

 #include <conio.h>
                #include <fastgraf.h>
                 #include <stdio.h>
                 #include <stdlib.h>
                void main (void);

 void main ()
                 {
                   int new_mode, old_mode; 
                                           Chapitre 13: Effets spéciaux 293


 fg_initpm ();
                   new_mode = fg_bestmode (320,200,2);
                   if (new_mode <0 || new_mode == 12) {
                      printf ( "Ce programme nécessite une 320");
                      ( "le mode x 200 graphiques couleur \ n".) printf;
                      sortie (1);
                       }
                   fg_getmode old_mode = ();
                   fg_setmode (new_mode);
                   fg_allocate (1);
                   fg_sethpage (1);

 fg_setcolor (9);
                   fg_rect (0,319,0,199);
                   fg_setcolor (15);
                   fg_rect (132,188,50,150);

 fg_setcolor (10);
                   fg_move (160,67);
                   fg_draw (175,107);
                   fg_draw (140,82);
                   fg_draw (180,82);
                   fg_draw (145,107);
                   fg_draw (160,67);
                   fg_paint (160,77);
                   fg_paint (150,87);
                   fg_paint (160,87);
                   fg_paint (170,87);
                   fg_paint (155,97);
                   fg_paint (165,97);

 tandis que (kbhit () == 0) {
                      fg_waitfor (1);
                      fg_scroll (136,184,50,150, -4,0);
                       }
                   fg_waitkey ();

 fg_freepage (1);
                   fg_setmode (old_mode);
                   fg_reset ();
                 }


===Modification de l'origine de l'écran===

Fastgraph comprend deux routines pour changer l'origine de l'écran.  Par
changer l'origine de l'écran, nous avons simplement entendons définir le (x, y) de coordonnées du coin supérieur gauche de la zone d'affichage. Les préformes de routine fg_pan cette fonction dans l'espace de l'écran, tandis que la routine fg_panw fait dans l'espace mondial. Ni les changements de routine les graphiques position du curseur. Parce que la fonction de fg_pan et fg_panw est de changer l'origine de l'écran, ces routines ne sont pas applicables aux tampons virtuels. Guide de l'utilisateur 294 Fastgraph


Chacun de ces sous-programmes comporte deux arguments qui spécifient x et y
les coordonnées de l'origine de l'écran. Pour fg_pan, les arguments sont des quantités entières. Pour fg_panw, ils flottent des quantités ponctuelles.

Dans le EGA, VGA, MCGA, modes XVGA et SVGA graphiques (modes 13 à 29),
vous pouvez définir l'origine de l'écran à tout (x, y) de coordonnées de position (qui est, à tout pixel). Dans d'autres modes les graphiques, certaines restrictions existent, imposées par le matériel vidéo spécifique. Ces contraintes limitent les positions de coordonnées qui peuvent être utilisés comme l'origine de l'écran. Fastgraph compense ces restrictions en réduisant spécifiées x et les coordonnées y des valeurs qui sont acceptables pour le mode vidéo en cours, comme indiqué dans le tableau suivant.

 x sera réduite y sera réduite
         mode vidéo à un multiple de: à un multiple de:

 4 à 5 août 2
              6 16 2
              9 4 4
             11 8 4
             12 4 2 ou 3

Dans les modes 4 et 5, par exemple, les coordonnées x seront réduits à un multiple de 8 pixels, et la coordonnée Y sera réduite à un multiple de 2 pixels. Dans le mode basse résolution Hercules (mode 12), la coordonnée y réduction dépend de si oui ou non la ligne de pixel spécifiée est scan doublé.

Exemple 13-6 montre un effet utile qui peut être réalisé avec ou fg_pan
fg_panw. Ce programme fg_automode utilise pour sélectionner un mode vidéo, puis dessine un rectangle blanc non rempli. Les faces supérieure et inférieure du rectangle sont intentionnellement dessinés juste plus petit que la taille physique de l'écran. Après avoir attendu pendant une séquence de touches, le programme utilise une boucle pour rendre le trémousser rectangle de haut en bas. Le déplace rectangle parce fg_pan est appelé dans la boucle pour changer l'origine de l'écran entre le coin supérieur gauche du rectangle et l'origine d'origine. Notez également l'utilisation de fg_waitfor pour provoquer de légers retards après chaque appel à fg_pan. Si on n'a pas utilisé fg_waitfor, le changement de l'origine se produirait si rapidement que nous ne remarquerait pas l'effet. Enfin, le programme restaure le mode vidéo original et attributs de l'écran avant de revenir à DOS.

 Exemple 13-6.

 #include <fastgraf.h>
                  #include <stdio.h>
                  #include <stdlib.h>
                 void main (void);

 #define DELAY 2
                 JUMP #define 4

 void main ()
                  {
                     int i;
                    int old_mode;

 fg_initpm (); 
                                           Chapitre 13: Effets spéciaux 295


 fg_getmode old_mode = ();
                    fg_setmode (fg_automode ());

 fg_setcolor (15);
                    fg_move (0, JUMP);
                    fg_draw (fg_getmaxx (), JUMP);
                    fg_draw (fg_getmaxx (), fg_getmaxy () - JUMP);
                    fg_draw (0, fg_getmaxy () - JUMP);
                    fg_draw (0, JUMP);
                    fg_waitkey ();

 for (i = 0; i <6; i ++) {
                       fg_pan (0, JUMP);
                       fg_waitfor (DELAY);
                       fg_pan (0,0);
                       fg_waitfor (DELAY);
                        }

 fg_setmode (old_mode);
                    fg_reset ();
                  }


La vraie puissance de fg_pan devient clair quand il est utilisé avec fg_resize à
effectuer un panoramique lisse. Rappel du chapitre 8 que fg_resize modifie la page vidéo dimensions en modes EGA et VGA graphiques natifs (modes 13 à 18), les modes étendus graphiques VGA (20 à 23), et les modes les SVGA graphiques (24 à 29). Nous allons maintenant présenter un exemple qui montre comment utiliser ces deux routines pour effectuer un panoramique en mode basse résolution EGA graphiques (mode 13). La méthode qu'il utilise également fonctionnerait dans un mode qui prend en charge la page de redimensionnement vidéo.

Exemple 13-7 commence par établir le mode vidéo, puis immédiatement
appels fg_resize pour augmenter la taille de la page vidéo de 640x400 pixels. Ainsi, la page vidéo est maintenant quatre fois sa taille originale. Suite à cela, le programme remplit la page (la page entière, et pas seulement ce qui est affiché) avec un rectangle vert clair avec une bordure blanche autour de lui. Il affiche ensuite le message "Appuyez sur les touches fléchées pour vous déplacer" dans le centre de la page 640x400.

La partie principale du programme est une boucle qui accepte les frappes et les appels
fg_pan pour effectuer le panoramique d'un pixel à la fois. Lorsque vous appuyez sur une des quatre touches fléchées, le programme ajuste les coordonnées x et y pour l'origine de l'écran comme indiqué. Par exemple, en appuyant sur la flèche haut fait défiler l'écran vers le haut un pixel. Lorsque nous arrivons au bord de la page vidéo, le programme empêche la poursuite de défilement dans cette direction. Ce processus se poursuit jusqu'à ce que vous appuyez sur la touche Echap, au moment où le programme restaure les attributs d'origine en mode vidéo et écran avant de quitter.

 Exemple 13-7.

 #include <fastgraf.h>
                 void main (void);

 void main ()
                  {
                    unsigned clé de char, aux;
                    int old_mode; 

Guide de l'utilisateur 296 Fastgraph


 int x, y;

 fg_initpm ();
                    fg_getmode old_mode = ();
                    fg_setmode (13);
                    fg_resize (640,400);

 fg_setcolor (2);
                    fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
                    fg_setcolor (15);
                    fg_box (0, fg_getmaxx (), 0, fg_getmaxy ());
                    fg_justify (0,0);
                    fg_move (320,200);
                    fg_print ( "Appuyez sur les touches fléchées pour vous déplacer.", 24);

 x = 0;
                    y = 0;

 faire {
                       fg_getkey (touche &, & aux);
                       if (aux == 72 && y <200)
                          y ++;
                       else if (aux == 75 && x <320)
                           x ++;
                       else if (aux == 77 && x> 0)
                          X--;
                       else if (aux == 80 && y> 0)
                           Y-;
                       fg_pan (x, y);
                    } While (key = 27!);

 fg_setmode (old_mode);
                    fg_reset ();
                  }


===Panning Avec Tampons Virtuels===

La routine de fg_pan ne convient pas pour le panoramique d'une grande image à travers un
petite fenêtre, car elle affecte l'ensemble de l'écran. Cependant, vous pouvez obtenir ce type de panoramique en stockant la grande image sur une page vidéo hors de l'écran ou dans un tampon virtuel, puis copier les parties appropriées à la fenêtre fixe sur la page visuelle. Exemple 13-8 illustre cette technique en utilisant un tampon virtuel.

 Exemple 13-8.

 #include <fastgraf.h>
                 void main (void);

 #ifdef FG32
                 char buffer [64000];
                  #autre
                 carboniser énorme tampon [64000];
                 #fin si   
                                           Chapitre 13: Effets spéciaux 297


 void main ()
                  {
                    unsigned clé de char, aux;
                    poignée int;
                    int old_mode;
                    int x, y;

 fg_initpm ();
                    fg_getmode old_mode = ();
                    fg_setmode (19);

 fg_vbinit ();
                    handle = fg_vbdefine (tampon, 320200);
                    fg_vbopen (poignée);
                    fg_loadpcx ( "CORAL.PCX", 0);
                    fg_vbclose ();

 fg_setcolor (2);
                    fg_fillpage ();
                    fg_setcolor (15);
                    fg_box (111,208,69,130);
                    fg_locate (3,8);
                    fg_text ( "Appuyez sur les touches fléchées pour vous déplacer.", 24);

 x = 112;
                    y = 129;
                    fg_vbpaste (x, x + 95, y 59, y, 112,129);

 faire {
                       fg_getkey (touche &, & aux);
                       if (aux == 72 && y <199)
                          y ++;
                       else if (aux == 75 && x <223)
                           x ++;
                       else if (aux == 77 && x> 0)
                          X--;
                       else if (aux == 80 && y> 59)
                           Y-;
                       fg_vbpaste (x, x + 95, y 59, y, 112,129);
                    } While (key = 27!);

 fg_setmode (old_mode);
                    fg_reset ();
                  }


Exemple 13-8 charge notre image familière de CORAL.PCX dans un 320x200 virtuel
tampon. Il définit ensuite une zone de 96x60 au milieu de la page visuelle qui servira d'une fenêtre dans l'image CORAL.PCX plus large (cette région est délimitée horizontalement par x = 112 et x = 207 et verticalement par y = 70 et y = 129). Le premier appel à fg_vbpaste copies de la partie centrale 96x60 du buffer virtuel à la fenêtre de la page visuelle. La boucle de panning est similaire à celle de l'exemple 13-7, sauf que fg_vbpaste utilise pour mettre à jour le contenu de la fenêtre. En appuyant sur les incréments de touches fléchées ou décrémente les coordonnées définissant la région de source dans le Guide de l'utilisateur 298 Fastgraph
la mémoire virtuelle. En outre, notons la façon dont nous avons ajusté l'if pour empêcher fg_vbpaste d'accéder à des pixels en dehors de la mémoire virtuelle.


===Écran divisé===

Fastgraph fournit un support écran partagé pour EGA, VGA, MCGA et XVGA
modes graphiques (modes 13 à 23) pour les applications en cours d'exécution sur les systèmes VGA ou SVGA. Quand un écran partagé est activé, la partie supérieure de l'écran (lignes 0 à n-1, où n est la rangée de pixels à laquelle l'écran partagé prend effet) contiendra un sous-ensemble de la page vidéo visuelle. La partie inférieure (à partir de la ligne n) contiendra la première fg_getmaxy () - n + 1 lignes de la page vidéo 0. Par exemple, supposons que nous utilisons un mode graphique de 200 lignes et nous permettre à un écran partagé à la ligne 180. Si la page 1 est la page vidéo visuelle, les 180 premières lignes de l'écran seront affichées à partir des lignes 0 à 179 de la page 1, et les 20 dernières lignes seront affichées à partir des lignes 0 à 19 de la page 0. Un environnement de l'écran partagé est utile pour maintenir une image statique, comme une boîte de tableau de bord ou de l'état, au bas de l'écran pendant le défilement de la partie supérieure.

Exemple 13-9 montre une opération typique de l'écran partagé en 320x200
XVGA mode graphique (mode 20). Dans cet exemple, nous supposerons que nous voulons avoir une boîte d'état occupant les 20 dernières lignes (lignes 180 à 199) de l'écran, tandis que les 180 rangées supérieures (0 à 179) seront défiler verticalement. Le programme commence par le réglage du mode vidéo, puis en appelant fg_measure pour calculer une valeur de retard dépendant processor- pour ralentir le défilement (cette technique est expliquée plus en détail dans le chapitre 16).

Dans le mode 20, la mémoire vidéo est structuré en quatre 320x200 pages physiques.
Page 1 est pas visible lorsque nous tirons la boîte bleue avec la bordure blanche, donc nous ne voyons pas jusqu'à ce que l'appel fg_setvpage faire page 1, page visuelle. Bien sûr, cela rend aussi la page 0 invisible, donc nous ne voyons pas la boîte creuse rouge de 20 pixels de haut quand nous dessinons à la page 0.

Une fois que nous avons établi ce que nous avons besoin dans les pages 0 et 1, nous activons le
écran partagé en appelant fg_split. Le seul paramètre passé à fg_split est la ligne de l'écran à laquelle l'écran partagé prend effet, ou en d'autres termes, le nombre de lignes dans la partie supérieure de l'écran. Dans l'exemple 13-9, nous fg_split (180) appelle, de sorte que les 180 premières lignes de la page 1 apparaissent en haut de l'écran, et les 20 premières lignes de la page 0 va apparaître au bas.

Maintenant, nous sommes prêts à faire défiler la partie supérieure de l'écran (qui est maintenant la page
1).fg_pan routine de Fastgraph convient à cet effet. Nous réalisons le défilement vers le haut par incrémentation de la fg_pan coordonnée y dans une boucle. Nous atteignons le défilement vers le bas par décrémenter la coordonnée y. Nous devons appeler fg_stall (ou utiliser une autre méthode similaire) pour forcer un bref délai entre les itérations. Si nous ne faisons pas cela, la pleine défilement 20 rangée apparaît presque instantanément, perdant ainsi l'effet de défilement. Notez que nous ne pouvions pas utiliser fg_pan pour faire défiler la partie supérieure de l'écran de cette manière sans mettre en place un environnement d'écran divisé. En effet, par défaut, fg_pan applique à l'ensemble de l'écran. Utilisation de l'écran partagé nous fournit deux pages vidéo indépendantes, et quand la page 1 est la page de vidéo active, fg_pan ne touche pas la page 0.

 Exemple 13-9.

 #include <fastgraf.h>
   void main (void); 
                                           Chapitre 13: Effets spéciaux 299


 void main ()
    {
      int retard, y;

 / * Initialisation de l'environnement vidéo * /

 fg_initpm ();
      fg_setmode (20);

 / * Définir un retard de panoramique processeur dépendant * /

 delay = fg_measure () / 16;

 / * Dessiner une boîte bleue avec une bordure blanche à la page 1 * /

 fg_setpage (1);
      fg_setcolor (9);
      fg_fillpage ();
      fg_setcolor (15);
      fg_box (0,319,0,199);
      fg_move (160,100);
      fg_justify (0,0);
      fg_print ( "Ceci est la page 1", 14);

 / * Affiche ce que nous venons dessiné à la page 1 * /

 fg_setvpage (1);
      fg_waitkey ();

 / * Dessiner une boîte creuse rouge en haut de la page 0 (maintenant invisible) * /

 fg_setpage (0);
      fg_setcolor (12);
      fg_box (0,319,0,19);
      fg_setcolor (15);
      fg_move (160,10);
      fg_print ( "Split Screen", 12);

 / * Activer l'environnement d'écran divisé, ce qui rend le premier * /
      / * 20 lignes de la page 0 apparaissent en bas de l'écran, * /
      / * Et faire les 180 premières lignes de la page 1 apparaît en haut * /

 fg_split (180);
      fg_waitkey ();

 / * Recadrer vers le haut par incréments d'une ligne, l'affichage du reste de * /
      /* Page 1 */

 fg_setpage (1);
      pour (y = 0; y <= 20; y ++)
       {
         fg_pan (0, y);
         fg_stall (retard);
       }
      fg_waitkey (); 

  / * Panoramique vers le bas par incréments d'une ligne à la position initiale * /

  pour (y = 20; y> = 0; Y-)
       {
          fg_pan (0, y);
          fg_stall (retard);
       }
       fg_waitkey ();

  / * Restauration 80x25 mode texte et la sortie * /

  fg_setmode (3);
       fg_reset ();
    }


Pour passer d'un environnement d'écran divisé retour à une «page unique»
environnement, appelez fg_split avec un paramètre de ligne égale à la résolution verticale de l'écran pour le mode vidéo actuel.


===Résumé des effets spéciaux Routines===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_FADEIN remplace incrémentielle la page contenu visuel avec le caché
contenu de la page. Cette routine n'a pas d'effet dans les modes vidéo texte et ne sont pas applicables aux tampons virtuels.

FG_FADEOUT remplace incrémentielle contenu de la page visuelle avec des pixels de
la couleur actuelle. Cette routine n'a pas d'effet dans les modes vidéo texte et ne sont pas applicables aux tampons virtuels.

FG_PAN change l'origine de l'écran (le coin supérieur gauche de l'écran) pour
coordonne l'espace de l'écran spécifié. Cette routine n'a pas d'effet dans les modes vidéo texte et ne sont pas applicables aux tampons virtuels.

FG_PANW est la version de la routine de fg_pan espace mondial.

FG_RESIZE modifie les dimensions d'une page vidéo EGA et VGA graphiques
modes. Cette routine est désactivé quand un tampon virtuel est actif.

FG_SCROLL fait défiler verticalement une région de la page vidéo active.  le
le défilement peut être fait soit vers le haut ou vers le bas, en utilisant soit une fin-off ou de la méthode circulaire. défilement circulaire utilise une partie de la page cachée comme un espace de travail temporaire. Cette routine ne fonctionne pas quand un tampon virtuel est actif.

FG_SPLIT active ou désactive un environnement d'écran partagé en EGA, VGA,
MCGA et XVGA modes graphiques.


==Guide de support de périphériques d'entrée==

La sélection des périphériques d'entrée d'application est une partie importante de
la conception d'un programme pour le PC IBM et PS / 2 famille de systèmes. Le clavier et la souris sont les plus populaires, et en fait de plus en plus d'applications, en particulier ceux qui utilisent une interface graphique, réellement besoin d'une souris pour utiliser le produit. Un autre dispositif d'entrée, principalement utilisé dans les logiciels de divertissement, est le joystick. Bien que pas aussi populaire que la souris, joysticks peuvent néanmoins simplifier l'utilisation de certaines applications. Fastgraph fournit un support pour ces trois types de périphériques d'entrée, et ce chapitre discutera en détail.


===Keyboard support===

Le support du clavier de Fastgraph comprend des routines pour lire les frappes, chèque
l'état de certaines touches, et réglez l'état de ces touches. En outre, Fastgraph fournit un gestionnaire de clavier de bas niveau qui remplace le gestionnaire de clavier du BIOS pour augmenter la réactivité du clavier. Ces routines sont indépendantes des autres parties du Fastgraph et ne nécessitent donc pas que vous appelez fg_setmode. Toutes les routines liées au clavier fonctionnent en mode texte et des graphiques vidéo.

Le PC IBM et claviers PS / 2 produire deux types de codes de caractères -
codes standards et codes étendus (codes étendus sont parfois appelés codes auxiliaires). Les codes standard correspondent aux 128 caractères dans le jeu de caractères ASCII. En général, la pression des touches sur la partie principale du clavier ou du pavé numérique avec NumLock allumé, va générer un code standard. Les 128 codes étendus sont spécifiques au PC IBM et claviers PS / 2. Quelques frappes communes qui produisent des codes étendus sont des touches du pavé numérique avec NumLock éteint, les touches de fonction, ou en appuyant sur Alt avec une autre touche. Les tableaux suivants présentent les codes de clavier standard et étendu.

  Tableau des codes de clavier standard

  code clé code clé code clé code clé

  (None) 0 espace 32 @ 64 `96
           Ctrl + A 1!  33 A 65 a 97
           Ctrl + B 2 "34 B 66 b 98
           Ctrl + C 3 # 35 C 67 c 99
           Ctrl + D 4 $ 36 D 68 d 100
           Ctrl + E 5% 37 E 69 e 101
           Ctrl + F 6 et 38 F 70 f 102
           Ctrl + G 7 '39 G 71 g 103
           Ctrl + H 8 (40 H 72 h 104
           Ctrl + I 9) 41 I 73 i 105
           Ctrl + J 10 * 42 J 74 j 106
           Ctrl + K 11 + 43 K 75 k 107
           Ctrl + L 12, 44 L 76 l 108
           Ctrl + M 13-45 M 77 m 109
           Ctrl + N 14.  46 N 78 n 110
           Ctrl + O 15/47 O 79 o 111
           Ctrl + P 16 0 48 P 80 p 112

  Ctrl + Q 17 1 49 Q 81 q 113
           Ctrl + R 18 2 50 R 82 r 114
           19 3 51 S 83 de Ctrl + s 115
           Ctrl + T 20 4 52 T 84 t 116
           Ctrl + U 21 5 53 U 85 u 117
           Ctrl + V 22 6 54 V 86 v 118
           Ctrl + W 23 7 55 W 87 w 119
           Ctrl + X 24 8 56 X 88 x 120
           Ctrl + Y 25 9 57 Y 89 y 121
           Ctrl + Z 26: 58 Z 90 z 122
           Ctrl + [27;  59 [91 {123
           Ctrl + \ 28 <60 \ 92 |  124
           Ctrl +] 29 = 61] 93} 125
           Ctrl + ^ 30> 62 ^ 94 ~ 126
           Ctrl + - 31?  63 _ 95 Ctrl + BS 127


  Tableau des codes de clavier étendu

  clé de code

  3 Ctrl + @
              15 Maj + Tab (onglet arrière)
              16-25 Alt + Q pour Alt + P (rangée supérieure de lettres)
              30-38 Alt + A pour Alt + L (rangée du milieu de lettres)
              44-50 Alt + Z à Alt + M (rangée du bas de lettres)
              59-68 F1 à F10
              71 Accueil
              72 flèche vers le haut
              73 PgUp
              75 flèche gauche
              77 flèche droite
              79 Fin
              80 flèche vers le bas
              81 PgDn
              82 Ins
              83 Del
              84-93 Maj + F1 à Maj + F10
              94-103 Ctrl + F1 pour Ctrl + F10
              104-113 Alt + F1 à Alt + F10
              114 Ctrl + PrtSc
              115 Ctrl + flèche gauche
              116 Ctrl + flèche droite
              117 Ctrl + Fin
              118 Ctrl + PgDn
              119 Ctrl + Accueil
              120-131 Alt + 1 à Alt + = (rangée supérieure de touches)
              132 Ctrl + PgUp


En outre, quatre touches génèrent les mêmes codes standard que les autres combinaisons de touches de commande. Ces clés sont:

  clé même code

  Backspace Ctrl + H 8

  Tab Ctrl + I 9
                         Entrez Ctrl + M 13
                         Évadez Ctrl + [27

Les touches CapsLock, NumLock et ScrollLock ne génèrent pas une norme ou
Code étendu lorsqu'il est pressé. Au lieu de cela, ils basculer entre off et les Etats.


===lecture Keystrokes===

Lorsque vous appuyez sur une combinaison de touches ou la touche, le code standard ou étendu
représentant cette séquence de touches est stockée dans la mémoire tampon de clavier du BIOS ROM. Ce tampon peut contenir jusqu'à 16 frappes et fournit ainsi une capacité de type avance. Fastgraph comprend trois routines pour lire une information de frappe de la mémoire tampon de clavier. La routine de fg_getkey lit l'élément suivant dans la mémoire tampon de clavier si l'on est disponible (qui est, si une touche a été pressée). Si la mémoire tampon du clavier est vide (ce qui signifie aucune touche n'a été pressée), fg_getkey attend une touche, puis fournit des informations à ce sujet. Une autre routine, fg_intkey, lit la frappe suivante de la mémoire tampon du clavier si l'on est disponible. Si la mémoire tampon du clavier est vide, fg_intkey retourne et rapports immédiatement cette condition. La routine de fg_intkey est utile lorsqu'un programme doit continuer d'exécuter une tâche jusqu'à ce qu'une touche est enfoncée. Nous avons déjà vu la troisième routine, fg_waitkey, qui vide le tampon du clavier, puis attend une autre touche. Contrairement à fg_getkey et fg_intkey, fg_waitkey ne renvoie aucune information de frappe. Il est très utile dans «appuyer sur une touche pour continuer" situations.

Les deux fg_getkey et fg_intkey nécessitent deux arguments d'un octet adoptées par
référence. Si la frappe est représentée par une norme de code de clavier, fg_getkey et fg_intkey retourner son code dans le premier argument et définir le second argument à zéro. De même, si la frappe génère un code étendu, les routines renvoient son code dans le second argument et mettre le premier argument à zéro. Si fg_intkey détecte une mémoire tampon du clavier vide, il définit les deux arguments à zéro.

Exemple 14-1 est un programme simple qui utilise fg_getkey.  Il sollicite
frappes et puis affiche les deux valeurs renvoyées par fg_getkey dont l'un sera toujours zéro. La variable clé reçoit le code standard de la clé, tandis aux reçoit son code étendu. A noter que fg_initpm et fg_getkey sont les seules routines Fastgraph du programme; cela peut être fait parce que les routines de support du clavier sont logiquement indépendants du reste de Fastgraph. Le programme retourne au DOS lorsque vous appuyez sur la touche Echap.

  Exemple 14-1.

  #include <fastgraf.h>
                #include <stdio.h>
                void main (void);

  #define ESC 27

  void main ()
                {
                   unsigned clé de char, aux;

  fg_initpm (); 
                                       Chapitre 14: Entrée Device Support 305


  faire {
                      fg_getkey (touche &, & aux);
                      printf ( "key =% 3d aux =% 3d \ n", clé, aux);
                      }
                   while (key = ESC!);
                }


  Exemple 14-2 lit les frappes à l'aide de fg_intkey à intervalles d'une demi-seconde

(18.2 fg_waitfor unités égales d'une seconde). Comme dans l'exemple précédent, le programme affiche les codes standard et étendu pour chaque frappe. Cependant, l'exemple 14-2 continuellement exécuter la boucle while même si aucune des séquences de touches sont disponibles, auquel cas les valeurs clés et aux deux seront zéro. Le programme retourne au DOS lorsque vous appuyez sur la touche Echap.

  Exemple 14-2.

  #include <fastgraf.h>
                #include <stdio.h>
                void main (void);

  #define ESC 27

  void main ()
                {
                   unsigned clé de char, aux;

  fg_initpm ();
                   faire {
                      fg_waitfor (9);
                      fg_intkey (touche &, & aux);
                     printf ( "key =% 3d aux =% 3d \ n", clé, aux);
                      }
                  while (key = ESC!);
                }


Lorsque vous utilisez fg_intkey dans une boucle "serré" qui ne fait guère d'autre, vous
devrait forcer un petit retard dans la boucle en appelant fg_waitfor comme dans l'exemple 14-2. Typiquement, un retard d'une ou deux impulsions d'horloge est suffisant. Sans ce délai, le BIOS peut ne pas être capable de gérer toutes les activités de clavier, et donc des frappes peut ne pas être disponible pour votre programme.


===Test et réglage États clés===

Comme mentionné précédemment, les CapsLock, NumLock, et les clés ScrollLock ne le font pas
générer un code standard ou étendu lorsqu'il est pressé, mais au lieu de basculer entre off et les Etats. Fastgraph comprend des routines pour vérifier l'état de ces touches, ainsi que la mise en l'état des touches CapsLock et NumLock.

Les routines Fastgraph fg_capslock, fg_numlock et fg_scrlock
respectivement lire l'état des touches ScrollLock CapsLock, NumLock, et. Chaque routine n'a pas d'arguments et renvoie l'état clé comme valeur de la fonction. Une valeur de retour de 0 signifie que la clé associée est à l'état bloqué, tandis que le Guide de 1 306 Fastgraph utilisateur
indique que la clé est dans l'état. Si le clavier ne dispose pas d'une clé ScrollLock, fg_scrlock considère la clé off et renvoie une valeur de zéro.

Exemple 14-3 est un programme simple qui utilise fg_capslock, fg_numlock, et
fg_scrlock d'imprimer des messages décrivant l'état actuel de ces trois touches.

 Exemple 14-3.

 #include <fastgraf.h>
                     #include <stdio.h>
                    void main (void);

 void main ()
                     {
                       fg_initpm ();
                       if (fg_capslock ())
                          printf ( "CapsLock est sur \ n.");
                        autre
                          printf ( "CapsLock est désactivé. \ n");

 if (fg_numlock ())
                          printf ( "Verr Num est sur \ n.");
                        autre
                          printf ( "Verr Num est désactivé. \ n");

 if (fg_scrlock ())
                          printf ( "ScrollLock est sur \ n.");
                        autre
                          printf ( "ScrollLock est désactivé. \ n");
                     }


Vous pouvez également définir l'état des CapsLock et NumLock clés au sein d'un
programme.Fastgraph comprend deux routines, fg_setcaps et fg_setnum, à cette fin. Chaque routine exige un argument entier qui spécifie le nouvel état clé. Si la valeur de l'argument est 0, la clé sera désactivée; si la valeur est 1, la touche est activée. Exemple 14-4 utilise fg_setcaps et fg_setnum pour désactiver CapsLock et Verr Num.

 Exemple 14-4.

 #include <fastgraf.h>
                            void main (void);

 void main ()
                             {
                               fg_initpm ();
                               fg_setcaps (0);
                               fg_setnum (0);
                             }


Sur la plupart des claviers, en changeant les Etats clés avec fg_setcaps ou fg_setnum aussi
va changer la lumière de l'état du clavier pour refléter le nouvel état clé. Cependant, certains claviers plus âgés, en particulier lorsqu'il est utilisé sur PC, PC / XT, ou Tandy 1000
systèmes, ne mettent pas à jour la lumière de l'Etat. Cela rend la lumière de l'Etat incompatible avec le véritable état clé.


===Low-Level Keyboard Handler===

Fastgraph comprend un gestionnaire de clavier de bas niveau qui remplace le BIOS
gestionnaire de clavier. Les interceptions de gestionnaire de remplacement frappes avant le BIOS et élimine ainsi le signal sonore gênant qui sonne lors du remplissage de la mémoire tampon du clavier du BIOS. Le gestionnaire de clavier de Fastgraph est particulièrement bien adapté pour le développement de jeux, car elle augmente la réactivité du clavier dans les jeux d'action à grande vitesse. Toutefois, lorsque le gestionnaire de clavier de bas niveau est activé, il est impossible d'utiliser fg_getkey, fg_intkey, fg_waitkey, ou des fonctions de tiers qui utilisent BIOS ou services DOS pour l'activité du clavier. Pour cette raison, un programme qui permet au gestionnaire de clavier de bas niveau doit le désactiver avant de quitter pour DOS.

Le gestionnaire de clavier de bas niveau peut être activé et désactivé à tout moment.

La routine de fg_kbinit est prévu à cet effet. Pour permettre à faible gestionnaire de clavier de niveau Fastgraph, passez la valeur 1 à fg_kbinit. Pour désactiver le gestionnaire de Fastgraph et réactiver le gestionnaire de clavier du BIOS, passer la valeur zéro. Aucun dommage est causé si vous essayez d'activer le gestionnaire de clavier Fastgraph quand il est déjà actif, ou si vous essayez de le désactiver lorsque le gestionnaire du BIOS est actif.

Lorsque le gestionnaire de clavier de bas niveau est activé, vous pouvez utiliser fg_kbtest à
vérifier si les touches sont actuellement enfoncée ou relâchée. Ce sous-programme fournit le seul mécanisme pour accéder au clavier lorsque le gestionnaire de niveau bas est activé. Il précise les clés à travers des codes de balayage. Si la touche correspondante est pressée, fg_kbtest renvoie 1. Si elle est libérée, la routine renvoie zéro. La routine de fg_kbtest peut tester si une touche est enfoncée si vous passez la valeur 0 à la place d'un code d'analyse spécifique. Le tableau suivant répertorie les codes de balayage correspondant aux touches d'un clavier de PC standard.

 Table de codes de balayage

 scan scan scan scan
          code clé code clé code clé code clé

 Esc 1 I 23 X 45 F9 67
          1 2 O 24 C 46 F10 68
          2 3 P 25 V 47 NumLock 69
          3 4 [26 B 48 ScrLock 70
          4 5] 27 N 49 71 Accueil
          5 6 Entrez 28 M 50 Up flèche 72
          6 7 Ctrl 29, 51 PgUp 73
          7 8 A 30. 52 KP- 74
          8 9 S 31/53 L flèche 75
          9 10 D 32 R shift 54 ??KP5 76
          0 11 F 33 R 55 KP * flèche 77
          - 12 G 34 Alt 56 KP + 78
          = H 13 35 Espace 57 79 Fin
          BS 14 J 36 CapsLock 58 Dn flèche 80
          Tab 15 K 37 F1 59 PgDn 81
          Q 16 L 38 F2 60 Ins 82
          W 17; 39 F3 61 Del 83
          E 18 '40 F4 62 (non utilisé) 84   
 R 19 `41 F5 63 (non utilisé) 85
          T 20 L décalage 42 F6 64 (non utilisé) 86
          Y 21 \ 43 F7 65 F11 87
          U 22 Z 44 F8 66 F12 88


Il y a des codes en fait plus d'analyse définis pour les claviers de PC que ceux énumérés
dans ce tableau. Ces codes de balayage sont générés quand une touche est pressée comme une combinaison d'une ou plusieurs touches, par exemple lorsque les touches Maj et slash sont pressées ensemble pour produire un point d'interrogation (?) Caractère. faible gestionnaire de clavier au niveau de Fastgraph est conçu pour signaler la compression ou la libération de touches elles-mêmes, par opposition à la communication des caractères réels ainsi produits. Il est donc impossible pour le gestionnaire de clavier pour signaler le code de balayage pour un caractère multi-clé. Si nécessaire, ces caractères peuvent être identifiés par les codes de balayage généré pour chaque clé dans la séquence. Par exemple, un point d'interrogation devrait être déclarée comme une barre oblique (code de balayage 53) généré en appuyant sur le décalage à gauche (42) ou décalage à droite (54) touches.

Exemple 14-5 illustre l'utilisation du clavier de bas niveau de Fastgraph
gestionnaire. Il fg_kbinit utilise d'abord pour permettre le gestionnaire de clavier Fastgraph et affiche un message indiquant cela. Puis, à environ une seconde d'intervalle, le programme appelle fg_kbtest pour vérifier lequel des quatre touches fléchées sont pressées et affiche un message approprié. En appuyant sur Echap restaure le gestionnaire de clavier du BIOS et quitte à DOS.

 Exemple 14-5.

 #include <fastgraf.h>
                #include <stdio.h>
               void main (void);

 #define ESC 1
               #define GAUCHE 75
               #define DROIT 77
               #define UP 72
               #define BAS 80

 void main ()
                {
                  fg_initpm ();
                  fg_kbinit (1);
                  printf ( "Keyboard gestionnaire activé. \ n");

 faire {
                     printf ( "touches enfoncées:");
                     if (fg_kbtest (GAUCHE)) printf ( "gauche");
                     if (fg_kbtest (DROITE)) printf ( «droit»);
                     if (fg_kbtest (UP)) printf ( "Up");
                     if (fg_kbtest (DOWN)) printf ( "Down");
                      printf ( "\ n");
                     fg_waitfor (18);
                  } While (fg_kbtest (ESC) == 0);

 fg_kbinit (0);
                  printf ( "Keyboard gestionnaire désactivé. \ n");
               }   
                                      Chapitre 14: Entrée Device Support 309



Fastgraph comprend deux autres routines pour le gestionnaire de clavier de bas niveau.

La fonction fg_kblast renvoie le code de balayage pour le plus récent keypress traitées par le gestionnaire de clavier de bas niveau. S'il n'y a pas eu de touches depuis l'appel fg_kbinit, la valeur de retour sera zéro. La routine de fg_kbreset réinitialise l'état du gestionnaire de clavier de bas niveau de Fastgraph à ce qu'elle était après avoir été initialisé avec fg_kbinit (1). Ceci a pour effet de "rinçage" le gestionnaire de clavier. Aucune de ces deux fonctions a des arguments.


===Mouse support===

La souris est un périphérique d'entrée et de pointage très populaire, en particulier dans
graphiquement des programmes orientés. Fastgraph contient plusieurs routines pour soutenir les souris. Ces routines effectuent des tâches telles que l'initialisation de la souris, le contrôle et la définition du curseur de la souris, et les rapports d'informations sur la position de la souris et de l'état du bouton.

Le logiciel sous-jacent qui contrôle la souris est appelée la souris
chauffeur.Les routines de support de la souris de Fastgraph fournissent une interface de haut niveau pour ce pilote. La souris Microsoft et son pilote de souris d'accompagnement sont devenus un standard de l'industrie, et d'autres fabricants de souris ont également fait leurs pilotes de souris compatible Microsoft. Pour cette raison, les routines de support de la souris Fastgraph supposent que vous utilisez un Microsoft ou le pilote de la souris compatible.

Malheureusement, tous les pilotes non de la souris sont créés égaux. Autrement dit, certains
les pilotes ne sont pas compatibles Microsoft, même si elles peuvent être annoncés en tant que telle. Dans certains cas, ces incompatibilités sont plutôt trivial, mais d'autres sont importants. Par exemple, les premières versions de certains pilotes tiers de souris avaient des problèmes réels dans les modes graphiques EGA. Le pilote de la souris Microsoft, le pilote souris Logitech (version 3.2 ou supérieure), et le pilote de la souris DFI (version 3.00 ou plus) sont connus pour bien travailler avec les routines de support de la souris de Fastgraph. Toute autre pilote de souris compatible Microsoft devrait également fonctionner correctement.


===Initialisation de la souris===

Il y a deux étapes nécessaires pour utiliser les routines de support de la souris de Fastgraph
au sein d'un programme d'application. D'abord, vous devez installer le pilote de la souris. Cela se fait avant de lancer l'application, généralement en entrant la commande MOUSE à l'invite de commande DOS. Deuxièmement, vous devez utiliser la fonction fg_mouseini de Fastgraph pour initialiser la souris dans le programme.

La fonction fg_mouseini n'a pas d'arguments et retourne un "succès ou
échec indicateur "comme valeur de fonction. Si la valeur de retour est -1, cela signifie fg_mouseini n'a pas pu initialiser la souris (soit parce que le pilote de la souris est pas installé, ou le pilote est installé, mais la souris est physiquement déconnecté). La valeur de retour sera également -1 si fg_mouseini est appelée quand un tampon virtuel est actif. Si fg_mouseini retourne une valeur entière positive, l'initialisation de la souris a réussi. la valeur elle-même indique le nombre de boutons (soit 2 ou 3) sur la souris. Si vous ne pas appeler fg_mouseini, ou si le Guide de l'utilisateur 310 Fastgraph


fg_mouseini ne peut pas initialiser la souris, aucun des autres routines de support de la souris de Fastgraph aura des effect.3

Exemple 14-6 illustre comment initialiser la souris. A la différence du clavier
routines de soutien, les routines de support de la souris de Fastgraph exigent que fg_setmode être appelé en premier. Dans cet exemple, nous passons simplement fg_setmode la valeur -1 pour initialiser Fastgraph pour tout ce mode vidéo est en vigueur lorsque nous courons le programme. Le programme appelle ensuite fg_mouseini et imprime un message indiquant si oui ou non l'initialisation a réussi. Si cela était le message comprend le nombre de boutons de la souris.

 Exemple 14-6.

 #include <fastgraf.h>
               #include <stdio.h>
              void main (void);

 void main ()
               {
                 statut int;

 fg_initpm ();
                 fg_setmode (-1);
                 status = fg_mouseini ();

 si (état <0)
                    printf ( "Souris pas disponible \ n".);
                  autre
                    printf ( "% d bouton de la souris trouvée. \ n", état);
               }


Vous devez être conscient que certains pilotes de souris n'initialisent pas entièrement
la souris lorsqu'un programme change les modes vidéo. Ce problème se produit plus fréquemment lorsque vous restaurez le mode vidéo d'origine à la fin d'un programme qui a appelé fg_mouseini. Lors du changement de mode vidéo, vous devez d'abord faire le curseur de la souris invisible (ceci est décrit dans la section suivante), changer le mode vidéo, puis appelez fg_mouseini nouveau pour initialiser la souris pour le nouveau mode vidéo.


====XVGA et SVGA Souris Considérations====

les pilotes de souris ne peuvent pas afficher directement le curseur de la souris dans XVGA et SVGA
modes graphiques (modes 20 à 29). Par conséquent, Fastgraph doit afficher le curseur de la souris à travers un gestionnaire d'interruption qui est activé chaque fois que la souris se déplace. Le gestionnaire est installé automatiquement lorsque vous appelez fg_mouseini dans les modes 20 à 29.


____________________

Si vous utilisez une autre bibliothèque de souris ou de communiquer directement avec la souris
pilote, vous devez toujours appeler fg_mouseini si votre programme fonctionne dans les modes 13 à 18. Dans le cas contraire, Fastgraph ne saura pas que votre programme utilise une souris et peut afficher des graphiques de manière incorrecte.

Si vous ne désactivez pas ce gestionnaire avant votre programme se termine, il sera
rester "accroché" au pilote de la souris. Ce sera très probablement accrocher votre système la prochaine fois que vous essayez de faire quoi que ce soit de conséquence. La routine fg_mousefin supprime le gestionnaire d'interruption de la souris de Fastgraph du pilote de la souris. Dans les modes XVGA et SVGA graphiques, vous devriez appeler fg_mousefin juste avant de restaurer le mode vidéo d'origine, comme indiqué ici:


 fg_mousefin ();
                            fg_setmode (old_mode);
                            fg_reset ();


Encore une fois, fg_mousefin appel est nécessaire que dans les modes graphiques XVGA et SVGA. L'appeler dans d'autres modes vidéo est pas applicable, si elle ne pose aucun problème.

Dans le VGA standard / MCGA mode 256 couleurs (mode 19), les pixels blancs dans le
curseur souris sont affichées dans la couleur 15. Cela est incompatible avec d'autres modes graphiques, où les pixels blancs du curseur de la souris sont affichées dans la valeur de couleur numéro le plus élevé disponible dans ce mode. Fastgraph corrige cette incohérence dans XVGA et modes SVGA 256 couleurs graphiques en affichant blanc curseur de la souris pixels de couleur 255. Comme la couleur 15, la couleur 255 est blanc par défaut. Cela vous permet de redéfinir la couleur 15 dans vos applications 256 couleurs sans interférer avec les couleurs du curseur de la souris.


====Contrôle du curseur de la souris====

Le curseur de la souris indique que la position courante de la souris.  Par défaut,
le curseur est une petite flèche blanche dans les modes graphiques et un rectangle d'un caractère en mode texte. Après avoir utilisé fg_mouseini pour initialiser la souris, le curseur de la souris est invisible. Pour le rendre visible, vous devez utiliser fg_mousevis. Cette routine a un seul argument entier qui définit la visibilité du curseur de la souris. Si elle est de 0, le curseur de la souris sera invisible; si elle est 1, le curseur de la souris devient visible. Si le curseur de la souris est déjà dans l'État requis, fg_mousevis ne fait rien.

Si le curseur se trouve dans une zone de l'écran étant mis à jour, ou si
se déplace dans ce domaine au cours du processus de mise à jour, vous devez faire le curseur de la souris invisible ou le congeler à sa position actuelle. Vous devez aussi le faire lors de l'exécution de sortie vidéo dans les modes EGA et VGA graphiques natifs (modes 13 à 18). Au lieu de vérifier ces conditions, il est souvent plus pratique et efficace pour rendre le curseur de la souris invisible pendant toutes les mises à jour de l'écran, puis le rendre visible à nouveau lorsque la mise à jour est terminée. Une alternative à rendre le curseur de la souris invisible gèle à sa position actuelle en utilisant fg_mousepos et fg_mouselim (ces routines seront décrites sous peu) au cours des mises à jour de l'écran, puis restaurer les limites de la souris par défaut. Notez, cependant, que cette méthode ne fonctionne que si le curseur de la souris est en dehors de la zone mise à jour. Vous devez également faire le curseur de la souris invisible lors du changement de numéro de page visuel avec fg_setvpage.

Après l'initialisation de la souris, le curseur est positionné dans le centre de
l'écran.Déplacer la souris bien sûr change la position du curseur, mais vous pouvez également placer le pointeur de la souris avec le fg_mousemov routine Fastgraph. Cette routine a deux arguments qui spécifient le nouveau Guide 312 Fastgraph utilisateur horizontal et vertical
la position du curseur. La position est exprimée en unités d'espace d'écran pour les modes graphiques, alors qu'il est exprimé dans les cellules de caractères pour les modes de texte. La routine fg_mousemov déplace le curseur si oui ou non il est visible.

Parfois, il est utile de limiter le curseur de la souris sur une zone déterminée de
l'écran.La fg_mouselim routine Fastgraph empêche le curseur de la souris de se déplacer en dehors de la zone rectangulaire spécifiée. Il nécessite quatre arguments qui spécifient l'horizontale minimale coordonnée, horizontale maximale de coordonnées, coordonnée minimale verticale et maximale coordonnée verticale de cette zone. Encore une fois, les coordonnées sont exprimées en unités d'espace d'écran pour les modes graphiques et des cellules de caractères pour les modes de texte.

L'une des fonctions les plus importantes du pilote de la souris est de traduire
les mouvements de la souris horizontale et verticale dans une position sur l'écran. La souris signale ces mouvements vers le pilote de souris en unités appelées mickeys (un mickey est d'environ 1/200 de pouce, bien que pour certains pilotes de souris, il est 1/400 de pouce). Par défaut, le déplacement de la souris 8 mickeys dans le sens horizontal déplace le curseur de la souris un pixel horizontal. De même, en déplaçant la souris 16 mickeys se déplace verticalement le curseur d'un pixel vertical. Fastgraph fournit une fg_mousespd nommée routine qui peut modifier ces valeurs, ce qui permet effectivement de contrôler la vitesse à laquelle le curseur de la souris se déplace par rapport au mouvement de la souris elle-même. La routine de fg_mousespd nécessite deux arguments qui définissent le nombre de mickeys requis pour huit pixels de déplacement du curseur de la souris. Le premier argument spécifie ce pour la direction horizontale, et le second pour la direction verticale.

Exemple 14-7, qui fonctionne dans un mode graphique, démontre fg_mousevis,
fg_mousemov, fg_mouselim et fg_mousespd. Le programme établit d'abord le mode vidéo, initialise la souris, et remplit l'écran avec un rectangle blanc. Ensuite, le programme appelle fg_mousevis pour rendre le curseur de la souris visible et appelle ensuite fg_mouselim pour restreindre le curseur de la souris sur une zone d'un quart de la taille de l'écran, centré au milieu de l'écran. À ce stade, vous devez déplacer le curseur de la souris sur l'écran pour voir l'effet de fg_mouselim et notez la vitesse à laquelle le curseur se déplace par rapport à la souris elle-même. Le programme se poursuit lorsque vous appuyez sur une touche.

Le programme utilise ensuite fg_mousemov pour déplacer le curseur de la souris à chaque coin
de la région établie par fg_mouselim. L'appel à fg_waitfor garde le curseur dans chaque coin pendant deux secondes, à moins que vous déplacez la souris. Notez comment le programme tente de déplacer le curseur de la souris à chaque coin de l'écran, mais puisque cela serait déplacer le curseur en dehors de la zone définie de mouvement, fg_mousemov positionne juste le curseur à l'endroit le plus proche possible dans cette région. Le dernier appel à fg_mousemov déplace le curseur vers le milieu de l'écran. Après avoir fait cela, le programme appelle fg_mousespd pour changer la vitesse du curseur de la souris. Les valeurs passées à fg_mousespd (16 et 32) sont deux fois les valeurs par défaut et permettent donc vous déplacez la souris deux fois plus loin avant de déplacer le curseur de la souris à la même distance. Lorsque vous exécutez le programme, comparer la sensibilité de la souris à la vitesse d'origine. Après une séquence de touches, le programme revient à DOS.

 Exemple 14-7.

 #include <fastgraf.h>
               #include <stdio.h>
               #include <stdlib.h>
              void main (void); 
                                      Chapitre 14: Entrée Device Support 313


 void main ()
               {
                 int maxx, maxy;
                 int old_mode;

 fg_initpm ();
                 fg_getmode old_mode = ();
                 fg_setmode (fg_automode ());

 if (fg_mouseini () <0) {
                    fg_setmode (old_mode);
                    fg_reset ();
                    sortie (1);
                     }

 maxx = fg_getmaxx ();
                 maxy = fg_getmaxy ();
                 fg_setcolor (15);
                 fg_rect (0, maxx, 0, maxy);

 fg_mousevis (1);
                 fg_mouselim (maxx / 4,3 * maxx / 4, maxy / 4,3 * maxy / 4);
                 fg_waitkey ();

 fg_mousemov (0,0);
                 fg_waitfor (36);
                 fg_mousemov (maxx, 0);
                 fg_waitfor (36);
                 fg_mousemov (maxx, maxy);
                 fg_waitfor (36);
                 fg_mousemov (0, maxy);
                 fg_waitfor (36);
                 fg_mousemov (maxx / 2, maxy / 2);
                 fg_mousespd (16,32);
                 fg_waitkey ();

 fg_setmode (old_mode);
                 fg_reset ();
               }


====Indication de l'état de la souris====

Il est évidemment important de pouvoir suivre la position de la souris et
état de la touche. Les Fastgraph routines fg_mousepos et fg_mousebut vous permettre de le faire.

Les informations fg_mousepos des retours de routine à propos de la souris actuelle
la position du curseur et de l'état du bouton. Il nécessite trois arguments entiers, tous passés par référence. Les deux premiers arguments reçoivent respectivement les coordonnées horizontales et verticales du curseur de la souris. Ces valeurs sont exprimées en unités d'espace d'écran pour les modes graphiques et des cellules de caractères pour les modes de texte. Le troisième argument reçoit un masque à trois bits contenant l'état du bouton comme indiqué ici: Guide de l'utilisateur 314 Fastgraph


 bit
                sens du nombre

 0 1 si le bouton gauche enfoncé, 0 sinon
                   1 1 si le bouton droit enfoncé, 0 sinon
                   2 1 si le bouton du milieu enfoncé, 0 sinon

Par exemple, si les deux boutons gauche et droit sont pressés, l'état du bouton sera réglé à 3. Si la souris n'a que deux boutons, le bit 2 sera toujours zéro.

Une autre routine fg_mousebut est disponible pour renvoyer le nombre de
appuyez sur le bouton ou de libérer les chiffres qui se sont produits depuis la dernière vérification, ou depuis l'appel fg_mouseini. Chaque bouton de la souris maintient ses propres compteurs séparés, revient donc fg_mousebut cette information pour une touche spécifique. En outre, fg_mousebut renvoie la position horizontale et verticale du curseur de la souris au moment où le bouton spécifié dernière pression ou libéré.

La routine fg_mousebut prend quatre arguments entiers, dont la dernière
trois sont passés par référence. La valeur absolue de premier argument spécifie le bouton d'intérêt (1 signifie le bouton gauche, 2 est le bouton droit, et 3 est le bouton du milieu), alors que sa valeur réelle détermine si nous vérifions des presses ou des rejets. Si la valeur est positive, appuyez sur le bouton chiffres seront communiqués. Si elle est négative, la libération chiffres seront communiqués. Les deuxième, troisième et quatrième arguments reçoivent respectivement la presse ou la libération compte, la position du curseur de la souris horizontale au moment de la dernière pression ou la libération, et la position verticale à la même époque. Si la presse ou la libération comptage est égal à zéro, la position du curseur de la souris est retourné comme (0,0). Les positions de coordonnées sont exprimées en unités d'espace d'écran pour les modes graphiques et des cellules de caractères pour les modes de texte.

Exemple 14-8 fonctionne dans un mode graphique vidéo, et illustre l'utilisation de
fg_mousepos et fg_mousebut. Le programme établit d'abord le mode vidéo et initialise la souris (le programme sort si l'initialisation échoue) puis. Il prochaine remplit tout l'écran avec un rectangle blanc puis appelle fg_mousevis pour rendre le curseur de la souris visible.

La partie principale de l'exemple 14-8 est une boucle while qui interroge la souris au
intervalles de trois secondes (l'appel fg_waitfor (54) retarde le programme pendant trois secondes). Dans la boucle, le programme fg_mousebut utilise d'abord pour obtenir le nombre de fois sur le bouton gauche de la souris a été pressé dans les trois dernières secondes. Par la suite, la routine fg_mousepos obtient la position courante de la souris. Le programme affiche ensuite ces informations dans le coin supérieur gauche de l'écran; noter comment fg_mousevis est utilisé pour faire le curseur invisible pendant les opérations graphiques. Le programme se poursuit jusqu'à ce que vous appuyez sur le bouton droit de la souris, vérifié par l'appel à fg_mousebut à la fin de la boucle.

 Exemple 14-8.

 #include <fastgraf.h>
          #include <stdio.h>
          #include <stdlib.h>
         void main (void);

 void main ()   

  {
            int old_mode;
            boutons int, count;
            int x, y;
            chaîne char [25];

 fg_initpm ();
            fg_getmode old_mode = ();
            fg_setmode (fg_automode ());

 if (fg_mouseini () <0) {
               fg_setmode (old_mode);
               fg_reset ();
               sortie (1);
                }

 fg_setcolor (15);
            fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());
            fg_mousevis (1);

 faire {
               fg_waitfor (54);
               fg_mousebut (1, & compter, et x, et y);
               fg_mousepos (& x, et y, et boutons);
               sprintf (string, "X =% 3d Y =% count 3d =% 4d", x, y, compter);
               fg_mousevis (0);
               fg_setcolor (15);
               fg_rect (0, fg_xconvert (25), 0, fg_yconvert (1));
               fg_setcolor (0);
               fg_locate (0,0);
               fg_text (string, 24);
               fg_mousevis (1);
               fg_mousebut (2, et compter, et x, et y);
                }
            tandis que (compter == 0);

 fg_setmode (old_mode);
            fg_reset ();
          }


====Définir le curseur de la souris====

Par défaut, le curseur de la souris est une petite flèche blanche dans les modes graphiques et
un rectangle d'un caractère en mode texte. Dans les modes graphiques, vous pouvez modifier le curseur de la souris sur une image 16 par 16 pixels avec la fg_mouseptr routine Fastgraph (en modes graphiques quatre couleurs les CGA, la taille du curseur est de 8 par 16 pixels). Vous ne pouvez pas changer la forme du curseur de la souris en mode texte, mais vous pouvez utiliser le fg_mousecur routine Fastgraph pour définir la façon dont il interagit avec des personnages existants sur l'écran. Guide de l'utilisateur 316 Fastgraph


====Modes de texte====

Pour changer le curseur de la souris en mode texte, vous devez d'abord définir deux 16-
des quantités de bits appelé le masque de l'écran et le masque de curseur. La figure suivante définit le format de chaque masque.

 les bits signifie

 valeur de caractère 0-7 ASCII
                   8 à 11 couleur de premier plan
                   12 à 14 couleur de fond
                   15 blink

Notez comment cette structure est parallèle à la nature et des octets d'attributs associé à chaque cellule de caractère. Le masque d'écran par défaut est 77FF hex, et le masque de curseur par défaut est 7700 hex.

Lorsque vous placez la souris sur une cellule de caractère spécifique, la souris
pilote utilise les masques d'écran et curseur pour déterminer l'apparence du curseur de la souris. Tout d'abord, le pilote de souris logiquement ANDS le masque de l'écran avec le contenu existant de cette cellule de caractère. Il a ensuite XORs résultant avec le masque de curseur pour afficher le curseur de la souris.

Par exemple, examiner comment le curseur de la souris est produit dans la colonne 80
mode texte de couleur (mode 3). Supposons qu'une cellule de caractère spécifique contient le caractère ASCII 0 (48 décimal, 30 hex) et un octet d'attribut qui spécifie un blanc (couleur 15) de premier plan sur un fond bleu (couleur 1) et ne clignote pas (bit clin 0). La structure binaire du caractère et son attribut sont:

 attribuer le caractère

 0 001 1111 00110000


Maintenant, nous allons voir ce qui se passe lorsque nous appliquons l'écran et de curseur masques pour le caractère et son attribut.


 attribut / caractère 0001 1111 0011 0000 (1F30 hex)
           écran de masque 0111 0111 1111 1111 (77FF hex) par défaut
                                  -------------------
           résultat de ET 0001 0111 0011 0000 (1730 hex)
           curseur de masque 0111 0111 0000 0000 (7700 hex) par défaut
                                  -------------------
           résultat de XOR 0110 0000 0011 0000 (6030 hex)


Le caractère résultant (30 hex) est le caractère original, mais le nouvel attribut (60 hex) représente un premier plan noir avec un fond brun et ne clignote pas. Tant que le curseur de la souris reste positionné sur cette cellule de caractère, il apparaît noir sur le brun.

Lorsque nous utilisons l'écran et de curseur par défaut des masques, le curseur de la souris
toujours afficher le caractère original et il ne clignote pas. La couleur de premier plan du curseur sera 15-F, où F est la couleur de premier plan du caractère affiché. De même, la couleur d'arrière-plan curseur sera 7-B, où B est la

La couleur de fond de caractère affiché. Les masques par défaut seront presque toujours produire un curseur de la souris satisfaisante.

Il est cependant possible de modifier l'aspect du curseur de la souris
modes de texte en utilisant vos propres masques d'écran et de curseur. La fg_mousecur routine Fastgraph fait justement cela. Il attend deux arguments, le premier étant le masque de curseur et le second masque de l'écran. Exemple 14-9 illustre l'utilisation de fg_mousecur. Le programme affiche un texte et utilise le curseur de la souris par défaut. Après avoir attendu pendant une séquence de touches, le programme appelle fg_mousecur pour définir un nouveau curseur de la souris. Le nouveau curseur est similaire au curseur par défaut, mais il affiche les couleurs de premier plan dans l'intensité opposé, comme le curseur par défaut. Le programme attend ensuite une autre touche avant de revenir à DOS.

 Exemple 14-9.

 #include <fastgraf.h>
                  #include <stdio.h>
                  #include <stdlib.h>
                 void main (void);

 void main ()
                  {
                    int old_mode;
                    int rangée;

 fg_initpm ();
                    fg_getmode old_mode = ();
                    fg_setmode (3);

 if (fg_mouseini () <0) {
                       fg_setmode (old_mode);
                       fg_reset ();
                       sortie (1);
                        }

 fg_setattr (7,0,0);
                    fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());

 fg_setattr (12,7,0);
                    pour (rang = 0; rangée <25; rangée ++) {
                       fg_locate (ligne, 34);
                       fg_text ( "exemple 14-9", 12);
                        }

 fg_mousevis (1);
                    fg_waitkey ();
                    fg_mousecur (0x7FFF, 0x7F00);
                    fg_waitkey ();

 fg_setmode (old_mode);
                    fg_reset ();
                 }   

====Modes graphiques====

Définir le curseur de la souris dans graphiques modes vidéo nécessite également création
un masque d'écran et le curseur masque, mais comme on pouvait s'y attendre, la structure de ces masques est très différent de modes de texte. En fait, il ressemble étroitement au format bitmap en mode indépendant utilisé par fg_drawmap. Bien que leur structure est différente, la façon dont le pilote de souris applique les masques sont les mêmes que dans les modes de texte. Autrement dit, le pilote affiche le curseur de la souris d'abord logiquement la mémoire ANDing vidéo avec le masque de l'écran, puis XORing qui résultent avec le masque de curseur.

Commençons par regarder les masques pour le curseur de la souris par défaut dans
les modes graphiques. La taille de chaque masque (et donc le curseur de la souris) est de 16 pixels de large et 16 pixels de haut. Comme mentionné précédemment, le curseur par défaut est une petite flèche blanche avec un contour noir autour d'elle. Voici ses masques d'écran et de curseur exprimés en valeurs binaires.

 curseur à l'écran curseur
              masque apparence de masque

        1001111111111111 0000000000000000 **
        1000111111111111 0010000000000000 * x *
        1000011111111111 0011000000000000 * xx *
        1000001111111111 0011100000000000 * xxx *
        1000000111111111 0011110000000000 * xxxx *
        1000000011111111 0011111000000000 * xxxxx *
        1000000001111111 0011111100000000 * xxxxxx *
        1000000000111111 0011111110000000 * xxxxxxx *
        1000000000011111 0011111111000000 * xxxxxxxx *
        1000000000001111 0011111000000000 * xxxxx *****
        1000000011111111 0011011000000000 * xx xx * *
        1000100001111111 0010001100000000 * x * xx *
        1001100001111111 0000001100000000 ** * * xx
        1111110000111111 0000000110000000 * xx *
        1111110000111111 0000000110000000 * xx *
        1111111000111111 0000000000000000 ***

Le pilote de souris premier ANDS le masque de l'écran avec la mémoire vidéo à la
position du curseur souris. Cela signifie que le masque d'écran 1 bits laissent mémoire vidéo intacte, tandis que les bits 0 changent les pixels correspondant au noir. Ensuite, le pilote de souris le résultat XOR avec le masque de curseur. Cette fois le curseur masque bits 0 quittent la mémoire vidéo inchangée, tandis que les 1 bits changent les pixels correspondants au blanc. Cela produit un curseur de la souris comme indiqué ci-dessus à droite, où un point () représente un pixel inchangé, un astérisque (*) un pixel noir et un pixel blanc xa. Le tableau suivant résume l'apparence du curseur pour toutes les combinaisons possibles de bits de masque.

 bit de masque écran masque bit de curseur résultant curseur pixel

 0 0 noir
                   0 1 blanc
                   1 0 inchangé
                   1 1 inversé

La couleur d'un pixel «inversé» est nk, où n est la couleur maximale
numéro dans le mode vidéo en cours, et k est la couleur du pixel
remplacé.En outre, "noir" et pixels "blancs" ne sont pas nécessairement ces couleurs dans les modes 16 couleurs et 256 couleurs. Plus exactement, "noir" pixels sont affichés dans la couleur attribuée à la palette 0 et pixels "blancs" sont les affichés dans la couleur attribuée à la palette 15 (255 en XVGA et SVGA 256 couleurs modes). Si vous utilisez les modes de couleur CGA, "noir" pixels sont affichés dans la couleur de fond, et "blancs" pixels apparaissent en couleur 3 (dont la couleur réelle est déterminée par la palette CGA sélectionnée).

Avec une compréhension de la façon dont le curseur de la souris par défaut fonctionne dans
modes graphiques, nous sommes maintenant prêts à définir notre propre curseur de la souris. On voit ici le masque de l'écran, le masque de curseur, et l'aspect résultant pour un curseur en forme de plus-solide. Les équivalents hexadécimaux des valeurs de masque binaires sont également donnés.

 ----- Masque écran ---- ----- masque de curseur ----
                                                                le curseur
       hex binaire apparence hexadécimal binaire

 1110000000111111 0000000000000000 E03F 0000 ... ******* ......
  1110000000111111 0000111110000000 E03F 0F80 ... * xxxxx * ......
  1110000000111111 0000111110000000 E03F 0F80 ... * xxxxx * ......
  0000000000000111 0000111110000000 0007 0F80 **** **** xxxxx ...
  0000000000000111 0111111111110000 0007 7FF0 * xxxxxxxxxxx * ...
  0000000000000111 0111111111110000 0007 7FF0 * xxxxxxxxxxx * ...
  0000000000000111 0111111111110000 0007 7FF0 * xxxxxxxxxxx * ...
  0000000000000111 0111111111110000 0007 7FF0 * xxxxxxxxxxx * ...
  0000000000000111 0111111111110000 0007 7FF0 * xxxxxxxxxxx * ...
  0000000000000111 0000111110000000 0007 0F80 **** **** xxxxx ...
  1110000000111111 0000111110000000 E03F 0F80 ... * xxxxx * ......
  1110000000111111 0000111110000000 E03F 0F80 ... * xxxxx * ......
  1110000000111111 0000000000000000 E03F 0000 ... ******* ......
  1111111111111111 0000000000000000 FFFF 0000 ................
  1111111111111111 0000000000000000 FFFF 0000 ................
  1111111111111111 0000000000000000 FFFF 0000 ................

Si nous voulions faire le curseur de la souris creuse plutôt que solide, les masques et l'apparence du curseur résultant serait ressembler à ceci.

 ----- Masque écran ---- ----- masque de curseur ----
                                                                le curseur
       hex binaire apparence hexadécimal binaire

 1110000000111111 0000000000000000 E03F 0000 ... ******* ......
  1110111110111111 0000000000000000 EFBF 0000 ... * ..... * ......
  1110111110111111 0000000000000000 EFBF 0000 ... * ..... * ......
  0000111110000111 0000000000000000 0F87 0000 **** ..... **** ...
  0111111111110111 0000000000000000 7FF7 0000 * ........... * ...
  0111111111110111 0000000000000000 7FF7 0000 * ........... * ...
  0111111111110111 0000001000000000 7FF7 0200 * ..... x ..... * ...
  0111111111110111 0000000000000000 7FF7 0000 * ........... * ...
  0111111111110111 0000000000000000 7FF7 0000 * ........... * ...
  0000111110000111 0000000000000000 0F87 0000 **** ..... **** ...
  1110111110111111 0000000000000000 EFBF 0000 ... * ..... * ......
  1110111110111111 0000000000000000 EFBF 0000 ... * ..... * ......
  1110000000111111 0000000000000000 E03F 0000 ... ******* ......
  1111111111111111 0000000000000000 FFFF 0000 ................
  1111111111111111 0000000000000000 FFFF 0000 ................
  1111111111111111 0000000000000000 FFFF 0000 ................   

Guide de l'utilisateur 320 Fastgraph


A noter que le bit central défini dans le masque de curseur provoque le pixel correspondant dans la mémoire vidéo qui doit être inversée.

Il y a un élément plus nécessaire pour définir un curseur de la souris en mode graphique
complètement.Ce point est le point chaud, ou la position réelle de l'écran utilisé ou rapporté par le pilote de la souris. Pour les curseurs en forme de plus-juste construit, il serait logique de définir le point chaud dans le centre de la plus. Le point chaud est spécifié par rapport au coin supérieur gauche du curseur, de sorte que sa position dans le curseur serait (6,6) - qui est, six pixels à droite et six pixels en dessous du coin supérieur gauche. Vous pouvez spécifier les décalages de points chauds en utilisant des valeurs ou des valeurs négatives au-dessus de 15 pour le positionner en dehors de la matrice du curseur de la souris si vous le souhaitez.

La fg_mouseptr routine Fastgraph définit un curseur de la souris dans les graphiques
modes. Le premier de ses trois arguments est un 32 élément 16 bits entier tableau, passé par référence. 16 premiers éléments du tableau contiennent le masque d'écran, et ses deuxièmes 16 éléments contiennent le masque de curseur. Les deux arguments restants précisent respectivement les décalages horizontaux et verticaux pour le point chaud. La routine de fg_mouseptr n'a aucun effet en mode texte vidéo. Dans les programmes C ou C ++, nous vous recommandons d'utiliser le type de données à court pour le tableau de masque parce court signifie un entier de 16 bits pour les environnements 16 bits et 32 ??bits. De même, les programmeurs FORTRAN devraient définir la matrice de masque comme un ENTIER * 2 article.

Exemple 14-10 est similaire à l'exemple 14-9. Il montre comment définir un
curseur de la souris en mode graphique en utilisant fg_mouseptr. Les valeurs stockées dans les tableaux pleins et creux définissent l'écran et de curseur masques pour les curseurs de souris en forme de plus-pleins et creux discuté plus tôt. Après avoir fait le curseur de la souris visible, le programme utilise le curseur de la souris par défaut jusqu'à ce qu'une touche est enfoncée. À la suite de cela, il se transforme en curseur solide. Après une autre touche, le programme se transforme en curseur creux. Lorsque vous exécutez exemple 14-10, comparer les différences entre les trois curseurs de souris.

 Exemple 14-10.

 #include <fastgraf.h>
                #include <stdio.h>
                #include <stdlib.h>
               void main (void);

 court solide [] = {0xE03F, 0xE03F, 0xE03F, 0x0007,
                                 0x0007,0x0007,0x0007,0x0007,
                                 0x0007,0x0007,0xE03F, 0xE03F,
                                 0xE03F, 0xFFFF, 0xFFFF, 0xFFFF,
                                 0x0000,0x0F80,0x0F80,0x0F80,
                                 0x7FF0,0x7FF0,0x7FF0,0x7FF0,
                                 0x7FF0,0x0F80,0x0F80,0x0F80,
                                 0x0000,0x0000,0x0000,0x0000};

 court creux [] = {0xE03F, 0xEFBF, 0xEFBF, 0x0F87,
                                 0x7FF7,0x7FF7,0x7FF7,0x7FF7,
                                 0x7FF7,0x0F87,0xEFBF, 0xEFBF,
                                 0xE03F, 0xFFFF, 0xFFFF, 0xFFFF,
                                 0x0000,0x0000,0x0000,0x0000,   
                                      Chapitre 14: Entrée Device Support 321


 0x0000,0x0000,0x0200,0x0000,
                                 0x0000,0x0000,0x0000,0x0000,
                                 0x0000,0x0000,0x0000,0x0000};

 void main ()
                {
                  int old_mode;
                  int colonne, ligne, LAST_ROW;

 fg_initpm ();
                  fg_getmode old_mode = ();
                  fg_setmode (fg_automode ());

 if (fg_mouseini () <0)
                   {
                     fg_setmode (old_mode);
                     fg_reset ();
                     sortie (1);
                   }

 fg_setcolor (15);
                  fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());

 fg_setcolor (12);
                  colonne = fg_xalpha (fg_getmaxx () / 2) - 6;
                  LAST_ROW = fg_yalpha (fg_getmaxy ()) + 1;

 pour (rang = 0; ligne <LAST_ROW; rangée ++)
                   {
                     fg_locate (ligne, colonne);
                     fg_text ( "exemple 14-10", 13);
                   }

 fg_mousevis (1);
                  fg_waitkey ();
                  fg_mouseptr (solide, 6,6);
                  fg_waitkey ();
                  fg_mouseptr (creux, 6,6);
                  fg_waitkey ();

 fg_setmode (old_mode);
                  fg_reset ();
                }


====Considérations CGA====

Le pilote de souris traite l'écran et curseur masques différemment dans le
CGA modes graphiques en quatre couleurs (modes 4 et 5) que dans les autres modes graphiques. Dans les modes CGA, chaque paire de bits de masque correspondant à un pixel. Cela signifie que les masques ressemblent plus étroitement à la forme spécifique du mode utilisé par fg_drwimage au lieu du format de mode indépendant de fg_drawmap.

Fastgraph utilise un curseur différent de la souris par défaut pour les modes 4 et 5. Son
écran et curseur masques, ainsi que l'apparence du curseur résultant, sont présentés dans le schéma suivant. Guide de l'utilisateur 322 Fastgraph


 curseur à l'écran curseur
                masque apparence de masque

 0000111111111111 0000000000000000 **
          0000001111111111 0011000000000000 ***
          0000000011111111 0011110000000000 ****
          0000000000111111 0011111100000000 *****
          0000000000001111 0011111111000000 ******
          0000000000000011 0011111111110000 *******
          0000000000000011 0011111100000000 *******
          0000000000111111 0011111110000000 *****
          0000000000001111 0011000011000000 ******
          0000110000001111 0000000011000000 ** ***
          1111111100000011 0000000000110000 ***
          1111111100000011 0010000000110000 ***
          1111111111000011 0000000000000000 **
          1111111111111111 0000000000000000
          1111111111111111 0000000000000000
          1111111111111111 0000000000000000

Comme vous pouvez le voir, le curseur de la souris résultante est huit pixels de large au lieu de 16.

Un autre point important concernant les curseurs de souris dans les modes 4 et 5 est le
risque de saignement du pixel, ou la modification des couleurs à l'intérieur du curseur de la souris lorsqu'elle se déplace horizontalement. Le saignement se produit si vous utilisez les paires de bits 01 ou 10 dans les deux masque pour représenter un pixel. Dans les masques par défaut pour les modes 4 et 5, notez que seules les valeurs binaires 00 et 11 apparaissent sous forme de paires de bits. Gardez cela à l'esprit si vous créez vos propres masques dans ces modes vidéo.

====XVGA et SVGA Considérations====

Dans les modes graphiques XVGA et modes 256 couleurs SVGA graphiques (20 à 27), il est
possible de créer un curseur de souris multicolores. Pour ce faire, utilisez fg_mouse256 au lieu de fg_mouseptr pour définir la forme et l'apparence du curseur de la souris. La routine fg_mouse256 utilise les mêmes arguments que fg_mouseptr, mais les masques sont passés dans un tableau de 512 octets constitué d'un masque d'écran de 256 octets suivi d'un masque de curseur 256 octets. Comme dans le cas fg_mouseptr, chaque masque est structurée comme une grille de 16x16 pixels, mais chaque pixel est représenté par une valeur d'octet plutôt que d'un seul bit.

Le pilote de la souris affiche le curseur de la souris par opération logique vidéo
mémoire avec le masque de l'écran, puis XORing qui résultent avec le masque de curseur. Cela signifie normalement les valeurs de masque d'écran sont soit 0 ou 255, tandis que les valeurs de masque de curseur se situent entre 0 et 255. Par exemple, examiner de nouveau la graphique par défaut mode curseur de la souris (la flèche). Si nous voulions afficher le curseur en jaune (couleur 14) à la place de son blanc par défaut, vous développez le masque d'écran de 16 à 256 octets, en remplaçant les bits à zéro dans le masque "standard" avec zéro octets et en remplaçant les bits un avec la valeur 255. Vous de même élargir le masque du curseur, en remplaçant les bits zéro avec zéro octets et les bits à la valeur 14.


===Joystick support===

Le troisième type de dispositif d'entrée pris en charge par Fastgraph est le joystick.

Bien que les joysticks sont pas aussi populaires que les souris, ils sont souvent préférables lorsque les réactions d'un utilisateur sont critiques, comme dans un jeu de style arcade. Fastgraph comprend des routines pour l'initialisation d'un joystick, la lecture la position ou le bouton du statut d'un joystick, et en faisant un joystick se comportent de manière analogue au clavier. Ces routines sont indépendantes du reste de Fastgraph et ne nécessitent donc pas que vous premier appel fg_setmode.

Manettes de jeu sont connectés à un système par l'intermédiaire d'un port de jeu. Le PCjr et

Tandy 1000 systèmes sont équipés de deux ports de jeu, et donc soutenir deux joysticks. Sur les autres systèmes de la famille IBM, vous pouvez installer une carte de jeu avec un ou deux ports de jeu. Si la carte ne comporte qu'un seul port de jeu, vous pouvez utiliser un câble séparateur à débourser deux joysticks dans le port.


====Initialisation Joysticks====

Avant de pouvoir utiliser l'une des routines de support de manette de Fastgraph avec un
joystick spécifique, vous devez initialiser ce joystick. La routine de fg_initjoy exécute cette tâche. Cette routine nécessite un seul argument entier qui spécifie le joystick pour initialiser, soit 1 ou 2. En cas de succès, fg_initjoy retourne 0 comme valeur de la fonction. Si la machine n'a pas de port de jeu, ou si le joystick demandé ne soit pas connecté au port de jeu, fg_initjoy renvoie -1. Lorsque vous utilisez fg_initjoy, le joystick en cours d'initialisation doit être centrée (qui est, le bâton lui-même doit pas être incliné dans les deux sens).

Exemple 14-11 utilise la routine de fg_initjoy pour essayer d'initialiser à la fois
joysticks. Pour chaque manette, le programme imprime un message indiquant si oui ou non l'initialisation a réussi.

 Exemple 14-11.

 #include <fastgraf.h>
                 #include <stdio.h>
                void main (void);

 void main ()
                 {
                   fg_initpm ();
                   if (fg_initjoy (1) <0)
                      printf ( "Joystick 1 pas disponible \ n de.");
                    autre
                      printf ( "Joystick 1 trouvé \ n de.");

 if (fg_initjoy (2) <0)
                      printf ( "Joystick 2 pas disponible \ n de.");
                    autre
                      printf ( "Joystick 2 trouvé \ n de.");
                }   

Guide de l'utilisateur 324 Fastgraph


====Rapports Joystick Status====

Chaque joystick peut signaler trois éléments: sa position horizontale, son
position verticale, et l'état du bouton. Fastgraph comprend des routines pour obtenir chacune de ces quantités.

Les fg_getxjoy et fg_getyjoy routines renvoient respectivement à l'horizontale
et la position verticale du levier de commande indiqué. Les deux routines nécessitent un seul argument entier, dont la valeur est 1 ou 2, pour identifier le joystick. La position demandée est renvoyée comme valeur de la fonction. Les coordonnées horizontales augmentent à mesure que la manette est déplacé vers la droite, tandis que les coordonnées verticales augmentent à mesure que la manette se déplace vers le bas. Si fg_initjoy n'a pas été initialisé le joystick spécifié, ou si votre programme n'a pas encore appelé fg_initjoy, tant fg_getxjoy et fg_getyjoy retournera -1.

Caractéristiques Joystick varient plus que ceux de tout autre dispositif d'entrée.

Les valeurs renvoyées par fg_getxjoy et fg_getyjoy dépendent de la vitesse du processeur du système et la marque du joystick utilisé. Il suffit souvent de connaître la position par rapport à sa position précédente du joystick, auquel cas la réelle valeurs de coordonnées ne comptent pas. Toutefois, si vous devez compter sur spécifique des valeurs de coordonnées, votre programme doit effectuer un certain type de calibrage manuel du joystick, puis escalader les coordonnées déclarées par fg_getxjoy et fg_getyjoy au besoin.

L'autre élément d'information joysticks fournissent est l'état du bouton.

La plupart des joysticks ont deux boutons, appelés les boutons du haut et du bas. D'autres ont trois boutons, mais l'un d'eux duplique la fonctionnalité d'un autre (par exemple, un joystick peut avoir un bouton en bas sur le côté gauche et une autre sur le côté droit). La fg_button routine Fastgraph renvoie le joystick statut de bouton comme sa valeur de fonction. Comme fg_getxjoy et fg_getyjoy, fg_button nécessite un seul argument qui spécifie le numéro de joystick. La signification de la valeur de retour est montré ici:

 sens de la valeur

 0 ne touche enfoncée
                             1 bouton supérieur enfoncé
                             2 bouton du bas pressé
                             3 boutons haut et bas pressé

 Vous ne devez appeler fg_initjoy avant d'utiliser fg_button.  Si la

joystick spécifié est absent, fg_button retourne une valeur de 0.

 Exemple 14-12 utilise fg_getxjoy, fg_getyjoy et fg_button pour interroger à la fois

joysticks à intervalles d'une demi-seconde. Il affiche ensuite le numéro de joystick (1 ou 2), la position horizontale, la position verticale, et l'état de bouton pour chaque manette. Comme le programme fonctionne, vous pouvez déplacer les joysticks et regarder la façon dont les mouvements affectent l'affichage des valeurs de coordonnées. Le programme continue ainsi jusqu'à ce que vous appuyez sur Ctrl / C ou Ctrl / Pause pour l'arrêter.

 Exemple 14-12.

 #include <fastgraf.h>
                  #include <stdio.h>
                 void main (void); 
                                      Chapitre 14: Entrée Device Support 325


 void main ()
                  {
                    int b, x, y;

 fg_initpm ();
                    fg_initjoy (1);
                    fg_initjoy (2);

 while (1) {
                       x = fg_getxjoy (1);
                       y = fg_getyjoy (1);
                       b = fg_button (1);
                       printf ( "1:% 3d% 3d% 1d \ n", x, y, b);
                       x = fg_getxjoy (2);
                       y = fg_getyjoy (2);
                       b = fg_button (2);
                       printf ( "2:% 3d% 3d% 1d \ n \ n", x, y, b);
                       fg_waitfor (9);
                        }
                  }


 Il y a deux façons de surveiller efficacement l'état de bouton du joystick.  Un

est d'appeler fg_button à de nombreux endroits dans votre programme, puis prendre les mesures nécessaires en fonction de l'état du bouton. Cependant, la méthode préférée est d'étendre le BIOS d'interruption du temps de la journée pour vérifier l'état du bouton à chaque coup d'horloge (il y a 18,2 horloge par seconde), définir un indicateur si un bouton est enfoncé, puis vérifier le drapeau comme nécessaire dans votre programme. Informations sur la modification du BIOS interruption de temps de jour figure à l'Annexe C.


====Keyboard Emulation====

Bien que nous puissions utiliser fg_getxjoy et fg_getyjoy pour surveiller par rapport
les mouvements de la manette, il est généralement plus facile de le faire avec une autre routine Fastgraph, fg_intjoy. Cette routine est similaire à fg_intkey en ce qu'il renvoie deux valeurs équivalentes aux codes de clavier standard ou étendues pour des frappes analogues.

La routine de fg_intjoy a besoin de trois arguments. Le premier argument spécifie
le numéro de joystick, 1 ou 2. Les deuxième et troisième arguments, les deux quantités d'octets ONe passés par référence, reçoivent les codes de clavier standard et étendu analogues au mouvement de la manette et l'état de bouton. Le second argument reçoit une valeur de 13 (le code de clavier standard pour la touche Entrée) si un bouton de la manette est enfoncée; il reçoit une valeur de 0 sinon. Le troisième argument reçoit une valeur correspondant au code de clavier étendu pour l'une des touches directionnelles du clavier numérique, tel que résumé dans le tableau suivant.

 position de joystick clé étendue code clé correspondant

 et quitté la maison 71
                  up up flèche 72
             haut et à droite PgUp 73
                 gauche flèche gauche 75   


 centrée (aucune action) 0
                 droite droite du 77
             vers le bas et 79 Fin gauche
                 flèche vers le bas vers le bas 80
            vers le bas et à droite PgDn 81

La routine fg_intjoy établira deux arguments clés de code à zéro si le joystick spécifié n'a pas encore été initialisé.

Exemple 14-13 est similaire à l'exemple 14-11, mais il utilise fg_intjoy en place
de fg_getxjoy et fg_getyjoy signaler la position relative du joystick. Ce programme ne signale pas l'état du bouton du joystick comme exemple 14-11 fait, mais vous pouvez facilement ajouter cette fonctionnalité à elle.

 Exemple 14-13.

 #include <fastgraf.h>
                    #include <stdio.h>
                   void main (void);

 void main ()
                    {
                      clé char, aux;

 fg_initpm ();
                      fg_initjoy (1);
                      fg_initjoy (2);

 while (1) {
                         fg_intjoy (1, touche &, & aux);
                         printf ( "1:% 2d% 2d \ n", clé, aux);
                         fg_intjoy (2, touche &, & aux);
                         printf ( "2:% 2d% 2d \ n \ n", clé, aux);
                         fg_waitfor (9);
                          }
                    }


====Considérations Joystick spéciales====

Si vous développez un programme qui prend en charge un seul joystick, vous devez utiliser
joystick 1. Les raisons sont de deux ordres. Tout d'abord, il fera de votre programme compatible avec la plupart des autres produits qui prennent en charge les joysticks. Deuxièmement, de nombreux Tandy 1000 machines de série ne peuvent pas déterminer si joystick 2 est présent lorsque ni joystick est connecté. Cela signifie que si vous utilisez joystick 2 à la place de la manette 1 dans un programme de joystick unique, vous ne serez pas en mesure de dire si un joystick est disponible lors de l'exécution sur un Tandy 1000.


===Résumé des Routines d'entrée===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.


FG_BUTTON renvoie des informations sur l'état de l'une manette de
boutons.

FG_CAPSLOCK détermine l'état de la touche CapsLock.

FG_GETKEY attend une touche (ou lit l'entrée suivante à partir du BIOS
mémoire tampon du clavier). Il renvoie le code de clavier standard ou étendu de la frappe.

FG_GETXJOY et FG_GETYJOY reviennent à l'horizontale et verticale de coordonnées
position du joystick spécifié. Les coordonnées réelles dépendent de la vitesse du processeur et la marque de joystick utilisé.

FG_INITJOY initialise joystick 1 ou 2 et doit être appelé avant d'utiliser
fg_getxjoy, fg_getyjoy ou fg_intjoy. Elle renvoie un code d'état indiquant si oui ou non l'initialisation a réussi.

FG_INTJOY renvoie les codes de clavier standard et étendue analogue à
la position et le bouton état actuel du joystick spécifié.

FG_INTKEY lit la prochaine entrée de la mémoire tampon et retourne clavier BIOS
code de clavier standard ou étendu de la frappe. Il est semblable à fg_getkey, mais il ne pas attendre une touche si la mémoire tampon du clavier est vide.

FG_KBINIT active ou désactive le gestionnaire de clavier de bas niveau de Fastgraph.  Si
le gestionnaire de clavier est déjà dans l'État requis, rien ne se passe.

FG_KBLAST renvoie le code de balayage pour le plus récent traité par keypress
Le gestionnaire de clavier de bas niveau de Fastgraph.

FG_KBRESET réinitialise l'état du gestionnaire de clavier de bas niveau de Fastgraph à
ce qu'il était après avoir été activé avec fg_kbinit.

FG_KBTEST détermine si la clé ayant le code de balayage spécifiée est maintenant
enfoncée ou relâchée. Le gestionnaire de clavier de bas niveau doit être activé pour que cette routine fonctionne correctement.

FG_MOUSE256 définit la forme et l'apparence d'une souris multicolore
curseur en mode SVGA graphiques XVGA et 256 couleurs.

FG_MOUSEBUT renvoie des informations sur le bouton de la souris ou de la libération de presse
compte, ainsi que la position du curseur de la souris au moment de la dernière pression sur un bouton ou de la libération.

FG_MOUSECUR définit l'apparence du curseur de la souris dans le texte vidéo
modes.

FG_MOUSEFIN dégrafe XVGA ou SVGA le gestionnaire de la souris de Fastgraph de la souris
chauffeur.Cette routine doit être utilisé juste avant de revenir au mode texte dans les programmes qui ont appelé fg_mouseini dans les modes graphiques XVGA ou SVGA. Il n'a pas d'effet dans d'autres modes vidéo.

FG_MOUSEINI initialise la souris et doit être appelée avant tout de
d'autres routines de support de la souris de Fastgraph. Elle retourne un état d'erreur si le Guide de l'utilisateur 328 Fastgraph
pilote de souris n'a pas été chargé, si la souris est pas connecté, ou si un tampon virtuel est actif.

FG_MOUSELIM définit la zone rectangulaire dans laquelle le curseur de la souris peut
Déplacer.

FG_MOUSEMOV déplace le curseur de la souris sur la cellule de caractère spécifié (en
modes de texte) ou la position de l'espace de l'écran (en mode graphique).

FG_MOUSEPOS renvoie la position actuelle de la souris et l'état de bouton.

FG_MOUSEPTR définit la forme et l'apparence du curseur de la souris dans
graphiques modes vidéo.

FG_MOUSESPD définit le nombre d'unités mickey par huit pixels du curseur
mouvement. Ce contrôle efficacement la vitesse à laquelle le curseur se déplace par rapport au déplacement de la souris elle-même.

FG_MOUSEVIS rend le curseur de la souris visible ou invisible.

FG_NUMLOCK détermine l'état de la touche Verr Num.

FG_SCRLOCK détermine l'état de la clé ScrollLock (qui ne sont pas
présent sur certains claviers).

FG_SETCAPS contrôle l'état de la clé de CapsLock.

FG_SETNUM contrôle l'état de la touche Verr Num.

FG_WAITKEY vide la mémoire tampon du clavier du BIOS (qui est, supprime toute type-
avance caractères) et attend une autre touche.


==Effets sonores==

Dans le domaine de l'IBM PC et PS / 2 famille de systèmes, un son est défini
par sa fréquence, la durée et le volume. La fréquence d'un son est mesurée en unités appelées Hertz. Alors que le PC et PS / 2 peuvent produire des sons allant de 18 à plus d'un million Hertz, l'humain moyen peut entendre des sons entre 20 et 20.000 Hertz. La longueur d'un son, appelé sa durée, est exprimée en tops d'horloge; il y a soit 18,2 de 72,8 horloge par seconde, selon la méthode utilisée pour produire le son. Enfin, le volume détermine l'intensité sonore du son. Comme nous le verrons dans ce chapitre, nous pouvons contrôler le volume d'un son uniquement sur le PCjr et Tandy 1000 systèmes.

Fastgraph propose plusieurs méthodes différentes pour produire des effets sonores.

Ceux-ci incluent des tonalités simples, une série de tonalités exprimée numériquement, ou une série de tonalités exprimées sous forme de notes musicales. Les effets sonores peuvent être discrètes, continue ou effectuée en même temps que d'autres activités. Les routines liées au son sont indépendants des autres parties du Fastgraph et ne nécessitent pas de routines d'initialisation être appelés.


===Sources sonores===

Tous les membres du PC et PS / 2 familles peuvent produire des sons à l'aide du
8253-5 puce minuterie programmable et le haut-parleur interne. Cette méthode est limitée à produire des sons uniques de fréquences et durées données, même si nous pouvons combiner ces sons pour créer des effets audio intéressants ou jouer de la musique. Lorsque nous utilisons cette technique, nous avons aucun contrôle sur le volume sonore. En fait, les volumes sonores varient souvent légèrement sur des systèmes différents parce que les propriétés physiques du haut-parleur et son logement ne sont pas toujours les mêmes.

Les PCjr et Tandy 1000 systèmes ont une puce supplémentaire, plus puissant
pour produire des sons. Ceci est la puce sonore Texas Instruments SN76496A, appelé la puce sonore TI pour faire court. La puce sonore TI dispose de trois canaux vocaux indépendants pour produire des sons purs, et un quatrième canal pour générer du bruit périodique ou blanc. Chaque canal vocal a un contrôle de volume séparé qui nous permet de contrôler le volume du son qu'il émet.


===synchrone son===

Un effet sonore est dit synchrone si elle est produite alors qu'aucun autre
l'activité est en cours. En d'autres termes, un programme émet un son synchrone en démarrant le son, l'attente pendant une durée déterminée, puis arrêter le son. Le programme doit attendre le son pour terminer avant de faire quoi que ce soit d'autre. Tant que la durée est relativement courte, du fait que le son est synchrone a peu ou pas d'effet sur la vitesse d'exécution du programme. Fastgraph comprend des routines pour la production de son synchrone en utilisant soit le 8253-5 minuterie programmable ou la puce sonore TI.

La routine fg_sound utilise la minuterie programmable pour produire un son d'une
compte tenu de la fréquence et la durée. La fréquence, définie par le premier argument, est exprimée en Hertz et doit être un entier compris entre 18 et 32.767. Le deuxième argument définit la durée et est exprimée en ticks d'horloge; Là
sont 18,2 horloge par seconde. Si la durée est nulle ou négative, le son continuera jusqu'à ce qu'il soit arrêté avec fg_quiet.

Exemple 15-1 utilise fg_sound pour créer différents effets sonores, une pause pour
une seconde entre chaque. Il se produit d'abord trois sons distincts de 20, 100 et 1000 Hertz. Chacun de ces sons dure environ 1/6 d'une seconde (trois coups d'horloge). Le programme fait alors un bruit gazouillant en alternant rapidement des sons de fréquences similaires. Enfin, le programme crée un ton glissement de fréquences croissantes entre 100 et 500 Hertz. Chaque tonalité dans cette séquence dure deux tops d'horloge, donc il faut environ 4,5 secondes pour jouer toute la séquence. Dans tous les cas, l'exemple 15-1 affiche un message identifiant juste avant chaque son.

 Exemple 15-1.

 #include <fastgraf.h>
              #include <stdio.h>
             void main (void);

 void main ()
              {
                int freq;

 fg_initpm ();
                printf ( "20 Hz ton ... \ n");
                fg_sound (20.3);
                fg_waitfor (18);

 printf ( "100 Hz ton ... \ n");
                fg_sound (100,3);
                fg_waitfor (18);

 printf ( "1000 Hz ton ... \ n");
                fg_sound (1000,3);
                fg_waitfor (18);

 printf ( "ramage ... \ n");
                fg_sound (400,1);
                fg_sound (410,1);
                fg_sound (400,1);
                fg_sound (410,1);
                fg_waitfor (18);

 printf ( "tonalité de glissement 100-500 Hz ... \ n");
                pour (freq = 100; freq <= 500; freq + = 10)
                   fg_sound (fréq, 2);
              }


La routine de fg_voice est analogue à fg_sound, mais il utilise le son TI
puce plutôt que la minuterie programmable pour créer des sons. Pour cette raison, fg_voice ne peut être utilisé sur le PCjr ou 1000 Tandy systèmes. La puce sonore TI nous permet de contrôler le volume d'un son, et il offre également quatre canaux vocaux distincts. Ainsi, fg_voice nécessite deux arguments supplémentaires en dehors de la fréquence et de durée afin de définir le canal vocal et le volume sonore. Guide de l'utilisateur 332 Fastgraph


 Le premier argument de fg_voice définit le canal vocal, comme indiqué ici:

 sens de la valeur

 1 voix canal # 1
                             2 voix canal # 2
                             3 voix canal # 3
                             4 voix canal n ° 4, le bruit périodique
                             5 voix canal # 4, bruit blanc

Si l'on utilise des canaux vocaux 1, 2 ou 3, le second argument définit la fréquence acoustique en Hertz, entre 18 et 32.767. Si nous utilisons un canal vocal 4, cependant, le second argument est plutôt une valeur qui représente une fréquence spécifique, comme indiqué dans ce tableau:

 La valeur de la fréquence

 0 512 Hertz
                                    1 1024 Hertz
                                    2 2048 Hertz

Le troisième argument définit le volume sonore. Il doit être compris entre 0 et 15, où 0 est silencieux et 15 est le plus fort. Le quatrième argument définit la durée de son horloge ticks. Comme fg_sound, il y a 18,2 horloge par seconde, et si la durée est nulle ou négative, le son continuera jusqu'à l'arrêt avec fg_quiet.

Exemple 15-2 utilise fg_voice pour créer différents effets sonores en utilisant la TI
puce sonore. Comme dans l'exemple 15-1, on fait une pause d'une seconde entre chaque. Les appels de programme premier fg_testmode pour être sûr qu'il est en cours d'exécution sur un PCjr ou Tandy 1000 système (mode vidéo 9 est disponible uniquement sur ces systèmes). Si oui, le programme utilise la voix canal # 4 pour produire un bruit périodique 2048 Hertz, suivie par un bruit blanc de la même fréquence. Les deux sons sont émis au niveau de volume maximum (15) et durent environ 1/6 d'une seconde chacune (trois coups d'horloge). Après ces bruits, par exemple 15-2 produit un son 500 Hertz du volume croissant. Dans tous les cas, le programme affiche un message identifiant juste avant chaque son.

 Exemple 15-2.

 #include <fastgraf.h>
              #include <stdio.h>
              #include <stdlib.h>
             void main (void);

 void main ()
              {
                le volume int;

 fg_initpm ();
                if (fg_testmode (9,0) == 0) {
                   printf ( "Ce programme nécessite une PCjr ou");
                   printf ( "un système Tandy 1000 \ n.");
                    sortie (1);
                   }   
                                             Chapitre 15: Effets sonores 333


 printf ( "2048 Hz bruit périodique ... \ n");
                fg_voice (4,2,15,3);
                fg_waitfor (18);

 printf ( "2048 Hz bruit blanc ... \ n");
                fg_voice (5,2,15,3);
                fg_waitfor (18);

 printf ( "500 Hz ton de volume croissant ... \ n");
                pour (volume = 1; volume <= 15, le volume ++) {
                   fg_voice (1500, volume, 0);
                   fg_waitfor (4);
                    }

 fg_quiet ();
              }


Notez comment exemple 15-2 utilise une durée de zéro (son continu) et
fg_waitfor pour spécifier la durée pour chaque niveau de volume de la séquence de tonalités 500 Hertz. Cela provoque la transition entre les changements de volume au mieux se fondre les uns avec les autres. La routine de fg_quiet, qui arrête son continu a commencé avec fg_sound ou fg_voice, termine le son après le niveau de volume final.

Les deux fg_sound et fg_voice produisent un son unique. Nous avons vu comment
combiner des sons pour produire des effets sonores, mais les sons individuels sont encore définis numériquement - qui est, par une certaine fréquence et la durée. Il est souvent plus facile de créer des sons à partir des notes de musique, et pour cette raison Fastgraph comprend une fg_music routine qui produit ces sons. La routine fg_music utilise la minuterie programmable pour produire un son synchrone; il ne supporte pas la puce sonore TI.

La routine fg_music a un seul argument appelé la chaîne de musique,
passé par référence comme un tableau d'octets ou de chaîne de caractères. La chaîne de musique est tout simplement une séquence de longueur variable des commandes de musique, suivi d'un signe dollar ($) terminateur. commandes de musique sont résumées dans le tableau suivant.

commande sens

A travers G Jouez la note spécifiée dans l'octave actuelle.

    Peut être annexée à un caractère de note (A à G) pour faire cette note 

 pointu.

. Peut être annexée à un caractère de note (A à G) ou une forte (#) pour

étendre cette note la moitié de sa longueur normale. Plusieurs points peuvent être
         utilisé, et chacun à nouveau d'étendre la note de la moitié autant que le
         l'extension précédente.

Ln Régler la longueur des notes et des pauses suivantes. La valeur de n est un

 entier compris entre 1 et 64, où 1 indique une note entière, deux demi
         Attention, 4 un quart de note, et ainsi de suite. Si aucune commande de L est présent, L4
          est assumé.

Sur Définir l'octave pour les notes suivantes. La valeur de n peut être un

entier compris entre 0 et 6 pour définir une octave spécifique. Il peut également être un   

 plus (+) ou moins (-) caractère pour augmenter ou diminuer la
         actuel numéro d'octave. Octave 4 contient du milieu C, et si aucune O
         commande est présente, O4 est supposé.

P Pause (repos) pendant la durée spécifiée par le plus récent L

 commander.

Sn Réglez la quantité de silence entre les notes. La valeur de n est un

 entier compris entre 0 et 2. Si n est 0, chaque note joue pour le plein
         délai fixé par la commande L (musique legato). Si n est égal à 1, chaque note
         joue pour 7/8 le délai fixé par la commande L (musique normale). Si n
         est 2, chaque note joue pour 3/4 le délai fixé par la commande L (musique
         staccato). Si aucune commande S est présent, S1 est supposé.

Tn Réglez le tempo de la musique (le nombre de notes trimestre par minute).

 La valeur de n est un entier compris entre 32 et 255. Si aucune commande de T est
         présente, T120 est supposé.

La routine fg_music ignore tous les autres caractères de la chaîne musicale. Il ignore également des valeurs de commande en dehors de la plage autorisée, comme T20 ou O8.

Exemple 15-3 illustre certaines utilisations de fg_music. Le programme joue le
premières mesures de «Mary Had a Little Lamb", suivi de l'échelle musicale (y compris les objets tranchants) dans deux octaves, et enfin l'introduction de la Cinquième Symphonie de Beethoven. Il y a une pause d'une seconde entre chaque morceau de musique, et le programme affiche les titres avant de jouer la musique. Les caractères vides apparaissent dans les chaînes de musique pour aider à les rendre plus lisibles.

 Exemple 15-3.


 #include <fastgraf.h>
    #include <stdio.h>
   void main (void);

 void main ()
    {
   {Fg_initpm ();
      printf ( "Mary Had a Little Lamb ... \ n");
      fg_music ( "T150 L8 EDCDEEE P DDD P EGG P EDCDEEE L16 P L8 EDDEDC $");
      fg_waitfor (18);

 printf ( "l'échelle dans deux octaves ... \ n");
      fg_music ( "L16 CC # DD # EFF # GG # AA # B O + CC # DD # EFF # GG # AA # B $");
      fg_waitfor (18);

 printf ( "Cinquième Symphonie de Beethoven ... \ n");
      fg_music ( "T180 O2 L2 P L8 P GGG L2 D # L24 P L8 P L2 FFF D $");
   }   
                                             Chapitre 15: Effets sonores 335


===Asynchronous sonore===

Les sons émis simultanément avec d'autres activités dans un programme sont dites
asynchrone. Les routines de Fastgraph qui produisent un son asynchrone commencent juste le son et le contrôle au programme appelant retournent immédiatement. Les sons cesseront automatiquement lorsque la fin de la séquence est atteinte, et vous pouvez également suspendre ou arrêter la demande avant cette date. Aucun des routines sonores asynchrones de Fastgraph aucun effet s'il y a déjà un son asynchrone en cours. En outre, les routines sonores asynchrones désactiver temporairement les routines sonores synchrones (fg_sound, fg_voice et fg_music) tandis que le son asynchrone est en cours.

Pour élargir la gamme d'effets sonores et de jouer de la musique à tempo rapide,

Fastgraph quadruple temporairement le taux d'interruption de tic d'horloge de 18,2 à 72,8 tiques par seconde, tout en produisant un son asynchrone. Parce que de nombreux contrôleurs de disques comptent sur le 18.2 tick par seconde fréquence d'horloge pour synchroniser les accès disque, vos programmes ne doivent pas effectuer toutes les opérations de disque lorsque le son asynchrone est en cours.

La routine de fg_sounds est la version asynchrone de fg_sound.  Il utilise
la minuterie programmable pour lire une séquence de tonalités simultanées à d'autres opérations. Cette routine attend comme premier argument un entier de tableau de longueur variable, passée par référence, contenant des paires de valeurs de fréquence et de durée. Comme fg_sound, chaque fréquence est exprimée en Hertz et doit être comprise entre 18 et 32.767. Les durées sont également mesurées en tops d'horloge, mais parce que le taux d'interruption est quadruplé, il y a 72,8 au lieu de 18,2 tiques par seconde.

Le format de la fréquence et de la durée tableau passé à fg_sounds est
montré ici:


 [0] fréquence du son 1

 [1] durée de son 1

 [2] fréquence du son 2

 [3] durée de son 2

  .
                                           .
                                           .

 [2n-2] fréquence du son n

 [2n-1] durée de son n

 [2n] terminaison (0)


A noter que le caractère nul (soit un octet nul) se termine à la matrice. Le deuxième argument passé à fg_sounds est une valeur entière indiquant le nombre de fois pour faire défiler la fréquence et la durée tableau. Si cette valeur est négative, les sons vont continuer jusqu'à l'arrêt avec fg_hush ou fg_hushnext. Guide de l'utilisateur 336 Fastgraph


Exemple 15-4 utilise fg_sounds pour jouer la tonalité 100 à 500 Hertz coulissant
la séquence de l'exemple 15-1. Pour prouver les sons sont faits en même temps que d'autres opérations, les messages sont affichés pendant la séquence de lecture. Ceci est contrôlé par la fg_playing routine Fastgraph, qui retourne une valeur de 1 si les sons asynchrones sont en cours, et 0 sinon. Notez comment la durée doit être spécifiée comme 8 ticks horloge (au lieu de 2 comme dans l'exemple 15-1) pour compenser le taux d'interruption horloge tique quadruplée.

 Exemple 15-4.

 #include <fastgraf.h>
                 #include <stdio.h>
                void main (void);

 void main ()
                 {
                    int i;
                   int freq;
                   int sound_array [83];

 i = 0;
                   pour (freq = 100; freq <= 500; freq + = 10) {
                      sound_array [i ++] = freq;
                      sound_array [i ++] = 8;
                       }
                   sound_array [i] = 0;

 fg_initpm ();
                   fg_sounds (sound_array, 1);

 tandis que (fg_playing ())
                      printf ( "jouer encore ... \ n");
                 }


Tout comme fg_sounds est analogue à fg_sound, il y a une routine Fastgraph
fg_voices qui est semblable à fg_voice. Autrement dit, fg_voices utilise la puce sonore TI pour jouer une séquence asynchrone de tonalités. Ses arguments sont les mêmes que ceux de fg_sounds, mais la structure de la matrice solide est différent. Sa structure est:


 [0] canal # 1 du son

 [1] fréquence du son 1

 [2] volume du son 1

 [3] durée de son 1

  .
                                           .
                                           .

 [4n-4] canal # de son n   
                                             Chapitre 15: Effets sonores 337


 [4n-3] fréquence du son n

 [4n-2] volume du son n

 [4n-1] durée de son n

 [4n] terminaison (0)


Les numéros de canaux, les fréquences, les volumes et les durées doivent être dans les mêmes plages comme indiqué dans la description de fg_voice, sauf les durées sont quadruplés en raison du taux d'interruption horloge tique accélérée. Encore une fois, notez que le caractère nul (qui est, un octet nul) met fin à la matrice.

Exemple 15-5 utilise fg_voices pour jouer la séquence de 500 Hertz de ton de
augmentation du volume introduit dans l'exemple 15-2. Comme dans l'exemple 15-4, le programme affiche des messages pendant la séquence de sons est en cours de lecture pour démontrer les sons sont en cours en même temps que d'autres opérations. Notez comment la durée est maintenant 16 coups d'horloge (au lieu de 4 comme dans l'exemple 15-2) en raison du taux d'interruption horloge tique quadruplée.

 Exemple 15-5.

 #include <fastgraf.h>
            #include <stdio.h>
           void main (void);

 void main ()
            {
              int voice_array [61];
               int i;
              le volume int;

 fg_initpm ();
              if (fg_testmode (9,0) == 0) {
                 printf ( "Ce programme nécessite une PCjr ou");
                 printf ( "un système Tandy 1000 \ n.");
                  sortie (1);
                  }

 i = 0;
              pour (volume = 1; volume <= 15, le volume ++) {
                 voice_array [i ++] = 1; / * L'utilisation du canal 1 * /
                 voice_array [i ++] = 500; / * 500 Hz de fréquence * /
                 voice_array [i ++] = volume; / * Volume variable * /
                 voice_array [i ++] = 16; / * Durée * /
                  }
              voice_array [i] = 0;

 fg_voices (voice_array, 1);

 tandis que (fg_playing ())
                 printf ( "jouer encore ... \ n");
           }   

Il existe également une version asynchrone de fg_music.  On l'appelle
fg_musicb, et il utilise la même chaîne format de musique comme fg_music fait. Cependant, fg_musicb a un second argument qui spécifie le nombre de fois pour faire défiler la chaîne de musique. Si cette valeur est négative, la musique jouera répétitivement jusqu'à ce que vous arrêtiez avec fg_hush ou fg_hushnext.

Exemple 15-6 joue les mêmes trois morceaux de musique que l'exemple 15-3, mais il
le fait en même temps que d'autres opérations. Alors que la musique joue, le programme affiche en permanence le titre de chaque morceau. Notez la façon dont nous pouvons tirer profit de la répétition dans la chaîne de musique pour la séquence "jusqu'à l'échelle" en jouant la séquence deux fois.

 Exemple 15-6.

 #include <fastgraf.h>
   #include <stdio.h>
  void main (void);

 void main ()
   {
     fg_initpm ();
     fg_musicb ( "T150 L8 EDCDEEE P DDD P EGG P EDCDEEE L16 P L8 EDDEDC $", 1);
     tandis que (fg_playing ())
        printf ( "Mary Had a Little Lamb ... \ n");
     fg_waitfor (18);

 fg_musicb ( "L16 CC # DD # EFF # GG # AA # B O + $", 2);
     tandis que (fg_playing ())
        printf ( "l'échelle dans deux octaves ... \ n");
     fg_waitfor (18);

 fg_musicb ( "T180 O2 L2 P L8 P GGG L2 D # L24 P L8 P L2 D FFF $", 1);
     tandis que (fg_playing ())
        printf ( "Cinquième Symphonie de Beethoven ... \ n");
   }


L'exemple suivant montre les effets des routines Fastgraph
fg_hush et fg_hushnext, qui arrêtent les sons ont commencé avec fg_sounds, fg_voices ou fg_musicb. La routine fg_hush arrête immédiatement son asynchrone, tandis que fg_hushnext le fait quand le cycle actuel se termine. Ni routine a des arguments, et ni la routine n'a aucun effet si aucun son asynchrone est en cours. En outre, notez que fg_hushnext n'a aucun effet à moins que le son asynchrone est continue.

Exemple 15-7 fonctionne dans un mode vidéo texte ou des graphiques.  Il affiche
rectangles jusqu'à 16 couleurs tout en jouant de la musique asynchrone continue. Le programme vérifie périodiquement les frappes avec fg_intkey, et il continue de jouer la musique alors qu'il n'y a pas d'activité de clavier. Si vous appuyez sur la touche Echap, le programme fg_hush utilise pour arrêter la musique immédiatement; ce qui provoque une sortie de la boucle while. Si vous appuyez sur une autre touche, le programme fg_hushnext utilise pour arrêter la musique dès que la répétition en cours se termine. Une fois que cela se produit, le programme sort de la boucle de temps parce que fg_playing retournera une valeur de zéro.

 Exemple 15-7.

 #include <fastgraf.h>
     void main (void);

 #define ESC 27

 void main ()
      {
        Couleur int;
        int old_mode;
        unsigned clé de char, aux;

 fg_initpm ();
        fg_getmode old_mode = ();
        fg_setmode (fg_automode ());
        color = 0;

 fg_musicb ( "O4 L16 CC # DD # EFF # GG # AA # B O + CC # DD # EFF # GG # AA # B $", - 1);

 tandis que (fg_playing ())
         {
           color = (couleur + 1) et 15;
           fg_setcolor (couleur);
           fg_rect (0, fg_getmaxx (), 0, fg_getmaxy ());

 fg_waitfor (4);
           fg_intkey (touche &, & aux);
           si (== touche ESC)
              fg_hush ();
           else if (+ aux clés! = 0)
              fg_hushnext ();
         }

 fg_setmode (old_mode);
        fg_reset ();
      }


Exemple 15-7 montre également un effet secondaire important de la fg_musicb lorsque
jouer de la musique en continu. Toute longueur, octave, le silence, ou des valeurs de tempo changé au sein de la chaîne ne sont pas réinitialisés à leurs valeurs initiales au début de chaque répétition. Si nous n'avons pas inclus la commande O4 au début de la chaîne, la commande ultérieurement O + causerait la musique à jouer dans octaves 4 et 5 au cours de la première répétition, 5 et 6 au cours de la seconde répétition, et l'octave 6 pour toutes les répétitions ultérieures (parce que vous ne pouvez pas augmenter le nombre d'octave au-dessus 6).

Les deux dernières routines relatives à son asynchrone sont fg_resume et
fg_suspend. La fg_suspend routine musique suspend précédemment commencé par fg_musicb, tandis que fg_resume redémarre la musique à partir du point où il a été suspendu. Exemple 15-8 joue les premières mesures de "Mary Had a Little Lamb". Si vous appuyez sur une touche alors que le morceau est joué, il arrête. Puis, après une autre touche, la musique reprend et se poursuit jusqu'à fini. Guide de 340 Fastgraph utilisateur

 Exemple 15-8.

 #include <fastgraf.h>
   #include <stdio.h>
  void main (void);

 void main ()
   {
     fg_initpm ();
     fg_musicb ( "T150 L8 EDCDEEE P DDD P EGG P EDCDEEE L16 P L8 EDDEDC $", 1);
     fg_waitkey ();

 fg_suspend ();
     printf ( "Musique suspendu Appuyez sur une touche pour reprendre \ n..");
     fg_waitkey ();

 fg_resume ();
     printf ( "Music reprend \ n.");
     tandis que (fg_playing ());
     printf ( "Musique terminée. \ n");
   }


La routine de fg_suspend n'a aucun effet s'il n'y a pas de musique asynchrone en cours. De même, fg_resume n'a pas d'effet s'il n'y a pas de musique suspendue. Si vous appelez fg_suspend puis besoin d'annuler la musique ou de sortie DOS au lieu de redémarrer la musique, appelez fg_hush au lieu de fg_resume.


===Résumé des Routines sonores===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_HUSH arrête immédiatement son asynchrone a commencé avec fg_sounds,
fg_voices ou fg_musicb.

FG_HUSHNEXT est similaire à fg_hush, mais il ne se limite pas asynchrone
sonner jusqu'à ce que la répétition en cours se termine.

FG_MUSIC utilise la minuterie programmable pour jouer une séquence de tonalités musicales.

FG_MUSICB est la version asynchrone de fg_music. Il utilise le
minuterie programmable pour lire une séquence de tonalités musicales, simultanément avec d'autres activités.

FG_PLAYING détermine si oui ou non il y a un son asynchrone
la progression.

FG_QUIET arrête son synchrone continu a commencé avec fg_sound ou
fg_voice.

FG_RESUME redémarre la musique asynchrone précédemment suspendu par fg_suspend. 

FG_SOUND produit un son d'une fréquence spécifiée et la durée en utilisant la
minuterie programmable.

FG_SOUNDS est la version asynchrone de fg_sound. Il peut jouer une série
des tons de fréquences et des durées déterminées, simultanées avec d'autres activités.

FG_SUSPEND suspend la musique asynchrone précédemment lancée par fg_musicb.

FG_VOICE produit un son d'une fréquence, la durée et le volume spécifié
en utilisant l'un des quatre canaux vocaux de la puce sonore TI.

FG_VOICES est la version asynchrone de fg_voice. Il peut jouer une série
des tons de fréquences spécifiées, les durées et les volumes, simultanées avec d'autres activités. Guide de l'utilisateur 342 Fastgraph


==Guide de synchronisation du programme==

Il est parfois nécessaire de retarder l'exécution d'un programme pour une brève
période, ou de déterminer combien de temps il faut pour exécuter des sections spécifiques d'un programme. Fastgraph comprend des routines pour accomplir ces tâches. Certains de ces routines sont dit être en temps réel, ce qui signifie qu'ils sont indépendants de la vitesse du processeur d'un système, alors que la vitesse des autres est spécifique au processeur. Ce chapitre décrit les deux classes de routines de cadencement, qui sont tous indépendamment des autres parties de Fastgraph.


===Real-Time Routines===

En temps réel des opérations de centre autour de l'heure du jour l'horloge du BIOS, qui est
rien de plus qu'un compteur qui incrémente automatiquement le système 18.2 fois par seconde. Ce nombre est souvent appelé le taux d'interruption horloge tique car une routine d'interruption effectue l'incrémentation. En outre, chaque incrément est généralement appelé un coup d'horloge.

La routine Fastgraph fg_waitfor retarde l'exécution d'un programme par le
nombre de tops d'horloge spécifié comme argument. Parce que fg_waitfor utilise des tops d'horloge, la longueur réelle du retard est le même, quelle que soit la vitesse du processeur du système. Même lorsque les routines sonores asynchrones de Fastgraph quadrupler le taux d'interruption horloge tique, Fastgraph compense cette intérieurement de façon fg_waitfor fonctionne toujours comme si le taux réel était encore 18,2 fois par seconde.

Exemple 16-1 affiche un message toutes les cinq secondes qui stipule combien de temps
le programme a été en cours d'exécution. La routine de fg_waitfor produit le délai de cinq secondes en arrêtant 91 (18,2 fois 5) coups d'horloge avant que le programme affiche chaque message. Le programme retourne au DOS lorsque vous appuyez sur une touche.

 Exemple 16-1.

 #include <fastgraf.h>
              #include <stdio.h>
             void main (void);

 void main ()
              {
                secondes unsigned int;
                unsigned clé de char, aux;

 fg_initpm ();
                secondes = 0;
                 faire {
                   fg_waitfor (91);
                   secondes + = 5;
                   printf ( "% u secondes se sont écoulées. \ n", secondes);
                   fg_intkey (touche &, & aux);
                 }
                tandis que (touche + aux == 0);
             }   
                                            Chapitre 16: Timing du programme 345


Une autre application commune de fg_waitfor est de ralentir une boucle qui utilise
fg_intkey pour vérifier les frappes. Dans les boucles qui ne font guère d'autre, nous pouvons appeler fg_intkey trop rapidement sans ce retard, et il est alors possible que le BIOS peut ne pas être en mesure de stocker les caractères dans sa mémoire tampon de clavier assez vite. Un petit retard, même un coup d'horloge, permet souvent de telles boucles "serrés".

La routine fg_getclock fournit un moyen efficace pour mesurer le temps,
en particulier les différences dans le temps. Cette routine n'a pas d'arguments et retourne un entier non signé 32 bits (comme sa valeur de fonction) représentant le nombre d'impulsions d'horloge depuis minuit. Exemple 16-2 montre fg_getclock. En réponse à une combinaison de touches (sauf Escape, qui retourne le contrôle au DOS), le programme affiche le nombre d'impulsions d'horloge à partir de minuit, et le nombre de tiques depuis le début du programme.

 Exemple 16-2.

 #include <fastgraf.h>
      #include <stdio.h>
     void main (void);

 #define ESC 27

 void main ()
      {
        démarrage long non signé, les tiques;
        unsigned clé de char, aux;

 fg_initpm ();
        start = fg_getclock ();
         faire {
           ticks = fg_getclock ();
           printf ( "% ld ticks depuis minuit. \ n", tiques);
           printf ( "% lu ticks depuis le début du programme \ n \ n.", ticks-start);
           fg_getkey (touche &, & aux);
         }
        while (key = ESC!);
      }


===Routines dépendant de la vitesse du système===

La routine de fg_waitfor décrit dans la section précédente est indépendante
de la vitesse du processeur du système. Cela signifie que la longueur effective de son retard est la même sur tout système. Une autre routine fg_stall est semblable à fg_waitfor, mais son retard est proportionnel à la vitesse du processeur. Comme fg_waitfor, fg_stall a un seul argument entier qui spécifie la longueur du délai. Cependant, au lieu d'être exprimée en coups d'horloge, fg_stall mesure le retard en unités de retard. Les gâteries de routine fg_stall la longueur comme une quantité non signée, de sorte que dans les modes 16 bits le nombre maximum d'unités de retard, nous pouvons spécifier est 65.535. Le tableau suivant indique le nombre approximatif d'unités de retard par horloge tique sur trois systèmes typiques. Guide de l'utilisateur 346 Fastgraph


 unités de retard du système
                      type par impulsion d'horloge

 Tandy 1000 HX 280
                  25 MHz 80386 3400
                  40 MHz 80386 7100

Fastgraph comprend une routine qui détermine le nombre d'unités de retard
par horloge cocher pour le processeur utilisé. Ceci est la routine de fg_measure, qui n'a pas d'arguments et renvoie le nombre d'unités de retard par impulsion d'horloge comme valeur de fonction. Une fois que nous déterminons cette valeur, nous pouvons utiliser fg_stall pour retarder l'exécution d'un programme en temps réel. Ceci permet d'obtenir un délai beaucoup plus raffiné que l'unité horloge tique utilisée par fg_waitfor.

 Exemple 16-3 est fonctionnellement identique à l'exemple 16-1, mais il utilise

fg_stall au lieu de fg_waitfor pour retarder l'exécution du programme. Les appels de programme fg_measure premier pour déterminer le nombre d'unités de retard équivalant à un coup d'horloge. Il passe ensuite cette valeur à fg_stall, appelée 91 fois à l'intérieur de la boucle pour créer le délai de cinq secondes (parce que 91 coups d'horloge est égale à cinq secondes). Le programme retourne au DOS lorsque vous appuyez sur une touche.

 Exemple 16-3.

 #include <fastgraf.h>
              #include <stdio.h>
             void main (void);

 void main ()
              {
                 int i;
                int units_per_tick;
                secondes unsigned int;
                unsigned clé de char, aux;

 fg_initpm ();
                secondes = 0;
                printf ( "Benchmarking de la vitesse du système ... \ n");
                fg_measure units_per_tick = ();
                printf ( "Benchmark terminée \ n \ n.");

 faire {
                   for (i = 0; i <91; i ++)
                      fg_stall (units_per_tick);
                   secondes + = 5;
                   printf ( "% u secondes se sont écoulées. \ n", secondes);
                   fg_intkey (touche &, & aux);
                 }
                tandis que (touche + aux == 0);
              }


Un dernier point: fg_measure prend quelques secondes pour le système de référence
accélérer avec précision. Pour cette raison, vous ne devriez appeler fg_measure fois (généralement au début du programme) et utiliser sa valeur de retour au lieu d'appeler fg_measure tout au long du programme.


===Résumé des Routines Timing===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_GETCLOCK renvoie le nombre de tops d'horloge depuis minuit comme
valeur de la fonction. Cette quantité est un entier non signé sur 32 bits.

FG_MEASURE renvoie le nombre approximatif d'unités de retard par impulsion d'horloge
comme valeur de fonction. Cette quantité est proportionnelle à la vitesse du processeur du système.

FG_STALL retarde l'exécution d'un programme pour un nombre donné de processor-
unités de retard spécifiques.

FG_WAITFOR retarde l'exécution d'un programme pour un nombre donné d'horloge
tiques. Il y a 18,2 horloge par seconde, quelle que soit la vitesse du processeur du système. Guide de l'utilisateur 348 Fastgraph



==Divers Routines==

Il y a encore quelques routines Fastgraph qui vraiment ne rentrent pas dans
aucune des catégories examinées jusqu'à présent. Pour cette raison, nous allons les décrire séparément dans ce chapitre.


===Détermination de la mémoire disponible===

La routine fg_memavail renvoie la quantité de mémoire conventionnelle libre
(En octets) disponible pour DOS. Il renvoie la quantité de mémoire que sa valeur de fonction, qui est un entier non signé 32 bits, et il n'a pas d'arguments.

Exemple 17-1 utilise fg_memavail pour montrer les effets de la création et
libérer des pages virtuelles. Lorsqu'il est exécuté dans un mode vidéo dans lequel les pages vidéo 1 et 2 sont des pages physiques, la quantité de mémoire libre reste le même parce que ces pages utilisent de la mémoire qui réside sur la carte vidéo. Cependant, dans les modes où les pages 1 et 2 sont des pages virtuelles, la quantité de mémoire libre diminue après chaque appel à fg_allocate et retourne à sa valeur d'origine après les appels à fg_freepage. Notez comment les demandes de programme et valide le mode vidéo.

 Exemple 17-1.

 #include <fastgraf.h>
       #include <stdio.h>
       #include <stdlib.h>
      void main (void);

 void main ()
       {
         original long, mem0, mem1, mem2;
         int mode, old_mode;

 printf ( "mode vidéo qui?");
         scanf ( "% d", et le mode);

 fg_initpm ();
         if (fg_testmode (mode 0) == 0) {
            printf ( "Votre système ne prend pas en charge ce mode vidéo. \ n");
             sortie (1);
             }
         if (fg_testmode (mode 3) == 0) {
            printf ( "Votre système ne dispose pas de suffisamment de mémoire. \ n");
             sortie (1);
             }

 originale = fg_memavail ();
         fg_getmode old_mode = ();
         fg_setmode (mode);
         mem0 = fg_memavail ();
         fg_allocate (1);
         mem1 = fg_memavail ();
         fg_allocate (2);
         mem2 = fg_memavail (); 
                                    Chapitre 17: Divers Routines 351


 fg_freepage (1);
         fg_freepage (2);
         fg_setmode (old_mode);
         fg_reset ();

 printf ( "origine =% ld \ n", original);
         printf ( "après setmode =% ld \ n", mem0);
         printf ( "après la 1ère page =% ld \ n", mem1);
         printf ( "après la 2ème page =% ld \ n", mem2);
         printf ( "à la fin =% ld \ n", memavail ());
       }


===Choisir la fonction Mise à jour vidéo Mémoire===

Dans le chapitre 12, nous avons vu comment utiliser la routine fg_setfunc pour effectuer XOR
animation en mode EGA et VGA graphiques natifs (modes 13 à 18). Dans ces modes vidéo, fg_setfunc commande l'opération logique appliquée lorsque le contenu de la modification de la mémoire vidéo. L'opération spécifique est définie par son argument, comme indiqué ici:

 valeur logique
                                opération d'argument

 0 remplacement
                                   1 et
                                   2 ou
                                   3 ou exclusif

Si un programme ne remet pas fg_setfunc, le mode de remplacement est toujours utilisé. Autrement dit, l'information écrite à la mémoire vidéo remplace tout ce qui était là avant. La routine de fg_setfunc applique uniquement à la mémoire vidéo, même si un tampon virtuel est actif, et n'a de sens que dans les modes graphiques EGA, VGA, SVGA et 16 couleurs.

Exemple 17-2 montre la routine de fg_setfunc. Le programme est similaire
à l'exemple 6-11, qui affiche 200 rectangles aléatoires sur l'écran. Cependant, l'exemple 17-2 montre les rectangles en mode XOR, ce qui rend les intersections du rectangle apparaissent dans des couleurs différentes.

 Exemple 17-2.

 #include <fastgraf.h>
             #include <stdio.h>
             #include <stdlib.h>
            void main (void);

 #define RECTANGLES 200
            #define SWAP (a, b, temp) {temp = a;  a = b; b = température;  }

 void main ()
             {
                int i;
               int minx, maxx, Miny, maxy; 

 int old_mode;
               int température;
               xres int, yres;

 fg_initpm ();
               if (fg_egacheck () == 0) {
                  printf ( "Ce programme nécessite EGA ou VGA. \ n");
                   sortie (1);
                   }

 fg_getmode old_mode = ();
               fg_setmode (fg_automode ());
               fg_setfunc (3);

 xres = fg_getmaxx () + 1;
               yres = fg_getmaxy () + 1;

 for (i = 0; i <RECTANGLES; i ++) {
                  minx = rand ()% xres;
                  maxx = rand ()% xres;
                  Miny = rand ()% yres;
                  maxy = rand ()% yres;
                  if (minx> maxx)
                     SWAP (minx, maxx, temp);
                  if (Miny> maxy)
                     SWAP (Miny, Maxy, temp);
                  fg_setcolor (rand ()% 16);
                  fg_rect (minx, maxx, Miny, maxy);
                   }

 fg_setmode (old_mode);
               fg_reset ();
             }


===Contrôle vertical Retrace Synchronisation===

Le retour vertical est la brève période où le faisceau d'électrons du moniteur
voyages à partir du bas de l'écran vers le coin supérieur gauche pour commencer un nouveau cycle de rafraîchissement d'affichage. En fonction du moniteur, le retour de balayage vertical se produit typiquement entre 50 et 60 fois par seconde.

Certaines opérations graphiques doivent être effectuées lors d'un retour vertical
intervalle pour éviter le scintillement de l'écran potentiel ou de la neige. Ceux-ci incluent un changement de page, le panoramique, et la lecture ou l'écriture d'un bloc de vidéo registres du CAD ou palettes. Par défaut, les routines de Fastgraph qui effectuent ces opérations fournissent automatiquement la synchronisation de retour vertical nécessaire. Dans la plupart des applications, ces contrôles de retour de balayage vertical sont tout à fait suffisant. Il y a des moments, cependant, lorsque vous pouvez désactiver la vérification verticale de retour de Fastgraph et effectuer la synchronisation de retour vertical au niveau de l'application.

Tel est l'objet de la routine de fg_waitvr de Fastgraph. Pour désactiver tous les
synchronisation de retour vertical interne au sein de Fastgraph, appelez fg_waitvr avec un argument zéro. Si vous voulez réactiver, passer une valeur non nulle

fg_waitvr (notez que cela est l'état par défaut). Les routines Fastgraph pertinentes du retour vertical sont fg_getdacs, fg_palettes, fg_pan, fg_setdacs et fg_setvpage; et dans les modes 256 couleurs, fg_getrgb, fg_palette et fg_setrgb. Le retour vertical est également applicable aux routines de Fastgraph pour l'affichage ou la création de PCX, GIF, ou des fichiers en flic modes graphiques 16 couleurs et 256 couleurs lorsque les valeurs de la palette ou du CAD sont manipulés.

A titre d'exemple des raisons pour lesquelles vous pourriez vouloir faire désactiver Fastgraph de vertical
commandes revenir, envisager un changement de page. Après fg_setvpage définit l'adresse de début d'affichage pour la nouvelle page visuelle, il attend un intervalle de retour vertical de sorte que la nouvelle adresse de départ peut prendre effet. Si fg_setvpage ne le faisait pas, graphiques affichés avant le prochain retour vertical seraient parfois apparaître sur l'écran avant de l'ancienne page visuelle est complètement enlevé. Supposons, cependant, que, immédiatement après la page bascule vous avez fait des calculs ou d'autres travaux qui ne touchent l'affichage vidéo. Si vous désactivez la synchronisation de retour vertical de Fastgraph, vous pourriez obtenir un taux de trame plus rapide parce que vous pouvez effectuer les calculs post-Page-bascules alors que le système est normalement en attente pour le retour vertical. Selon l'ampleur de ces calculs, vous pouvez constater qu'il est même pas nécessaire d'attendre le retour vertical suivant une page flip.


===Commutation Banque SVGA externe===

L'une des caractéristiques les plus importantes qui se produit au cours de la SVGA de Fastgraph
l'initialisation du noyau est la configuration des fonctions bancaires de commutation spécifiques chipset. Lorsqu'un commutateur bancaire est nécessaire, la routine actuelle Fastgraph effectue le commutateur de banque par des points d'entrée pré-définis dans le noyau SVGA. Cela supprime les détails de bas niveau de savoir quand et comment la banque commutateur à partir du code de haut niveau d'une application.

Si vous avez une application qui effectue une partie ou la totalité de ses graphiques SVGA
à l'extérieur de Fastgraph, vous pouvez toujours utiliser une vaste autodetection SVGA chipset Fastgraph et les fonctions bancaires de commutation. Après l'initialisation avec succès le noyau SVGA avec fg_svgainit et l'établissement d'un mode vidéo graphique SVGA, les numéros de banque lecture et d'écriture seront mis à zéro. Lorsque vous avez besoin de changer de banque SVGA, appelez les fg_setbanks de routine; ses deux arguments spécifient la nouvelle lecture et d'écriture des numéros de banque. Notez que fg_setbanks ne vous dit pas quand effectuer un commutateur de banque, il gère simplement les détails de la façon de le faire. Une routine complémentaire, fg_getbanks, retourne lecture actuelle du noyau SVGA et écrire les numéros de banque.


===Sauvegarde et restauration de l'État Vidéo===

Si vous appelez routines Fastgraph à partir d'une routine de service d'interruption (ISR) dans
un mode VGA, XVGA ou SVGA graphiques, l'ISR est responsable de la sauvegarde et la restauration de l'état de VGA. Ceci est nécessaire car une interruption peut se produire lors de l'exécution d'autres opérations graphiques, et les routines Fastgraph appelées à partir de l'ISR sera presque certainement changer l'état VGA. Lorsque le contrôle revient au point d'interruption, le VGA sera probablement dans un état différent de celui attendu.

La routine fg_vgastate enregistre et restaure les registres VGA qui
Fastgraph prévoit être dans des états spécifiques. Ces registres sont: Guide de l'utilisateur 354 Fastgraph


* Indice Contrôleur graphique
* Contrôleur graphique enregistre 0-8
* Sequence index Controller
* Sequence Controller registre 2

Pour enregistrer l'état de ces registres, appelez fg_vgastate (0). Pour les rendre à leurs valeurs précédemment enregistrées, appelez fg_vgastate (1). Si vous demandez une fg_vgastate opération de sauvegarde avant d'effectuer une opération de restauration, rien ne se passe. La routine de fg_vgastate n'a de sens que dans les modes vidéo numérotés 13 et ci-dessus lors de l'exécution sur un VGA ou SVGA système.

Si vous avez besoin pour sauvegarder et restaurer l'état du VGA en mode graphique SVGA,
vous devez utiliser fg_vgastate pour préserver les registres VGA ainsi fg_getbanks et fg_setbanks (décrit dans la section précédente) pour préserver les numéros de banque de SVGA.


===Résumé des Routines Divers===

Cette section résume les descriptions fonctionnelles du Fastgraph
routines présentées dans ce chapitre. Des informations plus détaillées sur ces routines, y compris leurs arguments et les valeurs de retour, peut être trouvée dans le manuel de référence Fastgraph.

FG_GETBANKS renvoie le SVGA courant lire et écrire les numéros de banque.  Ces
les valeurs seront correctes que si elle est définie par le noyau SVGA, ou avec fg_setbanks.

FG_MEMAVAIL renvoie la quantité de mémoire disponible pour DOS.

FG_SETBANKS définit le SVGA lire et écrire les numéros de banque. Cette routine est
généralement pas appelé dans une application, mais il est prévu comme une interface de haut niveau pour le noyau de SVGA Fastgraph.

FG_SETFUNC spécifie l'opération logique (remplacement ou, et,
ou exclusif) appliqué lorsque la mémoire vidéo change dans les modes graphiques EGA, VGA, SVGA et 16 couleurs. Cette routine n'a pas d'effet dans d'autres modes vidéo et ne concerne pas les informations écrites sur les tampons virtuels.

FG_VGASTATE enregistre ou restaure l'état du contrôleur graphique VGA
et les registres du contrôleur de séquence utilisés par Fastgraph.

FG_WAITVR désactive ou active la synchronisation de retour vertical au sein
Fastgraph.

==Fastgraph Routines par catégorie==

Cette section énumère les routines Fastgraph par catégorie.  Ces catégories
parallèlement les chapitres du Guide de l'utilisateur Fastgraph. Les listes de cette section sont fournis un aperçu général des capacités de Fastgraph. Vous pouvez trouver des informations détaillées sur chaque routine Fastgraph dans la section suivante de ce manuel, et bien sûr dans le Guide de l'utilisateur Fastgraph.

Vidéo Initialisation Routines: fg_automode, fg_bestmode, fg_cursor, fg_egacheck, fg_getlines, fg_getmode, fg_initpm, fg_memory, fg_reset, fg_setlines, fg_setmode, fg_svgainit, fg_svgastat, fg_testmode.
Coordonner Routines: fg_getmaxx, fg_getmaxy, fg_getview, fg_getworld, fg_initw, fg_setview, fg_setworld, fg_xalpha, fg_xconvert, fg_xscreen, fg_xview, fg_xworld, fg_yalpha, fg_yconvert, fg_yscreen, fg_yview, fg_yworld.

Couleur liés Routines: fg_colors, fg_defcolor, fg_getcolor, fg_getdacs, fg_getindex, fg_getrgb, fg_maprgb, fg_palette, fg_palettes, fg_setattr, fg_setcolor, fg_setdacs, fg_setrgb.

Fondamentaux Routines graphiques: fg_box, fg_boxdepth, fg_boxw, fg_boxx, fg_boxxw, fg_circle, fg_circlef, fg_circlefw, fg_circlew, fg_clprect, fg_clprectw, fg_dash, fg_dashrel, fg_dashrw, fg_dashw, fg_draw, fg_drawrel, fg_drawrelx, fg_drawrw, fg_drawrxw, fg_draww, fg_drawx, fg_drawxw, fg_drect, fg_drectw, fg_ellipse, fg_ellipsef, fg_ellipsew, fg_ellipsfw, fg_erase, fg_fillpage, fg_flood, fg_floodw, fg_getclip, fg_getpixel, fg_getxbox, fg_getxpos, fg_getybox, fg_getypos, fg_inside, fg_move, fg_moverel, fg_moverw, fg_movew, fg_paint, fg_paintw, fg_point, fg_pointw, fg_pointx, fg_pointxw, fg_polyedge, fg_polyfill, fg_polygon, fg_polygonw, fg_polyline, fg_polyoff, fg_rect, fg_rectw, fg_setclip, fg_setclipw.

Afficher des caractères Routines: fg_chgattr, fg_chgtext, fg_fontsize, fg_getattr, fg_getchar, fg_getxjust, fg_getyjust, fg_justify, fg_locate, fg_print, fg_printc, fg_setangle, fg_setattr, fg_setcolor, fg_setratio, fg_setsize, fg_setsizew, fg_swchar, fg_swlength, fg_swtext, fg_text, fg_textc, fg_where, fg_xalpha, fg_xconvert, fg_yalpha, fg_yconvert.

Vidéo page et Virtual Routines Buffer: fg_allocate, fg_alloccms, fg_allocems, fg_allocxms, fg_copypage, fg_defpages, fg_findpage, fg_freepage, fg_getaddr, fg_getentry, fg_gethpage, fg_getpage, fg_getvpage, fg_initems, fg_initxms, fg_pagesize, fg_resize, fg_setentry, fg_sethpage, fg_setpage, fg_setvpage, fg_vbaddr , fg_vballoc, fg_vbclose, fg_vbcopy, fg_vbcut,
fg_vbdefine, fg_vbfree, fg_vbhandle, fg_vbinit, fg_vbopen, fg_vbpaste, fg_vbtccopy, fg_vbtcxfer, fg_vbundef.

Routines de fichier image: fg_dispfile, fg_flicdone, fg_flichead, fg_flicmode, fg_flicopen, fg_flicplay, fg_flicsize, fg_flicskip, fg_gifhead, fg_gifmode, fg_gifpal, fg_gifrange, fg_imagebuf, fg_loadpcx, fg_makegif, fg_makepcx, fg_makeppr, fg_makespr, fg_pattern, fg_pcxhead, fg_pcxmode, fg_pcxpal, fg_pcxrange, fg_showflic, fg_showgif, fg_showpcx, fg_showppr, fg_showspr.

Bitmap Routines Image: fg_clipmap, fg_clipmask, fg_clpimage, fg_display, fg_displayp, fg_drawmap, fg_drawmask, fg_drwimage, fg_flipmask, fg_flpimage, fg_getimage, fg_getmap, fg_imagesiz, fg_invert, fg_pack, fg_putimage, fg_revimage, fg_revmask, fg_scale, fg_shear, fg_unpack.

Routines Bloc de transfert: fg_copypage, fg_getblock, fg_putblock, fg_restore, fg_restorew, fg_save, fg_savew, fg_tcdefine, fg_tcmask, fg_tcxfer, fg_transfer, fg_vbcopy, fg_vbcut, fg_vbpaste, fg_vbtccopy, fg_vbtcxfer.

Effets spéciaux Routines: fg_fadein, fg_fadeout, fg_pan, fg_panw, fg_resize, fg_scroll, fg_split.

Routines d'entrée: fg_button, fg_capslock, fg_getkey, fg_getxjoy, fg_getyjoy, fg_initjoy, fg_intjoy, fg_intkey, fg_kbinit, fg_kblast, fg_kbreset, fg_kbtest, fg_mouse256, fg_mousebut, fg_mousecur, fg_mousefin, fg_mouseini, fg_mouselim, fg_mousemov, fg_mousepos, fg_mouseptr, fg_mousespd, fg_mousevis, fg_numlock , fg_scrlock, fg_setcaps, fg_setnum, fg_waitkey.

Routines son: fg_hush, fg_hushnext, fg_music, fg_musicb, fg_playing, fg_quiet, fg_resume, fg_sound, fg_sounds, fg_suspend, fg_voice, fg_voices.

Routines Timing: fg_getclock, fg_measure, fg_stall, fg_waitfor.

Routines Divers: fg_getbanks, fg_memavail, fg_setbanks, fg_setfunc, fg_svgaver, fg_version, fg_vgastate, fg_waitvr.


==Liste alphabétique des Fastgraph Routines==

Cette section présente une description détaillée de chaque routine Fastgraph.

Une fois que vous êtes familier avec Fastgraph, vous aurez probablement référence à ces descriptions plus souvent que toute autre section des manuels Fastgraph.

 Les informations présentées pour chaque routine comprend les éléments suivants:

* prototypes ou des déclarations de fonction
     pour chaque langue prise en charge
* Une description de la même routine
* Le nombre de paramètres, leur
                      but, et leurs types de données
                    * Le sens et le type de données du
                      la valeur de retour de routine (le cas échéant)
                    * Informations sur importants
                      restrictions relatives à la
                      routine



  2
                    * références à des routines similaires, ou
                      d'autres routines qui affectent la
                      routine
                    * exemples de programmes dans le Fastgraph
                      Guide de l'utilisateur qui utilise la routine

Un prototype spécifie les types de paramètres et le retour d'une routine données
valeur. But de chaque routine Fastgraph comprend des prototypes pour C / C ++, BASIC, FORTRAN et Pascal (dans cet ordre). Par exemple, les prototypes pour fg_allocate sont les suivants:

  int fg_allocate (int page_number);
            fonction FGallocate% (page_number%)
            int fonction fg_allocate (int page_number)
            fonction fg_allocate (page_number: Integer): Integer;

Le C / C ++, prototypes BASIC, et Pascal utiliser la syntaxe de déclaration pour ces langues. FORTRAN ne pas utiliser des prototypes de fonction, donc nous allons créer notre propre syntaxe de prototype utilisant les abréviations de type de données du compilateur FORTRAN PowerStation de Microsoft. Dans les prototypes FORTRAN, chaque paramètre est précédé par l'un des indicateurs de type de données présentées ici:

  Indicateur type de données FORTRAN

  omble CHARACTER * (*)
                        int eNTIER
                       int1 ENTIER * 1
                       int2 ENTIER * 2
                       int4 INTEGER * 4
                        dbl REAL * 8

Le type de données int est équivalente à ENTIER * 2 dans les environnements 16 bits (Microsoft FORTRAN) et équivalent à INTEGER * 4 dans des environnements 32 bits (Microsoft FORTRAN PowerStation). En outre, si la routine a une valeur de retour, le prototype commence avec l'indicateur de type de données de la valeur de retour suivie par la fonction de mot. Si la routine n'a pas de valeur de retour, le prototype commence par le mot sous-programme.

===fg_allocate===

*'''Prototype'''

  int fg_allocate (int page_number);
   fonction FGallocate% (page_number%)
   int fonction fg_allocate (int page_number)
   fonction fg_allocate (page_number: Integer): Integer;

*'''But'''

  La routine de fg_allocate crée une page vidéo virtuelle.  La quantité de mémoire
   requis dépend du mode vidéo en cours.

*'''Paramètres'''

  page_number est le numéro par lequel la page virtuelle sera référencé.  Il
   doit être comprise entre 1 et 63.

*'''Valeur de retour'''

  Un code d'état indiquant le succès ou l'échec de la page virtuelle
   création, comme indiqué ici:

  0 page = virtuel créé
     1 = page spécifiée est une page physique ou logique
     7 = virtuels page créée, mais le contrôle de la mémoire des blocs ont été détruits
     8 = mémoire insuffisante pour créer la page virtuelle

*'''Restrictions'''

  Cette routine est sans effet si page_number référence à une page vidéo physique,
   une page vidéo logique, ou si elle est utilisée dans un mode vidéo qui ne fonctionne pas
   pages vidéo virtuelles.

*'''Voir aussi'''

  fg_findpage, fg_freepage, fg_pagesize

*'''Exemples'''

  8-3, 8-4, 8-5, 8-6, 8-9, 11-1, 11-2, 11-3, 11-4, 12-4, 12-5, 13-2, 13- 5,
   17-1


===fg_alloccms===

*'''Prototype'''

  int fg_alloccms (int page_number);
   FGalloccms fonction% (page_number%)
   fg_alloccms fonction int (int page_number)
   fg_alloccms de fonction (PAGE_NUMBER: Integer): Integer;

*'''But'''

  La routine de fg_alloccms crée une page logique dans la mémoire conventionnelle.  le
   la quantité de mémoire nécessaire dépend du mode vidéo et la vidéo en cours
   Dimensions de la mémoire tampon.

*'''Paramètres'''

  page_number est le numéro par lequel la page logique sera référencé.  Il
   doit être comprise entre 1 et 63.

*'''Valeur de retour'''

  0 = page logique créé en mémoire conventionnelle
   -2 = Non valide numéro de page
   -3 = La page déjà créée, ou page existe comme une page physique ou virtuel
   -4 = Mémoire conventionnelle insuffisante pour créer la page

*'''Restrictions'''

  Cette routine est sans effet si page_number fait référence à un physique ou virtuel
   Page vidéo.

  La seule fonction que vous pouvez effectuer avec des pages logiques est la copie d'un ensemble de
   page à l'autre (avec fg_copypage).

*'''Voir aussi'''

  fg_allocems, fg_allocxms, fg_copypage, fg_findpage, fg_freepage,
   fg_pagesize

*'''Exemples'''

  8-10, 8-12


===fg_allocems===

*'''Prototype'''

  int fg_allocems (int page_number);
   FGallocems fonction% (page_number%)
   fg_allocems fonction int (int page_number)
   fg_allocems de fonction (PAGE_NUMBER: Integer): Integer;

*'''But'''

  La routine de fg_allocems crée une page logique dans la mémoire paginée (EMS).
   La quantité de mémoire requise dépend du mode vidéo et la vidéo en cours
   Dimensions de la mémoire tampon.

*'''Paramètres'''

  page_number est le numéro par lequel la page logique sera référencé.  Il
   doit être comprise entre 1 et 63.

*'''Valeur de retour'''

  0 = page logique créé en mémoire étendue
   -1 = Expanded Memory Manager non initialisée
   -2 = Non valide numéro de page
   -3 = La page déjà créée, ou page existe comme une page physique ou virtuel
   -4 = Insuffisante mémoire étendue pour créer la page

*'''Restrictions'''

  Cette routine est sans effet si page_number fait référence à un physique ou virtuel
   Page vidéo.

  Avant d'utiliser cette routine, vous devez utiliser fg_initems pour initialiser le
   Expanded Memory Manager.

  La seule fonction que vous pouvez effectuer avec EMS pages logiques est la copie d'un
   page entière à un autre (avec fg_copypage).

*'''Voir aussi'''

  fg_alloccms, fg_allocxms, fg_copypage, fg_findpage, fg_freepage,
   fg_initems, fg_pagesize

*'''Exemples'''

  8-10

===fg_allocxms===

*'''Prototype'''

  int fg_allocxms (int page_number);
   FGallocxms fonction% (page_number%)
   fg_allocxms fonction int (int page_number)
   fg_allocxms de fonction (PAGE_NUMBER: Integer): Integer;

*'''But'''

  La routine de fg_allocxms crée une page logique dans la mémoire étendue (XMS).
   La quantité de mémoire requise dépend du mode vidéo et la vidéo en cours
   Dimensions de la mémoire tampon.

*'''Paramètres'''

  page_number est le numéro par lequel la page logique sera référencé.  Il
   doit être comprise entre 1 et 63.

*'''Valeur de retour'''

  0 = page logique créé dans la mémoire étendue
   -1 = XMS pilote pas présent
   -2 = Non valide numéro de page
   -3 = La page déjà créée, ou page existe comme une page physique ou virtuel
   -4 = Insuffisante mémoire étendue pour créer la page

*'''Restrictions'''

  Cette routine est sans effet si page_number fait référence à un physique ou virtuel
   Page vidéo.

  Avant d'utiliser cette routine, vous devez utiliser fg_initxms pour initialiser les XMS
   chauffeur.

  La seule fonction que vous pouvez effectuer avec XMS pages logiques est la copie d'un
   page entière à un autre (avec fg_copypage).

*'''Voir aussi'''

  fg_alloccms, fg_allocems, fg_copypage, fg_findpage, fg_freepage,
   fg_initxms, fg_pagesize

*'''Exemples'''

  8-10

===fg_automode===

*'''Prototype'''

  int fg_automode (void);
   fonction FGautomode% ()
   int fonction fg_automode ()
   fonction fg_automode: integer;

*'''But'''

  La routine fg_automode détermine le mode graphique vidéo qui offre la
   la plupart des fonctionnalités pour la configuration de l'affichage et l'adaptateur de l'utilisateur.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La valeur de retour est le numéro de mode vidéo proposé.  L'affichage en cours et
   configuration de l'adaptateur de déterminer le numéro de mode, comme indiqué ici:

  afficher
                       adaptateur mono RGB ECD VGA

  MDA 7 0 7 7
                          HGC 11 0 0 11
                          CGA 0 4 0 0
                          EGA 15 13 16 0
                          VGA 17 17 17 18
                         MCGA 17 17 17 19
                        Tandy 7 9 0 0
                         PCjr 7 9 0 0

  La valeur de retour peut être soit transmise directement à fg_setmode, ou il peut
   aider à déterminer les modes vidéo appropriés pour votre programme.

*'''Restrictions'''

  Pour la compatibilité avec les versions précédentes de Fastgraph, cette fonction ne
   ne pas considérer les modes XVGA ou SVGA graphiques en proposant un mode vidéo.

*'''Voir aussi'''

  fg_bestmode, fg_setmode, fg_testmode

*'''Exemples'''

  3-6, 4-4

===fg_bestmode===

*'''Prototype'''

  int fg_bestmode (int horizontales, verticales, int pages int);
   fonction FGbestmode% (horizontal%, vertical%, pages%)
   fonction int fg_bestmode (int horizontal, int vertical, pages int)
   fonction fg_bestmode (horizontale, verticale, pages: Integer): Integer;

*'''But'''

  La routine fg_bestmode détermine le mode vidéo présentant la demande
   résolution et le plus de fonctionnalités pour l'affichage et l'adaptateur de l'utilisateur
   configuration.  Il est semblable à fg_automode, mais il exclut les modes vidéo
   que ne proposent pas les exigences de résolution et page vidéo spécifiées.  le
   pages vidéo peuvent inclure des pages physiques, pages virtuelles, ou les deux.  Dans les modes
   que le soutien des pages virtuelles, fg_bestmode ne vérifie pas si les pages virtuelles
   ont été créés, seulement qu'il y a suffisamment de mémoire conventionnelle disponible
   faire cela.

*'''Paramètres'''

  horizontal spécifie la résolution horizontale requise en pixels.

  vertical spécifie la résolution verticale requise en pixels.

  pages spécifie le nombre requis de pages vidéo physiques ou virtuels.

*'''Valeur de retour'''

  Si fg_bestmode trouve un mode vidéo qui offre la résolution spécifiée, et
   Page exigences vidéo, il renvoie le numéro de mode vidéo correspondant.  Si
   pas, elle renvoie -1.

*'''Restrictions'''

  modes SVGA graphiques (24 à 29) sont disponibles uniquement après avoir réussi
   initialisant le noyau SVGA avec fg_svgainit.

  La routine de fg_bestmode ne considère pas les pages vidéo étendues lors de l'essai
   si le nombre requis de pages vidéo est disponible.

*'''Voir aussi'''

  fg_automode, fg_setmode, fg_svgainit, fg_testmode

*'''Exemples'''

  3-4, 3-7


===fg_box===

*'''Prototype'''

  fg_box void (int minx, maxx int, int Miny, int maxy);
   FGbox sous (minx de%, maxx%, miny%, maxy%)
   sous-programme fg_box (int minx, maxx int, int Miny, int maxy)
   procédure fg_box (minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine de fg_box dessine un rectangle vide dans l'espace de l'écran, avec
   rapport à la zone de découpage.  La largeur des bords du rectangle est une
   pixel à moins changé avec fg_boxdepth.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche du rectangle.

  maxx est la coordonnée X du bord droit du rectangle.  Elle doit être supérieure
   supérieure ou égale à la valeur de minx.

  Miny est la coordonnée y de bord supérieur du rectangle.

  Maxy est la coordonnée y du bord inférieur du rectangle.  Elle doit être supérieure
   supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_boxdepth, fg_boxw, fg_boxx, fg_rect

*'''Exemples'''

  6-12, 8-12, 8-17, 10-17, 10-18, 13-7, 13-8, 13-9


===fg_boxdepth===

*'''Prototype'''

  fg_boxdepth void (int xdepth, int ydepth);
   FGboxdepth sous (xdepth%, ydepth%)
   sous-programme fg_boxdepth (int xdepth, int ydepth)
   procédure fg_boxdepth (xdepth, ydepth: integer);

*'''But'''

  La routine fg_boxdepth définit la profondeur des rectangles dessinés avec la boîte
   les routines d'affichage.  La routine de fg_setmode initialise la boîte de la profondeur à une
   pixels dans chaque direction.

*'''Paramètres'''

  xdepth est la largeur en pixels de côtés gauche et droit du rectangle.  Il
   doit être supérieur à zéro.

  ydepth est la hauteur en pixels des côtés supérieur et inférieur du rectangle.  Il
   doit être supérieur à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_box, fg_boxw, fg_boxx, fg_boxxw

*'''Exemples'''

  6-11, 10-17, 10-18


===fg_boxw===

*'''Prototype'''

  fg_boxw void (double xmin, double xmax, double ymin, double ymax);
   FGboxw sous (xmin de #, xmax #, ymin #, ymax #)
   fg_boxw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
   procédure fg_boxw (xmin, xmax, ymin, ymax: real);

*'''But'''

  La routine de fg_boxw dessine un rectangle vide dans l'espace du monde, avec
   rapport à la zone de découpage.  La largeur des bords du rectangle est une
   pixel à moins changé avec fg_boxdepth.

*'''Paramètres'''

  xmin est l'espace x mondiale coordonnée du bord gauche du rectangle.

  xmax est l'espace x mondiale coordonnée bord droit du rectangle.  Il doit
   soit supérieure ou égale à la valeur de xmin.

  ymin est l'espace du monde y coordonnée du bord inférieur du rectangle.

  ymax est l'espace du monde y coordonnée du bord supérieur du rectangle.  Il doit
   soit supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes vidéo texte et ne sont pas disponibles dans
   Fastgraph / Lumière.

*'''Voir aussi'''

  fg_box, fg_boxdepth, fg_boxxw

===fg_boxx===

*'''Prototype'''

  fg_boxx void (int minx, maxx int, int Miny, int maxy);
   FGboxx sous (minx de%, maxx%, miny%, maxy%)
   sous-programme fg_boxx (int minx, maxx int, int Miny, int maxy)
   procédure fg_boxx (minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine de fg_boxx dessine un rectangle non rempli en mode "ou exclusif" dans
   l'espace de l'écran, par rapport à la zone de découpage.  La largeur de la
   Les bords du rectangle est un pixel à moins changé avec fg_boxdepth.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche du rectangle.

  maxx est la coordonnée X du bord droit du rectangle.  Elle doit être supérieure
   supérieure ou égale à la valeur de minx.

  Miny est la coordonnée y de bord supérieur du rectangle.

  Maxy est la coordonnée y du bord inférieur du rectangle.  Elle doit être supérieure
   supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_box, fg_boxdepth, fg_boxxw

*'''Exemples'''

  6-13

===fg_boxxw===

*'''Prototype'''

  fg_boxxw void (double xmin, double xmax, double ymin, double ymax);
   FGboxxw sous (xmin de #, xmax #, ymin #, ymax #)
   fg_boxxw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
   procédure fg_boxxw (xmin, xmax, ymin, ymax: real);

*'''But'''

  La routine de fg_boxxw dessine un rectangle non rempli en mode "ou exclusif" dans
   l'espace du monde, par rapport à la zone de découpage.  La largeur de la
   Les bords du rectangle est un pixel à moins changé avec fg_boxdepth.

*'''Paramètres'''

  xmin est l'espace x mondiale coordonnée du bord gauche du rectangle.

  xmax est l'espace x mondiale coordonnée bord droit du rectangle.  Il doit
   soit supérieure ou égale à la valeur de xmin.

  ymin est l'espace du monde y coordonnée du bord inférieur du rectangle.

  ymax est l'espace du monde y coordonnée du bord supérieur du rectangle.  Il doit
   soit supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes vidéo texte et ne sont pas disponibles dans
   Fastgraph / Lumière.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_boxdepth, fg_boxw, fg_boxx

===fg_button===

*'''Prototype'''

  int fg_button (int n);
   fonction FGbutton% (n%)
   int fonction fg_button (int n)
   fonction fg_button (n: nombre entier): nombre entier;

*'''But'''

  Les informations fg_button de routine revient sur l'état de soit
   L'état de la touche de joystick.

*'''Paramètres'''

  n indique le numéro de joystick, soit 1 ou 2.

*'''Valeur de retour'''

  Un code d'état indiquant l'état du bouton en cours pour la demande
   joystick, comme indiqué ici:

  0 = aucun bouton pressé
     1 bouton = top pressé
     2 = bouton du bas pressé
     3 = Touches haut et bas pressé

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getxjoy, fg_getyjoy, fg_initjoy, fg_intjoy

*'''Exemples'''

  14-12


===fg_capslock===

*'''Prototype'''

  int fg_capslock (void);
   fonction FGcapslock% ()
   int fonction fg_capslock ()
   fonction fg_capslock: integer;

*'''But'''

  La routine fg_capslock détermine l'état de la touche CapsLock.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Si la valeur de retour est 0, cela signifie que la touche CapsLock est éteint.  Si elle est de 1, il
   signifie que la clé de CapsLock est activée.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_numlock, fg_scrlock, fg_setcaps, fg_setnum

*'''Exemples'''

  14-4


===fg_chgattr===

*'''Prototype'''

  fg_chgattr void (int n);
   FGchgattr sub (n%)
   fg_chgattr sous-programme (int n)
   procédure fg_chgattr (n: integer);

*'''But'''

  La routine fg_chgattr applique l'attribut texte actuel à un nombre donné
   de caractères démarrant à la position du curseur de texte.  Cette feuille de routine
   le texte curseur d'une colonne à droite du dernier caractère modifié (ou
   la première colonne de la rangée suivante si le dernier caractère est à la fin d'un
   rangée).

*'''Paramètres'''

  n est le nombre de caractères pour lequel pour modifier l'attribut de texte.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

  fg_chgtext, fg_locate, fg_text

*'''Exemples'''

  7-3

===fg_chgtext===

*'''Prototype'''

  fg_chgtext void (char * string, int n);
   FGchgtext sub (chaîne de $, n%)
   fg_chgtext sous-programme (chaîne de char, int n)
   procédure fg_chgtext (string: string; n: nombre entier);

*'''But'''

  Les affichages de routine fg_chgtext une chaîne de caractères matériels, à partir
   à la position du curseur de texte, en utilisant les attributs de texte existants.  Ce
   feuilles de routine le texte le curseur d'une colonne à droite de la dernière
   caractère changé (ou la première colonne de la ligne suivante si le dernier
   le caractère est à la fin d'une rangée).

*'''Paramètres'''

  chaîne est la séquence de caractères à afficher arbitraire de longueur.

  n est le nombre de caractères dans la chaîne.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

  fg_chgattr, fg_locate, fg_text

*'''Exemples'''

  7-3


===fg_circle===

*'''Prototype'''

  fg_circle void (int rayon);
   FGcircle sous (rayon%)
   fg_circle sous-programme (int rayon)
   procédure fg_circle (rayon: entier);

*'''But'''

  La routine de fg_circle dessine un cercle vide dans l'espace de l'écran.  Le cercle
   est centrée à la position actuelle du curseur graphique.

*'''Paramètres'''

  rayon définit le rayon du cercle dans horizontales unités de l'espace de l'écran.  Il est
   La valeur doit être supérieure à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_circlef, fg_circlew, fg_ellipse

*'''Exemples'''

  6-10

===fg_circlef===

*'''Prototype'''

  fg_circlef void (int rayon);
   FGcirclef sous (rayon%)
   fg_circlef sous-programme (int rayon)
   procédure fg_circlef (rayon: entier);

*'''But'''

  La routine de fg_circlef dessine un cercle rempli dans l'espace de l'écran.  Le cercle est
   centré sur la position du curseur graphique actuelle et est rempli avec des pixels
   de la couleur actuelle.

*'''Paramètres'''

  rayon définit le rayon du cercle dans horizontales unités de l'espace de l'écran.  Il est
   La valeur doit être supérieure à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_circle, fg_circlefw, fg_ellipsef

===fg_circlefw===

*'''Prototype'''

  fg_circlefw void (double rayon);
   sous FGcirclefw (rayon #)
   fg_circlefw sous-programme (rayon de dbl)
   procédure fg_circlefw (rayon: real);

*'''But'''

  La routine de fg_circlefw dessine un cercle rempli dans l'espace mondial.  Le cercle est
   centré sur la position du curseur graphique actuelle et est rempli avec des pixels
   de la couleur actuelle.

*'''Paramètres'''

  rayon définit le rayon du cercle dans horizontales unités spatiales du monde.  Il est
   La valeur doit être supérieure à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_circlef, fg_circlew, fg_ellipsfw

===fg_circlew===

*'''Prototype'''

  fg_circlew void (double rayon);
   sous FGcirclew (rayon #)
   fg_circlew sous-programme (rayon de dbl)
   procédure fg_circlew (rayon: real);

*'''But'''

  La routine fg_circlew dessine un cercle vide dans l'espace mondial.  Le cercle
   est centrée à la position actuelle du curseur graphique.

*'''Paramètres'''

  rayon définit le rayon du cercle dans horizontales unités spatiales du monde.  Il est
   La valeur doit être supérieure à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_circle, fg_circlefw, fg_ellipsew

*'''Exemples'''

  6-9

===fg_clipmap===

*'''Prototype'''

  fg_clipmap (char * map_array, int largeur, int hauteur);
   FGclipmap sub (map_array de $, largeur%, hauteur%)
   fg_clipmap sous-programme (INT1 map_array, int largeur, int hauteur)
   procédure fg_clipmap (var map_array; largeur, hauteur: integer);

*'''But'''

  La routine fg_clipmap affiche une image stockée en tant que mode indépendant
   bitmap.  L'image sera affichée de telle sorte que son coin inférieur gauche est à la
   graphiques position du curseur.  Seule la partie de l'image qui tombe dans le
   limites d'écrêtage actuelles seront affichées.  Reportez-vous à la Fastgraph l'utilisateur
   Guide pour toutes les infos sur bitmaps en mode indépendant.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

  fg_drawmap, fg_getmap, fg_invert

===fg_clipmask===

*'''Prototype'''

  fg_clipmask void (char * map_array, int runs, int largeur);
   FGclipmask sous (map_array de $, fonctionne%, largeur%)
   sous-programme fg_clipmask (int1 map_array, int exécute, int largeur)
   procédure fg_clipmask (var map_array: octet; pistes, largeur: integer);

*'''But'''

  Les fg_clipmask affiche de routine une image écrêté stockée sous forme de carte de masquage.
   L'image sera positionnée de sorte que son coin inférieur gauche est à la
   graphiques position du curseur.  Reportez-vous à *'''But''' de fg_drawmask pour plus
   le masquage d'informations sur les cartes.

*'''Paramètres'''

  map_array est le nom du tableau contenant la carte de masquage.

  courses est le nombre de pixels courses dans la carte de masquage.

  largeur est la largeur en pixels de la carte de masquage.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_drawmask, fg_flipmask, fg_revmask, fg_setclip

*'''Exemples'''

  10-23

===fg_clpimage===

*'''Prototype'''

  fg_clpimage void (char * map_array, int largeur, int hauteur);
   FGclpimage sub (map_array de $, largeur%, hauteur%)
   fg_clpimage sous-programme (INT1 map_array, int largeur, int hauteur)
   procédure fg_clpimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

  Les affichages de routine fg_clpimage une image écrêté stockée comme un mode spécifique
   bitmap.  L'image sera positionnée de sorte que son coin inférieur gauche est à
   les graphiques position du curseur.  Seule la partie de l'image qui tombe dans
   les limites d'écrêtage actuelles seront affichées.  Reportez-vous à la Fastgraph
   Guide de l'utilisateur pour toutes les infos sur bitmaps spécifiques au mode.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_drwimage, fg_flpimage, fg_getimage, fg_invert, fg_pack, fg_putimage,
   fg_revimage, fg_setclip, fg_unpack

*'''Exemples'''

  10-8, 10-9

===fg_clprect===

*'''Prototype'''

  fg_clprect void (int minx, maxx int, int Miny, int maxy);
   FGclprect sous (minx de%, maxx%, miny%, maxy%)
   sous-programme fg_clprect (int minx, maxx int, int Miny, int maxy)
   procédure fg_clprect (minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine de fg_clprect dessine un solide (rempli) rectangle dans l'espace de l'écran,
   par rapport à la zone de découpage.

*'''Paramètres'''

  minx est l'espace x écran coordonnées du bord gauche du rectangle.

  maxx est l'espace x écran coordonnée du bord droit du rectangle.  Il
   doit être supérieure ou égale à la valeur de minx.

  Miny est l'espace de l'écran coordonnée y du bord supérieur du rectangle.

  Maxy est l'espace de l'écran y coordonnée du bord inférieur du rectangle.  Il
   doit être supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_clprectw, fg_rect, fg_rectw, fg_setclip

*'''Exemples'''

  12-1, 12-2, 12-3, 12-4, 12-6

===fg_clprectw===

*'''Prototype'''

  fg_clprectw void (double xmin, double xmax, double ymin, double ymax);
   FGclprectw sous (xmin de #, xmax #, ymin #, ymax #)
   fg_clprectw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
   procédure fg_clprectw (xmin, xmax, ymin, ymax: real);

*'''But'''

  La routine de fg_clprectw dessine un solide (rempli) rectangle dans l'espace mondial,
   par rapport à la zone de découpage.

*'''Paramètres'''

  xmin est l'espace x mondiale coordonnée du bord gauche du rectangle.

  xmax est l'espace x mondiale coordonnée bord droit du rectangle.  Il doit
   soit supérieure ou égale à la valeur de xmin.

  ymin est l'espace du monde y coordonnée du bord inférieur du rectangle.

  ymax est l'espace du monde y coordonnée du bord supérieur du rectangle.  Il doit
   soit supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_clprect, fg_rect, fg_rectw, fg_setclipw

===fg_colors===

*'''Prototype'''

  int fg_colors (void);
   FGcolors de fonction (%)
   fg_colors fonction int ()
   fg_colors fonction: Integer;

*'''But'''

  Les fg_colors routine renvoie le nombre de couleurs disponibles simultanément
   dans le mode vidéo en cours.  Dans les modes vidéo de texte, le nombre de couleurs sera
   est nul.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le nombre de couleurs disponibles, entre 0 et 256.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setcolor

*'''Exemples'''

  6-1

===fg_copypage===

*'''Prototype'''

  fg_copypage void (int source_page, int dest_page);
  FGcopypage secondaire (source_page de% dest_page%)
  sous-programme fg_copypage (int source_page, int dest_page)
  procédure fg_copypage (source_page, dest_page: integer);

*'''But'''

 Le fg_copypage des transferts de routine le contenu d'une page vidéo à
   un autre. Les pages peuvent être des pages vidéo physiques, virtuels ou logiques.
  En supposant que maxx et maxy représentent le maximum de coordonnées x et y d'une vidéo
  page, l'appel

 fg_copypage (source, dest);

 est équivalent à

 fg_transfer (0, maxx, 0, Maxy, 0, Maxy, source, dest);

*'''Paramètres'''

source_page est le numéro de page de source vidéo. Il doit être compris entre 0 et 63.

dest_page est le numéro de la page vidéo de destination. Il doit être compris entre 0 et
   63.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Si source_page et dest_page fois référence pages logiques, les pages doivent
  exister dans le même type de mémoire. Par exemple, vous ne pouvez pas copier une logique
  page en mémoire étendue à une page logique dans la mémoire conventionnelle.

 La routine de fg_copypage applique toujours les pages vidéo ou des pages logiques,
  même quand un tampon virtuel est actif.

*'''Voir aussi'''

 fg_alloccms, fg_allocems, fg_allocxms, fg_initems, fg_initxms, fg_transfer,
  fg_vbcopy

*'''Exemples'''

 8-8, 8-10, 8-12, 8-13, 11-1

===fg_cursor===

*'''Prototype'''

 fg_cursor void (int state);
  FGcursor sous (état%)
  fg_cursor sous-programme (int state)
  procédure fg_cursor (état: entier);

*'''But'''

 La routine fg_cursor détermine le BIOS ROM curseur de visibilité dans le texte
  modes vidéo. Après avoir appelé fg_setmode, le curseur est rendu visible par
   défaut.

*'''Paramètres'''

Le paramètre d'état définit la visibilité du curseur. Si elle est à 0, le curseur
  devient invisible; si elle est 1, le curseur devient visible.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Exemples'''

 3-1, 3-2, 3-3, 3-4, 3-5, 5-16, 7-1, 7-2, 7-3, 7-4, 8-3, 8-5, 8- 7, 8-12,
  8-17, 10-7, 10-13, 11-2, 11-4, 13-4

===fg_dash===

*'''Prototype'''

 fg_dash void (int ix, iy int, int motif);
  FGdash sous (ix%, iy%, modèle%)
  fg_dash sous-programme (int ix, iy int, int motif)
  procédure fg_dash (ix, iy, motif: entier);

*'''But'''

 La routine de fg_dash dessine une ligne en pointillés de la position du curseur graphiques
  à une position d'espace d'écran absolu. Elle rend également la destination
  positionner la nouvelle position du curseur graphique.

*'''Paramètres'''

 ix est l'espace x écran de coordonnées de la position de destination.

 iy est l'espace de l'écran coordonnée y de la position de destination.

motif représente un motif cyclique dash 16 bits. Les bits qui sont 1 volonté
  résultat dans un pixel en cours d'élaboration; les bits qui sont 0 se traduira par un être de pixel
  sautée.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_dashrel, fg_dashrw, fg_dashw, fg_move

*'''Exemples'''

 6-6

===fg_dashrel===

*'''Prototype'''

 fg_dashrel void (int ix, iy int, int motif);
  FGdashrel sous (ix%, iy%, modèle%)
  fg_dashrel sous-programme (int ix, iy int, int motif)
  procédure fg_dashrel (ix, iy, motif: entier);

*'''But'''

 La routine de fg_dashrel dessine une ligne en pointillés du curseur graphique
  position à une position d'espace de l'écran par rapport à lui.  Il rend également le
  position de destination de la nouvelle position du curseur graphique.

*'''Paramètres'''

 ix est l'espace de l'écran x décalage de la position de destination.

 iy est l'espace de l'écran de décalage de la position de destination y.

motif représente un motif cyclique dash 16 bits. Les bits qui sont 1 volonté
  résultat dans un pixel en cours d'élaboration; les bits qui sont 0 se traduira par un être de pixel
  sautée.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_dash, fg_dashrw, fg_dashw, fg_moverel


===fg_dashrw===

*'''Prototype'''

 fg_dashrw void (double x, double y, int motif);
  FGdashrw sub (x #, y #, modèle%)
  fg_dashrw sous-programme (dbl x, dbl y, int motif)
  procédure fg_dashrw (x, y: real; motif: entier);

*'''But'''

 La routine de fg_dashrw dessine une ligne en pointillés de la position du curseur graphiques
  à une position de l'espace du monde par rapport à lui. Elle rend également la destination
  positionner la nouvelle position du curseur graphique.

*'''Paramètres'''

 x est l'espace mondial x décalage de la position de destination.

 y est égal à l'espace mondial décalage de la position de destination y.

motif représente un motif cyclique dash 16 bits. Les bits qui sont 1 volonté
  résultat dans un pixel en cours d'élaboration; les bits qui sont 0 se traduira par un être de pixel
  sautée.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

*'''Voir aussi'''

 fg_dash, fg_dashrel, fg_dashw, fg_moverw


===fg_dashw===

*'''Prototype'''

 fg_dashw void (double x, double y, int motif);
  FGdashw sub (x #, y #, modèle%)
  fg_dashw sous-programme (dbl x, dbl y, int motif)
  procédure fg_dashw (x, y: real; motif: entier);

*'''But'''

 La routine de fg_dashw dessine une ligne en pointillés de la position du curseur graphiques
  à une position mondiale de l'espace absolu. Il permet également la position de destination
  les nouveaux graphiques la position du curseur.

*'''Paramètres'''

 x est l'espace x mondial de coordonnées de la position de destination.

 y est égal à l'espace mondial coordonnée y de la position de destination.

motif représente un motif cyclique dash 16 bits. Les bits qui sont 1 volonté
  résultat dans un pixel en cours d'élaboration; les bits qui sont 0 se traduira par un être de pixel
  sautée.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

*'''Voir aussi'''

 fg_dash, fg_dashrel, fg_dashrw, fg_movew


===fg_defcolor===

*'''Prototype'''

 fg_defcolor void (int index, valeur int);
  FGdefcolor sous (indice%, valeur%)
  fg_defcolor sous-programme (int index, valeur int)
  procédure fg_defcolor (index, valeur: integer);

*'''But'''

  La routine fg_defcolor attribue une valeur de couleur à un indice de couleur virtuelle.

*'''Paramètres'''

 index est l'index de couleur virtuelle pour définir, entre 0 et 255.

 valeur est la valeur de la couleur à attribuer à l'indice de couleur spécifiée.  Ce doit être
  entre 0 et la valeur maximale de couleur correspondant au mode vidéo en cours.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet dans les modes vidéo de texte ou 256 couleurs graphiques
  modes vidéo.

*'''Voir aussi'''

 fg_getindex, fg_palette, fg_setcolor

*'''Exemples'''

 5-15, 5-16


===fg_defpages===

*'''Prototype'''

 fg_defpages void (int source_page, int dest_page);
  sous FGdefpages (source_page% dest_page%)
  fg_defpages de sous-programme (int source_page, int dest_page)
  fg_defpages procédure (de source_page, dest_page: integer);

*'''But'''

 La routine fg_defpages définit les banques SVGA pour la source et
  les numéros de page de destination lors de l'utilisation des routines de transfert de bloc de Fastgraph
  avec des pages vidéo étendues.

*'''Paramètres'''

 source_page est la page de la vidéo à partir duquel récupérer le bloc.

 dest_page est la page de la vidéo à laquelle le bloc est copié.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine est significative seulement dans EGA standard, VGA et XVGA graphiques
  modes (modes 13 à 18 et 20 à 23) pour les chipsets SVGA support étendu
  pages vidéo.

*'''Voir aussi'''

 fg_copypage, fg_restore, fg_save, fg_svgainit, fg_svgastat, fg_tcxfer,
  fg_transfer

*'''Exemples'''

 8-8


===fg_dispfile===

*'''Prototype'''

 fg_dispfile void (char * filename, int largeur, format int);
  FGdispfile sous (nom de fichier de $, largeur%, le format%)
  fg_dispfile sous-programme (char filename, int largeur, format int)
  procédure fg_dispfile (filename: string; largeur, format: integer);

*'''But'''

 Les affichages de routine fg_dispfile une image stockée dans une norme ou emballés
  pixel fichier exécuté. L'image sera positionnée de sorte que son coin inférieur gauche
  est à la position graphique du curseur sur la page vidéo active ou virtuelle
   tampon. Reportez-vous aux descriptions de fg_display et fg_displayp pour plus
  informations sur les deux formats pixel d'exécution.

*'''Paramètres'''

 filename est le nom du fichier PPR ou SPR.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
  caractère nul (soit un octet nul).

largeur est la largeur de l'image en pixels. Il doit être supérieur à zéro.

format spécifie le format d'image. La valeur du format doit être 0 si la
  l'image est au format pixel d'exécution standard, et 1 si l'image est en comble
  pixel Format exécuté.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_display, fg_displayp, fg_imagebuf, fg_pattern, fg_showppr, fg_showspr

*'''Exemples'''

 9-10


===fg_display===

*'''Prototype'''

 fg_display void (char * map_array, int runs, int largeur);
  FGdisplay sous (map_array de $, fonctionne%, largeur%)
  sous-programme fg_display (int1 map_array, int exécute, int largeur)
  procédure fg_display (var map_array: octet; pistes, largeur: integer);

*'''But'''

 La routine fg_display affiche une image stockée dans la norme Fastgraph
  pixel le format géré, où l'image se trouve dans un tableau. L'image sera
  positionné de telle sorte que son coin inférieur gauche est au niveau du curseur graphique
   position.

*'''Paramètres'''

map_array est le nom du tableau contenant la carte pixel de l'exécution. le pixel
  pistes sont représentées par (couleur, nombre) paires, comme indiqué ici:

 [0] couleur pour la course 1

 [1] compter pour la course 1

 [2] la couleur pour la course 2

 [3] compter pour la course 2

  .
                                          .
                                          .

 [2n-2] couleur pour la course n

 [2n-1] compter pour la course n

 Chaque élément "de couleur" est une valeur entre 0 et 255 indiquant la couleur
  index pour ce pixel terme. Chaque élément «de comptage» est une valeur comprise entre 0 et 255
  spécifiant la longueur en pixels de ce pixel terme.

 courses est le nombre de pixel court à afficher à partir de la carte pixel de l'exécution.  C'est
  normalement une moitié de la taille de la matrice de map_array.

largeur est la largeur de l'image en pixels. Il doit être supérieur à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_dispfile, fg_displayp, fg_pattern, fg_showspr

*'''Exemples'''

 10-20, 10-22

===fg_displayp===

*'''Prototype'''

 fg_displayp void (char * map_array, int runs, int largeur);
  FGdisplayp sous (map_array de $, fonctionne%, largeur%)
  sous-programme fg_displayp (int1 map_array, int exécute, int largeur)
  procédure fg_displayp (var map_array: octet; pistes, largeur: integer);

*'''But'''

 La routine fg_displayp affiche une image stockée dans Fastgraph est emballé
  pixel le format géré, où l'image se trouve dans un tableau. L'image sera
  positionné de telle sorte que son coin inférieur gauche est au niveau du curseur graphique
   position.

*'''Paramètres'''

map_array est le nom du tableau contenant la carte pixel de l'exécution. le pixel
  pistes sont représentées par (couleur, nombre) paires, comme indiqué ici:
                        7 4 3 0

 [0] couleur pour la course 1 couleur pour la course 2

 [1] compter pour la course 1

 [2] compter pour l'exécution 2

 [3] la couleur pour la course 3 couleurs pour la course 4

 [4] compter pour la course 3

 [5] compter pour l'exécution 4

  .
                                           .
                                           .

 [3n / 2-3] couleur pour la course n-1 couleur pour la course n

 [3n / 2-2] compter pour la course n-1

 [3n / 2-1] compter pour la course n

 Chaque élément "de couleur" est une valeur comprise entre 0 et 15 spécifiant l'index de couleur
  pour ce pixel terme. Chaque élément «de comptage» est une valeur comprise entre 0 et 255
  spécifiant la longueur en pixels de ce pixel terme.

 courses est le nombre de pixel court à afficher à partir de la carte pixel de l'exécution.  C'est
  normalement les deux tiers de la taille de la matrice de map_array.

largeur est la largeur de l'image en pixels. Il doit être supérieur à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_dispfile, fg_display, fg_pattern, fg_showppr

*'''Exemples'''

 10-21, 10-22

===fg_draw===

*'''Prototype'''

 fg_draw void (int ix, iy int);
  Sous FGdraw (ix% iy%)
  fg_draw sous-programme (int ix, iy int)
  procédure fg_draw (ix, iy: integer);

*'''But'''

 La routine de fg_draw dessine une ligne solide à partir de la position graphique du curseur
  une position d'espace d'écran absolu. Il permet également la position de destination
  les nouveaux graphiques la position du curseur.

*'''Paramètres'''

 ix est l'espace x écran de coordonnées de la position de destination.

 iy est l'espace de l'écran coordonnée y de la position de destination.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_drawrel, fg_draww, fg_drawx, fg_move

*'''Exemples'''

 6-2, 6-5, 13-5, 13-6

===fg_drawmap===

*'''Prototype'''

 fg_drawmap void (char * map_array, int largeur, int hauteur);
  FGdrawmap sub (map_array de $, largeur%, hauteur%)
  fg_drawmap sous-programme (INT1 map_array, int largeur, int hauteur)
  procédure fg_drawmap (var map_array: octet; largeur, hauteur: integer);

*'''But'''

 La routine fg_drawmap affiche une image stockée en tant que mode indépendant
  bitmap. L'image sera positionnée de sorte que son coin inférieur gauche est à
   les graphiques position du curseur. Reportez-vous au Guide de l'utilisateur Fastgraph pour
  toutes les infos sur bitmaps en mode indépendant.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap. Chaque octet
  map_array représente huit pixels. Les bits qui sont fixés (1) dans le résultat
  pixel correspondant affiché dans la couleur actuelle. Les bits qui sont
  reset (0) laisser le pixel correspondant inchangé.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

 fg_clipmap, fg_drwimage, fg_getmap, fg_invert

*'''Exemples'''

 10-1, 10-2, 10-10, 10-11


===fg_drawmask===

*'''Prototype'''

 fg_drawmask void (char * map_array, int runs, int largeur);
  FGdrawmask sous (map_array de $, fonctionne%, largeur%)
  sous-programme fg_drawmask (int1 map_array, int exécute, int largeur)
  procédure fg_drawmask (var map_array: octet; pistes, largeur: integer);

*'''But'''

 La routine fg_drawmask affiche une image stockée sous forme de carte de masquage.  le
  image sera positionnée de sorte que son coin inférieur gauche est aux graphiques
   la position du curseur. Reportez-vous au Guide de l'utilisateur Fastgraph pour une complète
  discussion des cartes de masquage.

*'''Paramètres'''

map_array est le nom du tableau contenant la carte de masquage. le masquage
  la carte est une série d'une alternance de "protection" et "zéro" pixel pistes, comme le montre
   ici:


 [1] longueur de 1ère manche de protection

 [2] longueur du 1er zéro run

 [3] longueur du 2ème manche de protection

 [4] longueur de 2ème manche zéro

  .
                                          .
                                          .

 [N-2] longueur de course finale de protection

 [N-1] longueur de course finale zéro


 Les pistes "protéger" protéger la mémoire vidéo, tandis que le "zéro" exécute vidéo zéro
  la mémoire (qui est, définissez les pixels à la couleur d'arrière-plan).  La longueur de
  chaque essai doit être comprise entre 0 et 255.

 courses est le nombre de pixels courses dans la carte de masquage.

 largeur est la largeur en pixels de la carte de masquage.

*'''Valeur de retour'''

  aucun


*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_clipmask, fg_flipmask, fg_revmask

*'''Exemples'''

 23/10, 24/10

===fg_drawrel===

*'''Prototype'''

 fg_drawrel void (int ix, iy int);
  FGdrawrel sous (ix%, iy%)
  fg_drawrel sous-programme (int ix, iy int)
  procédure fg_drawrel (ix, iy: integer);

*'''But'''

 La routine de fg_drawrel dessine une ligne solide à partir de la position du curseur graphiques
  à une position d'espace de l'écran par rapport à lui. Elle rend également la destination
  positionner la nouvelle position du curseur graphique.

*'''Paramètres'''

 ix est l'espace de l'écran x décalage de la position de destination.

 iy est l'espace de l'écran de décalage de la position de destination y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_draw, fg_drawrelx, fg_drawrw, fg_moverel

*'''Exemples'''

 6-3, 6-17

===fg_drawrelx===

*'''Prototype'''

 fg_drawrelx void (int ix, iy int);
  sous FGdrawrelx (ix% iy%)
  fg_drawrelx sous-programme (int ix, iy int)
  procédure fg_drawrelx (ix, iy: integer);

*'''But'''

   La routine fg_drawrelx dessine une ligne continue en mode "ou exclusif" à la position graphique du curseur vers une position d'espace de l'écran par rapport à lui.  La position de destination devient la nouvelle position du curseur graphique. 

*'''Paramètres'''

  ix est l'espace de l'écran x décalage de la position de destination.

  iy est l'espace de l'écran de décalage de la position de destination y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_drawrel, fg_drawrxw, fg_drawx, fg_moverel

===fg_drawrw===

*'''Prototype'''

   fg_drawrw void (double x, double y);
   sous FGdrawrw (x #, y #)
   fg_drawrw sous-programme (dbl x, dbl y)
   procédure fg_drawrw (x, y: real);

*'''But'''

La routine de fg_drawrw dessine une ligne solide à partir de la position du curseur graphiques
à une position de l'espace du monde par rapport à lui.  Elle rend également la destination
positionner la nouvelle position du curseur graphique.

*'''Paramètres'''

*  x est l'espace mondial x décalage de la position de destination.
*  y est égal à l'espace mondial décalage de la position de destination y.

*'''Valeur de retour'''

aucun

*'''Restrictions'''

Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet en mode texte.

*'''Voir aussi'''

fg_drawrel, fg_drawrxw, fg_draww, fg_moverw

===fg_drawrxw===

*'''Prototype'''

  fg_drawrxw void (double x, double y);
   FGdrawrxw sub (x #, y #)
   fg_drawrxw sous-programme (dbl x, dbl y)
   procédure fg_drawrxw (x, y: real);

*'''But'''

  La routine de fg_drawrxw dessine une ligne solide en mode "ou exclusif" de la
   la position du curseur graphique à une position de l'espace du monde par rapport à lui.  Ça aussi
   qui rend la position de destination de la nouvelle position du curseur graphique.

*'''Paramètres'''

  x est l'espace mondial x décalage de la position de destination.

  y est égal à l'espace mondial décalage de la position de destination y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_drawrelx, fg_drawrw, fg_drawxw, fg_moverw

===fg_draww===

*'''Prototype'''

  fg_draww void (double x, double y);
   sous FGdraww (x #, y #)
   fg_draww sous-programme (dbl x, dbl y)
   procédure fg_draww (x, y: real);

*'''But'''

  La routine de fg_draww dessine une ligne solide à partir de la position du curseur graphiques
   à une position mondiale de l'espace absolu.  Il permet également la position de destination
   les nouveaux graphiques la position du curseur.

*'''Paramètres'''

  x est l'espace x mondial de coordonnées de la position de destination.

  y est égal à l'espace mondial coordonnée y de la position de destination.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_draw, fg_drawrw, fg_drawxw, fg_movew

*'''Exemples'''

  4-4, 6-4


===fg_drawx===

*'''Prototype'''

  fg_drawx void (int ix, iy int);
   Sous FGdrawx (ix% iy%)
   fg_drawx sous-programme (int ix, iy int)
   procédure fg_drawx (ix, iy: integer);

*'''But'''

  La routine de fg_drawx dessine une ligne solide en mode "ou exclusif" de la
   graphiques position du curseur à une position d'espace d'écran absolu.  Ça aussi
   qui rend la position de destination de la nouvelle position du curseur graphique.

*'''Paramètres'''

  ix est l'espace x écran de coordonnées de la position de destination.

  iy est l'espace de l'écran coordonnée y de la position de destination.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_draw, fg_drawrelx, fg_drawxw, fg_move


===fg_drawxw===

*'''Prototype'''

  fg_drawxw void (double x, double y);
   FGdrawxw sub (x #, y #)
   fg_drawxw sous-programme (dbl x, dbl y)
   procédure fg_drawxw (x, y: real);

*'''But'''

  La routine de fg_drawxw dessine une ligne solide en mode "ou exclusif" de la
   graphiques position du curseur à une position mondiale de l'espace absolu.  Il fait également
   la destination positionner la nouvelle position du curseur graphique.

*'''Paramètres'''

  x est l'espace x mondial de coordonnées de la position de destination.

  y est égal à l'espace mondial coordonnée y de la position de destination.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

  Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
   est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

  fg_drawrxw, fg_draww, fg_drawx, fg_movew


===fg_drect===

*'''Prototype'''

  fg_drect void (int minx, maxx int, int Miny, int maxy, char * matrice);
   FGdrect sous (minx de%, maxx%, miny%, maxy%, matrice $)
   sous-programme fg_drect (int minx, maxx int, int Miny, int maxy, int1 matrice)
   procédure fg_drect (minx, maxx, Miny, Maxy: integer; var matrix: byte);

*'''But'''

  La routine de fg_drect dessine un rectangle tramé dans l'espace de l'écran, sans
   ce qui concerne la zone de découpage.

*'''Paramètres'''

  minx est l'espace x écran coordonnées du bord gauche du rectangle.

  maxx est l'espace x écran coordonnée du bord droit du rectangle.  Il
   doit être supérieure ou égale à la valeur de minx.

  Miny est l'espace de l'écran coordonnée y du bord supérieur du rectangle.

  Maxy est l'espace de l'écran y coordonnée du bord inférieur du rectangle.  Il
   doit être supérieure ou égale à la valeur de miny.

  matrice est un tableau à quatre éléments (un tableau de huit éléments en 256 couleurs
   modes graphiques) qui définit la matrice de tramage.  Le format de la
   tramage matricielle dépend du mode vidéo;  reportez-vous à la Fastgraph
   Guide de l'utilisateur pour plus d'informations.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_drectw, fg_rect

*'''Exemples'''

  6-14, 6-15, 6-16


===fg_drectw===

*'''Prototype'''

  fg_drectw void (double-xmin, double xmax, double ymin, double ymax,
     char * matrice);
   FGdrectw sous (xmin de #, xmax #, ymin #, ymax #, matrice $)
   fg_drectw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax, matrice int1)
   procédure fg_drectw (xmin, xmax, ymin, ymax: real; var matrix: byte);

*'''But'''

  La routine de fg_drectw dessine un rectangle tramé dans l'espace mondial, sans
   ce qui concerne la zone de découpage.

*'''Paramètres'''

  xmin est l'espace x mondiale coordonnée du bord gauche du rectangle.

  xmax est l'espace x mondiale coordonnée bord droit du rectangle.  Il doit
   soit supérieure ou égale à la valeur de xmin.

  ymin est l'espace du monde y coordonnée du bord inférieur du rectangle.

  ymax est l'espace du monde y coordonnée du bord supérieur du rectangle.  Il doit
   soit supérieure ou égale à la valeur de ymin.

  matrice est un tableau à quatre éléments (un tableau de huit éléments en 256 couleurs
   modes graphiques) qui définit la matrice de tramage.  Le format de la
   tramage matricielle dépend du mode vidéo;  reportez-vous à la Fastgraph
   Guide de l'utilisateur pour plus d'informations.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_drect, fg_rectw


===fg_drwimage===

*'''Prototype'''

  fg_drwimage void (char * map_array, int largeur, int hauteur);
   FGdrwimage sub (map_array de $, largeur%, hauteur%)
   fg_drwimage sous-programme (INT1 map_array, int largeur, int hauteur)
   procédure fg_drwimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

  La routine fg_drwimage affiche une image stockée sous forme de bitmap mode spécifique.
   L'image sera positionnée de sorte que son coin inférieur gauche est à la
   Position graphique du curseur (ou la position du curseur de texte en mode texte vidéo).
   Reportez-vous au Guide de l'utilisateur Fastgraph pour toutes les infos sur mode-
   bitmaps spécifiques.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

  fg_clpimage, fg_flpimage, fg_getimage, fg_invert, fg_pack, fg_putimage,
   fg_revimage, fg_unpack

*'''Exemples'''

  10-3, 10-4, 10-5, 10-6, 10-7, 10-8, 10-9, 10-12, 10-13, 10-14, 10-15,
   10-16, 10-24


===fg_egacheck===

*'''Prototype'''

  int fg_egacheck (void);
   fonction FGegacheck% ()
   int fonction fg_egacheck ()
   fonction fg_egacheck: integer;

*'''But'''

  Les informations fg_egacheck des retours de routine à propos de l'adaptateur EGA actif
   et l'affichage (ou les capacités d'émulation EGA d'un VGA).  Il est utile dans
   vérifier si la carte a suffisamment de mémoire pour exécuter un programme.  Cette fonction
   reste dans Fastgraph à des fins de compatibilité;  il a été remplacé par
   fg_testmode.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La routine fg_egacheck renvoie une valeur de 0 si un EGA ne se trouve pas, ou si
   un EGA sans écran couleur Enhanced (ECD) est détecté.  Autrement,
   fg_egacheck renvoie un nombre entier positif indiquant le nombre de 64K octets
   incréments de mémoire vidéo sur le EGA, que résumées ci-dessous.

  1 = EGA avec mémoire vidéo 64K
     2 = EGA avec de la mémoire 128K vidéo
     3 = EGA avec de la mémoire 192K vidéo
     4 = EGA avec de la mémoire 256K vidéo

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_testmode

===fg_ellipse===

*'''Prototype'''

  fg_ellipse void (int horiz, int vert);
   FGellipse sub (horiz%, vert%)
   fg_ellipse sous-programme (int horiz, int vert)
   procédure fg_ellipse (horiz, vert: entier);

*'''But'''

  La routine de fg_ellipse dessine une ellipse non remplie dans l'espace de l'écran.  le
   ellipse est centrée à la position actuelle du curseur graphique, et sa taille
   est déterminée par les longueurs déterminées de ses demi-axes.

*'''Paramètres'''

  horiz est la longueur du demi-axe horizontal de l'ellipse (absolu
   distance de l'espace de l'écran à partir du centre de l'ellipse à son horizontale
   extrémité).

  vert est la longueur du demi-axe vertical de l'ellipse (l'écran absolue
   la distance spatiale du centre de l'ellipse à son extrémité verticale).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_circle, fg_ellipsef, fg_ellipsew

*'''Exemples'''

  6-10, 12-4, 12-5, 12-6


===fg_ellipsef===

*'''Prototype'''

  fg_ellipsef void (int horiz, int vert);
   FGellipsef sub (horiz%, vert%)
   fg_ellipsef sous-programme (int horiz, int vert)
   procédure fg_ellipsef (horiz, vert: entier);

*'''But'''

  La routine de fg_ellipsef dessine une ellipse remplie dans l'espace de l'écran.  l'ellipse
   est centré sur la position actuelle du curseur graphique, et sa taille est
   déterminée par les longueurs déterminées de ses demi-axes.  L'ellipse est remplie
   avec des pixels de la couleur actuelle.

*'''Paramètres'''

  horiz est la longueur du demi-axe horizontal de l'ellipse (absolu
   distance de l'espace de l'écran à partir du centre de l'ellipse à son horizontale
   extrémité).

  vert est la longueur du demi-axe vertical de l'ellipse (l'écran absolue
   la distance spatiale du centre de l'ellipse à son extrémité verticale).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_circlef, fg_ellipse, fg_ellipsfw


===fg_ellipsew===

*'''Prototype'''

  fg_ellipsew void (double horiz, double vert);
   FGellipsew sub (horiz #, vert #)
   sous-programme fg_ellipsew (dbl horiz, dbl vert)
   procédure fg_ellipsew (horiz, vert: real);

*'''But'''

  La routine fg_ellipsew dessine une ellipse non remplie dans l'espace mondial.  le
   ellipse est centrée à la position actuelle du curseur graphique, et sa taille
   est déterminée par les longueurs déterminées de ses demi-axes.

*'''Paramètres'''

  horiz définit les demi-axe horizontal de l'ellipse (le monde absolu
   la distance spatiale du centre de l'ellipse à son extrémité horizontale).

  vert définit le demi-axe vertical de l'ellipse (le monde absolu
   la distance spatiale du centre de l'ellipse à son extrémité verticale).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_circlew, fg_ellipse, fg_ellipsfw

*'''Exemples'''

  6-9

===fg_ellipsfw===

*'''Prototype'''

  fg_ellipsfw void (double horiz, double vert);
   FGellipsfw sub (horiz #, vert #)
   sous-programme fg_ellipsfw (dbl horiz, dbl vert)
   procédure fg_ellipsfw (horiz, vert: real);

*'''But'''

  La routine de fg_ellipsfw dessine une ellipse remplie dans l'espace mondial.  l'ellipse
   est centré sur la position actuelle du curseur graphique, et sa taille est
   déterminée par les longueurs déterminées de ses demi-axes.  L'ellipse est remplie
   avec des pixels de la couleur actuelle.

*'''Paramètres'''

  horiz définit les demi-axe horizontal de l'ellipse (le monde absolu
   la distance spatiale du centre de l'ellipse à son extrémité horizontale).

  vert définit le demi-axe vertical de l'ellipse (le monde absolu
   la distance spatiale du centre de l'ellipse à son extrémité verticale).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_circlefw, fg_ellipsew


===fg_erase===

*'''Prototype'''

  fg_erase void (void);
   FGerase sub ()
   sous-routine fg_erase ()
   procédure fg_erase;

*'''But'''

  La routine fg_erase efface la page vidéo active ou tampon virtuel.  Dans
   modes de texte, les magasins de fg_erase un caractère d'espace (ASCII 32) avec un gris
   attribut de premier plan dans chaque cellule de caractère.  Dans les modes graphiques, fg_erase
   définit chaque pixel à zéro.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_fillpage, fg_reset

*'''Exemples'''

  4-4, 8-10, 8-11, 8-13, 9-10, 10-22, 11-1


===fg_fadein===

*'''Prototype'''

  fg_fadein void (int de retard);
   sous FGfadein (delay%)
   fg_fadein sous-programme (int retard)
   procédure fg_fadein (délai: entier);

*'''But'''

  La routine de fg_fadein remplace le contenu des pages visuelles avec le caché
   contenu de la page.  Le remplacement est fait au hasard dans les petites sections, ainsi
   donnant un "fade in" effet.

*'''Paramètres'''

  retard contrôle la vitesse à laquelle le remplacement a lieu.  Une valeur de
   zéro signifie pour effectuer le remplacement le plus rapidement possible, alors que 1 est
   légèrement plus lente, la figure 2 est plus lente encore, et ainsi de suite.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

  La routine de fg_fadein applique toujours les pages vidéo, même lorsqu'un virtuel
   tampon est actif.

*'''Voir aussi'''

  fg_fadeout, fg_sethpage

*'''Exemples'''

  13-2


===fg_fadeout===

*'''Prototype'''

  fg_fadeout void (int de retard);
   FGfadeout sous (délai%)
   fg_fadeout sous-programme (int retard)
   procédure fg_fadeout (délai: entier);

*'''But'''

  La routine de fg_fadeout remplace le contenu des pages visuelles avec des pixels de la
   couleur actuelle.  Le remplacement est fait au hasard dans les petites sections, ainsi
   donnant un effet "fade out".

*'''Paramètres'''

  retard contrôle la vitesse à laquelle le remplacement a lieu.  Une valeur de
   zéro signifie pour effectuer le remplacement le plus rapidement possible, alors que 1 est
   légèrement plus lente, la figure 2 est plus lente encore, et ainsi de suite.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

  La routine de fg_fadeout applique toujours les pages vidéo, même lorsqu'un virtuel
   tampon est actif.

*'''Voir aussi'''

  fg_fadein, fg_setcolor

*'''Exemples'''

  13-1

===fg_fillpage===

*'''Prototype'''

  fg_fillpage void (void);
   FGfillpage sub ()
   sous-routine fg_fillpage ()
   procédure fg_fillpage;

*'''But'''

  La routine de fg_fillpage remplit la page vidéo active ou tampon virtuel.  Dans
   modes de texte, il stocke un caractère de bloc solide (ASCII 219) avec le courant
   attribut d'affichage dans chaque cellule de caractère.  Dans les modes graphiques, fg_fillpage
   remplit la page vidéo active ou tampon virtuel avec des pixels du courant
   Couleur.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_erase, fg_setcolor, fg_setattr

*'''Exemples'''

  7-6, 7-8, 8-8, 8-12, 8-16, 8-17, 10-8, 10-9, 10-15, 10-16, 13-8, 13-9


===fg_findpage===

*'''Prototype'''

  int fg_findpage (void)
   fonction FGfindpage% ()
   int fonction fg_findpage ()
   fonction fg_findpage: integer;

*'''But'''

  La routine de fg_findpage trouve un nombre disponible Page vidéo pour un virtuel
   ou d'une page logique.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  En cas de succès, fg_findpage renvoie un numéro de page vidéo disponibles (entre
   1 et 63), qui peut ensuite être transmis à fg_allocate, fg_alloccms,
   fg_allocems ou fg_allocxms.  En cas d'échec, la valeur de retour est nulle.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_allocate, fg_alloccms, fg_allocems, fg_allocxms

*'''Exemples'''

  8-9, 8-10, 8-12

===fg_flicdone===

*'''Prototype'''

  fg_flicdone void (* contexte de char);
   FGflicdone sous (contexte $)
   fg_flicdone sous-programme (contexte int1)
   procédure fg_flicdone (contexte var);

*'''But'''

  La routine de fg_flicdone ferme le fichier flac associé à l'indication
   contexte descripteur.

*'''Paramètres'''

  contexte est le nom d'un tampon de 16 octets contenant le contexte de fichier flac
   descripteur.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flicopen

*'''Exemples'''

  9-8

===fg_flichead===

*'''Prototype'''

  int fg_flichead (char * flic_file, char * flic_header);
   fonction FGflichead% (flic_file $, flic_header $)
   int fonction fg_flichead (char flic_file, flic_header int1)
   fonction fg_flichead (flic_file: string; var flic_header): integer;

*'''But'''

  La routine de fg_flichead lit un FLI ou en-tête de fichier FLC.

*'''Paramètres'''

  flic_file est le nom du fichier FLI / FLC, terminé par un octet nul.

  flic_header est le nom de la mémoire tampon pour recevoir le 128-byte fichier FLI / FLC
   entête.  En BASIC, il doit être une longueur fixe chaîne de 128 octets.

*'''Valeur de retour'''

  0 = Succès
   -1 = Le fichier spécifié n'existe pas
   -2 = Le fichier spécifié est pas un FLI ou d'un fichier FLC

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flicmode, fg_flicplay, fg_flicsize, fg_showflic

*'''Exemples'''

  9-7

===fg_flicmode===

*'''Prototype'''

  int fg_flicmode (char * flic_header);
   fonction FGflicmode% (flic_header $)
   fonction int fg_flicmode (int1 flic_header)
   fonction fg_flicmode (var flic_header): integer;

*'''But'''

  La routine fg_flicmode détermine le mode vidéo optimal pour le FLI ou
   l'image FLC associée à l'en-tête de fichier flac spécifié.  Le mode optimal
   est le mode 256 couleurs graphiques ayant la plus basse résolution supérieure ou
   égales aux dimensions de l'image.

*'''Paramètres'''

  flic_header est le nom de la mémoire tampon contenant 128 octets fichier FLI / FLC
   entête.

*'''Valeur de retour'''

  > 0 = Le mode vidéo optimal pour afficher l'image FLI / FLC
   -1 = Le tampon de flic_header ne contient pas un en-tête de fichier flac valide

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flichead, fg_showflic

*'''Exemples'''

  9-7

===fg_flicopen===

*'''Prototype'''

  int fg_flicopen (char * flic_file, char contexte *);
   fonction FGflicopen% (flic_file $, le contexte $)
   int fonction fg_flicopen (char flic_file, contexte int1)
   fonction fg_flicopen (flic_file: string; contexte var): integer;

*'''But'''

  La routine fg_flicopen ouvre un FLI ou d'un fichier FLC (collectivement appelés FLIC
   fichiers) pour un traitement ultérieur par un autre fichier flac de bas niveau de Fastgraph
   routines de support.  En cas de succès, le pointeur de fichier sera positionné à la
   au début de la première image.

*'''Paramètres'''

  flic_file est le nom du fichier flac.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  contexte est le nom d'un tampon de 16 octets qui recevra le fichier flac
   contexte descripteur.  Les valeurs de descripteurs ne seront significatifs si la
   valeur de retour est nulle.

*'''Valeur de retour'''

  0 = FLI fichier / FLC a ouvert avec succès
   -1 = Le fichier spécifié n'existe pas
   -2 = Le fichier spécifié est pas un FLI ou d'un fichier FLC

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flicdone, fg_flicplay, fg_flicskip, fg_showflic

*'''Exemples'''

  9-8


===fg_flicplay===

*'''Prototype'''

  int fg_flicplay (char * contexte, int cadres, int flags);
   fonction FGflicplay% (contexte $, cadres%, drapeaux%)
   fonction int fg_flicplay (contexte de int1, int cadres, int flags)
   fonction fg_flicplay (contexte var, cadres, drapeaux: entier): nombre entier;

*'''But'''

  La routine fg_flicplay affiche les prochains un ou plusieurs cadres individuels
   un fichier flac qui a été précédemment ouvert avec fg_flicopen.

*'''Paramètres'''

  contexte est le nom d'un tampon de 16 octets contenant le contexte de fichier flac
   descripteur.

  cadres est le nombre d'images à afficher à partir du fichier flac, à partir de
   la position actuelle du fichier.

  flags est un masque de bits qui contrôle la façon dont l'image est affichée.
     bit 0
        0 = retard entre les images comme indiqué dans l'entête FLIC
        1 = pas de retard entre les images
     bit 1
        0 = affichage image par rapport à l'origine de l'écran
        la position graphique actuelle par rapport 1 = image d'affichage
     bit 2
        0 = image d'affichage à partir du fichier spécifié FLIC
        1 = image d'affichage depuis la mémoire tampon de fg_imagebuf
     Bits 3-15 sont réservés pour une utilisation future et devrait être nul.

*'''Valeur de retour'''

  Le nombre d'images affichées.  Cette valeur peut être inférieure à trames si la
   fin de fichier est atteinte avant d'afficher le nombre requis de cadres.

*'''Restrictions'''

  fichiers Flic ne sont significatives que dans les modes graphiques 256 couleurs.  Cette routine
   n'a pas d'effet dans d'autres modes vidéo.

*'''Voir aussi'''

  fg_flicopen, fg_flicskip, fg_showflic

*'''Exemples'''

  9-8

===fg_flicsize===

*'''Prototype'''

  fg_flicsize void (char * flic_header, int * largeur, int * hauteur);
   FGflicsize sub (flic_header de $, largeur%, hauteur%)
   fg_flicsize sous-programme (INT1 flic_header, int largeur, int hauteur)
   procédure fg_flicsize (var flic_header; var largeur, hauteur: entier);

*'''But'''

  La routine fg_flicsize renvoie les dimensions de l'image FLIC
   associé à l'en-tête de fichier flac spécifié.

*'''Paramètres'''

  flic_header est le nom de la mémoire tampon contenant 128 octets fichier FLI / FLC
   entête.

  largeur reçoit la largeur en pixels de l'image flac.  Si flic_header ne
   contient pas un en-tête de fichier FLI / FLC valide, la largeur sera réglé sur -1.

  hauteur reçoit la hauteur en pixels de l'image flac.  Si flic_header ne
   contient pas un en-tête de fichier FLI / FLC valide, la hauteur sera fixée à -1.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flichead, fg_showflic

*'''Exemples'''

  9-7

===fg_flicskip===

*'''Prototype'''

  int fg_flicskip (char * contexte, int cadres);
   fonction FGflicskip% (contexte $, cadres%)
   fonction int fg_flicskip (contexte de int1, cadres int)
   fonction fg_flicskip (contexte var; cadres: nombre entier): nombre entier;

*'''But'''

  La routine de fg_flicskip avance un ou plusieurs cadres dans un fichier flac qui était
   précédemment ouvert avec fg_flicopen.  Si la dernière image jouée par fg_flicplay
   affiche le cadre de la mémoire tampon de fg_imagebuf, la position du cadre sera
   ajustés dans le tampon de fg_imagebuf.  Dans le cas contraire, la position du fichier flac
   lui-même sera ajusté.

*'''Paramètres'''

  contexte est le nom d'un tampon de 16 octets contenant le contexte de fichier flac
   descripteur.

  cadres est le nombre d'images pour sauter dans le fichier flac, à partir de la
   position de fichier en cours.  Si des cadres est négatif, la position de fichier flac sera
   être réglé sur la première image.

*'''Valeur de retour'''

  Le nombre d'images sautées.  Cette valeur peut être inférieure à trames si la
   fin de fichier est atteinte avant de sauter le nombre requis de cadres.  Si
   cadres est négatif, la valeur de retour sera zéro.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_flicopen, fg_flicplay


===fg_flipmask===

*'''Prototype'''

  fg_flipmask void (char * map_array, int runs, int largeur);
   FGflipmask sous (map_array de $, fonctionne%, largeur%)
   sous-programme fg_flipmask (int1 map_array, int exécute, int largeur)
   procédure fg_flipmask (var map_array: octet; pistes, largeur: integer);

*'''But'''

  Les fg_flipmask affiche de routine une image écrêté inversée stockée en tant que
   masquer la carte.  L'image sera positionnée de sorte que son coin inférieur gauche est
   à la position du curseur graphique.  Reportez-vous à *'''But''' de fg_drawmask
   pour plus d'informations sur le masquage des cartes.

*'''Paramètres'''

  map_array est le nom du tableau contenant la carte de masquage.

  courses est le nombre de pixels courses dans la carte de masquage.

  largeur est la largeur en pixels de la carte de masquage.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_clipmask, fg_drawmask, fg_revmask, fg_setclip

*'''Exemples'''

  10-23


===fg_flood===

*'''Prototype'''

  fg_flood void (int ix, iy int);
   Sous FGflood (ix% iy%)
   fg_flood sous-programme (int ix, iy int)
   procédure fg_flood (ix, iy: integer);

*'''But'''

  La routine de fg_flood remplit une région arbitraire fermée avec le courant
   valeur de couleur, par rapport aux limites d'écrêtage actuelles.  La région est
   défini par la spécification d'un point de l'espace de l'écran dans son intérieur.

*'''Paramètres'''

  ix est l'espace x écran coordonnée du point intérieur.

  iy est l'espace de l'écran y coordonnée du point intérieur.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_floodw, fg_paint

===fg_floodw===

*'''Prototype'''

  fg_floodw void (double x, double y);
   sous FGfloodw (x #, y #)
   fg_floodw sous-programme (dbl x, dbl y)
   procédure fg_floodw (x, y: real);

*'''But'''

  La routine de fg_floodw remplit une région arbitraire fermée avec le courant
   valeur de couleur, par rapport aux limites d'écrêtage actuelles.  La région est
   défini par la spécification d'un point de l'espace mondial dans son intérieur.

*'''Paramètres'''

  x est l'espace x mondiale coordonnée du point intérieur.

  y est l'espace du monde y coordonnée du point intérieur.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_flood, fg_paintw

===fg_flpimage===

*'''Prototype'''

  fg_flpimage void (char * map_array, int largeur, int hauteur);
   FGflpimage sub (map_array de $, largeur%, hauteur%)
   fg_flpimage sous-programme (INT1 map_array, int largeur, int hauteur)
   procédure fg_flpimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

  Les affichages de routine fg_flpimage une image écrêté inversée stockée comme mode-
   bitmap spécifique.  L'image sera positionnée de sorte que son coin inférieur gauche
   est à la position du curseur graphique.  Seule la partie de l'image qui tombe
   dans les limites d'écrêtage actuelles seront affichées.  Se référer au
   Guide de l'utilisateur Fastgraph pour des informations complètes sur le mode spécifique
   bitmaps.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_clpimage, fg_drwimage, fg_getimage, fg_invert, fg_pack, fg_putimage,
   fg_revimage, fg_setclip, fg_unpack

*'''Exemples'''

  10-8, 10-9

===fg_fontsize===

*'''Prototype'''

  fg_fontsize void (int char_height);
   FGfontsize sous (char_height%)
   fg_fontsize sous-programme (int char_height)
   procédure fg_fontsize (char_height: integer);

*'''But'''

  La routine de fg_fontsize permet au 8x8, 8x14 ou 8x16 caractère BIOS ROM
   police pour les chaînes affichées avec fg_print et fg_text.  Reportez-vous au chapitre 7 de
   Guide de l'utilisateur Fastgraph pour obtenir des informations sur le caractère par défaut
   tailles et nombre de lignes de texte disponibles dans chaque mode vidéo.

*'''Paramètres'''

  char_height est la hauteur du caractère désiré en pixels.  Sa valeur doit être 8,
   14 ou 16.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Si char_height est pas une valeur valide, fg_fontsize ne fait rien.

  Cette routine n'a de sens que dans les modes VGA et SVGA graphiques vidéo.

*'''Voir aussi'''

  fg_print, fg_text

*'''Exemples'''

  7-8

===fg_freepage===

*'''Prototype'''

  int fg_freepage (int page_number);
   fonction FGfreepage% (page_number%)
   int fonction fg_freepage (int page_number)
   fonction fg_freepage (page_number: Integer): Integer;

*'''But'''

  La routine de presse de fg_freepage une page vidéo virtuelle ou logique créé
   fg_allocate, avec fg_alloccms, ou fg_allocems fg_allocxms.

*'''Paramètres'''

  page_number est le numéro de la page virtuelle ou logique à libérer.  Il
   doit être comprise entre 1 et 63.

*'''Valeur de retour'''

  Un code d'état indiquant le succès ou l'échec de la page virtuelle
   libérer, comme indiqué ici:

  0 = page virtuelle ou logique libéré avec succès
     1 = numéro de page est invalide
     7 pages publié, mais commande de mémoire blocs = virtuels détruits
     9 = tentative de libérer une page physique, ou une page virtuelle ou logique
         qui n'a jamais été créé

*'''Restrictions'''

  Cette routine est sans effet si page_number référence à une page vidéo physique,
   ou une page virtuelle qui n'a jamais été créé.

*'''Voir aussi'''

  fg_allocate, fg_alloccms, fg_allocems, fg_allocxms

*'''Exemples'''

  8-3, 8-4, 8-5, 8-6, 8-9, 8-10, 8-12, 11-1, 11-2, 11-3, 11-4, 12-4, 12- 5,
   13-2, 13-5, 17-1


===fg_getaddr===

*'''Prototype'''

  int fg_getaddr (void);
   fonction FGgetaddr% ()
   int fonction fg_getaddr ()
   fonction fg_getaddr: integer;

*'''But'''

  La routine fg_getaddr renvoie l'adresse de segment (en mode réel) ou
   sélecteur de segment (en mode protégé) pour la page de la vidéo active.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  L'adresse de segment de la page vidéo active.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setpage

*'''Exemples'''

  8-9

===fg_getattr===

*'''Prototype'''

  int fg_getattr (int ligne, colonne int);
   fonction FGgetattr% (ligne%, colonne%)
   int fonction fg_getattr (int ligne, colonne int)
   fonction fg_getattr (ligne, colonne: nombre entier): nombre entier;

*'''But'''

  La routine fg_getattr renvoie l'attribut de caractère stockée à la
   position spécifiée sur la page vidéo active.

*'''Paramètres'''

  ligne est le numéro de ligne de la cellule de caractère à examiner, entre 0 et 24
   (Sauf si vous avez appelé fg_setlines d'augmenter le nombre de lignes par
   page).

  la colonne est le numéro de colonne de la cellule de caractère à examiner, entre 0 et
   39 pour les modes 40 colonnes, ou entre 0 et 79 pour les modes 80 colonnes.

*'''Valeur de retour'''

  L'attribut de caractère stockée à la position spécifiée.

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

  fg_getchar, fg_getimage

*'''Exemples'''

  7-4

===fg_getbanks===

*'''Prototype'''

  fg_getbanks void (int * de read_bank, int * write_bank);
   sous FGgetbanks (read_bank% write_bank%)
   fg_getbanks de sous-programme (int read_bank, int write_bank)
   fg_getbanks procédure (var read_bank, write_bank: integer);

*'''But'''

  Les fg_getbanks retours de routine du SVGA courant lire et écrire la banque
   Nombres.

*'''Paramètres'''

  read_bank reçoit le numéro de banque SVGA utilisé dans les opérations de lecture.

  write_bank reçoit le numéro de banque SVGA utilisé dans les opérations d'écriture.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Les numéros de banque lecture et d'écriture seront correctes que si elles ont été fixées
   à travers le noyau de SVGA Fastgraph ou avec fg_setbanks.

  Pour les chipsets SVGA sans lecture séparée / écriture des banques, ou lorsque vous utilisez un VESA
   pilote qui ne prend pas en charge les banques séparées, les valeurs retournées pour
   read_bank et write_bank seront identiques.

*'''Voir aussi'''

  fg_setbanks, fg_svgainit

===fg_getblock===

*'''Prototype'''

  fg_getblock void (char [bien] * buffer, int minx, maxx int, int Miny,
     int maxy);
   FGgetblock sous ($ buffer, minx%, maxx%, miny%, maxy%)
   sous-programme fg_getblock (int1 tampon [bien], int minx, maxx int, int Miny,
     int maxy)
   procédure fg_getblock (buffer: pointeur; minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine de fg_getblock récupère un bloc (pour un affichage plus tard avec
   fg_putblock) à partir de la position spécifiée sur la page vidéo active ou
   tampon virtuel.  Dans les modes de texte, les extrêmes de blocs sont définis dans le caractère
   espace;  dans les modes graphiques, ils sont définis dans l'espace de l'écran.  Utilisez fg_imagesiz
   pour déterminer la taille de la matrice nécessaire pour stocker le bloc.

*'''Paramètres'''

  tampon est le nom du tableau à recevoir le bloc.  Il est passé de loin
   référence en modes 16 bits, sauf lors de l'utilisation BASIC.

  minx est l'espace x écran coordonnées du bord gauche du bloc.  Dans les graphiques
   modes, sa valeur est réduite à une limite d'octet si nécessaire.

  maxx est la coordonnée X du bord droit du bloc.  Il doit être supérieur à
   ou égale à la valeur de minx.  Dans les modes graphiques, sa valeur est étendue à
   une limite d'octet, si nécessaire.

  Miny est la coordonnée y de la bordure supérieure du bloc.

  Maxy est la coordonnée y du bord inférieur du bloc.  Elle doit être supérieure
   supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille du buffer est limitée à 64K octets.

  Dans les programmes Pascal en mode réel, le tampon doit être allouée de façon dynamique avec le
   procédure GetMem.  Ceci est la seule façon de transmettre quelque chose par référence loin
   en Pascal.

*'''Voir aussi'''

  fg_imagesiz, fg_putblock

*'''Exemples'''

  11-10


===fg_getchar===

*'''Prototype'''

  int fg_getchar (int ligne, colonne int);
   fonction FGgetchar% (ligne%, colonne%)
   int fonction fg_getchar (int ligne, colonne int)
   fonction fg_getchar (ligne, colonne: nombre entier): nombre entier;

*'''But'''

  La routine fg_getchar renvoie la valeur de caractères stockée à la valeur spécifiée
   position sur la page vidéo active.

*'''Paramètres'''

  ligne est le numéro de ligne de la cellule de caractère à examiner, entre 0 et 24
   (Sauf si vous avez appelé fg_setlines d'augmenter le nombre de lignes par
   page).

  la colonne est le numéro de colonne de la cellule de caractère à examiner, entre 0 et
   39 pour les modes 40 colonnes, ou entre 0 et 79 pour les modes 80 colonnes.

*'''Valeur de retour'''

  La valeur de caractère stocké à la position spécifiée.

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

  fg_getattr, fg_getimage

*'''Exemples'''

  7-4

===fg_getclip===

*'''Prototype'''

  fg_getclip void (int * de mijaurée, int * maxx, int * Miny, int * maxy);
   FGgetclip sous (minx de%, maxx%, miny%, maxy%)
   sous-programme fg_getclip (int minx, maxx int, int Miny, int maxy)
   procédure fg_getclip (var minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine fg_getclip renvoie les extrêmes de la région de découpage à l'écran
   espace.  La zone de découpage est une zone rectangulaire à l'extérieur de laquelle certains
   graphiques sont supprimés.  Par défaut, la zone de découpage est réglé sur la
   Page vidéo extrêmes.

*'''Paramètres'''

  minx reçoit la coordonnée x du bord gauche de la zone de découpage.

  maxx reçoit la coordonnée x du bord droit de la zone de découpage.

  Miny reçoit la coordonnée y de bord supérieur de la zone de découpage.

  Maxy reçoit la coordonnée y du bord inférieur de la zone de découpage.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_setclip

===fg_getclock===

*'''Prototype'''

  longue fg_getclock (void);
   fonction FGgetclock & ()
   fonction int4 fg_getclock ()
   fonction fg_getclock: longint;

*'''But'''

  Les fg_getclock routine renvoie le nombre de tops d'horloge depuis minuit.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le nombre d'impulsions d'horloge depuis minuit.  Il y a environ 18,2
   horloge par seconde.  La valeur de retour est toujours une quantité de 32 bits.

*'''Restrictions'''

  aucun

*'''Exemples'''

  16-2

===fg_getcolor===

*'''Prototype'''

  int fg_getcolor (void);
   fonction FGgetcolor% ()
   int fonction fg_getcolor ()
   fonction fg_getcolor: integer;

*'''But'''

  La routine fg_getcolor renvoie l'attribut de texte en cours (en mode texte)
   ou de l'indice de couleur (dans les modes graphiques), tel que défini par l'appel le plus récent
   fg_setattr ou fg_setcolor.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Dans graphiques modes vidéo, la valeur de retour est l'indice de couleur actuelle.  Dans
   modes de texte, il est l'attribut de texte actuel.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setattr, fg_setcolor

===fg_getdacs===

*'''Prototype'''

  fg_getdacs void (int start, int count, les valeurs char *);
   sous FGgetdacs (start%, compter%, les valeurs $)
   fg_getdacs sous-programme (int start, int count, valeurs INT1)
   procédure fg_getdacs (début, count: nombre entier, les valeurs var: ShortInt);

*'''But'''

  La routine fg_getdacs récupère les composants rouge, vert et bleu
   d'un bloc contigu de registres vidéo du CAD.  Chaque composante de couleur est un
   valeur comprise entre 0 et 63;  valeurs croissantes produisent des couleurs plus intenses.
   Lecture de registres du CAD avec fg_getdacs est considérablement plus rapide que
   faisant individuellement avec fg_getrgb.

*'''Paramètres'''

  début est la vidéo DAC numéro de registre de départ, entre 0 et 255.

  compte est le nombre de contigue DAC enregistre pour récupérer, entre 1 et
   256. Si la somme de départ et le nombre dépasse 256, les numéros de registre wrap
   autour et reprendre avec le registre numéro 0.

  Les valeurs sont le nom du tableau qui va recevoir les composants de couleur.  le
   trois premiers octets de ce tableau reçoivent les composantes rouge, verte et bleue
  DAC début de registre, les trois octets suivants reçoivent les composants pour
  inscrivez-vous commencer à + 1, et ainsi de suite. La taille du tableau de valeurs doit être au
  moins 3 * octets de comptage.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte, ou CGA, Tandy, et Hercules
  les modes graphiques. Dans les modes 13 à 16, il est significatif que lorsqu'il est exécuté sur un VGA
  ou un système SVGA; ses résultats sont imprévisibles dans ces modes lorsqu'il est exécuté sur un
  EGA. Vous pouvez utiliser fg_testmode (18,0) pour vérifier un VGA ou SVGA système.

*'''Voir aussi'''

 fg_getrgb, fg_setdacs, fg_setrgb

*'''Exemples'''

 5-12

===fg_getentry===

*'''Prototype'''

 fg_getentry void (int page_number, int * page_addr, int * page_type);
  FGgetentry sous (page_number%, page_addr%, page_type%)
  sous-programme fg_getentry (int page_number, int page_addr, int page_type)
  procédure fg_getentry (page_number: integer; var page_addr,
    page_type: integer);

*'''But'''

 La routine de fg_getentry récupère le type et l'adresse d'un physique,
  Page vidéo virtuel ou logique. Cette routine est utile pour la sauvegarde virtuelle
  ou le contenu de pages logiques à travers les changements de mode vidéo.

*'''Paramètres'''

page_number est le numéro de la page vidéo souhaité. Il doit être compris entre 0
  et 63.

page_addr est l'adresse de la page spécifiée. Pour les pages physiques, virtuels
  pages et des pages logiques dans la mémoire conventionnelle, l'adresse est une ordinaire
  adresse de segment. Pour les pages logiques dans la mémoire EMS ou XMS, l'adresse de la page
  est une poignée EMS ou XMS.

 page_type est une valeur de retour indiquant le type de page, comme indiqué ici:
    0 page = non alloué
     1 page = physique
    2 = page virtuelle
     3 page = logique dans la mémoire paginée (EMS)
    4 = page logique dans la mémoire étendue (XMS)
    5 = page logique dans la mémoire conventionnelle

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_setentry

*'''Exemples'''

 8-12

===fg_gethpage===

*'''Prototype'''

 int fg_gethpage (void);
  fonction FGgethpage% ()
  int fonction fg_gethpage ()
  fonction fg_gethpage: integer;

*'''But'''

 La routine fg_gethpage renvoie le numéro de la page vidéo cachée (tel que défini dans la
  plus récent appel à fg_sethpage).

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 Le numéro de la page vidéo cachée, entre 0 et 63.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_sethpage

===fg_getimage===

*'''Prototype'''

 fg_getimage void (char * map_array, int largeur, int hauteur);
  FGgetimage sub (map_array de $, largeur%, hauteur%)
  fg_getimage sous-programme (INT1 map_array, int largeur, int hauteur)
  procédure fg_getimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

 La routine de fg_getimage récupère une image en tant que bitmap mode spécifique.  le
  graphiques position du curseur (la position du curseur de texte en mode texte vidéo)
  définit le coin inférieur gauche de l'image pour récupérer.  Se référer au
  Guide de l'utilisateur Fastgraph pour des informations complètes sur le mode spécifique
  bitmaps.

*'''Paramètres'''

map_array est le nom du tableau qui recevra le bitmap. En BASIC,
  vous devez déclarer explicitement map_array comme une chaîne variable de longueur fixe
  longueur Largeur hauteur.

 largeur est la largeur en octets de la bitmap.

 hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

 fg_clpimage, fg_drwimage, fg_flpimage, fg_getmap, fg_putimage, fg_revimage

*'''Exemples'''

 10-12, 10-13, 10-17, 10-18


===fg_getindex===

*'''Prototype'''

 int fg_getindex (int index);
  fonction FGgetindex% (indice%)
  int fonction fg_getindex (int index)
  fonction fg_getindex (index: integer): integer;

*'''But'''

 La routine fg_getindex renvoie la valeur de couleur assignée à un spécifiée
  indice de couleur virtuelle.

*'''Paramètres'''

 index est l'indice de couleur virtuelle pour récupérer, entre 0 et 255.

*'''Valeur de retour'''

 Dans les modes graphiques vidéo avec moins de 256 couleurs disponibles, le retour
  La valeur est la valeur de couleur assignée à l'index virtuel spécifié. Dans le texte
  modes et modes graphiques 256 couleurs, fg_getindex retourne la valeur passée à
   il.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_defcolor, fg_palette, fg_setcolor

===fg_getkey===

*'''Prototype'''

 fg_getkey void (unsigned char * clé, unsigned char * aux);
  FGgetkey sous (touche $, aux $)
  fg_getkey sous-programme (touche INT1, INT1 aux)
  procédure fg_getkey (clé var, aux: byte);

*'''But'''

 Les attentes de routine fg_getkey pour une séquence de touches, ou lit la prochaine entrée de
  le tampon de clavier du BIOS (sans écho). Il renvoie les frappes de
  code de clavier standard ou étendu (une liste de ces apparaît dans le chapitre 14
  du Guide de l'utilisateur Fastgraph).

*'''Paramètres'''

 clé reçoit le code de clavier standard de la touche si elle représente un
  caractère standard. Si la combinaison de touches représente un caractère étendu, clé
  sera mis à zéro. En BASIC, vous devez déclarer explicitement clé comme fixe
  longueur variable chaîne de longueur 1.

 aux reçoit le code de clavier étendu de la frappe si elle représente un
  caractère étendu. Si la combinaison de touches représente un caractère standard, aux
  sera mis à zéro. En BASIC, vous devez déclarer explicitement aux comme un fixe
  longueur variable chaîne de longueur 1.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_intkey, fg_kbtest, fg_waitkey

*'''Exemples'''

 13-7, 13-8, 14-1, 16-2


===fg_getlines===

*'''Prototype'''

 int fg_getlines (void);
  FGgetlines de fonction (%)
  fg_getlines fonction int ()
  fg_getlines fonction: Integer;

*'''But'''

 Les fg_getlines de routine renvoie le nombre de lignes de texte par page vidéo pour
  le mode vidéo en cours.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 Le nombre de lignes de texte par page vidéo pour le mode vidéo actuel.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_fontsize, fg_setlines

*'''Exemples'''

 3-5

===fg_getmap===

*'''Prototype'''

 fg_getmap void (char * map_array, int largeur, int hauteur);
  FGgetmap sub (map_array de $, largeur%, hauteur%)
  fg_getmap sous-programme (INT1 map_array, int largeur, int hauteur)
  procédure fg_getmap (var map_array: octet; largeur, hauteur: integer);

*'''But'''

 La routine de fg_getmap récupère une image en tant que bitmap en mode indépendant.  le
  la position du curseur graphique définit le coin inférieur gauche de l'image à
  récupérer. Reportez-vous au Guide de l'utilisateur Fastgraph pour une information complète
  à propos de bitmaps en mode indépendant.

*'''Paramètres'''

map_array est le nom du tableau qui recevra le bitmap. chaque octet
  map_array représente de huit pixels. Pixels de la couleur actuelle régler la
  bits correspondants dans map_array. Pixels d'autres couleurs rendent le
  bits de map_array correspondant zéro. En BASIC, vous devez déclarer explicitement
  map_array comme une variable chaîne de longueur largeur * hauteur de longueur fixe.

 largeur est la largeur en octets de la bitmap.

 hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_clipmap, fg_drawmap, fg_getimage

*'''Exemples'''

 10-10, 10-11

===fg_getmaxx===

*'''Prototype'''

 int fg_getmaxx (void);
  fonction FGgetmaxx% ()
  int fonction fg_getmaxx ()
  fonction fg_getmaxx: integer;

*'''But'''

 La routine fg_getmaxx retourne le maximum coordonnée x dans l'espace de l'écran
  quand il est utilisé dans un mode graphique vidéo. Elle retourne le nombre maximum de colonnes dans
  un espace de caractère lorsqu'il est utilisé dans un mode texte. Dans les deux cas, le maximum x
  coordonnée est un de moins que la résolution horizontale de l'écran.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 Les maximales coordonnée x.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getmaxy

*'''Exemples'''

 4-1, 4-2

===fg_getmaxy===

*'''Prototype'''

 int fg_getmaxy (void);
  fonction FGgetmaxy% ()
  int fonction fg_getmaxy ()
  fonction fg_getmaxy: integer;

*'''But'''

 La routine fg_getmaxy retourne le maximum coordonnée y dans l'espace de l'écran
  quand il est utilisé dans un mode graphique vidéo. Il retourne le nombre de lignes maximum
  un espace de caractère lorsqu'il est utilisé dans un mode texte. Dans les deux cas, l'y maximale
  coordonnée est un de moins que la résolution verticale de l'écran.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 Le maximum coordonnée y.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getmaxx

*'''Exemples'''

 4-1, 4-2

===fg_getmode===

*'''Prototype'''

 int fg_getmode (void);
  fonction FGgetmode% ()
  int fonction fg_getmode ()
  fonction fg_getmode: integer;

*'''But'''

   La routine fg_getmode renvoie le numéro de mode vidéo actuel.  Elle est typiquement une des premières routines appelées Fastgraph dans un programme.  La valeur retournée par fg_getmode peut être conservé pour rétablir le mode vidéo original lorsqu'un programme transfère le contrôle de retour au DOS. 

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le numéro de mode vidéo actuel, entre 0 et 29. Se reporter à *'''But'''
   de fg_setmode pour une description de chaque mode vidéo.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setmode

*'''Exemples'''

  3-3, 3-4, 3-5, 3-6, 3-7, 3-8, 3-10


===fg_getpage===

*'''Prototype'''

  int fg_getpage (void);
   fonction FGgetpage% ()
   int fonction fg_getpage ()
   fonction fg_getpage: integer;

*'''But'''

  La routine fg_getpage renvoie le numéro de page vidéo actif (tel que défini dans la
   plus récent appel à fg_setpage).

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le numéro de la page vidéo active, entre 0 et 63.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setpage

*'''Exemples'''

  8-9

===fg_getpixel===

*'''Prototype'''

  int fg_getpixel (int ix, iy int);
   fonction FGgetpixel% (ix%, iy%)
   int fonction fg_getpixel (int ix, iy int)
   fonction fg_getpixel (ix, iy: entier): nombre entier;

*'''But'''

  La routine fg_getpixel renvoie la valeur de couleur d'un pixel spécifié.

*'''Paramètres'''

  ix est un écran espace x du pixel de coordonnées.

  iy est l'espace de l'écran du pixel y coordonnées.

*'''Valeur de retour'''

  La valeur de couleur du pixel, entre 0 et une inférieur au nombre de
   couleurs disponibles dans le mode vidéo actuel.  Si les (ix, iy) coordonnées
   se situent en dehors de la zone de découpage, fg_getpixel renvoie -1.  En mode texte,
   fg_getpixel retourne toujours zéro.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_point, fg_pointw

*'''Exemples'''

  6-1

===fg_getrgb===

*'''Prototype'''

  fg_getrgb void (int number, int * rouge, int vert *, int bleu *);
   FGgetrgb sous (numéro%, rouge%, vert%, bleu%)
   fg_getrgb sous-programme (nombre int, rouge, int vert, int bleu)
   procédure fg_getrgb (nombre: integer; var rouge, vert, bleu: entier);

*'''But'''

  La routine retourne fg_getrgb les composantes de couleur rouge, vert et bleu pour
   une vidéo spécifiée registre DAC.  Chaque composante de couleur est une valeur comprise entre 0
   et 63;  valeurs croissantes produisent des couleurs plus intenses.

*'''Paramètres'''

  nombre est la vidéo DAC numéro de registre.  Il doit être compris entre 0 et 15 à 16-
   Modes de graphiques couleur, et entre 0 et 255 dans les modes 256 couleurs.

  rouge, vert et bleu reçoivent respectivement le rouge, vert et bleu
   composants de la vidéo spécifiée registre DAC.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo, ou dans une vidéo graphique
   Mode numéro 12 ou ci-dessous (parce que ces modes vidéo n'utilisent pas DAC
   registres).
   Cette routine n'a pas d'effet dans les modes 13, 14, et 16 lorsqu'il est exécuté sur un EGA
   système.

*'''Voir aussi'''

  fg_getdacs, fg_palette, fg_setdacs, fg_setrgb

*'''Exemples'''

  5-11

===fg_getview===

*'''Prototype'''

  vide fg_getview (int * view_minx, int * view_maxx, int * view_miny,
     int * view_maxy, int * mijaurée, int * maxx, int * Miny, int * maxy);
   FGgetview sous (view_minx de%, view_maxx%, view_miny%, view_maxy%, minx%,
     maxx%, miny%, maxy%)
   fg_getview sous-programme (int view_minx, int view_maxx, int view_miny,
     int view_maxy, int minx, maxx int, int Miny, int maxy)
   procédure fg_getview (var view_minx, view_maxx, view_miny, view_maxy,
     minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine fg_getview renvoie les extrêmes viewport en unités de fenêtres et
   unités de l'espace de l'écran.

*'''Paramètres'''

  view_minx reçoit le bord gauche de la fenêtre en unités de viewport.

  view_maxx reçoit le bord droit de la fenêtre en unités de viewport.

  view_miny reçoit le bord supérieur de la fenêtre en unités de viewport.

  view_maxy reçoit le bord inférieur de la fenêtre en unités de viewport.

  minx reçoit le bord gauche de la fenêtre en unités d'espace d'écran.

  maxx reçoit le bord droit de la fenêtre en unités d'espace d'écran.

  Miny reçoit le bord supérieur de la fenêtre en unités d'espace d'écran.

  Maxy reçoit le bord inférieur de la fenêtre en unités d'espace d'écran.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setview

===fg_getvpage===

*'''Prototype'''

  int fg_getvpage (void);
   fonction FGgetvpage% ()
   int fonction fg_getvpage ()
   fonction fg_getvpage: integer;

*'''But'''

  La routine fg_getvpage renvoie le numéro de la page vidéo visuel (tel que défini dans la
   plus récent appel à fg_setvpage).

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le numéro de la page vidéo visuelle, entre 0 et 63.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setvpage

*'''Exemples'''

  8-9

===fg_getworld===

*'''Prototype'''

  fg_getworld void (double * xmin, double * xmax, double * ymin, double * ymax);
   FGgetworld sous (xmin de #, xmax #, ymin #, ymax #)
   fg_getworld sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
   procédure fg_getworld (var xmin, xmax, ymin, ymax: real);

*'''But'''

  La routine fg_getworld renvoie les limites de l'espace mondial actuel, tel que défini
   dans l'appel le plus récent à fg_setworld.

*'''Paramètres'''

  xmin reçoit l'espace mondial de coordonnées du bord de l'écran de gauche.

  xmax reçoit l'espace mondial de coordonnées du bord droit de l'écran.

  ymin reçoit l'espace mondial de coordonnées du bord inférieur de l'écran.

  ymax reçoit l'espace mondial de coordonnées du bord supérieur de l'écran.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

  fg_setworld

*'''Exemples'''

  4-4

===fg_getxbox===

*'''Prototype'''

  int fg_getxbox (void);
   fonction FGgetxbox% ()
   int fonction fg_getxbox ()
   fonction fg_getxbox: integer;

*'''But'''

  La routine fg_getxbox retourne la largeur en pixels de la gauche et à droite
   bords des rectangles dessinés avec la famille fg_box des routines.  Par défaut,
   la largeur est un pixel, mais cela peut être changé en appelant fg_boxdepth.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La largeur en pixels des côtés gauche et droit (qui est, à la verticale
   bords) des rectangles dessinés avec la famille fg_box des routines.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_boxdepth, fg_getybox

===fg_getxjoy===

*'''Prototype'''

  int fg_getxjoy (int n);
   fonction FGgetxjoy% (n%)
   int fonction fg_getxjoy (int n)
   fonction fg_getxjoy (n: nombre entier): nombre entier;

*'''But'''

  La routine fg_getxjoy renvoie position du coordonnées horizontales
   Joystick spécifié.  Les coordonnées réelles dépendent de la vitesse du processeur
   et la marque de joystick utilisé.

*'''Paramètres'''

  n indique le numéro de joystick, soit 1 ou 2.

*'''Valeur de retour'''

  Si la valeur de retour est positif, il représente l'horizontale actuelle
   position du joystick demandé de coordonnées.  Si la valeur de retour est -1,
   cela signifie que le joystick demandé n'a pas été initialisé ou non présent.

*'''Restrictions'''

  Avant d'utiliser cette routine, vous devez utiliser fg_initjoy pour initialiser le
   manette requise.

*'''Voir aussi'''

  fg_button, fg_getyjoy, fg_initjoy, fg_intjoy

*'''Exemples'''

  14-12

===fg_getxjust===

*'''Prototype'''

  int fg_getxjust (void);
   fonction FGgetxjust% ()
   int fonction fg_getxjust ()
   fonction fg_getxjust: integer;

*'''But'''

  La routine fg_getxjust renvoie le paramètre de justification horizontale utilisée
   par fg_print.  La routine fg_setmode définit la justification par défaut à -1,
   et sa valeur peut être modifiée avec fg_justify.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  -1 = Cordes sont justifiés à gauche par rapport à la position de graphiques actuelles x
    0 = les chaînes sont centrées sur les graphiques x position actuelle
    1 = cordes sont justifiés à droite par rapport aux x graphiques actuelles

position

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getyjust, fg_justify

===fg_getxpos===

*'''Prototype'''

  int fg_getxpos (void);
   FGgetxpos de fonction (%)
   fg_getxpos fonction int ()
   fg_getxpos fonction: Integer;

*'''But'''

  Les fg_getxpos routine renvoie l'espace x écran de coordonnées de la
   graphiques position du curseur.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La coordonnée x de la position du curseur graphique.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getypos

===fg_getybox===

*'''Prototype'''

  int fg_getybox (void);
   fonction FGgetybox% ()
   int fonction fg_getybox ()
   fonction fg_getybox: integer;

*'''But'''

  La routine fg_getybox retourne la largeur en pixels de haut et en bas
   bords des rectangles dessinés avec la famille fg_box des routines.  Par défaut,
   la largeur est un pixel, mais cela peut être changé en appelant fg_boxdepth.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La largeur en pixels des côtés supérieur et inférieur (qui est, à l'horizontale
   bords) des rectangles dessinés avec la famille fg_box des routines.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_boxdepth, fg_getxbox

===fg_getyjoy===

*'''Prototype'''

  int fg_getyjoy (int n);
   fonction FGgetyjoy% (n%)
   int fonction fg_getyjoy (int n)
   fonction fg_getyjoy (n: nombre entier): nombre entier;

*'''But'''

  La routine fg_getyjoy renvoie la position verticale de la coordonnée
   Joystick spécifié.  Les coordonnées réelles dépendent de la vitesse du processeur
   et la marque de joystick utilisé.

*'''Paramètres'''

  n indique le numéro de joystick, soit 1 ou 2.

*'''Valeur de retour'''

  Si la valeur de retour est positif, il représente la verticale actuelle
   position du joystick demandé de coordonnées.  Si la valeur de retour est -1,
   cela signifie que le joystick demandé n'a pas été initialisé ou non présent.

*'''Restrictions'''

  Avant d'utiliser cette routine, vous devez utiliser fg_initjoy pour initialiser le
   manette requise.

*'''Voir aussi'''

  fg_button, fg_getxjoy, fg_initjoy, fg_intjoy

*'''Exemples'''

  14-12

===fg_getyjust===

*'''Prototype'''

  int fg_getyjust (void);
   fonction FGgetyjust% ()
   int fonction fg_getyjust ()
   fonction fg_getyjust: integer;

*'''But'''

  La routine fg_getyjust renvoie le paramètre de justification verticale utilisée par
   fg_print.  La routine fg_setmode définit la justification par défaut à -1, et
   sa valeur peut être modifiée avec fg_justify.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  -1 = Cordes auront leur bord inférieur à la position y des graphiques actuels
    0 = les chaînes sont centrées sur les graphiques position y courante
    1 = cordes auront leur bord supérieur à la position y des graphiques actuels

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getxjust, fg_justify


===fg_getypos===

*'''Prototype'''

  int fg_getypos (void);
   FGgetypos de fonction (%)
   fg_getypos fonction int ()
   fg_getypos fonction: Integer;

*'''But'''

  La routine fg_getypos renvoie l'espace de l'écran y coordonnée du
   graphiques position du curseur.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La coordonnée y de la position du curseur graphique.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getxpos


===fg_gifhead===

*'''Prototype'''

  int fg_gifhead (char * gif_file, char * gif_header);
   fonction FGgifhead% (gif_file $, gif_header $)
   int fonction fg_gifhead (char gif_file, gif_header int1)
   fonction fg_gifhead (gif_file: string; var gif_header): integer;

*'''But'''

  La routine de fg_gifhead lit l'en-tête mondial et premier en-tête local à partir
   le fichier GIF spécifié.

*'''Paramètres'''

  gif_file est le nom du fichier GIF, terminé par un octet nul.

  gif_header est le nom de la mémoire tampon de 23 octets pour recevoir du global du fichier GIF
   en-tête et le premier en-tête local.  En BASIC, il doit être une longueur fixe de 23 octets
   chaîne.

*'''Valeur de retour'''

  0 = Succès
   -1 = Le fichier spécifié n'existe pas
   -2 = Le fichier spécifié est pas un fichier GIF

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_gifmode, fg_gifrange, fg_showgif

*'''Exemples'''

  9-5

===fg_gifmode===

*'''Prototype'''

  int fg_gifmode (char * gif_header);
   fonction FGgifmode% (gif_header $)
   fonction int fg_gifmode (int1 gif_header)
   fonction fg_gifmode (var gif_header): integer;

*'''But'''

  La routine fg_gifmode détermine le mode vidéo optimal pour l'image GIF
   associé à l'en-tête de fichier GIF spécifié.  Le mode optimal est le
   mode vidéo ayant la plus basse résolution supérieure ou égale à l'image
   dimensions.

*'''Paramètres'''

  gif_header est le nom du tampon contenant le fichier GIF 23 octets
   entête.

*'''Valeur de retour'''

  > 0 = Le mode vidéo optimal pour afficher l'image GIF
   -1 = Le tampon de gif_header ne contient pas un en-tête de fichier GIF valide
   -2 = Impossible de déterminer un mode vidéo compatible

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_gifhead, fg_setmode, fg_showgif

*'''Exemples'''

  9-5

===fg_gifpal===

*'''Prototype'''

  int fg_gifpal (char * gif_file, char * gif_palette);
   fonction FGgifpal% (gif_file $, gif_palette $)
   int fonction fg_gifpal (char gif_file, gif_palette int1)
   fonction fg_gifpal (gif_file: string; var gif_palette): integer;

*'''But'''

  La routine fg_gifpal récupère la palette d'une image stockée dans un GIF
   fichier.  Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chacune entre
   0 et 63. Pour les modes vidéo 18 et au-dessus, les valeurs de la palette sont adaptés pour
   fg_setdacs.  Pour les modes natifs EGA graphiques (13 à 16), la palette
   les valeurs doivent être converties en valeurs spécifiques au mode (avec fg_maprgb) avant
   être utilisé avec fg_palette ou fg_palettes.

  Si le fichier GIF comprend une palette locale pour la première image, fg_gifpal
   renverra les valeurs de la palette locale.  Sinon, fg_gifpal sera
   renvoyer les valeurs de la palette globale du fichier GIF.

*'''Paramètres'''

  gif_file est le nom du fichier GIF.  Le nom du fichier doit se terminer par un
   octet nul.

  gif_palette est le nom du tableau qui va recevoir la palette de GIF
   valeurs.  Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chaque
   entre 0 et 63. Les trois premiers octets de gif_palette contiendra RGB
   des valeurs pour la couleur 0, les trois prochaines pour la couleur 1, et ainsi de suite.  La taille de
   la matrice de gif_palette doit être au moins trois fois le nombre de couleurs
   l'image GIF.

*'''Valeur de retour'''

  > 0 = le nombre de couleurs dans la palette de GIF
   -1 = Fichier non trouvé
   -2 = Fichier est pas un fichier GIF

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_maprgb, fg_palette, fg_palettes, fg_setdacs, fg_showgif

*'''Exemples'''

  9-5

===fg_gifrange===

*'''Prototype'''

  fg_gifrange void (char * gif_header, int * mijaurée, int * maxx, int * Miny,
     int * maxy);
   FGgifrange sous (gif_header de $, minx%, maxx%, miny%, maxy%)
   fg_gifrange sous-programme (int1 gif_header, int minx, maxx int, int Miny,
     int maxy)
   procédure fg_gifrange (var gif_header; var minx, maxx, Miny, Maxy:
     entier);

*'''But'''

  La routine fg_gifrange retourne les étendues d'image pour l'image GIF
   associé à l'en-tête de fichier GIF spécifié.

*'''Paramètres'''

  gif_header est le nom du tampon contenant le fichier GIF 23 octets
   entête.

  minx reçoit les coordonnées x du bord gauche de l'image.  Si gif_header ne
   contient pas un en-tête de fichier GIF valide, minx sera défini à -1.

  maxx reçoit les coordonnées x du bord droit de l'image.  Si gif_header
   ne contient pas un en-tête de fichier GIF valide, maxx sera défini à -1.

  Miny reçoit la coordonnée y de bord supérieur de l'image.  Si gif_header ne
   pas contenir un en-tête de fichier GIF valide, miny sera fixé à -1.

  Maxy reçoit la coordonnée y de bord inférieur de l'image.  Si gif_header
   ne contient pas un en-tête de fichier GIF valide, maxy sera défini à -1.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_gifhead, fg_showgif

*'''Exemples'''

  9-5


===fg_hush===

*'''Prototype'''

  fg_hush void (void);
   FGhush sub ()
   sous-routine fg_hush ()
   procédure fg_hush;

*'''But'''

  La routine fg_hush arrête immédiatement son asynchrone a commencé avec
   fg_musicb, fg_sounds ou fg_voices.  Il n'a aucun effet s'il n'y a pas
   son asynchrone en cours.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_hushnext, fg_musicb, fg_sounds, fg_suspend, fg_voices

*'''Exemples'''

  15-7

===fg_hushnext===

*'''Prototype'''

  fg_hushnext void (void);
   FGhushnext sub ()
   sous-routine fg_hushnext ()
   procédure fg_hushnext;

*'''But'''

  La routine fg_hushnext arrête son asynchrone a commencé avec fg_musicb,
   fg_sounds, ou fg_voices, mais pas jusqu'à ce que la répétition en cours se termine.  Il
   n'a pas d'effet s'il n'y a pas de son asynchrone en cours.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet à moins que le son asynchrone est continue.

*'''Voir aussi'''

  fg_hush, fg_musicb, fg_sounds, fg_suspend, fg_voices

*'''Exemples'''

  15-7

===fg_imagebuf===

*'''Prototype'''

  fg_imagebuf void (char [bien] * buffer, taille non signé);
   FGimagebuf sous (tampon $, taille%)
   fg_imagebuf sous-programme (int1 [bien] buffer, int size)
   procédure fg_imagebuf (buffer: pointeur; taille: mot);

*'''But'''

  La routine de fg_imagebuf spécifie la taille et l'adresse du tampon utilisé
   en interne lors de la création ou l'affichage GIF, PCX, PPR, ou des fichiers SPR.
   interne par défaut tampon taille Fastgraph est 4096 octets.  Affichage de l'image ou
   la création est généralement plus rapide quand un tampon plus grand est utilisé.

*'''Paramètres'''

  tampon est l'adresse de la mémoire tampon interne.  Il est passé par référence loin
   dans les modes 16 bits, sauf lors de l'utilisation BASIC.

  la taille correspond à la taille en octets du tampon.  Si la taille est égale à zéro, Fastgraph utilisera son
   propres tampons internes lors de la création ou de l'affichage des fichiers d'image.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les programmes Pascal en mode réel, le tampon doit être allouée de façon dynamique avec le
   procédure GetMem.  Ceci est la seule façon de transmettre quelque chose par référence loin
   en Pascal.

*'''Voir aussi'''

  fg_dispfile, fg_flicplay, fg_makegif, fg_makepcx, fg_makeppr, fg_makespr,
   fg_showflic, fg_showgif, fg_showpcx, fg_showppr, fg_showspr

*'''Exemples'''

  9-12


===fg_imagesiz===

*'''Prototype'''

  longue fg_imagesiz (largeur, int hauteur);
   fonction FGimagesiz & (largeur%, hauteur%)
   fonction int4 fg_imagesiz (int largeur, int hauteur)
   fonction fg_imagesiz (largeur, hauteur: entier): longint;

*'''But'''

  La routine fg_imagesiz détermine le nombre d'octets requis pour stocker une
   spécifique en mode image pixelisée de dimensions spécifiées.

*'''Paramètres'''

  largeur spécifie la largeur de l'image en pixels.

  hauteur spécifie la hauteur de l'image en pixels.

*'''Valeur de retour'''

  Le nombre d'octets requis pour stocker une image bitmap de mode spécifique
   la taille spécifiée dans le mode vidéo en cours.  La valeur de retour est toujours un
   quantité de 32 bits.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_clpimage, fg_drwimage, fg_flpimage, fg_getblock, fg_getimage,
   fg_putblock, fg_putimage, fg_revimage

*'''Exemples'''

  10-12

===fg_initems===

*'''Prototype'''

  int fg_initems (void);
   FGinitems de fonction (%)
   fg_initems fonction int ()
   fonction fg_initems: integer;

*'''But'''

  Le fg_initems initialise routine mémoire paginée (EMS) pour une utilisation avec
   Fastgraph.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  0 = succès
   -1 = Expanded Memory Manager pas installé ou non accessible

*'''Restrictions'''

  Cette routine nécessite un gestionnaire de mémoire étendue (EMM) qui est conforme à la
   Lotus / Intel / Microsoft Expanded Memory Specification (LIM-EMS) version 3.2
   ou plus tard.  Sur 80386 et 80486 systèmes, le pilote de périphérique EMM386.EXE fourni
   avec DOS 5.0 peut être utilisé pour traiter une partie ou l'ensemble de la mémoire étendue que
   mémoire étendue.

  Après avoir appelé fg_setmode, le gestionnaire de mémoire étendue est désactivée et doit
   être ré-initialisé.

  Cette routine est significative uniquement en mode réel.  En mode protégé, il sera
   toujours revenir -1.

  Le gestionnaire de mémoire étendue utilise 67h d'interruption.  Par conséquent, ce vecteur est
   non disponible pour les programmes d'application.

*'''Voir aussi'''

  fg_allocems, fg_initxms

*'''Exemples'''

  8-10

===fg_initjoy===

*'''Prototype'''

  int fg_initjoy (int n);
   fonction FGinitjoy% (n%)
   int fonction fg_initjoy (int n)
   fonction fg_initjoy (n: nombre entier): nombre entier;

*'''But'''

  La routine de fg_initjoy initialise soit joystick et doit être appelé
   avant d'utiliser fg_getxjoy, fg_getyjoy ou fg_intjoy.

*'''Paramètres'''

  n indique le numéro de joystick, soit 1 ou 2.

*'''Valeur de retour'''

  Si la valeur de retour est 0, cela signifie que l'initialisation du joystick était
   réussi.  Si elle est -1, cela signifie que la machine n'a pas de port de jeu, ou
   Joystick demandée n'a pas été connecté au port de jeu.

*'''Restrictions'''

  Lorsque vous appelez fg_initjoy, Fastgraph assume le joystick demandé est
   centrée.

*'''Voir aussi'''

  fg_button, fg_getxjoy, fg_getyjoy, fg_intjoy

*'''Exemples'''

  14-11, 14-12, 14-13

===fg_initpm===

*'''Prototype'''

  fg_initpm void (void);
   FGinitpm sub ()
   sous-routine fg_initpm ()
   procédure fg_initpm;

*'''But'''

  La routine de fg_initpm initialise protégé le noyau du mode de Fastgraph pour
   extendeurs DOS spécifiques.  Elle doit être appelée avant tout autre Fastgraph
   routine dans les programmes en mode protégé.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est non significatif en mode réel.

*'''Exemples'''

  1-1

===fg_initw===

*'''Prototype'''

  fg_initw void (void);
   sous FGinitw ()
   sous-routine fg_initw ()
   procédure fg_initw;

*'''But'''

  La routine de fg_initw initialise l'espace du monde interne Fastgraph
   paramètres.  Cette routine doit être appelée une fois, avant toute autre routine
   qui utilise les coordonnées spatiales du monde.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Exemples'''

  4-4, 6-4, 6-9, 7-10, 7-11, 7-12, 7-13

===fg_initxms===

*'''Prototype'''

  int fg_initxms (void);
   FGinitxms de fonction (%)
   fg_initxms fonction int ()
   fonction fg_initxms: integer;

*'''But'''

  Le fg_initxms initialise routine mémoire étendue (XMS) pour une utilisation avec
   Fastgraph.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  0 = succès
   -1 = XMS pilote non installé ou non accessible

*'''Restrictions'''

  Cette routine requiert un conducteur externe qui est conforme à la
   Lotus / Intel / Microsoft / AST eXtended Memory Specification (XMS) version 2.0,
   tel que HIMEM.SYS.  pilotes XMS nécessitent un système 80286, 80386 ou 80486.

  Après avoir appelé fg_setmode, le pilote XMS est désactivé et doit être re-
   initialisée.

  Cette routine est significative uniquement en mode réel.  En mode protégé, il sera
   toujours revenir -1.

*'''Voir aussi'''

  fg_allocxms, fg_initems

*'''Exemples'''

  8-10

===fg_inside===

*'''Prototype'''

  int fg_inside (int * vertex_array, int n, int ix, iy int);
   fonction FGinside% (vertex_array% (), n%, ix%, iy%)
   int fonction fg_inside (int vertex_array, int n, int ix, iy int)
   fonction fg_inside (var vertex_array: integer; n, ix, iy: integer):
     entier;

*'''But'''

  La routine fg_inside détermine si le point spécifié se trouve dans un convexe
   polygone.  Les décalages d'fg_polyoff sont appliqués aux sommets du polygone mais pas
   au point de test.

*'''Paramètres'''

  vertex_array est le nom du tableau contenant le (x, y) paires de coordonnées
   de chaque sommet.  Le premier élément de tableau est la composante x du premier
   sommet, le second élément est la composante y du premier sommet, la
   troisième élément est la composante x du deuxième sommet, et ainsi de suite.

  n est le nombre de sommets du polygone.  Normalement, il est une moitié de la
   taille de vertex_array.

  ix est l'espace x écran coordonnées du point de test.

  iy est l'espace de l'écran coordonnée y du point de test.

*'''Valeur de retour'''

  0 = le point de test est en dehors du polygone
   1 = le point de test est à l'intérieur du polygone

*'''Restrictions'''

  Si vertex_array ne définit pas un polygone convexe, la valeur de retour est
   indéfini.

  Dans les modes de 16 bits, la taille des vertex_array est limitée à 64K octets.

*'''Voir aussi'''

  fg_polyfill, fg_polyline, fg_polyoff

===fg_intjoy===

*'''Prototype'''

  fg_intjoy void (int n, char * key, char * aux);
   FGintjoy sub (n%, touche $, aux $)
   fg_intjoy sous-programme (int n, clé INT1, INT1 aux)
   procédure fg_intjoy (n: integer; clé var, aux: byte);

*'''But'''

  La routine fg_intjoy renvoie les codes de clavier standard et étendus
   analogue à la position et l'état actuel de touche spécifié
   manette.

*'''Paramètres'''

  n indique le numéro de joystick, soit 1 ou 2.

  clé reçoit le statut de touche de la manette.  Si un bouton de la demande
   joystick est pressé, la touche est réglée sur 13, le code de clavier standard pour la
   La touche Entrée.  Si aucune touche, la touche est réglée sur zéro.  En BASIC, vous
   doit déclarer explicitement clé comme une variable chaîne de longueur 1 de longueur fixe.

  aux reçoit la position analogique de la manette, comme indiqué ci-dessous.  En BASIC, vous
   doit déclarer explicitement aux comme une variable chaîne de longueur 1 de longueur fixe.

  position de joystick clé étendue code clé correspondant

  et quitté la maison 71
                 up up flèche 72
            haut et à droite PgUp 73
                gauche flèche gauche 75
              centrée (aucune action) 0
                droite droite du 77
            vers le bas et 79 Fin gauche
                flèche vers le bas vers le bas 80
           vers le bas et à droite PgDn 81

  Si le joystick demandé n'a pas été initialisé, la clé et aux volonté
   être mis à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Avant d'utiliser cette routine, vous devez utiliser fg_initjoy pour initialiser le
   manette requise.

*'''Voir aussi'''

  fg_button, fg_getxjoy, fg_getyjoy, fg_initjoy, fg_intkey

*'''Exemples'''

  14-13


===fg_intkey===

*'''Prototype'''

  fg_intkey void (unsigned char * clé, unsigned char * aux);
   FGintkey sous (touche $, aux $)
   fg_intkey sous-programme (touche INT1, INT1 aux)
   procédure fg_intkey (clé var, aux: byte);

*'''But'''

  La routine fg_intkey lit l'entrée suivante dans la mémoire tampon de clavier du BIOS
   (Sans écho) et renvoie le clavier standard ou étendu de la frappe
   code (une liste de ces apparaît dans le chapitre 14 du Guide de l'utilisateur Fastgraph).
   Il est semblable à fg_getkey, mais il ne pas attendre une touche si la
   mémoire tampon du clavier est vide.

*'''Paramètres'''

  clé reçoit le code de clavier standard de la touche si elle représente un
   caractère standard.  Si la combinaison de touches représente un caractère étendu, clé
   sera mis à zéro.  En BASIC, vous devez déclarer explicitement clé comme fixe
   longueur variable chaîne de longueur 1.

  aux reçoit le code de clavier étendu de la frappe si elle représente un
   caractère étendu.  Si la combinaison de touches représente un caractère standard, aux
   sera mis à zéro.  En BASIC, vous devez déclarer explicitement aux comme un fixe
   longueur variable chaîne de longueur 1.

  Si la mémoire tampon du clavier du BIOS est vide, la clé et aux seront mis à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getkey, fg_intjoy, fg_kbtest, fg_waitkey

*'''Exemples'''

  14-2, 15-7, 16-1, 16-3


===fg_invert===

*'''Prototype'''

  fg_invert void (char * map_array, int largeur, int hauteur);
   FGinvert sub (map_array de $, largeur%, hauteur%)
   fg_invert sous-programme (INT1 map_array, int largeur, int hauteur)
   procédure fg_invert (var map_array; largeur, hauteur: integer);

*'''But'''

  La routine fg_invert intervertit l'orientation d'un mode spécifique ou mode-
   image bitmap indépendante.  bitmaps routines d'affichage d'image de Fastgraph
   attendez que l'image soit stockée à partir de la ligne et de procédure de fond
   vers le haut.  La routine de fg_invert va inverser l'ordre de rangée de tels
   images, de sorte qu'un "haut en bas" image devient un "bas en haut" image, ou
   vice versa.

*'''Paramètres'''

  map_array est le nom du tableau contenant le bitmap.

  largeur est la largeur en octets de la bitmap.

  hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

  fg_clipmap, fg_clpimage, fg_drawmap, fg_drwimage, fg_flpimage, fg_putimage,
   fg_revimage

*'''Exemples'''

  10-14

===fg_justify===

*'''Prototype'''

  fg_justify void (int xjust, int yjust);
   sous FGjustify (xjust% yjust%)
   sous-programme fg_justify (int xjust, int yjust)
   procédure fg_justify (xjust, yjust: integer);

*'''But'''

  La routine fg_justify définit la justification horizontale et verticale
   paramètres pour les chaînes affichées avec fg_print et fg_printc.

*'''Paramètres'''

  xjust définit la justification horizontale.  Si xjust est -1, les chaînes seront
   affiché justifié à gauche par rapport à la graphiques x position actuelle.  Si
   xjust est 0, les chaînes seront centrées sur le position x.  Si xjust est 1,
   chaînes seront justifiées à droite.

  yjust définit la justification verticale.  Si yjust est -1, le fond de la
   caractères seront la position graphique y actuelle.  Si yjust est 0, les chaînes
   sera centrée autour de la position y.  Si yjust est égal à 1, la partie supérieure du
   caractères seront à la position y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Les valeurs des xjust et doivent être yjust -1, 0 ou 1.

*'''Voir aussi'''

  fg_getxjust, fg_getyjust, fg_print, fg_printc

*'''Exemples'''

  7-6, 10-17, 10-18, 13-7, 13-9


===fg_kbinit===

*'''Prototype'''

  fg_kbinit void (int state);
   FGkbinit sous (état%)
   fg_kbinit sous-programme (int state)
   procédure fg_kbinit (état: entier);

*'''But'''

  La routine de fg_kbinit active ou désactive le clavier de bas niveau de Fastgraph
   gestionnaire.  Si le gestionnaire de clavier est déjà dans l'État requis, rien
   qui se passe.

*'''Paramètres'''

  Etat est un indicateur précisant si le gestionnaire de clavier doit être activé (état
   = 1) ou désactivé (état = 0).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Lorsque le gestionnaire de clavier de bas niveau est activé, il est impossible d'utiliser
   fg_getkey, fg_intkey, fg_waitkey, ou des fonctions de tiers qui utilisent
   BIOS ou DOS Services pour accéder au clavier.

*'''Voir aussi'''

  fg_kblast, fg_kbreset, fg_kbtest

*'''Exemples'''

  14-5

===fg_kblast===

*'''Prototype'''

  int fg_kblast (void);
   fonction FGkblast% ()
   int fonction fg_kblast ()
   fonction fg_kblast: integer;

*'''But'''

  La routine fg_kblast renvoie le code de balayage pour le keypress le plus récent
   traitées par le gestionnaire de clavier de bas niveau de Fastgraph.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le code de balayage pour le plus récent keypress traité par le bas niveau
   gestionnaire de clavier.  S'il n'y a pas eu de touches depuis l'appel
   fg_kbinit, la valeur de retour sera zéro.

*'''Restrictions'''

  Le gestionnaire de clavier de bas niveau doit être activé pour fg_kblast travailler
   correctement.

*'''Voir aussi'''

  fg_kbinit, fg_kbreset, fg_kbtest

===fg_kbreset===

*'''Prototype'''

  fg_kbreset void (void);
   sous FGkbreset ()
   sous-routine fg_kbreset ()
   procédure fg_kbreset;

*'''But'''

  La routine de fg_kbreset réinitialise l'état du clavier de bas niveau de Fastgraph
   gestionnaire à ce qu'elle était après avoir été initialisé avec fg_kbinit (1).

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Le gestionnaire de clavier de bas niveau doit être activé pour fg_kbreset travailler
   correctement.

*'''Voir aussi'''

  fg_kbinit, fg_kblast, fg_kbtest

===fg_kbtest===

*'''Prototype'''

  int fg_kbtest (int scan_code);
   fonction FGkbtest% (scan_code%)
   int fonction fg_kbtest (int scan_code)
   fonction fg_kbtest (scan_code: Integer): Integer;

*'''But'''

  La routine fg_kbtest détermine si la clé ayant le code de balayage spécifié
   est maintenant enfoncée ou relâchée.

*'''Paramètres'''

  scan_code est le code de balayage de la clé pour vérifier, ou zéro.  Si scan_code est
   zéro, fg_kbtest indique si une touche est enfoncée.  Reportez-vous à la Fastgraph
   Guide de l'utilisateur pour obtenir une liste des codes de balayage.

*'''Valeur de retour'''

  0 = touche est relâchée
   1 = touche est pressée

*'''Restrictions'''

  Le gestionnaire de clavier de bas niveau doit être activé pour fg_kbtest travailler
   correctement.

*'''Voir aussi'''

  fg_kbinit, fg_kblast, fg_kbreset

*'''Exemples'''

  14-5

===fg_loadpcx===

*'''Prototype'''

  int fg_loadpcx (char * filename, int flags);
   fonction FGloadpcx% (filename $, drapeaux%)
   fonction int fg_loadpcx (char filename, drapeaux int)
   fonction fg_loadpcx (filename: string; drapeaux: entier): nombre entier;

*'''But'''

  La fg_loadpcx routine charge une image PCX dans le tampon virtuel actif.

*'''Paramètres'''

  filename est le nom du fichier PCX.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  flags est un masque de bits qui contrôle la façon dont l'image est affichée.
     bit 0
        0 = utilisent des valeurs de palette stockées dans le fichier PCX
        1 = utiliser les paramètres de la palette en cours
     bit 1
        0 = l'image de charge à la position indiquée en tête PCX
        1 = image de charge à la position graphique actuelle
     bit 2
        0 = l'image de charge à partir du fichier PCX spécifié
        1 = image de charge à partir de la mémoire tampon de fg_imagebuf
     Bits 3-15 sont réservés pour une utilisation future et devrait être nul.

*'''Valeur de retour'''

  0 = succès
   1 = fichier non trouvé
   2 = fichier est pas un fichier PCX

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_showpcx, fg_vbopen

*'''Exemples'''

  9-2, 10-19, 13-8

===fg_locate===

*'''Prototype'''

  fg_locate void (int ligne, colonne int);
   FGlocate sous (ligne%, colonne%)
   fg_locate sous-programme (int ligne, colonne int)
   procédure fg_locate (ligne, colonne: nombre entier);

*'''But'''

  La routine fg_locate modifie la position du curseur de texte pour les actifs
   page d'affichage.  La routine fg_setmode définit la position du curseur de texte de chaque page
   à (0,0).

*'''Paramètres'''

  ligne est le numéro de destination de la ligne du curseur de texte, entre 0 et un de moins
   que le nombre de lignes de caractères disponibles.

  colonne est le numéro de colonne de destination du curseur de texte, entre 0 et un de moins
   que le nombre de colonnes de caractères disponibles.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

   Les huit premières pages vidéo (0 à 7) ont chacune leur propre curseur de texte.  Chaque groupe ultérieur de 8 pages vidéo (pages 8 à 15, pages 16 à 23, et ainsi de suite) partagent respectivement les mêmes positions texte du curseur que les 8 premières pages.  Par exemple, en changeant la position du curseur de texte sur la page vidéo 9 modifie également sa position sur la page vidéo 1. 

*'''Voir aussi'''

  fg_text, fg_textc, fg_where

*'''Exemples'''

  7-1, 7-2, 7-3, 7-4, 7-5, 7-7, 7-8, 7-9, 7-10

===fg_makegif===

*'''Prototype'''

  int fg_makegif (int minx, maxx int, int Miny, int maxy, char * filename);
   fonction FGmakegif% (minx%, maxx%, miny%, maxy%, filename $)
   int fonction fg_makegif (int minx, maxx int, int Miny, int maxy,
    omble filename)
   fonction fg_makegif (minx, maxx, Miny, Maxy: integer; filename: string):
    entier;

*'''But'''

  La routine de fg_makegif crée un fichier GIF à partir du rectangle spécifié
   région de la page vidéo active ou tampon virtuel.  Les extrêmes de la région
   sont exprimés en unités de l'espace de l'écran.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche de la région.

  maxx est la coordonnée X du bord droit de la région.  Elle doit être supérieure
   ou égale à mijaurée.

  Miny est la coordonnée y de bord supérieur de la région.

  Maxy est la coordonnée y du bord inférieur de la région.  Elle doit être supérieure
   supérieure ou égale à miny.

  filename est le nom du fichier GIF pour créer.  Un nom de périphérique et le chemin peut
   être inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   caractère nul (soit un octet nul).  Si un fichier portant le même nom déjà
   existe, il est écrasé.

*'''Valeur de retour'''

  0 = succès
   1 = Le fichier ne crée pas

*'''Restrictions'''

  La routine de fg_makegif n'a aucun effet en mode texte vidéo, ou dans le CGA et
   modes graphiques Hercules.

  Dans le mode 16-graphique couleur Tandy / PCjr (mode 9) et l'EGA native
   modes graphiques (modes 13 à 16), les registres de la palette ne sont pas
   lisible.  Par conséquent, fg_makegif utilisera les paramètres de la palette par défaut lorsqu'il est utilisé
   dans ces modes vidéo sur Tandy ou systèmes EGA.

*'''Voir aussi'''

  fg_imagebuf, fg_makepcx, fg_makeppr, fg_makespr, fg_showgif

*'''Exemples'''

  9-4

===fg_makepcx===

*'''Prototype'''

  int fg_makepcx (int minx, maxx int, int Miny, int maxy, char * filename);
   fonction FGmakepcx% (minx%, maxx%, miny%, maxy%, filename $)
   int fonction fg_makepcx (int minx, maxx int, int Miny, int maxy,
     omble filename)
   fonction fg_makepcx (minx, maxx, Miny, Maxy: integer; filename: string):
     entier;

*'''But'''

  La routine de fg_makepcx crée un fichier PCX à partir du rectangle spécifié
   région de la page vidéo active ou tampon virtuel.  Les extrêmes de la région
   sont exprimés en unités de l'espace de l'écran.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche de la région.  Sa valeur est réduite à
   une limite d'octet, si nécessaire.

  maxx est la coordonnée X du bord droit de la région.  Elle doit être supérieure
   ou égale à mijaurée.

  Miny est la coordonnée y de bord supérieur de la région.

  Maxy est la coordonnée y du bord inférieur de la région.  Elle doit être supérieure
   supérieure ou égale à miny.

  filename est le nom du fichier PCX pour créer.  Un nom de périphérique et le chemin peut
   être inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   caractère nul (soit un octet nul).  Si un fichier portant le même nom déjà
   existe, il est écrasé.

*'''Valeur de retour'''

  0 = succès
   1 = Le fichier ne crée pas

*'''Restrictions'''

  La routine de fg_makepcx n'a aucun effet en mode vidéo de texte ou dans le Hercules
   basse résolution en mode graphique.  Reportez-vous à *'''But''' de fg_showpcx pour
   informations sur la compatibilité de fichier PCX entre différents modes vidéo.

  Dans le mode 16-graphique couleur Tandy / PCjr (mode 9) et l'EGA native
   modes graphiques (modes 13 à 16), les registres de la palette ne sont pas
   lisible.  Par conséquent, fg_makepcx utilisera les paramètres de la palette par défaut lorsqu'il est utilisé
   dans ces modes vidéo sur Tandy ou systèmes EGA.

  Quand un tampon virtuel est actif, fg_makepcx crée toujours 256 couleurs PCX
   fichiers, quel que soit le mode vidéo actuel.  Si le mode vidéo est pas
   mode vidéo 256 couleurs, le fichier PCX 256 couleurs aura pas d'extension
   palette.

  139

fg_makepcx (suite)

*'''Voir aussi'''

  fg_imagebuf, fg_makegif, fg_makespr, fg_makeppr, fg_showpcx

*'''Exemples'''

  9-1

===fg_makeppr===

*'''Prototype'''

  int fg_makeppr (int minx, maxx int, int Miny, int maxy, char * filename);
   fonction FGmakeppr% (minx%, maxx%, miny%, maxy%, filename $)
   int fonction fg_makeppr (int minx, maxx int, int Miny, int maxy,
     omble filename)
   fonction fg_makeppr (minx, maxx, Miny, Maxy: integer; filename: string):
     entier;

*'''But'''

  La routine de fg_makeppr crée une série de pixels emballés (PPR) fichier à partir du
   région rectangulaire spécifiée de la page vidéo active ou tampon virtuel.
   Les extrêmes de la région sont exprimés en unités d'espace d'écran.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche de la région.

  maxx est la coordonnée X du bord droit de la région.  Elle doit être supérieure
   ou égale à mijaurée.

  Miny est la coordonnée y de bord supérieur de la région.

  Maxy est la coordonnée y du bord inférieur de la région.  Elle doit être supérieure
   supérieure ou égale à miny.

  filename est le nom du fichier PPR pour créer.  Un nom de périphérique et le chemin peut
   être inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   caractère nul (soit un octet nul).  Si un fichier portant le même nom déjà
   existe, il est écrasé.

*'''Valeur de retour'''

  0 = succès
   1 = Le fichier ne crée pas

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_imagebuf, fg_makegif, fg_makepcx, fg_makespr, fg_showppr

===fg_makespr===

*'''Prototype'''

  int fg_makespr (int minx, maxx int, int Miny, int maxy, char * filename);
   fonction FGmakespr% (minx%, maxx%, miny%, maxy%, filename $)
   int fonction fg_makespr (int minx, maxx int, int Miny, int maxy,
     omble filename)
   fonction fg_makespr (minx, maxx, Miny, Maxy: integer; filename: string):
     entier;

*'''But'''

  La routine de fg_makespr crée une piste de pixel standard (SPR) fichier à partir du
   région rectangulaire spécifiée de la page vidéo active ou tampon virtuel.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche de la région.  Sa valeur est réduite à
   une limite d'octet, si nécessaire.

  maxx est la coordonnée X du bord droit de la région.  Elle doit être supérieure
   ou égale à mijaurée.

  Miny est la coordonnée y de bord supérieur de la région.

  Maxy est la coordonnée y du bord inférieur de la région.  Elle doit être supérieure
   supérieure ou égale à miny.

  filename est le nom du fichier SPR pour créer.  Un nom de périphérique et le chemin peut
   être inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   caractère nul (soit un octet nul).  Si un fichier portant le même nom déjà
   existe, il est écrasé.

*'''Valeur de retour'''

  0 = succès
   1 = Le fichier ne crée pas

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_imagebuf, fg_makegif, fg_makepcx, fg_makeppr, fg_showspr

*'''Exemples'''

  9-9

===fg_maprgb===

*'''Prototype'''

  int fg_maprgb (int rouge, int vert bleu, int);
   fonction FGmaprgb% (rouge%, vert%, bleu%)
   fonction int fg_maprgb (int rouge, int vert, int bleu)
   fonction fg_maprgb (rouge, vert, bleu: entier): nombre entier;

*'''But'''

  Les cartes de routine fg_maprgb six bits rouge, vert, et les composants de couleur bleue
   en une valeur de palette appropriée pour le mode vidéo en cours.  Vous pouvez ensuite passer
   cette valeur à fg_palette.

*'''Paramètres'''

  rouge, vert et bleu spécifier respectivement la couleur de rouge, vert et bleu
   Composants.  Ces valeurs doivent être comprises entre 0 et 63;  des valeurs croissantes
   produire des couleurs plus intenses.

*'''Valeur de retour'''

  La valeur de la palette mode spécifique pour les composants de couleur spécifiée.

*'''Restrictions'''

  Cette routine n'a de sens que dans les modes graphiques vidéo 16 couleurs.

*'''Voir aussi'''

  fg_palette, fg_palettes, fg_setrgb

*'''Exemples'''

  5-13

===fg_measure===

*'''Prototype'''

  int fg_measure (void);
   fonction FGmeasure% ()
   int fonction fg_measure ()
   fonction fg_measure: integer;

*'''But'''

  La routine fg_measure renvoie le nombre approximatif d'unités de retard par
   horloge tique.  Cette quantité est proportionnelle à la vitesse du processeur du système.
   unités de retard sont utilisés par fg_stall.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Le nombre approximatif d'unités de retard par impulsion d'horloge.  Les valeurs typiques pour
   certains systèmes communs sont:

  unités de retard du système
                                    type par impulsion d'horloge
                                Tandy 1000 HX 280
                                25 MHz 80386 3400
                                40 MHz 80386 7100

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_stall

*'''Exemples'''

  13-9, 16-3

===fg_memavail===

*'''Prototype'''

  longue fg_memavail (void);
   fonction FGmemavail & ()
   fonction int4 fg_memavail ()
   fonction fg_memavail: longint;

*'''But'''

  La routine fg_memavail détermine la quantité de mémoire conventionnelle
   disponible pour DOS.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La quantité de mémoire conventionnelle (en octets) disponible pour DOS.  Le retour
   La valeur est toujours une quantité de 32 bits.

*'''Restrictions'''

  aucun

*'''Exemples'''

  17-1

===fg_memory===

*'''Prototype'''

  int fg_memory (void);
   fonction FGmemory% ()
   int fonction fg_memory ()
   fonction fg_memory: integer;

*'''But'''

  La routine fg_memory renvoie la quantité de mémoire vidéo présente (en
   kilooctets) sur la carte de SVGA de l'utilisateur.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La quantité de mémoire vidéo en kilo-octets.  Par exemple, si l'utilisateur SVGA
   carte possède 1 Mo de mémoire vidéo installée, la valeur de retour sera 1,024.

*'''Restrictions'''

  Cette routine est seulement significative après l'initialisation avec succès Fastgraph de
   kernel SVGA avec fg_svgainit.

*'''Voir aussi'''

  fg_svgainit

*'''Exemples'''

  3-9, 8-8

===fg_mouse256===

*'''Prototype'''

  fg_mouse256 vides (char * masques, int xoffset, int yoffset);
   FGmouse256 sous (masques $, xoffset%, yoffset%)
   fg_mouse256 sous-programme (masques INT1, int xoffset, int yoffset)
   procédure fg_mouse256 (masques var; xoffset, yoffset: integer);

*'''But'''

  La routine fg_mouse256 définit la forme et l'apparence d'un multicolore
   curseur souris en mode SVGA graphiques XVGA et 256 couleurs.  Reportez-vous au chapitre 14
   du Guide de l'utilisateur Fastgraph pour des informations complètes sur la définition de la
   curseur souris dans les modes graphiques.

*'''Paramètres'''

  masques est un réseau de 512 octets contenant le masque d'écran 256 éléments suivis
   par le 256-élément masque de curseur.  Le pilote de la souris affiche le curseur de la souris
   par opération logique mémoire vidéo avec le masque de l'écran, puis XOR que
   entraîner le masque de curseur.  Le premier élément de chaque masque correspond à la
   rangée supérieure du curseur de la souris.  valeurs de masque d'écran sont généralement 0 ou 255,
   tandis que les valeurs de masque de curseur se situent entre 0 et 255.

  xoffset est la coordonnée x du "point chaud" par rapport à la partie supérieure gauche
   coin du curseur de la souris.

  yoffset La coordonnée y du "point chaud" par rapport à la partie supérieure gauche
   coin du curseur de la souris.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est significative seulement dans XVGA et modes graphiques SVGA 256 couleurs.

*'''Voir aussi'''

  fg_mouseini, fg_mouseptr, fg_mousevis

===fg_mousebut===

*'''Prototype'''

  fg_mousebut void (int number, int * count, int * LASTx, int * lasty);
   FGmousebut sous (numéro%, compter%, LASTx%, lasty%)
   fg_mousebut sous-programme (nombre int, int count, int LASTx, int lasty)
   procédure fg_mousebut (nombre: integer; count var, LASTx, lasty:
     entier);

*'''But'''

  La routine renvoie des informations à propos de fg_mousebut bouton de la souris ou appuyez sur
   libérer les chiffres, ainsi que la position du curseur de la souris au moment de la
   dernière pression sur un bouton ou de la libération.

*'''Paramètres'''

  nombre est le bouton de la souris pour laquelle un rapport d'information (1 signifie la
   bouton gauche, 2 sur le bouton droit, et 3 le bouton du milieu).  Si le nombre est
   , appuyez sur les chiffres positifs seront rapportés.  Si elle est négative, la libération
   les chiffres seront communiqués.

  comptage reçoit le nombre de communiqués ou de libération des chiffres pour les demandé
   bouton depuis la dernière vérification, ou depuis l'appel fg_mouseini.

  LASTx reçoit les coordonnées x (dans l'espace de l'écran) du curseur de la souris
   position au moment de la dernière pression ou la libération du bouton demandé.
   Si le nombre est égal à zéro, LASTx est également mis à zéro.

  lasty reçoit la coordonnée y (dans l'espace de l'écran) du curseur de la souris
   position au moment de la dernière pression ou la libération du bouton demandé.
   Si le nombre est égal à zéro, lasty est également mis à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_mousepos

*'''Exemples'''

  14-8

===fg_mousecur===

*'''Prototype'''

  fg_mousecur void (int screen_mask, int cursor_mask);
   FGmousecur sous (screen_mask%, cursor_mask%)
   sous-programme fg_mousecur (int screen_mask, int cursor_mask)
   procédure fg_mousecur (screen_mask, cursor_mask: integer);

*'''But'''

  La routine fg_mousecur définit l'apparence du curseur de la souris dans le texte
   modes vidéo.  Reportez-vous au chapitre 14 du Guide de l'utilisateur Fastgraph pour complète
   informations sur la définition du curseur de la souris en mode texte.

*'''Paramètres'''

  screen_mask définit le masque de l'écran.  Lorsque vous placez la souris sur un
   cellule de caractère spécifique, le pilote de souris logiquement ANDS le masque d'écran
   avec le contenu existant de cette cellule.

  cursor_mask définit le masque de curseur.  Après logiquement ANDing le masque d'écran
   avec le contenu d'une cellule de caractère, le pilote de souris XORs le curseur
   masque avec le résultat pour produire le curseur de la souris.

  La structure binaire de screen_mask et cursor_mask est la suivante:

  les bits signifie

  valeur de caractère 0-7 ASCII
                                8 à 11 couleur de premier plan
                                12 à 14background couleur
                                15 blink

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

  fg_mouseini, fg_mouseptr, fg_mousevis

*'''Exemples'''

  14-9

===fg_mousefin===

*'''Prototype'''

  fg_mousefin void (void);
   sous FGmousefin ()
   sous-routine fg_mousefin ()
   procédure fg_mousefin;

*'''But'''

  La routine de fg_mousefin dégrafe le gestionnaire XVGA ou SVGA souris de Fastgraph de
   le pilote de souris.  Cette routine doit être utilisé juste avant de revenir à un
   mode texte dans les programmes qui ont appelé fg_mouseini dans XVGA ou SVGA graphiques
   modes.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est seulement significatif dans les modes graphiques XVGA et SVGA.

*'''Voir aussi'''

  fg_mouseini

===fg_mouseini===

*'''Prototype'''

  int fg_mouseini (void);
   fonctionner FGmouseini% ()
   int fonction fg_mouseini ()
   fonction fg_mouseini: integer;

*'''But'''

  La routine fg_mouseini initialise la souris et doit être appelée avant tout
   d'autres routines de support de la souris de Fastgraph.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Si la valeur de retour est positif, il indique le nombre de boutons sur la
   souris utilisé (2 ou 3).  Si la valeur de retour est -1, cela signifie que le
   initialisation a échoué car le pilote de la souris n'a pas été chargé ou
   la souris est pas physiquement connecté.

*'''Restrictions'''

  Cette routine ne fonctionne pas quand un tampon virtuel est actif.

*'''Voir aussi'''

  fg_mouse256, fg_mousebut, fg_mousecur, fg_mousefin, fg_mouselim,
   fg_mousemov, fg_mousepos, fg_mouseptr, fg_mousespd, fg_mousevis, fg_resize

*'''Exemples'''

  14-6, 14-7, 14-8, 14-9, 14-10

===fg_mouselim===

*'''Prototype'''

  fg_mouselim void (int minx, maxx int, int Miny, int maxy);
   FGmouselim sous (minx de%, maxx%, miny%, maxy%)
   sous-programme fg_mouselim (int minx, maxx int, int Miny, int maxy)
   procédure fg_mouselim (minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine fg_mouselim définit la zone rectangulaire dans laquelle la souris
   le curseur peut se déplacer.  Dans les modes graphiques, la zone est définie dans l'espace de l'écran
   coordonnées.  En mode texte, il est défini en lignes et colonnes.

*'''Paramètres'''

  minx est la coordonnée x du bord gauche de la zone.

  maxx est la coordonnée X du bord droit de la zone.  Il doit être supérieur à
   ou égale à la valeur de minx.

  Miny est la coordonnée y de bord supérieur de la région.

  Maxy est la coordonnée y du bord inférieur de la zone.  Il doit être supérieur à
   ou égale à la valeur de miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_mouseini, fg_mousemov

*'''Exemples'''

  14-7

===fg_mousemov===

*'''Prototype'''

  fg_mousemov void (int ix, iy int);
   Sous FGmousemov (ix% iy%)
   fg_mousemov sous-programme (int ix, iy int)
   procédure fg_mousemov (ix, iy: integer);

*'''But'''

  La routine fg_mousemov déplace le curseur de la souris sur le caractère spécifié
   cellule (en mode texte) ou de la position de l'espace de l'écran (en mode graphique).  le
   curseur souris est déplacée si oui ou non il est actuellement visible.

*'''Paramètres'''

  ix est la coordonnée x de la nouvelle position du curseur de la souris.

  iy est la coordonnée y de la nouvelle position du curseur de la souris.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Si vous essayez de déplacer le curseur de la souris en dehors de la zone définie par
   fg_mouselim, fg_mousemov positionne le curseur à l'endroit le plus proche possible
   dans cette zone.

*'''Voir aussi'''

  fg_mouseini, fg_mouselim

*'''Exemples'''

  14-7

===fg_mousepos===

*'''Prototype'''

  fg_mousepos void (int * de ix, int * iy, boutons int *);
   sous FGmousepos (ix%, iy%, boutons%)
   fg_mousepos sous-programme (int ix, int iy, boutons int)
   fg_mousepos procédure (var ix, iy, boutons: integer);

*'''But'''

  La routine fg_mousepos renvoie la position actuelle de la souris et le bouton
   statut.  Dans les modes graphiques, la position est définie dans l'espace de l'écran
   coordonnées.  En mode texte, il est défini en lignes et colonnes.

*'''Paramètres'''

  ix reçoit la coordonnée x de la position du curseur de la souris.

  iy reçoit la coordonnée y de la position du curseur de la souris.

  les boutons reçoivent un masque de bits représentant l'état du bouton, où chaque bit
   est réglé si le bouton correspondant est enfoncé.  Le bit 0 correspond à la
   bouton gauche, le bit 1 du bouton droit, et le bit 2 au bouton central.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_mousebut, fg_mouseini

*'''Exemples'''

  14-8

===fg_mouseptr===

*'''Prototype'''

  fg_mouseptr void (courts * masques, int xoffset, int yoffset);
   FGmouseptr sous (masques de% (), xoffset%, yoffset%)
   fg_mouseptr sous-programme (masques int2, int xoffset, int yoffset)
   procédure fg_mouseptr (masques var: integer; xoffset, yoffset:
     entier);

*'''But'''

  La routine fg_mouseptr définit la forme et l'apparence de la souris
   curseur en mode graphique vidéo.  Reportez-vous au chapitre 14 de la Fastgraph l'utilisateur
   Guide pour des informations complètes sur la définition du curseur de la souris dans les graphiques
   modes.

*'''Paramètres'''

  masques est un ensemble de 32 éléments contenant le masque d'écran 16-élément suivi
   par l'élément de 16 masque de curseur.  Le pilote de la souris affiche le curseur de la souris
   par opération logique mémoire vidéo avec le masque de l'écran, puis XOR que
   entraîner le masque de curseur.  Le premier élément de chaque masque correspond à la
   rangée supérieure du curseur de la souris.  Le tableau suivant résume le curseur
   apparence pour toutes les combinaisons possibles de bits de masque.

  bit de masque écran masque bit de curseur résultant curseur pixel

  0 0 noir
                 0 1 blanc
                 1 0 inchangé
                 1 1 inversé

  xoffset est la coordonnée x du "point chaud" par rapport à la partie supérieure gauche
   coin du curseur de la souris.

  yoffset est la coordonnée y de la "hot spot" par rapport à la partie supérieure gauche
   coin du curseur de la souris.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_mouse256, fg_mousecur, fg_mouseini, fg_mousevis

*'''Exemples'''

  14-10

===fg_mousespd===

*'''Prototype'''

  fg_mousespd void (int xmickeys, int ymickeys);
   FGmousespd sous (xmickeys%, ymickeys%)
   sous-programme fg_mousespd (int xmickeys, int ymickeys)
   procédure fg_mousespd (xmickeys, ymickeys: integer);

*'''But'''

  La routine fg_mousespd définit le nombre d'unités mickey par huit pixels
   de déplacement du curseur (en fonction du pilote de la souris, une unité est égale à mickey
   1/200 ou 1/400 de pouce).  Ce contrôle efficacement la vitesse à laquelle
   le curseur se déplace par rapport au déplacement de la souris elle-même.

*'''Paramètres'''

  xmickeys est le nombre d'unités mickey par huit pixels de la souris horizontale
   le mouvement du curseur (la valeur par défaut est 8).

  ymickeys est le nombre d'unités mickey par huit pixels de souris verticale
   le mouvement du curseur (la valeur par défaut est 16).

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_mouseini

*'''Exemples'''

  14-7

===fg_mousevis===

*'''Prototype'''

  fg_mousevis void (int de l'Etat);
   sous FGmousevis (état%)
   fg_mousevis sous-programme (int state)
   fg_mousevis procédure (état: entier);

*'''But'''

  La routine fg_mousevis rend le curseur de la souris visible ou invisible.  Après
   appelant fg_mouseini, le curseur de la souris est invisible.

*'''Paramètres'''

  Etat définit la visibilité du curseur de la souris.  Si l'état est 0, le curseur de la souris
   est rendu invisible.  Si elle est de 1, le curseur de la souris est rendu visible.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_mouseini

*'''Exemples'''

  14-7, 14-8, 14-9, 14-10

===fg_move===

*'''Prototype'''

  fg_move void (int ix, iy int);
   Sous FGmove (ix% iy%)
   fg_move sous-programme (int ix, iy int)
   procédure fg_move (ix, iy: integer);

*'''But'''

  La routine fg_move établit la position du curseur graphique à une absolue
   point de l'espace de l'écran.  La routine fg_setmode définit le curseur graphique
   à la position (0,0).

*'''Paramètres'''

  ix est l'espace x écran de coordonnées de la nouvelle position du curseur graphique.

  iy est l'espace de l'écran coordonnée y de la nouvelle position du curseur graphique.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_moverel, fg_moverw, fg_movew

*'''Exemples'''

  6-2, 6-3, 6-5, 6-6, 6-10, 6-17, 7-6, 9-9, 9-10, 9-11, 10-1, 12-4, 12- 5,
   12-6, 13-5, 13-6

===fg_moverel===

*'''Prototype'''

  fg_moverel void (int ix, iy int);
   FGmoverel sous (ix%, iy%)
   fg_moverel sous-programme (int ix, iy int)
   procédure fg_moverel (ix, iy: integer);

*'''But'''

  La routine fg_moverel établit la position du curseur graphique sur un écran
   point par rapport à la position actuelle de l'espace.

*'''Paramètres'''

  ix est l'espace de l'écran x décalage de la nouvelle position du curseur graphique.

  iy est l'espace de l'écran de décalage de la nouvelle position du curseur graphique y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_move, fg_moverw, fg_movew

*'''Exemples'''

  6-3

===fg_moverw===

*'''Prototype'''

  fg_moverw void (double x, double y);
   sous FGmoverw (x #, y #)
   fg_moverw sous-programme (dbl x, dbl y)
   procédure fg_moverw (x, y: real);

*'''But'''

  La routine fg_moverw établit la position du curseur graphique dans un monde
   point par rapport à la position actuelle de l'espace.

*'''Paramètres'''

  x est l'espace mondial x décalage de la nouvelle position du curseur graphique.

  y est l'espace du monde décalage de la nouvelle position du curseur graphique y.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_move, fg_moverel, fg_movew

===fg_movew===

*'''Prototype'''

  fg_movew void (double x, double y);
   sous FGmovew (x #, y #)
   fg_movew sous-programme (dbl x, dbl y)
   procédure fg_movew (x, y: real);

*'''But'''

  La routine fg_movew établit la position du curseur graphique à un
   absolu point de l'espace mondial.  La routine fg_initw définit le curseur graphique
   à la position (0.0,0.0).

*'''Paramètres'''

  x est l'espace x mondial de coordonnées de la nouvelle position du curseur graphique.

  y est l'espace mondial coordonnée y de la nouvelle position du curseur graphique.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

*'''Voir aussi'''

  fg_move, fg_moverel, fg_moverw

*'''Exemples'''

  4-4, 6-4, 6-9, 7-10, 7-11, 7-12, 7-13

===fg_music===

*'''Prototype'''

  fg_music void (char * music_string);
   FGmusic sous (music_string $)
   fg_music sous-programme (char music_string)
   procédure fg_music (music_string: string);

*'''But'''

  La routine fg_music utilise la minuterie programmable pour jouer une séquence de
   tonalités musicales.

*'''Paramètres'''

  music_string est une séquence de commandes de musique arbitraire de longueur, suivie par
   un signe dollar ($) terminateur.  commandes de musique sont résumés dans le
   tableau suivant:

commande sens

A travers G Jouez la note spécifiée dans l'octave actuelle.

    Peut être annexée à un caractère de note (A à G) pour faire cette note 

  pointu.

. Peut être annexée à un caractère de note (A à G) ou une forte (#) pour

  étendre cette note la moitié de sa longueur normale.  des points multiples peuvent être utilisées,
        et chacun à nouveau d'étendre la note moitié moins que la précédente
        extension.

Ln Régler la longueur des notes et des pauses suivantes. La valeur de n est un

  entier compris entre 1 et 64, où 1 indique une note entière, deux demi
        Attention, 4 un quart de note, et ainsi de suite.  Si aucune commande de L est présent, L4
        est assumé.

Sur Définir l'octave pour les notes suivantes. La valeur de n peut être un nombre entier

  entre 0 et 6 pour définir une octave spécifique.  Il peut également être un signe plus (+) ou
        moins (-) caractère pour augmenter ou diminuer l'octave en cours
        nombre.  Octave 4 contient du milieu C, et si aucune commande O est présent, O4
        est assumé.

P Pause (repos) pendant la durée spécifiée par la commande la plus récente de L.

Sn Réglez la quantité de silence entre les notes. La valeur de n est un nombre entier

  entre 0 et 2. Si n est 0, chaque note joue pendant toute la période fixée par
        la commande L (musique legato).  Si n est 1, chaque note joue pour 7/8 la
        délai fixé par la commande L (musique normale).  Si n est 2, chaque note joue
        pour 3/4 de la période définie par la commande L (musique saccadée).  Si aucun S
        commande est présente, S1 est supposé.

Tn Réglez le tempo de la musique (le nombre de notes trimestre par minute).

  La valeur de n est un entier compris entre 32 et 255. Si aucune commande de T est
        présente, T120 est supposé.


  La routine fg_music ignore tous les autres personnages de music_string.  Ça aussi
   ignore les valeurs de commande en dehors de la plage autorisée, comme T20 ou O8.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet s'il y a du son asynchrone en cours.

*'''Voir aussi'''

  fg_musicb

*'''Exemples'''

  15-3

===fg_musicb===

*'''Prototype'''

  fg_musicb void (char * music_string, int nTimes);
   FGmusicb sous (music_string de $, nTimes%)
   sous-programme fg_musicb (char music_string, int nTimes)
   procédure fg_musicb (music_string: string; nTimes: integer);

*'''But'''

  La routine fg_musicb utilise la minuterie programmable pour jouer une séquence de
   tonalités musicales, simultanées avec d'autres activités.

*'''Paramètres'''

  music_string est une séquence de commandes de musique arbitraire de longueur, suivie par
   un signe dollar ($) terminateur.  Reportez-vous à *'''But''' de fg_music pour une
   liste complète des commandes de musique.

  nTimes spécifie le nombre de fois pour faire défiler les commandes de musique en
   music_string.  Si nTimes est négatif, la musique va jouer répétitivement jusqu'à ce que
   vous arrêtez avec fg_hush ou fg_hushnext.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet s'il y a du son asynchrone déjà en
   la progression.

  Pour permettre la musique tempo rapide, Fastgraph quadruple temporairement l'horloge
   cocher taux d'interruption de 18,2 à 72,8 tiques par seconde tout en produisant
   son asynchrone.  Parce que de nombreux contrôleurs de disques comptent sur le 18,2 par tick
   deuxième fréquence d'horloge pour synchroniser les accès disque, vos programmes ne devraient pas
   effectuer toutes les opérations de disque lorsque le son asynchrone est en cours.

*'''Voir aussi'''

  fg_hush, fg_hushnext, fg_music, fg_playing, fg_resume, fg_suspend

*'''Exemples'''

  15-6, 15-7, 15-8

===fg_numlock===

*'''Prototype'''

  int fg_numlock (void);
   fonction FGnumlock% ()
   int fonction fg_numlock ()
   fonction fg_numlock: integer;

*'''But'''

  La routine fg_numlock détermine l'état de la touche Verr Num.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Si la valeur de retour est 0, cela signifie que la touche Verr Num est éteint.  Si elle est de 1, il
   signifie la touche Verr Num est activée.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_capslock, fg_scrlock, fg_setcaps, fg_setnum

*'''Exemples'''

  14-4

===fg_pack===

*'''Prototype'''

  vide fg_pack (char * source char * dest, int largeur, int hauteur);
   FGpack sous (source $, $ dest, largeur%, hauteur%)
   sous-programme fg_pack (source int1, dest int1, int largeur, int hauteur)
   procédure fg_pack (source var, dest; largeur, hauteur: integer);

*'''But'''

  La routine de fg_pack convertit un bitmap dans le format "un pixel par octet"
   utilisé dans les modes graphiques 256 couleurs et des tampons virtuels en mode spécifique
   format bitmap pour le mode vidéo en cours.  Reportez-vous à la Fastgraph l'utilisateur
   Guide pour toutes les infos sur bitmaps spécifiques au mode.

  Dans les modes graphiques 256 couleurs, ou quand un tampon virtuel est actif, fg_pack
   simplement une copie du tableau de source à la matrice de dest.

*'''Paramètres'''

  source est le nom du tableau contenant le bitmap "un pixel par octet"
   convertir.

  dest est le nom du tableau qui recevra le bitmap converti.

  largeur est la largeur de l'image source en pixels.

  la hauteur correspond à la hauteur de l'image source en pixels.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille de la source et dest réseaux est limitée à 64K
   octets.

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_clpimage, fg_drwimage, fg_flpimage, fg_getimage, fg_putimage,
   fg_revimage, fg_scale, fg_shear, fg_unpack

*'''Exemples'''

  10-15

===fg_pagesize===

*'''Prototype'''

  longue fg_pagesize (void);
   fonction FGpagesize & ()
   fonction int4 fg_pagesize ()
   fonction fg_pagesize: longint;

*'''But'''

  La routine fg_pagesize renvoie la page vidéo taille en octets pour le
   mode vidéo actuel.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  La taille de la page vidéo en octets.  La valeur de retour est toujours une quantité de 32 bits.

*'''Restrictions'''

  Cette routine renvoie toujours la taille de la page vidéo, même quand un tampon virtuel
   c'est actif.

===fg_paint===

*'''Prototype'''

  fg_paint void (int ix, iy int);
   Sous FGpaint (ix% iy%)
   fg_paint sous-programme (int ix, iy int)
   procédure fg_paint (ix, iy: integer);

*'''But'''

  La routine de fg_paint remplit une région arbitraire fermée avec le courant
   valeur couleur.  La région est définie en spécifiant un point de l'espace de l'écran
   au sein de son intérieur.

*'''Paramètres'''

  ix est l'espace x écran coordonnée du point intérieur.

  iy est l'espace de l'écran y coordonnée du point intérieur.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.  Les bords de l'écran ne sont pas
   considéré les limites des régions, et en remplissant une région ouverte provoquera
   fg_paint à se comporter de façon imprévisible.

*'''Voir aussi'''

  fg_flood, fg_paintw

*'''Exemples'''

  6-17, 13-5

===fg_paintw===

*'''Prototype'''

  fg_paintw void (double x, double y);
   sous FGpaintw (x #, y #)
   fg_paintw sous-programme (dbl x, dbl y)
   procédure fg_paintw (x, y: real);

*'''But'''

  La routine de fg_paintw remplit une région arbitraire fermée avec le courant
   valeur couleur.  La région est définie en spécifiant un point de l'espace mondial dans
   son intérieur.

*'''Paramètres'''

  x est l'espace x mondiale coordonnée du point intérieur.

  y est l'espace du monde y coordonnée du point intérieur.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.  Les bords de l'écran ne sont pas considérés comme des limites des régions, et
   remplir une région ouverte provoquera fg_paintw à se comporter de façon imprévisible.

*'''Voir aussi'''

  fg_floodw, fg_paint

===fg_palette===

*'''Prototype'''

  fg_palette void (int number, int couleur);
   FGpalette sous (numéro%, couleur%)
   fg_palette sous-programme (nombre int, int couleur)
   procédure fg_palette (nombre, couleur: integer);

*'''But'''

  La routine fg_palette a des fonctions différentes en fonction du courant
   graphiques en mode vidéo.  Pour CGA modes de quatre couleurs (modes 4 et 5), il
   établit la palette actuelle et définit la couleur de fond pour que
   palette.  Dans le mode deux couleurs CGA (mode 6), il définit le premier plan
   Couleur.  Pour les modes graphiques 16 couleurs (mode 9, 13, 14, 15, 16, 17, 18, 28,
   et 29), il définit la valeur d'un registre de palette.  Pour 256 graphiques couleur
   modes (modes 19 à 27), il définit la valeur d'un registre vidéo DAC.

*'''Paramètres'''

  Les significations du nombre et couleur paramètres dépendent de la vidéo en cours
   mode.  Le tableau suivant résume les significations des paramètres et juridique
   valeurs pour chaque mode vidéo.

  paramètre de numéro de mode (plage) paramètre de couleur (plage)

  4-5 CGA numéro de palette (0 à 5) couleur de fond (0 à 15)
   6 couleur de premier plan ignoré (0 à 15)
   9 registre de la palette (0 à 15) Valeur de la palette (0 à 15)
   13-14 registre de la palette (0 à 15) Valeur de la palette (0 à 23)
   15 palette de registre (0, 1, 4 ou 5) la valeur de la palette (0, 8, ou 24)
   16 registre de la palette (0 à 15) Valeur de la palette (0 à 63)
   registre 17 de la palette (0 ou 1) registre vidéo DAC (0 à 15)
   18 registre de la palette (0 à 15) vidéo registre DAC (0 à 15)
   19-27 vidéo registre DAC (0 à 255) Valeur DAC (0 à 63)
   28-29 registre de la palette (0 à 15) vidéo registre DAC (0 à 15)

  Reportez-vous au chapitre 5 du Guide de l'utilisateur Fastgraph pour plus spécifique
   des informations sur le nombre et la couleur des paramètres.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes vidéo de texte ou les modes graphiques Hercules.
   Changer la couleur de premier plan (en mode 6) fonctionne toujours vrai CGA
   adaptateurs, mais il y a très peu d'adaptateurs EGA et VGA qui correctement
   mettre en œuvre cette fonctionnalité dans leur mode d'émulation 6.

*'''Voir aussi'''

  fg_defcolor, fg_maprgb, fg_palettes, fg_setcolor, fg_setdacs, fg_setrgb

*'''Exemples'''

  5-1, 5-2, 5-3, 5-6, 5-7, 5-8, 5-9, 5-13, 5-16, 9-11

===fg_palettes===

*'''Prototype'''

  fg_palettes void (int * de color_array);
   sous FGpalettes (color_array% ())
   fg_palettes sous-programme (int color_array)
   fg_palettes procédure (var color_array: integer);

*'''But'''

  La routine fg_palettes définit tous les registres 16 de la palette (en 16 couleurs
   modes graphiques), ou les 16 premiers registres vidéo DAC (en 256 couleurs graphiques
   modes).

*'''Paramètres'''

  color_array est un tableau de 16 éléments qui contient les valeurs à attribuer à la
   registres de palette ou registres vidéo du CAD.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes vidéo de texte, les modes graphiques CGA, ou
   modes graphiques Hercules.

*'''Voir aussi'''

  fg_maprgb, fg_palette, fg_setdacs

*'''Exemples'''

  5-14

===fg_pan===

*'''Prototype'''

  fg_pan void (int ix, iy int);
   FGpan sous (ix%, iy%)
   fg_pan sous-programme (int ix, iy int)
   procédure fg_pan (ix, iy: integer);

*'''But'''

  La routine fg_pan modifie l'origine de l'écran (le coin supérieur gauche de la
   écran) à l'espace d'écran spécifié coordonnées.

*'''Paramètres'''

  ix est le nouvel espace de l'écran coordonnée x de l'origine de l'écran.

  iy est le nouvel espace d'écran coordonnée y de l'origine de l'écran.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.  À cause du matériel
   limites, seules certaines positions de coordonnées peuvent être utilisés comme écran
   origine.  Fastgraph compense ces restrictions en réduisant ix et iy
   à des valeurs acceptables dans les modes vidéo pertinents, comme indiqué ici:

  x sera réduite y sera réduite
               mode vidéo à un multiple de: à un multiple de:

  4 à 5 août 2
                    6 16 2
                    9 4 4
                   11 8 4
                   12 4 2 ou 3

  La routine de fg_pan applique toujours à la mémoire vidéo, même lorsqu'un virtuel
   tampon est actif.

*'''Voir aussi'''

  fg_panw

*'''Exemples'''

  13-6, 13-7, 13-9

fg_panw

*'''Prototype'''

  fg_panw void (double x, double y);
   sous FGpanw (x #, y #)
   fg_panw sous-programme (dbl x, dbl y)
   procédure fg_panw (x, y: real);

*'''But'''

  La routine fg_panw modifie l'origine de l'écran (le coin supérieur gauche de la
   écran) pour les coordonnées spatiales du monde spécifiées.

*'''Paramètres'''

  x est le nouvel espace mondial coordonnée x de l'origine de l'écran.

  y est le nouvel espace mondial coordonnée y de l'origine de l'écran.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
   modes vidéo.

  Pour compenser les limitations matérielles qui limitent l'origine de l'écran
   coordonnées (voir *'''But''' de fg_pan), Fastgraph réduit x et y
   un niveau acceptable équivalent de l'espace de l'écran.

  La routine de fg_panw applique toujours à la mémoire vidéo, même lorsqu'un virtuel
   tampon est actif.

*'''Voir aussi'''

  fg_pan

===fg_pattern===

*'''Prototype'''

  fg_pattern void (int index, int display_pattern);
   FGpattern sous (indice%, display_pattern%)
   fg_pattern sous-programme (int index, int display_pattern)
   procédure fg_pattern (index, display_pattern: integer);

*'''But'''

  La routine fg_pattern définit l'un des 256 modèles d'affichage de Fastgraph utilisé
  avec fg_dispfile, fg_display, fg_displayp, fg_showppr ou fg_showspr.  Quand
  l'utilisation de ces routines pour afficher une carte pixel de l'exécution, Fastgraph utilisera le
  motif associé à cet indice de couleur au lieu d'afficher la couleur
   lui-même. Reportez-vous au Guide de l'utilisateur Fastgraph pour plus d'informations sur
  modèles d'affichage et leurs valeurs par défaut pour chaque mode graphique vidéo.

*'''Paramètres'''

 l'indice est le nombre du motif d'affichage pour définir, entre 0 et 255.

display_pattern représente un motif d'affichage 16 bits. Sa structure dépend
  le mode vidéo, telles qu'elles sont résumées ici:

 Modes vidéo structure de motif

 4, 5, 12 comptage de décalage (8 bits), quatre pixels (2 bits chacun)
    6, le nombre 11 de décalage (8 bits), huit pixels (1 bit)
    compte 9 décalage (8 bits), deux pixels (4 bits chacun)
    13-16, 18, 28, 29 inutilisés (8 bits), deux pixels (4 bits)
    17 inutilisés (14 bits), deux pixels (1 bit)

 Le compte de décalage définit le nombre de bits qui est tourné display_pattern
  gauche lorsqu'elle est appliquée à des rangées de pixels impaires, tandis que les pixels sont
  les valeurs des couleurs réelles répliqués à travers le cycle de pixel. Pour l'EGA et VGA
  les modes graphiques, un nombre de décalage d'un pixel implicite est utilisé.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet dans les modes vidéo de texte ou 256 couleurs graphiques
  modes.

*'''Voir aussi'''

 fg_dispfile, fg_display, fg_displayp, fg_showppr, fg_showspr

*'''Exemples'''

 9-11

===fg_pcxhead===

*'''Prototype'''

 int fg_pcxhead (char * pcx_file, char * pcx_header);
  fonction FGpcxhead% (pcx_file $, pcx_header $)
  int fonction fg_pcxhead (char pcx_file, pcx_header int1)
  fonction fg_pcxhead (pcx_file: string; var pcx_header: byte): integer;

*'''But'''

 La routine de fg_pcxhead lit un en-tête de fichier PCX dans un tampon de 128 octets.

*'''Paramètres'''

pcx_file est le nom du fichier PCX. Elle peut inclure une spécification de trajet
  et doit être terminée par un octet nul.

 pcx_header est le nom de la mémoire tampon de 128 octets pour recevoir le fichier PCX
   entête. En BASIC, il doit être une longueur fixe chaîne de 128 octets.

*'''Valeur de retour'''

 0 = Succès
  -1 = Le fichier spécifié n'existe pas
  -2 = Le fichier spécifié est pas un fichier PCX

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_loadpcx, fg_pcxmode, fg_pcxpal, fg_pcxrange, fg_showpcx

*'''Exemples'''

 9-2

===fg_pcxmode===

*'''Prototype'''

 int fg_pcxmode (char * pcx_header);
  fonction FGpcxmode% (pcx_header $)
  fonction int fg_pcxmode (int1 pcx_header)
  fonction fg_pcxmode (var pcx_header: byte): integer;

*'''But'''

 La routine fg_pcxmode détermine le mode vidéo optimal pour l'affichage d'une
  fichier PCX. Le mode optimal est le mode vidéo compatible ayant la plus faible
  résolution supérieure ou égale aux dimensions de l'image.  Voir le
  description de fg_showpcx pour une table de modes vidéo compatibles pour PCX
   fichiers.

*'''Paramètres'''

 pcx_header est le nom d'un tampon de 128 octets contenant l'en-tête de fichier PCX.
  En BASIC, il doit être une longueur fixe chaîne de 128 octets.

*'''Valeur de retour'''

 > 0 = Le mode vidéo optimal pour afficher l'image PCX
  -1 = Pcx_header ne contient pas un en-tête de fichier PCX valide
  -2 = Impossible de déterminer un mode vidéo compatible

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_pcxhead, fg_setmode, fg_showpcx

*'''Exemples'''

 9-2

===fg_pcxpal===

*'''Prototype'''

 int fg_pcxpal (char * pcx_file, char * pcx_palette);
  fonction FGpcxpal% (pcx_file $, pcx_palette $)
  int fonction fg_pcxpal (char pcx_file, pcx_palette int1)
  fonction fg_pcxpal (pcx_file: string; var pcx_palette): integer;

*'''But'''

 La routine fg_pcxpal extrait la palette d'une image stockée dans un PCX
   fichier. Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chacune entre
  0 et 63. Pour les modes vidéo 18 et au-dessus, les valeurs de la palette sont adaptés pour
  fg_setdacs. Pour les modes natifs EGA graphiques (13 à 16), la palette
  les valeurs doivent être converties en valeurs spécifiques au mode (avec fg_maprgb) avant
  être utilisé avec fg_palette ou fg_palettes.

 Si le fichier PCX comprend un (256 couleurs) palette étendue, volonté fg_pcxpal
  renvoyer les valeurs dans la palette étendue. Sinon, fg_pcxpal retournera
  les valeurs de la palette de 16 couleurs dans l'en-tête PCX.

*'''Paramètres'''

pcx_file est le nom du fichier PCX. Le nom du fichier doit se terminer par un
   octet nul.

 pcx_palette est le nom du tableau qui va recevoir la palette PCX
   valeurs. Les valeurs de la palette sont renvoyées en tant que composants de couleur RVB, chaque
  entre 0 et 63. Les trois premiers octets de pcx_palette contiendra RGB
  des valeurs pour la couleur 0, les trois prochaines pour la couleur 1, et ainsi de suite.  La taille de
  la matrice de pcx_palette doit être au moins trois fois le nombre de couleurs
  l'image PCX.

*'''Valeur de retour'''

 > 0 = le nombre de couleurs dans la palette de PCX (16 ou 256)
  -1 = Fichier non trouvé
  -2 = Fichier est pas un fichier PCX

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_loadpcx, fg_maprgb, fg_pcxhead, fg_palette, fg_palettes, fg_setdacs,
  fg_showpcx

*'''Exemples'''

 9-3

===fg_pcxrange===

*'''Prototype'''

 fg_pcxrange void (char * pcx_header, int * mijaurée, int * maxx, int * Miny,
    int * maxy);
  FGpcxrange sous (pcx_header de $, minx%, maxx%, miny%, maxy%)
  fg_pcxrange sous-programme (int1 pcx_header, int minx, maxx int, int Miny,
    int maxy)
  procédure fg_pcxrange (var pcx_header; var minx, maxx, Miny, Maxy:
    entier);

*'''But'''

 La routine fg_pcxrange retourne les étendues d'image pour l'image PCX
  associé à l'en-tête de fichier PCX spécifié.

*'''Paramètres'''

 pcx_header est le nom de la mémoire tampon contenant le fichier PCX 128 octets
   entête.

minx reçoit les coordonnées x du bord gauche de l'image. Si pcx_header ne
  contient pas un en-tête de fichier PCX valide, minx sera défini à -1.

maxx reçoit les coordonnées x du bord droit de l'image. Si pcx_header
  ne contient pas un en-tête de fichier PCX valide, maxx sera défini à -1.

Miny reçoit la coordonnée y de bord supérieur de l'image. Si pcx_header ne
  pas contenir un en-tête de fichier PCX valide, miny sera fixé à -1.

Maxy reçoit la coordonnée y de bord inférieur de l'image. Si pcx_header
  ne contient pas un en-tête de fichier PCX valide, maxy sera défini à -1.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_pcxhead, fg_loadpcx, fg_showpcx

*'''Exemples'''

 9-3

===fg_playing===

*'''Prototype'''

 int fg_playing (void);
  fonction FGplaying% ()
  int fonction fg_playing ()
  fonction fg_playing: integer;

*'''But'''

 La routine fg_playing détermine si oui ou non il y a une asynchrone
  le son en cours.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 Si la valeur de retour est 0, cela signifie qu'il n'y a pas de son asynchrone
  la progression. Si elle est 1, alors il y a du son asynchrone en cours.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_musicb, fg_sounds, fg_voices

*'''Exemples'''

 15-4, 15-5, 15-6, 15-7, 15-8

===fg_point===

*'''Prototype'''

 fg_point void (int ix, iy int);
  Sous FGpoint (ix% iy%)
  fg_point sous-programme (int ix, iy int)
  procédure fg_point (ix, iy: integer);

*'''But'''

 La routine de fg_point dessine un point (affiche un pixel) dans l'espace de l'écran.

*'''Paramètres'''

 ix est l'écran l'espace x du point de coordonnées.

 iy est l'espace de l'écran du point de coordonnée y.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_pointw, fg_pointx

*'''Exemples'''

 6-1

===fg_pointw===

*'''Prototype'''

 fg_pointw void (double x, double y);
  sous FGpointw (x #, y #)
  fg_pointw sous-programme (dbl x, dbl y)
  procédure fg_pointw (x, y: real);

*'''But'''

 La routine de fg_pointw dessine un point (affiche un pixel) dans l'espace mondial.

*'''Paramètres'''

 x est l'espace du monde du point de coordonnée x.

 y est l'espace du point de monde y coordonnées.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

*'''Voir aussi'''

 fg_point, fg_pointxw


===fg_pointx===

*'''Prototype'''

 fg_pointx void (int ix, iy int);
  sous FGpointx (ix% iy%)
  fg_pointx sous-programme (int ix, iy int)
  procédure fg_pointx (ix, iy: integer);

*'''But'''

 La routine de fg_pointx dessine un point (affiche un pixel) dans "ou exclusif"
  mode dans l'espace de l'écran.

*'''Paramètres'''

 ix est l'écran l'espace x du point de coordonnées.

 iy est l'espace de l'écran du point de coordonnée y.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

 Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
  est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

 fg_point, fg_pointxw

===fg_pointxw===

*'''Prototype'''

 fg_pointxw void (double x, double y);
  FGpointxw sub (x #, y #)
  fg_pointxw sous-programme (dbl x, dbl y)
  procédure fg_pointxw (x, y: real);

*'''But'''

 La routine de fg_pointxw dessine un point (affiche un pixel) dans "ou exclusif"
  mode dans l'espace mondial.

*'''Paramètres'''

 x est l'espace du monde du point de coordonnée x.

 y est l'espace du point de monde y coordonnées.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

 Dans 16 couleurs des modes EGA, VGA ou SVGA graphiques, le registre de la fonction EGA / VGA
  est remis à son mode de remplacement par défaut sur le retour.

*'''Voir aussi'''

 fg_pointw, fg_pointx

===fg_polyedge===

*'''Prototype'''

 fg_polyedge void (int edge_flag);
  FGpolyedge sous (edge_flag%)
  sous-programme fg_polyedge (int edge_flag)
  procédure fg_polyedge (edge_flag: integer);

*'''But'''

 La routine de fg_polyedge spécifie si les polygones dessinés avec fg_polyfill sera
  leur droit et en bas des pixels de bord inclus. Par défaut, ces pixels
  sont exclus.

*'''Paramètres'''

 edge_flag contrôle le dessin du bord droit et en bas d'un polygone rempli
  pixels. Si edge_flag est 0, ces pixels sont inclus. Si elle est de 1, ceux-ci
  pixels sont exclus.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_polyfill

===fg_polyfill===

*'''Prototype'''

 fg_polyfill void (int * vertex_array, int * work_array, int n);
  FGpolyfill sous (vertex_array% (), work_array% (), n%)
  sous-programme fg_polyfill (int vertex_array, int work_array, int n)
  procédure fg_polyfill (var vertex_array, work_array: integer;
    n: nombre entier);

*'''But'''

 La routine de fg_polyfill dessine un polygone convexe rempli dans l'espace de l'écran.  le
  polygone est rempli avec des pixels de la couleur sélectionnée. Par défaut, les pixels
  le long des bords droit et inférieur du polygone sont exclus pour améliorer polygone
  engrener. Cette fonctionnalité peut être désactivée via fg_polyedge.

*'''Paramètres'''

 vertex_array est le nom du tableau contenant le (x, y) paires de coordonnées
  de chaque sommet. Le premier élément de tableau est la composante x du premier
  sommet, le second élément est la composante y du premier sommet, la
  troisième élément est la composante x du deuxième sommet, et ainsi de suite.

work_array est utilisé en interne par fg_polyfill. Sa taille en octets doit être au
  au moins quatre fois la hauteur du polygone écrêté.

 n est le nombre de sommets du polygone.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Si vous essayez de remplir un polygone non convexe, seule une partie de celui-ci sera
  rempli.

 Dans les modes de 16 bits, la taille des vertex_array et work_array est limitée à 64K
   octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_polyedge, fg_polyline, fg_polyoff

*'''Exemples'''

 6-8

===fg_polygon===

*'''Prototype'''

 fg_polygon void (int * de ix_array, int * iy_array, int n);
  sous FGpolygon (ix_array% (), iy_array% (), n%)
  sous-programme fg_polygon (int ix_array, int iy_array, int n)
  procédure fg_polygon (var ix_array, iy_array: integer; n: nombre entier);

*'''But'''

 La routine de fg_polygon dessine un polygone vide dans l'espace de l'écran, en utilisant deux
  coordonner des réseaux pour définir les sommets du polygone. Le dessin de la
  polygone commence au niveau du premier sommet défini dans les matrices de coordonnées,
  à travers les sommets restants dans l'ordre, et enfin de retour à la première
  vertex si nécessaire.

*'''Paramètres'''

 ix_array est le nom du tableau contenant l'espace écran coordonnées x
  des sommets du polygone.

 iy_array est le nom du tableau contenant l'espace écran coordonnées y
  des sommets du polygone.

 n est le nombre de sommets du polygone.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des ix_array et iy_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_polyline, fg_polygonw

*'''Exemples'''

 6-7

===fg_polygonw===

*'''Prototype'''

 fg_polygonw void (double * de x_array, double * y_array, int n);
  sous FGpolygonw (x_array # (), y_array # (), n%)
  fg_polygonw sous-programme (dbl x_array, dbl y_array, int n)
  procédure fg_polygonw (var x_array, y_array: real; n: nombre entier);

*'''But'''

 La routine de fg_polygonw dessine un polygone dans l'espace non rempli de monde, en utilisant deux
  coordonner des réseaux pour définir les sommets du polygone. Le dessin de la
  polygone commence au niveau du premier sommet défini dans les matrices de coordonnées,
  à travers les sommets restants dans l'ordre, et enfin de retour à la première
  vertex si nécessaire.

*'''Paramètres'''

 x_array est le nom du tableau contenant les espaces du monde coordonnées x
  des sommets du polygone.

 y_array est le nom du tableau contenant les espaces du monde coordonnées y
  des sommets du polygone.

 n est le nombre de sommets du polygone.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des x_array et y_array est limitée à 64K octets.

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

*'''Voir aussi'''

 fg_polygon

===fg_polyline===

*'''Prototype'''

 fg_polyline void (int * vertex_array, int n);
  FGpolyline sous (vertex_array% (), n%)
  fg_polyline sous-programme (int vertex_array, int n)
  procédure fg_polyline (var vertex_array: integer; n: nombre entier);

*'''But'''

 La routine de fg_polyline dessine un polygone vide dans l'espace de l'écran, en utilisant un
  seul tableau pour définir les sommets du polygone. Comparez cela à fg_polygon,
  qui utilise des matrices séparées pour les composants x et y de chaque sommet.

*'''Paramètres'''

 vertex_array est le nom du tableau contenant le (x, y) paires de coordonnées
  de chaque sommet. Le premier élément de tableau est la composante x du premier
  sommet, le second élément est la composante y du premier sommet, la
  troisième élément est la composante x du deuxième sommet, et ainsi de suite.

 n est le nombre de sommets du polygone.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des vertex_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_polyfill, fg_polygon, fg_polyoff

*'''Exemples'''

 6-8

===fg_polyoff===

*'''Prototype'''

 fg_polyoff void (int ix, iy int);
  Sous FGpolyoff (ix% iy%)
  fg_polyoff sous-programme (int ix, iy int)
  procédure fg_polyoff (ix, iy: integer);

*'''But'''

 La routine fg_polyoff définit l'espace de l'écran de décalage appliqué à chaque
  polygone sommet pour fg_inside, fg_polyfill et fg_polyline.  Par défaut, le
  fonctions d'affichage de polygones utilisent un décalage de zéro, ce qui signifie leur sommet
  les tableaux indiquent les coordonnées réelles des sommets.

*'''Paramètres'''

 ix est l'espace d'écran horizontal décalage appliqué à la composante x de tous
  sommets.

 iy est l'espace vertical de l'écran de décalage appliquée à la composante y de tous
  sommets.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_inside, fg_polyfill, fg_polyline

*'''Exemples'''

 6-8

===fg_print===

*'''Prototype'''

 fg_print void (char * string, int n);
  FGprint sub (chaîne de $, n%)
  fg_print sous-programme (chaîne de char, int n)
  procédure fg_print (string: string; n: nombre entier);

*'''But'''

 Les affichages de routine fg_print une chaîne de caractères de matériel par rapport à
  la position actuelle des graphiques en utilisant l'indice de couleur actuel, sans
  coupure. Par défaut, les chaînes sont affichées de telle sorte que la rangée du bas de la
  le premier caractère est à la position graphique courante. En retour, le
  graphiques curseur est positionné juste à droite du dernier caractère
   affiché.

*'''Paramètres'''

 chaîne est la séquence de caractères à afficher arbitraire de longueur.

 n est le nombre de caractères à afficher à partir de la chaîne.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_justify, fg_printc, fg_text

*'''Exemples'''

 7-6, 10-17, 10-18, 13-7

===fg_printc===

*'''Prototype'''

 fg_printc void (char * string, int n);
  sous FGprintc (string $, n%)
  fg_printc sous-programme (chaîne de char, int n)
  procédure fg_printc (string: string; n: nombre entier);

*'''But'''

 Les affichages de routine fg_printc une chaîne de caractères de matériel par rapport à
  la position graphique actuelle à l'aide de l'indice de couleur actuelle. Par défaut,
  chaînes sont affichées de telle sorte que la rangée du bas du premier caractère est à
  la position graphique actuelle. Seule la partie de la chaîne qui tombe
  dans les limites d'écrêtage actuelles seront affichées. En retour, le
  graphiques curseur est positionné juste à droite du dernier caractère
   affiché.

*'''Paramètres'''

 chaîne est la séquence de caractères à afficher arbitraire de longueur.

 n est le nombre de caractères à afficher à partir de la chaîne.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_print, fg_setclip, fg_textc

===fg_putblock===

*'''Prototype'''

 fg_putblock void (char [bien] * buffer, int minx, maxx int, int Miny,
    int maxy);
  FGputblock sous ($ buffer, minx%, maxx%, miny%, maxy%)
  sous-programme fg_putblock (int1 tampon [bien], int minx, maxx int, int Miny,
    int maxy)
  procédure fg_putblock (buffer: pointeur; minx, maxx, Miny, Maxy: integer);

*'''But'''

 La routine fg_putblock affiche un bloc (précédemment obtenu avec
  fg_getblock) à la position indiquée sur la page vidéo active ou virtuelle
  tampon.  Dans les modes de texte, les extrêmes de blocs sont définis dans l'espace de caractère;
  dans les modes graphiques, ils sont définis dans l'espace de l'écran.

*'''Paramètres'''

tampon est le nom du tableau contenant le bloc. Il est passé de loin
  référence en modes 16 bits, sauf lors de l'utilisation BASIC.

minx est la coordonnée x du bord gauche du bloc. Dans les modes graphiques, son
  La valeur est réduite à une limite d'octet, si nécessaire.

maxx est la coordonnée X du bord droit du bloc. Il doit être supérieur à
  ou égale à la valeur de minx. Dans les modes graphiques, sa valeur est étendue à
  une limite d'octet, si nécessaire.

 Miny est la coordonnée y de la bordure supérieure du bloc.

Maxy est la coordonnée y du bord inférieur du bloc. Elle doit être supérieure
  supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille du buffer est limitée à 64K octets.

 Dans les programmes Pascal en mode réel, le tampon doit être allouée de façon dynamique avec le
  procédure GetMem. Ceci est la seule façon de transmettre quelque chose par référence loin
  en Pascal.

*'''Voir aussi'''

 fg_getblock

*'''Exemples'''

 11-10

===fg_putimage===

*'''Prototype'''

 fg_putimage void (char * map_array, int largeur, int hauteur);
  FGputimage sub (map_array de $, largeur%, hauteur%)
  fg_putimage sous-programme (INT1 map_array, int largeur, int hauteur)
  procédure fg_putimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

 La routine fg_putimage affiche une image stockée sous forme de bitmap mode spécifique,
  sans traiter la couleur 0 aussi transparent. L'image sera positionné de façon
  que son coin inférieur gauche est à la position du curseur graphique.  Se référer au
  Guide de l'utilisateur Fastgraph pour des informations complètes sur le mode spécifique
  bitmaps.

*'''Paramètres'''

 map_array est le nom du tableau contenant le bitmap.

 largeur est la largeur en octets de la bitmap.

 hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

*'''Voir aussi'''

 fg_drwimage, fg_getimage, fg_invert, fg_pack, fg_unpack

*'''Exemples'''

 10-8, 10-9, 10-17, 10-18

===fg_quiet===

*'''Prototype'''

 fg_quiet void (void);
  FGquiet sub ()
  sous-routine fg_quiet ()
  procédure fg_quiet;

*'''But'''

 La routine fg_quiet arrête son synchrone continu a commencé avec
  fg_sound ou fg_voice. Il n'a aucun effet s'il n'y a pas de son continu
  la progression.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_sound, fg_voice

*'''Exemples'''

 15-2

===fg_rect===

*'''Prototype'''

 fg_rect void (int minx, maxx int, int Miny, int maxy);
  FGrect sous (minx de%, maxx%, miny%, maxy%)
  sous-programme fg_rect (int minx, maxx int, int Miny, int maxy)
  procédure fg_rect (minx, maxx, Miny, Maxy: integer);

*'''But'''

 La routine de fg_rect dessine un solide (rempli) rectangle dans l'espace de l'écran ou
  un espace de caractère, sans tenir compte de la zone de découpage.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche du rectangle.

maxx est la coordonnée X du bord droit du rectangle. Elle doit être supérieure
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur du rectangle.

Maxy est la coordonnée y du bord inférieur du rectangle. Elle doit être supérieure
  supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_box, fg_clprect, fg_drect, fg_rectw

*'''Exemples'''

 5-8, 5-10, 6-11, 6-13, 7-5, 7-9

===fg_rectw===

*'''Prototype'''

 fg_rectw void (double xmin, double xmax, double ymin, double ymax);
  FGrectw sous (xmin de #, xmax #, ymin #, ymax #)
  fg_rectw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
  procédure fg_rectw (xmin, xmax, ymin, ymax: real);

*'''But'''

 La routine de fg_rectw dessine un solide (rempli) rectangle dans l'espace mondial,
  sans tenir compte de la zone de découpage.

*'''Paramètres'''

 xmin est l'espace x mondiale coordonnée du bord gauche du rectangle.

 xmax est l'espace x mondiale coordonnée bord droit du rectangle.  Il doit
  soit supérieure ou égale à la valeur de xmin.

 ymin est l'espace du monde y coordonnée du bord inférieur du rectangle.

 ymax est l'espace du monde y coordonnée du bord supérieur du rectangle.  Il doit
  soit supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_boxw, fg_clprectw, fg_drectw, fg_rect

*'''Exemples'''

 7-13

===fg_reset===

*'''Prototype'''

 fg_reset void (void);
  sous FGreset ()
  sous-routine fg_reset ()
  procédure fg_reset;

*'''But'''

 Lorsque le pilote ANSI.SYS est pas chargé, fg_reset efface l'écran.  Quand
  ANSI.SYS est chargé, fg_reset restaure également un écran précédemment défini
  les attributs. Il est généralement la dernière routine Fastgraph appelé dans un programme.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

 fg_erase

*'''Exemples'''

 3-2

===fg_resize===

*'''Prototype'''

 fg_resize void (largeur, int hauteur);
  FGresize sub (largeur%, hauteur%)
  fg_resize sous-programme (largeur, int hauteur)
  procédure fg_resize (largeur, hauteur: integer);

*'''But'''

 La routine fg_resize modifie les dimensions d'une page vidéo EGA, VGA,
  et modes SVGA graphiques.

*'''Paramètres'''

 largeur spécifie la nouvelle largeur de la page vidéo en pixels.

 hauteur spécifie la nouvelle hauteur de la page vidéo en pixels.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 La taille d'une page vidéo est limitée seulement par la quantité de mémoire vidéo
   disponible. L'augmentation de la taille de la page vidéo réduit le nombre de physique
  pages disponibles proportionnellement. Dans le mode 13, par exemple, en augmentant la
  taille de la page de 320x200 à 640x400 réduit le nombre de pages vidéo de 8
  à 2.

 Lorsque vous appelez fg_resize, la page visuelle doit être la page 0.

 Si vous avez créé des pages vidéo logiques, vous devez les libérer avec
  fg_freepage avant d'appeler fg_resize, puis créer à nouveau par la suite.

 Si vous avez initialisé la souris (avec fg_mouseini), joysticks (avec
  fg_initjoy), mémoire étendue (avec fg_initems), ou mémoire étendue (avec
  fg_initxms), vous devez réinitialiser ces ressources après l'appel
  fg_resize. La plupart des pilotes de souris attendent une largeur fixe de la page vidéo, de sorte que la souris
  curseur peut se déformer après le redimensionnement des pages vidéo.

 La routine de fg_setmode rétablit les dimensions d'une page vidéo à la
  résolution d'écran par défaut pour le mode vidéo sélectionné.

 pages vidéo partiel (initialement disponibles dans certains modes vidéo) sont
  indisponible après avoir appelé fg_resize, même si vous utilisez ce mode vidéo
  résolution d'origine.

 Cette routine n'a de sens que dans les modes les natifs EGA et VGA graphiques
  (13 à 18), des modes étendus graphiques VGA (20 à 23), et les modes SVGA graphiques
  (24 à 29). Il n'a pas d'effet dans d'autres modes vidéo ou quand un tampon virtuel
  c'est actif.

*'''Voir aussi'''

 fg_pan

*'''Exemples'''

 8-11, 13-7

===fg_restore===

*'''Prototype'''

 fg_restore void (int minx, maxx int, int Miny, int maxy);
  FGrestore sous (minx de%, maxx%, miny%, maxy%)
  sous-programme fg_restore (int minx, maxx int, int Miny, int maxy)
  procédure fg_restore (minx, maxx, Miny, Maxy: integer);

*'''But'''

 La fg_restore copies de routine d'une région rectangulaire de la vidéo cachée
  page à la même position sur la page vidéo active. Dans les modes de texte, le
  région est définie dans un espace de caractère; en mode graphique, il est défini dans la
  l'espace de l'écran. Comme avec d'autres routines de transfert de bloc de Fastgraph, pas
  écrêtage est effectué.

*'''Paramètres'''

minx est la coordonnée x du bord gauche de la région. Dans les modes graphiques, son
  La valeur est réduite à une limite d'octet, si nécessaire.

maxx est la coordonnée X du bord droit de la région. Elle doit être supérieure
  supérieure ou égale à la valeur de minx. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 Miny est la coordonnée y de bord supérieur de la région.

Maxy est la coordonnée y du bord inférieur de la région. Elle doit être supérieure
  supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine applique toujours les pages vidéo, même quand un tampon virtuel est
   actif.

*'''Voir aussi'''

 fg_restorew, fg_save, fg_sethpage, fg_transfer

*'''Exemples'''

 11-2, 11-3

===fg_restorew===

*'''Prototype'''

 fg_restorew void (double xmin, double xmax, double ymin, double ymax);
  FGrestorew sous (xmin de #, xmax #, ymin #, ymax #)
  fg_restorew sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
  procédure fg_restorew (xmin, xmax, ymin, ymax: real);

*'''But'''

 Les copies de routine fg_restorew une zone rectangulaire, définie dans le monde
  l'espace, à partir de la page vidéo cachée à la même position sur la vidéo active
   page. Comme avec d'autres routines de transfert de bloc de Fastgraph, aucun découpage est
   exécutée.

*'''Paramètres'''

 xmin est l'espace x mondiale coordonnée du bord gauche de la région.  Dans les graphiques
  modes, sa valeur est réduite à une limite d'octet si nécessaire.

 xmax est l'espace x mondiale coordonnée bord droit de la région.  Ce doit être
  supérieure ou égale à la valeur de xmin. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 ymin est l'espace du monde y coordonnée du bord inférieur de la région.

 ymax est l'espace du monde y coordonnée du bord supérieur de la région.  Ce doit être
  supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine applique toujours les pages vidéo, même quand un tampon virtuel est
   actif. Il est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_restore, fg_savew, fg_sethpage, fg_transfer

===fg_resume===

*'''Prototype'''

 fg_resume void (void);
  sous FGresume ()
  sous-routine fg_resume ()
  procédure fg_resume;

*'''But'''

 Le redémarrage de routine musique asynchrone fg_resume précédemment suspendu par
  fg_suspend. Il n'a aucun effet s'il n'y a pas de musique suspendue.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_musicb, fg_suspend

*'''Exemples'''

 15-8

===fg_revimage===

*'''Prototype'''

 fg_revimage void (char * map_array, int largeur, int hauteur);
  FGrevimage sub (map_array de $, largeur%, hauteur%)
  fg_revimage sous-programme (INT1 map_array, int largeur, int hauteur)
  procédure fg_revimage (var map_array: octet; largeur, hauteur: integer);

*'''But'''

 Les affichages de routine fg_revimage une image inversée stockée comme un mode spécifique
  bitmap. L'image sera positionnée de sorte que son coin inférieur gauche est à
  les graphiques position du curseur. Reportez-vous au Guide de l'utilisateur Fastgraph pour
  toutes les infos sur bitmaps spécifiques au mode.

*'''Paramètres'''

 map_array est le nom du tableau contenant le bitmap.

 largeur est la largeur en octets de la bitmap.

 hauteur est la hauteur en octets (lignes de pixels) de l'image bitmap.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_clpimage, fg_drwimage, fg_flpimage, fg_getimage, fg_invert, fg_pack,
  fg_putimage, fg_unpack

*'''Exemples'''

 10-8, 10-9

===fg_revmask===

*'''Prototype'''

 fg_revmask void (char * map_array, int runs, int largeur);
  FGrevmask sous (map_array de $, fonctionne%, largeur%)
  sous-programme fg_revmask (int1 map_array, int exécute, int largeur)
  procédure fg_revmask (var map_array: octet; pistes, largeur: integer);

*'''But'''

 Les fg_revmask affiche de routine une image inversée stockée sous forme de carte de masquage.
  L'image sera positionnée de sorte que son coin inférieur gauche est à la
  graphiques position du curseur. Reportez-vous à *'''But''' de fg_drawmask pour plus
  le masquage d'informations sur les cartes.

*'''Paramètres'''

 map_array est le nom du tableau contenant la carte de masquage.

 courses est le nombre de pixels courses dans la carte de masquage.

 largeur est la largeur en pixels de la carte de masquage.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille des map_array est limitée à 64K octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_clipmask, fg_drawmask, fg_flipmask

*'''Exemples'''

 10-23

===fg_save===

*'''Prototype'''

 fg_save void (int minx, maxx int, int Miny, int maxy);
  FGsave sous (minx de%, maxx%, miny%, maxy%)
  sous-programme fg_save (int minx, maxx int, int Miny, int maxy)
  procédure fg_save (minx, maxx, Miny, Maxy: integer);

*'''But'''

 Les copies de routine fg_save une région rectangulaire de la page vidéo active
  à la même position sur la page vidéo masquée. Dans les modes de texte, la région est
  défini dans l'espace de caractère; dans les modes graphiques, il est défini dans l'écran
   espace. Comme avec d'autres routines de transfert de bloc de Fastgraph, aucun découpage est
   exécutée.

*'''Paramètres'''

minx est la coordonnée x du bord gauche de la région. Dans les modes graphiques, son
  La valeur est réduite à une limite d'octet, si nécessaire.

maxx est la coordonnée X du bord droit de la région. Elle doit être supérieure
  supérieure ou égale à la valeur de minx. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 Miny est la coordonnée y de bord supérieur de la région.

Maxy est la coordonnée y du bord inférieur de la région. Elle doit être supérieure
  supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine applique toujours les pages vidéo, même quand un tampon virtuel est
   actif.

*'''Voir aussi'''

 fg_restore, fg_savew, fg_sethpage, fg_transfer

*'''Exemples'''

 11-2, 11-3

===fg_savew===

*'''Prototype'''

 fg_savew void (double xmin, double xmax, double ymin, double ymax);
  sous FGsavew (xmin #, xmax #, ymin #, ymax #)
  fg_savew sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
  procédure fg_savew (xmin, xmax, ymin, ymax: real);

*'''But'''

 Les copies de routine fg_savew une région rectangulaire, définis dans l'espace mondial,
  à partir de la page vidéo active à la même position sur la page vidéo cachée.
  Comme avec d'autres routines de transfert de bloc de Fastgraph, aucun découpage est
   exécutée.

*'''Paramètres'''

 xmin est l'espace x mondiale coordonnée du bord gauche de la région.  Dans les graphiques
  modes, sa valeur est réduite à une limite d'octet si nécessaire.

 xmax est l'espace x mondiale coordonnée bord droit de la région.  Ce doit être
  supérieure ou égale à la valeur de xmin. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 ymin est l'espace du monde y coordonnée du bord inférieur de la région.

 ymax est l'espace du monde y coordonnée du bord supérieur de la région.  Ce doit être
  supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine applique toujours les pages vidéo, même quand un tampon virtuel est
   actif. Il est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_restorew, fg_save, fg_sethpage, fg_transfer

===fg_scale===

*'''Prototype'''

 fg_scale void (char * source char * dest, int sw, int sh, int dw, int dh);
  FGscale sous (source $, dest $, sw%, sh%, dw%, dh%)
  fg_scale sous-programme (int1 source dest int1, int sw, int sh, int dw,
    int dh)
  procédure fg_scale (source var, dest; sw, sh, dw, dh: integer);

*'''But'''

 La routine de fg_scale Pèse une image bitmap stockée dans le "un pixel par
  byte "le format.

*'''Paramètres'''

 source est le nom du tableau contenant le "un pixel par octet"
  image bitmap à l'échelle.

 dest est le nom du tableau qui va recevoir l'image à l'échelle résultant.

SW est la largeur de l'image source en pixels. Il doit être supérieur à
   zéro.

SH est la hauteur de l'image source en pixels. Il doit être supérieur à
   zéro.

dw est la largeur de l'image en pixels dest. Il doit être supérieur à zéro.

dh est la hauteur de l'image en pixels dest. Il doit être supérieur à zéro.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille de la source et dest réseaux est limitée à 64K

octets.

 La largeur maximale admissible ou la hauteur de la source et dest est 1.024 pixels.

*'''Voir aussi'''

 fg_drwimage, fg_pack, fg_putimage, fg_shear, fg_unpack

*'''Exemples'''

 10-17, 10-19

===fg_scrlock===

*'''Prototype'''

 int fg_scrlock (void);
  fonction FGscrlock% ()
  int fonction fg_scrlock ()
  fonction fg_scrlock: integer;

*'''But'''

 La routine fg_scrlock détermine l'état de la clé ScrollLock.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

Si la valeur de retour est 0, cela signifie que la clé ScrollLock est éteint. Si elle vaut 1,
  cela signifie que la clé ScrollLock est activée.

*'''Restrictions'''

tous les claviers PC ne disposent pas d'une clé ScrollLock. Pour de tels systèmes, fg_scrlock
  retourne une valeur de zéro.

*'''Voir aussi'''

 fg_capslock, fg_numlock, fg_setcaps, fg_setnum

*'''Exemples'''

 14-4

===fg_scroll===

*'''Prototype'''

 fg_scroll void (int minx, maxx int, int Miny, int maxy, int saut,
    type int);
  FGscroll sous (minx de%, maxx%, miny%, maxy%, sauter%, type%)
  sous-programme fg_scroll (int minx, maxx int, int Miny, int maxy, int saut,
    int Type)
  procédure fg_scroll (minx, maxx, Miny, Maxy, saut, tapez: integer);

*'''But'''

 La routine de fg_scroll défile verticalement une région de la page vidéo active.
  Le défilement peut être fait soit vers le haut ou vers le bas, en utilisant soit une fin-off ou
  méthode circulaire. En mode texte, la région est définie dans un espace de caractère;
  dans les modes graphiques, il est défini dans l'espace de l'écran.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la zone de défilement.  Dans les graphiques
  modes, sa valeur est réduite à une limite d'octet si nécessaire.

 maxx est la coordonnée X du bord droit de la zone de défilement.  Ce doit être
  supérieure ou égale à la valeur de minx. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 Miny est la coordonnée y de bord supérieur de la zone de défilement.

 Maxy est la coordonnée y du bord inférieur de la zone de défilement.  Ce doit être
  supérieure ou égale à la valeur de miny.

 saut est le nombre de pixels pour sauter entre chaque itération de défilement.  Si
  saut est négatif, la région défile vers le haut de l'écran.  Si
  saut est positif, la région défiler vers le bas de l'écran.

type spécifie le type de défilement. Si le type est égal à zéro, les lignes qui défiler off
  un bord apparaît sur le bord opposé, produisant ainsi un défilement circulaire
   effet. Si le type est une autre valeur, les lignes qui défilent hors un bord sera
  remplacer au bord opposé par des lignes de la couleur courante.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet quand un tampon virtuel est actif.

 défilement circulaire utilise une partie de la page cachée (tel que défini dans le plus
  appel récent à fg_sethpage) comme un espace de travail temporaire.

*'''Voir aussi'''

 fg_setcolor, fg_sethpage

*'''Exemples'''

 13-3, 13-4, 13-5

===fg_setangle===

*'''Prototype'''

 fg_setangle void (double angle);
  sous FGsetangle (angle #)
  sous-programme fg_setangle (dbl angle)
  procédure fg_setangle (angle: real);

*'''But'''

 La routine fg_setangle définit l'angle de rotation à laquelle le logiciel
  caractères sont affichés. Si un programme dessine les personnages de logiciels avant
  appelant fg_setangle, Fastgraph utilisera son angle de zéro degré par défaut
  (Qui est horizontale).

*'''Paramètres'''

 angle est l'angle de rotation, exprimée en degrés et mesuré
  antihoraire à partir de l'axe x positif.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.  Avant d'utiliser cette
  routine, vous devez utiliser fg_initw et fg_setworld pour établir un espace mondial
  système de coordonnées.

*'''Voir aussi'''

 fg_initw, fg_setratio, fg_setsize, fg_setsizew, fg_setworld, fg_swchar,
  fg_swlength, fg_swtext

*'''Exemples'''

 7-12

===fg_setattr===

*'''Prototype'''

 fg_setattr void (int premier plan, int fond, int blink);
  FGsetattr sous (premier plan%, fond%, blink%)
  fg_setattr sous-programme (int premier plan, int fond, int blink)
  procédure fg_setattr (premier plan, fond, blink: integer);

*'''But'''

 La routine fg_setattr établit le courant attribut de texte en texte vidéo
  modes.

*'''Paramètres'''

 premier plan est la composante de premier plan de l'attribut, entre 0 et 15.

 arrière-plan est la composante de l'attribut d'arrière-plan, entre 0 et 7.

 blink est la composante de clignotement de l'attribut, entre 0 et 1.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a pas d'effet dans les modes graphiques vidéo.

*'''Voir aussi'''

 fg_setcolor

*'''Exemples'''

 7-1, 7-2, 7-3, 7-4, 8-1, 8-3, 8-5, 8-7, 10-13, 11-2, 11-4, 13-4, 14- 9

===fg_setbanks===

*'''Prototype'''

 fg_setbanks void (int read_bank, int write_bank);
  sous FGsetbanks (read_bank% write_bank%)
  fg_setbanks de sous-programme (int read_bank, int write_bank)
  fg_setbanks procédure (de read_bank, write_bank: integer);

*'''But'''

 La routine fg_setbanks définit le SVGA lire et écrire les numéros de banque.  Ce
  la routine est appelée habituellement pas dans une application, mais est fournie en tant que haut
  interface de niveau SVGA le noyau de Fastgraph.

*'''Paramètres'''

read_bank est le numéro de banque SVGA utilisé dans les opérations de lecture. Si la valeur de
  read_bank est négative, le numéro de banque de lecture ne change pas.

 write_bank est le numéro de banque SVGA utilisé dans les opérations d'écriture.  Si la valeur
  de write_bank est négatif, le numéro de banque d'écriture ne change pas.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet si le noyau de SVGA Fastgraph n'a pas été
  initialisée.

*'''Voir aussi'''

 fg_getbanks, fg_svgainit

===fg_setcaps===

*'''Prototype'''

 fg_setcaps void (int de l'Etat);
  sous FGsetcaps (état%)
  fg_setcaps sous-programme (int state)
  fg_setcaps procédure (état: entier);

*'''But'''

 Les fg_setcaps contrôles de routine de l'Etat de la clé CapsLock.

*'''Paramètres'''

Etat définit l'état clé CapsLock. Si l'état est 0, la touche CapsLock est
  éteindre. Si elle est de 1, la clé de verrouillage des majuscules est activée.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Sur la plupart des claviers, changer l'état de touche CapsLock va aussi changer la
  Clavier état clair pour refléter le nouvel état clé. Cependant, certains anciens
  claviers, en particulier lorsqu'ils sont utilisés sur PC, PC / XT ou Tandy 1000 systèmes, ne le font pas
  mettre à jour la lumière de l'Etat. Cela rend la lumière de l'état incompatible avec la
  véritable état clé.

*'''Voir aussi'''

 fg_capslock, fg_numlock, fg_scrlock, fg_setnum

*'''Exemples'''

 14-4

===fg_setclip===

*'''Prototype'''

 fg_setclip void (int minx, maxx int, int Miny, int maxy);
  FGsetclip sous (minx de%, maxx%, miny%, maxy%)
  sous-programme fg_setclip (int minx, maxx int, int Miny, int maxy)
  procédure fg_setclip (minx, maxx, Miny, Maxy: integer);

*'''But'''

 La routine fg_setclip définit la zone de découpage dans l'espace de l'écran.  le
  zone de découpage est une zone rectangulaire à l'extérieur de laquelle certains graphiques sont
  supprimée.

*'''Paramètres'''

 minx est l'espace x écran coordonnées du bord gauche de la zone de découpage.

 maxx est l'espace x écran coordonnée bord droit de la zone de découpage.
  Il doit être supérieure ou égale à la valeur de minx.

 Miny est l'espace de l'écran coordonnée y du bord supérieur de la zone de découpage.

 Maxy est l'espace de l'écran y coordonnée du bord inférieur de la zone de découpage.
  Il doit être supérieure ou égale à la valeur de miny.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_setclipw

*'''Exemples'''

 6-5, 6-8, 10-8, 10-9, 10-23, 12-4

===fg_setclipw===

*'''Prototype'''

 fg_setclipw void (double xmin, double xmax, double ymin, double ymax);
  FGsetclipw sous (xmin de #, xmax #, ymin #, ymax #)
  fg_setclipw sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
  procédure fg_setclipw (xmin, xmax, ymin, ymax: real);

*'''But'''

 La routine fg_setclipw définit la zone de découpage dans l'espace mondial.  le
  zone de découpage est une zone rectangulaire à l'extérieur de laquelle certains graphiques sont
  supprimée.

*'''Paramètres'''

 xmin est l'espace x mondiale coordonnée du bord gauche de la zone de découpage.

 xmax est l'espace x mondiale coordonnée bord droit de la zone de découpage.
  Il doit être supérieure ou égale à la valeur de xmin.

 ymin est l'espace du monde y coordonnée du bord inférieur de la zone de découpage.

 ymax est l'espace du monde y coordonnée du bord supérieur de la zone de découpage.  Il
  doit être supérieure ou égale à la valeur de ymin.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Light et n'a aucun effet dans le texte
  modes vidéo.

*'''Voir aussi'''

 fg_setclip

===fg_setcolor===

*'''Prototype'''

 fg_setcolor void (int couleur);
  FGsetcolor sous (couleur%)
  fg_setcolor sous-programme (int couleur)
  procédure fg_setcolor (couleur: integer);

*'''But'''

 La routine fg_setcolor établit l'indice de couleur actuel (qui peut être un
  indice de couleur virtuelle) dans les modes graphiques. En mode texte, fg_setcolor fournit
  une autre méthode de définition de l'attribut de texte actuel.

*'''Paramètres'''

 la couleur définit l'indice actuel des couleurs (en modes graphiques) ou un attribut de texte
  (En mode texte). Sa valeur doit être comprise entre 0 et 255.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_colors, fg_defcolor, fg_getcolor, fg_setattr

*'''Exemples'''

 3-1 à 3-8, 3-10

===fg_setdacs===

*'''Prototype'''

 fg_setdacs void (int start, int count, les valeurs char *);
  sous FGsetdacs (start%, compter%, les valeurs $)
  fg_setdacs sous-programme (int start, int count, valeurs INT1)
  procédure fg_setdacs (début, count: nombre entier, les valeurs var: ShortInt);

*'''But'''

 La routine fg_setdacs définit les valeurs d'un bloc de la vidéo contiguë
   DAC enregistre en spécifiant leurs rouges, verts et bleus composantes de couleur.
  Définition de registres du CAD avec fg_setdacs est considérablement plus rapide que
  faisant individuellement avec fg_setrgb.

*'''Paramètres'''

 début est la vidéo DAC numéro de registre de départ, entre 0 et 255.

   compte est le nombre de contigue DAC enregistre pour définir, entre 1 et 256. Si la somme de départ et le nombre dépasse 256, les numéros de registre enveloppent et reprendre avec le registre numéro 0. 

  Les valeurs sont le nom du tableau contenant les composants de couleur.  La première
   trois octets de ce tableau doit contenir les composantes rouge, verte et bleue
   DAC début de registre, les trois octets suivants contiennent les composants pour
   inscrivez-vous commencer à + 1, et ainsi de suite.  La taille du tableau de valeurs doit être au
   moins 3 * octets de comptage.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte, ou CGA, Tandy, et Hercules
   les modes graphiques.  Dans les modes 13 à 16, il est significatif que lorsqu'il est exécuté sur un VGA
   ou un système SVGA;  ses résultats sont imprévisibles dans ces modes lorsqu'il est exécuté sur un
   EGA.  Vous pouvez utiliser fg_testmode (18,0) pour vérifier un VGA ou SVGA système.

*'''Voir aussi'''

  fg_getdacs, fg_getrgb, fg_setrgb

*'''Exemples'''

  5-12

===fg_setentry===

*'''Prototype'''

  fg_setentry void (int page_number, int page_addr, int page_type);
   FGsetentry sous (page_number%, page_addr%, page_type%)
   sous-programme fg_setentry (int page_number, int page_addr, int page_type)
   procédure fg_setentry (page_number, page_addr, page_type: integer);

*'''But'''

  La routine de fg_setentry spécifie le type et l'adresse d'un physique,
   Page vidéo virtuel ou logique.  Pour les pages logiques, il précise en outre si
   la page réside dans la mémoire conventionnelle, étendue ou prolongée.  Ce
   routine est utile pour sauvegarder le contenu de la page virtuelles ou logiques à travers la vidéo
   changements de mode, ou pour la création manuelle des pages virtuelles et logiques.

*'''Paramètres'''

  page_number est le numéro de la page vidéo étant définie.  Ce doit être
   entre 0 et 63.

  page_addr est l'adresse de la page spécifiée.  Pour les pages physiques, virtuels
   pages et des pages logiques dans la mémoire conventionnelle, l'adresse est une ordinaire
   adresse de segment.  Pour les pages logiques dans la mémoire EMS ou XMS, l'adresse de la page
   est une poignée EMS ou XMS.

  page_type est un code indiquant le type de page.  Voir *'''But''' de
   fg_getentry pour les valeurs de type de page valide.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getentry

*'''Exemples'''

  8-12, 8-13

===fg_setfunc===

*'''Prototype'''

  fg_setfunc void (int mode);
   sous FGsetfunc (mode%)
   fg_setfunc sous-programme (int mode)
   procédure fg_setfunc (mode: entier);

*'''But'''

  La routine fg_setfunc spécifie l'opération logique appliquée lorsque la vidéo
   changements de mémoire dans les modes graphiques EGA / VGA / SVGA 16 couleurs.  Mode de remplacement est
   sélectionné après avoir utilisé fg_setmode pour établir un mode vidéo.

*'''Paramètres'''

  Mode définit l'opération logique, comme indiqué ici:

  valeur logique
                       Le fonctionnement en mode

  0 remplacement
                         1 et
                         2 ou
                         3 ou exclusif

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine fonctionne uniquement en EGA / VGA / SVGA graphiques modes vidéo 16-couleur
   (modes 13 à 18, 28 et 29).  Il applique toujours à la mémoire vidéo, même
   quand un tampon virtuel est actif.

*'''Exemples'''

  12-3, 17-2

===fg_sethpage===

*'''Prototype'''

  fg_sethpage void (int page_number);
   FGsethpage sous (page_number%)
   fg_sethpage sous-programme (int page_number)
   procédure fg_sethpage (page_number: integer);

*'''But'''

  La routine fg_sethpage établit la page vidéo cachée.  Il peut être
   Page vidéo physique ou virtuel.  La routine fg_setmode désigne vidéo
   Page 0 comme page cachée.

*'''Paramètres'''

  page_number est le numéro caché de la page vidéo, entre 0 et 63.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est sans effet si page_number référence à une page vidéo physique
   qui n'existe pas, ou une page vidéo virtuel qui n'a pas été créé.

*'''Voir aussi'''

  fg_gethpage, fg_setpage, fg_setvpage

*'''Exemples'''

  11-2, 11-3, 13-2, 13-5

===fg_setlines===

*'''Prototype'''

  fg_setlines vides (lignes int);
   sous FGsetlines lignes (%)
   fg_setlines de sous-programmes (lignes int)
   fg_setlines procédure (lignes: integer);

*'''But'''

  La routine de fg_setlines étend un mode texte de 80 colonnes à 25, 43, ou 50
   lignes par écran.  La routine fg_setmode définit le nombre de lignes à 25
   lors de l'établissement d'un mode texte de 80 colonnes.

*'''Paramètres'''

  lignes est le nombre de lignes de texte par écran.  Sur les systèmes EGA, la valeur de
   lignes doivent être 25 ou 43. Sur les systèmes MCGA, il doit être 25 ou 50. Le VGA et
   systèmes SVGA, il doit être 25, 43 ou 50. Toute autre valeur est ignorée.  Avant
   appelant fg_setlines, vous devez appeler fg_testmode avec des pages = 0 pour voir si le
   le système utilisateur prend en charge le nombre de lignes nécessaires.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est seulement significatif lors de l'exécution de 80 colonnes de texte Modes sur
   EGA, MCGA, systèmes VGA ou SVGA (dans d'autres cas, il ne fait rien).

  Lorsque vous appelez fg_setlines, la page visuelle doit être la page 0.

  Appel fg_setlines rend le curseur de texte visible.

  Si vous avez initialisé la souris (avec fg_mouseini), joysticks (avec
   fg_initjoy), mémoire étendue (avec fg_initems), ou mémoire étendue (avec
   fg_initxms), vous devez réinitialiser ces ressources après l'appel
   fg_setlines.

*'''Voir aussi'''

  fg_getlines, fg_testmode

*'''Exemples'''

  3-5

===fg_setmode===

*'''Prototype'''

  fg_setmode void (int mode_number);
   FGsetmode sous (mode_number de%)
   fg_setmode sous-programme (int mode_number)
   procédure fg_setmode (mode_number: integer);

*'''But'''

  La routine fg_setmode établit un mode vidéo et initialise Fastgraph de
   paramètres internes pour ce mode.  Elle doit être appelée avant toute Fastgraph
   routine qui effectue la sortie vidéo.  Un programme peut appeler fg_setmode autant
   de fois que nécessaire pour basculer entre les différents modes vidéo.

*'''Paramètres'''

  mode_number est le numéro de mode vidéo, entre 0 et 29, comme indiqué ici:

  Mode Nombre de Supporté Supporté
    No. Type Résolution Couleurs Adaptateurs Affiche

  0 T 40x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     1 T 40x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     2 T 80x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     3 T 80x25 16/8 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     4 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     5 G 320x200 4 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     6 G 640x200 2/16 CGA, EGA, VGA, MCGA, SVGA RGB, ECD, VGA, SVGA
     7 T 80x25 b / w MDA, HGC, EGA, VGA, SVGA Monochrome
     9 G 320x200 16 Tandy 1000, PCjr RGB
    11 G 720x348 b / w HGC Monochrome
    12 G 320x200 b / w HGC Monochrome
    13 G 320x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
    14 G 640x200 16 EGA, VGA, SVGA RGB, ECD, VGA, SVGA
    15 G 640x350 b / w EGA, VGA, SVGA Mono, VGA, SVGA
    16 G 640x350 16/64 EGA, VGA, SVGA ECD, VGA, SVGA
    17 G 640x480 2 / 256K VGA, MCGA, SVGA VGA, SVGA
    18 G 640x480 16 / 256K VGA, SVGA VGA, SVGA
    19 G 320x200 256 / 256K VGA, MCGA, SVGA VGA, SVGA
    20 G 320x200 256 / 256K VGA, SVGA VGA, SVGA
    21 G 320x400 256 / 256K VGA, SVGA VGA, SVGA
    22 G 320x240 256 / 256K VGA, SVGA VGA, SVGA
    23 G 320x480 256 / 256K VGA, SVGA VGA, SVGA
    24 G 640x400 256 / 256K SVGA SVGA
    25 G 640x480 256 / 256K SVGA SVGA
    26 G 800x600 256 / 256K SVGA SVGA
    27 G 1024x768 256 / 256K SVGA SVGA
    28 G 800x600 16 / 256K SVGA SVGA
    29 G 1024x768 16 / 256K SVGA SVGA

  Pour plus d'informations sur chaque mode vidéo, y compris leur nécessaire
   cartes graphiques (cartes graphiques) et les moniteurs, s'il vous plaît se référer à la
   Guide de l'utilisateur Fastgraph.

  La valeur de mode_number peut aussi être -1, ce qui indique Fastgraph d'utiliser la
   mode vidéo actuel.  Cette fonction est souvent utile dans les programmes qui utilisent uniquement
   modes vidéo de texte, les programmes exécutés à partir d'un autre programme, ou se terminent et
   séjour (TSR) résident.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  La routine de fg_setmode ne vérifie pas si le mode vidéo est spécifié
   disponible sur le système de l'utilisateur.  Si nécessaire, vous devez d'abord utiliser
   fg_testmode pour ce faire.

  modes SVGA graphiques (24 à 29) ne sont disponibles qu'après succès
   initialisant le noyau SVGA avec fg_svgainit.

  Cette routine n'a pas d'effet quand un tampon virtuel est actif.

*'''Voir aussi'''

  fg_automode, fg_bestmode, fg_svgainit, fg_testmode

*'''Exemples'''

  3-1 à 3-8, 3-10

===fg_setnum===

*'''Prototype'''

  fg_setnum void (int state);
   FGsetnum sous (état%)
   fg_setnum sous-programme (int state)
   procédure fg_setnum (état: entier);

*'''But'''

  La routine fg_setnum contrôle l'état de la touche Verr Num.

*'''Paramètres'''

  Etat définit l'état de touche Verr Num.  Si l'état est 0, la touche Verr Num est
   éteindre.  Si elle est de 1, la clé de verrouillage numérique est activée.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Sur la plupart des claviers, changer l'état de touche Verr Num va aussi changer la
   Clavier état clair pour refléter le nouvel état clé.  Cependant, certains anciens
   claviers, en particulier lorsqu'ils sont utilisés sur PC, PC / XT ou Tandy 1000 systèmes, ne le font pas
   mettre à jour la lumière de l'Etat.  Cela rend la lumière de l'état incompatible avec la
   véritable état clé.

*'''Voir aussi'''

  fg_capslock, fg_numlock, fg_scrlock, fg_setcaps

*'''Exemples'''

  14-4

===fg_setpage===

*'''Prototype'''

  fg_setpage void (int page_number);
   FGsetpage sous (page_number%)
   fg_setpage sous-programme (int page_number)
   procédure fg_setpage (page_number: integer);

*'''But'''

  La routine fg_setpage établit la page vidéo active.  Il peut être
   Page vidéo physique ou virtuel.  La routine fg_setmode désigne vidéo
   Page 0 comme la page active.

*'''Paramètres'''

  page_number est le nombre actif de Page vidéo, entre 0 et 63.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est sans effet si page_number référence à une page vidéo physique
   qui n'existe pas, ou une page vidéo virtuel qui n'a pas été créé.

*'''Voir aussi'''

  fg_getpage, fg_sethpage, fg_setvpage

*'''Exemples'''

  8-1 à 8-9, 8-13, 12-4, 12-5, 12-6, 13-2, 13-9

===fg_setratio===

*'''Prototype'''

  fg_setratio void (double ratio);
   sous FGsetratio (rapport #)
   fg_setratio sous-programme (rapport dbl)
   procédure fg_setratio (rapport: real);

*'''But'''

  La routine fg_setratio définit le rapport d'aspect pour les caractères de logiciel.
   Le rapport d'aspect est le rapport de la largeur à la hauteur de caractère du caractère.  Si un
   programme dessine les personnages de logiciels avant d'appeler fg_setratio, Fastgraph
   utilisera son ratio d'aspect par défaut de 1.

*'''Paramètres'''

  rapport est le rapport d'aspect.  Il doit être supérieur à zéro.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.  Avant d'utiliser cette
   routine, vous devez utiliser fg_initw et fg_setworld pour établir un espace mondial
   système de coordonnées.

*'''Voir aussi'''

  fg_initw, fg_setangle, fg_setsize, fg_setsizew, fg_setworld, fg_swchar,
   fg_swlength, fg_swtext

*'''Exemples'''

  7-11

===fg_setrgb===

*'''Prototype'''

  fg_setrgb void (int number, int rouge, int vert, int bleu);
   FGsetrgb sous (numéro%, rouge%, vert%, bleu%)
   fg_setrgb sous-programme (nombre int, rouge, int vert, int bleu)
   procédure fg_setrgb (nombre, rouge, vert, bleu: entier);

*'''But'''

  Le fg_setrgb définit la valeur d'un registre de la palette (en Tandy / PCjr et
   modes graphiques EGA) ou registre vidéo DAC (en VGA, MCGA, XVGA et SVGA
   modes graphiques) en spécifiant ses rouges, verts et bleus composantes de couleur.

*'''Paramètres'''

  nombre est la palette ou vidéo DAC numéro de registre.  Si elle fait référence à une
   le registre de la palette, il doit être compris entre 0 et 15 (0 et 1 en mode 17).  Si ça
   références vidéo registre DAC, il doit être compris entre 0 et 255. La valeur de
   nombre peut être négatif pour spécifier une couleur intense pour cette palette
   inscrire dans Tandy / PCjr et modes graphiques EGA 200 lignes.

  rouge, vert et bleu spécifier respectivement le rouge, vert et bleu
   composants de la palette spécifiée ou vidéo registre DAC.  ces valeurs
   doit être 0 ou 1 pour les modes graphiques EGA / PCjr et 200 lignes Tandy, entre 0
   et 3 pour les modes EGA 350 lignes et entre 0 et 63 pour le VGA, MCGA, XVGA et
   Modes SVGA.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a pas d'effet dans les modes vidéo de texte, les modes graphiques CGA, ou
   modes graphiques Hercules.

*'''Voir aussi'''

  fg_getrgb, fg_palette, fg_setcolor, fg_setdacs

*'''Exemples'''

  5-9, 5-11, 5-13, 5-16, 9-11

===fg_setsize===

*'''Prototype'''

  fg_setsize void (int size);
   FGsetsize sub (taille%)
   fg_setsize sous-programme (int size)
   procédure fg_setsize (taille: integer);

*'''But'''

  La routine fg_setsize définit la hauteur des caractères de logiciels dans l'écran
   unités spatiales.  Si ni fg_setsize ni fg_setsizew est appelé, Fastgraph
   utilisera sa hauteur de caractères par défaut d'une unité mondiale de l'espace.

*'''Paramètres'''

  taille est la hauteur des caractères en unités d'espace d'écran.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.  Avant d'utiliser cette
   routine, vous devez utiliser fg_initw et fg_setworld pour établir un espace mondial
   système de coordonnées.

*'''Voir aussi'''

  fg_initw, fg_setangle, fg_setratio, fg_setsizew, fg_setworld, fg_swchar,
   fg_swlength, fg_swtext

===fg_setsizew==

*'''Prototype'''

  fg_setsizew void (double taille);
   sous FGsetsizew (taille #)
   sous-programme fg_setsizew (dbl taille)
   procédure fg_setsizew (taille: real);

*'''But'''

  La routine fg_setsizew définit la hauteur des caractères de logiciels dans le monde
   unités spatiales.  Si ni fg_setsize ni fg_setsizew est appelé, Fastgraph
   utilisera sa hauteur de caractères par défaut d'une unité mondiale de l'espace.

*'''Paramètres'''

  taille est la hauteur des caractères dans les unités spatiales du monde.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.  Avant d'utiliser cette
   routine, vous devez utiliser fg_initw et fg_setworld pour établir un espace mondial
   système de coordonnées.

*'''Voir aussi'''

  fg_initw, fg_setangle, fg_setratio, fg_setsize, fg_setworld, fg_swchar,
   fg_swlength, fg_swtext

*'''Exemples'''

  7-10, 7-11, 7-12, 7-13

===fg_setview===

*'''Prototype'''

  fg_setview void (int view_minx, int view_maxx, int view_miny,
     int view_maxy, int minx, maxx int, int Miny, int maxy);
   FGsetview sous (view_minx de%, view_maxx%, view_miny%, view_maxy%, minx%,
     maxx%, miny%, maxy%)
   fg_setview sous-programme (int view_minx, int view_maxx, int view_miny,
     int view_maxy, int minx, maxx int, int Miny, int maxy)
   procédure fg_setview (view_minx, view_maxx, view_miny, view_maxy,
     minx, maxx, Miny, Maxy: integer);

*'''But'''

  La routine fg_setview définit une fenêtre avec les extrêmes spécifiées à
   la position de l'espace de l'écran spécifié.

*'''Paramètres'''

  view_minx est au bord de la fenêtre gauche en unités de viewport.

  view_maxx est bord droit de la fenêtre en unités de viewport.  Sa valeur doit être
   supérieur à view_minx.

  view_miny est le bord supérieur de la fenêtre en unités de viewport.

  view_maxy est le bord inférieur de la fenêtre en unités de viewport.  Sa valeur doit
   être supérieure à view_miny.

  minx est l'espace x écran de coordonnées correspondant à la gauche de la fenêtre
   bord.

  maxx est l'espace x écran de coordonnées correspondant à la droite de la fenêtre
   bord.  Il doit être supérieur à mijaurée.

  Miny est l'écran l'espace coordonnée y correspondant à la partie supérieure de la fenêtre
   bord.

  Maxy est l'écran l'espace coordonnée y correspondant à la fenêtre de
   bord inférieur.  Il doit être supérieur à miny.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_getview, fg_xview, fg_yview

*'''Exemples'''

  4-3

===fg_setvpage===

*'''Prototype'''

  fg_setvpage void (int page_number);
   FGsetvpage sous (page_number%)
   fg_setvpage sous-programme (int page_number)
   procédure fg_setvpage (page_number: integer);

*'''But'''

  La routine fg_setvpage établit la page vidéo visuelle.  Il peut être
   Page vidéo physique ou virtuel, mais pas une page logique.  Le fg_setmode
   routine désigne Page vidéo 0 comme la page visuelle.

*'''Paramètres'''

  page_number est le numéro visuel de la page vidéo, entre 0 et 63.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est sans effet si page_number référence à une page vidéo physique
   qui n'existe pas, ou une page vidéo virtuel qui n'a pas été créé.

*'''Voir aussi'''

  fg_getpage, fg_sethpage, fg_setpage

*'''Exemples'''

  8-1 à 8-8, 12-6, 13-9

===fg_setworld===

*'''Prototype'''

  fg_setworld void (double xmin, double xmax, double ymin, double ymax);
   FGsetworld sous (xmin de #, xmax #, ymin #, ymax #)
   fg_setworld sous-programme (dbl xmin, dbl xmax, ymin dbl, dbl ymax)
   procédure fg_setworld (xmin, xmax, ymin, ymax: real);

*'''But'''

  La routine fg_setworld définit les coordonnées de l'espace mondial correspondant
   sur les bords physiques de l'écran.

*'''Paramètres'''

  xmin est l'espace mondial de coordonnées du bord de l'écran de gauche.

  xmax est l'espace mondial de coordonnées du bord droit de l'écran.  Ce doit être
   supérieure à la valeur de xmin.

  ymin est l'espace mondial de coordonnées du bord inférieur de l'écran.

  ymax est l'espace mondial de coordonnées du bord supérieur de l'écran.  Ce doit être
   supérieure à la valeur de ymin.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est pas disponible dans Fastgraph / Lumière.  Avant d'utiliser cette
   routine, vous devez appeler fg_initw pour initialiser l'espace mondial de Fastgraph
   paramètres.

*'''Voir aussi'''

  fg_getworld, fg_initw, fg_setview

*'''Exemples'''

  4-4, 6-4, 6-9, 7-10, 7-11, 7-12, 7-13

===fg_shear===

*'''Prototype'''

  fg_shear void (char * source, char * dest, int largeur, int hauteur,
     int new_size, type int);
   FGshear sous (source $, dest $, largeur%, hauteur%, new_size%, type%)
   sous-programme fg_shear (source int1, dest int1, int largeur, int hauteur,
     int new_size, type int)
   procédure fg_shear (source var, dest; largeur, hauteur, new_size, tapez:
     entier);

*'''But'''

  Les ciseaux de routine fg_shear une image bitmap stockée dans le "un pixel par
   byte "le format.

*'''Paramètres'''

  source est le nom du tableau contenant le "un pixel par octet"
   image pixelisée à cisaillé.

  dest est le nom du tableau qui va recevoir la résultante cisaillé
   image.

  la largeur correspond à la largeur de l'image source en pixels.  Il doit être supérieur à
   zéro.

  la hauteur correspond à la hauteur de l'image source en pixels.  Il doit être supérieur à
   zéro.

  new_size est la largeur en pixels (pour cisailles horizontales) ou la hauteur en pixels
   (Pour les ciseaux verticaux) de l'image résultante dest.  Il doit être au moins aussi
   grande que la dimension correspondante dans l'image source.

  type est un code indiquant le type et la direction de cisaillement, comme indiqué ici:
     0 = cisaillement horizontal vers la gauche (le bord inférieur est tendu vers la droite)
     1 = cisaillement horizontal vers la droite (bord supérieur est tendu vers la droite)
     2 = cisaillement vertical à gauche (bord gauche est tendue vers le haut)
     3 = cisaillement vertical vers la droite (bord droit est étiré vers le haut)

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Dans les modes de 16 bits, la taille de la source et dest réseaux est limitée à 64K

octets.

  La largeur maximale admissible ou la hauteur de la source et dest est 1.024 pixels.

*'''Voir aussi'''

  fg_drwimage, fg_pack, fg_putimage, fg_scale, fg_unpack

  236

fg_shear (suite)

*'''Exemples'''

  10-18

===fg_showflic===

*'''Prototype'''

  int fg_showflic (char * filename, int count, int flags);
   fonction FGshowflic% (filename $, compter%, drapeaux%)
   fonction int fg_showflic (char filename, int count, drapeaux int)
   fonction fg_showflic (filename: string; compter, drapeaux: entier): nombre entier;

*'''But'''

  Les affichages de routine fg_showflic une image stockée dans un FLI ou d'un fichier FLC
   (Collectivement appelés fichiers CIDF).

*'''Paramètres'''

  filename est le nom du fichier flac.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  compte est le nombre de fois pour afficher l'image flac.  Si le nombre est égal à zéro,
   le flic joue en continu.  Vous pouvez arrêter l'affichage FLIC à tout moment par
   en appuyant sur la touche Echap.

  flags est un masque de bits qui contrôle la façon dont l'image est affichée.
     bit 0
        0 = retard entre les images comme indiqué dans l'entête FLIC
        1 = pas de retard entre les images
     bit 1
        0 = affichage image par rapport à l'origine de l'écran
        la position graphique actuelle par rapport 1 = image d'affichage
     bit 2
        0 = image d'affichage à partir du fichier spécifié FLIC
        1 = image d'affichage depuis la mémoire tampon de fg_imagebuf
     4 bits
        0 = utiliser des données de palette dans le fichier flac
        1 = ignorer les données de la palette dans le fichier flac
     Bits 3 et 5-15 sont réservés pour une utilisation future et devrait être nul.

*'''Valeur de retour'''

  0 = succès, 1 = fichier non trouvé, 2 = fichier est pas un fichier flac

*'''Restrictions'''

  fichiers Flic ne sont significatives que dans les modes graphiques 256 couleurs.  Cette routine
   n'a pas d'effet dans d'autres modes vidéo.

*'''Voir aussi'''

  fg_flichead, fg_flicmode, fg_flicplay, fg_flicsize, fg_imagebuf

*'''Exemples'''

  9-6


===fg_showgif===

*'''Prototype'''

  int fg_showgif (char * filename, int flags);
   fonction FGshowgif% (filename $, drapeaux%)
   fonction int fg_showgif (char filename, drapeaux int)
   fonction fg_showgif (filename: string; drapeaux: entier): nombre entier;

*'''But'''

  La routine fg_showgif affiche une image stockée dans un fichier GIF.

*'''Paramètres'''

  filename spécifie le nom du fichier GIF.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  flags est un masque de bits qui contrôle la façon dont l'image est affichée.
     bit 0
        0 = utilisent des valeurs de palette stockées dans le fichier GIF
        1 = utiliser les paramètres de la palette en cours
     bit 1
        0 = image d'affichage à la position indiquée en en-tête GIF
        1 = image d'affichage à la position graphique actuelle
     bit 2
        0 = image d'affichage à partir du fichier GIF
        1 = image d'affichage depuis la mémoire tampon de fg_imagebuf
     Bits 3-15 sont réservés pour une utilisation future et devrait être nul.

*'''Valeur de retour'''

  0 = succès
   1 = fichier non trouvé
   2 = fichier est pas un fichier GIF

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo, ou la CGA et Hercules
   les modes graphiques.

  Lors de l'affichage d'un GIF 256 couleurs dans un mode graphique de 16 couleurs, fg_showgif
   affiche des pixels de couleur c dans la couleur c modulo 16.

*'''Voir aussi'''

  fg_gifhead, fg_gifmode, fg_gifpal, fg_gifrange, fg_imagebuf, fg_makegif

*'''Exemples'''

  9-4

===fg_showpcx===

*'''Prototype'''

  int fg_showpcx (char * filename, int flags);
   fonction FGshowpcx% (filename $, drapeaux%)
   fonction int fg_showpcx (char filename, drapeaux int)
   fonction fg_showpcx (filename: string; drapeaux: entier): nombre entier;

*'''But'''

  La routine fg_showpcx affiche une image stockée dans un fichier PCX.

*'''Paramètres'''

  filename est le nom du fichier PCX.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   caractère nul (soit un octet nul).

  flags est un masque de bits qui contrôle la façon dont l'image est affichée.
     bit 0
        0 = utilisent des valeurs de palette stockées dans le fichier PCX
        1 = utiliser les paramètres de la palette en cours
     bit 1
        0 = image d'affichage à la position indiquée en tête PCX
        1 = image d'affichage à la position graphique actuelle
     bit 2
        0 = image d'affichage à partir du fichier PCX
        1 = image d'affichage depuis la mémoire tampon de fg_imagebuf
     Bits 3-15 sont réservés pour une utilisation future et devrait être nul.

*'''Valeur de retour'''

  0 = succès
   1 = fichier non trouvé
   2 = fichier est pas un fichier PCX

*'''Restrictions'''

  fichiers PCX sont spécifiques à certains modes vidéo.  Le tableau suivant
   résume les modes vidéo compatibles pour les fichiers PCX.

  Si le fichier PCX était Vous pouvez afficher
                    créé en mode dans ces modes

  4, 5 4, 5
                    6, 11 6, 11, 13-18, 28, 29
                    9 9
                    13-18 13-18, 28, 29
                    19-27 19-27
                    28-29 13-18, 28, 29

  Affichage d'un fichier PCX à une résolution inférieure (par exemple, un 640x480 PCX
   fichier à 320x200) tronque l'affichage sur la droite et sur le fond.
   Cette affiche effectivement le coin supérieur gauche du fichier PCX.  Si vous
   essayer d'afficher un fichier PCX dans un mode vidéo incompatible, fg_showpcx
   sera toujours afficher quelque chose, mais il sera brouillé.

  La routine de fg_showpcx n'a aucun effet en mode vidéo de texte ou dans le Hercules
   basse résolution en mode graphique.

  Vous ne pouvez pas utiliser fg_showpcx pour charger un fichier PCX dans un tampon virtuel.  le
   fg_loadpcx routine est prévu à cet effet.

*'''Voir aussi'''

  fg_imagebuf, fg_loadpcx, fg_makepcx, fg_pcxhead, fg_pcxmode, fg_pcxpal,
   fg_pcxrange

*'''Exemples'''

  9-1, 9-12

===fg_showppr===

*'''Prototype'''

  int fg_showppr (char * filename, int largeur);
   fonction FGshowppr% (filename $, largeur%)
   int fonction fg_showppr (char filename, int largeur)
   fonction fg_showppr (filename: string; largeur: entier): nombre entier;

*'''But'''

  La routine de fg_showppr affiche une image stockée dans une course de pixel emballé (PPR)
   fichier.  L'image sera positionnée de sorte que son coin inférieur gauche est à la
   graphiques curseur position sur la page vidéo active ou tampon virtuel.

*'''Paramètres'''

  filename spécifie le nom du fichier PPR.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  largeur est la largeur de l'image en pixels.  Il doit être supérieur à zéro.

*'''Valeur de retour'''

  0 = succès
   1 = fichier non trouvé

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_dispfile, fg_imagebuf, fg_makeppr, fg_pattern, fg_showspr

*'''Exemples'''

  9-11

===fg_showspr===

*'''Prototype'''

  int fg_showspr (char * filename, int largeur);
   fonction FGshowspr% (filename $, largeur%)
   int fonction fg_showspr (char filename, int largeur)
   fonction fg_showspr (filename: string; largeur: entier): nombre entier;

*'''But'''

  La routine fg_showspr affiche une image stockée dans une course de pixel norme
   (SPR) fichier.  L'image sera positionnée de sorte que son coin inférieur gauche est
   à la position graphique du curseur sur la page vidéo active ou tampon virtuel.

*'''Paramètres'''

  filename spécifie le nom du fichier SPR.  Un nom de périphérique et le chemin peut être
   inclus dans le nom du fichier.  Le nom du fichier doit se terminer par un
   octet nul.

  largeur est la largeur de l'image en pixels.  Il doit être supérieur à zéro.

*'''Valeur de retour'''

  0 = succès
   1 = fichier non trouvé

*'''Restrictions'''

  Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

  fg_dispfile, fg_imagebuf, fg_makespr, fg_pattern, fg_showppr

*'''Exemples'''

  9-9

===fg_sound===

*'''Prototype'''

  fg_sound void (fréquence, int durée);
   FGsound secondaire (% fréquence, la durée%)
   fg_sound sous-programme (fréquence, int durée)
   procédure fg_sound (fréquence, durée: integer);

*'''But'''

  La routine de fg_sound produit un son d'une fréquence et de la durée spécifiée
   en utilisant la minuterie programmable.

*'''Paramètres'''

  fréquence est la fréquence de ton Hertz, entre 18 et 32.767.

  la durée est la longueur de la tonalité en tops d'horloge (il y a environ 18.2
   horloge par seconde).  Si la durée est nulle ou négative, le ton est dit
   être continu et va jouer jusqu'à ce que vous arrêtiez avec fg_quiet.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet s'il y a du son asynchrone déjà en
   la progression.

*'''Voir aussi'''

  fg_music, fg_quiet, fg_sounds, fg_voice

*'''Exemples'''

  15-1

===fg_sounds===

*'''Prototype'''

  fg_sounds void (int * sound_array, int nTimes);
   sous FGsounds (sound_array% (), nTimes%)
   fg_sounds de sous-programme (int sound_array, int nTimes)
   fg_sounds procédure (var sound_array: Integer; nTimes: integer);

*'''But'''

  La routine fg_sounds utilise la minuterie programmable pour jouer une série de tonalités
   des fréquences spécifiées et durées, simultanées avec d'autres activités.  Il
   est la version asynchrone de fg_sound.

*'''Paramètres'''

  sound_array est le nom du tableau contenant une série de
   définitions (fréquence, durée) sonores.  Le format de ce tableau est le suivant:

  [0] fréquence du son 1

  [1] durée de son 1

  [2] fréquence du son 2

  [3] durée de son 2

  .
                                          .
                                          .

  [2n-2] fréquence du son n

  [2n-1] durée de son n

  [2n] terminaison (0)

  Chaque valeur de fréquence est mesurée en Hertz et doit être comprise entre 18 et
   32,767.  Les durées sont mesurées en ticks d'horloge (il y a environ
   72,8 horloge par seconde).  Un caractère nul (qui est, un octet nul)
   met fin à la série.

  nTimes spécifie le nombre de fois à travers les sons définis pour le cycle
   sound_array.  Si nTimes est négatif, les sons vont jouer répétitivement jusqu'à ce que
   arrêté avec fg_hush ou fg_hushnext.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine n'a aucun effet s'il y a du son asynchrone déjà en
   la progression.

  Pour élargir la gamme des effets sonores, Fastgraph temporairement le quadruple
   horloge taux d'interruption de la tique de 18,2 à 72,8 tiques par seconde tandis que
   produire un son asynchrone.  Parce que de nombreux contrôleurs de disques comptent sur le
   18,2 tick par seconde fréquence d'horloge pour synchroniser les accès disque, vos programmes
   ne devrait pas effectuer toutes les opérations de disque lorsque le son asynchrone est en
   la progression.

  Dans les modes de 16 bits, la taille des sound_array est limitée à 64K octets.

*'''Voir aussi'''

  fg_hush, fg_hushnext, fg_musicb, fg_playing, fg_sound, fg_voice, fg_voices

*'''Exemples'''

  15-4

===fg_split===

*'''Prototype'''

  fg_split void (int iy);
   FGsplit sous (iy%)
   fg_split sous-programme (int iy)
   procédure fg_split (iy: integer);

*'''But'''

  La routine de fg_split active ou désactive un environnement d'écran divisé.  Lorsqu'un
   écran partagé est activé, la partie supérieure de l'écran (lignes 0 par
   iy-1) contient un sous-ensemble de la page vidéo visuelle.  La partie inférieure
   (À partir de la ligne iy) contiendra la première fg_getmaxy () - iy + 1 rangées de vidéo
   Page 0.

*'''Paramètres'''

  iy est l'espace de l'écran numéro de la ligne à laquelle l'écran partagé prend effet.
   Pour désactiver un écran divisé, réglez iy à la résolution verticale du courant
   mode vidéo.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Cette routine est significative seulement dans EGA, VGA, les modes graphiques MCGA et XVGA
   (modes 13 à 23) lorsqu'il est exécuté sur un système VGA ou SVGA.

*'''Voir aussi'''

  fg_pan, fg_setvpage

*'''Exemples'''

  13-9

===fg_stall===

*'''Prototype'''

  fg_stall void (int de retard);
   FGstall sous (délai%)
   fg_stall sous-programme (int retard)
   procédure fg_stall (délai: entier);

*'''But'''

  La routine fg_stall retarde l'exécution d'un programme pour un nombre donné de
   unités de retard spécifiques au processeur.  Vous pouvez utiliser fg_measure pour obtenir le nombre
   des unités de retard par impulsion d'horloge pour le système utilisé.

*'''Paramètres'''

  retard est le nombre d'unités de retard à attendre.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_measure, fg_waitfor

*'''Exemples'''

  13-9, 16-3

===fg_suspend===

*'''Prototype'''

  fg_suspend void (void);
   FGsuspend sub ()
   sous-routine fg_suspend ()
   procédure fg_suspend;

*'''But'''

  La routine fg_suspend suspend la musique asynchrone précédemment commencé par
   fg_musicb.  Il n'a aucun effet s'il n'y a pas de musique asynchrone en cours.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Un programme ne doit pas sortir de DOS avec de la musique suspendue.  Vous devez appeler fg_hush
   d'annuler la musique d'abord.

*'''Voir aussi'''

  fg_hush, fg_musicb, fg_resume

*'''Exemples'''

  15-8

===fg_svgainit===

*'''Prototype'''

  int fg_svgainit (int méthode);
   fonction FGsvgainit% (méthode%)
   int fonction fg_svgainit (méthode int)
   fonction fg_svgainit (méthode: nombre entier): nombre entier;

*'''But'''

  La routine de fg_svgainit initialise SVGA le noyau de Fastgraph.  Ce doit être
   appelé avant l'établissement d'un mode graphique SVGA (modes 24-29) avec
   fg_setmode, avant de tester la disponibilité SVGA en mode vidéo avec fg_bestmode ou
   fg_testmode, ou avant d'appeler fg_memory.

*'''Paramètres'''

  méthode spécifie comment initialiser le noyau SVGA.  Si la méthode est 0, le
   kernel SVGA effectue une détection automatique du chipset, donnant code spécifique chipset
   préséance sur le BIOS VESA.  Si la méthode est 1, le noyau également SVGA
   effectue une autodetect mais donne la priorité VESA BIOS sur le chipset
   code spécifique.  Si la méthode est 2 ou plus, le noyau SVGA est initialisé pour une
   chipset spécifique (sans tester la présence de ce chipset).  Faire référence à
   Le chapitre 3 du Guide de l'utilisateur Fastgraph pour une liste des chipsets pris en charge.

*'''Valeur de retour'''

  Pour les demandes de Autodetect (méthode = 0 ou 1), fg_svgainit retourne une valeur
   entre 1 et 34 correspondant au chipset SVGA trouvé.  Une valeur de 1
   un moyen de BIOS VESA sera utilisé.  Une valeur comprise entre 2 et 34 un moyen spécifique
   SVGA jeu de puces est utilisé.  Si aucun VESA BIOS ou soutenu chipset SVGA est
   trouvé, fg_svgainit renvoie zéro.

  Pour chipsets spécifiques, fg_svgainit renvoie la valeur du chipset qui lui est passé.
   Aucun des contrôles sont effectués pour voir si ce chipset est effectivement présent.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_setmode, fg_svgastat

*'''Exemples'''

  3-9, 3-10

===fg_svgastat===

*'''Prototype'''

  int fg_svgastat (void);
   fonction FGsvgastat% ()
   int fonction fg_svgastat ()
   fonction fg_svgastat: integer;

*'''But'''

  La routine renvoie des informations fg_svgastat sur l'état actuel de la
   le noyau SVGA de Fastgraph.

*'''Paramètres'''

  aucun

*'''Valeur de retour'''

  Un masque de bits contenant des informations sur le noyau SVGA.
     bit 0
        0 = SVGA noyau non initialisée (tous les bits seront 0 dans ce cas)
        1 = noyau SVGA initialisée
     bit 1
        soutenir 0 = VESA désactivé
        1 support = VESA activé
     bit 2
        pages vidéo = Extended 0 ne sont pas disponibles dans les modes 13-23
        1 pages vidéo = Extended sont disponibles dans ces modes
     bit 3
        0 = SVGA chipset utilise une banque pour la lecture et l'écriture
        1 = SVGA chipset a lecture séparée et écrire banques
     Bits 4-15 sont réservés pour une utilisation future et sont tous nuls.

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_svgainit

*'''Exemples'''

  8-8

===fg_svgaver===

*'''Prototype'''

  fg_svgaver void (int * major, int * mineur);
   FGsvgaver sub (majeur%, mineure%)
   sous-programme fg_svgaver (int majeur, int mineur)
   procédure fg_svgaver (var majeur, mineur: entier);

*'''But'''

  La routine fg_svgaver renvoie les grands et petits numéros de version pour
   le noyau SVGA de Fastgraph.

*'''Paramètres'''

  major reçoit le noyau SVGA numéro de version majeure.

  mineur reçoit le noyau SVGA numéro de version mineure, exprimée en
   centièmes.


*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  aucun

*'''Voir aussi'''

  fg_svgainit, fg_version

*'''Exemples'''

  3-9

===fg_swchar===

*'''Prototype'''

  fg_swchar void (char * string, int n, int justifier);
   FGswchar sous (string $, n%, justifier%)
   sous-programme fg_swchar (chaîne de char, int n, int justifier)
   procédure fg_swchar (string: string; n, justifie: integer);

*'''But'''

  La routine fg_swchar affiche une chaîne de caractères de logiciels dans le
   indice de couleur actuelle.  La chaîne peut être justifié à gauche, centré ou à droite
   justifié par rapport au curseur graphique.

*'''Paramètres'''

  chaîne est la séquence de caractères à afficher arbitraire de longueur.  Cela pourrait
   contenir des agents spéciaux, tels que résumés dans le tableau suivant.

  operatormeaning

  \ Commutateur autre police
                         \ ^ Exposant le caractère suivant
                         \ V indicer le caractère suivant
                         _ Commencer soulignant les caractères jusqu'à ce qu'un autre
                              caractère de soulignement est rencontrée

  n est le nombre de caractères dans la chaîne, y compris tout opérateur spécial
   personnages.

  justifier détermine la façon dont la chaîne est positionnée par rapport au courant
   position.  Si justifier est négatif, la chaîne est justifié à gauche;  si elle est nulle,
   chaîne est centrée;  si elle est positive, la chaîne est justifié à droite.

*'''Valeur de retour'''

  aucun

*'''Restrictions'''

  Avant d'utiliser cette routine, vous devez utiliser fg_initw et fg_setworld à
   établir un espace de système de coordonnées.  Cette routine est pas disponible dans
   Fastgraph / Lumière et n'a pas d'effet dans les modes vidéo texte.

*'''Voir aussi'''

  fg_initw, fg_setangle, fg_setratio, fg_setsize, fg_setsizew, fg_setworld,
   fg_swlength, fg_swtext

*'''Exemples'''

  7-10, 7-11

===fg_swlength===

*'''Prototype'''

  à double fg_swlength (char * string, int n);
   fonction FGswlength # (string $, n%)
   fonction dbl fg_swlength (chaîne de char, int n)
   fonction fg_swlength (string: string; n: nombre entier): real;

*'''But'''

  La routine calcule fg_swlength la longueur d'une chaîne de logiciels
   personnages.

*'''Paramètres'''

  chaîne est la séquence de caractères pour lesquels le calcul arbitraire de longueur
   la durée.  Elle peut contenir des opérateurs spéciaux utilisés par le fg_swchar et
   routines fg_swtext.

  n est le nombre de caractères dans la chaîne, y compris tout opérateur spécial
   personnages.

*'''Valeur de retour'''

  La longueur de la chaîne, dans les unités spatiales du monde.

*'''Restrictions'''

  Avant d'utiliser cette routine, vous devez utiliser fg_initw et fg_setworld à
   établir un espace de système de coordonnées.  Cette routine est pas disponible dans
   Fastgraph / Lumière et n'a pas d'effet dans les modes vidéo texte.

*'''Voir aussi'''

  fg_initw, fg_setangle, fg_setratio, fg_setsize, fg_setsizew, fg_setworld,
   fg_swchar, fg_swtext

*'''Exemples'''

  7-13

===fg_swtext===

*'''Prototype'''

  fg_swtext void (char * string, int n, int justifier);
   FGswtext sous (string $, n%, justifier%)
   sous-programme fg_swtext (chaîne de char, int n, int justifier)
   procédure fg_swtext (string: string; n, justifie: integer);

*'''But'''

  La routine de fg_swtext est une version réduite de fg_swchar.  Ce ne est pas
   inclure les définitions de caractères de police de rechange et nécessite donc moins
   mémoire que fg_swchar.

*'''Paramètres'''

  chaîne est la séquence de caractères à afficher arbitraire de longueur.  Cela pourrait
   contenir des agents spéciaux, tels que résumés dans le tableau suivant.

  operatormeaning

  \ ^ Exposant le caractère suivant
                         \ V indicer le caractère suivant
                         _ Commencer soulignant les caractères jusqu'à ce qu'un autre
                              caractère de soulignement est rencontrée

 n est le nombre de caractères dans la chaîne, y compris tout opérateur spécial
   personnages.

 justifier détermine la façon dont la chaîne est positionnée par rapport au courant
   position.Si justifier est négatif, la chaîne est justifié à gauche; si elle est nulle,
  chaîne est centrée; si elle est positive, la chaîne est justifié à droite.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Avant d'utiliser cette routine, vous devez utiliser fg_initw et fg_setworld à
  établir un espace de système de coordonnées. Cette routine est pas disponible dans
  Fastgraph / Lumière et n'a pas d'effet dans les modes vidéo texte.

*'''Voir aussi'''

 fg_initw, fg_setangle, fg_setratio, fg_setsize, fg_setsizew, fg_setworld,
  fg_swchar, fg_swlength

*'''Exemples'''

 7-12, 7-13

===fg_tcdefine===

*'''Prototype'''

 fg_tcdefine void (int index, attribut int);
  FGtcdefine sous (indice%, attribuer%)
  fg_tcdefine sous-programme (int index, attribut int)
  procédure fg_tcdefine (index, attribut: integer);

*'''But'''

 La routine fg_tcdefine définit l'attribut de transparence d'un indice de couleur
  pour une utilisation avec fg_tcxfer et fg_vbtcxfer.

*'''Paramètres'''

 index est l'indice de couleur étant définie (entre 0 et 255).

 attribut est l'attribut de transparence pour l'indice de couleur.  Si la
  attribut est 0, la couleur spécifiée sera opaque (non transparent).  Si ça
  est une autre valeur, fg_tcxfer et fg_vbtcxfer traiteront la couleur
   transparent.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_tcmask, fg_tcxfer, fg_vbtcxfer

*'''Exemples'''

 11-9

===fg_tcmask===

*'''Prototype'''

 fg_tcmask void (masque int);
  FGtcmask sous (masque%)
  fg_tcmask sous-programme (masque int)
  procédure fg_tcmask (masque: entier);

*'''But'''

  Les définit routine fg_tcmask qui de la première des valeurs de 16 couleurs fg_tcxfer et fg_vbtcxfer envisageront transparent. Utilisez fg_tcdefine pour contrôler la transparence des couleurs 17 à 255 dans les modes graphiques 256 couleurs.

*'''Paramètres'''

 le masque est un masque de 16 bits, où chaque bit indique si oui ou non le
  valeur de couleur correspondante est transparente. Par exemple, si le bit 0 (
  bit à droite) est 1, puis la couleur 0 sera transparent. Si le bit 0 est 0, la couleur
  0 ne sera pas transparent.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_tcdefine, fg_tcxfer, fg_vbtcxfer

*'''Exemples'''

 11-8

===fg_tcxfer===

*'''Prototype'''

 fg_tcxfer void (int minx, maxx int, int Miny, int maxy, int newX, int newy,
    int source_page, int dest_page);
  sous FGtcxfer (minx%, maxx%, miny%, maxy%, newX%, newy%, source_page%,
    dest_page%)
  fg_tcxfer sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, int source_page, int dest_page)
  procédure fg_tcxfer (minx, maxx, Miny, Maxy, newX, newy, source_page,
    dest_page: integer);

*'''But'''

 La fg_tcxfer copies de routine d'une région rectangulaire de toute position sur tout
  Page vidéo à une position sur une page vidéo, à l'exclusion des pixels dont
  la couleur est transparente. Comme avec d'autres routines de transfert de bloc de Fastgraph, pas
  écrêtage est effectué. Les fg_tcdefine et fg_tcmask routines définissent les
  couleurs sont transparentes.

*'''Paramètres'''

minx est la coordonnée x du bord gauche de la région de source. Sa valeur est
  réduite à une limite d'octet, si nécessaire.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx. Sa valeur est étendue à un octet
  limite si nécessaire.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

newX est la coordonnée x du bord gauche de la région de destination. Sa valeur
  est réduite à une limite d'octet, si nécessaire.

 newy est la coordonnée y du bord inférieur de la région de destination.

 source_page est le numéro de la page vidéo contenant la région de source.

 dest_page est la vidéo numéro de page pour la région de destination.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Si source_page et dest_page référence la page vidéo même, la source et
  régions de destination ne doivent pas se chevaucher. Cette routine n'a pas d'effet dans le texte
  modes vidéo.

 La routine de fg_tcxfer applique toujours les pages vidéo, même lorsqu'un virtuel
  tampon est actif.

*'''Voir aussi'''

 fg_tcdefine, fg_tcmask, fg_transfer, fg_vbtccopy, fg_vbtcxfer

*'''Exemples'''

 11-8

===fg_testmode===

*'''Prototype'''

 int fg_testmode (mode int, int pages);
  fonction FGtestmode% (mode%, pages%)
  fonction int fg_testmode (mode int, pages int)
  fonction fg_testmode (Mode, pages: Integer): Integer;

*'''But'''

 La routine fg_testmode détermine si oui ou non un mode vidéo spécifié est
  disponible sur le système de l'utilisateur. En outre, fg_testmode peut vérifier si
  il y a suffisamment de mémoire vidéo (pour les pages physiques) ou de la mémoire à accès aléatoire
  (Pour les pages virtuelles) pour soutenir le nombre de pages vidéo nécessaires.

*'''Paramètres'''

 mode est le numéro de mode vidéo pour tester, entre 0 et 29. Se reporter à la
  description de fg_setmode pour une liste des modes vidéo disponibles.

 pages est le nombre de pages vidéo nécessaires (soit pages physiques, virtuels
  pages, ou les deux). Si le paramètre de pages est égal à zéro ou négatif, fg_testmode
  vérifie la disponibilité du mode vidéo, mais ne considère pas la vidéo
  des besoins en mémoire.

*'''Valeur de retour'''

 Si le mode vidéo demandé est disponible (avec le nombre requis de
  pages vidéo), fg_testmode renvoie 1. Sinon, elle retourne 0.

*'''Restrictions'''

 modes graphiques SVGA sont disponibles uniquement après l'initialisation avec succès le
  kernel SVGA avec fg_svgainit.

 La routine de fg_testmode ne considère pas les pages vidéo étendues lors de l'essai
  si le nombre requis de pages vidéo est disponible.

*'''Voir aussi'''

 fg_automode, fg_bestmode, fg_setmode, fg_svgainit

*'''Exemples'''

 3-3, 3-5, 3-8, 3-10, 5-16, 6-7, 6-8

===fg_text===

*'''Prototype'''

 fg_text void (char * string, int n);
  FGtext sub (chaîne de $, n%)
  fg_text sous-programme (chaîne de char, int n)
  procédure fg_text (string: string; n: nombre entier);

*'''But'''

 La routine fg_text affiche une chaîne de caractères de matériel, à partir de
  la position du curseur de texte, en utilisant l'attribut de texte en cours (pour les modes de texte)
  ou de l'indice de couleur (pour les graphiques modes), sans écrêtage. Cette feuille de routine
  le texte curseur d'une colonne à droite du dernier caractère affiché (ou
  la première colonne de la rangée suivante si le dernier caractère est à la fin d'un
  rangée).

*'''Paramètres'''

 chaîne est la séquence de caractères à afficher arbitraire de longueur.

 n est le nombre de caractères à afficher à partir de la chaîne.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_locate, fg_print, fg_setattr, fg_textc

*'''Exemples'''

 7-1, 7-2, 7-3, 7-4, 7-5, 7-7, 7-8, 7-9, 7-10

===fg_textc===

*'''Prototype'''

 fg_textc void (char * string, int n);
  sous FGtextc (string $, n%)
  fg_textc sous-programme (chaîne de char, int n)
  procédure fg_textc (string: string; n: nombre entier);

*'''But'''

 La routine fg_textc affiche une chaîne de caractères de matériel, à partir de
  la position du curseur de texte, en utilisant l'attribut de texte en cours (pour les modes de texte)
  ou de l'indice de couleur (pour les modes graphiques). Dans les modes graphiques, seule la partie de la
  la chaîne qui se situe dans les limites d'écrêtage de courant sera affiché.
  Cette routine laisse le curseur de texte d'une colonne à droite de la dernière
  caractère affiché (ou la première colonne de la ligne suivante si le dernier
  le caractère est à la fin d'une rangée).

*'''Paramètres'''

 chaîne est la séquence de caractères à afficher arbitraire de longueur.

 n Le nombre de caractères à afficher de chaîne.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_locate, fg_printc, fg_setattr, fg_setclip, fg_text

===fg_transfer===

*'''Prototype'''

 fg_transfer void (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, int source_page, int dest_page);
  sous FGtransfer (minx%, maxx%, miny%, maxy%, newX%, newy%, source_page%,
    dest_page%)
  fg_transfer sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, int source_page, int dest_page)
  procédure fg_transfer (minx, maxx, Miny, Maxy, newX, newy, source_page,
    dest_page: integer);

*'''But'''

 Les fg_transfer copies de routine d'une région rectangulaire d'une page vidéo
  l'autre, ou à une position sans chevauchement sur la page vidéo identique. Dans le texte
  modes, la région est définie dans l'espace de caractère; dans les modes graphiques, il est
  défini dans l'espace de l'écran. Comme avec d'autres routines de transfert de bloc de Fastgraph,
  aucune coupure est effectuée.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.  Dans les graphiques
  modes, sa valeur est réduite à une limite d'octet si nécessaire.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx. Dans les modes graphiques, sa valeur est
  étendu à une limite d'octet, si nécessaire.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

newX est la coordonnée x du bord gauche de la région de destination. Sa valeur
  est réduite à une limite d'octet, si nécessaire.

 newy est la coordonnée y du bord inférieur de la région de destination.

 source_page est le numéro de la page vidéo contenant la région de source.

 dest_page est la vidéo numéro de page pour la région de destination.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Si source_page et dest_page référence la page vidéo même, la source et
  régions de destination ne doivent pas se chevaucher.

 La routine de fg_transfer applique toujours les pages vidéo, même lorsqu'un virtuel
  tampon est actif.

 263   

fg_transfer (suite)

*'''Voir aussi'''

 fg_copypage, fg_restore, fg_save, fg_tcxfer, fg_vbcopy

*'''Exemples'''

 11-4, 11-5, 11-6, 12-4, 12-5, 12-6

===fg_unpack===

*'''Prototype'''

 vide fg_unpack (char * source char * dest, int size);
  FGunpack sous (source $, $ dest, taille%)
  sous-programme fg_unpack (source de int1, dest int1, int size)
  procédure fg_unpack (source var, dest; taille: integer);

*'''But'''

 La routine de fg_unpack convertit une image bitmap spécifique en mode à la "une
  pixel par octet "format utilisé dans les modes graphiques 256 couleurs et virtuelle
  des tampons. Reportez-vous au Guide de l'utilisateur Fastgraph pour toutes les infos sur
  bitmaps spécifiques au mode.

 Dans les modes graphiques 256 couleurs, ou quand un tampon virtuel est actif, fg_unpack
  simplement une copie du tableau de source à la matrice de dest.

*'''Paramètres'''

 la source est le nom du tableau contenant le mode spécifique pixelisée
  image pour convertir. Il est supposé être dans le format spécifique pour le mode
   mode vidéo actuel.

 dest est le nom du tableau qui recevra le pixelisée converti
   image.

 la taille correspond à la taille du réseau de sources en octets.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Dans les modes de 16 bits, la taille de la source et dest réseaux est limitée à 64K
   octets.

 Cette routine n'a aucun effet en mode texte vidéo.

*'''Voir aussi'''

 fg_clpimage, fg_drwimage, fg_flpimage, fg_getimage, fg_pack, fg_putimage,
  fg_revimage, fg_scale, fg_shear

*'''Exemples'''

 10-16

===fg_vbaddr===

*'''Prototype'''

 longue fg_vbaddr (poignée int);
  fonction FGvbaddr & (poignée%)
  fonction int4 fg_vbaddr (int poignée)
  fonction fg_vbaddr (poignée: integer): pointeur;

*'''But'''

 La routine fg_vbaddr renvoie l'adresse de la mémoire tampon virtuelle spécifiée.

*'''Paramètres'''

 la poignée est la poignée qui fait référence à la mémoire tampon virtuelle, entre 0 et 31.

*'''Valeur de retour'''

L'adresse de la mémoire tampon virtuelle spécifiée. Dans les modes 16 bits, l'adresse
  sera un véritable segment des modes: paire offset ou sélecteur de mode protégé: offset
  paire.  Dans les modes de 32 bits, ce sera un décalage dans le segment de données par défaut.

*'''Restrictions'''

 Si la poignée ne fait pas référence une poignée de tampon virtuel valide, le retour
  valeur sera définie.

*'''Voir aussi'''

 fg_vbopen

===fg_vballoc===

*'''Prototype'''

 int fg_vballoc (int largeur, int hauteur);
  fonction FGvballoc% (largeur%, hauteur%)
  int fonction fg_vballoc (largeur, int hauteur)
  fonction fg_vballoc (largeur, hauteur: entier): nombre entier;

*'''But'''

 La routine de fg_vballoc crée un tampon virtuel de la taille spécifiée.  le
  mémoire pour la mémoire virtuelle est attribuée automatiquement. Cette routine
  devrait être utilisé au lieu de fg_vbdefine pour les compilateurs en mode réel qui ne sont pas
  soutenir d'énormes blocs de mémoire (qui est, des blocs beaucoup plus grand que 64K octets).

*'''Paramètres'''

 la largeur correspond à la largeur du buffer virtuel en pixels.

 la hauteur correspond à la hauteur du buffer virtuel en pixels.

*'''Valeur de retour'''

 En cas de succès, fg_vballoc renvoie une poignée par laquelle le tampon virtuel est
  référencé (entre 0 et 31). Si, les codes de retour possibles infructueuses
  sont -1 (table de tampon virtuel complet) ou -2 (ne peut pas allouer de la mémoire pour la
  tampon virtuel).

*'''Restrictions'''

 Cette routine est présent dans les bibliothèques en mode réel Fastgraph seulement.  Dans
  mode protégé, utilisez fg_vbdefine pour créer des tampons virtuels.

 les programmeurs de base doivent utiliser la fonction SETMEM pour réduire la taille loin tas
  par la taille de la mémoire tampon virtuelle plus 16 octets avant de créer un tampon virtuel
  avec fg_vballoc.

 Les programmeurs Pascal doivent utiliser la directive $ M pour réduire la taille bien tas par
  la taille de la mémoire tampon virtuelle avant d'appeler fg_vballoc.

*'''Voir aussi'''

 fg_vbdefine, fg_vbfree, fg_vbinit, fg_vbopen

===fg_vbclose===

*'''Prototype'''

 fg_vbclose void (void);
  FGvbclose sub ()
  sous-routine fg_vbclose ()
  procédure fg_vbclose;

*'''But'''

 La routine de fg_vbclose ferme le tampon virtuel actif et dirige
  sortie vers la page vidéo active graphique.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vbopen

*'''Exemples'''

 8-14, 8-15, 8-16, 8-17, 9-2, 10-16, 10-19, 11-7, 11-9, 13-8

===fg_vbcopy===

*'''Prototype'''

 fg_vbcopy void (int minx, maxx int, int Miny, int maxy, int newX, int newy,
    source int, int dest);
  FGvbcopy sous (minx de%, maxx%, miny%, maxy%, newX%, newy% source%, dest%)
  fg_vbcopy sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, source int, int dest)
  procédure fg_vbcopy (minx, maxx, Miny, Maxy, newX, newy, source, dest:
    entier);

*'''But'''

 La copie de routine une zone rectangulaire fg_vbcopy d'un tampon virtuel
  à une autre, ou vers une position sans chevauchement à l'intérieur de la même virtuelle
  tampon.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

 newX est la coordonnée x du bord gauche de la région de destination.

 newy est la coordonnée y du bord inférieur de la région de destination.

 la source est la poignée pour le tampon virtuel contenant la région de source.

 dest est la poignée pour le tampon virtuel contenant la destination
   région.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Si la source et dest référencent le même tampon virtuel, la source et
  régions de destination ne doivent pas se chevaucher.

*'''Voir aussi'''

 fg_vbcut, fg_vbdefine, fg_vbpaste

*'''Exemples'''

 11-7

===fg_vbcut===

*'''Prototype'''

 fg_vbcut void (int minx, maxx int, int Miny, int maxy, int newX, int newy);
  FGvbcut sous (minx%, maxx%, miny%, maxy%, newX%, newy%)
  fg_vbcut sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy)
  procédure fg_vbcut (minx, maxx, Miny, Maxy, newX, newy: integer);

*'''But'''

 Les copies de routine fg_vbcut une région rectangulaire de la page vidéo active
  à la mémoire tampon virtuelle active.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

 newX est la coordonnée x du bord gauche de la région de destination.

 newy est la coordonnée y du bord inférieur de la région de destination.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vbcopy, fg_vbdefine, fg_vbpaste

*'''Exemples'''

 8-15, 8-17

===fg_vbdefine===

*'''Prototype'''

 int fg_vbdefine (char [grand] * buffer, int largeur, int hauteur);
  fonction FGvbdefine% (tampon $, largeur%, hauteur%)
  fonction int fg_vbdefine (int1 [immense] tampon, int largeur, int hauteur)
  fonction fg_vbdefine (buffer: pointeur; largeur, hauteur: entier): nombre entier;

*'''But'''

 La routine de fg_vbdefine crée un tampon virtuel de la taille spécifiée.

*'''Paramètres'''

tampon est l'adresse de la mémoire virtuelle. Il doit faire référence à une mémoire
  bloc d'au moins la largeur * octets de hauteur. Reportez-vous au chapitre 8 de la Fastgraph
  Guide de l'utilisateur pour plus de détails au sujet de l'attribution des blocs de mémoire appropriée pour
  tampons virtuels. Notez que le tampon est passé par référence loin dans 16 bits
  les modes, sauf lors de l'utilisation de base.

 la largeur correspond à la largeur du buffer virtuel en pixels.

 la hauteur correspond à la hauteur du buffer virtuel en pixels.

*'''Valeur de retour'''

 En cas de succès, fg_vbdefine retourne une poignée par laquelle le tampon virtuel est
  référencé (entre 0 et 31). En cas d'échec, la routine renvoie -1.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vballoc, fg_vbinit, fg_vbopen, fg_vbundef

*'''Exemples'''

 8-14, 8-15, 8-16, 8-17, 9-2, 10-16, 10-19, 11-7, 11-9, 13-8

===fg_vbfree===

*'''Prototype'''

 fg_vbfree void (poignée int);
  FGvbfree sous (poignée%)
  fg_vbfree sous-programme (int poignée)
  procédure fg_vbfree (poignée: integer);

*'''But'''

 La routine fg_vbfree libère la poignée d'un tampon virtuel et libère le
  la mémoire allouée à la mémoire tampon virtuelle.

*'''Paramètres'''

poignée est la poignée qui fait référence à la mémoire tampon virtuelle libre. Sa valeur
  doit être compris entre 0 et 31 et ne doit pas faire référence à la mémoire tampon virtuelle active.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine est présent dans les bibliothèques en mode réel Fastgraph seulement.

 Vous devez utiliser fg_vbfree uniquement avec des tampons virtuels créés avec fg_vballoc.

 Cette routine n'a aucun effet si la poignée fait référence à la mémoire tampon virtuelle active.

*'''Voir aussi'''

 fg_vballoc

===fg_vbhandle===

*'''Prototype'''

 int fg_vbhandle (void);
  fonction FGvbhandle% ()
  int fonction fg_vbhandle ()
  fonction fg_vbhandle: integer;

*'''But'''

 La routine retourne fg_vbhandle la poignée du buffer virtuel actif.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 La poignée de tampon virtuel actif, entre 0 et 31. Si aucun buffer virtuel est
  actif, la valeur de retour est -1.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vbopen

===fg_vbinit===

*'''Prototype'''

 fg_vbinit void (void);
  FGvbinit sub ()
  sous-routine fg_vbinit ()
  procédure fg_vbinit;

*'''But'''

 La routine de fg_vbinit initialise environnement tampon virtuel Fastgraph.
  Cette routine doit être appelée une fois, avant que d'autres routines qui font référence
  tampons virtuels.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vballoc, fg_vbclose, fg_vbcopy, fg_vbcut, fg_vbdefine, fg_vbfree,
  fg_vbhandle, fg_vbopen, fg_vbpaste, fg_vbtcxfer, fg_vbundef

*'''Exemples'''

 8-14, 8-15, 8-16, 8-17, 9-2, 10-16, 10-19, 11-7, 11-9, 13-8

===fg_vbopen===

*'''Prototype'''

 int fg_vbopen (int handle);
  fonction FGvbopen% (poignée%)
  int fonction fg_vbopen (poignée int)
  fonction fg_vbopen (poignée: Integer): Integer;

*'''But'''

 La routine fg_vbopen fait un tampon virtuel existant actif virtuel
  tampon.

*'''Paramètres'''

 la poignée est la poignée du buffer virtuel souhaité, tel que renvoyé par
  fg_vballoc ou fg_vbdefine. Sa valeur doit être une poignée de tampon virtuel valide
  entre 0 et 31. Si un autre tampon virtuel est ouvert lorsque vous appelez cette
  de routine, ce buffer virtuel est d'abord fermé.

*'''Valeur de retour'''

 0 = tampon virtuel ouvert avec succès
  poignée de tampon virtuel -1 = Invalid
  -2 = Aucun tampon virtuel encore défini pour la poignée spécifiée

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vbclose, fg_vbdefine, fg_vbinit

*'''Exemples'''

 8-14, 8-15, 8-16, 8-17, 9-2, 10-16, 10-19, 11-7, 11-9, 13-8

===fg_vbpaste===

*'''Prototype'''

 fg_vbpaste void (int minx, maxx int, int Miny, int maxy, int newX,
    int newy);
  FGvbcopy sous (minx%, maxx%, miny%, maxy%, newX%, newy%)
  fg_vbpaste sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy)
  procédure fg_vbpaste (minx, maxx, Miny, Maxy, newX, newy: integer);

*'''But'''

 Les copies de routine fg_vbpaste une région rectangulaire de la virtuelle active
  tampon à la page de la vidéo active.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

 newX est la coordonnée x du bord gauche de la région de destination.

 newy est la coordonnée y du bord inférieur de la région de destination.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_vbcopy, fg_vbcut, fg_vbdefine, fg_vbtcxfer

*'''Exemples'''

 8-14, 8-15, 8-16, 8-17, 9-2, 10-16, 10-19, 11-7, 11-9, 13-8

===fg_vbtccopy===

*'''Prototype'''

 fg_vbtccopy void (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, source int, int dest);
  FGvbtccopy sous (minx de%, maxx%, miny%, maxy%, newX%, newy% source%, dest%)
  fg_vbtccopy sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy, source int, int dest)
  procédure fg_vbtccopy (minx, maxx, Miny, Maxy, newX, newy, source, dest:
    entier);

*'''But'''

 La copie de routine une zone rectangulaire fg_vbtccopy d'un tampon virtuel
  à une autre, ou vers une position sans chevauchement à l'intérieur de la même virtuelle
  tampon, avec des couleurs transparentes. Utiliser fg_tcdefine ou pour définir fg_tcmask
  les couleurs sont transparentes.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

 newX est la coordonnée x du bord gauche de la région de destination.

 newy est la coordonnée y du bord inférieur de la région de destination.

 la source est la poignée pour le tampon virtuel contenant la région de source.

 dest est la poignée pour le tampon virtuel contenant la destination
   région.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Si la source et dest référencent le même tampon virtuel, la source et
  régions de destination ne doivent pas se chevaucher.

*'''Voir aussi'''

 fg_tcdefine, fg_tcmask, fg_tcxfer, fg_vbcopy


===fg_vbtcxfer===

*'''Prototype'''

 fg_vbtcxfer void (int minx, maxx int, int Miny, int maxy, int newX,
    int newy);
  sous FGvbtcxfer (minx%, maxx%, miny%, maxy%, newX%, newy%)
  fg_vbtcxfer sous-programme (int minx, maxx int, int Miny, int maxy, int newX,
    int newy)
  procédure fg_vbtcxfer (minx, maxx, Miny, Maxy, newX, newy: integer);

*'''But'''

 La fg_vbtcxfer copies de routine d'une région rectangulaire de la virtuelle active
  tampon à la page de la vidéo active, à l'exclusion des pixels transparents.  le
  fg_tcdefine et fg_tcmask routines définissent les couleurs qui sont transparents.

*'''Paramètres'''

 minx est la coordonnée x du bord gauche de la région de source.

 maxx est la coordonnée X du bord droit de la zone de source.  Ce doit être
  supérieure ou égale à la valeur de minx.

 Miny est la coordonnée y de bord supérieur de la région de source.

 maxy est la coordonnée y du bord inférieur de la région de source.  Ce doit être
  supérieure ou égale à la valeur de miny.

 newX est la coordonnée x du bord gauche de la région de destination.

 newy est la coordonnée y du bord inférieur de la région de destination.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_tcdefine, fg_tcmask, fg_tcxfer, fg_vbdefine, fg_vbpaste, fg_vbtccopy

*'''Exemples'''

 11-9

===fg_vbundef===

*'''Prototype'''

 fg_vbundef void (poignée int);
  FGvbundef sous (poignée%)
  fg_vbundef sous-programme (int poignée)
  procédure fg_vbundef (poignée: integer);

*'''But'''

 La routine de fg_vbundef libère la poignée associée à une virtuelle
  tampon.

*'''Paramètres'''

poignée est la poignée de tampon virtuel pour libérer. Sa valeur doit être comprise entre 0
  et 31 et ne doit pas faire référence à la mémoire tampon virtuelle active.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a aucun effet si la poignée fait référence à la mémoire tampon virtuelle active.

*'''Voir aussi'''

 fg_vbdefine

===fg_version===

*'''Prototype'''

 fg_version void (int * major, int * mineur);
  FGversion sub (majeur%, mineure%)
  sous-programme fg_version (int majeur, int mineur)
  procédure fg_version (var majeur, mineur: entier);

*'''But'''

 La routine fg_version renvoie les grands et petits numéros de version pour votre
  copie de Fastgraph ou Fastgraph / Lumière. Par exemple, si vous utilisez
  Fastgraph version 2.10, le numéro de version majeure est 2 et la version mineure
  nombre est 10.

*'''Paramètres'''

 major reçoit le numéro de version majeure.

 mineur reçoit le numéro de version mineure, exprimé en centièmes.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_svgaver

*'''Exemples'''

 1-1

===fg_vgastate===

*'''Prototype'''

 fg_vgastate void (option int);
  FGvgastate sub (en option%)
  fg_vgastate sous-programme (option int)
  procédure fg_vgastate (option: integer);

*'''But'''

 La routine de fg_vgastate enregistre ou restaure l'état des graphiques VGA
  registres du contrôleur et du contrôleur de séquence utilisés par Fastgraph.  le
  les articles suivants sont sauvegardés ou restaurés:

 * Indice Contrôleur graphique
    * Contrôleur graphique enregistre 0-8
    * Sequence index Controller
    * Sequence Controller registre 2

 Si vous demandez une opération de restauration avant d'effectuer une opération de sauvegarde,
  fg_vgastate ne fait rien.

*'''Paramètres'''

 option spécifie si fg_vgastate effectue une opération de sauvegarde ou de restauration.
  Si l'option est égal à zéro, les valeurs de registre en cours sont sauvegardés. Si elle est toute
  autre valeur, les valeurs de registre précédemment enregistrés sont restaurés.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine n'a de sens que dans les modes vidéo numérotés 13 et ci-dessus lorsque
  fonctionnant sur un système VGA ou SVGA.

===fg_voice===

*'''Prototype'''

 fg_voice void (int canal, la fréquence int, volume int, int durée);
  FGvoice sous (canal%, fréquence%,% en volume, la durée%)
  fg_voice sous-programme (int canal, la fréquence int, volume int, int durée)
  procédure fg_voice (canal, fréquence, volume, durée: integer);

*'''But'''

 La routine de fg_voice produit un son d'une fréquence, la durée spécifiée,
  et le volume en utilisant l'une des quatre voix indépendante de la puce sonore TI
   canaux.

*'''Paramètres'''

 canal définit le canal vocal ou le type de bruit, comme indiqué ici:

 sens de la valeur

 1 voix canal # 1
                              2 voix canal # 2
                              3 voix canal # 3
                              4 voix canal n ° 4, le bruit périodique
                              5 voix canal # 4, bruit blanc

fréquence définit la fréquence de la tonalité en Hertz. Si le canal est égal à 1, 2 ou 3,
  alors la fréquence représente la fréquence réelle, entre 18 et 32.767.  Si
  le canal est 4 ou 5, la fréquence est à la place une valeur qui représente une spécifique
  fréquence, comme indiqué ici:

 La valeur de la fréquence

 0 512 Hertz
                              1 1024 Hertz
                              2 2048 Hertz

 le volume est le volume de la tonalité, entre 0 (silence) et 15 (le plus fort).

 la durée est la longueur de la tonalité en tops d'horloge (il y a environ 18.2
  horloge par seconde). Si la durée est nulle ou négative, le ton est dit
  être continu et va jouer jusqu'à ce que vous arrêtiez avec fg_quiet.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine ne doit être utilisé sur les systèmes équipés de la puce sonore TI
  (À savoir la PCjr et 1000 Tandy systèmes). Elle n'a aucun effet s'il y a
  son asynchrone déjà en cours.

*'''Voir aussi'''

 fg_music, fg_quiet, fg_sound, fg_voices

*'''Exemples'''

 15-2

===fg_voices===

*'''Prototype'''

 fg_voices void (int * sound_array, int nTimes);
  sous FGvoices (sound_array% (), nTimes%)
  fg_voices de sous-programme (int sound_array, int nTimes)
  fg_voices procédure (var sound_array: Integer; nTimes: integer);

*'''But'''

 La routine de fg_voices utilise la puce sonore TI pour jouer une série de tonalités de
  fréquences spécifiées, les durées et les volumes, simultanées avec d'autres
   activité. Elle est la version asynchrone de fg_voice.

*'''Paramètres'''

 sound_array est le nom du tableau contenant une série de (canal,
  définitions fréquence, volume, durée) sonores. Le format de ce tableau
   est:

 [0] canal # 1 du son

 [1] fréquence du son 1

 [2] volume du son 1

 [3] durée de son 1

  .
                                          .
                                          .

 [4n-4] canal # de son n

 [4n-3] fréquence du son n

 [4n-2] volume du son n

 [4n-1] durée de son n

 [4n] terminaison (0)

 Les numéros de canaux, les fréquences, les volumes et les durées doivent être dans la
  mêmes plages que discuté dans *'''But''' de fg_voice, à l'exception du
  les durées sont quadruplé en raison de l'horloge accélérée tick interrupt
  taux (il y a 72,8 au lieu de 18,2 horloge par seconde). A null
  personnage (soit un octet nul) se termine à la matrice.

 nTimes spécifie le nombre de fois à travers les sons définis pour le cycle
  sound_array. Si nTimes est négatif, les sons vont jouer répétitivement jusqu'à ce que
  arrêté avec fg_hush ou fg_hushnext.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 Cette routine ne doit être utilisé sur les systèmes équipés de la puce sonore TI
  (À savoir la PCjr et 1000 Tandy systèmes). Elle n'a aucun effet s'il y a
  son asynchrone déjà en cours.

 Pour élargir la gamme des effets sonores, Fastgraph temporairement le quadruple
  horloge taux d'interruption de la tique de 18,2 à 72,8 tiques par seconde tandis que
  produire un son asynchrone. Parce que de nombreux contrôleurs de disques comptent sur le
  18,2 tick par seconde fréquence d'horloge pour synchroniser les accès disque, vos programmes
  ne devrait pas effectuer toutes les opérations de disque lorsque le son asynchrone est en
  la progression.

 Dans les modes de 16 bits, la taille des sound_array est limitée à 64K octets.

*'''Voir aussi'''

 fg_hush, fg_hushnext, fg_musicb, fg_playing, fg_sounds, fg_voice

*'''Exemples'''

 15-5

===fg_waitfor===

*'''Prototype'''

 fg_waitfor void (int ticks);
  FGwaitfor sous (ticks%)
  sous-programme fg_waitfor (int ticks)
  procédure fg_waitfor (ticks: integer);

*'''But'''

 La routine fg_waitfor retarde l'exécution d'un programme pour un nombre donné de
  clock ticks. Il y a 18,2 horloge par seconde, quelle que soit la
  la vitesse du processeur de système.

*'''Paramètres'''

 tiques est le nombre d'impulsions d'horloge à attendre.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_stall

*'''Exemples'''

 5-11, 5-12, 12-1 à 12-6, 13-5, 13-6, 14-2, 14-5, 14-7, 14-8, 14-12, 14-13,
  15-1, 15-2, 15-3, 15-6, 15-7, 16-1

===fg_waitkey===

*'''Prototype'''

 fg_waitkey void (void);
  FGwaitkey sub ()
  sous-routine fg_waitkey ()
  procédure fg_waitkey;

*'''But'''

 La routine de fg_waitkey vide la mémoire tampon du clavier du BIOS (qui est, supprime
  tous les caractères de type à venir) et attend une autre touche.  Il est très
  utile dans "appuyer sur une touche pour continuer" situations.

*'''Paramètres'''

 aucun

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getkey, fg_intkey

*'''Exemples'''

 3-2 à 3-8, 3-10

===fg_waitvr===

*'''Prototype'''

 fg_waitvr void (int state);
  FGwaitvr sous (état%)
  fg_waitvr sous-programme (int state)
  procédure fg_waitvr (état: entier);

*'''But'''

 La routine de fg_waitvr désactive ou active Fastgraph de vertical interne
  revenir en attente (elle est activée par défaut). Quand il est désactivé, Fastgraph
  suppose votre application va contrôler la synchronisation de retour comme
   nécessaire. retraçage vertical attente applique aux routines Fastgraph énumérés
  dans la section "voir aussi" ci-dessous.

*'''Paramètres'''

 Etat définit si retour vertical attente est activée ou désactivée.  Si
  état est 0, retour vertical attente est désactivé. Si elle est de 1, à la verticale
  retraçage attente est activée.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getdacs, fg_makegif, fg_makepcx, fg_palettes, fg_pan, fg_setdacs,
  fg_setvpage, fg_showgif, fg_showpcx

===fg_where===

*'''Prototype'''

 fg_where void (int * de ligne, int * colonne);
  sous FGwhere (ligne%, colonne%)
  fg_where sous-programme (int ligne, colonne int)
  procédure fg_where (ligne, colonne: nombre entier);

*'''But'''

 La routine de fg_where récupère la position du curseur de texte pour les actifs
  page d'affichage.

*'''Paramètres'''

 rangée reçoit le numéro de la ligne courante du curseur de texte, entre 0 et un de moins
  que le nombre de lignes de caractères disponibles.

 colonne reçoit le numéro de colonne courante de curseur de texte, entre 0 et un de moins
  que le nombre de colonnes de caractères disponibles.

*'''Valeur de retour'''

 aucun

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_locate

*'''Exemples'''

 7-2

===fg_xalpha===

*'''Prototype'''

 int fg_xalpha (int ix);
  fonction FGxalpha% (ix%)
  int fonction fg_xalpha (int ix)
  fonction fg_xalpha (ix: nombre entier): nombre entier;

*'''But'''

 La routine fg_xalpha traduit un espace x écran de coordonnées à la
  colonne de l'espace de caractères contenant cette coordonnée.

*'''Paramètres'''

 ix est l'espace de l'écran de coordonnées à traduire.

*'''Valeur de retour'''

 La colonne de l'espace de caractères contenant l'espace de l'écran de coordonnées ix.  Dans
  modes de texte, la valeur de retour est égale à la valeur de ix.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_xconvert, fg_yalpha, fg_yconvert

*'''Exemples'''

 14-10

===fg_xconvert===

*'''Prototype'''

 int fg_xconvert (int colonne);
  fonction FGxconvert% (colonne%)
  int fonction fg_xconvert (colonne int)
  fonction fg_xconvert (colonne: nombre entier): nombre entier;

*'''But'''

 La routine fg_xconvert traduit une colonne de l'espace de caractères à l'écran
  l'espace de coordonnées de son pixel de gauche. Dans les modes graphiques vidéo,
  fg_xconvert (1) est un moyen facile de déterminer la largeur en pixels d'un
  cellule de caractère.

*'''Paramètres'''

 colonne est la colonne de l'espace de caractères à traduire.

*'''Valeur de retour'''

 L'espace x écran coordonnée du pixel à gauche dans l'espace de caractère
  Colonne de colonne. En mode texte, la valeur de retour est égale à la valeur de
   colonne.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_xalpha, fg_yalpha, fg_yconvert

*'''Exemples'''

 7-9, 14-8

===fg_xscreen===

*'''Prototype'''

 int fg_xscreen (double x);
  fonction FGxscreen% (x #)
  int fonction fg_xscreen (dbl x)
  fonction fg_xscreen (x: real): integer;

*'''But'''

 La routine fg_xscreen traduit un espace mondial coordonnée x à son écran
  un espace équivalent.

*'''Paramètres'''

 x est l'espace mondial de coordonnées à traduire.

*'''Valeur de retour'''

 L'espace x écran de coordonnées équivalent à l'espace mondial de coordonnées x.

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_xworld, fg_yscreen, fg_yworld

===fg_xview===

*'''Prototype'''

 int fg_xview (int vx);
  fonction FGxview% (vx%)
  int fonction fg_xview (int vx)
  fonction fg_xview (vx: Integer): Integer;

*'''But'''

 La routine fg_xview traduit une fenêtre horizontale coordonnée à la
  correspondant espace x écran de coordonnées.

*'''Paramètres'''

 vx est la fenêtre coordonnée horizontale à traduire.

*'''Valeur de retour'''

 L'espace x écran de coordonnées correspondant à la fenêtre spécifiée
  coordonner. Si aucune fenêtre a été définie, la valeur de retour sera égale
  à vx.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getview, fg_setview, fg_yview

*'''Exemples'''

 4-3

===fg_xworld===

*'''Prototype'''

 à double fg_xworld (int ix);
  fonction FGxworld # (ix%)
  fonction dbl fg_xworld (int ix)
  fonction fg_xworld (ix: integer): real;

*'''But'''

 La routine fg_xworld traduit un espace d'écran coordonnée x à son monde
  un espace équivalent.

*'''Paramètres'''

 ix est l'espace de l'écran de coordonnées à traduire.

*'''Valeur de retour'''

 L'espace x mondiale coordonnée équivalente à l'espace de l'écran de coordonnées ix.

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_xscreen, fg_yscreen, fg_yworld

===fg_yalpha===

*'''Prototype'''

 int fg_yalpha (int iy);
  fonction FGyalpha% (iy%)
  int fonction fg_yalpha (int iy)
  fonction fg_yalpha (iy: Integer): Integer;

*'''But'''

 La routine fg_yalpha traduit un espace d'écran coordonnée y à la
  rangée de caractères de l'espace contenant cette coordonnée.

*'''Paramètres'''

 iy est l'espace de l'écran de coordonnées à traduire.

*'''Valeur de retour'''

La ligne de l'espace de caractères contenant l'espace de l'écran de coordonnées iy. Dans le texte
  modes, la valeur de retour est égale à la valeur de iy.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_xalpha, fg_xconvert, fg_yconvert

*'''Exemples'''

 14-10

===fg_yconvert===

*'''Prototype'''

 int fg_yconvert (int ligne);
  fonction FGyconvert% (ligne%)
  int fonction fg_yconvert (int ligne)
  fonction fg_yconvert (ligne: entier): nombre entier;

*'''But'''

 La routine fg_yconvert traduit une ligne d'espace de caractère à l'écran
  l'espace de coordonnées de son sommet (numéro le plus bas) pixel. Dans les graphiques vidéo
  modes, fg_yconvert (1) est un moyen facile de déterminer la hauteur en pixels d'un
  cellule de caractère.

*'''Paramètres'''

 ligne est la ligne d'espace de caractère à traduire.

*'''Valeur de retour'''

 L'espace écran coordonnée y du pixel en haut dans l'espace rangée de caractères
   rangée. Dans les modes de texte, la valeur de retour est égale à la valeur de la ligne.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_xalpha, fg_xconvert, fg_yalpha

*'''Exemples'''

 7-9, 14-8

===fg_yscreen===

*'''Prototype'''

 int fg_yscreen (double-y);
  fonction FGyscreen% (y #)
  int fonction fg_yscreen (dbl y)
  fonction fg_yscreen (y: real): integer;

*'''But'''

 La routine fg_yscreen traduit un espace mondial coordonnée y à son écran
  un espace équivalent.

*'''Paramètres'''

 y est l'espace mondial de coordonnées à traduire.

*'''Valeur de retour'''

 L'espace écran coordonnée y équivalent à l'espace mondial de coordonnées y.

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_xscreen, fg_xworld, fg_yworld

===fg_yview===

*'''Prototype'''

 int fg_yview (int vy);
  fonction FGyview% (vy%)
  int fonction fg_yview (int vy)
  fonction fg_yview (vy: Integer): Integer;

*'''But'''

 La routine fg_yview traduit une fenêtre coordonnée verticale du
  l'espace de l'écran correspondant coordonnée y.

*'''Paramètres'''

 vy est la fenêtre coordonnée verticale à traduire.

*'''Valeur de retour'''

 L'espace écran coordonnée y correspondant à la fenêtre spécifiée
  coordonner. Si aucune fenêtre a été définie, la valeur de retour sera égale
  à Vy.

*'''Restrictions'''

 aucun

*'''Voir aussi'''

 fg_getview, fg_setview, fg_xview

*'''Exemples'''

 4-3

===fg_yworld===

*'''Prototype'''

 à double fg_yworld (int iy);
  fonction FGyworld # (iy%)
  fonction dbl fg_yworld (int iy)
  fonction fg_yworld (iy: integer): real;

*'''But'''

 La routine fg_yworld traduit un espace d'écran coordonnée y à son monde
  un espace équivalent.

*'''Paramètres'''

 iy est l'espace de l'écran de coordonnées à traduire.

*'''Valeur de retour'''

 L'espace mondial coordonnée y équivalent à l'espace de l'écran de coordonnées iy.

*'''Restrictions'''

 Cette routine est pas disponible dans Fastgraph / Lumière.

*'''Voir aussi'''

 fg_xscreen, fg_xworld, fg_yscreen




==Fastgraph Utilities==

Cette annexe décrit les programmes utilitaires fournis avec Fastgraph.  Par
par défaut, la procédure d'installation Fastgraph place ces utilitaires dans le répertoire \ FG. Pour utiliser ces utilitaires, vous devez soit (1) copier le fichier EXE de \ FG à votre répertoire courant, (2) faire \ FG votre répertoire courant, ou (3) inclure le répertoire \ FG dans votre spécification de chemin DOS.


===INSTANTANÉ Utility===

L'utilitaire INSTANTANÉ est un fin et rester programme résident (TSR) à
capturer des images graphiques. Il stocke l'image dans la norme pixel run (SPR) format Fastgraph. Pour charger INSTANTANÉ, il suffit d'entrer la commande INSTANTANÉ à l'invite DOS, et vous verrez des messages similaires aux cas INSTANTANÉ charges suivantes avec succès.


 C> INSTANTANÉ

 INSTANTANÉ Version 1.04
        Copyright (c) 1993 Ted Gruber Software.  Tous les droits sont réservés.

 Appuyez sur <alt> - <shift gauche> pour l'activer.


Après des charges INSTANTANÉ, la commande revient à l'invite DOS.  À ce point,
vous pouvez utiliser tout procédé que ce soit pour afficher une image graphique et puis appuyez sur les touches Alt et Maj gauche en même temps pour capturer l'image. Vous ne devez pas charger INSTANTANÉ pour chaque capture d'image, une seule fois par le démarrage du système. INSTANTANÉ utilise environ 24.000 octets de mémoire conventionnelle, une fois chargés.

Pour illustrer l'utilisation de INSTANTANÉ, supposons que vous avez dessiné et sauvegardé un
image avec un programme de peinture commerciale, et que vous voulez incorporer cette image dans une application Fastgraph. Une fois que vous chargez INSTANTANÉ, démarrez le programme de peinture et de récupérer votre image. Ensuite, appuyez sur les touches Alt et Maj gauche simultanément et attendez la tonalité de réussite (trois sons de pente moyenne rapide). Enfin, quittez le programme de peinture pour revenir à l'invite DOS.

La séquence décrite dans le paragraphe précédent va stocker le capturé
l'image au format pixel de fonctionnement standard de Fastgraph, dans un fichier nommé SNAPSHOT.nnn dans le répertoire courant. Le nnn de type de fichier sera la première séquence de chiffres qui ne donnent pas lieu à un nom de fichier dupliqué. Autrement dit, s'il n'y a pas des fichiers d'images capturées dans le répertoire courant, INSTANTANÉ utilisera le nom du fichier SNAPSHOT.000. La prochaine fois que vous prenez une photo, INSTANTANÉ va stocker dans SNAPSHOT.001, puis SNAPSHOT.002, et ainsi de suite. Si vous renommez ou supprimez un de ces fichiers, INSTANTANÉ sera à nouveau utiliser ce nom de fichier. Par exemple, si vous supprimez SNAPSHOT.000 mais gardez SNAPSHOT.001, INSTANTANÉ va stocker l'image suivante il capture en SNAPSHOT.000.

Si SNAPSHOT est incapable de capturer l'image, il produira son erreur
ton (un son unique à faible pente). La cause la plus courante de cette tente de capturer une image à partir d'un texte en mode vidéo, mais il sera également se produire s'il n'y a pas assez d'espace disque ou si tous les 1000 noms de fichiers d'image sont déjà utilisés.


==Utilitaire CLIP==

L'utilitaire INSTANTANÉ décrit dans la section précédente capture la
tout l'écran. Bien que cela puisse être souhaitable dans certains cas, d'autres fois vous aurez juste besoin d'une partie de l'écran. CLIP est un utilitaire interactif que vous pouvez utiliser pour réduire la taille d'une image stockée au format pixel d'exécution standard ou emballé de Fastgraph. La syntaxe de la commande pour appeler l'utilitaire CLIP à partir de l'invite DOS est

CLIP fichier_entrée les options output_file
où fichier_entrée est le nom du fichier d'image d'origine, et output_file est le nom du nouveau fichier image. CLIP ne modifie pas le fichier_entrée en aucune façon, mais il écrasera le output_file si un fichier portant le même nom existe dans le répertoire en cours. La liste des options spécifie un ou plusieurs commutateurs en option comme indiqué ici:

Option sens

/ M: Mode Indique le numéro de mode vidéo dans lequel pour afficher l'image. le

 La valeur de mode doit être un nombre entier compris entre 0 et 29. Si ce mode vidéo
         est un mode texte, un mode graphique non pris en charge, ou un indisponible
         mode graphique, CLIP affiche un message d'erreur indiquant cela.  Si la
         / M commutateur est pas présent, CLIP utilise le premier mode vidéo disponible
         à partir de la liste 18, 16, 15, 19, 13, 9, 4, 12.

/ P Indique le fichier_entrée est au format pixel de course emballé de Fastgraph.

 Si le commutateur / P est pas présent, CLIP suppose qu'il est dans la norme
         pixel Format exécuté. Output_file le sera dans le même format que le
         fichier_entrée.

/ W: largeur Indique la largeur de l'image en pixels. La valeur de largeur doit être un

 entier compris entre 1 et la résolution horizontale de l'sélectionné
         mode vidéo. Si le commutateur / W est pas présent, CLIP utilise le
         la résolution horizontale du mode vidéo sélectionné.

Par exemple, si vous voulez créer le fichier image PARTIAL.PPR du SCREEN.PPR de fichier d'exécution de pixel emballé, et utiliser le 320x200 graphiques EGA mode vidéo natif (mode 13), vous commencez CLIP avec la commande suivante.

 CLIP PARTIAL.PPR SCREEN.PPR / P / M: 13

Parce qu'aucun commutateur / W apparaît dans la commande ci-dessus et la résolution horizontale de mode 13 est de 320 pixels, CLIP prend la largeur de l'image est de 320 pixels.

Lorsque CLIP affiche l'image et le curseur en forme de plus-, vous êtes prêt à
définir un coin de la zone de découpage (cette partie de l'image utilisée pour créer le output_file). Pour ce faire, utilisez les touches directionnelles du clavier numérique pour déplacer le curseur à la position désirée, puis appuyez sur la touche Entrée. Vous êtes alors prêt à définir le coin opposé de la zone de découpage. Encore une fois, utilisez les touches directionnelles pour déplacer le curseur à la position désirée. Lors de la définition du deuxième coin, cependant, CLIP utilise une boîte rectangulaire au lieu du curseur en forme de plus- pour simplifier le marquage des limites de la zone de découpage. Une fois que vous appuyez sur Entrée pour définir le deuxième virage, CLIP crée le output_file et le Guide de l'utilisateur 358 Fastgraph
affiche la largeur de l'image résultante et le nombre de pixel exécute l'image contient.

CLIP inclut d'autres fonctionnalités pour aider à définir la zone de découpage.  Vous pouvez
changer la distance le curseur se déplace en réponse aux touches directionnelles, afficher les courants (x, y) les coordonnées de pixels du curseur, et changer la couleur du curseur. Le tableau suivant explique les frappes que CLIP reconnaît lorsque vous définissez la zone de découpage.
signification clé

F1 Affiche le (x, y) de coordonnées barre en haut de l'écran. Si la

 coordonner bar est déjà allumé, F1 supprime.

F2 Affiche le (x, y) de coordonnées barre en bas de l'écran. Si

 la barre de coordonnées est déjà allumé, F2 supprime.

F3 Transforme le curseur ou la boîte de couleur du blanc au noir, ou du noir

 au blanc.

F4 Affiche un résumé des touches CLIP reconnaît lors de la définition de la

 zone de découpage.

KP1 Déplace le curseur d'une unité vers le bas et vers la gauche. KP2 Déplace le curseur un vers le bas de l'unité. KP3 Déplace le curseur d'une unité vers le bas et vers la droite. KP4 Déplace le curseur d'une unité vers la gauche. KP6 Déplace le curseur d'une unité vers la droite. KP7 Déplace le curseur d'une unité et à la gauche. KP8 Déplace le curseur d'une unité vers le haut. KP9 Déplace le curseur d'une unité et à droite. + Augmente l'unité de déplacement du curseur d'un pixel. Le défaut

 le mouvement du curseur est un pixel.

- Diminue l'unité de déplacement du curseur d'un pixel. Entrez Définit un coin de la zone de découpage à la position du curseur. Esc Quitte à DOS sans créer output_file. CLIP sera d'abord question

un "Exit to DOS?" rapide en cas vous avez appuyé sur la touche Echap
         accidentellement.


==CONVERT Utility==

L'utilitaire CONVERT vous permet de traduire des fichiers entre la SPR et de Fastgraph
PPR formats de fichier d'image. La syntaxe de la commande pour appeler CONVERT partir de l'invite DOS est

 CONVERT output_file fichier_entrée

où fichier_entrée est le nom du fichier d'image d'origine, et output_file est le nom du nouveau fichier image traduit. CONVERT ne modifie pas le fichier_entrée en aucune façon, mais il écrasera le output_file si un fichier portant le même nom existe dans le répertoire en cours.

 Par défaut, le type de fichier de l'fichier_entrée et output_file déterminer la

format d'image de ce fichier. Si le type de fichier est PPR, CONVERT assume l'image est au format pixel de course emballé de Fastgraph. Si le type de fichier est SPR, CONVERT suppose qu'il est au format pixel de fonctionnement standard de l'Fastgraph. Si vos fichiers d'images utilisent d'autres types de fichiers, vous pouvez spécifier explicitement le format d'image du fichier en ajoutant l'un des commutateurs / PPR ou / SPR au nom de fichier. Le fichier_entrée

 Annexe A: Fastgraph Utilities 359


et output_file ne doit pas aussi bien spécifier le même format d'image (CONVERT affichera un message d'erreur si tel est le cas).

La commande suivante traduire le fichier pixel d'exécution norme
PICTURE.SPR au format compressé. L'image emballé sera stockée dans le fichier PICTURE.IMG, nous devons donc ajouter le commutateur / PPR pour dire CONVERT que ce sera un fichier compressé.

 CONVERSION PICTURE.SPR PICTURE.IMG / PPR


===EDITSPR Utility===

L'utilitaire EDITSPR change toutes les courses de pixels d'une couleur à une autre couleur
dans un fichier image stocké dans la norme pixel run (SPR) format Fastgraph. La syntaxe de la commande pour appeler l'utilitaire EDITSPR de l'invite de commande DOS est

 EDITSPR fichier_entrée output_file

où fichier_entrée est le nom du fichier d'image d'origine, et output_file est le nom du nouveau fichier image. EDITSPR ne modifie pas le fichier_entrée en aucune façon, mais il écrasera le output_file si un fichier portant le même nom existe dans le répertoire en cours.

 Après il lit les pistes de pixels de l'fichier_entrée, EDITSPR effectuera

les changements de couleur requises. Elle le fait de manière itérative en demandant une valeur de couleur ancienne suivie d'une nouvelle valeur de couleur (chaque valeur doit être comprise entre 0 et 255). EDITSPR trouve alors les pistes de pixels de la valeur de couleur vieux et les changements à la nouvelle valeur de couleur. Par la suite, EDITSPR affiche un message indiquant le nombre de pixel court il a changé. Ce processus se répète jusqu'à ce que vous entrez un nombre négatif pour l'une des valeurs de couleur.

 EDITSPR va ensuite combiner pistes de pixels adjacents de couleurs semblables.  Pour

exemple, supposons que le fichier image d'origine contenait une couleur 1 pixel course de longueur 50, suivi d'un pixel run couleur 2 de longueur 20, suivie d'une autre couleur 1 pixel course de longueur 10. Si vous avez changé toutes les couleurs 2 pixel fonctionne à la couleur 1 , EDITSPR va combiner ces trois points de pixels en une seule course de longueur 80.


===GrabRGB Utility===

L'utilitaire GrabRGB est une fin et rester programme résident (TSR) à
capturer les rouges, verts et bleus composantes de couleur actuelles de vidéo registres du CAD dans les modes graphiques 256 couleurs. Vous pouvez utiliser GrabRGB conjointement avec l'utilitaire de INSTANTANÉ de Fastgraph pour préserver les couleurs d'origine d'une image capturée.

Pour charger GrabRGB, il suffit d'entrer la commande GRABRGB à l'invite DOS.  Après
charges GrabRGB, le contrôle revient à l'invite DOS. À ce stade, vous pouvez utiliser tout procédé que ce soit pour afficher une image graphique 256 couleurs, puis appuyez sur la touche Alt et décalage à droite des touches en même temps pour capturer les valeurs du CAD actuelles. Vous ne devez charger GrabRGB pour chaque image, une seule fois par le démarrage du système. GrabRGB utilise environ 28.000 octets de mémoire conventionnelle, une fois chargés. Guide de l'utilisateur 360 Fastgraph


Pour illustrer l'utilisation de GrabRGB, supposons que vous avez dessiné et enregistré un 256-
image couleur avec un programme de peinture commerciale, et que vous voulez incorporer cette image dans une application Fastgraph. Une fois que vous chargez INSTANTANÉ et GrabRGB, démarrez le programme de peinture et de récupérer votre image. Ensuite, appuyez sur les touches Maj gauche Alt et pour capturer l'image avec SNAPSHOT. Après le succès de ton de INSTANTANÉ (trois sons de pente moyenne rapide), appuyez sur Alt et Maj de droite pour saisir les composantes RVB de chaque CNA enregistrent avec GrabRGB, et attendre pour le succès de ton de GrabRGB. Enfin, quittez le programme de peinture et de revenir à l'invite DOS.

La séquence décrite dans le paragraphe précédent écrira le RGB
composantes de couleur pour chaque DAC enregistrent dans un fichier nommé GRABRGB.nnn dans le répertoire courant. Le nnn de type de fichier sera la première séquence de chiffres qui ne donnent pas lieu à un nom de fichier dupliqué. Autrement dit, s'il n'y a pas de fichiers de sortie GrabRGB dans le répertoire courant, GrabRGB utilisera le nom du fichier GRABRGB.000. La prochaine fois que vous utilisez GrabRGB, il va stocker les informations RVB dans GRABRGB.001, puis GRABRGB.002, et ainsi de suite. Si vous renommez ou supprimez un de ces fichiers, GrabRGB sera à nouveau utiliser ce nom de fichier. Par exemple, si vous supprimez GRABRGB.000 mais gardez GRABRGB.001, GrabRGB va ensuite utiliser le nom du fichier GRABRGB.000.

Si GrabRGB est incapable d'obtenir les composantes RVB de chaque registre DAC,
il produira sa tonalité d'erreur (un son unique à faible pente). La cause la plus courante de cette tente de capturer une image à partir d'un mode vidéo de texte ou d'un mode graphique vidéo avec moins de 256 couleurs. Il sera également se produire s'il n'y a pas assez d'espace disque ou si tous les 1000 noms de fichiers de sortie sont déjà utilisés.

Chaque ligne dans le fichier de sortie créé par GrabRGB est de la forme

 nnn, rr, gg, bb,

où nnn est un indice de registre DAC (entre 0 et 255), rr est la composante rouge de ce registre DAC, gg est la composante verte, et bb est la composante bleue. Chaque composante de couleur est comprise entre 0 et 63. Vous pouvez éditer et reformater ces lignes que nécessaire pour l'inclusion dans un C ou la liste d'initialisation de C, une déclaration de données BASIC ou FORTRAN, ou une liste constante de type tableau Pascal. Un tel réseau de composants RVB, mais sans les indices nnn, est dans le format attendu par fg_setdacs.

 Par défaut, GrabRGB capture des informations pour tous les 256 registres du CAD.  Si

vous voulez considérer que le CAD enregistre avec des composants de couleurs différentes de leurs valeurs par défaut, juste inclure l'option / D lorsque vous chargez GrabRGB (qui est, utilisez la commande GRABRGB / D). Si vous spécifiez l'option / D et les 256 DACs utiliser leurs valeurs par défaut, le fichier de sortie contiendra un message indiquant cela.


===HERCFIX Utility===

L'utilitaire HERCFIX vous permet d'utiliser INSTANTANÉ (et éventuellement d'autres programmes)
avec des programmes qui ne mettent pas à jour la zone de données du BIOS lors de l'établissement du mode graphique 720x348 Hercules. Si vous utilisez INSTANTANÉ avec un tel programme, il pense que le mode texte monochrome (mode vidéo 7) est actif et produira sa tonalité d'erreur grave lorsqu'il est activé.

Si cela se produit, utilisez HERCFIX pour charger l'application à partir de laquelle vous êtes
essayant de capturer l'image. Pour ce faire, entrez

 commande HERCFIX

à l'invite DOS, où la commande est la commande qui démarre l'application. Par exemple, supposons que vous utilisez la commande PEINTRE / H pour lancer un programme de peinture commerciale en mode graphique Hercules. Pour charger le programme de peinture avec HERCFIX, entrez la commande HERCFIX PEINTRE / H.


===PCXHEAD Utility===

L'utilitaire PCXHEAD affiche les informations les plus importantes de la
en-tête d'un fichier PCX. Cela comprend le numéro de version PCX, le nombre de bits par pixel, le nombre de plans de bits, la largeur de ligne de balayage, et la position des dimensions de l'image et de l'écran. Il propose également le mode vidéo optimal pour afficher le fichier PCX. Par optimal, on entend le mode vidéo compatible ayant la plus basse résolution est supérieure ou égale aux dimensions de l'image. Pour 256- images couleur PCX, PCXHEAD affiche la palette de couleurs étendue si l'on est présent.

La syntaxe de la commande pour appeler l'utilitaire PCXHEAD du DOS
invite de commande est

 PCXHEAD pcx_file

où pcx_file est le nom du fichier PCX à examiner. PCXHEAD ne modifie pas la pcx_file en aucune façon. Si le fichier PCX comprend une palette de couleurs étendue, vous pouvez préférer diriger la sortie PCXHEAD à un fichier en utilisant l'opérateur de redirection DOS (>). Guide de l'utilisateur 362 Fastgraph


==Utilisation de Fastgraph du Guide de l'Assemblée Langue==

Les informations contenues dans cette annexe fournit des informations sur l'appel
routines Fastgraph de programmes en langage assembleur. Il ne vise pas à être un tutoriel complet sur le sujet, mais il devrait fournir des programmeurs expérimentés en langage assembleur avec suffisamment de détails pour appeler routines Fastgraph dans leurs applications.

Fastgraph utilise la même dénomination et conventions d'appel basée sur la pile utilisée
par Borland, Microsoft et d'autres entreprises dans leur C et les compilateurs C de. Les détails de ces conventions importantes à la programmation en langage assembleur sont résumés ci-dessous. Si vous appelez routines Fastgraph d'un programme en langage assembleur, le programme doit suivre ces conventions.

* Tous les tableaux et les pointeurs sont passés par référence.
* Tous les autres éléments sont passés par valeur.
* Les arguments sont poussés sur la pile dans le sens inverse
               commande.
* Le programme appelant est responsable de l'enlèvement
              les arguments de la pile.
* Les valeurs de fonction 16 bits sont retournés dans l'AX
               registre.
* valeurs de fonction 32 bits sont retournés dans le DX: AX
              enregistrer paire dans des environnements 16 bits, ou l'EAX
              inscrivez-vous dans des environnements 32 bits.
* Les noms de routine Fastgraph sont préfixés par un
               souligner.

Les bibliothèques Fastgraph petites et moyennes modèle en mode réel passent des tableaux et des pointeurs par référence proche (un décalage dans DGROUP), tandis que le grand modèle et 16 bits des bibliothèques en mode protégé font par référence loin (un segment: paire offset: offset ou sélecteur) . Les bibliothèques protégées en mode 32 bits utilisent une architecture de modèle plat, ce qui signifie des tableaux et des pointeurs sont transmis sous forme de décalages 32 bits dans DGROUP. Ceci est cohérent avec les conventions et les bibliothèques d'exécution pour les compilateurs pris en charge.

Toutes les routines Fastgraph préserver la (E) BP, (E) DI, (E) SI, et DS
registres. Dans les 32 bits des bibliothèques en mode protégé, les EBX et ES registres sont également conservés. Le contenu de tous les autres registres sont inconnus lors du retour d'une routine Fastgraph (sauf pour le (E) registre AX, qui soit contenir zéro ou la valeur de retour de la routine).

Exemple B-1 appelle fg_getmode, fg_setmode, fg_reset et fg_version de
un programme en langage assembleur. La routine fg_getmode renvoie sa valeur de fonction dans le (E) registre AX. La routine de fg_setmode a un seul argument, alors que fg_reset n'a pas d'arguments. La routine de fg_version a deux arguments, à la fois passé par référence. Remarquez comment ils sont poussés sur la pile dans l'ordre inverse. Cet exemple est écrit pour le modèle de mémoire moyenne. Pour le faire fonctionner avec les grandes bibliothèques de modèles, ajouter 8 au lieu de 4 à la (E) registre de SP qui suit l'appel à fg_version (parce que les grands éléments de modèles passés par référence sont 32 bits des valeurs segmentées). Pour le faire fonctionner avec la petite bibliothèque de modèles, changer le mot «bien» à «proche» dans les déclarations de EXTRN, et changer le nom du segment de code de "main_TEXT" à "_TEXT".

Cet exemple est dans le fichier BB-01.ASM dans le répertoire \ FG \ EXEMPLES.  le
commandes suivantes montrent comment utiliser MASM ou TASM pour assembler ce programme et le lien avec le modèle moyen en mode réel bibliothèque Fastgraph.

 Microsoft Macro Assembler (MASM) Version 5:
         MASM BB-01.ASM;
         LINK / CP: 4096 BB-01, NUL, MGF;

 Microsoft Macro Assembler (MASM) la version 6:
         ML / c / Cx / Zm BB-01.ASM
         LINK / CP: 4096 BB-01, NUL, MGF;

 Turbo Assembler (TASM):
         TASM BB-01.ASM
         TLink BB-01.OBJ FGM.LIB

 Exemple B-1.

_fg_getmode EXTRN: loin; La routine de getMode de Fastgraph
               _fg_reset EXTRN: loin; la routine RESET de Fastgraph
               _fg_setmode EXTRN: loin; La routine de setMode de Fastgraph
               _fg_version EXTRN: loin; La routine VERSION de Fastgraph

 stackseg SEGMENT pile
               db 1024 dup (?); utiliser une pile 1K
     ENDS stackseg

 _DATA Mot SEGMENT 'DATA' publique
     dw majeur?  ; numéro de version majeure
     dw mineure?  ; numéro de version mineure
     old_mode dw?  ; mode vidéo d'origine
     ENDS _data

 dgroup GROUP _DATA
               ASSUMER cs: main_TEXT, ds: dgroup

 octet SEGMENT main_TEXT 'CODE' publique

commencer: mov ax, _DATA; Emplacement du segment de charge
               mov ds, ax; dans le registre DS

appeler _fg_getmode; AX = mode vidéo actuel
               mov old_mode, ax; sauvegarde le

mov ax, 4; utiliser le mode vidéo 4
               pousser la hache; passer l'argument fg_setmode
               appeler _fg_setmode; établir CGA mode quatre couleurs
               ajouter sp, 2; retirer argument fg_setmode

pousser old_mode; passer argument pour fg_setmode
               appeler _fg_setmode; rétablir le mode vidéo original
               ajouter sp, 2; retirer argument fg_setmode

appeler _fg_reset; restaurer les attributs d'écran

lea ax, mineur; obtenir l'adresse de la variable mineure
               pousser la hache; passer l'argument # 2 à fg_version
               lea ax, major; obtenir l'adresse de la variable majeure
               pousser la hache; passer l'argument n ° 1 à fg_version   

appeler _fg_version; obtenir le numéro de version Fastgraph
               ajouter sp, 4; supprimer des arguments fg_version

mov ah, 76; fonction 76: processus fin
               xor al, al; errorlevel 0
               int 21h; sortie sur DOS

 ENDS main_TEXT
               début END   


==Guide de Interruptions et Fastgraph==


===Utilisé par Fastgraph Les interruptions===

DOS maintient une table de vecteur d'interruption où il stocke les adresses des
256 gestionnaires d'interruption, ou des routines, qui exécutent diverses fonctions. Les gestionnaires sont généralement référencées par leur numéro d'interruption hexadécimal, entre 00 et FF. Parmi ceux-ci, seulement interrompt 60 à 66 et F1 par le biais de FF ne sont pas utilisés par le DOS, le BIOS ROM, ou un autre logiciel et sont donc disponibles pour les applications de l'utilisateur.

Certaines routines de Fastgraph utilisent certaines des interruptions disponibles.  Tout
routines Fastgraph / lumière utilisent interruption 62. En outre, le gestionnaire de clavier de bas niveau de Fastgraph remplace interruption 09. Si votre programme définit ses propres gestionnaires d'interruption, il ne faut pas utiliser des interruptions réservées aux Fastgraph (à moins, bien sûr, il n'utilise pas toutes les routines Fastgraph qui pourraient créer un conflit).


===L'extension du temps d'interruption de journée===

Comme indiqué au chapitre 16, l'horloge du BIOS heure du jour est incrémenté
un gestionnaire d'interruption. La routine qui fait cela est d'interruption 08, une interruption matérielle automatiquement activée 18,2 fois par seconde. Après incrémentation de l'horloge, interrompent 08 invoque interrompent 1C, qui par des références par défaut un gestionnaire "ne rien faire" interruption. En changeant d'interruption 08 peut être délicat, il est assez simple de définir notre propre gestionnaire pour 1C interruption. Ce gestionnaire sera également exécutée automatiquement 18.2 fois par seconde. Exemple C-1 illustre comment faire cela.

Lorsque nous avons discuté joysticks dans le chapitre 14, nous avons dit qu'il y avait deux façons de
surveiller joystick état de la touche. La première consiste à entremêler les appels à fg_button à des endroits stratégiques dans votre programme, puis prendre les mesures nécessaires en fonction de l'état du bouton. Cependant, le problème avec ce système est la possibilité de manquer une pression sur le bouton - si vous appuyez sur le bouton de la manette, puis relâchez entre les appels à fg_button, le programme ne sera pas détecter l'activité du joystick. Un procédé préférable consiste à appeler fg_button à partir d'un gestionnaire pour 1C interruption, qui prévoit essentiellement une surveillance continue des boutons du joystick. Lorsque nous avons besoin de l'état de bouton dans notre programme, tout ce que nous devons faire est examiner une variable globale.

 Exemple C-1 est constitué d'un programme principal (écrit en C) et un ensemble

sous-programme de langage appelé int1C (approprié pour le modèle de support de mémoire en mode réel). Le programme principal appelle int1C pour définir un gestionnaire pour 1C interruption. En réponse à une combinaison de touches (sauf Echap), le programme affiche les informations de presse de bouton pour chaque manette depuis la touche précédente (reportez-vous à la discussion de fg_button pour les significations des valeurs d'état). Lorsque vous appuyez sur la touche Echap, le programme sort de DOS, mais pas avant d'appeler int1C pour restaurer le gestionnaire d'origine d'interruption de 1C.

 Exemple C-1 (programme principal).

 #include <fastgraf.h>
               #include <stdio.h>
              void main (void);

 #define ESC 27   
                                  Annexe C: Interruptions et Fastgraph 369


 int status1, status2;

 void main ()
               {
                 unsigned clé de char, aux;

 int1C (1);

 status1 = 0;
                 status2 = 0;

 faire {
                     printf ( "\ n");
                    printf ( "Joystick 1 statut:% d \ n", status1);
                    printf ( "Joystick 2 Statut:% d \ n", status2);
                    status1 = 0;
                    status2 = 0;
                    fg_getkey (touche &, & aux);
                     }
                 while (key = ESC!);

 int1C (0);
               }


Nous allons maintenant examiner le sous-programme int1C en langage assembleur.  Il fait
se compose de trois parties: une partie pour permettre à notre gestionnaire d'interruption, notre gestionnaire lui-même, et une partie de désactiver le gestionnaire. Lorsque nous appelons int1C avec un argument non nul, il enregistre le segment de données d'origine (afin que nous puissions accéder aux variables globales au sein du gestionnaire), enregistre l'adresse du gestionnaire original (appelé le vecteur) pour 1C interruption, puis permet à notre gestionnaire, qui prend la forme d'une procédure beaucoup.

La routine de gestionnaire commence alors à être activés 18,2 fois par seconde.

Après avoir enregistré tous les registres importants, le gestionnaire appelle la routine fg_button Fastgraph deux fois, une fois pour chaque manette. Les valeurs de retour sont logiquement OU avec les STATUS 1 et status2 C variables globales pour mettre à jour les informations d'état du bouton. Enfin, le gestionnaire restaure les registres originaux et renvoie le contrôle au point de l'interruption.

Avant les sorties principales du programme, il appelle int1C avec un argument zéro à
restaurer le gestionnaire d'interruption d'origine pour 1C. Aucune disposition ne prévoit dans le programme pour vérifier si nous avions précédemment défini notre propre gestionnaire (et donc sauvé le 1C vecteur d'interruption d'origine), mais cela pourrait être ajouté avec peu de difficulté.

Exemple C-1 (langage d'assemblage sous-programme).

_status1 EXTRN: mot; C variable globale pour le bouton 1 état
          _status2 EXTRN: mot; C variable globale pour le bouton 2 état
          _fg_button EXTRN: loin; routine Fastgraph

octet SEGMENT int1C_TEXT 'CODE' publique

 ASSUMER cs: int1C_TEXT   

int1C_CS dw? ; détient d'origine INT 1C adresse de segment int1C_IP dw? ; détient INT d'origine 1C décalage orig_DS dw? ; détient le segment de données d'origine

_int1C PROC loin

 PUBLIC _int1C

pousser bp; sauvegarder le registre BP de l'appelant
          mov pb, sp; faire le point à la liste d'arguments BP
          si push; sauvegarder le registre SI de l'appelant
          di-poussoir; sauvegarder le registre DI de l'appelant

mov dx, [pb + 6]; obtenir le paramètre de drapeau
          ou dx dx; remplacer l'ancien gestionnaire d'interruption?
          jz remplacer; oui, branche pour que le traitement

définir un nouveau gestionnaire pour INT 1C

définir: mov ax, ds; mettre segment de données en cours dans AX

mov cs: orig_DS, ax; enregistrez-le dans la zone d'information de commande

mov al, 1Ch; vecteur d'interruption pour sauver
          mov ah, 53; fonction 53: obtenir vecteur d'interruption
          int 21h; obtenir le vecteur d'interruption
          mov cs: int1C_CS, es; enregistrer le segment
          mov cs: int1C_IP, bx; enregistrer le décalage

pousser ds; sauver notre registre DS
          mov dx, gestionnaire de décalage; obtenir décalage de gestionnaire d'interruption
          mov ax, gestionnaire seg; obtenir segment du gestionnaire d'interruption
          mov ds, ax; mettre dans DS
          mov al, 1Ch; vecteur d'interruption pour changer
          mov ah, 37; fonction 37: set vecteur d'interruption
          int 21h; changer le vecteur INT 1C à notre gestionnaire
          ds pop; restaurer notre registre DS

rendement à court jmp; retourner à l'appelant

remplacer le gestionnaire original pour INT 1C

remplacer: pousser ds; sauver notre registre DS

mov dx, cs: int1C_IP; mettre offset DX originale 1C INT
          ds mov, cs: int1C_CS; mettre segment original INT 1C DS
          mov ah, 37; fonction 37: set vecteur d'interruption
          mov al, 1Ch; interruption vecteur 1C
          int 21h; restauration originale vecteur INT 1C
          ds pop; restaurer notre registre DS

retour: xor ax, ax; en cas int1C a été appelé en fonction

di pop; restaurer notre registre DI
          si pop; restaurer notre registre SI
          pop pb; restaurer notre registre BP
           ret

_int1C ENDP


gestionnaire PROC loin; le gestionnaire d'interruption qui remplace INT 1C

cli; interruptions désactiver tout gestionnaire actif
          pousser la hache; sauvegarder les registres qui peuvent être modifiés
          poussoir bx
          poussoir cx
          poussoir dx
          poussoir di
          poussoir si
          pousser ds
          pousser es

ds mov, cs: orig_DS; récupérer le segment de données d'origine

mov ax, 1; utilisation joystick 1
          pousser la hache; transmettre le numéro de manette pour le bouton de routine
          appeler _fg_button; AX = état de la touche pour joystick 1
          ajouter sp, 2; supprimer l'argument
          ou _status1, ax; mise à jour variable d'état pour joystick 1

mov ax, 2; utilisation joystick 2
          pousser la hache; transmettre le numéro de manette pour le bouton de routine
          appeler _fg_button; AX = état de la touche pour joystick 2
          ajouter sp, 2; supprimer l'argument
          ou _status2, ax; mise à jour variable d'état pour joystick 2

es pop; restaurer les registres modifiés
          ds pop
          pop si
          pop di
          pop dx
          pop cx
          pop bx
          pop ax
          iret; retour de la routine d'interruption

gestionnaire ENDP

ENDS int1C_TEXT

  FIN

L'exemple vient d'être présenté ne vise pas à être un tutoriel sur les interruptions;

il y a beaucoup de bonnes références sur DOS qui les expliquent en détail. Cependant, un exemple spécifique à Fastgraph devrait être utile. Guide de l'utilisateur 372 Fastgraph


==Contenu du compilateur spécifique Bibliothèques Guide de==

Pour la plupart des compilateurs, Fastgraph fournit une bibliothèque spécifique au compilateur (également
appelé la bibliothèque Fastgraph auxiliaire) qui contient les routines suivantes:

 fg_boxw fg_drawxw fg_panw fg_setsize
    fg_boxxw fg_drectw fg_pointw fg_setsizew
    fg_circlew fg_ellipsew fg_pointxw fg_setworld
    fg_circlefw fg_ellipsfw fg_polygonw fg_swchar
    fg_clprectw fg_floodw fg_rectw fg_swlength
    fg_dashrw fg_getworld fg_restorew fg_swtext
    fg_dashw fg_initw fg_savew fg_xscreen
    fg_drawrw fg_moverw fg_setangle fg_xworld
    fg_drawrxw fg_movew fg_setclipw fg_yscreen
    fg_draww fg_paintw fg_setratio fg_yworld

Ces routines utilisent l'espace de système de coordonnées, soit directement, soit en interne. Aucun d'entre eux sont inclus dans Fastgraph / Lumière.

Comme mentionné dans le chapitre 1, si votre programme utilise l'une de ces routines,
vous devez lier avec la bibliothèque générale Fastgraph et la bibliothèque Fastgraph auxiliaire correspondant. Certains compilateurs, tels que Microsoft Visual C ++ 32- bit Edition, Microsoft FORTRAN PowerStation et compilateurs BASIC pris en charge de Fastgraph ne nécessitent pas une bibliothèque auxiliaire parce que les routines énumérées ci-dessus sont inclus directement dans la bibliothèque Fastgraph pour les compilateurs.


==Contenu du Guide de l'Fichiers Pascal Unit==


Borland Pascal et Turbo Pascal limitent la taille totale de l'ensemble du code
segments dans une unité fichier 65,520 octets. Parce que la taille du code de Fastgraph dépasse ce montant, les fonctions Fastgraph sont répartis entre plusieurs fichiers unité. Cette annexe énumère le contenu de chaque fichier unité Pascal.
des routines de Fastgraph dans FGBITMAP

 fg_clipmap fg_flpimage fg_pack fg_scale
    fg_clipmask fg_getblock fg_print fg_shear
    fg_clpimage fg_getimage fg_printc fg_text
    fg_drawmap fg_getmap fg_putblock fg_textc
    fg_drawmask fg_imagebuf fg_putimage fg_unpack
    fg_drwimage fg_imagesiz fg_revimage
    fg_flipmask fg_invert fg_revmask

des routines de Fastgraph dans FGFLIC

 fg_flicdone fg_flicmode fg_flicplay fg_flicskip
    fg_flichead fg_flicopen fg_flicsize fg_showflic

des routines de Fastgraph dans FGGIF

 fg_gifhead fg_gifpal fg_makegif fg_showgif
    fg_gifmode fg_gifrange

des routines de Fastgraph dans FGMISC

 fg_button fg_kbinit fg_mousemov fg_setcaps
    fg_capslock fg_kblast fg_mousepos fg_setnum
    fg_cursor fg_kbreset fg_mouseptr fg_sound
    fg_getclock fg_kbtest fg_mousespd fg_sounds
    fg_getkey fg_measure fg_mousevis fg_suspend
    fg_getxjoy fg_memavail fg_music fg_voice
    fg_getyjoy fg_mouse256 fg_musicb fg_voices
    fg_hush fg_mousebut fg_numlock fg_waitfor
    fg_hushnext fg_mousecur fg_playing fg_waitkey
    fg_initjoy fg_mousefin fg_quiet
    fg_intjoy fg_mouseini fg_resume
    fg_intkey fg_mouselim fg_scrlock

des routines de Fastgraph dans FGPCX

 fg_loadpcx fg_pcxhead fg_pcxpal fg_showpcx
    fg_makepcx fg_pcxmode fg_pcxrange

des routines de Fastgraph dans FGPR

 fg_dispfile fg_displayp fg_makespr fg_showspr
    fg_display fg_makeppr fg_showppr

des routines de Fastgraph dans FGSVGA

 fg_defpages fg_memory fg_svgainit fg_svgaver
    fg_getbanks fg_setbanks fg_svgastat

des routines de Fastgraph dans FGVB

 fg_vbaddr fg_vbcut fg_vbinit fg_vbundef
    fg_vballoc fg_vbdefine fg_vbopen
    fg_vbclose fg_vbfree fg_vbpaste
    fg_vbcopy fg_vbhandle fg_vbtcxfer   


Les routines spatiales mondiales énumérées à l'annexe D sont dans l'unité de FGWORLD. Toute autre routine Fastgraph ne figure pas dans cette annexe se trouve dans l'unité de FGMAIN.

Comme mentionné dans le chapitre 1, les programmes Pascal doivent inclure une déclaration des utilisations énumérant toutes les unités référencées dans le programme. L'unité de fgmain est toujours nécessaire dans tous les programmes, est l'unité WinAPI dans les programmes protégés en mode 16 bits. D'autres fichiers unitaires sont nécessaires lorsque vous appelez les routines Fastgraph qu'ils contiennent. Guide de l'utilisateur 378 Fastgraph


==Intégration Fastgraph Avec Autres Graphics Software==

Parfois, vous voudrez peut-être utiliser Fastgraph avec d'autres logiciels graphiques,
tels que lors de la conversion d'une application graphique existante à Fastgraph. Cette annexe peut éclaircir certains points à faire cela.

Tout d'abord, laissez les autres logiciels graphiques établir le mode vidéo, puis
initialiser Fastgraph pour ce mode en appelant fg_setmode (-1). Passant -1 à fg_setmode ne change pas physiquement modes vidéo, mais initialise simplement les paramètres internes de Fastgraph pour le mode vidéo actuel.

Deuxièmement, si vous utilisez les modes EGA / VGA / SVGA 16 couleurs graphiques (modes
13 à 18, 28 et 29), vous aurez probablement besoin de définir explicitement la valeur de l'EGA / VGA Activer Set / Reset registre (adresse de port 03CE hex, index 01). Les fonctions de Fastgraph attendre ce registre pour avoir la valeur hexadécimale de 0F; cela permet Fastgraph profiter d'une variante plus efficace disponible en EGA / VGA mode d'écriture 0. La valeur par défaut pour l'option Activer Set / Reset registre est égal à zéro.

Une fois que vous avez appelé fg_setmode (-1) et besoin d'appeler un tiers
fonction graphique, réglez l'option Activer Set / Reset registre à sa valeur par défaut en incluant la déclaration suivante juste avant d'appeler la fonction de tiers:
outport (0x03CE, 0x0001); Borland C ++, Turbo C / C ++, ou Power C outpw (0x03CE, 0x0001); Microsoft C / C ++, QuickC, WATCOM C / C ++ OUT & h03CE, 1: OUT & h03CF, 0 QuickBASIC, BASIC PDS, ou Visual Basic

Juste avant d'appeler la fonction suivante Fastgraph, restaurer la Set / valeur du registre de réinitialisation avec l'énoncé suivant Activer:
outport (0x03CE, 0x0F01); Borland C ++, Turbo C / C ++, ou Power C outpw (0x03CE, 0x0F01); Microsoft C / C ++, QuickC, WATCOM C / C ++ OUT & h03CE, 1: OUT & h03CF, 15 QuickBASIC, BASIC PDS, ou Visual Basic


==Conversion de programmes au Guide de mode protégé==


Dans cette annexe, nous allons décrire les étapes nécessaires pour le portage en mode réel
applications Fastgraph en mode protégé. Nous allons aussi couvrir les changements communs nécessaires lors de la conversion des applications 16 bits en mode protégé 32 bits.


===Mode protégé Initialisation===

La première et la plus évidente étape lors de la conversion des programmes visant à protéger
le mode est d'appeler fg_initpm. Cette routine met en place des fonctionnalités du mode protégé pour chaque extension DOS pris en charge et doivent être appelées avant toute autre routine Fastgraph dans les programmes en mode protégé. Le non-respect cela se traduira par un défaut de protection, généralement immédiatement après le réglage du mode vidéo. La routine de fg_initpm n'a pas d'arguments et aucune valeur de retour. Il est inclus dans les bibliothèques de support spécifiques à extension (par exemple, dans FG16DPMI.LIB) si Fastgraph prend en charge plus d'une extension DOS pour un compilateur donné.


===Considérations pour les pages logiques===

En mode réel, Fastgraph vous permet de créer des pages logiques classiques
la mémoire (avec fg_alloccms), mémoire étendue (avec fg_allocems), ou mémoire étendue (avec fg_allocxms). En mode protégé, la distinction entre la mémoire conventionnelle, élargi et étendu disparaît parce que DOS extenders essentiellement traiter toute la mémoire système comme mémoire conventionnelle. Pour cette raison, les fg_initems et fg_initxms routines ne sont pas significatifs et donc toujours revenir -1 en mode protégé bibliothèques Fastgraph. Cela désactive efficacement les fg_allocems et fg_allocxms routines, vous devez donc créer des pages logiques avec fg_alloccms en mode protégé.

Si vous avez de réelles applications Fastgraph de mode qui utilisent des pages logiques, il est
très simple pour les convertir en mode protégé - il suffit de changer tous les fg_allocems et fg_allocxms appels à fg_alloccms.


===Considérations pour Tampons Virtuels===

Le chapitre 8 décrit les différentes méthodes disponibles pour l'allocation de mémoire
pour les tampons virtuels. Parce que certains compilateurs en mode réel ont un soutien pour d'énormes réseaux limités (blocs de mémoire supérieure à 64K octets), fg_vballoc et fg_vbfree les routines de Fastgraph sont prévus pour allouer et libérer la mémoire appropriée pour les tampons virtuels. Tous les compilateurs en mode protégé fournissent un support complet pour les tableaux énormes, de sorte que ces deux fonctions ne sont pas nécessaires (en fait, ils ne sont pas encore inclus dans les bibliothèques en mode protégé). Ainsi, vous devez remplacer les fg_vballoc et fg_vbfree appels avec les fonctions correspondantes de gestion de la mémoire de votre compilateur comme indiqué dans le chapitre 8 et utiliser fg_vbdefine pour créer le tampon virtuel.


===Curseur de la souris Définition===

La routine fg_mouseptr attend l'écran et curseur masques de résider dans
un réseau de 32 éléments de valeurs 16 bits. Si vous convertissez un C ou d'une application C ++ Fastgraph à partir d'un 16 bits à un environnement 32 bits, vous devez modifier le type du tableau de masque écran / curseur est passé à fg_mouseptr de int à court données.
les programmeurs FORTRAN devraient être sûr de passer un INTEGER * 2 tableau au lieu d'un tableau de INTEGER ordinaire.


===Types de données FORTRAN===

Lors de la conversion des programmes FORTRAN en mode protégé 32 bits, tout ENTIER * 2
quantités passés aux fonctions Fastgraph doivent être modifiés pour des entiers sur quatre octets. Pour une portabilité maximale, nous vous recommandons de les changer de type integer, ce qui équivaut à ENTIER * 2 dans les environnements 16 bits et équivalent à INTEGER * 4 dans des environnements 32 bits.


===Incompatible comportement du mode réel===

Après avoir ajouté l'appel fg_initpm et fait les autres changements
décrit jusqu'à présent, vous devez tester votre programme pour voir si elle fonctionne en mode protégé. La plupart des programmes linguistiques de haut niveau travailleront à ce point avec aucun autre changement requis.

Cependant, certains programmes comprennent des fonctionnalités qui sont acceptables en mode réel
mais pas en mode protégé (souvent ce comportement est involontaire). Ces pratiques comprennent le chargement des adresses physiques dans les registres de segment, en utilisant des adresses de segments physiques pointeurs loin, écriture de données sur un segment de code, le référencement des arguments de ligne de commande non précisés, l'accès à la mémoire au-delà de la limite d'un segment, et le déréférencement des pointeurs nuls. Quand un programme en mode protégé rencontre l'un de ces problèmes lors de l'exécution, il sort pour DOS avec une erreur de protection générale ou GPF.

La documentation livrée avec votre extension DOS fournira probablement
informations sur l'isolement des erreurs de protection et d'offrir des suggestions sur la façon de les corriger. Deux autres références, extension DOS édité par Ray Duncan (Addison- Wesley, 1992) et DOS et mode protégé de Windows par Al Williams (Addison- Wesley, 1993) sont des ressources précieuses pour la programmation en mode protégé. Les deux livres comprennent des informations détaillées sur les différences entre le mode réel et en mode protégé et discuter des problèmes et des solutions communes protégées de programmation de mode. Guide de l'utilisateur 384 Fastgraph


==Guide de fichier image en-tête Formats==

images PCX, GIF et FLI / FLC incluent les en-têtes de fichiers qui définissent l'image
taille, le nombre de couleurs, et d'autres informations nécessaires pour afficher l'image. Fastgraph fournit des routines pour lire les en-têtes d'image et de récupérer leurs éléments les plus utiles. Cependant, il peut y avoir des moments où vous avez besoin d'informations supplémentaires stockées dans l'en-tête du fichier. Cette annexe fournit des détails complets sur la structure du PCX, GIF, et en-têtes de fichier flic. Dans les tableaux qui suivent, nous supposerons que tous les décalages commencent à zéro, toutes les tailles de champ sont en octets, et toutes les valeurs entières sont stockées avec l'octet le moins significatif en premier.

fichiers PCX commencent par un en-tête de 128 octets:

 décalage taille description

 0 1 octet du fabricant, doit être de 10 décimales
       1 1 PCX numéro de version
                     0 = PC Paintbrush version 2.5
                     2 = PC Paintbrush 2.8 avec des informations de la palette
                     3 = PC Paintbrush 2.8 sans information de la palette
                     4 = PC Paintbrush pour Windows
                     5 = PC Paintbrush 3.0 ou version ultérieure, PC Paintbrush plus
       2 1 run octet longueur de codage, doit être 1
       3 1 nombre de bits par pixel par plan de bits
       4 8 limites de l'image en pixels: Xmin, Ymin, Xmax, Ymax
      12 2 points horizontaux par pouce lorsque imprimés (peu fiable)
      14 2 points verticaux par pouce lorsque imprimés (peu fiable)
      16 48 palette de 16 couleurs (16 RGB triple entre 0-255)
      64 1 réservé, doit être nul
      65 1 nombre de plans de bits
      66 2 mémoire vidéo octets par image rangée
      68 2 16 palette de couleurs interprétation (peu fiable)
                     0 = couleur ou b & w, 1 = niveaux de gris
      70 2 résolution horizontale de l'écran - 1 (peu fiable)
      72 2 résolution verticale de l'écran - 1 (peu fiable)
      74 54 réservé, doit être nul

Les fichiers GIF commencent par un en-tête global de 13 octets et un en-tête locale de 10 octets:

 décalage taille description

 0 6 GIF signature, doit être GIF87a ou GIF89a
       6 2 résolution horizontale de la création de mode vidéo (non fiable)
       8 2 résolution verticale de la création mode vidéo (non fiable)
      10 1 octet indicateur global
                     bit 7 est défini si la carte de couleur globale est présent
                     les bits 0-3 sont le nombre de couleurs (2 ** (n + 1)),
      couleur 11 1 fond
      12 1 pour GIF87a, doit être nul
                   pour GIF89a, rapport d'aspect
      13 0 réservé, doit être 44 décimal (ASCII virgule)
      14 2 bord gauche de l'image en pixels
      16 2 bord supérieur de l'image en pixels
      18 2 Largeur de l'image en pixels
      hauteur 20 2 image en pixels
      22 1 octet de drapeau locale
                     bit 7 est défini si la carte de la couleur locale est présente   
                                 Annexe H: Image File Formats d'en-tête 387


 bit 6 est réglé si l'image est entrelacée
                     les bits 0-3 sont le nombre de couleurs (2 ** (n + 1)),


Les fichiers FLI et FLC commencent par un en-tête de 128 octets:

 décalage taille description

 taille 0 4 du fichier en octets
       4 2 signature, AF11 hex pour les fichiers FLI, AF12 hex pour les fichiers FLC
       6 2 nombre d'images
       8 2 Largeur de l'image en pixels
      hauteur 10 2 image en pixels
      12 2 bits par pixel, doit être 8
      14 2 réservé, doit être 3
      retard 16 4 temps entre les images
                     unités sont 1/70 seconde pour les fichiers FLI
                     unités sont millisecondes pour les fichiers FLC
      20 2 réservé, doit être nul
      22 4 fichier création date / heure (format MS-DOS)
      le numéro de série 26 4 créateur (non fiable)
      30 4 révision du fichier de date / heure (format MS-DOS)
      le numéro de série 34 4 updater (peu fiable)
      38 4 horizontal rapport d'aspect de la création de mode vidéo
      40 2 vertical rapport d'aspect de la création de mode vidéo
      42 38 réservé, doit être nul
      80 4 octets de décalage au début de la première image
      84 4 octets de décalage au début de la seconde trame
      88 40 réservé, doit être nul

Les champs à partir du décalage 22 et ci-dessus dans l'en-tête de fichier flac appliquent aux fichiers FLC seulement. Pour les fichiers FLI, ils devraient tous être zéro. Guide de l'utilisateur 388 Fastgraph