Jolie Bouton

Vous avez une idée pour améliorer ou modifier PureBasic ? N'hésitez pas à la proposer.
Avatar de l’utilisateur
Micoute
Messages : 2522
Inscription : dim. 02/oct./2011 16:17
Localisation : 35520 La Mézière

Re: Jolie Bouton

Message par Micoute »

Bonjour falsam,

c'est très bon ça, j'adopte !
Microsoft Windows 10 Famille 64 bits : Carte mère : ASRock 970 Extreme3 R2.0 : Carte Graphique NVIDIA GeForce RTX 3080 : Processeur AMD FX 6300 6 cœurs 12 threads 3,50 GHz PB 5.73 PB 6.00 LTS (x64)
Un homme doit être poli, mais il doit aussi être libre !
Shadow
Messages : 1373
Inscription : mer. 04/nov./2015 17:39

Re: Jolie Bouton

Message par Shadow »

Salut,

Aller, sognion fout :D
Je travail sur un autre code en ce moment même...

Partie 1:

Code : Tout sélectionner

; Créer par Shadow le 20/11/2014.

;{ Fonctionnement des commandes:

; Note: Si #BG_AutoNum est utilisé pour le paramètre '#Gadget', le numéro du nouveau gadget sera renvoyé dans 'Resultat'
; Exemple: Resulta = BoutonGadget(#BG_AutoNum, 100, 100, 100, 25, "Bouton Perso", RGB(255, 198, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, 0)

; Resulta Contiendra la plus haute valeur enregistrer par l'enumeration

; Ont commencera toujours par crée notre bouton, exemple:

; -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; BoutonGadget(#MonBouton, 100, 100, 100, 25, "Bouton Perso", RGB(255, 198, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, 0)

; Si par exemple l'utilisateur ne souhaite pas se prendre la tête à personnaliser son bouton
; il aurra juste à définir les informations de bases du bouton pour le crée et le programme se chargera du reste
; 
; Le programme créera automatiquement lui même les images par defaut qu'il faux pour ensuite gérer les divers étas du bouton
; Il n'y aurra donc rien de plus a faire !

; Cependent si l'utilisateur souhaite par la suite et ça n'importe quand, personnaliser son bouton, les images qui auron été crée par defaut
; seron remplacer par les images que l'utilisateur aurra crée lui même grace aux commandes !
; 
; Il n'est pas obliger de définir toutes les étas du bouton, il peux choisire ceux qu'il souhaite personnaliser !
; 
; Il peut par exemple simplement recrée l'image Normale du bouton ou bien l'image Survoler et/ou Appuyer ou même les trois !
; 
; Note: Le programme a été crée pour pouvoir être très souple au niveaux des commandes, c'est-à-dire que vous pouvez employer
; les commandes dans n'importe quel sens vue que le bouton sera en faite a chaque fois redéssiner !

; Il n'y a pas d'ordre spécifique pour les commandes, vous pouvez très bien commencer par exemple par ImageBoutonGadget()
; puis enchainer par exemple avec TexteBoutonGadget() puis ensuite par InterieurBoutonGadget() et pour finir par BordureBoutonGadget()
; 
; Par contre il vous faux impérativement crée votre bouton avent d'utiliser l'une de ses commande !
; 
; -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

; Ensuite ont personnalise notre bouton, ont peux crée jusqua trois images différente (Normale, Survoler, Appuyer) suivent l'étas du bouton, le programme se chargera du reste !
; Exemple d'utilisation:
;
; BoutonGadget(#MonBouton, 100, 100, 100, 25, "Mon bouton", 0, 0, RGB(255, 198, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, Image1, 5, 5, 0)
; 
; BordureBoutonGadget(#MonBouton, "Normale", RGB(255, 255, 255), RGB(160, 160, 160), RGB(255, 255, 255), RGB(160, 160, 160), 1)
; BordureBoutonGadget(#MonBouton, "Survoler", RGB(255, 255, 255), RGB(160, 160, 160), RGB(255, 255, 255), RGB(160, 160, 160), 1)
; BordureBoutonGadget(#MonBouton, "Appuyer", RGB(160, 160, 160), RGB(255, 255, 255), RGB(160, 160, 160), RGB(255, 255, 255), 1)
; 
; InterieurBoutonGadget(#MonBouton, "Normale", RGB(240, 240, 240), RGB(240, 240, 240), 1, 0, 1)
; InterieurBoutonGadget(#MonBouton, "Survoler", RGB(240, 240, 240), RGB(240, 240, 240), 1, 0, 1)
; InterieurBoutonGadget(#MonBouton, "Appuyer", RGB(240, 240, 240), RGB(240, 240, 240), 1, 0, 1)
; 
; TexteBoutonGadget(#MonBouton, "Normale", 24, 0, "Arial", 9, RGB(255, 198, 0), RGB(240, 240, 240), "Mon bouton", 0)
; TexteBoutonGadget(#MonBouton, "Survoler", 24, 0, "Arial", 9, RGB(255, 198, 0), RGB(240, 240, 240), "Mon bouton", 0)
; TexteBoutonGadget(#MonBouton, "Appuyer", 24, 0, "Arial", 9, RGB(255, 198, 0), RGB(240, 240, 240), "Mon bouton", 0)
; 
; ImageBoutonGadget(#MonBouton, "Normale", Image1, 5, 5)
; ImageBoutonGadget(#MonBouton, "Survoler", Image1, 5, 5)
; ImageBoutonGadget(#MonBouton, "Appuyer", Image1, 5, 5)

; Note: Pour le texte, si une position X et/ou Y est = à 0, le programme se chargera de centrer celui-ci autamatiquement sur le bouton
; Sinon c'est à vous de choisir ou le texte sera afficher sur le bouton, le programme se chargera du reste

; Ensuite, si les options de texte sons = à -1, alors toutes les options de texte seron mise sur le texte en question
; C'est-a-dire que le texte sera en: Gras, Italique, Soulignier et barrer

; Note: Le qualité du texte sera toujours au maximum car l'option haute qualité est mise automatiquement et systematiquement pour le texte !
  
; Pour afficher une image sur le bouton:

; -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; ;- Image Globals
; Global Image1
; 
; ;- Catch Images
; Image1 = CatchImage(#PB_Any, ?Image1) ; Ici il faut impérativement mèttre Pb_any pour l'image
; 
; ;- Images
; DataSection
;   Image1:
;   IncludeBinary "error.png"
; EndDataSection
; -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

; ImageBouton est le numéro de votre image, ici donc: Image1

; Si XImage = 0, l'image sera automatiquement centrer en horizontal
; Si YImage = 0, l'image sera automatiquement centrer en vertical

; Exemple:
; BoutonGadget(#MonBouton, 100, 100, 100, 25, "Mon bouton", 0, 0, RGB(255, 198, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, Image1, 0, 0, 0)

;}

;- Image Plugins
UsePNGImageDecoder()

Enumeration #PB_Compiler_EnumerationValue
  #Fenetre
EndEnumeration

Enumeration #PB_Compiler_EnumerationValue
  #MonBouton
  #MonBouton2
  #MonBouton3
  #MonBouton4
  #NombreBouton ; Marque permettant de dire que c'est la fin de notre énumération. Le total sera donc de #NombreBouton - 1
EndEnumeration

; 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
  
  CouleurBordureHautBoutonNormale.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
  TexteTransparentBoutonNormale.i
  OptionTexteBoutonNormale.i
  NumeroPoliceBoutonNormale.i
  
  ImageBoutonBoutonNormale.i
  XImageBoutonNormale.i
  YImageBoutonNormale.i
  ;---------------------------------------------------
  
  ; Bouton image survoler
  ;---------------------------------------------------
  TexteBoutonSurvoler.s
  
  CouleurBordureHautBoutonSurvoler.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
  TexteTransparentBoutonSurvoler.i
  OptionTexteBoutonSurvoler.i
  NumeroPoliceBoutonSurvoler.i
  
  ImageBoutonBoutonSurvoler.i
  XImageBoutonSurvoler.i
  YImageBoutonSurvoler.i
  ;---------------------------------------------------
  
  ; Bouton image appuyer
  ;---------------------------------------------------
  TexteBoutonAppuyer.s
  
  CouleurBordureHautBoutonAppuyer.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
  TexteTransparentBoutonAppuyer.i
  OptionTexteBoutonAppuyer.i
  NumeroPoliceBoutonAppuyer.i
  
  ImageBoutonBoutonAppuyer.i
  XImageBoutonAppuyer.i
  YImageBoutonAppuyer.i
  ;---------------------------------------------------
  
  ;} 
EndStructure

Global Dim Bouton.Caracteristiques(#NombreBouton - 1)
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 Information Bouton

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

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

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

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

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

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

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

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

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

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

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

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

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

Procedure.l RenvoyerCouleurBordureHautBoutonNormale(BoutonID.i)
  ProcedureReturn Bouton(BoutonID)\CouleurBordureHautBoutonNormale
EndProcedure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Procedure.l RenvoyerCouleurBordureHautBoutonSurvoler(BoutonID.i)
  ProcedureReturn Bouton(BoutonID)\CouleurBordureHautBoutonSurvoler
EndProcedure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Procedure.l RenvoyerCouleurBordureHautBoutonAppuyer(BoutonID.i)
  ProcedureReturn Bouton(BoutonID)\CouleurBordureHautBoutonAppuyer
EndProcedure

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

;}

Procedure AfficherImage(NumeroImage)
  If OpenWindow(#FenetreImage, 327, 177, 500, 300, "Fenêtre windows",  #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar)
    If IsImage(NumeroImage)
      ImageGadget(#ImageFenetreImage, 10, 10, 1, 1, ImageID(NumeroImage))
    EndIf
    
    Repeat ; Départ des évènements de boucle
      
      Event2 = WaitWindowEvent(1) ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la fenêtre
      ; Où est déclaré le minuteur 1 ?
    Until Event2 = #PB_Event_CloseWindow ; Fin des évènements de boucle
    CloseWindow(#FenetreImage)
  EndIf
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(BoutonID)\Largeur
  Hauteur = Bouton(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(BoutonID)\Largeur
    Hauteur = Bouton(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 BoutonGadget(BoutonID, X, Y, Largeur, Hauteur, Texte$, PoliceTexte$, XTexte, YTexte, CouleurTexte, CouleurFondTexte, TailleTexte, TexteTransparent, OptionTexte, CouleurBouton, CurseurSurBouton, ImageBouton, XImage, YImage, OptionBouton)
  
  ; 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 VerificationValeurVariable(TexteTransparent) > 1
    TexteTransparent = 1
  EndIf
  
  If OptionTexte < -1
    OptionTexte = -1
  ElseIf OptionTexte <> -1
    OptionTexte = VerificationValeurVariable(OptionTexte)
  EndIf
  
  Bouton(BoutonID)\BoutonID = BoutonID
  Bouton(BoutonID)\X = X
  Bouton(BoutonID)\Y = Y
  Bouton(BoutonID)\Largeur = Largeur
  Bouton(BoutonID)\Hauteur = Hauteur
  
  Bouton(BoutonID)\TexteBoutonNormale = Texte$
  
  Bouton(BoutonID)\CouleurTexteBoutonNormale = CouleurTexte
  Bouton(BoutonID)\CouleurFondTexteBoutonNormale = CouleurFondTexte
  
  Bouton(BoutonID)\Curseur = CurseurSurBouton
  Bouton(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, PoliceTexte$, 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, PoliceTexte$, TailleTexte, OptionTexte | #PB_Font_HighQuality)
    EndIf
    
    Bouton(BoutonID)\OptionTexteBoutonNormale = OptionTexte | #PB_Font_HighQuality
    
    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(BoutonID)\CouleurDegrader1InterieurBoutonNormale = CouleurBouton
    Bouton(BoutonID)\CouleurDegrader2InterieurBoutonNormale = CouleurBouton
    Bouton(BoutonID)\ActiverDegraderBoutonNormale = 1
    Bouton(BoutonID)\OptionDegraderInterieurBoutonNormale = 0
    Bouton(BoutonID)\TexteTransparentBoutonNormale = TexteTransparent
    
    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(BoutonID)\PocileTexteBoutonNormale = PoliceTexte$
      Bouton(BoutonID)\TailleTexteBoutonNormale = TailleTexte
      Bouton(BoutonID)\NumeroPoliceBoutonNormale = FontID
    Else
      DrawingFont(#PB_Default)
      Bouton(BoutonID)\PocileTexteBoutonNormale = "Inconnue"
      Bouton(BoutonID)\TailleTexteBoutonNormale = 0
      Bouton(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(BoutonID)\ImageBoutonBoutonNormale = ImageBouton
      Bouton(BoutonID)\XImageBoutonNormale = PositionImageX
      Bouton(BoutonID)\YImageBoutonNormale = PositionImageY
      
    EndIf
    
    If TexteTransparent = 1
    DrawingMode(#PB_2DDrawing_Transparent)
  EndIf
  
    DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    
    StopDrawing()
    
    ; Par defaut, les bordures serons blanche (Haut et gauche) et gris foncer (Bas et droite)
    Bouton(BoutonID)\CouleurBordureHautBoutonNormale = RGB(255, 255, 255)
    Bouton(BoutonID)\CouleurBordureBasBoutonNormale = RGB(160, 160, 160)
    Bouton(BoutonID)\CouleurBordureGaucheBoutonNormale = RGB(255, 255, 255)
    Bouton(BoutonID)\CouleurBordureDroiteBoutonNormale = RGB(160, 160, 160)
    
    Bouton(BoutonID)\XTexteBoutonNormale = PositionTexteX
    Bouton(BoutonID)\YTexteBoutonNormale = PositionTexteY
    
    Bouton(BoutonID)\TailleDesBorduresBoutonNormale = 1
    
    ; Initialisation du curseur sur le bouton
    SetGadgetAttribute(BoutonID, #PB_Canvas_Cursor, CurseurSurBouton)
    
    Bouton(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(BoutonID)\TexteBoutonSurvoler = Texte$
  
  Bouton(BoutonID)\CouleurTexteBoutonSurvoler = CouleurTexte
  Bouton(BoutonID)\CouleurFondTexteBoutonSurvoler = CouleurFondTexte
  
  Bouton(BoutonID)\CouleurDegrader1InterieurBoutonSurvoler = CouleurBouton
  Bouton(BoutonID)\CouleurDegrader2InterieurBoutonSurvoler = CouleurBouton
  Bouton(BoutonID)\ActiverDegraderBoutonSurvoler = 1
  Bouton(BoutonID)\OptionDegraderInterieurBoutonSurvoler = 0
  Bouton(BoutonID)\TexteTransparentBoutonSurvoler = TexteTransparent
  
  Bouton(BoutonID)\OptionTexteBoutonSurvoler = OptionTexte
  
  ImageAuto = CreateImage(#PB_Any, Largeur, Hauteur)
  
  If ImageAuto
    
    FontID = LoadFont(#PB_Any, PoliceTexte$, 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(BoutonID)\PocileTexteBoutonSurvoler = PoliceTexte$
      Bouton(BoutonID)\TailleTexteBoutonSurvoler = TailleTexte
      Bouton(BoutonID)\NumeroPoliceBoutonSurvoler = FontID
    Else
      DrawingFont(FontID(#PB_Default))
      Bouton(BoutonID)\PocileTexteBoutonSurvoler = "Inconnue"
      Bouton(BoutonID)\TailleTexteBoutonSurvoler = 0
      Bouton(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(BoutonID)\ImageBoutonBoutonSurvoler = ImageBouton
      Bouton(BoutonID)\XImageBoutonSurvoler = PositionImageX
      Bouton(BoutonID)\YImageBoutonSurvoler = PositionImageY
      
    EndIf
    
    If TexteTransparent = 1
    DrawingMode(#PB_2DDrawing_Transparent)
  EndIf
    
    DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    
    StopDrawing()
    
    ; Par defaut, les bordures serons blanche (Haut et gauche) et gris foncer (Bas et droite)
    Bouton(BoutonID)\CouleurBordureHautBoutonSurvoler = RGB(255, 255, 255)
    Bouton(BoutonID)\CouleurBordureBasBoutonSurvoler = RGB(160, 160, 160)
    Bouton(BoutonID)\CouleurBordureGaucheBoutonSurvoler = RGB(255, 255, 255)
    Bouton(BoutonID)\CouleurBordureDroiteBoutonSurvoler = RGB(160, 160, 160)
    
    Bouton(BoutonID)\XTexteBoutonSurvoler = PositionTexteX
    Bouton(BoutonID)\YTexteBoutonSurvoler = PositionTexteY
    
    Bouton(BoutonID)\TailleDesBorduresBoutonSurvoler = 1
    
    Bouton(BoutonID)\ImageSurvoler = ImageAuto
    
  EndIf
Processeur: Intel Core I7-4790 - 4 Cœurs - 8 Thread: 3.60 Ghz.
Ram: 32 GB.
Disque: C: SDD 250 GB, D: 3 TB.
Vidéo: NVIDIA GeForce GTX 960: 2 GB DDR5.
Écran: Asus VX248 24 Pouces: 1920 x 1080.
Système: Windows 7 64 Bits.

PureBasic: 5.60 x64 Bits.
Shadow
Messages : 1373
Inscription : mer. 04/nov./2015 17:39

Re: Jolie Bouton

Message par Shadow »

Partie 2 à collé à la suite de la partie 1:

Code : Tout sélectionner

  ; Création de l'image Appuyer du bouton:
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  ;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  Bouton(BoutonID)\TexteBoutonAppuyer = Texte$
  
  Bouton(BoutonID)\CouleurTexteBoutonAppuyer = CouleurTexte
  Bouton(BoutonID)\CouleurFondTexteBoutonAppuyer = CouleurFondTexte
  
  Bouton(BoutonID)\CouleurDegrader1InterieurBoutonAppuyer = CouleurBouton
  Bouton(BoutonID)\CouleurDegrader2InterieurBoutonAppuyer = CouleurBouton
  Bouton(BoutonID)\ActiverDegraderBoutonAppuyer = 1
  Bouton(BoutonID)\OptionDegraderInterieurBoutonAppuyer = 0
  Bouton(BoutonID)\TexteTransparentBoutonAppuyer = TexteTransparent
  
  Bouton(BoutonID)\OptionTexteBoutonAppuyer = OptionTexte
  
  ImageAuto = CreateImage(#PB_Any, Largeur, Hauteur)
  
  If ImageAuto
    
    FontID = LoadFont(#PB_Any, PoliceTexte$, 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(BoutonID)\PocileTexteBoutonAppuyer = PoliceTexte$
      Bouton(BoutonID)\TailleTexteBoutonAppuyer = TailleTexte
      Bouton(BoutonID)\NumeroPoliceBoutonAppuyer = FontID
    Else
      DrawingFont(FontID(#PB_Default))
      Bouton(BoutonID)\PocileTexteBoutonAppuyer = "Inconnue"
      Bouton(BoutonID)\TailleTexteBoutonAppuyer = 0
      Bouton(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(BoutonID)\ImageBoutonBoutonAppuyer = ImageBouton
      Bouton(BoutonID)\XImageBoutonAppuyer = PositionImageX
      Bouton(BoutonID)\YImageBoutonAppuyer = PositionImageY
      
    EndIf
    
    If TexteTransparent = 1
    DrawingMode(#PB_2DDrawing_Transparent)
  EndIf
    
    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(BoutonID)\CouleurBordureHautBoutonAppuyer = RGB(160, 160, 160)
    Bouton(BoutonID)\CouleurBordureBasBoutonAppuyer = RGB(255, 255, 255)
    Bouton(BoutonID)\CouleurBordureGaucheBoutonAppuyer = RGB(160, 160, 160)
    Bouton(BoutonID)\CouleurBordureDroiteBoutonAppuyer = RGB(255, 255, 255)
    
    Bouton(BoutonID)\XTexteBoutonAppuyer = PositionTexteX
    Bouton(BoutonID)\YTexteBoutonAppuyer = PositionTexteY
    
    Bouton(BoutonID)\TailleDesBorduresBoutonAppuyer = 1
    Bouton(BoutonID)\ImageAppuyer = ImageAuto
    
  EndIf
  
EndProcedure

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

; Ici je recupère toutes les données du bouton
Macro EnregistrementDonnerBouton()
  
  If LCase(NomEtasImage$) = "normal"
    
    Bouton(BoutonID)\TexteBoutonNormale = TexteBoutonTemps$
    
    Bouton(BoutonID)\CouleurBordureHautBoutonNormale = CouleurBordureHautBoutonTemps
    Bouton(BoutonID)\CouleurBordureBasBoutonNormale = CouleurBordureBasBoutonTemps
    Bouton(BoutonID)\CouleurBordureGaucheBoutonNormale = CouleurBordureGaucheBoutonTemps
    Bouton(BoutonID)\CouleurBordureDroiteBoutonNormale = CouleurBordureDroiteBoutonTemps
    Bouton(BoutonID)\TailleDesBorduresBoutonNormale = TailleDesBorduresBoutonTemps
    
    Bouton(BoutonID)\CouleurDegrader1InterieurBoutonNormale = CouleurDegrader1InterieurBoutonTemps
    Bouton(BoutonID)\CouleurDegrader2InterieurBoutonNormale = CouleurDegrader2InterieurBoutonTemps
    Bouton(BoutonID)\OptionDegraderInterieurBoutonNormale = OptionDegraderInterieurBoutonTemps
    Bouton(BoutonID)\ActiverDegraderBoutonNormale = ActiverDegraderBoutonTemps
    
    Bouton(BoutonID)\XTexteBoutonNormale = XTexteBoutonTemps
    Bouton(BoutonID)\YTexteBoutonNormale = YTexteBoutonTemps
    Bouton(BoutonID)\PocileTexteBoutonNormale = PocileTexteBoutonTemps$
    Bouton(BoutonID)\TailleTexteBoutonNormale = TailleTexteBoutonTemps
    Bouton(BoutonID)\CouleurTexteBoutonNormale = CouleurTexteBoutonTemps
    Bouton(BoutonID)\CouleurFondTexteBoutonNormale = CouleurFondTexteBoutonTemps
    Bouton(BoutonID)\TexteTransparentBoutonNormale = TexteTransparentBoutonTemps
    Bouton(BoutonID)\OptionTexteBoutonNormale = OptionTexteBoutonTemps
    Bouton(BoutonID)\NumeroPoliceBoutonNormale = NumeroPoliceBoutonTemps
    
    Bouton(BoutonID)\ImageBoutonBoutonNormale = ImageBoutonTemps
    Bouton(BoutonID)\XImageBoutonNormale = XImageBoutonTemps
    Bouton(BoutonID)\YImageBoutonNormale = YImageBoutonTemps
    
  ElseIf LCase(NomEtasImage$) = "survolé"
    Bouton(BoutonID)\TexteBoutonSurvoler = TexteBoutonTemps$
    
    Bouton(BoutonID)\CouleurBordureHautBoutonSurvoler = CouleurBordureHautBoutonTemps
    Bouton(BoutonID)\CouleurBordureBasBoutonSurvoler = CouleurBordureBasBoutonTemps
    Bouton(BoutonID)\CouleurBordureGaucheBoutonSurvoler = CouleurBordureGaucheBoutonTemps
    Bouton(BoutonID)\CouleurBordureDroiteBoutonSurvoler = CouleurBordureDroiteBoutonTemps
    Bouton(BoutonID)\TailleDesBorduresBoutonSurvoler = TailleDesBorduresBoutonTemps
    
    Bouton(BoutonID)\CouleurDegrader1InterieurBoutonSurvoler = CouleurDegrader1InterieurBoutonTemps
    Bouton(BoutonID)\CouleurDegrader2InterieurBoutonSurvoler = CouleurDegrader2InterieurBoutonTemps
    Bouton(BoutonID)\OptionDegraderInterieurBoutonSurvoler = OptionDegraderInterieurBoutonTemps
    Bouton(BoutonID)\ActiverDegraderBoutonSurvoler = ActiverDegraderBoutonTemps
    
    Bouton(BoutonID)\XTexteBoutonSurvoler = XTexteBoutonTemps
    Bouton(BoutonID)\YTexteBoutonSurvoler = YTexteBoutonTemps
    Bouton(BoutonID)\PocileTexteBoutonSurvoler = PocileTexteBoutonTemps$
    Bouton(BoutonID)\TailleTexteBoutonSurvoler = TailleTexteBoutonTemps
    Bouton(BoutonID)\CouleurTexteBoutonSurvoler = CouleurTexteBoutonTemps
    Bouton(BoutonID)\CouleurFondTexteBoutonSurvoler = CouleurFondTexteBoutonTemps
    Bouton(BoutonID)\TexteTransparentBoutonSurvoler = TexteTransparentBoutonTemps
    Bouton(BoutonID)\OptionTexteBoutonSurvoler = OptionTexteBoutonTemps
    Bouton(BoutonID)\NumeroPoliceBoutonSurvoler = NumeroPoliceBoutonTemps
    
    Bouton(BoutonID)\ImageBoutonBoutonSurvoler = ImageBoutonTemps
    Bouton(BoutonID)\XImageBoutonSurvoler = XImageBoutonTemps
    Bouton(BoutonID)\YImageBoutonSurvoler = YImageBoutonTemps
    
  ElseIf LCase(NomEtasImage$) = "appuyé"
    Bouton(BoutonID)\TexteBoutonAppuyer = TexteBoutonTemps$
    
    Bouton(BoutonID)\CouleurBordureHautBoutonAppuyer = CouleurBordureHautBoutonTemps
    Bouton(BoutonID)\CouleurBordureBasBoutonAppuyer = CouleurBordureBasBoutonTemps
    Bouton(BoutonID)\CouleurBordureGaucheBoutonAppuyer = CouleurBordureGaucheBoutonTemps
    Bouton(BoutonID)\CouleurBordureDroiteBoutonAppuyer = CouleurBordureDroiteBoutonTemps
    Bouton(BoutonID)\TailleDesBorduresBoutonAppuyer = TailleDesBorduresBoutonTemps
    
    Bouton(BoutonID)\CouleurDegrader1InterieurBoutonAppuyer = CouleurDegrader1InterieurBoutonTemps
    Bouton(BoutonID)\CouleurDegrader2InterieurBoutonAppuyer = CouleurDegrader2InterieurBoutonTemps
    Bouton(BoutonID)\OptionDegraderInterieurBoutonAppuyer = OptionDegraderInterieurBoutonTemps
    Bouton(BoutonID)\ActiverDegraderBoutonAppuyer = ActiverDegraderBoutonTemps
    
    Bouton(BoutonID)\XTexteBoutonAppuyer = XTexteBoutonTemps
    Bouton(BoutonID)\YTexteBoutonAppuyer = YTexteBoutonTemps
    Bouton(BoutonID)\PocileTexteBoutonAppuyer = PocileTexteBoutonTemps$
    Bouton(BoutonID)\TailleTexteBoutonAppuyer = TailleTexteBoutonTemps
    Bouton(BoutonID)\CouleurTexteBoutonAppuyer = CouleurTexteBoutonTemps
    Bouton(BoutonID)\CouleurFondTexteBoutonAppuyer = CouleurFondTexteBoutonTemps
    Bouton(BoutonID)\TexteTransparentBoutonAppuyer = TexteTransparentBoutonTemps
    Bouton(BoutonID)\OptionTexteBoutonAppuyer = OptionTexteBoutonTemps
    Bouton(BoutonID)\NumeroPoliceBoutonAppuyer = NumeroPoliceBoutonTemps
    
    Bouton(BoutonID)\ImageBoutonBoutonAppuyer = ImageBoutonTemps
    Bouton(BoutonID)\XImageBoutonAppuyer = XImageBoutonTemps
    Bouton(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$, CouleurBordureHaut, CouleurBordureBas, CouleurBordureGauche, CouleurBordureDroite, TailleDesBordures)
  ; Ont pourais choisir individuellement la taille des bordures mais ça va pas être façile !
  
  BoutonID = VerificationValeurVariable(BoutonID)
  CouleurBordureHaut = VerificationValeurVariable(CouleurBordureHaut)
  CouleurBordureBas = VerificationValeurVariable(CouleurBordureBas)
  CouleurBordureGauche = VerificationValeurVariable(CouleurBordureGauche)
  CouleurBordureDroite = VerificationValeurVariable(CouleurBordureDroite)
  
  Largeur = Bouton(BoutonID)\Largeur
  Hauteur = Bouton(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
  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, CouleurBordureHaut)
    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 TexteTransparentBoutonTemps = 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$) = "normal"
      Bouton(BoutonID)\ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survolé"
      Bouton(BoutonID)\ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyé"
      Bouton(BoutonID)\ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    CouleurBordureHautBoutonTemps = CouleurBordureHaut
    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 ; on peut mettre cette valeur par défaut
    OptionDegrader = 1
  EndIf
  
  If VerificationValeurVariable(ActiverDegrader) > 1 ; pareil ici
    ActiverDegrader = 1
  EndIf
  
  If VerificationValeurVariable(TexteTransparent) > 1 ; idem
    TexteTransparent = 1
  EndIf
  
  Largeur = Bouton(BoutonID)\Largeur
  Hauteur = Bouton(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, CouleurBordureHautBoutonTemps)
    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()
    
    If LCase(NomEtasImage$) = "normal"
      Bouton(BoutonID)\ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survolé"
      Bouton(BoutonID)\ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyé"
      Bouton(BoutonID)\ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    CouleurDegrader1InterieurBoutonTemps = CouleurDegrader1
    CouleurDegrader2InterieurBoutonTemps = CouleurDegrader2
    ActiverDegraderBoutonTemps = ActiverDegrader
    OptionDegraderInterieurBoutonTemps = OptionDegrader
    TexteTransparentBoutonTemps = 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(BoutonID)\Largeur
  Hauteur = Bouton(BoutonID)\Hauteur
  
  RecuperationDonnerBouton()
  
  OptionTexteBoutonTemps = 0
  
  ; Si le bouton existe bien
  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, CouleurBordureHautBoutonTemps)
    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 TexteTransparentBoutonTemps = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    If LCase(NomEtasImage$) = "normal" Or LCase(NomEtasImage$) = "survolé"
      DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    ElseIf LCase(NomEtasImage$) = "appuyé"
      PositionTexteX + 1
      PositionTexteY + 1
      DrawText(PositionTexteX, PositionTexteY, Texte$, CouleurTexte, CouleurFondTexte)
    EndIf
    
    StopDrawing()
    
    If LCase(NomEtasImage$) = "normal"
      Bouton(BoutonID)\ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survolé"
      
      Bouton(BoutonID)\ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyé"
      Bouton(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(BoutonID)\Largeur
  Hauteur = Bouton(BoutonID)\Hauteur
  
  RecuperationDonnerBouton()
  
  ; Si le bouton existe bien
  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, CouleurBordureHautBoutonTemps)
    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 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$) = "normal" Or LCase(NomEtasImage$) = "survolé"
        DrawImage(ImageID(ImageBouton), PositionImageX, PositionImageY, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      ElseIf LCase(NomEtasImage$) = "appuyé"
        DrawImage(ImageID(ImageBouton), PositionImageX + 1, PositionImageY + 1, ImageWidth(ImageBouton), ImageHeight(ImageBouton))
      EndIf
      DrawingMode(0)
      
      If LCase(NomEtasImage$) = "normal"
        Bouton(BoutonID)\ImageBoutonBoutonNormale = ImageBouton
        Bouton(BoutonID)\XImageBoutonNormale = PositionImageX
        Bouton(BoutonID)\YImageBoutonNormale = PositionImageY
        
      ElseIf LCase(NomEtasImage$) = "survolé"
        Bouton(BoutonID)\ImageBoutonBoutonSurvoler = ImageBouton
        Bouton(BoutonID)\XImageBoutonSurvoler = PositionImageX
        Bouton(BoutonID)\YImageBoutonSurvoler = PositionImageY
        
      ElseIf LCase(NomEtasImage$) = "appuyé"
        Bouton(BoutonID)\ImageBoutonBoutonAppuyer = ImageBouton
        Bouton(BoutonID)\XImageBoutonAppuyer = PositionImageX
        Bouton(BoutonID)\YImageBoutonAppuyer = PositionImageY
        
      EndIf
      
    EndIf
    
    If TexteTransparentBoutonTemps = 1
      DrawingMode(#PB_2DDrawing_Transparent)
    EndIf
    
    DrawText(XTexteBoutonTemps, YTexteBoutonTemps, TexteBoutonTemps$, CouleurTexteBoutonTemps, CouleurFondTexteBoutonTemps)
    
    StopDrawing()
    
    If LCase(NomEtasImage$) = "normal"
      Bouton(BoutonID)\ImageNormale = ImageEtasBouton
      
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(BoutonID))
      DrawImage(ImageID(ImageEtasBouton), 0, 0)
      StopDrawing()
      
    ElseIf LCase(NomEtasImage$) = "survolé"
      Bouton(BoutonID)\ImageSurvoler = ImageEtasBouton
      
    ElseIf LCase(NomEtasImage$) = "appuyé"
      Bouton(BoutonID)\ImageAppuyer = ImageEtasBouton
      
    EndIf
    
    EnregistrementDonnerBouton()
    
  EndIf
  
EndProcedure

Procedure.l EventBouton(EventGadget, EventType)
  
  Select EventType
      
    Case #PB_EventType_MouseEnter
      If Bouton(EventGadget)\EtasBoutonGaucheSouris = 0
        Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageNormale
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton(EventGadget)\ImageSurvoler), 0, 0)
        StopDrawing()
      ElseIf Bouton(EventGadget)\EtasBoutonGaucheSouris = 1
        Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageAppuyer
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton(EventGadget)\ImageAppuyer), 0, 0)
        StopDrawing()
      EndIf
      
    Case #PB_EventType_MouseLeave
      Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageNormale
      ; Je déssine le bouton
      StartDrawing(CanvasOutput(EventGadget))
      DrawImage(ImageID(Bouton(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(EventGadget)\ImageAppuyer), 0, 0)
      StopDrawing()
      Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageAppuyer
      Bouton(EventGadget)\EtasBoutonGaucheSouris = 1
      
    Case #PB_EventType_LeftButtonUp
      If Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageAppuyer And Bouton(EventGadget)\EtasBoutonGaucheSouris = #True
        Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageNormale
        Bouton(EventGadget)\EtasBoutonGaucheSouris = 0
        ; Je déssine le bouton
        StartDrawing(CanvasOutput(EventGadget))
        DrawImage(ImageID(Bouton(EventGadget)\ImageSurvoler), 0, 0)
        StopDrawing()
        ProcedureReturn #True
      EndIf
      
      ForEach EnumerationBouton()
        ; Je reset tous les boutons
        Bouton(EnumerationBouton())\EtasBouton = Bouton(EventGadget)\ImageNormale
        Bouton(EnumerationBouton())\EtasBoutonGaucheSouris = 0
      Next
      
  EndSelect
  
EndProcedure

;- Image Globals
Global Image1

;- Image Globals
Global Image2

;- Image Globals
Global Image3

;- Catch Images
Image1 = CatchImage(#PB_Any, ?Image1)

;- Catch Images
Image2 = CatchImage(#PB_Any, ?Image2)

;- Catch Images
Image3 = CatchImage(#PB_Any, ?Image3)

;- Images
DataSection
  Image1:
  IncludeBinary "error.png"
  Image2:
  IncludeBinary "compil.png"
  Image3:
  IncludeBinary "supprimer.png"
EndDataSection

Procedure Ma_Fenetre()
  If OpenWindow(#Fenetre, 327, 177, 500, 300, "Fenêtre windows",  #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar)
    BoutonGadget(#MonBouton, 10, 10, 115, 25, "Un simple bouton", "", 0, 0, 0, 0, 9, 1, 0, RGB(240, 240, 240), 0, 0, 0, 0, 0)
    BoutonGadget(#MonBouton2, 10, 36, 128, 25, "Un simple bouton", "", 25, 0, RGB(255, 198, 0), 0, 9, 1, 0, RGB(240, 240, 240), #PB_Cursor_Hand, Image1, 5, 5, 0)
    BoutonGadget(#MonBouton3, 10, 62, 128, 25, "Un simple bouton", "Cambria", 8, 0, RGB(0, 0, 255), RGB(255, 198, 0), 8, 0, #PB_Font_Bold, RGB(0, 150, 0), #PB_Cursor_Busy, Image2, 108, 5, 0)
    BoutonGadget(#MonBouton4, 10, 88, 128, 25, "Un bouton perso", "", 0, 0, 0, 0, 9, 1, 0, RGB(240, 240, 240), #PB_Cursor_IBeam, 0, 0, 0, 0)
    
    BordureBoutonGadget(#MonBouton4, "normal", RGB(255, 0, 0), RGB(255, 198, 0), RGB(0, 150, 0), RGB(0, 0, 255), 1)
    BordureBoutonGadget(#MonBouton4, "survolé", RGB(255, 0, 0), RGB(255, 198, 0), RGB(0, 150, 0), RGB(0, 0, 255), 2)
    BordureBoutonGadget(#MonBouton4, "appuyé", RGB(255, 198, 0), RGB(255, 0, 0), RGB(0, 0, 255), RGB(0, 150, 0), 3)
    
    InterieurBoutonGadget(#MonBouton4, "normal", RGB(255, 0, 0), RGB(255, 198, 0), 1, 1, 1)
    InterieurBoutonGadget(#MonBouton4, "survolé", RGB(255, 0, 0), RGB(255, 198, 0), 1, 0, 1)
    InterieurBoutonGadget(#MonBouton4, "appuyé", RGB(0, 150, 0), RGB(255, 198, 0), 0, 0, 1)
    
    TexteBoutonGadget(#MonBouton4, "normal", 24, 0, PoliceTexte$, 9, RGB(255, 0, 0), RGB(240, 240, 240), "Bouton normal", 0)
    TexteBoutonGadget(#MonBouton4, "survolé", 30, 0, PoliceTexte$, 9, RGB(0, 0, 255), RGB(240, 240, 240), "Bouton survolé", #PB_Font_Bold)
    TexteBoutonGadget(#MonBouton4, "appuyé", 24, 1, PoliceTexte$, 9, RGB(255, 0, 255), RGB(240, 240, 240), "Bouton appuyé", #PB_Font_Bold|#PB_Font_Italic|#PB_Font_Underline)
    
    ImageBoutonGadget(#MonBouton4, "normal", Image2, 5, 5)
    ImageBoutonGadget(#MonBouton4, "survolé", Image1, 5, 5)
    ImageBoutonGadget(#MonBouton4, "appuyé", Image3, 5, 5)
    
;     BoutonGadget(#MonBouton2, 100, 126, 100, 25, "Mon bouton", 0, 0, RGB(255, 0, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, 0, 0, 0, 0)
;     BoutonGadget(#MonBouton3, 100, 152, 100, 25, "Mon bouton", 0, 0, RGB(0, 150, 0), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, 0, 0, 0, 0)
;     BoutonGadget(#MonBouton4, 100, 177, 100, 25, "Mon bouton", 0, 0, RGB(0, 0, 255), RGB(240, 240, 240), 9, 0, RGB(240, 240, 240), #PB_Cursor_Hand, 0, 0, 0, 0)
;     
    
    Repeat ; Départ des évènements de boucle
      
      Event = WaitWindowEvent() ; 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 #MonBouton
              If EventBouton(EventGadget, EventType)
                Debug "Bouton jaune appuyer !"
              EndIf
              
            Case #MonBouton2
              If EventBouton(EventGadget, EventType)
                Debug "Bouton rouge appuyer !"
              EndIf
              
            Case #MonBouton3
              If EventBouton(EventGadget, EventType)
                Debug "Bouton vert appuyer !"
              EndIf
              
            Case #MonBouton4
              If EventBouton(EventGadget, EventType)
                Debug "Bouton bleu appuyer !"
              EndIf
              
          EndSelect
          
        Case 514, 160 ; Bouton gauche relacher avec la souris sur la fenêtre ou en dehord de celle-ci
          
          If Not IsMouseOverGadget(EventGadget) And EventGadget < #NombreBouton
            Bouton(EventGadget)\EtasBouton = Bouton(EventGadget)\ImageNormale
            Bouton(EventGadget)\EtasBoutonGaucheSouris = 0
            
            ForEach EnumerationBouton()
              ; Je reset tous les boutons
              Bouton(EnumerationBouton())\EtasBouton = Bouton(EventGadget)\ImageNormale
              Bouton(EnumerationBouton())\EtasBoutonGaucheSouris = 0
            Next
            
          Else
            
          EndIf
          
      EndSelect
      
    Until Event = #PB_Event_CloseWindow ; Fin des évènements de boucle
    
  EndIf
EndProcedure

Ma_Fenetre()
Le tous, ici: http://www.aht.li/2775814/Bonton_gadget_maison_3.7z
Processeur: Intel Core I7-4790 - 4 Cœurs - 8 Thread: 3.60 Ghz.
Ram: 32 GB.
Disque: C: SDD 250 GB, D: 3 TB.
Vidéo: NVIDIA GeForce GTX 960: 2 GB DDR5.
Écran: Asus VX248 24 Pouces: 1920 x 1080.
Système: Windows 7 64 Bits.

PureBasic: 5.60 x64 Bits.
Répondre