• S'inscrire
  • Affichage des résultats 1 à 2 sur 2

    Discussion: slt

    1. #1
      rastajah
      Guest

      Par défaut slt

      j'ai un blem sur les graphismes en pascal car ca veu po s'initialiser g besoin d'iade et aussi j veu un cours d'algorithmiques sur les filles d'attentes,les piles let a derecursiviter ou b1 un lien de cela.merci d'avence.

    2. #2
      x_octet
      Guest

      Par défaut

      un cour de d'algorithmiques

      http://www-ipst.u-strasbg.fr/pat/program/pascal.htm

      //-----------------------------------------------------------------------------------//
      Les graphismes en Turbo Pascal
      Turbo Pascal n'est pas limité au seul affichage de texte. Il peut également utiliser des fonctions graphiques qui lui permettent de réaliser des dessins plus ou moins sophistiqués.
      La totalité de ces fonctions sont situées dans l'unité graph.
      Initialisation
      Avant toute utilisation des fonctions graphiques, il faut initaliser le système avec l'instruction InitGraph. La syntaxe est la suivante :

      InitGraph(Pilote, Mode, Chemin);

      * Pilote représente le pilote graphique de la machine
      * Mode correspond au mode graphique
      * Chemin est l'emplacement du répertoire BGI sur votre machine

      Les 2 premiers arguments doivent être des variables. Les valeurs que peut prendre Pilote sont les suivantes :



      Detect permet de réaliser une auto-détéction (voir plus loin).
      Pour les modes graphique, ce peut être une des valeurs suivantes :



      Le mode utilisé doit correspondre au pilote utilisé (logique), sauf si vous utiliser l'auto-détéction (voir plus loin).
      Voici un exemple :

      Uses Graph;
      VarPilote : Integer;{Variable pour le pilote}
      Mode : Integer;{Variable pour le mode}
      begin
      Pilote := VGA;
      Mode := VGAHi;
      InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
      CloseGraph;
      end.

      Vous remarquez que l'on a utiliser l'instruction CloseGraph. CloseGraph doit être appelé à chaque fois en fin de programme. Il désactive le mode graphique et permet de libérer les divers secteur de mémoire occupés par les méthodes graphques.
      Pour réaliser une auto-détection, il suffit d'utiliser Detect pour le pilote. La variable Mode n'a plus besoin d'être initialisée :

      Code:
       Uses Graph;
          VarPilote : Integer;
          Mode : Integer;
          begin
          Pilote := Detect;
          InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
          CloseGraph;
          end.
      Dessiner
      Après avoir initialisé le système, il devient enfin possible d'utiliser les fonctions graphiques.
      Les fonctions regroupées dans le tableau ci-dessous sont celles permettant de tracer des formes quelconques à l'écran.
      Code:
      Fonctions de dessin Fonction 	Description
      Arc 	Dessine un arc de cercle à l'écran.
      X et Y representent le centre de l'arc, AngleDeb est l'angle de départ de l'arc, AngleFin celui de fin et Rayon le rayon de l'arc.
      Les angles sont exprimés en degrès.
      Syntaxe :
      
          Arc(X, Y: Integer; AngleDeb, AngleFin, Rayon: Word);
      
      Bar 	Dessine un rectangle plein.
      x1 et y1 represente le coin supérieur gauche et x2 et y2 le coin inférieur droit.
      La couleur et le style de remplissage est défini par SetFillStyle ou SetFillPattern (voir plus loin).
      Syntaxe :
      
          Bar(x1, y1, x2, y2: Integer);
      
      Bar3D 	Réalise la même chose que Bar, mais en 3D.
      Profond represente la taille en pixel du contour.
      Les valeurs possible pour Top sont les constantes TopOn (true) et TopOff (false).
      Si Top vaut TopOn, alors une face supérieure est dessinée.
      Syntaxe :
      
          Bar3D(x1, y1, x2, y2: Integer; Profond: Word; Top: Boolean);
      
      Circle 	Dessine un cercle de centre X et Y, et de rayon Rayon.
      Syntaxe :
      
          Circle(X, Y: Integer; Rayon: Word);
      
      DrawPoly 	Dessine un polygone vide de NbPoints sommets.
      Les coordonnées de ces sommets sont définis dans la variable PolyPoints du type PointType.
      Syntaxe :
      
          DrawPoly(NbPoints: Word; var PolyPoints);
      
      Exemple :
      
          Uses Graph;
          ConstFrance : array[1..9] of PointType = ((X:0; Y:20),
          (X:100; Y:0), (X:200; Y:20), (X:150; Y:150),
          (X:200; Y:280), (X:100; Y:300),(X:0; Y:280),
          (X:50; Y:50), (X:0; Y:20));
          VarPilote : Integer;
          Mode : Integer;
          begin
          Pilote := Detect;
          InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
          DrawPoly(SizeOf(France) div SizeOf(PointType), France);
          CloseGraph;
          end.
      
      Ellipse 	Dessine une ellipse de centre X et Y.
      AngleDeb et AngleFin representent les angles de début et de fin, en degrès.
      XRayon et YRayon representent la distance entre le centre et la tangente verticale et la tangente horizontale.
      Syntaxe :
      
          Ellipse(X, Y: Integer; AngleDeb, AngleFin: Word; XRayon, YRayon: Word);
      
      FillEllipse 	Réalise la même chose que Ellipse, mais remplit la forme.
      Il n'y a donc pas d'angles de départ et de fin.
      Syntaxe :
      
          FillEllipse(X, Y: Integer; XRayon, YRayon: Word);
      
      FillPoly 	Réalise la même chose que DrawPoly, mais remplit le polygone.
      Syntaxe :
      
          FillPoly(NbPoints: Word; var PointsPoly);
      
      Line 	Trace une ligne du point x1 et y1 au point x2 et y2.
      Syntaxe :
      
          Line(x1, y1, x2, y2: Integer);
      
      LineRel 	Trace à une ligne à partir de la position du curseur graphique (voir plus loin).
      Dx et Dy represente la distance sur X et sur Y à parcourir à partir de la position du curseur graphique.
      Syntaxe :
      
          LineRel(Dx, Dy: Integer);
      
      LineTo 	Trace à une ligne à partir de la position du curseur graphique, jusqu'au point de coordonnées X et Y.
      Syntaxe :
      
          LineTo(X, Y: Integer);
      
      MoveRel 	Déplace le curseur graphique de Dx pixels sur l'axe des X et de Dy pixels sur l'axe des Y.
      Syntaxe :
      
          MoveRel(Dx, Dy: Integer);
      
      MoveTo 	Déplace le curseur graphique à la positon X et Y.
      Syntaxe :
      
          MoveTo(X, Y: Integer);
      
      PieSlice 	Réalise la même chose que Arc, mais remplit la forme.
      Syntaxe :
      
          PieSlice(X, Y: Integer; AngleDeb, AngleFin, Rayon: Word);
      
      PutPixel 	Dessine un point au coordonnées X et Y de couleur Pixel.
      Syntaxe :
      
          PutPixel(X, Y: Integer; Pixel: Word);
      
      Rectangle 	Trace un rectangle du coin supérieur gauche de coordonnées x1 et y1, au coin inférieur droit de coordonnées x2 et y2.
      Syntaxe :
      
          Rectangle(x1, y1, x2, y2: Integer);
      
      Sector 	Réalise la même chose que Ellipse, mais remplit la forme. Contrairement à FillEllipse, il est possible de spécifier un angle.
      Syntaxe :
      
          Sector(x, y: Integer; AngleDeb, AngleFin, XRayon, YRayon: Word);
      exemple, pour tracer un cercle rouge, on écrira :

      Code:
       Uses Graph;
          VarPilote : Integer;
          Mode : Integer;
          begin
          Pilote := Detect;
          InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
          SetColor(Red);{Premier plan rouge}
          Circle(50, 50, 50);
          CloseGraph;
          end.
      Il est également possible de définir une couleur de fond avec SetBkColor :

      Code:
       Uses Graph;
          VarPilote : Integer;
          Mode : Integer;
          begin
          Pilote := Detect;
          InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
          SetColor(Red);{Premier plan rouge}
          SetBkColor(LightGreen);{Arrière plan vert-pale}
          Circle(50, 50, 50);
          CloseGraph;
          end.
      Par exemple, pour tracer un rectangle bleu clair en ecailles de poisson, on écrira :

      Code:
       Uses Graph;
          VarPilote : Integer;
          Mode : Integer;
          begin
          Pilote := Detect;
          InitGraph(Pilote, Mode, 'c:\outils\tp\bgi');
          SetFillStyle(InterLeaveFill, LightBLue);
          Bar(0, 0, 300, 100);
          CloseGraph;
          end.
      Obtenir les états
      Pour programmer plus facilement, le Turbo Pascal dispose de plusieurs fonctions permettant au programmeur de connaitre les états de plusieurs parametres. Voici ces fonctions :
      Code:
      Fonction 	Description
      GetArcCoords 	Modifie la variable ArcCoords du type ArcCoordsType transmise en argument avec les coordonnées transmises à Arc lors de son dernier appel.
      Voici le type ArcCoordsType :
      
          ArcCoordsType = RECORD
            X, Y,
            Xstart, Ystart,
            Xend, Yend : INTEGER;
          END;
      
      GetBkColor 	Renvoi l'index de la couleur de fond d'écran utilisée.
      GetColor 	Renvoi l'index de la couleur de premier plan utilisée.
      GetDriverName 	Renvoi une chaîne de caractères renvoyant le nom du pilote graphique utilisé.
      GetFillPattern 	Modifie la variable FillPattern transmise en argument avec le motif de remplissage defini par l'utilisateur avec SetFillPattern.
      GetFillSettings 	Modifie la variable FillInfo transmise en argument avec les informations de remplissage courant.
      Voici le type FillSettingsType :
      
          FillSettingsType = RECORD
            Pattern : WORD;
            Color   : WORD;
          END;
      
      GetGraphMode 	Renvoi l'index du mode graphique utilisé.
      GetLineSettings 	Modifie la variable LineInfo transmise en arguments avec les informations de style de ligne courant.
      GetMaxColor 	Renvoi l'index de la couleur la plus haute pouvant être utilisé.
      GetMaxMode 	Renvoi l'index du mode graphique le plus haut pouvant être utilisé avec le pilote courant.
      GetMaxX 	Renvoi le numéro de la colonne le plus à droite (autrement dit, la largeur de l'écran).
      GetMaxY 	Renvoi le numéro de la ligne la plus basse (autrement dit, la hauteur de l'écran).
      GetModeName 	Renvoi une chaîne de caractère représentant le nom du mode graphique correspondant à l'index transmis en argument.
      GetModeRange 	Modifie les variables ModeInf et ModeSup transmises en argument avec respectivement le plus petit et le plus grand index utilisables par le pilote spécifié comme mode graphique.
      Syntaxe :
      
          GetModeRange(PiloteGraph: Integer; var ModeInf, ModeSup:Integer);
      
      GetPixel 	Renvoi la couleur du pixel situé aux coordonnées X et Y.
      Syntaxe :
      
          GetPixel(X, Y: Integer): Word;
      
      GetX 	Renvoi la position X du curseur graphique
      GetY 	Renvoi la position Y du curseur graphique
      :KKDS

      Enjoy

    Règles de messages

    • You may not post new threads
    • You may not post replies
    • You may not post attachments
    • You may not edit your posts
    •  

    Forum Ti9ni n'est responsable d'aucun accord commercial ou coopératif entre les membres
    Chaque personne assume la responsabilité de la direction de la vente, l'achat, l'accord et l'information de sa position
    Les commentaires publiés ne représentent pas l'opinion de Forum Ti9ni et nous n'en assumons aucune responsabilité (et l'auteur est responsable de la publication)
    Buffer Digg Email Facebook Google LinkedIn Pinterest Print Reddit StumbleUpon Tumblr Twitter VK Yummly