PureBasic

C'est surement con mais je ne trouve plus..
Quelqu'un pourrait me dire ou j'ai fauté pour que mon Canvas ne se remplisse pas à l'ouverture de ma fenêtre ?

Code : Tout sélectionner

Enumeration GUI
  #LDVM
  #CANVAS
EndEnumeration

; /////////////////////////////////////////
    ;- PROGRAMME
    ; //////////////////////////////////////////

Global WinL = 1024, WinH = 600, Canv_L, Canv_H
Canv_L = WinL-(WinL/10) : Can_H = WinH
Canv_X = WinL - Canv_L

If OpenWindow(#LDVM, 0, 0, WinL, WinH, "Image'In by Ar-S", #PB_Window_Invisible | #PB_Window_SystemMenu | #PB_Window_ScreenCentered)
  
  Debug WinL
  Debug Canv_L
  Debug Canv_X
  
  CanvasGadget(#CANVAS,Canv_X, 0, Canv_L, Canv_H, #PB_Canvas_ClipMouse)
  
  EnableWindowDrop(#LDVM, #PB_Drop_Files, #PB_Drag_Copy)
  
  HideWindow(#LDVM,0)
  
  StartDrawing(CanvasOutput(#canvas))
    Box(0,0,Canv_L, Canv_H, $FFCC00)
  StopDrawing()
  
  Repeat
    Event = WaitWindowEvent()
    
  Until Event = #PB_Event_CloseWindow
EndIf

Ta fais une erreur de variable plus haut, ta oublier le V de Canva_H ^^

Code : Tout sélectionner

Global WinL = 1024, WinH = 600, Canv_L, Canv_H
Canv_L = WinL-(WinL/10) : CanV_H = WinH
Canv_X = WinL - Canv_L

Un oublie ne pardonne pas, utilise EnableExplicite comme ça pas d'erreur, c'est lesieur

Bien vu shadow

Merci, faut fêter ça xd

Ah mais quel âne,

bien vu Shadow

Cela arrive à tous le monde, et la j'suis d'accord avec shadow EnableExplicit évite bien des erreur

Je suis d'accord mais c'est tout de même pénible de devoir tout déclarer.
Genre déclarer le event de event = waitwindowsevent()..
Je vais utiliser une structure, ce sera plus simple à "syntaxer" (X,Y,L,H).

---edit----

Hop, comme ça ça le fait mieux. ça m'apprendra à faire mon flemmard

Code : Tout sélectionner

Structure G
  X.i
  Y.i
  L.i
  H.i
EndStructure

Macro GAD(gadget,val)
  gadget.G\val
EndMacro

Macro SDC(gadget)
  StartDrawing(CanvasOutput(gadget))
EndMacro

Global Event, WinL = 1024, WinH = 600
GAD(CANVAS,L) = WinL-(WinL/10) 
GAD(CANVAS,H) = WinH - (WinH/20)
GAD(CANVAS,X) = WinL - GAD(CANVAS,L)

GAD(COM,L) = GAD(CANVAS,L)
GAD(COM,H) = WinH - GAD(CANVAS,H)
GAD(COM,X) = GAD(CANVAS,X)
GAD(COM,Y) = GAD(CANVAS,H)

Ar-S a écrit :Je suis d'accord mais c'est tout de même pénible de devoir tout déclarer.
Genre déclarer le event de event = waitwindowsevent()..

Code : Tout sélectionner

    Repeat
        Select WaitWindowEvent()
                
            Case #PB_Event_CloseWindow
                End
                
        EndSelect
    ForEver

Une variable de moins

J'utilise les modèles pour gagner du temps:

Code : Tout sélectionner

Repeat
    Select WaitWindowEvent()
;         Case #PB_Event_Menu          
;         Case #PB_Event_Gadget   
;         Case #PB_Event_SysTray 		
;         Case #PB_Event_Timer           
;         Case #PB_Event_CloseWindow     
;         Case #PB_Event_Repaint         
;         Case #PB_Event_SizeWindow      
;         Case #PB_Event_MoveWindow      
;         Case #PB_Event_MinimizeWindow  
;         Case #PB_Event_MaximizeWindow  
;         Case #PB_Event_RestoreWindow   
;         Case #PB_Event_ActivateWindow  
;         Case #PB_Event_DeactivateWindow
;         Case #PB_Event_WindowDrop      
;         Case #PB_Event_GadgetDrop      
;         Case #PB_Event_RightClick      
;         Case #PB_Event_LeftClick       
;         Case #PB_Event_LeftDoubleClick 
        Case #PB_Event_CloseWindow
            End
    EndSelect
ForEver

End

C'est dans le même ordre que la doc.
Il ne reste qu'à activer les events dont on a besoin.

C'était pour l'exemple

J'ai de toute façon revu ma macro (précédente) compatible tout gadget.

J'utilise les modèles pour gagner du temps:

j'essaye d'utiliser les bindevent le plus possible maintenant.. Mais je suis d'accord qu'un bon template est pratique

J'essaye au contraire de revenir à l'ancienne méthode étant donné que certaines fonctions ne sont pas prises en compte si elles sont déclenchées par BindEvent (ex: WM_)
De plus il faut refaire un Bind à chaque réouverture d'une même fenêtre si elle a eut son ID créé via #Pb_Any

Je ne l'utilise plus que pour #PB_Event_SizeWindow quand il y a beaucoup d'objets regénérés en même temps (exemple remplissage d'une listeview pour un log)

Pour ma part je n'utilise jamais #Pb_Any. Mais c'est vrai que les bind ont leur limite. Mais ils ont leurs petits avantages.
Je suis en train de me refaire un soft d'effets d'images (contraste et compagnie), les bind devraient me suffire.

Ar-S a écrit :Pour ma part je n'utilise jamais #Pb_Any.

Idem.

Je vois peu d'avantage aux PB_any.

Contrairement à Ar-S, je suis partisan de EnableExplicit, vraiment c'est peu de travail comparativement au temps passé à chercher une erreur et puis vous comme moi (

), on en fait à la pelle.

Donc je déclare tout et on s'y retrouve, en mettant en plus des commentaires au début des procédures, c'est peut-être long mais sur des codes longs ou on arrête de programmer et que l'on reprend, c'est tout sauf du luxe.

Un extrait d'une de mes procédure de conversion format ico vers icl/dll.
J'ajoute au début un compilerif avec une constante qui permet d'afficher le nom de la procédure.
Fait pour toutes les procédures, c'est une aide au debug simple et facile, permet de voir la chronologie d'appel des procédures.

Code : Tout sélectionner

Procedure.i PIM_Convert_icoStream_To_iclFile2(*Stream.Istream, DestinationFile$, Mode, ExtensionType)
CompilerIf #Nom_Procedure = #True
Debug #PB_Compiler_Procedure
CompilerEndIf
      ;///////////////////////////////////////////////////////////////////////////////////////////////////
      ;//
      ;// FONCTION: PIM_Convert_icoFile_To_iclFile2()
      ;//
      ;// BUT: à partir du fichier .ico, on va créer un fichier icl/dll 32 bits
      ;//
      ;// PARAMS: *StreamId - Identifiant du stream contenant le fichier au format ico
      ;//         Mode - valant #PIM_One_Group : un seul groupe d'icônes est créé
      ;//                valant #PIM_Multi_Group : chaque icône est un groupe
      ;//         DestinationFile$- fichier destination icl/dll avec chemin complet
      ;//         Si DestinationFile$ est une chaine vide, on utilise le même nom suivi de '.icl' ou '.dll'
      ;//         ext$ - doit valoir #icl_Extension ou #dll_Extension en fonction du type de fichier voulu
      ;//              si ext$ vaut #icl_Extension, les noms de groupes peuvent exister
      ;//              si ext$ vaut #dll_Extension, les noms de groupes n'existent pas
      ;//              si ext$ = #dll_Extension, Mode ne peut pas contenir la constante #PIM_No_GroupName
      ;//
      ;//
      ;// RETOURNE: #Return_No_Error (=#True) en cas de succès
      ;//           Retourne #Return_Error (= 0) en cas d'erreur
      ;//
      ;//    La fonction teste les valeurs de la structure IconDir qui débute le fichier, puis
      ;//    le fichier est scruté pour créer le fichier icl
      ;//
      ;///////////////////////////////////////////////////////////////////////////////////////////////////
      ;// mémorise le handle du fichier icl/dll créé
      Protected h_ICL_File
      ;// mémorise l'adresse du contenu du fichier à partir du début du fichier, modifié dans chaque boucle
      Protected *Memory_Add_temp.IconDir_0
      ;// mémorise le pointeur des zones de données à écrire dans la ressource
      Protected *iconGroup.MemIconDir_0
      ;// memorise la dernière adresse valide du fichier en mémoire pour vérifier le non dépassement
      Protected *LastMemoryAdress
      ;// mémorise le nombre d'icônes de la structure IconDir_0
      Protected Nb_icones
      ;// mémorise le handle de l'API  BeginUpdateResource_()
      Protected BeginUpdateResource
      ;// compteur de boucles
      Protected i
      ;// mémorise le nom du groupe contenu dans le fichier icl/dll (= nom fichier sans extension)
      Protected NomGroupe.string
      ;// mémorise la chaine complète des noms de groupes
      Protected Chaine_Groupes.string
      ;//mémorise la longueur de la chaine créée à partir du nombre de groupe str()
      Protected Nb_char_Nb_GroupeIcone
      ;// mémorise la longueur du nom de groupe
      Protected Longueur_nom_groupe
      ;// mémorise l'extension du fichier
      Protected ext$
      ;// long utilisé pour lire une donnée dans le stream
      Protected Input.l
      ;// mémorise le nombre d'octets lus dans le stream
      Protected pcbRead
      ;// mémorise l'offset de l'image courante
      Protected dwImageOffset 
      ;// mémorise le nombre d'octets de la ressource
      Protected dwBytesInRes
      ;// mémorise la valeur courante du pointeur de stream
      Protected Seek_pointer_Current_value.ULARGE_INTEGER
      ;// mémorise la taille de la dll compressée en RC_DATA
      Protected Taille_Empy_dll
      ;// mémorise la date pour les fichiers
      Protected Date
      
      ;// teste si le pointeur est nul
      If *Stream = #Null
            MAC_PIM_SetError_Code(#Sous_Error_2_Error_Code_Pointeur_Null|#Error_Code_Pointeur_Null)
            ProcedureReturn #Return_Error
      EndIf

Et ben...tu nous fait des codes d'écologistes

Le dernier djeun's geek de 20 berges, ingénieur developpeur full stack sorti premier de sa promotion que j'ai eu le bonheur de connaître à mon boulot quelque mois, m'a fait passer pour un dinosaure, quand je lui dit tout fier, que je "verdissais" mes pages de codes.

Il m'a répondu : "un code correctement rédigé et étudié n'a nul besoin de commentaires"
Je me suis marré en moi même, j'ai juste perdu le sourire quand je l'ai vu s'attaquer à une multitude de langages différents, et en plus non codé par lui, plus facilement que je relie les miens

Ca promet .....

Je hais les jeunes geeks ...

Mouai ton djeuns est bien gentil mais on a pas tous une mémoire eidétique, du moins il y en a peu qui connaissent le mode d'emploi.

Je suis pour le commentaire à outrance dans un code. Surtout quand tu refiles le bébé au voisin.

Bon,

je fais ce que je peux avec ce qui me sert de cerveau

Je travaille sur PureIconManager depuis plusieurs années et j'ai laissé parfois beaucoup de temps avant de reprendre, je suis content de mes commentaires. Je m'y retrouve.

L'inspiration des explications en début de procédure, je l'ai piqué sur un code de MS qui étais commenté de la même manière.

PureBasic

[OK] Remplir Canvas à l'ouverture de la fenêtre

[OK] Remplir Canvas à l'ouverture de la fenêtre

Re: remplir Canvas à l'ouverture de la fenêtre

Re: remplir Canvas à l'ouverture de la fenêtre

Re: remplir Canvas à l'ouverture de la fenêtre

Re: remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre

Re: [OK] Remplir Canvas à l'ouverture de la fenêtre