Découpeur d'images

Vous débutez et vous avez besoin d'aide ? N'hésitez pas à poser vos questions
Répondre
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

TazNormand a écrit :@Dayvid :
1° je suis d'accord avec Atlante, ton algo n'est pas bon, car tu es dans l'optique que l'image est un cercle, mais imagines un peu si l'image était un I majuscule avec le point :

Code : Tout sélectionner

  #

#####
  #
  #
  #
  #
#####
tu te retrouves avec 2 images, voire tu tronques le corps du "i" puisque ton algo s'est focalisé sur le point !!!

2° Je te rappelle que Atlante est modo du forum, même si cela ne lui donne pas tous les droits, il a raison sur un point : tourne 7 fois ta langue dans ta bouche avant de "poster", évite de mettre des messages qui ont l'air de questions ou de sollicitations de membres.


@ Atlante : A la décharge de Dayvid, il a au moins le mérite de proposer un "challenge" intéressant sur le forum, ne lui en veut pas trop de poster à tout va, je suis sur qu'il va s'auto-modérer, hein Dayvid ?
Exacte Taz, mais là dans ce cas de figure j'igniore comment faire autrement !
Déjà c'est pas mal je trouve :)

Tu ferais comment toi, dis-moi :)

Je sais que atland est modo mais franchement je suis ennuyé par certaine de ces réponses :oops:
Il est agressif je trouve envers moi :(

Je me modère déjà le plus possible et dite pas le contraire hein :wink:
Je fais de mon mieux pour ne pas m'emporter !

Atland je te demande d'être moins agressif, tu me mets en colère avec t'es réponse là
Je sais que tu es modo mais reste cool ok, je fais de mon mieux :)

Bon sinon pour cet algo, malgré le schéma, je sais pas comment faire :?
Je préfère ne rien tenter pour le moment histoire de pas me lancer dans un truc trop gros pour moi :wink:
C'est quand même un truc de ouf et je vais faire une petite remarque:

Au début ce n'étais qu'une question simple :wink:
Puis le bon Taz ma donner les procédures à suivre, trouvent cella pas trop compliquer, j'ai décidé d'essayer pour voir si j'y arriverais et j'y suis arriver :o

Mais là c'est quand même du haut niveau je trouve, je suis même carrément étonner d'avoir réussi cella tous seule 8O
Chui t’être pas aussi con que ça après tous hein ! :mrgreen:

Mais là, je le sens pas cette histoire d'image, je ne sais pas, je le sens pas, je me casse la tête à essayer de trouver une solution parce que c'est ce qu'il faut faire, essayer de se faire des procédures dans sa tête puis ensuite de l'écrire et de faire même un schéma comme je l'es fait, c'est pas facile à faire !

Bon et puis j'vais pas tous me taper non plus hein, on est sur un forum ici ou pas :?

"Arrête de demander tous le temps" Mais je te ferais dire que (je pense) on ne me donne pas tous ce que je demande ici et je ne fais pas que demander
je cherche aussi fugure toi :wink:

Et puis on est sur un forum, forum veut dire aussi échange et pas "ferme ta g.... et fait ta m.... tous seule"
Je partage ce que je fais comme les copains aussi mais c'est bien aussi pour les idées ! :wink:

Regarde je corrige aussi un maximum mes fautes, vous l’avez vus ça quand même non ?! :|
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
Avatar de l’utilisateur
TazNormand
Messages : 1297
Inscription : ven. 27/oct./2006 12:19
Localisation : Calvados (14)

Re: Découpeur d'images

Message par TazNormand »

Dayvid, un Forum c'est un lieu d'échange et d'entraide, et quand tu dis :
Bon et puis j'vais pas tous me taper non plus hein, on est sur un forum ici ou pas :?
forcément ça énerve les membres : tu as besoin d'un programme pour découper tes images, OK, mais sois tu cherches sur le Net un soft déjà existant, sois tu te le fais toi-même, mais on va pas faire ton boulot, on a tous des trucs à faire.

Tu m'as demandé de l'aide en MP, je ne t'ai pas répondu, certes, mais je pense que je t'aide comme beaucoup d'autres dans tes nombreux différents topics.

Si tu n'as pas toutes les réponses à tes questions, et bien on y peut rien, et tanpis si ton programme ne répond qu'à 90% de tes besoins, 90% c'est mieux que 10%.

EDIT : essaies de ne pas écorcher les pseudos des membres : c'est Atlante, pas Atland
Me concernant, tu peux dire Taz, pas de soucis :)
Image
Image
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

TazNormand a écrit :Dayvid, un Forum c'est un lieu d'échange et d'entraide, et quand tu dis :
Bon et puis j'vais pas tous me taper non plus hein, on est sur un forum ici ou pas :?
forcément ça énerve les membres : tu as besoin d'un programme pour découper tes images, OK, mais sois tu cherches sur le Net un soft déjà existant, sois tu te le fais toi-même, mais on va pas faire ton boulot, on a tous des trucs à faire.

Tu m'as demandé de l'aide en MP, je ne t'ai pas répondu, certes, mais je pense que je t'aide comme beaucoup d'autres dans tes nombreux différents topics.

Si tu n'as pas toutes les réponses à tes questions, et bien on y peut rien, et tanpis si ton programme ne répond qu'à 90% de tes besoins, 90% c'est mieux que 10%.

EDIT : essaies de ne pas écorcher les pseudos des membres : c'est Atlante, pas Atland
Me concernant, tu peux dire Taz, pas de soucis :)
Je demande pas que on fasse mon boulot comme tu le dis si bien mais juste qu'on m'aide :) :wink:
Tu ne m'as pas répondu ok et j'en ai pas fait un fromage :lol:

Pour les pseudo désoler, pas volontaire :wink:
Merci pour le reste :)
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

Salut !

Après avoir beaucoup travaillé sur ce code je le poste, il est fonctionnel mais
j'ai un petit problème quand même:

A la ligne 1195 il y a la commande:

Code : Tout sélectionner

WaitThread(ThreadDecoupageImage)
Si j'ai mis la gestion du découpage dans un thread
c'est que je voulais que ça se fasse en arrière-plan pour que la fenêtre puis toujours
s’actualiser elle-même et que je puis montrer la progression en changeants les valeurs du ScrollAreaGadget
en X et en Y !

Mais hélas cella ne fonctionne pas étant donné que si je ne mets pas la commande

Code : Tout sélectionner

WaitThread(ThreadDecoupageImage)
Il me dit qu'il faut d'abord utiliser StopDrawing() avent de pouvoir réutiliser un StartDrawing()
J'ai alors cherché d'où venais le problème mais sans succès !

Alors je suis bloquer et ne sais pas comment faire !

J’ai encore des progrès à réaliser dans la gestion des threads et des Start / Stop Drawing
Bref si un bon samaritain veut bien me dire ou ça cloche et ce que je dois faire

Image du curseur:
Image

Partie 1:

Code : Tout sélectionner

; Crée par monsieur dieppedalle le 22 avril 2012

; Règles à suivre:

