Gestion affichage dans un Canvas

Shadow · Message par **Shadow** » jeu. 27/janv./2022 23:10

salut, je test un truc pour un future projet, j'aimerais avoir els avis de ça, et comment améliorer.
ont peux jouer avec WaitWindowEvent() en mettant un timer de 0 pour du temps réel et donc là l'affichage sera bien fluide, mais a contrario sa fai tourner le proco, et si on met plus, alors le proco tourne moins mais l'affichage est moins fluide, genre 1ms.

J'ai besoin de vos avis, voir ce qu'on pourais faire pour améliorer ça.
comme dis c'est pour un future projet, des chose seront dessiner sur le canevas et il faudra un affichage constant pour afficher les changement...

Je cherche a rendre sa facile d'utilisation, ici le principe c'est que je passe une image en paramètre de la procédure RefrechCanvas() et le programme se démerde a actualiser le canevas, mais c'est pas optimale c'est sur, ici c'est qu'un test, en réalité la procédure ne contiendra pas tous ce que j'y est mis, hormis les information sur l'affichage du canevas, qui pourra être activer ou non, bref.

Je pourais directement dessiner sur le canevas ce qui serais un peu plus rapide, je le sais j'ai fais des test mais c'est plus compliquer a gérer car il faudra passer par je pense un prototype pour dire au canevas d'afficher le truc.

j'étudie le module editors factory pour tenté de le refaire à ma sauce, et ya pas mal de truc que je dois comprendre pour ça, donc jle refais a mon rythme mais je fais des test et essais avant....

j'ai d'autre idée, mais je voulais avoir votre avis et si ont pouvais améliorer....
pourquoi pas utiliser le processeur graphique ???, je ne sais pas faire, ce serais peut être plus rapide ?

Pour l'image, prenez une image de par exemple 1920 x 1080 et mettez la fenêtre en agrandis.

Code : Tout sélectionner

Structure StructureRefrechCanvas
  
  RefrechCanvasActualTimeMs.i ; Le temps actuel en Millisecondes pour actualiser le Canaves.
  RefrechCanvasTotalTimeMsPerSecond.i ; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves, actualisé toutes les 1 seconde.
  RefrechCanvasTotalTimeMs.i          ; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves.
  RefrechCanvasMediumTimeMsPerFrame.f ; Le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
  RefrechCanvasActuelFrame.i      ; Le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves.
  RefrechCanvasTotaleFrame.i      ; Le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
  RefrechCanvasFramePerSecond.i       ; Le nombre de boucle accomplie en 1 secondes (FPS).
  RefrechCanvasMediumFramePerSecond.f ; Le nombre de boucle moyen accomplie en 1 secondes.
  
EndStructure

Global RefrechCanvas.StructureRefrechCanvas

#Font = 1
LoadFont(#Font, "Cambria", 20, #PB_Font_HighQuality)

; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
Procedure.i GetRefrechCanvasActualTimeMs()
  ProcedureReturn RefrechCanvas\RefrechCanvasActualTimeMs
EndProcedure

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde..
Procedure.i GetRefrechCanvasTotalTimeMsPerSecond()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond
EndProcedure

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves
Procedure.i GetRefrechCanvasCanvasTotalTimeMs()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotalTimeMs
EndProcedure

; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde..
Procedure.f GetRefrechCanvasMediumTimeMsPerFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame
EndProcedure

; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
Procedure.f GetRefrechCanvasActuelFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasActuelFrame
EndProcedure

; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
Procedure GetRefrechCanvasTotalFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotaleFrame
EndProcedure

; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
Procedure GetRefrechCanvasFramePerSecond()
  ProcedureReturn RefrechCanvas\RefrechCanvasFramePerSecond
EndProcedure

; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
Procedure.f GetRefrechCanvasMediumFramePerSecond()
ProcedureReturn RefrechCanvas\RefrechCanvasMediumFramePerSecond
EndProcedure

Procedure.b RefrechCanvas(CanvasNumber.i, Images.i)
  
  Static Reset.b = #False
  
  T1.i = ElapsedMilliseconds()
  
  If Not IsGadget(CanvasNumber.i)
    ProcedureReturn #False
    
  ElseIf IsImage(Images.i)
    
      ; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
      TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
      
      ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
      TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
      
      ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
      TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
      
      ; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
      TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
      
      ; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
      NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
      
      ; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
      NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
      
      ; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
      NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
      
      ; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
      NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
       
      If StartVectorDrawing(CanvasVectorOutput(CanvasNumber.i))
        
      AddPathBox(0, 0, VectorOutputWidth(), VectorOutputHeight())
      VectorSourceColor(RGBA(255, 255, 255, 255))
      FillPath()
      DrawVectorImage(ImageID(Images.i))
      
      MovePathCursor(ImageWidth(Images.i) / 2, ImageHeight(Images.i) / 2)
      
      Angle.d = TempsTotaleMsParSecondeActualisationCanevas.i / (1000 / 360)
      
      RotateCoordinates((ImageWidth(Images.i) / 2), (ImageHeight(Images.i) / 2), Angle.d) ; rotation de -20 degrés autour du point(50, 50)
      
      AddPathLine((ImageWidth(Images.i) / 2), (ImageHeight(Images.i) / 2) - 300)
      VectorSourceColor(RGBA(255, 0, 0, 255))
      StrokePath(3)
      
      ResetCoordinates()
      
      For I = 1 To 5000
        AddPathCircle(Random(ImageWidth(Images.i), 1), Random(ImageHeight(Images.i), 1), 0.5)
        VectorSourceColor(RGBA(255, 255, 255, 255))
        StrokePath(1)
      Next
      
      X.i = 10
      Y.i = 10
      
      MovePathCursor(X.i, Y.i)
      
      VectorFont(FontID(#Font), 20)
      VectorSourceColor(RGBA(0, 0, 0, 255))
      
      DrawVectorText("Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles.")
      Y.i + 25
      MovePathCursor(X.i, Y.i)
      
      DrawVectorText("Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles.")
      
      StopVectorDrawing()
      
    EndIf
    
  Else
    ProcedureReturn #False
    
  EndIf
  
  T2.i = ElapsedMilliseconds()
  RefrechCanvasTime.i = T2.i - T1.i
  
  If Reset.b = #True
    Reset.b = #False
    RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond = 0 ; Le temps totale en Milliseconde qui a servie pour actualiser le Canaves est remis à 0.
    RefrechCanvas\RefrechCanvasActuelFrame = 0          ; Le nombre de boucle accomplie est remis à 0.
  EndIf
  
  RefrechCanvas\RefrechCanvasActualTimeMs = RefrechCanvasTime.i ; Le temps en Millisecondes pour actualiser le Canaves.
  RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond + RefrechCanvasTime.i ; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde..
  RefrechCanvas\RefrechCanvasTotalTimeMs + RefrechCanvasTime.i ; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves.
  RefrechCanvas\RefrechCanvasActuelFrame + 1 ; Le nombre de boucle accomplie actuellement.
  RefrechCanvas\RefrechCanvasTotaleFrame + 1 ; Le nombre de boucle accomplie totale.
  
  If RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond >= 1000 ; Si le temps totale en Milliseconde est égale ou supérieur à 1000 = 1 seconde.
    
    If RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = 0 ; Si le temps moyen en Millisecondes pour actualiser le Canaves est égale à 0.
      ; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale au temps totale qui ont servie pour actualiser celui-ci divisé par le nombre de boucle accomplie..
      RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)
    Else
      ; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale à lui même + (Le temps totale en Millisecondes
      ; pour actualiser le Canaves divisé par Le nombre de boucle accomplie) tous ça divisé par 2 pour faire la moyenne.
      RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame + (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)) / 2
    EndIf
    
    If RefrechCanvas\RefrechCanvasMediumFramePerSecond = 0 ; Si le nombre de boucle moyen accomplie est égale à 0.
      RefrechCanvas\RefrechCanvasMediumFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame ; Le nombre de boucle moyen accomplie sera égale au nombre de boucle accomplie.
    Else
      ; Le nombre de boucle moyen accomplie sera égale à lui même + au nombre de boucle accomplie, tous ça divisé par 2 pour faire la moyenne.
      RefrechCanvas\RefrechCanvasMediumFramePerSecond = (RefrechCanvas\RefrechCanvasMediumFramePerSecond + RefrechCanvas\RefrechCanvasActuelFrame) / 2
    EndIf
    
    ; Le nombre de boucle accomplie en 1 secondes (FPS).
    RefrechCanvas\RefrechCanvasFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame
    Reset.b = #True
    
  EndIf
  
  ProcedureReturn #True
  
EndProcedure

; ------------------- EXEMPLE ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

;{ Enumeration des Gadgets du programme à partir de 1.
Enumeration 1
  #Window
  #ScrollAreaGadget
  #CanvasGadget
  #ImageCanvasGadget
EndEnumeration
;}

; Création d'une fenêtre.
If OpenWindow(#Window, 0, 0, 800, 600, "Canvas Object Manager", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_SizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar) ; Code de la Fenêtre.
  WindowBounds(#Window, 400, 300, #PB_Ignore, #PB_Ignore) ; Dimensions Minimale et Maximale par défaut de la Fenêtre.
  
  ScrollAreaGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2, 1920, 1080, 50, #PB_ScrollArea_Flat) ; ScrollAreaGadget.
  
  ; Création d'un Canevas gadget.
  CanvasGadget(#CanvasGadget, 0, 0, 0, 0, #PB_Canvas_Keyboard)
  
  CloseGadgetList()                                                 ; Ferme la Gadget liste de ScrollAreaGadget.
  
  ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
  
  UseJPEGImageDecoder()
  LoadImage(#ImageCanvasGadget, "Chateau de Val, coreze.jpg")
  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  

  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  NewList ListeTimeRefrechCanvas.i()
  
  ;{ Événements de la fenêtre.
  Repeat ; Départ des évènements de boucle.
    
    EventWindows.i = WaitWindowEvent(0) ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la Fenêtre.
    WindowID.i = EventWindow()          ; La Fenêtre oû l'évènement c'est produit.
    GadgetID.i = EventGadget()          ; Pour savoir sur quel gadget c'est produis l'évènement.
    MenuID.i = EventMenu()              ; Pour savoir sur quel menue c'est produis l'évènement.
    EventType.i = EventType()           ; Le type d'évènement qui c'est produis sur le gadget.
    EventTimer.i = EventTimer()         ; Le num?ro du timer ou s'est produit l'évènement (Le temps du minuteur s'est écoulé).
    
    If RefrechCanvas(#CanvasGadget, #ImageCanvasGadget)
      
;       ; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
;       TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
;       
;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
;       TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
;       
;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
;       TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
;       
;       ; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
;       TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
;       
;       ; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
;       NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
;       
;       ; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
;       NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
;       
;       ; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
;       NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
;       
;       ; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
;       NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
;       
;       ClearDebugOutput()
;       
;       Debug "Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms."
;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms."
;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms."
;       Debug "Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms."
;       Debug "Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles."
;       Debug "Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles."
;       Debug "Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles."
;       Debug "Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles."
      
    EndIf
    
    Select EventWindows ; Quel Evenement de la fenêtre est survenue.
        
      Case #PB_Event_Gadget ; Un évènement c'est passé sur un gadget.
        
        If GadgetID.i = #CanvasGadget
          
        EndIf
        
        
      Case #PB_Event_Menu ; Un menu a été sélectionné.
        
      Case #PB_Event_Timer ; Le temps d'un minuteur s'est écoulé.
        
      Case #PB_Event_Repaint ; Tout ou une partie du contenu de la fenêtre a été détruit et doit être reconstitué.
        
      Case #PB_Event_SizeWindow
        ResizeGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2) ; ScrollAreaGadget.
        ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
        
      Case #PB_Event_CloseWindow ; L'icône de fermeture de la fenêtre a été cliquée.
        
    EndSelect
    
  Until EventWindows.i = #PB_Event_CloseWindow ; Termine la boucle de la fenêtre.
  
EndIf

Mesa · Message par **Mesa** » ven. 28/janv./2022 11:01

Je gagne un tout petit peu de temps avec un thread.
Sinon il faudrait passer par les sprites pour un maximum d'efficacité.

Code : Tout sélectionner

CompilerIf Not #PB_Compiler_Thread 
	CompilerError "METTRE l'Option du Compilateur sur ThreadSafe !" 
CompilerEndIf

;{ Enumeration des Gadgets du programme à partir de 1.
Enumeration 1
	#Window
	#ScrollAreaGadget
	#CanvasGadget
	#ImageCanvasGadget
EndEnumeration
;}

Structure StructureRefrechCanvas
	
	RefrechCanvasActualTimeMs.i ; Le temps actuel en Millisecondes pour actualiser le Canaves.
	RefrechCanvasTotalTimeMsPerSecond.i ; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves, actualisé toutes les 1 seconde.
	RefrechCanvasTotalTimeMs.i					; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves.
	RefrechCanvasMediumTimeMsPerFrame.f	; Le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
	RefrechCanvasActuelFrame.i					; Le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves.
	RefrechCanvasTotaleFrame.i					; Le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
	RefrechCanvasFramePerSecond.i				; Le nombre de boucle accomplie en 1 secondes (FPS).
	RefrechCanvasMediumFramePerSecond.f	; Le nombre de boucle moyen accomplie en 1 secondes.
	
EndStructure

Global RefrechCanvas.StructureRefrechCanvas

#Font = 1
LoadFont(#Font, "Cambria", 20, #PB_Font_HighQuality)

; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
Macro GetRefrechCanvasActualTimeMs()
	RefrechCanvas\RefrechCanvasActualTimeMs
EndMacro

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde..
Macro GetRefrechCanvasTotalTimeMsPerSecond()
	RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond
EndMacro

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves
Macro GetRefrechCanvasCanvasTotalTimeMs()
	RefrechCanvas\RefrechCanvasTotalTimeMs
EndMacro

; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde..
Macro GetRefrechCanvasMediumTimeMsPerFrame()
	RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame
EndMacro

; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
Macro GetRefrechCanvasActuelFrame()
	RefrechCanvas\RefrechCanvasActuelFrame
EndMacro

; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
Macro GetRefrechCanvasTotalFrame()
	RefrechCanvas\RefrechCanvasTotaleFrame
EndMacro

; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
Macro GetRefrechCanvasFramePerSecond()
	RefrechCanvas\RefrechCanvasFramePerSecond
EndMacro

; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
Macro GetRefrechCanvasMediumFramePerSecond()
	RefrechCanvas\RefrechCanvasMediumFramePerSecond
EndMacro

; Threaded Reset.b
Procedure.b RefrechCanvas(*ok)
	CanvasNumber=PeekI(*ok);#CanvasGadget
	Images=PeekI(*ok+4)		 ;#ImageCanvasGadget
	
	Static Reset.b = #False
	; 	Reset = #False; Threaded
	Repeat
		T1.i = ElapsedMilliseconds()
		
		
		;     
		; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
		TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
		
		; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
		TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
		
		; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
		TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
		
		; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
		TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
		
		; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
		NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
		
		; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
		NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
		
		; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
		NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
		
		; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
		NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
		
		If StartVectorDrawing(CanvasVectorOutput(CanvasNumber.i))
			
			AddPathBox(0, 0, VectorOutputWidth(), VectorOutputHeight())
			VectorSourceColor(RGBA(255, 255, 255, 255))
			FillPath()
			DrawVectorImage(ImageID(Images.i))
			
			MovePathCursor(ImageWidth(Images.i) / 2, ImageHeight(Images.i) / 2)
			
			Angle.d = TempsTotaleMsParSecondeActualisationCanevas.i / (1000 / 360)
			
			RotateCoordinates((ImageWidth(Images.i) / 2), (ImageHeight(Images.i) / 2), Angle.d) ; rotation de -20 degrés autour du point(50, 50)
			
			AddPathLine((ImageWidth(Images.i) / 2), (ImageHeight(Images.i) / 2) - 300)
			VectorSourceColor(RGBA(255, 0, 0, 255))
			StrokePath(3)
			
			ResetCoordinates()
			
			For I = 1 To 5000
				AddPathCircle(Random(ImageWidth(Images.i), 1), Random(ImageHeight(Images.i), 1), 0.5)
				VectorSourceColor(RGBA(255, 255, 255, 255))
				StrokePath(1)
			Next
			
			X.i = 10
			Y.i = 10
			
			MovePathCursor(X.i, Y.i)
			
			VectorFont(FontID(#Font), 20)
			VectorSourceColor(RGBA(0, 0, 0, 255))
			
			DrawVectorText("Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles.")
			Y.i + 25
			MovePathCursor(X.i, Y.i)
			
			DrawVectorText("Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles.")
			
			StopVectorDrawing()
			
		EndIf
		
		;   Else
		;     ProcedureReturn #False
		;     
		;   EndIf
		
		T2.i = ElapsedMilliseconds()
		RefrechCanvasTime.i = T2.i - T1.i
		
		If Reset.b = #True
			Reset.b = #False
			RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond = 0 ; Le temps totale en Milliseconde qui a servie pour actualiser le Canaves est remis à 0.
			RefrechCanvas\RefrechCanvasActuelFrame = 0					; Le nombre de boucle accomplie est remis à 0.
		EndIf
		
		RefrechCanvas\RefrechCanvasActualTimeMs = RefrechCanvasTime.i ; Le temps en Millisecondes pour actualiser le Canaves.
		RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond + RefrechCanvasTime.i ; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde..
		RefrechCanvas\RefrechCanvasTotalTimeMs + RefrechCanvasTime.i					; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves.
		RefrechCanvas\RefrechCanvasActuelFrame + 1														; Le nombre de boucle accomplie actuellement.
		RefrechCanvas\RefrechCanvasTotaleFrame + 1														; Le nombre de boucle accomplie totale.
		
		If RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond >= 1000 ; Si le temps totale en Milliseconde est égale ou supérieur à 1000 = 1 seconde.
			
			If RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = 0 ; Si le temps moyen en Millisecondes pour actualiser le Canaves est égale à 0.
																														 ; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale au temps totale qui ont servie pour actualiser celui-ci divisé par le nombre de boucle accomplie..
				RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)
			Else
				; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale à lui même + (Le temps totale en Millisecondes
				; pour actualiser le Canaves divisé par Le nombre de boucle accomplie) tous ça divisé par 2 pour faire la moyenne.
				RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame + (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)) / 2
			EndIf
			
			If RefrechCanvas\RefrechCanvasMediumFramePerSecond = 0 ; Si le nombre de boucle moyen accomplie est égale à 0.
				RefrechCanvas\RefrechCanvasMediumFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame ; Le nombre de boucle moyen accomplie sera égale au nombre de boucle accomplie.
			Else
				; Le nombre de boucle moyen accomplie sera égale à lui même + au nombre de boucle accomplie, tous ça divisé par 2 pour faire la moyenne.
				RefrechCanvas\RefrechCanvasMediumFramePerSecond = (RefrechCanvas\RefrechCanvasMediumFramePerSecond + RefrechCanvas\RefrechCanvasActuelFrame) / 2
			EndIf
			
			; Le nombre de boucle accomplie en 1 secondes (FPS).
			RefrechCanvas\RefrechCanvasFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame
			Reset.b = #True
			
		EndIf
		
		;   ProcedureReturn #True
		Delay(1) ; important il faut placer un petit delay 
	ForEver
EndProcedure

; ------------------- EXEMPLE ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------



; Création d'une fenêtre.
If OpenWindow(#Window, 0, 0, 800, 600, "Canvas Object Manager", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_SizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar) ; Code de la Fenêtre.
	WindowBounds(#Window, 400, 300, #PB_Ignore, #PB_Ignore)																																																																																 ; Dimensions Minimale et Maximale par défaut de la Fenêtre.
	
	ScrollAreaGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2, 1920, 1080, 50, #PB_ScrollArea_Flat) ; ScrollAreaGadget.
	
	; Création d'un Canevas gadget.
	CanvasGadget(#CanvasGadget, 0, 0, 0, 0, #PB_Canvas_Keyboard)
	
	CloseGadgetList()                                                 ; Ferme la Gadget liste de ScrollAreaGadget.
	
	ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
	
	UseJPEGImageDecoder()
	LoadImage(#ImageCanvasGadget, "F:\Alexis-Bledel-see-through.jpg")
	
	; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	
	
	; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
	
	NewList ListeTimeRefrechCanvas.i()
	Dim can.i(1)
	can(0)=#CanvasGadget
	can(1)= #ImageCanvasGadget
	
	If Bool(IsGadget(#CanvasGadget) And IsImage(#ImageCanvasGadget)) = #True
		CreateThread(@RefrechCanvas(), @can())
	EndIf
	
	;- loop
	;{ Événements de la fenêtre.
	Repeat ; Départ des évènements de boucle.
		
		EventWindows.i = WaitWindowEvent(0) ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la Fenêtre.
		WindowID.i = EventWindow()					; La Fenêtre oû l'évènement c'est produit.
		GadgetID.i = EventGadget()					; Pour savoir sur quel gadget c'est produis l'évènement.
		MenuID.i = EventMenu()							; Pour savoir sur quel menue c'est produis l'évènement.
		EventType.i = EventType()						; Le type d'évènement qui c'est produis sur le gadget.
		EventTimer.i = EventTimer()					; Le num?ro du timer ou s'est produit l'évènement (Le temps du minuteur s'est écoulé).
		
		; ;     If RefrechCanvas(#CanvasGadget, #ImageCanvasGadget)
		
		;       ; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
		;       TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
		;       
		;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
		;       TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
		;       
		;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
		;       TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
		;       
		;       ; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
		;       TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
		;       
		;       ; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
		;       NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
		;       
		;       ; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
		;       NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
		;       
		;       ; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
		;       NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
		;       
		;       ; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
		;       NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
		;       
		;       ClearDebugOutput()
		;       
		;       Debug "Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms."
		;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms."
		;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms."
		;       Debug "Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms."
		;       Debug "Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles."
		;       Debug "Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles."
		;       Debug "Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles."
		;       Debug "Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles."
		
		;     EndIf
		
		Select EventWindows ; Quel Evenement de la fenêtre est survenue.
				
			Case #PB_Event_Gadget ; Un évènement c'est passé sur un gadget.
				
				If GadgetID.i = #CanvasGadget
					
				EndIf
				
				
			Case #PB_Event_Menu ; Un menu a été sélectionné.
				
			Case #PB_Event_Timer ; Le temps d'un minuteur s'est écoulé.
				
				;       Case #PB_Event_Repaint ; Tout ou une partie du contenu de la fenêtre a été détruit et doit être reconstitué.
				
			Case #PB_Event_SizeWindow
				ResizeGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2) ; ScrollAreaGadget.
				ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
				
			Case #PB_Event_CloseWindow ; L'icône de fermeture de la fenêtre a été cliquée.
				
		EndSelect
		
	Until EventWindows.i = #PB_Event_CloseWindow ; Termine la boucle de la fenêtre.
	
EndIf

M.

Shadow · Message par **Shadow** » ven. 28/janv./2022 19:57

Salut,

Merci Mesa

J'ai fais ceci plutôt, tu en pense quoi ?

Code : Tout sélectionner


Structure StructureRefrechCanvas
  
  CanvasNumber.i
  CanvasImages.i
  RefrechCanvasActualTimeMs.i ; Le temps actuel en Millisecondes pour actualiser le Canaves.
  RefrechCanvasTotalTimeMsPerSecond.i ; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves, actualisé toutes les 1 seconde.
  RefrechCanvasTotalTimeMs.i          ; Totale de tous les temps en Millisecondes qui ont servie pour actualiser le Canaves.
  RefrechCanvasMediumTimeMsPerFrame.f ; Le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
  RefrechCanvasActuelFrame.i      ; Le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves.
  RefrechCanvasTotaleFrame.i      ; Le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
  RefrechCanvasFramePerSecond.i       ; Le nombre de boucle accomplie en 1 secondes (FPS).
  RefrechCanvasMediumFramePerSecond.f ; Le nombre de boucle moyen accomplie en 1 secondes.
  
EndStructure

Global RefrechCanvas.StructureRefrechCanvas

#Font = 1
LoadFont(#Font, "Cambria", 20, #PB_Font_HighQuality)

; Renvoie le temps actuel en Millisecondes qu'il a fallut pour actualiser le Canaves.
Procedure.i GetRefrechCanvasActualTimeMs()
  ProcedureReturn RefrechCanvas\RefrechCanvasActualTimeMs
EndProcedure

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
Procedure.i GetRefrechCanvasTotalTimeMsPerSecond()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond
EndProcedure

; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
Procedure.i GetRefrechCanvasCanvasTotalTimeMs()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotalTimeMs
EndProcedure

; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
Procedure.f GetRefrechCanvasMediumTimeMsPerFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame
EndProcedure

; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
Procedure.f GetRefrechCanvasActuelFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasActuelFrame
EndProcedure

; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
Procedure GetRefrechCanvasTotalFrame()
  ProcedureReturn RefrechCanvas\RefrechCanvasTotaleFrame
EndProcedure

; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
Procedure GetRefrechCanvasFramePerSecond()
  ProcedureReturn RefrechCanvas\RefrechCanvasFramePerSecond
EndProcedure

; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
Procedure.f GetRefrechCanvasMediumFramePerSecond()
ProcedureReturn RefrechCanvas\RefrechCanvasMediumFramePerSecond
EndProcedure

Procedure.b RefrechCanvas(Valeur.i)
  
  Static Reset.b = #False
  
  CanvasNumber.i = RefrechCanvas\CanvasNumber
  CanvasImages.i = RefrechCanvas\CanvasImages
  
  If Not IsGadget(CanvasNumber.i)
    ProcedureReturn #False
    
  ElseIf IsImage(CanvasImages.i)
    
    Repeat
      
  T1.i = ElapsedMilliseconds()
  
      ; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
      TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
      
      ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
      TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
      
      ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
      TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
      
      ; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
      TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
      
      ; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
      NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
      
      ; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
      NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
      
      ; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
      NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
      
      ; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
      NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
      
      If StartVectorDrawing(CanvasVectorOutput(CanvasNumber.i))
        
        AddPathBox(0, 0, VectorOutputWidth(), VectorOutputHeight())
        VectorSourceColor(RGBA(255, 255, 255, 255))
        FillPath()
        DrawVectorImage(ImageID(CanvasImages.i))
        
        MovePathCursor(ImageWidth(CanvasImages.i) / 2, ImageHeight(CanvasImages.i) / 2)
        
        Angle.d = TempsTotaleMsParSecondeActualisationCanevas.i / (1000 / 360)
        
        RotateCoordinates((ImageWidth(CanvasImages.i) / 2), (ImageHeight(CanvasImages.i) / 2), Angle.d) ; rotation de -20 degrés autour du point(50, 50)
        
        AddPathLine((ImageWidth(CanvasImages.i) / 2), (ImageHeight(CanvasImages.i) / 2) - 300)
        VectorSourceColor(RGBA(255, 0, 0, 255))
        StrokePath(3)
        
        ResetCoordinates()
        
        For I = 1 To 5000
          AddPathCircle(Random(ImageWidth(CanvasImages.i), 1), Random(ImageHeight(CanvasImages.i), 1), 0.5)
          VectorSourceColor(RGBA(255, 255, 255, 255))
          StrokePath(1)
        Next
        
        X.i = 10
        Y.i = 10
        
        MovePathCursor(X.i, Y.i)
        
        VectorFont(FontID(#Font), 20)
        VectorSourceColor(RGBA(0, 0, 0, 255))
        
        DrawVectorText("Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles.")
        Y.i + 25
        MovePathCursor(X.i, Y.i)
        
        DrawVectorText("Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles.")
        
        StopVectorDrawing()
        
      EndIf
      
      T2.i = ElapsedMilliseconds()
      RefrechCanvasTime.i = T2.i - T1.i
      
      If Reset.b = #True
        Reset.b = #False
        RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond = 0 ; Le temps totale en Milliseconde qui a servie pour actualiser le Canaves est remis à 0.
        RefrechCanvas\RefrechCanvasActuelFrame = 0          ; Le nombre de boucle accomplie est remis à 0.
      EndIf
      
      RefrechCanvas\RefrechCanvasActualTimeMs = RefrechCanvasTime.i ; Le temps en Millisecondes pour actualiser le Canaves.
      RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond + RefrechCanvasTime.i ; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde..
      RefrechCanvas\RefrechCanvasTotalTimeMs + RefrechCanvasTime.i          ; Tous les temps en Millisecondes qui sont additionné qui ont servie pour actualiser le Canaves.
      RefrechCanvas\RefrechCanvasActuelFrame + 1                            ; Le nombre de boucle accomplie actuellement.
      RefrechCanvas\RefrechCanvasTotaleFrame + 1                            ; Le nombre de boucle accomplie totale.
      
      If RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond >= 1000 ; Si le temps totale en Milliseconde est égale ou supérieur à 1000 = 1 seconde.
        
        If RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = 0 ; Si le temps moyen en Millisecondes pour actualiser le Canaves est égale à 0.
                                                               ; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale au temps totale qui ont servie pour actualiser celui-ci divisé par le nombre de boucle accomplie..
          RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)
        Else
          ; Le temps moyen en Millisecondes pour actualiser le Canaves sera égale à lui même + (Le temps totale en Millisecondes
          ; pour actualiser le Canaves divisé par Le nombre de boucle accomplie) tous ça divisé par 2 pour faire la moyenne.
          RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame = (RefrechCanvas\RefrechCanvasMediumTimeMsPerFrame + (RefrechCanvas\RefrechCanvasTotalTimeMsPerSecond / RefrechCanvas\RefrechCanvasActuelFrame)) / 2
        EndIf
        
        If RefrechCanvas\RefrechCanvasMediumFramePerSecond = 0 ; Si le nombre de boucle moyen accomplie est égale à 0.
          RefrechCanvas\RefrechCanvasMediumFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame ; Le nombre de boucle moyen accomplie sera égale au nombre de boucle accomplie.
        Else
          ; Le nombre de boucle moyen accomplie sera égale à lui même + au nombre de boucle accomplie, tous ça divisé par 2 pour faire la moyenne.
          RefrechCanvas\RefrechCanvasMediumFramePerSecond = (RefrechCanvas\RefrechCanvasMediumFramePerSecond + RefrechCanvas\RefrechCanvasActuelFrame) / 2
        EndIf
        
        ; Le nombre de boucle accomplie en 1 secondes (FPS).
        RefrechCanvas\RefrechCanvasFramePerSecond = RefrechCanvas\RefrechCanvasActuelFrame
        Reset.b = #True
        
      EndIf
      
    ForEver
    
  Else
    ProcedureReturn #False
    
  EndIf
  
EndProcedure

; ------------------- EXEMPLE ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

;{ Enumeration des Gadgets du programme à partir de 1.
Enumeration 1
  #Window
  #ScrollAreaGadget
  #CanvasGadget
  #ImageCanvasGadget
EndEnumeration
;}

; Création d'une fenêtre.
If OpenWindow(#Window, 0, 0, 800, 600, "Canvas Object Manager", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_SizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar) ; Code de la Fenêtre.
  WindowBounds(#Window, 400, 300, #PB_Ignore, #PB_Ignore) ; Dimensions Minimale et Maximale par défaut de la Fenêtre.
  
  ScrollAreaGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2, 1920, 1080, 50, #PB_ScrollArea_Flat) ; ScrollAreaGadget.
  
  ; Création d'un Canevas gadget.
  CanvasGadget(#CanvasGadget, 0, 0, 0, 0, #PB_Canvas_Keyboard)
  
  CloseGadgetList()                                                 ; Ferme la Gadget liste de ScrollAreaGadget.
  
  ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
  
  UseJPEGImageDecoder()
  LoadImage(#ImageCanvasGadget, "Chateau de Val, coreze.jpg")
  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  ;*Parametres.StructureRefrechCanvas = AllocateMemory(SizeOf(StructureRefrechCanvas))
  RefrechCanvas\CanvasNumber = #CanvasGadget
  RefrechCanvas\CanvasImages = #ImageCanvasGadget
  
  CreateThread(@RefrechCanvas(), 0)
  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  ;{ Événements de la fenêtre.
  Repeat ; Départ des évènements de boucle.
    
    EventWindows.i = WaitWindowEvent() ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la Fenêtre.
    WindowID.i = EventWindow()          ; La Fenêtre oû l'évènement c'est produit.
    GadgetID.i = EventGadget()          ; Pour savoir sur quel gadget c'est produis l'évènement.
    MenuID.i = EventMenu()              ; Pour savoir sur quel menue c'est produis l'évènement.
    EventType.i = EventType()           ; Le type d'évènement qui c'est produis sur le gadget.
    EventTimer.i = EventTimer()         ; Le num?ro du timer ou s'est produit l'évènement (Le temps du minuteur s'est écoulé).
    
;     If RefrechCanvas(#CanvasGadget, #ImageCanvasGadget)
;       
; ;       ; Renvoie le temps actuel en Millisecondes pour actualiser le Canaves.
; ;       TempsActuelMsActualisationCanevas.i = GetRefrechCanvasActualTimeMs()
; ;       
; ;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
; ;       TempsTotaleMsParSecondeActualisationCanevas.i = GetRefrechCanvasTotalTimeMsPerSecond()
; ;       
; ;       ; Renvoie le temps totale en Millisecondes qui ont servie pour actualiser le Canaves.
; ;       TempsTotaleMsActualisationCanevas.i = GetRefrechCanvasCanvasTotalTimeMs()
; ;       
; ;       ; Renvoie le temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde.
; ;       TempsMoyenMsActualisationCanevas.f = GetRefrechCanvasMediumTimeMsPerFrame()
; ;       
; ;       ; Renvoie le nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde.
; ;       NombreBoucleActuelActualisationCanevas.i = GetRefrechCanvasActuelFrame()
; ;       
; ;       ; Renvoie le nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves.
; ;       NombreBoucleTotaleActualisationCanevas.i = GetRefrechCanvasTotalFrame()
; ;       
; ;       ; Renvoie le nombre de boucle accomplie en 1 secondes (FPS).
; ;       NombreBoucleActualisationCanevasParSeconde.i = GetRefrechCanvasFramePerSecond()
; ;       
; ;       ; Renvoie le nombre de boucle moyen accomplie en 1 secondes (FPS).
; ;       NombreBoucleMoyenActualisationCanevasParSeconde.f = GetRefrechCanvasMediumFramePerSecond()
; ;       
; ;       ClearDebugOutput()
; ;       
; ;       Debug "Temps actuel en Millisecondes pour actualiser le Canaves = " + Str(TempsActuelMsActualisationCanevas.i) + " Ms."
; ;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(TempsTotaleMsParSecondeActualisationCanevas.i) + " Ms."
; ;       Debug "Temps totale en Millisecondes qui ont servie pour actualiser le Canaves = " + Str(TempsTotaleMsActualisationCanevas.i) + " Ms."
; ;       Debug "Temps moyen en Millisecondes pour actualiser le Canaves, actualisé toutes les 1 seconde = " + StrF(TempsMoyenMsActualisationCanevas.f, 3) + " Ms."
; ;       Debug "Nombre de boucle actuel accomplie qui ont servie pour actualiser le Canaves, remis à 0 toutes les 1 seconde = " + Str(NombreBoucleActuelActualisationCanevas.i) + " Boucles."
; ;       Debug "Nombre de boucle totale accomplie qui ont servie pour actualiser le Canaves = " + Str(NombreBoucleTotaleActualisationCanevas.i) + " Boucles."
; ;       Debug "Nombre de boucle accomplie en 1 secondes (FPS) = " + Str(NombreBoucleActualisationCanevasParSeconde.i) + " Boucles."
; ;       Debug "Nombre de boucle moyen accomplie en 1 secondes (FPS) = " + StrF(NombreBoucleMoyenActualisationCanevasParSeconde.f, 3) + " Boucles."
;       
;     EndIf
    
    Select EventWindows ; Quel Evenement de la fenêtre est survenue.
        
      Case #PB_Event_Gadget ; Un évènement c'est passé sur un gadget.
        
        If GadgetID.i = #CanvasGadget
          
        EndIf
        
        
      Case #PB_Event_Menu ; Un menu a été sélectionné.
        
      Case #PB_Event_Timer ; Le temps d'un minuteur s'est écoulé.
        
      Case #PB_Event_Repaint ; Tout ou une partie du contenu de la fenêtre a été détruit et doit être reconstitué.
        
      Case #PB_Event_SizeWindow
        ResizeGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2) ; ScrollAreaGadget.
        ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
        
      Case #PB_Event_CloseWindow ; L'icône de fermeture de la fenêtre a été cliquée.
        
    EndSelect
    
  Until EventWindows.i = #PB_Event_CloseWindow ; Termine la boucle de la fenêtre.
  
EndIf

Mesa · Message par **Mesa** » sam. 29/janv./2022 9:52

C'est bien aussi

.

M.

Shadow · Message par **Shadow** » sam. 29/janv./2022 12:07

Merci.

Mais je pense que ça pourais être mieux encore, le thread est une excellente idée car il permet dans le programme
ici de gérer en même temps les évènement de la fenêtre et l'affichage de canevas.

Le truc que tu vois dans le Canvas est juste un test avec l'image est les petits point blanc qui apparaisse et la ligne rouge qui tourne.
Chez moi je tourne a environ 44 FPS (boucles), c'est pas si mal je pense.

Ce qui me chagrine un peu c'est toutes ses valeurs pour gérer la calcule des FPS, je pense qu'on dois pouvoir faire mieux ?
Et jme dis que si c'était gérer par le processeur graphique sa irais plus vite.
Merci.

microdevweb · Message par **microdevweb** » mer. 02/févr./2022 9:00

Bonjour Shadow,

Si tu veux rafraîchir une canvas automatiquement, la meilleure solution est, je pense l'utilisation d'un Thread. Sans cela, le programme sera bloqué pendant que ta routine travaille. Tu as même de la chance Pb permet la mise à jour des composants Windows dans un thread (ce qui n'est pas le cas avec d'autres langages comme Java, C# etc...).

Tu dois juste faire une boucle infinie dans ta fonction thread, attention, il vaut mieux placé un léger delay dans la boucle pour que mcu respire un peu.

Je te conseille également de placer un flag qui sera utilisé pour savoir s'il a lieu ou non de rafraîchir le canvas.

Cordialement,

Shadow · Message par **Shadow** » mer. 02/févr./2022 23:58

Salut, microdevweb
Oui, tu as raison, c'est ce que j'ai fais, une autre personne m'avais dit de faire ça aussi.
Merci.

Je poste un code, il n'est pas finie encore, je suis dessus depuis un moment pour l'optimiser.
Je le mettrais à jour, plus tard quand je l'aurais fini.
J'ai encore un peu de travail à faire.

Code : Tout sélectionner

Structure CanvasDrawingLManager
  
  ; Si le canevas est intitialisé (#True) ou non (#False).
  CanvasInit.b
  
  ; Le numéro du canevas.
  CanvasNumber.i
  
  ; Le numéro du Thread du canevas.
  CanvasThread.i
  
  ; Le delais entre chaque boucle d'affichage du canevas.
  CanvasThreadDelay.i
  
  ; La priorité du thread du canevas qui gère l'affichage de celui-ci.
  CanvasThreadPriority.i

  ; Le numéro de l'image qui serra affiché sur le canevas.
  CanvasImageNumber.i
  
  ; Le numéro du font utilisé pour afficher les information sur le canevas.
  CanvasFontIDTextInfo.i
  
  ; Affiche (#True) ou masque (#False) les FPS (Frame (Boucle) par seconde), utile pour savoir le nombre de fois ou l'image du canevas a été actualisé (Redéssiné).
  CanvasPrintFPS.b
  
  ; Le temps de la boucle (Frame) actuel d'affichage du canevas.
  CanvasTimeLoop.i
  
  ; Le temps totale de toutes les boucles (Frame) d'affichage du canevas, remis à 0 toutes les 1 seconde.
  CanvasTotaleTimeLoop.i
  
  ; Le nombre de boucle (Frame) actuel accomplie, remis à 0 toutes les 1 seconde.
  CanvasLoop.i
  
  ; Le nombre de boucle (Frame) accomplie en 1 seconde, actualisé toutes les 1 seconde.
  CanvasFPS.i
  
EndStructure

Global CanvasDrawingLManager.CanvasDrawingLManager

; Le thread qui va gèrer l'affichage sur le canevas.
Procedure ThreadCanvasDrawingLManager(Delay.i)
  
  Repeat
    
    TimeStart.i = ElapsedMilliseconds()
    
    If StartVectorDrawing(CanvasVectorOutput(CanvasDrawingLManager\CanvasNumber))
      
      ; Affiche l'image sur le canevas
      DrawVectorImage(ImageID(CanvasDrawingLManager\CanvasImageNumber))
      
      ; Si l'affichage des FPS est autorisé.
      If CanvasDrawingLManager\CanvasPrintFPS = #True
        MovePathCursor(10, 10)
        VectorFont(FontID(CanvasDrawingLManager\CanvasFontIDTextInfo), 30)
        VectorSourceColor(RGBA(255, 255, 255, 255))
        AddPathText("FPS = " + Str(CanvasDrawingLManager\CanvasFPS))
        StrokePath(3)
      EndIf
      
      StopVectorDrawing()
      
    EndIf
    
    Delay(Delay.i)
    
    TimeEnd.i = ElapsedMilliseconds()
    
    ; Le temps de celle boucle.
    CanvasDrawingLManager\CanvasTimeLoop = (TimeEnd.i - TimeStart.i)
    
    ; Le temps totale de toutes les boucles.
    CanvasDrawingLManager\CanvasTotaleTimeLoop + CanvasDrawingLManager\CanvasTimeLoop
    
    ; Le nombre de boucle actuel.
    CanvasDrawingLManager\CanvasLoop + 1
    
    ; Si une seconde s'est écoulé.
    If CanvasDrawingLManager\CanvasTotaleTimeLoop >= 1000
      
      ; Le nombre de boucle faite en 1 seconde.
      CanvasDrawingLManager\CanvasFPS = CanvasDrawingLManager\CanvasLoop
      
      ; ; Le temps totale de toutes les boucles, remis à 0.
      CanvasDrawingLManager\CanvasTotaleTimeLoop = 0
      
      ; Le nombre de boucle actuel est remis à 0.
      CanvasDrawingLManager\CanvasLoop = 0
      
    EndIf
    
  ForEver
  
EndProcedure

; Initialise la gestion du canevas pour gèrer l'affichage automatiquement de celui-ci.
Procedure.b InitCanvasDrawingLManager(CanvasNumber.i, CanvasImageNumber.i, PrintFPS.b = #False, Delay.i = 0, Priority.i = 0)
  
  If IsGadget(CanvasNumber.i) And IsImage(CanvasImageNumber.i) And CanvasDrawingLManager\CanvasInit.b = #False
    
    CanvasDrawingLManager\CanvasNumber = CanvasNumber.i
    CanvasDrawingLManager\CanvasImageNumber = CanvasImageNumber.i
    CanvasDrawingLManager\CanvasPrintFPS = PrintFPS.b
    
    If Delay.i < 0
      Delay.i = 0
    EndIf
    
    Thread.i = CreateThread(@ThreadCanvasDrawingLManager(), Delay.i)
    
    If IsThread(Thread.i)
      
      If Priority.i < 0
        Priority.i = 0
      ElseIf Priority.i > 32
        Priority.i = 32
      EndIf
      
      Font.i = LoadFont(#PB_Any, "Cambria", 30, #PB_Font_HighQuality)
      
      If IsFont(Font.i)
        CanvasDrawingLManager\CanvasFontIDTextInfo = Font.i
      EndIf
      
      ThreadPriority(Thread.i, Priority.i)
      CanvasDrawingLManager\CanvasThread = Thread.i
      CanvasDrawingLManager\CanvasThreadDelay.i = Delay.i
      CanvasDrawingLManager\CanvasThreadPriority = Priority.i
      CanvasDrawingLManager\CanvasInit.b = #True
      
      ProcedureReturn #True
      
    EndIf
    
  EndIf
  
  ProcedureReturn #False
  
EndProcedure

; ------------------- EXEMPLE ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

;{ Enumeration des Gadgets du programme à partir de 1.
Enumeration 1
  #Window
  #ScrollAreaGadget
  #CanvasGadget
  #CanvasFontText
  #ImageCanvasGadget
EndEnumeration
;}

; Création d'une fenêtre.
If OpenWindow(#Window, 0, 0, 800, 600, "Canvas Object Manager", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_SizeGadget | #PB_Window_ScreenCentered | #PB_Window_TitleBar) ; Code de la Fenêtre.
  WindowBounds(#Window, 400, 300, #PB_Ignore, #PB_Ignore)                                                                                                                                                                ; Dimensions Minimale et Maximale par défaut de la Fenêtre.
  
  ScrollAreaGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2, 1920, 1080, 50, #PB_ScrollArea_Flat) ; ScrollAreaGadget.
  
  ; Création d'un Canevas gadget.
  CanvasGadget(#CanvasGadget, 0, 0, 0, 0, #PB_Canvas_Keyboard)
  
  CloseGadgetList()                                                 ; Ferme la Gadget liste de ScrollAreaGadget.
  
  ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
  
  UseJPEGImageDecoder()
  LoadImage(#ImageCanvasGadget, "Chateau de Val, coreze.jpg")
  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  If InitCanvasDrawingLManager(#CanvasGadget, #ImageCanvasGadget, #True, 0)
    Debug 1
  EndIf
  
  ; ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  
  ;{ Événements de la fenêtre.
  Repeat ; Départ des évènements de boucle.
    
    EventWindows.i = WaitWindowEvent(1) ; Cette ligne attend pendent (Minuteur) qu'un évènement soit recus par la Fenêtre.
    WindowID.i = EventWindow()         ; La Fenêtre oû l'évènement c'est produit.
    GadgetID.i = EventGadget()         ; Pour savoir sur quel gadget c'est produis l'évènement.
    MenuID.i = EventMenu()             ; Pour savoir sur quel menue c'est produis l'évènement.
    EventType.i = EventType()          ; Le type d'évènement qui c'est produis sur le gadget.
    EventTimer.i = EventTimer()        ; Le num?ro du timer ou s'est produit l'évènement (Le temps du minuteur s'est écoulé).
    
    ClearDebugOutput()
    Debug CanvasDrawingLManager\CanvasFPS
    
    Select EventWindows ; Quel Evenement de la fenêtre est survenue.
        
      Case #PB_Event_Gadget ; Un évènement c'est passé sur un gadget.
        
        If GadgetID.i = #CanvasGadget
          
          If EventType.i = #PB_EventType_MouseMove
            

          EndIf
          
        EndIf
        
      Case #PB_Event_Menu ; Un menu a été sélectionné.
        
      Case #PB_Event_Timer ; Le temps d'un minuteur s'est écoulé.
        
      Case #PB_Event_Repaint ; Tout ou une partie du contenu de la fenêtre a été détruit et doit être reconstitué.
        
      Case #PB_Event_SizeWindow
        ResizeGadget(#ScrollAreaGadget, 1, 1, WindowWidth(#Window) - 2, WindowHeight(#Window) - 2) ; ScrollAreaGadget.
        ResizeGadget(#CanvasGadget, 0, 0, GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerWidth), GetGadgetAttribute(#ScrollAreaGadget, #PB_ScrollArea_InnerHeight)) ; SplitterGadget.
        
      Case #PB_Event_CloseWindow ; L'icône de fermeture de la fenêtre a été cliquée.
        If IsThread(CanvasDrawingLManager\CanvasThread)
          KillThread(CanvasDrawingLManager\CanvasThread)
        EndIf
        
        End
        
    EndSelect
    
  Until EventWindows.i = #PB_Event_CloseWindow ; Termine la boucle de la fenêtre.
  End
EndIf

PureBasic

Gestion affichage dans un Canvas

Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas

Re: Gestion affichage dans un Canvas