; Vos petites images sur la feuille (l'image qui contient toutes vos petites images) doivent avoir un arrière plant de couleur et l'arrière doit-être de forme carrer ou rectangle et non transparent !
; Vos petites images sur la feuille doivent êtres espacer d'au moins 1 pixel (arrière plant compris)

UsePNGImageDecoder()
UsePNGImageEncoder()

Global NewList PixelImage.l()

Enumeration 1
  #Fenetre
  #AreaGadget
  #CanvasGadget
  #TexeInfoCouleurArrierPlantSprite
  #TexeInfoCouleurFeuille
  #ImageCouleurArrierPlantSprite
  #ImageCouleurFeuille
  #BoutonDecouper
  #BoutonImageCouleurArrierPlantSprite
  #BoutonImageCouleurFeuille
EndEnumeration

Procedure EnregistrementPixel(CouleurPixel)
  
  AddElement(PixelImage.l())
  PixelImage.l() = CouleurPixel
  
EndProcedure

Procedure.i CreeSprite(ImageSave, LargeurImage, HauteurImage, CouleurTransparence)
  
  Static NumeroImageGenerer
  
  NumeroImageGenerer + 1
  
  X = 0
  Y = 0
  
  StartDrawing(ImageOutput(ImageSave))
  
  ForEach PixelImage.l()
    
    If PixelImage.l() = CouleurTransparence
      
      DrawingMode(#PB_2DDrawing_AlphaChannel)
      Plot(X, Y, RGBA(Red(CouleurTransparence), Green(CouleurTransparence), Blue(CouleurTransparence), 0))
      
    Else
      
      DrawingMode(#PB_2DDrawing_Default)
      Plot(X, Y, PixelImage.l())
      
    EndIf
    
    If Y <> HauteurImage - 1
      Y + 1
    Else
      X + 1
      Y = 0
    EndIf
    
  Next
  
  StopDrawing()
  
  ClearList(PixelImage.l())
  
  SaveImage(ImageSave, "Image " + Str(NumeroImageGenerer) + ".png", #PB_ImagePlugin_PNG)
  
  ProcedureReturn NumeroImageGenerer
EndProcedure

Procedure DecoupageImage(ImagePourDecoupe, CouleurArrierPlantSprite, CouleurFeuille, CouleurTransparence)
  
  T1.d = ElapsedMilliseconds()
  
  ; J'initialise au départ les valeurs de coordonnées et de dimension de l'ImagePourDecoupe
  
  X = 0
  Y = 0
  
  LargeurImagePourDecoupe = ImageWidth(ImagePourDecoupe)
  HauteurImagePourDecoupe = ImageHeight(ImagePourDecoupe)
  
  ;   Je parcours ligne à ligne le fichier ImagePourDecoupe
  
  Repeat
    
    ; Je réinitialise les valeurs du sprite
    
    HauteurSprite = 0
    LargeurSprite = 0
    
    ; Je démarre la lecture du pixel de l'ImagePourDecoupe
    
    StartDrawing(ImageOutput(ImagePourDecoupe))
    CouleurLue = Point(X, Y) ; Lecture du pixel de l'ImagePourDecoupe
    StopDrawing()
    
    ;   SI je rencontre du "CouleurArrierPlantSprite",
    ;   ALORS je suis sur un sprite !
    
    If CouleurLue = CouleurArrierPlantSprite
      
      ;   Je mémorise les coordonnées actuelles
      
      SauvegardeX = X -1 ; -1 car une fois le sprite lue, je copierais celui-ci et effacerais le sprite et le remplacerais donc par du "CouleurFeuille" et je reviendrais à cette coordonnée pour lire la suite de l'ImagePourDecoupe
      SauvegardeY = Y
      
      ;   Boucle secondaire pour extraire le sprite
      ;   Je boucle sur les colonnes tant que j'ai du "CouleurArrierPlantSprite"
      
      Repeat
        
        StartDrawing(ImageOutput(ImagePourDecoupe))
        CouleurLue = Point(X, Y) ; Lecture du pixel de l'ImagePourDecoupe
        StopDrawing()
        
        If Y = SauvegardeY And CouleurLue = CouleurArrierPlantSprite ; Si le premier pixel en haut du sprite est bien "CouleurArrierPlantSprite"
          
          ; Nous enregistrons le pixel
          EnregistrementPixel(CouleurLue)
          
          Y + 1 ; Passage au pixel suivent
          
        ElseIf Y = SauvegardeY And CouleurLue = CouleurFeuille ; SinonSi le premier pixel en haut du sprite n'est plus "CouleurArrierPlantSprite"
          
          ; J'enregistre la Largeur du sprite si ce n'est pas déjà fait, sinon je ne fais rien !
          
          If LargeurSprite = 0
            LargeurSprite = X - 1 - SauvegardeX ; Moins 1 car on est en dehors du sprite en horizontale puisqu'on a lu un "CouleurFeuille"
          EndIf
          
          ; Je remplace le sprite par du "CouleurFeuille" pour effacer le sprite et ainsi pouvoir continuer !
          
          StartDrawing(ImageOutput(ImagePourDecoupe))
          Box(SauvegardeX + 1, SauvegardeY, LargeurSprite, HauteurSprite, CouleurFeuille) ; Moins 1 car on est en dehors du sprite en horizontale puisqu'on a lu un "CouleurFeuille"
          StopDrawing()
          
          ; Je vais maintenant crée et enregistre l'ImagePourDecoupe !:
          NombreImagePourDecoupeGenerer = CreeSprite(CreateImage(#PB_Any, LargeurSprite, HauteurSprite, 32), LargeurSprite, HauteurSprite, CouleurTransparence)
          
          ; Je restitue les valeurs enregistrées avent de lire le sprite
          
          X = SauvegardeX + LargeurSprite ; Pourquoi "+ LargeurSprite" ?, bin pourquoi revenir en arrière !, autent aller de l'avent !
          Y = SauvegardeY
          
          StartDrawing(CanvasOutput(#CanvasGadget))
          DrawImage(ImageID(ImagePourDecoupe), 0, 0, ImageWidth(ImagePourDecoupe), ImageHeight(ImagePourDecoupe))
          StopDrawing()
          
          Break ; Mon sprite est complet, donc on retourne à la ligne mémorisée pour passer éventuellement au sprite horizontal suivant
          
        ElseIf CouleurLue = CouleurFeuille ; On est à maintenant à l'extrémité du sprite !
          
          ; On enregistre pas le pixel puisque c'est en dehors du sprite !
          
          ; J'enregistre la hauteur du sprite si ce n'est pas déjà fait, sinon je ne fait rien !
          
          If HauteurSprite = 0
            HauteurSprite = Y - SauvegardeY
          EndIf
          
          X + 1 ; On ajoute 1 en horizontale pour lire la ligne suivante du sprite
          Y = SauvegardeY ; On revient au coordonnées enregistrer en Y
          
        Else
          
          StartDrawing(ImageOutput(ImagePourDecoupe))
          CouleurLue = Point(X, Y) ; Lecture du pixel de l'ImagePourDecoupe
          StopDrawing()
          
          ; Nous enregistrons le pixel
          EnregistrementPixel(CouleurLue)
          
          Y + 1 ; Passage au pixel suivent
          
        EndIf
        
      ForEver
      
    EndIf ; Sinon on continue !
    
    ; Si la position X est plus petit que la largeur de l'ImagePourDecoupe
    If X <> LargeurImagePourDecoupe - 1
      X + 1 ; Ont rajoute 1 à X pour lire la ligne suivente
    Else ; Sinon (Si la position X est ègale à la largeur de l'ImagePourDecoupe) 
      X = 0 ; On remet X à 0 pour revenir au début de l'ImagePourDecoupe
      Y + 1 ; Ont rajoute 1 à Y pour lire la ligne suivente de l'ImagePourDecoupe
    EndIf
    
  Until X = LargeurImagePourDecoupe - 1 And Y = HauteurImagePourDecoupe - 1 ; Si la position X est ègale à la largeur de l'ImagePourDecoupe (- 1 car les oppérations de déssins commence à 0)
  ; Et que la position Y est ègale à la Hauteur de l'ImagePourDecoupe (- 1 car les oppérations de déssins commence à 0)
  ; On a terminé la lecture de l'ImagePourDecoupe !
  
  T2.d = ElapsedMilliseconds()
  
  Temps.d = (T2.d - T1.d) / 1000
  
  MessageRequester("Information", "      " + Str(NombreImagePourDecoupeGenerer) + " ImagePourDecoupes ont été découpée(s) en " + StrD(Temps.d, 0) + " seconde(s) !", 64)
  
  DisableGadget(#BoutonImageCouleurArrierPlantSprite, 0)
  DisableGadget(#BoutonImageCouleurFeuille, 0)
  DisableGadget(#BoutonDecouper, 0)
  
EndProcedure

; Procedure de chargement d'une image
Procedure.l ChargementImage()
  
  Chargement_Image:
  Filtre$ = "Image Supporté (*.Bmp, *.Png, *.Jpeg)|*.Bmp;*.Png;*.Jpeg|Image Bmp (*.Bmp)|*.Bmp|Image Png (*.Png)|*.Png|Image Jpeg (*.Jpeg)|*.Jpeg"
  FichierImage$ = OpenFileRequester("Choisissez un fichier à charger", GetHomeDirectory() + "Bureau\", Filtre$, 0)
  
  If FichierImage$
    
    If FindString(GetFilePart(FichierImage$), ".bmp", 1) Or FindString(GetFilePart(FichierImage$), ".png", 1) Or FindString(GetFilePart(FichierImage$), ".jpeg", 1)
      ; Ok
    Else
      MessageRequester("Fichier invalide !", "      Veuillez choisir un fichier d'image invalide !", 48)
      ProcedureReturn 0
    EndIf
    
    If LoadImage(#PB_Any, FichierImage$) <> 0
      ProcedureReturn LoadImage(#PB_Any, FichierImage$)
    Else
      MessageRequester("Erreur de chargement !", "      Impossible de charger le fichier " + Chr(34) + GetFilePart(FichierImage$) + Chr(34) + " !", 16)
      ProcedureReturn 0
    EndIf
    
  EndIf
  
  ProcedureReturn 0
  
EndProcedure

Procedure CurseurPersonnaliser(CheminImage$)
  
  Image = LoadImage(#PB_Any, CheminImage$)
  
  If Image
  ImageCurseur = ResizeImage(Image, ImageWidth(Image), ImageHeight(Image))
  
  ; Création du masque du curseur
  CreateImage = CreateImage(#PB_Any, ImageWidth(Image),ImageHeight(Image))
  
  If CreateImage
  StartDrawing(ImageOutput(CreateImage))
  
  DrawImage(ImageID(Image), 0, 0) ; Déssine l'image 0 sur l'image 1
  CouleurTransparente = Point(0, 0) ; Renvoie le masque de l'image a la position 0, 0
  
  ; On va remplacer tous les pixels transparent de l'image s'il en a par du blanc et les autres couleur par du noir
  For Largeur = 0 To ImageWidth(Image) -1
    
    For Hauteur = 0 To ImageHeight(Image) -1
      
      If Point(Largeur, Hauteur) = CouleurTransparente
        Plot(Largeur, Hauteur, #White)
        
      Else
        Plot(Largeur, Hauteur, #Black)
        
      EndIf
      
    Next
    
  Next
  
  StopDrawing() 
  
  ; Enregistrement des informations néccessaire dans la structure du curseur 
  IconeInformation.ICONINFO 
  IconeInformation\fIcon = #False 
  IconeInformation\xHotspot = 0 ; La position X du curseur par apport au curseur de windows
  IconeInformation\yHotspot = 0 ; La position Y du curseur par apport au curseur de windows
  IconeInformation\hbmMask = ImageID(CreateImage) ; Le masque du curseur
  IconeInformation\hbmColor = ImageCurseur ; L'image du curseur
  
  ; Création du curseur personnaliser 
  CurseurPersonnaliser = CreateIconIndirect_(IconeInformation) 
  
  ; Change le curseur actuel du canva par le curseur personnaliser et le place sur la la canva
  SetGadgetAttribute(#CanvasGadget, #PB_Canvas_CustomCursor , CurseurPersonnaliser)
  
  EndIf
  EndIf

EndProcedure

;{ Code pour gérer les boutons perso


#BG_AutoNum = -917346825

; Ma tructure qui ma servir pour stoquer toutes les imformations du bouton
Structure Caracteristiques
  ;{
  ; Cette structure est asser grande car elle permet de savoir tous sur notre bouton
  ; Si par la suite on veut savoir quoi que ce soit, tous est inscrie ici !
  
  ; Le bouton en lui-même
  ;---------------------------------------------------
  BoutonID.i
  
  X.i
  Y.i
  
  Largeur.i
  Hauteur.i
  
  ImageNormale.i
  ImageSurvoler.i
  ImageAppuyer.i
  
  Curseur.l
  
  OptionBouton.i
  
  EtasBouton.i
  EtasBoutonGaucheSouris.i
  ;---------------------------------------------------
  
  ; Bouton image normale
  ;---------------------------------------------------
  TexteBoutonNormale.s
  
  CouleurBordureHauteBoutonNormale.i
  CouleurBordureBasBoutonNormale.i
  CouleurBordureGaucheBoutonNormale.i
  CouleurBordureDroiteBoutonNormale.i
  TailleDesBorduresBoutonNormale.i
  
  CouleurDegrader1InterieurBoutonNormale.i
  CouleurDegrader2InterieurBoutonNormale.i
  OptionDegraderInterieurBoutonNormale.i
  ActiverDegraderBoutonNormale.i
  
  XTexteBoutonNormale.i
  YTexteBoutonNormale.i
  PocileTexteBoutonNormale.s
  TailleTexteBoutonNormale.i
  CouleurTexteBoutonNormale.i
  CouleurFondTexteBoutonNormale.i
  TexteTrensparentBoutonNormale.i
  OptionTexteBoutonNormale.i
  NumeroPoliceBoutonNormale.i
  
  ImageBoutonBoutonNormale.i
  XImageBoutonNormale.i
  YImageBoutonNormale.i
  ;---------------------------------------------------
  
  ; Bouton image survoler
  ;---------------------------------------------------
  TexteBoutonSurvoler.s
  
  CouleurBordureHauteBoutonSurvoler.i
  CouleurBordureBasBoutonSurvoler.i
  CouleurBordureGaucheBoutonSurvoler.i
  CouleurBordureDroiteBoutonSurvoler.i
  TailleDesBorduresBoutonSurvoler.i
  
  CouleurDegrader1InterieurBoutonSurvoler.i
  CouleurDegrader2InterieurBoutonSurvoler.i
  OptionDegraderInterieurBoutonSurvoler.i
  ActiverDegraderBoutonSurvoler.i
  
  XTexteBoutonSurvoler.i
  YTexteBoutonSurvoler.i
  PocileTexteBoutonSurvoler.s
  TailleTexteBoutonSurvoler.i
  CouleurTexteBoutonSurvoler.i
  CouleurFondTexteBoutonSurvoler.i
  TexteTrensparentBoutonSurvoler.i
  OptionTexteBoutonSurvoler.i
  NumeroPoliceBoutonSurvoler.i
  
  ImageBoutonBoutonSurvoler.i
  XImageBoutonSurvoler.i
  YImageBoutonSurvoler.i
  ;---------------------------------------------------
  
  ; Bouton image appuyer
  ;---------------------------------------------------
  TexteBoutonAppuyer.s
  
  CouleurBordureHauteBoutonAppuyer.i
  CouleurBordureBasBoutonAppuyer.i
  CouleurBordureGaucheBoutonAppuyer.i
  CouleurBordureDroiteBoutonAppuyer.i
  TailleDesBorduresBoutonAppuyer.i
  
  CouleurDegrader1InterieurBoutonAppuyer.i
  CouleurDegrader2InterieurBoutonAppuyer.i
  OptionDegraderInterieurBoutonAppuyer.i
  ActiverDegraderBoutonAppuyer.i
  
  XTexteBoutonAppuyer.i
  YTexteBoutonAppuyer.i
  PocileTexteBoutonAppuyer.s
  TailleTexteBoutonAppuyer.i
  CouleurTexteBoutonAppuyer.i
  CouleurFondTexteBoutonAppuyer.i
  TexteTrensparentBoutonAppuyer.i
  OptionTexteBoutonAppuyer.i
  NumeroPoliceBoutonAppuyer.i
  
  ImageBoutonBoutonAppuyer.i
  XImageBoutonAppuyer.i
  YImageBoutonAppuyer.i
  ;---------------------------------------------------
  
  ;} 
EndStructure

Global Dim Bouton.Caracteristiques(64000)
Global NewList EnumerationBouton.l()

Procedure.l IsMouseOverGadget(Gadget)
  If IsGadget(Gadget)
    GetWindowRect_(GadgetID(Gadget),GadgetRect.RECT) 
    GetCursorPos_(mouse.POINT) 
    If mouse\x>=GadgetRect\Left And mouse\x<=GadgetRect\right And mouse\y>=GadgetRect\Top And mouse\y<=GadgetRect\bottom
      ProcedureReturn #True 
    Else 
      ProcedureReturn #False 
    EndIf 
  EndIf
EndProcedure 

Enumeration #PB_Compiler_EnumerationValue
  #FenetreImage
  #ImageFenetreImage
EndEnumeration

Procedure.i BG_AutoNum()
  
  Static Minimum = #PB_Compiler_EnumerationValue
  
  BG_AutoNum = Minimum
  Minimum + 1
  
  ProcedureReturn BG_AutoNum
EndProcedure

BG_AutoNum()

;{ Procedure Information Bouton

Procedure.l RenvoyerBoutonId(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ BoutonID
EndProcedure

Procedure.l RenvoyerPositionBoutonX(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ X
EndProcedure

Procedure.l RenvoyerPositionBoutonY(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ Y
EndProcedure

Procedure.l RenvoyerLargeurBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ Largeur
EndProcedure

Procedure.l RenvoyerHauteurBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ Hauteur
EndProcedure

Procedure.l RenvoyerImageNormaleBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageNormale
EndProcedure

Procedure.l RenvoyerImageSurvolerBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageSurvoler
EndProcedure

Procedure.l RenvoyerImageAppuyerBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageAppuyer
EndProcedure

Procedure.l RenvoyerCurseurBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ Curseur
EndProcedure

Procedure.l RenvoyerOptionBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionBouton
EndProcedure

Procedure.l RenvoyerEtasBouton(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ EtasBouton
EndProcedure

Procedure.l RenvoyerEtasBoutonGaucheSouris(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ EtasBoutonGaucheSouris
EndProcedure

Procedure.s RenvoyerTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurBordureHauteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurBordureBasBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurBordureGaucheBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurBordureDroiteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonNormale
EndProcedure

Procedure.l RenvoyerTailleDesBorduresBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurDegrader1InterieurBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurDegrader2InterieurBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonNormale
EndProcedure

Procedure.l RenvoyerOptionDegraderInterieurBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonNormale
EndProcedure

Procedure.l RenvoyerEtasDegraderBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonNormale
EndProcedure

Procedure.l RenvoyerXTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerYTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YTexteBoutonNormale
EndProcedure

Procedure.s RenvoyerNomPocileTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerTailleTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerCouleurFondTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerEtasTrensparenceTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonNormale
EndProcedure

Procedure.l RenvoyerOptionTexteBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonNormale
EndProcedure

Procedure.l RenvoyerNumeroPoliceBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonNormale
EndProcedure

Procedure.l RenvoyerImage2BoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonNormale
EndProcedure

Procedure.l RenvoyerXImageBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XImageBoutonNormale
EndProcedure

Procedure.l RenvoyerYImageBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YImageBoutonNormale
EndProcedure

;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Procedure.s RenvoyerTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurBordureHauteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurBordureBasBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurBordureGaucheBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurBordureDroiteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerTailleDesBorduresBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurDegrader1InterieurBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurDegrader2InterieurBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonSurvoler
EndProcedure

Procedure.l RenvoyerOptionDegraderInterieurBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonSurvoler
EndProcedure

Procedure.l RenvoyerEtasDegraderBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonSurvoler
EndProcedure

Procedure.l RenvoyerXTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerYTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YTexteBoutonSurvoler
EndProcedure

Procedure.s RenvoyerNomPocileTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerTailleTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerCouleurFondTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerEtasTrensparenceTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonSurvoler
EndProcedure

Procedure.l RenvoyerOptionTexteBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonSurvoler
EndProcedure

Procedure.l RenvoyerNumeroPoliceBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonSurvoler
EndProcedure

Procedure.l RenvoyerImage2BoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonSurvoler
EndProcedure

Procedure.l RenvoyerXImageBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XImageBoutonSurvoler
EndProcedure

Procedure.l RenvoyerYImageBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YImageBoutonSurvoler
EndProcedure

;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Procedure.s RenvoyerTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurBordureHauteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurBordureBasBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurBordureGaucheBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurBordureDroiteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerTailleDesBorduresBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurDegrader1InterieurBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurDegrader2InterieurBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonAppuyer
EndProcedure

Procedure.l RenvoyerOptionDegraderInterieurBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonAppuyer
EndProcedure

Procedure.l RenvoyerEtasDegraderBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonAppuyer
EndProcedure

Procedure.l RenvoyerXTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerYTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YTexteBoutonAppuyer
EndProcedure

Procedure.s RenvoyerNomPocileTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerTailleTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerCouleurFondTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerEtasTrensparenceTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonAppuyer
EndProcedure

Procedure.l RenvoyerOptionTexteBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonAppuyer
EndProcedure

Procedure.l RenvoyerNumeroPoliceBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonAppuyer
EndProcedure

Procedure.l RenvoyerImage2BoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonAppuyer
EndProcedure

Procedure.l RenvoyerXImageBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ XImageBoutonAppuyer
EndProcedure

Procedure.l RenvoyerYImageBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton.Caracteristiques(BoutonID) \ YImageBoutonAppuyer
EndProcedure

;}

; Procedure permetans d'initialiser une valeur à 0 si elle est inférieur à 0
Procedure VerificationValeurVariable(Valeur)
  
  If Valeur < 0
    Valeur = 0
  EndIf
  
  ProcedureReturn Valeur
EndProcedure

; Procedure permetans de centrer le texte sur le bouton
Procedure.s CentreTexteSurMonBouton(BoutonID, Texte$)
  
  Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
  Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
  
  LargeurTexte = TextWidth(Texte$)
  HauteurTexte = TextHeight(Texte$)
  
  DifferenceLargeur = Largeur - LargeurTexte
  DifferenceHauteur = Hauteur - HauteurTexte
  
  XTexte = DifferenceLargeur / 2
  YTexte = DifferenceHauteur / 2
  
  ProcedureReturn Str(XTexte) + "|" + Str(YTexte)
EndProcedure

; Procedure permetans de centrer l'image sur le bouton
Procedure.s CentreImageSurMonBouton(BoutonID, ImageBouton)
  
  If IsImage(ImageBouton)
    
    Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
    Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
    
    LargeurImage = ImageWidth(ImageBouton)
    HauteurImage = ImageHeight(ImageBouton)
    
    DifferenceLargeur = Largeur - LargeurImage
    DifferenceHauteur = Hauteur - HauteurImage
    
    XImage = DifferenceLargeur / 2
    YImage = DifferenceHauteur / 2
    
    ProcedureReturn Str(XImage) + "|" + Str(YImage)
  EndIf

EndProcedure

; Là on va juste crée (déssiner) le bouton simplemant comme un bouton normale !
; C'est cette commande qui servira à crée et initialiser le bouton !
Procedure.i BoutonGadget(BoutonID, X, Y, Largeur, Hauteur, Texte$, XTexte, YTexte, CouleurTexte, CouleurFondTexte, TailleTexte, OptionTexte, CouleurBouton, CurseurSurBouton, ImageBouton, XImage, YImage, OptionBouton)
  
  If BoutonID = #BG_AutoNum
    BoutonID = BG_AutoNum()
    BG_AutoNum = 1
  EndIf
  
  ; Option pourra être:
  
  ; #BG_Toggle = Crée un bouton de type 'Toogle'. Ce bouton alterne l'état 'appuyé' et 'normal'
  ; #BG_Flat = Le bouton sera plat
  ; #BG_BorderLess = Aucune bordure n'est affichée autour du bouton, TailleDesBordures = 0 (Aucun bordure déssiner)
  ; #BG_Staticedge = Crée une seconde bordure autour du bouton (si je me trompe pas)
  
  ; Autres:
  
  ; #PB_Canvas_Border = Dessine une bordure enfoncer autour du bouton
  ; #PB_Canvas_DrawFocus = Dessine un rectangle de focus sur le bouton
  
  ; Ont pourais éventuellement aussi mètre:
  
  ; #BG_Defaul = Définit le bouton comme bouton par défaut (encadré en noir ou autres couleur)
  
  
  ; Création de l'image normale du bouton:
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  ListIndex = -1
  
  ForEach EnumerationBouton.l() ; Je recherche si le bouton existe déjà
    
    If EnumerationBouton.l() = BoutonID
      ListIndex = ListIndex(EnumerationBouton.l())
      Break
    EndIf
    
    ListIndex = -1
    
  Next
  
  If ListIndex = -1
    AddElement(EnumerationBouton.l())
    EnumerationBouton.l() = BoutonID
  EndIf
  
  BoutonID = VerificationValeurVariable(BoutonID)
  X = VerificationValeurVariable(X)
  Y = VerificationValeurVariable(Y)
  Largeur = VerificationValeurVariable(Largeur)
  Hauteur = VerificationValeurVariable(Hauteur)
  CouleurTexte = VerificationValeurVariable(CouleurTexte)
  CouleurFondTexte = VerificationValeurVariable(CouleurFondTexte)
  CouleurBouton = VerificationValeurVariable(CouleurBouton)
  OptionBouton = VerificationValeurVariable(OptionBouton)
  Curseur = VerificationValeurVariable(Curseur)
  ImageBouton = VerificationValeurVariable(ImageBouton)
  XImage = VerificationValeurVariable(XImage)
  YImage = VerificationValeurVariable(YImage)
  LargeurImage = VerificationValeurVariable(LargeurImage)
  HauteurImage = VerificationValeurVariable(HauteurImage)
  
  If VerificationValeurVariable(TailleTexte) = 0
    TailleTexte = 1
  EndIf
  
  If OptionTexte < -1
    OptionTexte = -1
  ElseIf OptionTexte <> -1
    OptionTexte = VerificationValeurVariable(OptionTexte)
  EndIf
  
  Bouton.Caracteristiques(BoutonID) \ BoutonID = BoutonID
  Bouton.Caracteristiques(BoutonID) \ X = X
  Bouton.Caracteristiques(BoutonID) \ Y = Y
  Bouton.Caracteristiques(BoutonID) \ Largeur = Largeur
  Bouton.Caracteristiques(BoutonID) \ Hauteur = Hauteur
  
  Bouton.Caracteristiques(BoutonID) \ TexteBoutonNormale = Texte$
  
  Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonNormale = CouleurTexte
  Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonNormale = CouleurFondTexte
  
  Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonNormale & #PB_Font_HighQuality
  
  Bouton.Caracteristiques(BoutonID) \ Curseur = CurseurSurBouton
  Bouton.Caracteristiques(BoutonID) \ OptionBouton = OptionBouton
  
  CanvasGadget(BoutonID, X, Y, Largeur, Hauteur, OptionBouton|#PB_Canvas_ClipMouse)
  
  ImageAuto = CreateImage(#PB_Any, Largeur, Hauteur)
  
  If ImageAuto
    
    If OptionTexte = -1
      FontID = LoadFont(#PB_Any, "Arial", TailleTexte, #PB_Font_Bold | #PB_Font_Italic | #PB_Font_Underline | #PB_Font_StrikeOut | #PB_Font_HighQuality)
      OptionTexte = #PB_Font_Bold | #PB_Font_Italic | #PB_Font_Underline | #PB_Font_StrikeOut | #PB_Font_HighQuality
    Else
      FontID = LoadFont(#PB_Any, "Arial", TailleTexte, OptionTexte & #PB_Font_HighQuality)
      OptionTexte & #PB_Font_HighQuality
    EndIf
    
    Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonNormale = OptionTexte
    
    StartDrawing(ImageOutput(ImageAuto))
    
    DrawingMode(#PB_2DDrawing_Gradient)
    
    ; degrader en horizontale
    LinearGradient(1, 1, Largeur, 1) 
    GradientColor(1, CouleurBouton)
    
    LinearGradient(Largeur, 1, 1, 1)
    GradientColor(0, CouleurBouton)
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonNormale = CouleurBouton
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonNormale = CouleurBouton
    Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonNormale = 1
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonNormale = 0
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonNormale = 1
    
    Line(0, 0, Largeur - 1, 1, RGB(255, 255, 255))
    Line(Largeur - 1, 0, 1, Hauteur - 1, RGB(160, 160, 160))
    Line(1, Hauteur - 1, Largeur - 1, 1, RGB(160, 160, 160))
    Line(0, 1, 1, Hauteur - 1, RGB(255, 255, 255))
    
    If IsFont(FontID)
      DrawingFont(FontID(FontID))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonNormale = "Arial"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonNormale = TailleTexte
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonNormale = FontID
    Else
      DrawingFont(FontID(#PB_Default))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonNormale = "Inconnue"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonNormale = 0
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonNormale = 0
    EndIf
    
    If XTexte = 0
      PositionTexteX = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 1, "|"))
    Else
      PositionTexteX = XTexte
    EndIf
    
    If YTexte = 0
      PositionTexteY = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 2, "|"))
    Else
      PositionTexteY = YTexte
    EndIf
  
    If IsImage(ImageBouton)
      
      If XImage = 0
        PositionImageX = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 1, "|")) + XImage
      Else
        PositionImageX = XImage
      EndIf
      
      If YImage = 0
        PositionImageY = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 2, "|")) + YImage
      Else
        PositionImageY = YImage
      EndIf
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBouton), PositionImageX, PositionImageY, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      DrawingMode(0)
      
      Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonNormale = ImageBouton
      Bouton.Caracteristiques(BoutonID) \ XImageBoutonNormale = PositionImageX
      Bouton.Caracteristiques(BoutonID) \ YImageBoutonNormale = PositionImageY
      
    EndIf
    
    DrawingMode(#PB_2DDrawing_Transparent)
    
    DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    
    StopDrawing()
    
    ; Par defaut, les bordures serons blanche (Haut et gauche) et gris foncer (Bas et droite)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonNormale = RGB(255, 255, 255)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonNormale = RGB(160, 160, 160)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonNormale = RGB(255, 255, 255)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonNormale = RGB(160, 160, 160)
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

Partie 2:

Code : Tout sélectionner

    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonNormale = PositionTexteX
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonNormale = PositionTexteY
    
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonNormale = 1
    
    ; Initialisation du curseur sur le bouton
    SetGadgetAttribute(BoutonID, #PB_Canvas_Cursor, CurseurSurBouton)
    
    Bouton.Caracteristiques(BoutonID) \ ImageNormale = ImageAuto
    
    ; Je déssine le bouton
    StartDrawing(CanvasOutput(BoutonID))
    DrawImage(ImageID(ImageAuto), 0, 0)
    StopDrawing()
    ;AfficherImage(ImageAuto)
    
  EndIf
  
  ; Création de l'image survolé du bouton:
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  Bouton.Caracteristiques(BoutonID) \ TexteBoutonSurvoler = Texte$
  
  Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonSurvoler = CouleurTexte
  Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonSurvoler = CouleurFondTexte
  
  Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonSurvoler = CouleurBouton
  Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonSurvoler = CouleurBouton
  Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonSurvoler = 1
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonSurvoler = 0
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonSurvoler = 1
    
  Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonSurvoler = OptionTexte
  
  ImageAuto = CreateImage(#PB_Any, Largeur, Hauteur)
  
  If ImageAuto
    
    FontID = LoadFont(#PB_Any, "Arial", TailleTexte, OptionTexte)
    
    StartDrawing(ImageOutput(ImageAuto))
    
    DrawingMode(#PB_2DDrawing_Gradient)
    
    ; degrader en horizontale
    LinearGradient(1, 1, Largeur, 1) 
    GradientColor(1, CouleurBouton)
    
    LinearGradient(Largeur, 1, 1, 1)
    GradientColor(0, CouleurBouton)
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
    Line(0, 0, Largeur - 1, 1, RGB(255, 255, 255))
    Line(Largeur - 1, 0, 1, Hauteur - 1, RGB(160, 160, 160))
    Line(1, Hauteur - 1, Largeur - 1, 1, RGB(160, 160, 160))
    Line(0, 1, 1, Hauteur - 1, RGB(255, 255, 255))
    
    If IsFont(FontID)
      DrawingFont(FontID(FontID))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonSurvoler = "Arial"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonSurvoler = TailleTexte
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonSurvoler = FontID
    Else
      DrawingFont(FontID(#PB_Default))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonSurvoler = "Inconnue"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonSurvoler = 0
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonSurvoler = 0
    EndIf
    
    If XTexte = 0
      PositionTexteX = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 1, "|"))
    Else
      PositionTexteX = XTexte
    EndIf
    
    If YTexte = 0
      PositionTexteY = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 2, "|"))
    Else
      PositionTexteY = YTexte
    EndIf
    
    If IsImage(ImageBouton)
      
      If XImage = 0
        PositionImageX = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 1, "|")) + XImage
      Else
        PositionImageX = XImage
      EndIf
      
      If YImage = 0
        PositionImageY = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 2, "|")) + YImage
      Else
        PositionImageY = YImage
      EndIf
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBouton), PositionImageX, PositionImageY, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      DrawingMode(0)
      
      Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonSurvoler = ImageBouton
      Bouton.Caracteristiques(BoutonID) \ XImageBoutonSurvoler = PositionImageX
      Bouton.Caracteristiques(BoutonID) \ YImageBoutonSurvoler = PositionImageY
      
    EndIf
    
    DrawingMode(#PB_2DDrawing_Transparent)
    
    DrawText(PositionTexteX + XTexte, PositionTexteY + YTexte, Texte$, CouleurTexte, CouleurFondTexte)
    
    StopDrawing()
    
    ; Par defaut, les bordures serons blanche (Haut et gauche) et gris foncer (Bas et droite)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonSurvoler = RGB(255, 255, 255)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonSurvoler = RGB(160, 160, 160)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonSurvoler = RGB(255, 255, 255)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonSurvoler = RGB(160, 160, 160)
    
    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonSurvoler = PositionTexteX
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonSurvoler = PositionTexteY
    
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonSurvoler = 1
    
    Bouton.Caracteristiques(BoutonID) \ ImageSurvoler = ImageAuto
    
  EndIf
  
  ; Création de l'image Appuyer du bouton:
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  Bouton.Caracteristiques(BoutonID) \ TexteBoutonAppuyer = Texte$
  
  Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonAppuyer = CouleurTexte
  Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonAppuyer = CouleurFondTexte
  
  Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonAppuyer = CouleurBouton
  Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonAppuyer = CouleurBouton
  Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonAppuyer = 1
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonAppuyer = 0
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonAppuyer = 1
  
  Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonAppuyer = OptionTexte
  
  ImageAuto = CreateImage(#PB_Any, Largeur, Hauteur)
  
  If ImageAuto
    
      FontID = LoadFont(#PB_Any, "Arial", TailleTexte, OptionTexte)
    
    StartDrawing(ImageOutput(ImageAuto))
    
    DrawingMode(#PB_2DDrawing_Gradient)
    
    ; degrader en horizontale
    LinearGradient(1, 1, Largeur, 1) 
    GradientColor(1, CouleurBouton)
    
    LinearGradient(Largeur, 1, 1, 1)
    GradientColor(0, CouleurBouton)
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
    Line(0, 0, Largeur - 1, 1, RGB(160, 160, 160))
    Line(Largeur - 1, 0, 1, Hauteur - 1, RGB(255, 255, 255))
    Line(1, Hauteur - 1, Largeur - 1, 1, RGB(255, 255, 255))
    Line(0, 1, 1, Hauteur - 1, RGB(160, 160, 160))
    
    If IsFont(FontID)
      DrawingFont(FontID(FontID))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonAppuyer = "Arial"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonAppuyer = TailleTexte
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonAppuyer = FontID
    Else
      DrawingFont(FontID(#PB_Default))
      Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonAppuyer = "Inconnue"
      Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonAppuyer = 0
      Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonAppuyer = 0
    EndIf
    
    PositionTexteX = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 1, "|")) + 1
    PositionTexteY = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 2, "|")) + 1
    
    If IsImage(ImageBouton)
      
      If XImage = 0
        PositionImageX = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 1, "|")) + XImage + 1
      Else
        PositionImageX = XImage + 1
      EndIf
      
      If YImage = 0
        PositionImageY = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 2, "|")) + YImage + 1
      Else
        PositionImageY = YImage + 1
      EndIf
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBouton), PositionImageX, PositionImageY, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      DrawingMode(0)
      
      Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonAppuyer = ImageBouton
      Bouton.Caracteristiques(BoutonID) \ XImageBoutonAppuyer = PositionImageX
      Bouton.Caracteristiques(BoutonID) \ YImageBoutonAppuyer = PositionImageY
      
    EndIf
    
    DrawingMode(#PB_2DDrawing_Transparent)
    
    If XTexte = 0
      PositionTexteX = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 1, "|")) + 1
    Else
      PositionTexteX = XTexte + 1
    EndIf
    
    If YTexte = 0
      PositionTexteY = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 2, "|")) + 1
    Else
      PositionTexteY = YTexte + 1
    EndIf
    
    DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    
    StopDrawing()
    
    ; Par defaut, les bordures serons blanche (Haut et gauche) et gris foncer (Bas et droite)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonAppuyer = RGB(160, 160, 160)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonAppuyer = RGB(255, 255, 255)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonAppuyer = RGB(160, 160, 160)
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonAppuyer = RGB(255, 255, 255)
    
    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonAppuyer = PositionTexteX
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonAppuyer = PositionTexteY
    
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonAppuyer = 1
    Bouton.Caracteristiques(BoutonID) \ ImageAppuyer = ImageAuto
    
  EndIf
  
  If BG_AutoNum = 1
    ProcedureReturn BoutonID
  EndIf
  
EndProcedure

; Ici je recupère toutes les données du bouton
Macro RecuperationDonnerBouton()
  
  If LCase(NomEtasImage$) = "normale"
    Global TexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ TexteBoutonNormale
    
    Global CouleurBordureHauteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonNormale
    Global CouleurBordureBasBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonNormale
    Global CouleurBordureGaucheBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonNormale
    Global CouleurBordureDroiteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonNormale
    Global TailleDesBorduresBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonNormale
    
    Global CouleurDegrader1InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonNormale
    Global CouleurDegrader2InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonNormale
    Global OptionDegraderInterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonNormale
    Global ActiverDegraderBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonNormale
    
    Global XTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XTexteBoutonNormale
    Global YTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YTexteBoutonNormale
    Global PocileTexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonNormale
    Global TailleTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonNormale
    Global CouleurTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonNormale
    Global CouleurFondTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonNormale
    Global TexteTrensparentBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonNormale
    Global OptionTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonNormale
    Global NumeroPoliceBoutonTemps = Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonNormale
    
    Global ImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonNormale
    Global XImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XImageBoutonNormale
    Global YImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YImageBoutonNormale
    
  ElseIf LCase(NomEtasImage$) = "survoler"
    Global TexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ TexteBoutonSurvoler
    
    Global CouleurBordureHauteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonSurvoler
    Global CouleurBordureBasBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonSurvoler
    Global CouleurBordureGaucheBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonSurvoler
    Global CouleurBordureDroiteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonSurvoler
    Global TailleDesBorduresBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonSurvoler
    
    Global CouleurDegrader1InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonSurvoler
    Global CouleurDegrader2InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonSurvoler
    Global OptionDegraderInterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonSurvoler
    Global ActiverDegraderBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonSurvoler
    
    Global XTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XTexteBoutonSurvoler
    Global YTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YTexteBoutonSurvoler
    Global PocileTexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonSurvoler
    Global TailleTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonSurvoler
    Global CouleurTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonSurvoler
    Global CouleurFondTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonSurvoler
    Global TexteTrensparentBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonSurvoler
    Global OptionTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonSurvoler
    Global NumeroPoliceBoutonTemps = Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonSurvoler
    
    Global ImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonSurvoler
    Global XImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XImageBoutonSurvoler
    Global YImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YImageBoutonSurvoler
    
  ElseIf LCase(NomEtasImage$) = "appuyer"
    Global TexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ TexteBoutonAppuyer
    
    Global CouleurBordureHauteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonAppuyer
    Global CouleurBordureBasBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonAppuyer
    Global CouleurBordureGaucheBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonAppuyer
    Global CouleurBordureDroiteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonAppuyer
    Global TailleDesBorduresBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonAppuyer
    
    Global CouleurDegrader1InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonAppuyer
    Global CouleurDegrader2InterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonAppuyer
    Global OptionDegraderInterieurBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonAppuyer
    Global ActiverDegraderBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonAppuyer
    
    Global XTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XTexteBoutonAppuyer
    Global YTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YTexteBoutonAppuyer
    Global PocileTexteBoutonTemps$ = Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonAppuyer
    Global TailleTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonAppuyer
    Global CouleurTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonAppuyer
    Global CouleurFondTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonAppuyer
    Global TexteTrensparentBoutonTemps = Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonAppuyer
    Global OptionTexteBoutonTemps = Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonAppuyer
    Global NumeroPoliceBoutonTemps = Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonAppuyer
    
    Global ImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonAppuyer
    Global XImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ XImageBoutonAppuyer
    Global YImageBoutonTemps = Bouton.Caracteristiques(BoutonID) \ YImageBoutonAppuyer
    
  EndIf
  
EndMacro

; Ici je recupère toutes les données du bouton
Macro EnregistrementDonnerBouton()
  
  If LCase(NomEtasImage$) = "normale"
    
    Bouton.Caracteristiques(BoutonID) \ TexteBoutonNormale = TexteBoutonTemps$
    
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonNormale = CouleurBordureHauteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonNormale = CouleurBordureBasBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonNormale = CouleurBordureGaucheBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonNormale = CouleurBordureDroiteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonNormale = TailleDesBorduresBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonNormale = CouleurDegrader1InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonNormale = CouleurDegrader2InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonNormale = OptionDegraderInterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonNormale = ActiverDegraderBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonNormale = XTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonNormale = YTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonNormale = PocileTexteBoutonTemps$
    Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonNormale = TailleTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonNormale = CouleurTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonNormale = CouleurFondTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonNormale = TexteTrensparentBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonNormale = OptionTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonNormale = NumeroPoliceBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonNormale = ImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ XImageBoutonNormale = XImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YImageBoutonNormale = YImageBoutonTemps
    
  ElseIf LCase(NomEtasImage$) = "survoler"
    Bouton.Caracteristiques(BoutonID) \ TexteBoutonSurvoler = TexteBoutonTemps$
    
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonSurvoler = CouleurBordureHauteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonSurvoler = CouleurBordureBasBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonSurvoler = CouleurBordureGaucheBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonSurvoler = CouleurBordureDroiteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonSurvoler = TailleDesBorduresBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonSurvoler = CouleurDegrader1InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonSurvoler = CouleurDegrader2InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonSurvoler = OptionDegraderInterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonSurvoler = ActiverDegraderBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonSurvoler = XTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonSurvoler = YTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonSurvoler = PocileTexteBoutonTemps$
    Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonSurvoler = TailleTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonSurvoler = CouleurTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonSurvoler = CouleurFondTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonSurvoler = TexteTrensparentBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonSurvoler = OptionTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonSurvoler = NumeroPoliceBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonSurvoler = ImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ XImageBoutonSurvoler = XImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YImageBoutonSurvoler = YImageBoutonTemps
    
  ElseIf LCase(NomEtasImage$) = "appuyer"
    Bouton.Caracteristiques(BoutonID) \ TexteBoutonAppuyer = TexteBoutonTemps$
    
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureHauteBoutonAppuyer = CouleurBordureHauteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureBasBoutonAppuyer = CouleurBordureBasBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureGaucheBoutonAppuyer = CouleurBordureGaucheBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurBordureDroiteBoutonAppuyer = CouleurBordureDroiteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TailleDesBorduresBoutonAppuyer = TailleDesBorduresBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader1InterieurBoutonAppuyer = CouleurDegrader1InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurDegrader2InterieurBoutonAppuyer = CouleurDegrader2InterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionDegraderInterieurBoutonAppuyer = OptionDegraderInterieurBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ ActiverDegraderBoutonAppuyer = ActiverDegraderBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ XTexteBoutonAppuyer = XTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YTexteBoutonAppuyer = YTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ PocileTexteBoutonAppuyer = PocileTexteBoutonTemps$
    Bouton.Caracteristiques(BoutonID) \ TailleTexteBoutonAppuyer = TailleTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurTexteBoutonAppuyer = CouleurTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ CouleurFondTexteBoutonAppuyer = CouleurFondTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ TexteTrensparentBoutonAppuyer = TexteTrensparentBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ OptionTexteBoutonAppuyer = OptionTexteBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ NumeroPoliceBoutonAppuyer = NumeroPoliceBoutonTemps
    
    Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonAppuyer = ImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ XImageBoutonAppuyer = XImageBoutonTemps
    Bouton.Caracteristiques(BoutonID) \ YImageBoutonAppuyer = YImageBoutonTemps
    
  EndIf
  
EndMacro

; Là ont va colorer et choisir la taille des bordures du bouton
; Si le BoutonID n'est pas initialiser (crée) rien ne se passera 
Procedure BordureBoutonGadget(BoutonID, NomEtasImage$, CouleurBordureHaute, CouleurBordureBas, CouleurBordureGauche, CouleurBordureDroite, TailleDesBordures)
  ; Ont pourais choisir individuellement la taille des bordures mais ça va pas être façile !
  
  BoutonID = VerificationValeurVariable(BoutonID)
  CouleurBordureHaute = VerificationValeurVariable(CouleurBordureHaute)
  CouleurBordureBas = VerificationValeurVariable(CouleurBordureBas)
  CouleurBordureGauche = VerificationValeurVariable(CouleurBordureGauche)
  CouleurBordureDroite = VerificationValeurVariable(CouleurBordureDroite)
  
  Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
  Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
  
  ; Les bordures ne peuvent pas être mise à zéro, pour les enlever, il faut choisir l'option #BG_BorderLess pour le bouton
  If VerificationValeurVariable(TailleDesBordures) = 0
    TailleDesBordures = 1
  EndIf
  
  RecuperationDonnerBouton()
  
  ; Si le bouton existe bien et que l'image de l'états du bouton existe également
  If IsGadget(BoutonID)
    
  FontID = LoadFont(#PB_Any, PocileTexteBoutonTemps$, TailleTexteBoutonTemps, OptionTexteBoutonTemps)
    
    ImageEtasBouton = CreateImage(#PB_Any, Largeur, Hauteur)
    
    StartDrawing(ImageOutput(ImageEtasBouton))
    
    If ActiverDegraderBoutonTemps = 1
      
      DrawingMode(#PB_2DDrawing_Gradient)
      
    If OptionDegraderInterieurBoutonTemps = 0
      ; degrader en horizontale
      LinearGradient(1, 1, Largeur, 1) 
      GradientColor(1, CouleurDegrader1InterieurBoutonTemps)
      
      LinearGradient(Largeur, 1, 1, 1)
      GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
      
    ElseIf OptionDegraderInterieurBoutonTemps = 1
      ; degrader en verticalle
      LinearGradient(1, Largeur, 1, 1) 
      GradientColor(0.6, CouleurDegrader1InterieurBoutonTemps)
      
      LinearGradient(1, 1, 1, Largeur)
      GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
    EndIf
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
  Else
    If OptionDegraderInterieurBoutonTemps = 0
      Box(0, 0, Largeur / 2, Hauteur, CouleurDegrader1InterieurBoutonTemps)
      Box(Largeur / 2, 0, Largeur / 2, Hauteur, CouleurDegrader2)
    ElseIf OptionDegraderInterieurBoutonTemps = 1
      Box(0, 0, Largeur, Hauteur / 2, CouleurDegrader1InterieurBoutonTemps)
      Box(0, Hauteur / 2, Largeur, Hauteur, CouleurDegrader2)
    EndIf
    
  EndIf
  
    Box(0, 0, Largeur - TailleDesBordures, TailleDesBordures, CouleurBordureHaute)
    Box(Largeur - TailleDesBordures, 0, TailleDesBordures, Hauteur - TailleDesBordures, CouleurBordureDroite)
    Box(TailleDesBordures, Hauteur - TailleDesBordures, Largeur - TailleDesBordures, TailleDesBordures, CouleurBordureBas)
    Box(0, TailleDesBordures, TailleDesBordures, Hauteur - TailleDesBordures, CouleurBordureGauche)
  
    If IsFont(NumeroPoliceBoutonTemps)
      DrawingFont(FontID(FontID))
    Else
      DrawingFont(FontID(#PB_Default))
    EndIf
    
    If CouleurDegrader1InterieurBoutonTemps <> CouleurDegrader2InterieurBoutonTemps
      DrawingMode(#PB_2DDrawing_Transparent)
    Else
      DrawingMode(0)
    EndIf
    
    If TexteTrensparentBoutonTemps = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    If IsImage(ImageBoutonTemps)
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBoutonTemps), XImageBoutonTemps, YImageBoutonTemps, ImageWidth(ImageBoutonTemps), ImageHeight(ImageBoutonTemps))
      DrawingMode(0)
      
    EndIf
    
    DrawText(XTexteBoutonTemps, YTexteBoutonTemps, TexteBoutonTemps$, CouleurTexteBoutonTemps, CouleurFondTexteBoutonTemps)

    StopDrawing()
    
    If LCase(NomEtasImage$) = "normale"
      Bouton.Caracteristiques(BoutonID) \ ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survoler"
      Bouton.Caracteristiques(BoutonID) \ ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyer"
      Bouton.Caracteristiques(BoutonID) \ ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    CouleurBordureHauteBoutonTemps = CouleurBordureHaute
    CouleurBordureBasBoutonTemps = CouleurBordureBas
    CouleurBordureGaucheBoutonTemps = CouleurBordureGauche
    CouleurBordureDroiteBoutonTemps = CouleurBordureDroite
    TailleDesBorduresBoutonTemps = TailleDesBordures
    
    EnregistrementDonnerBouton()
    
  EndIf
  
EndProcedure

; Ici on va choisir la couleur du bouton interne
; Si le BoutonID n'est pas initialiser (crée) rien ne se passera 
Procedure InterieurBoutonGadget(BoutonID, NomEtasImage$, CouleurDegrader1, CouleurDegrader2, ActiverDegrader, OptionDegrader, TexteTransparent)

  ; Option pourra être:
  
  ; 0 = Le dégrader est horizontale, de gauche à droite
  ; 1 = Le dégrader est verticale, de bas en haut
  
  ; On pourais le faire aussi pour les bordures mais ça va pas être façile !
  
  BoutonID = VerificationValeurVariable(BoutonID)
  CouleurDegrader1 = VerificationValeurVariable(CouleurDegrader1)
  CouleurDegrader2 = VerificationValeurVariable(CouleurDegrader2)
  
  If VerificationValeurVariable(OptionDegrader) > 1
    OptionDegrader = 1
  EndIf
  
  If VerificationValeurVariable(ActiverDegrader) > 1
    ActiverDegrader = 1
  EndIf
  
  If VerificationValeurVariable(TexteTransparent) > 1
    TexteTransparent = 1
  EndIf
  
  Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
  Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
  
  RecuperationDonnerBouton()
  
  ; Si le bouton existe bien et que l'image de l'états du bouton existe également
  If IsGadget(BoutonID)
    
    FontID = LoadFont(#PB_Any, PocileTexteBoutonTemps$, TailleTexteBoutonTemps, OptionTexteBoutonTemps)
    
    ImageEtasBouton = CreateImage(#PB_Any, Largeur, Hauteur)
    
    StartDrawing(ImageOutput(ImageEtasBouton))
    
    If ActiverDegrader = 1
      
      DrawingMode(#PB_2DDrawing_Gradient)
      
    If OptionDegrader = 0
      ; degrader en horizontale
      LinearGradient(1, 1, Largeur, 1) 
      GradientColor(1, CouleurDegrader1)
      
      LinearGradient(Largeur, 1, 1, 1)
      GradientColor(0, CouleurDegrader2)
      
    ElseIf OptionDegrader = 1
      ; degrader en verticalle
      LinearGradient(1, Largeur, 1, 1) 
      GradientColor(0.6, CouleurDegrader1)
      
      LinearGradient(1, 1, 1, Largeur)
      GradientColor(0, CouleurDegrader2)
    EndIf
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
  Else
    If OptionDegrader = 0
      Box(0, 0, Largeur / 2, Hauteur, CouleurDegrader1)
      Box(Largeur / 2, 0, Largeur / 2, Hauteur, CouleurDegrader2)
    ElseIf OptionDegrader = 1
      Box(0, 0, Largeur, Hauteur / 2, CouleurDegrader1)
      Box(0, Hauteur / 2, Largeur, Hauteur, CouleurDegrader2)
    EndIf
    
  EndIf
  
    Box(0, 0, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureHauteBoutonTemps)
    Box(Largeur - TailleDesBorduresBoutonTemps, 0, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureDroiteBoutonTemps)
    Box(TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureBasBoutonTemps)
    Box(0, TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureGaucheBoutonTemps)
  
    If IsFont(NumeroPoliceBoutonTemps)
      DrawingFont(FontID(FontID))
    Else
      DrawingFont(FontID(#PB_Default))
    EndIf
    
    If IsImage(ImageBoutonTemps)
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBoutonTemps), XImageBoutonTemps, YImageBoutonTemps, ImageWidth(ImageBoutonTemps), ImageHeight(ImageBoutonTemps))
      DrawingMode(0)
      
    EndIf
    
    If CouleurDegrader1 <> CouleurDegrader2
      DrawingMode(#PB_2DDrawing_Transparent)
    Else
      DrawingMode(0)
    EndIf
    
    If TexteTransparent = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    DrawText(XTexteBoutonTemps, YTexteBoutonTemps, TexteBoutonTemps$, CouleurTexteBoutonTemps, CouleurFondTexteBoutonTemps)

    StopDrawing()
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

Partie 3:

Code : Tout sélectionner

    
    If LCase(NomEtasImage$) = "normale"
      Bouton.Caracteristiques(BoutonID) \ ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survoler"
      Bouton.Caracteristiques(BoutonID) \ ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyer"
      Bouton.Caracteristiques(BoutonID) \ ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    CouleurDegrader1InterieurBoutonTemps = CouleurDegrader1
    CouleurDegrader2InterieurBoutonTemps = CouleurDegrader2
    ActiverDegraderBoutonTemps = ActiverDegrader
    OptionDegraderInterieurBoutonTemps = OptionDegrader
    TexteTrensparentBoutonTemps = TexteTransparent
    
    EnregistrementDonnerBouton()
    
  EndIf
  
EndProcedure

; Ici on va personnaliser notre texte sur le bouton
; Si le BoutonID n'est pas initialiser (crée) rien ne se passera 
Procedure TexteBoutonGadget(BoutonID, NomEtasImage$, XTexte, YTexte, Pocile$, Taille, CouleurTexte, CouleurFondTexte, Texte$, OptionTexte)
  
  ; X et Y serviron à recadrer notre bouton comme on le souhaite en plus des otpions de cadrage tu texte
  
  
  ; Option pourra être:
  
  ; #BG_Texte_Centrage_Auto = Le texte serra automatiquement centrer suivent les options ou simplement centrer au millieux du bouton si juste cette option est définie
  ; #BG_Texte_Gauche = Le texte sera mis à gauche
  ; #BG_Texte_Droite = Le texte sera mis à droite
  ; #BG_Texte_Haut = Le texte sera mis en haut
  ; #BG_Texte_Bas = Le texte sera mis en bas
  
  ; #BG_Texte_Gras = Le texte sera en gras
  ; #BG_Texte_Italique = Le texte sera en italique
  ; #BG_Texte_Soulignier = Le texte sera soulignier
  ; #BG_Texte_Barrer = Le texte sera en barrer
  
  ; Ont pourais aussi mètre d'autre options comme le pivotement du texte, un dégrader pour le texte suivent l'option choisie mais ça va pas être façile !
  
  BoutonID = VerificationValeurVariable(BoutonID)
  XTexte = VerificationValeurVariable(XTexte)
  YTexte = VerificationValeurVariable(YTexte)
  Taille = VerificationValeurVariable(Taille)
  CouleurTexte = VerificationValeurVariable(CouleurTexte)
  CouleurFondTexte = VerificationValeurVariable(CouleurFondTexte)
  
  If OptionTexte < -1
    OptionTexte = -1
  ElseIf OptionTexte <> -1
    OptionTexte = VerificationValeurVariable(OptionTexte)
  EndIf
  
  Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
  Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
  
  RecuperationDonnerBouton()
  
  OptionTexteBoutonTemps = 0
  
  ; Si le bouton existe bien et que l'image de l'états du bouton existe également
  If IsGadget(BoutonID)
    
    If OptionTexte = -1
      FontID = LoadFont(#PB_Any, Pocile$, Taille, #PB_Font_Bold | #PB_Font_Italic | #PB_Font_Underline | #PB_Font_StrikeOut | #PB_Font_HighQuality)
      OptionTexte = #PB_Font_Bold | #PB_Font_Italic | #PB_Font_Underline | #PB_Font_StrikeOut | #PB_Font_HighQuality
    Else
      FontID = LoadFont(#PB_Any, Pocile$, Taille, OptionTexte | #PB_Font_HighQuality)
      OptionTexte & #PB_Font_HighQuality
    EndIf
    
    ImageEtasBouton = CreateImage(#PB_Any, Largeur, Hauteur)
    
    StartDrawing(ImageOutput(ImageEtasBouton))
    
    If ActiverDegraderBoutonTemps = 1
      
      DrawingMode(#PB_2DDrawing_Gradient)
      
      If OptionDegraderInterieurBoutonTemps = 0
        ; degrader en horizontale
        LinearGradient(1, 1, Largeur, 1) 
        GradientColor(1, CouleurDegrader1InterieurBoutonTemps)
        
        LinearGradient(Largeur, 1, 1, 1)
        GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
        
      ElseIf OptionDegraderInterieurBoutonTemps = 1
        ; degrader en verticalle
        LinearGradient(1, Largeur, 1, 1) 
        GradientColor(0.6, CouleurDegrader1InterieurBoutonTemps)
        
        LinearGradient(1, 1, 1, Largeur)
        GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
      EndIf
      
      Box(0, 0, Largeur, Hauteur, 0)
      
      DrawingMode(0)
      
    Else
      If OptionDegraderInterieurBoutonTemps = 0
        Box(0, 0, Largeur / 2, Hauteur, CouleurDegrader1InterieurBoutonTemps)
        Box(Largeur / 2, 0, Largeur / 2, Hauteur, CouleurDegrader2InterieurBoutonTemps)
      ElseIf OptionDegraderInterieurBoutonTemps = 1
        Box(0, 0, Largeur, Hauteur / 2, CouleurDegrader1InterieurBoutonTemps)
        Box(0, Hauteur / 2, Largeur, Hauteur, CouleurDegrader2InterieurBoutonTemps)
      EndIf
      
    EndIf
    
      Box(0, 0, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureHauteBoutonTemps)
      Box(Largeur - TailleDesBorduresBoutonTemps, 0, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureDroiteBoutonTemps)
      Box(TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureBasBoutonTemps)
      Box(0, TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureGaucheBoutonTemps)
    
    If IsFont(NumeroPoliceBoutonTemps)
      DrawingFont(FontID(FontID))
    Else
      DrawingFont(FontID(#PB_Default))
    EndIf
    
    If IsImage(ImageBoutonTemps)
      
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      DrawImage(ImageID(ImageBoutonTemps), XImageBoutonTemps, YImageBoutonTemps, ImageWidth(ImageBoutonTemps), ImageHeight(ImageBoutonTemps))
      DrawingMode(0)
      
    EndIf
    
    If XTexte = 0
      PositionTexteX = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 1, "|"))
    Else
      PositionTexteX = XTexte
    EndIf
    
    If YTexte = 0
      PositionTexteY = Val(StringField(CentreTexteSurMonBouton(BoutonID, Texte$), 2, "|"))
    Else
      PositionTexteY = YTexte
    EndIf
    
    If CouleurDegrader1InterieurBoutonTemps <> CouleurDegrader2InterieurBoutonTemps
      DrawingMode(#PB_2DDrawing_Transparent)
    Else
      DrawingMode(0)
    EndIf
    
    If TexteTrensparentBoutonTemps = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    If LCase(NomEtasImage$) = "normale" Or LCase(NomEtasImage$) = "survoler"
      DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    ElseIf LCase(NomEtasImage$) = "appuyer"
      PositionTexteX + 1
      PositionTexteY + 1
      DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    EndIf
    
    StopDrawing()
    
    If LCase(NomEtasImage$) = "normale"
      Bouton.Caracteristiques(BoutonID) \ ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survoler"
      
      Bouton.Caracteristiques(BoutonID) \ ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyer"
      Bouton.Caracteristiques(BoutonID) \ ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    PocileTexteBoutonTemps$ = Pocile$
    TailleTexteBoutonTemps = Taille
    CouleurTexteBoutonTemps = CouleurTexte
    CouleurFondTexteBoutonTemps = CouleurFondTexte
    TexteBoutonTemps$ = Texte$
    OptionTexteBoutonTemps = OptionTexte
    NumeroPoliceBoutonTemps = FontID
    XTexteBoutonTemps = PositionTexteX
    YTexteBoutonTemps = PositionTexteY
    
    EnregistrementDonnerBouton()
    
  EndIf
  
EndProcedure

Procedure ImageBoutonGadget(BoutonID, NomEtasImage$, ImageBouton, XImage, YImage)
  
  BoutonID = VerificationValeurVariable(BoutonID)
  ImageBouton = VerificationValeurVariable(ImageBouton)
  XImage = VerificationValeurVariable(XImage)
  YImage = VerificationValeurVariable(YImage)
  
  Largeur = Bouton.Caracteristiques(BoutonID) \ Largeur
  Hauteur = Bouton.Caracteristiques(BoutonID) \ Hauteur
  
  RecuperationDonnerBouton()
  
  ; Si le bouton existe bien et que l'image de l'états du bouton existe également
  If IsGadget(BoutonID)
    
    FontID = LoadFont(#PB_Any, PocileTexteBoutonTemps$, TailleTexteBoutonTemps, OptionTexteBoutonTemps)
    
    ImageEtasBouton = CreateImage(#PB_Any, Largeur, Hauteur)
    
    StartDrawing(ImageOutput(ImageEtasBouton))
    
    If ActiverDegraderBoutonTemps = 1
      
      DrawingMode(#PB_2DDrawing_Gradient)
      
    If OptionDegraderInterieurBoutonTemps = 0
      ; degrader en horizontale
      LinearGradient(1, 1, Largeur, 1) 
      GradientColor(1, CouleurDegrader1InterieurBoutonTemps)
      
      LinearGradient(Largeur, 1, 1, 1)
      GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
      
    ElseIf OptionDegraderInterieurBoutonTemps = 1
      ; degrader en verticalle
      LinearGradient(1, Largeur, 1, 1) 
      GradientColor(0.6, CouleurDegrader1InterieurBoutonTemps)
      
      LinearGradient(1, 1, 1, Largeur)
      GradientColor(0, CouleurDegrader2InterieurBoutonTemps)
    EndIf
    
    Box(0, 0, Largeur, Hauteur, 0)
    
    DrawingMode(0)
    
  Else
    If OptionDegraderInterieurBoutonTemps = 0
      Box(0, 0, Largeur / 2, Hauteur, CouleurDegrader1InterieurBoutonTemps)
      Box(Largeur / 2, 0, Largeur / 2, Hauteur, CouleurDegrader2InterieurBoutonTemps)
    ElseIf OptionDegraderInterieurBoutonTemps = 1
      Box(0, 0, Largeur, Hauteur / 2, CouleurDegrader1InterieurBoutonTemps)
      Box(0, Hauteur / 2, Largeur, Hauteur, CouleurDegrader2InterieurBoutonTemps)
    EndIf
    
  EndIf
  
    Box(0, 0, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureHauteBoutonTemps)
    Box(Largeur - TailleDesBorduresBoutonTemps, 0, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureDroiteBoutonTemps)
    Box(TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, Largeur - TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, CouleurBordureBasBoutonTemps)
    Box(0, TailleDesBorduresBoutonTemps, TailleDesBorduresBoutonTemps, Hauteur - TailleDesBorduresBoutonTemps, CouleurBordureGaucheBoutonTemps)
  
    If IsFont(NumeroPoliceBoutonTemps)
      DrawingFont(FontID(FontID))
    Else
      DrawingFont(FontID(#PB_Default))
    EndIf
    
    If CouleurDegrader1InterieurBoutonTemps <> CouleurDegrader2InterieurBoutonTemps
      DrawingMode(#PB_2DDrawing_Transparent)
    Else
      DrawingMode(0)
    EndIf
    
    If TexteTrensparentBoutonTemps = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    If XImage = 0
      PositionImageX = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 1, "|")) + XImage
    Else
      PositionImageX = XImage
    EndIf
    
    If YImage = 0
      PositionImageY = Val(StringField(CentreImageSurMonBouton(BoutonID, ImageBouton), 2, "|")) + YImage
    Else
      PositionImageY = YImage
    EndIf
    
    If IsImage(ImageBouton)
      DrawingMode(#PB_2DDrawing_AlphaBlend)
      If LCase(NomEtasImage$) = "normale" Or LCase(NomEtasImage$) = "survoler"
        DrawImage(ImageID(ImageBouton), PositionImageX, PositionImageY, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      ElseIf LCase(NomEtasImage$) = "appuyer"
        DrawImage(ImageID(ImageBouton), PositionImageX + 1, PositionImageY + 1, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      EndIf
      DrawingMode(0)
      
      If LCase(NomEtasImage$) = "normale"
        Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonNormale = ImageBouton
        Bouton.Caracteristiques(BoutonID) \ XImageBoutonNormale = PositionImageX
        Bouton.Caracteristiques(BoutonID) \ YImageBoutonNormale = PositionImageY
        
      ElseIf LCase(NomEtasImage$) = "survoler"
        Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonSurvoler = ImageBouton
        Bouton.Caracteristiques(BoutonID) \ XImageBoutonSurvoler = PositionImageX
        Bouton.Caracteristiques(BoutonID) \ YImageBoutonSurvoler = PositionImageY
        
      ElseIf LCase(NomEtasImage$) = "appuyer"
        Bouton.Caracteristiques(BoutonID) \ ImageBoutonBoutonAppuyer = ImageBouton
        Bouton.Caracteristiques(BoutonID) \ XImageBoutonAppuyer = PositionImageX
        Bouton.Caracteristiques(BoutonID) \ YImageBoutonAppuyer = PositionImageY
        
      EndIf
      
    EndIf
    
    DrawText(XTexteBoutonTemps, YTexteBoutonTemps, TexteBoutonTemps$, CouleurTexteBoutonTemps, CouleurFondTexteBoutonTemps)
    
    StopDrawing()
    
    If LCase(NomEtasImage$) = "normale"
      Bouton.Caracteristiques(BoutonID) \ ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survoler"
      Bouton.Caracteristiques(BoutonID) \ ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyer"
      Bouton.Caracteristiques(BoutonID) \ ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    EnregistrementDonnerBouton()
    
  EndIf
  
EndProcedure

Procedure.l EventBouton(EventGadget, EventType)
  
  Select EventType
      
    Case #PB_EventType_MouseEnter
      If Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 0
        Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton.Caracteristiques(EventGadget) \ ImageSurvoler), 0, 0)
        StopDrawing()
      ElseIf Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 1
        Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageAppuyer
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton.Caracteristiques(EventGadget) \ ImageAppuyer), 0, 0)
        StopDrawing()
      EndIf
      
    Case #PB_EventType_MouseLeave
      Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(EventGadget))
      DrawImage(ImageID(Bouton.Caracteristiques(EventGadget) \ ImageNormale), 0, 0)
      StopDrawing()
      
    Case #PB_EventType_LeftButtonDown
      SauvegardeBoutonAppuyer = EventGadget
      SetGadgetAttribute(EventGadget, #PB_Canvas_Clip , 0) ; Enlève le confinement (clippage).
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(EventGadget))
      DrawImage(ImageID(Bouton.Caracteristiques(EventGadget) \ ImageAppuyer), 0, 0)
      StopDrawing()
      Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageAppuyer
      Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 1
      
    Case #PB_EventType_LeftButtonUp
      If Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageAppuyer And Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 1
        Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
        Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 0
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton.Caracteristiques(EventGadget) \ ImageSurvoler), 0, 0)
        StopDrawing()
        ProcedureReturn 1
      EndIf
      
      ForEach EnumerationBouton()
        ; Je reset tous les boutons
        Bouton.Caracteristiques(EnumerationBouton()) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
        Bouton.Caracteristiques(EnumerationBouton()) \ EtasBoutonGaucheSouris = 0
      Next
      
  EndSelect
  
EndProcedure


;}
; 
Procedure ThreadDecoupageImage(Image)
  DecoupageImage(Image, RenvoyerCouleurDegrader1InterieurBoutonNormale(#BoutonImageCouleurArrierPlantSprite), RenvoyerCouleurDegrader1InterieurBoutonNormale(#BoutonImageCouleurFeuille), RenvoyerCouleurDegrader1InterieurBoutonNormale(#BoutonImageCouleurArrierPlantSprite))
EndProcedure

Enumeration 1
  #Fenetre
EndEnumeration

Procedure InterfaceDecoupageImage(CouleurFenetre, CouleurBordure, CouleurTexteInfo) 
  
    If OpenWindow(#Fenetre, 327, 177, 500, 345, "Découpeur d'image 1.02 crée par: Dieppedalle David",  #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar)
      SetWindowColor(#Fenetre, CouleurFenetre)
      
      TextGadget(#TexeInfoCouleurArrierPlantSprite, 65, 325, 150, 18, "Couleur de l'arrier plant du sprite")
      SetGadgetColor(#TexeInfoCouleurArrierPlantSprite, #PB_Gadget_FrontColor, CouleurTexteInfo)
      SetGadgetColor(#TexeInfoCouleurArrierPlantSprite, #PB_Gadget_BackColor, CouleurFenetre)
      
      TextGadget(#TexeInfoCouleurFeuille, 275, 325, 100, 18, "Couleur de la Feuille")
      SetGadgetColor(#TexeInfoCouleurFeuille, #PB_Gadget_FrontColor, CouleurTexteInfo)
      SetGadgetColor(#TexeInfoCouleurFeuille, #PB_Gadget_BackColor, CouleurFenetre)
      
      ScrollAreaGadget(#AreaGadget, 5, 5, 490, 310, 490, 310, 100, #PB_ScrollArea_BorderLess)
      CanvasGadget(#CanvasGadget, 0, 0, 490, 310, #PB_Canvas_ClipMouse | #PB_Canvas_Keyboard)
      CurseurPersonnaliser("Pipette.png")
      
      GadgetToolTip(#CanvasGadget, "Cliquez centre pour charger une image")
      CloseGadgetList()
      
      ImageBordureHauteCanva = CreateImage(#PB_Any, GadgetWidth(#AreaGadget) + 4, 2)
      ImageBordureBasCanva = CreateImage(#PB_Any, GadgetWidth(#AreaGadget) + 4, 2)
      ImageBordureGaucheCanva = CreateImage(#PB_Any, 2, GadgetHeight(#AreaGadget) + 2)
      ImageBordureDroiteCanva = CreateImage(#PB_Any, 2, GadgetHeight(#AreaGadget) + 2)
      
      StartDrawing(ImageOutput(ImageBordureHauteCanva))
      Plot(0, 1, CouleurBordure)
      Plot(GadgetWidth(#AreaGadget) + 4 - 1, 1, CouleurBordure)
      Line(0, 0, GadgetWidth(#AreaGadget) + 4, 1, CouleurBordure)
      Line(1, 1, GadgetWidth(#AreaGadget) + 2, 1, RGB(255, 255, 255))
      StopDrawing()
      
      StartDrawing(ImageOutput(ImageBordureBasCanva))
      Line(0, 1, GadgetWidth(#AreaGadget) + 4, 1, CouleurBordure)
      Line(0, 0, GadgetWidth(#AreaGadget) + 4, 1, RGB(255, 255, 255))
      Plot(0, 0, CouleurBordure)
      Plot(GadgetWidth(#AreaGadget) + 4 - 1, 0, CouleurBordure)
      StopDrawing()
      
      StartDrawing(ImageOutput(ImageBordureGaucheCanva))
      Line(0, 0, 1, GadgetHeight(#AreaGadget) + 4, CouleurBordure)
      Line(1, 0, 1, GadgetHeight(#AreaGadget) + 4, RGB(255, 255, 255))
      StopDrawing()
      
      StartDrawing(ImageOutput(ImageBordureDroiteCanva))
      Line(0, 0, 1, GadgetHeight(#AreaGadget) + 4, RGB(255, 255, 255))
      Line(1, 0, 1, GadgetHeight(#AreaGadget) + 4, CouleurBordure)
      StopDrawing()
      
      ImageGadget(#PB_Any, GadgetX(#AreaGadget) - 2, GadgetY(#AreaGadget) - 2, GadgetWidth(#AreaGadget) + 4, 2, ImageID(ImageBordureHauteCanva))
      ImageGadget(#PB_Any, GadgetX(#AreaGadget) - 2, GadgetY(#AreaGadget) + GadgetHeight(#AreaGadget), GadgetWidth(#AreaGadget) + 4, 2, ImageID(ImageBordureBasCanva))
      ImageGadget(#PB_Any, GadgetX(#AreaGadget) - 2, GadgetY(#AreaGadget), 2, GadgetHeight(#AreaGadget) + 3, ImageID(ImageBordureGaucheCanva))
      ImageGadget(#PB_Any, GadgetX(#AreaGadget) + GadgetWidth(#AreaGadget), GadgetY(#AreaGadget), 2, GadgetHeight(#AreaGadget) + 3, ImageID(ImageBordureDroiteCanva))
      
      BoutonGadget(#BoutonDecouper, 400, 320, 58, 22, "Découper", 0, 0, RGB(0, 0, 255), RGB(240, 240, 240), 7, 0, RGB(255, 198, 0), #PB_Cursor_Hand, 0, 0, 0, 0)
      GadgetToolTip(#BoutonDecouper, "Ceci va lancer la découpe automatique des sprites dans l'image")
      
      BoutonGadget(#BoutonImageCouleurArrierPlantSprite, 40, 321, 20, 20, "", 0, 0, 0, 0, 0, 0, RGB(240, 240, 240), #PB_Cursor_Hand, ImageCouleurArrierPlantSprite, 0, 0, 0)
      GadgetToolTip(#BoutonImageCouleurArrierPlantSprite, "Ceci est la couleur de l'arrière plant de vos petits sprites dans l'image, Cliquez gauche sur l'éditeur d'image pour la capturer")
      
      BoutonGadget(#BoutonImageCouleurFeuille, 250, 321, 20, 20, "", 0, 0, 0, 0, 0, 0, RGB(240, 240, 240), #PB_Cursor_Hand, ImageCouleurFeuille, 0, 0, 0)
      GadgetToolTip(#BoutonImageCouleurFeuille, "Ceci est la couleur de l'image qui contient vos petits sprites, Cliquez droit sur l'éditeur d'image pour la capturer")
      
      InterieurBoutonGadget(#BoutonDecouper, "Normale", RGB(150, 150, 150), RGB(255, 255, 255), 1, 1, 1)
      InterieurBoutonGadget(#BoutonDecouper, "Survoler", RGB(150, 150, 150), RGB(255, 255, 255), 1, 1, 1)
      InterieurBoutonGadget(#BoutonDecouper, "Appuyer", RGB(150, 150, 150), RGB(255, 255, 255), 1, 1, 1)
      
      TexteBoutonGadget(#BoutonDecouper, "Survoler", 0, 0, "Arial", 7, RGB(0, 0, 255), 0, "Découper", #PB_Font_Underline | #PB_Font_Bold)
      TexteBoutonGadget(#BoutonDecouper, "Appuyer", 0, 0, "Arial", 7, RGB(0, 0, 255), 0, "Découper", #PB_Font_Underline | #PB_Font_Bold)
      
      Repeat ; Départ des évènements de boucle
        
        Event = WaitWindowEvent(1) ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la fenêtre
        EventWindow = EventWindow() ; La fenêtre où l'évènement c'est produit
        EventGadget = EventGadget() ; Pour savoir sur quel gadget c'est produis l'évènement
        EventMenu = EventMenu() ; Pour savoir sur quel menue c'est produis l'évènement
        EventType = EventType() ; Le type d'évènement qui c'est produis sur le gadget
        
        Select Event 
          
          Case #PB_Event_Gadget
            
            Select EventGadget
                
              Case #BoutonDecouper
                If EventBouton(EventGadget, EventType)
                  
                  CouleurBoutonArrierPlantSprite = RenvoyerCouleurDegrader1InterieurBoutonNormale(#BoutonImageCouleurArrierPlantSprite)
                  CouleurBoutonFeuille = RenvoyerCouleurDegrader1InterieurBoutonNormale(#BoutonImageCouleurFeuille)
                  
                  ThreadDecoupageImage = CreateThread(@ThreadDecoupageImage(), SauvegargeImage)
                  WaitThread(ThreadDecoupageImage)
                  
                EndIf
                
              Case #BoutonImageCouleurArrierPlantSprite
                If EventBouton(EventGadget, EventType)
                  
                EndIf
                
              Case #BoutonImageCouleurFeuille
                If EventBouton(EventGadget, EventType)
                  
                EndIf
                
              Case #CanvasGadget
               
                If EventType = #PB_EventType_LeftButtonUp
                  Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
                  Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 0
                  
                  ForEach EnumerationBouton()
                    ; Je reset tous les boutons
                    Bouton.Caracteristiques(EnumerationBouton()) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
                    Bouton.Caracteristiques(EnumerationBouton()) \ EtasBoutonGaucheSouris = 0
                  Next
                EndIf
                
                Select EventType
                    
                  Case #PB_EventType_LeftDoubleClick ; Double clique gauche
                    
                  Case #PB_EventType_LeftButtonDown ; Clique gauche
                    SetGadgetAttribute(EventGadget, #PB_Canvas_Clip , 0) ; Enlève le confinement (clippage).
                    If IsImage(SauvegargeImage)
                      MouseX = GetGadgetAttribute(#CanvasGadget, #PB_Canvas_MouseX)
                      MouseY = GetGadgetAttribute(#CanvasGadget, #PB_Canvas_MouseY)
                      
                      StartDrawing(ImageOutput(SauvegargeImage))
                      CouleurArrierPlantSprite = Point(MouseX, MouseY)
                      StopDrawing()
                      
                      If SauvegardeCouleurArrierPlantSprite <> CouleurArrierPlantSprite 
                      BoutonGadget(#BoutonImageCouleurArrierPlantSprite, 40, 321, 20, 20, "", 0, 0, 0, 0, 0, 0, CouleurArrierPlantSprite, #PB_Cursor_Hand, 0, 0, 0, 0)
                      GadgetToolTip(#BoutonImageCouleurArrierPlantSprite, "Ceci est la couleur de l'arrière plant de vos petits sprites dans l'image, Cliquez gauche sur l'éditeur d'image pour la capturer")
                      SauvegardeCouleurArrierPlantSprite = CouleurArrierPlantSprite
                      EndIf
                    
                    EndIf
                    
                  Case #PB_EventType_RightButtonDown ; Clique droit
                    SetGadgetAttribute(EventGadget, #PB_Canvas_Clip , 0) ; Enlève le confinement (clippage).
                    If IsImage(SauvegargeImage)
                      MouseX = GetGadgetAttribute(#CanvasGadget, #PB_Canvas_MouseX)
                      MouseY = GetGadgetAttribute(#CanvasGadget, #PB_Canvas_MouseY)
                      
                      StartDrawing(ImageOutput(SauvegargeImage))
                      CouleurFeuille = Point(MouseX, MouseY)
                      StopDrawing()
                      
                      If SauvegardeCouleurFeuille <> CouleurFeuille
                      BoutonGadget(#BoutonImageCouleurFeuille, 250, 321, 20, 20, "", 0, 0, 0, 0, 0, 0, CouleurFeuille, #PB_Cursor_Hand, 0, 0, 0, 0)
                      GadgetToolTip(#BoutonImageCouleurFeuille, "Ceci est la couleur de l'image qui contient vos petits sprites, Cliquez droit sur l'éditeur d'image pour la capturer")
                      SauvegardeCouleurFeuille = CouleurFeuille
                      EndIf
                      
                    EndIf
                    
                  Case #PB_EventType_MiddleButtonDown ; Clique centre
                    SetGadgetAttribute(EventGadget, #PB_Canvas_Clip , 0) ; Enlève le confinement (clippage).
                    
                    ImageOriginale = ChargementImage()
                    
                    If IsImage(ImageOriginale)
                      SauvegargeImage = ImageOriginale
                      SetGadgetAttribute(#AreaGadget, #PB_ScrollArea_InnerWidth, ImageWidth(SauvegargeImage))
                      SetGadgetAttribute(#AreaGadget, #PB_ScrollArea_InnerHeight, ImageHeight(SauvegargeImage))
                      ResizeGadget(#CanvasGadget, 0, 0, ImageWidth(SauvegargeImage), ImageHeight(SauvegargeImage))
                      StartDrawing(CanvasOutput(#CanvasGadget))
                      DrawImage(ImageID(SauvegargeImage), 0, 0, ImageWidth(SauvegargeImage), ImageHeight(SauvegargeImage))
                      StopDrawing()
                    EndIf
                    
                  Case #PB_EventType_MouseWheel ; Molette 
                    EtasMolette = GetGadgetAttribute(#CanvasGadget, #PB_Canvas_WheelDelta)
                    
                  Case #PB_EventType_MouseEnter
                    SetActiveGadget(#CanvasGadget)
                    
                  Case #PB_EventType_MouseLeave
                    SetActiveGadget(#AreaGadget)
                    
                EndSelect
                
            EndSelect
            
          Case #PB_Event_Menu
            
            Select EventMenu
                
              Case 0
                
            EndSelect
            
          Case 514, 160 ; Bouton gauche relacher avec la souris sur la fenêtre ou en dehord de celle-ci
            
            If Not IsMouseOverGadget(EventGadget)
            Bouton.Caracteristiques(EventGadget) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
            Bouton.Caracteristiques(EventGadget) \ EtasBoutonGaucheSouris = 0
            
            ForEach EnumerationBouton()
              ; Je reset tous les boutons
              Bouton.Caracteristiques(EnumerationBouton()) \ EtasBouton = Bouton.Caracteristiques(EventGadget) \ ImageNormale
              Bouton.Caracteristiques(EnumerationBouton()) \ EtasBoutonGaucheSouris = 0
            Next
            
          Else
            
          EndIf
            
        EndSelect
        
      Until Event = #PB_Event_CloseWindow ; Fin des évènements de boucle
      
    EndIf
  EndProcedure
  
InterfaceDecoupageImage(RGB(220, 220, 220), RGB(255, 0, 0), RGB(0, 150, 0))
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

Bon sinon à part sa ça marche bien, voici le programme (Code + Images)
http://www.archive-host.com/files/15693 ... _dimage.7z

J'ai aussi rajouté un petit bonus :D
2 Autres curseur qui vous rappelleront bien quelque choses :lol:

Il faut mètre:

InterfaceDecoupageImage(RGB(220, 220, 220), RGB(255, 0, 0), RGB(0, 150, 0), 3)

Le premier paramètre = Couleur de la fenêtre
Le deuxième paramètre = Couleur des textes d’information
Le dernier paramètre, c'est pour le curseur du canva:

1 = La pipette
2 = Le viseur 2
3 = Le viseur 1

Voilà :D

Bon c'est pas encore parfais mais déjà ça vous donnera un aperçu de ce que c'est :wink:
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
Avatar de l’utilisateur
Atlante
Messages : 337
Inscription : mer. 29/juin/2011 18:35
Localisation : Paris

Re: Découpeur d'images

Message par Atlante »

dayvid essayes de faire une archive pour ton code PB les prochaines fois et mets là sur un hébergeur de fichier. Car sinon on va avoir 15 post pour 4 messages.
Merci
Modérateur
Config : Intel I5 4670K, Nvidia Geforce GTX 1060, 16go RAM, SSD 256go, DD 2000go
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

Atlante a écrit :dayvid essayes de faire une archive pour ton code PB les prochaines fois et mets là sur un hébergeur de fichier. Car sinon on va avoir 15 post pour 4 messages.
Merci
Oui je comprends et approuve Atlante mais j'ai aussi peur que personne ne veuille la télécharger cette archive :(
J'ai cru comprendre qu'ils n'aiment pas trop ça justement, mais ok pas de problème je ferais ça la prochaine fois :)
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
Avatar de l’utilisateur
Kwai chang caine
Messages : 6989
Inscription : sam. 23/sept./2006 18:32
Localisation : Isere

Re: Découpeur d'images

Message par Kwai chang caine »

D'accord ATLANTE mais ça a aussi le désavantage d'avoir noir de posts sans valeur avec des liens HS :?
Par contre la methode a DOBRO....si tenté que ce soit lui le "createur" :D est de garder le premier CODE en debut de POST et le remettre a jour en marquant juste un "Update du premier code" et ce que tu as fait :wink:
Je crois que soldat en fait de même 8)
Remarque ce qui ne t'empeche pas de te creer un site, ou autre, de mettre le lien dans ta signature, avec les anciennes versions en archives comme a fait FRED, au cas ou tu aurais un "client" qui aurait loupé quelque chose dans l'evolution de tes codes :D
ImageLe bonheur est une route...
Pas une destination

PureBasic Forum Officiel - Site PureBasic
Haut
Avatar de l’utilisateur
Ar-S
Messages : 9540
Inscription : dim. 09/oct./2005 16:51
Contact :
Contacter Ar-S

Re: Découpeur d'images

Message par Ar-S »

Kwai chang caine a écrit :D'accord ATLANTE mais ça a aussi le désavantage d'avoir noir de posts sans valeur avec des liens HS :?
Par contre la methode a DOBRO....si tenté que ce soit lui le "createur" :D est de garder le premier CODE en debut de POST et le remettre a jour en marquant juste un "Update du premier code" et ce que tu as fait :wink:
Je crois que soldat en fait de même 8)
Remarque ce qui ne t'empeche pas de te creer un site, ou autre, de mettre le lien dans ta signature, avec les anciennes versions en archives comme a fait FRED, au cas ou tu aurais un "client" qui aurait loupé quelque chose dans l'evolution de tes codes :D
Il faut faire les 2 selon moi mais le 1er topic doit toujours comporter le code à jour. Dans un topic à 10 pages, bonjour l'angoisse sinon pour suivre. :mrgreen:
~~~~Règles du forum ~~~~
⋅.˳˳.⋅ॱ˙˙ॱ⋅.˳Ar-S ˳.⋅ॱ˙˙ॱ⋅.˳˳.⋅
W11x64 PB 6.x
Section HORS SUJET : ICI
LDV MULTIMEDIA : Dépannage informatique & mes Logiciels PB
UPLOAD D'IMAGES : Uploader des images de vos logiciels
Haut
jbernard13
Messages : 1501
Inscription : dim. 18/avr./2004 15:04
Localisation : sud de la france

Re: Découpeur d'images

Message par jbernard13 »

dayvid a écrit :Bon sinon à part sa ça marche bien, voici le programme (Code + Images)
http://www.archive-host.com/files/15693 ... _dimage.7z

J'ai aussi rajouté un petit bonus :D
2 Autres curseur qui vous rappelleront bien quelque choses :lol:

Il faut mètre:

InterfaceDecoupageImage(RGB(220, 220, 220), RGB(255, 0, 0), RGB(0, 150, 0), 3)

Le premier paramètre = Couleur de la fenêtre
Le deuxième paramètre = Couleur des textes d’information
Le dernier paramètre, c'est pour le curseur du canva:

1 = La pipette
2 = Le viseur 2
3 = Le viseur 1

Voilà :D

Bon c'est pas encore parfais mais déjà ça vous donnera un aperçu de ce que c'est :wink:
j'ai télécharger et une fois le programme lancer , il y a aucune decoupe .
Jbernard13
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

jbernard13 a écrit :
dayvid a écrit :Bon sinon à part sa ça marche bien, voici le programme (Code + Images)
http://www.archive-host.com/files/15693 ... _dimage.7z

J'ai aussi rajouté un petit bonus :D
2 Autres curseur qui vous rappelleront bien quelque choses :lol:

Il faut mètre:

InterfaceDecoupageImage(RGB(220, 220, 220), RGB(255, 0, 0), RGB(0, 150, 0), 3)

Le premier paramètre = Couleur de la fenêtre
Le deuxième paramètre = Couleur des textes d’information
Le dernier paramètre, c'est pour le curseur du canva:

1 = La pipette
2 = Le viseur 2
3 = Le viseur 1

Voilà :D

Bon c'est pas encore parfais mais déjà ça vous donnera un aperçu de ce que c'est :wink:
j'ai télécharger et une fois le programme lancer , il y a aucune decoupe .
As-tu définie les couleurs ?!

Sinon attends, je suis en train d'améliorer le tous mais comme je n'ai pas de loupe et que j'essaie d'en faire une, ça va prendre un moment !
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
Avatar de l’utilisateur
TazNormand
Messages : 1297
Inscription : ven. 27/oct./2006 12:19
Localisation : Calvados (14)

Re: Découpeur d'images

Message par TazNormand »

Petit Dayvid devient grand on dirait :wink:
Image
Image
Haut
dayvid
Messages : 1242
Inscription : mer. 11/nov./2009 18:17
Localisation : Poitiers (Vienne)

Re: Découpeur d'images

Message par dayvid »

TazNormand a écrit :Petit Dayvid devient grand on dirait :wink:
Mdr :lol:

Oui, du moins, on essaie :lol: :wink:
La vie, C'est comme, Une boitte, De startis, On en voie, De toutes, Les couleurs !

Mon forum http://purebasic.forumphp3.com/index.php
Haut
Répondre

Revenir à « Débutants »