Vue que le manuel n'est pas encore mis à jours pour PB 4.6 Beta 3... en français.
J'ai traduit quelques instructions qui m'ont été utiles... Et j'en profite pour les mettre
a disposition du forum...
S'il y a des erreurs possibles, ben...
Sorry... ET c'est l'occasion pour les corriger.Et pour la forme... Ben , c'est là pour qui veux améliorer...
Voilà, voilà...
Code : Tout sélectionner
; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Quelques traductions :
; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; - Ajouté CanvasGadget()
;
; Syntaxe :
; --------
Resultat = CanvasGadget (#Gadget, x, y, largeur, hauteur [, flags])
;
; Descriptif :
; -----------
; Créer un gadget "toile" dans le GadgetList actuel. Ce gadget permet une surface
; de dessin "comme une toile de peintre" et d'événements pour la souris et du clavier
; d'interaction pour créer facilement des vues personnalisées.
;
; Paramètres :
; ------------------------------------------------------------------------------
; #Gadget | Spécifie un numéro pour identifier le nouveau gadget.
; | PB_Any # peut être utilisé pour générer automatiquement ce numéro.
; ------------------------------------------------------------------------------
; x, y, |
; largeur,| Spécifie la position et les dimensions du nouveau gadget.
; hauteur
; ------------------------------------------------------------------------------
; Drapeaux| Indique des drapeaux facultatifs pour modifier le comportement gadget.
; (Flag) | Il peut être une combinaison des constantes suivantes :
;Optionnel|
;
#PB_Canvas_Border ; Dessine une bordure autour du gadget.
#PB_Canvas_ClipMouse ; Maintient la souris sur le gadget tant qu'un bouton est pressé.
#PB_Canvas_GrabMouse ; Signale les événements souris, même en dehors du gadget tant qu'un
; ; bouton est pressé (Windows, Linux uniquement)
#PB_Canvas_Keyboard ; Permet au gadget de recevoir le focus et les événements du clavier.
#PB_Canvas_DrawFocus ; Dessine un rectangle de focus autour du gadget si il a le focus clavier.
;
; Remarque : Le #PB_Canvas_GrabMouse n'a aucun effet en Mac OSX, mais est toujours présent avec Linux.
; --------
; Le drapeau #PB_Canvas_Keyboard est nécessaire pour recevoir tous les événements de clavier
; dans le gadget. Si vous incluez ce drapeau, vous devriez vérifier les évenements #PB_EventType_LostFocus
; et #PB_EventType_Focus et en tirer une indication visuelle sur le gadget quand il a le focus de sorte
; qu'il soit clair pour l'utilisateur que le gadget a actuellement le focus.
; Sinon, le drapeau #PB_Canvas_DrawFocus peuvent être inclus pour laisser le gadget dessiner un
; rectangle de focus standard chaque fois qu'il a le focus.
;
; Valeur de retour :
; ------------------
; Retours non nulle en cas de succès et de zéro en cas d'échec. Si #PB_Any a été utilisée comme paramètre
; alors #Gadget reçoit en retour le numéro du gadget auto-générés.
;
; Remarques :
; -----------
; Le gadget créé commence avec avec un fond blanc. Utilisez la commande CanvasOutput() pour dessiner sur le
; gadget. Le contenu dessiné reste permanente jusqu'à ce qu'il soit effacé par une opération de dessin
; ultérieure. Il n'est pas nécessaire de redessiner le contenu à chaque fois un événement #PB_Event_Repaint
; est reçu.
;
; Les événements suivants sont signalés par le gadget.
; La fonction EventType() donne type d'événement du gadget actuelle:
;
#PB_EventType_MouseEnter ; Le curseur de la souris est entré le gadget
#PB_EventType_MouseLeave ; Le curseur de gauche de la souris le gadget
#PB_EventType_MouseMove ; Le curseur de la souris déplacée
#PB_EventType_MouseWheel ; La molette de la souris a été déplacée
#PB_EventType_LeftButtonDown ; Le bouton gauche de la souris a été pressé
#PB_EventType_LeftButtonUp ; Le bouton gauche de la souris a été libéré
#PB_EventType_RightButtonDown ; Le bouton droit de la souris a été pressé
#PB_EventType_RightButtonUp ; Le bouton droit de la souris a été libéré
#PB_EventType_MiddleButtonDown; Le bouton du milieu a été pressé
#PB_EventType_MiddleButtonUp ; Le bouton du milieu a été libéré
#PB_EventType_Focus ; Le gadget gagné le focus du clavier
#PB_EventType_LostFocus ; Le gadget a perdu le focus du clavier
#PB_EventType_KeyDown ; Une touche a été pressée
#PB_EventType_KeyUp ; Une clé a été libéré
; Notez que les événements #PB_EventType_KeyDown et #PB_EventType_KeyUp ne sont signalées que lorsque
; le gadget a le focus clavier. Cela signifie que le drapeau #PB_Canvas_Keyboard doit être activé a la
; création du gadgets pour permettre les événements clavier.
;
; Sous Windows, l'événement #PB_EventType_MouseWheel est également rapporté si le gadget a le focus clavier.
; Sur les autres OS, cet événement est rapporté quand le curseur et sur le gadget et ce quel que soit le focus
; du clavier.
;
; De plus amples informations sur l'événement en cours peut être reçu avec la fonction GetGadgetAttribute().
; Cette information est uniquement disponible si les événements WaitWindowEvent() ou WindowEvent() sont activés
; pour ce gadget. Les attributs suivants peuvent être utilisés:
#PB_Canvas_MouseX, #PB_Canvas_MouseY
; Qui donnent les coordonnées de la souris donnée relatives à la zone de dessin du gadget.
; Cela renvoie la position de la souris au moment où l'événement a été généré, de sorte que le résultat
; peut varier par rapport aux coordonnées rendues par WindowMouseX() et WindowMouseY() qui donnent
; l'emplacement actuelle de la souris indépendamment de l'état des événements traités.
; Les coordonnées rendues en utilisant ces attributs doivent être utilisés pour ce gadget pour s'assurer
; que les coordonnées de la souris sont en phase avec l'événement en cours.
#PB_Canvas_Buttons
; Renvois l'état des boutons de la souris pour l'événement.
; Le résultat est une combinaison (par OU binaire) des valeurs suivantes:
#PB_Canvas_LeftButton ; Le bouton gauche est actuellement en panne.
#PB_Canvas_RightButton ; Le bouton droit est actuellement en panne.
#PB_Canvas_MiddleButton ; Le bouton du milieu est actuellement en panne.
#PB_Canvas_Modifiers
; Renvois l'état des modificateurs de clavier pour l'événement.
; Le résultat est une combinaison (par OU binaire) des valeurs suivantes:
#PB_Canvas_Shift ; Le «changement» clés est actuellement pressée.
#PB_Canvas_Alt ; la touche «Alt» est actuellement pressée.
#PB_Canvas_Control ; La touche 'Control' est actuellement pressée.
#PB_Canvas_Command ; Le «commandement» (ou «pomme») est actuellement pressée clés. (Mac OSX uniquement)
#PB_Canvas_WheelDelta
; Retourne le mouvement de la molette de la souris dans le cas actuel en multiples de 1 ou -1.
; Une valeur positive indique que la roue a été déplacé vers le haut (loin de l'utilisateur) et
; une valeur négative indique que la roue a été déplacé vers le bas (vers l'utilisateur).
; Cet attribut est 0 si l'événement en cours n'est pas un événement #PB_EventType_MouseWheel.
#PB_Canvas_Key
; Renvois la touche qui a été enfoncée ou relâchée dans un #PB_EventType_KeyDown ou un
; événement #PB_EventType_KeyUp. La valeur retournée est l'un des #PB_Shortcut_ ... valeurs
; utilisées par la fonction AddKeyboardShortcut().
; En plus de cette information sur les événements, GetGadgetAttribute() peut aussi être utilisé pour
; lire les attributs suivants:
#PB_Canvas_Image
; Retourne une valeur qui représente ImageID l'image une avec le contenu actuel de la CanvasGadget.
; Cette valeur peut être utilisée pour dessiner le contenu du gadget à une autre sortie de dessin
; en utilisant la fonction DrawImage () .
; Note: La valeur retournée est valable jusqu'au modifications sont apportées à ce gadget en le
; redimensionnement ou le dessin à elle, donc il ne devrait être utilisé directement dans une commande
; comme DrawImage() et ne sont pas stockées pour une utilisation future.
#PB_Canvas_Cursor
; Retourne le curseur qui est actuellement utilisé dans le gadget.
; Voir ci-dessous pour une liste de valeurs possibles.
; La fonction SetGadgetAttribute () peut être utilisé pour modifier les attributs suivants gadget
#PB_Canvas_Image
; Applique les ImageID au CanvasGadget. Le gadget fait une copie de l'image d'entrée afin qu'il
; puisse être libérée ou réutilisée après cet appel. Définir cet attribut c'est la même chose que
; pour StartDrawing(), CanvasOutput() et DrawImage() pour dessiner l'image sur le CanvasGadget.
#PB_Canvas_Cursor
; Change le curseur qui s'affiche lorsque la souris est sur le gadget.
; Les valeurs suivantes sont possibles:
#PB_Cursor_Default ; flèche du curseur par défaut
#PB_Cursor_Cross ; curseur à réticule
#PB_Cursor_IBeam ; I-curseur utilisé pour la sélection de texte
#PB_Cursor_Hand ; curseur main
#PB_Cursor_Busy ; sablier ou de regarder le curseur
#PB_Cursor_Denied ; cercle réduit ou un curseur X
#PB_Cursor_Arrows ; flèches dans tous les sens (pas disponible sur Mac OSX)
#PB_Cursor_LeftRight ; Flèches gauche et droite
#PB_Cursor_UpDown ; Flèches haut et bas
#PB_Cursor_Invisible ; masque le curseur
; Vous pouvez ajouter un 'help mini »pour ce gadget en utilisant GadgetToolTip ().
; ------------------------------------------------------------------------------
; - Ajouté CanvasOutput()
; Syntaxe :
; --------------
OutputID = CanvasOutput(#Gadget)
; Descriptif :
; --------------
; Renvois l'identifiant "OutputID" d'un CanvasGadget pour effectuer une opération 2D sur Canvas...
; paramètres :
;
; #Gadget : Spécifie le gadget sur lesquels on s'appuye. Cela doit être un CanvasGadget().
;
; valeur de retour :
; --------------
; Retourne l'identifiant ouput ou zéro si le dessin n'est pas possible.
; Cette valeur doit être transmis directement à l'StartDrawing() pour lancer l'opération de dessin.
; Le returnValue est valide pour une seule opération de dessin et ne peuvent pas être réutilisés.
;
; Remarques :
; --------------
; S'appuyant sur une CanvasGadget() est à double-tampon. Cela signifie que les opérations de dessin
; ne deviennent visibles à l'StopDrawing() commande pour éviter de scintillement pendant le dessin.
;
;
; - Ajouté SetGadgetItemData() For PanelGadget
; - Ajouté commands
; ==================================================================================
; - Ajouté MergeLists()
; ==================================================================================
; Syntaxe :
; --------------
MergeLists(SourceList(), DestinationList() [, Location])
;
; Paramètres :
; --------------
; SourceList() ; Désigne la liste d'origine des éléments à déplacer.
; ; Ceci vide la liste d'origine après le transfert.
; DestinationList() ; Specifies la liste ou doit être déplacé l'élément.
; ; Celle-ci contraindra tout les éléments de la liste d'origine.
; Location(optionel); Précise à partir d'ou insérer les éléments dans la liste de destination.
; ; Cela peut être une des spécifications suivante :
;
; #PB_List_First : Insert les elements au début de la Destination
; #PB_List_Last : Ajoute à la fin de la Destination
; #PB_List_Before: Insert avant l'élément courant de la Destination
; #PB_List_After : Insert après l'élément courant de la Destination
;
; Exemple :
; --------------
NewList A.s()
AddElement(A()): A() = "a0"
AddElement(A()): A() = "a1"
AddElement(A()): A() = "a2"
AddElement(A()): A() = "a3"
NewList B.s()
AddElement(B()): B() = "b0"
AddElement(B()): B() = "b1"
AddElement(B()): B() = "b2"
AddElement(B()): B() = "b3"
; Insert les élements de A() AVANT l'élément "b1" de B()
SelectElement(B(), 1)
MergeLists(A(), B(), #PB_List_Before)
ForEach B() ; Ceci montre que le contenu de A() a été déplacé
Debug B() ; dans B() à partir du deuxième élément de B()
Next
Debug ";;;;;;;;;;"
ForEach A() ; Ceci montre que A() est vide...
Debug A()
Next
; ===============================================================
; - Ajouté MoveElement()
; ===============================================================
; syntaxe
; --------------
MoveElement(LinkedList (), Lieu [* RelativeElement])
;
; Descriptif :
; --------------
; Déplace l'élément courant de la liste spécifiée à une position différente dans la liste.
; L'élément déplacé demeure l'élément courant de la liste. C'est une opération rapide car les données
; et l'élément lui-même n'est pas déplacé de modifier l'emplacement dans la liste.
;
; Paramètres :
; --------------
; LinkedList() | Nom de votre liste chaînée, créée avec la fonction NewList. Vous devez inclure les
; | parenthèses après le nom de la liste.
;
; Localisation | Précise où déplacer l'élément courant. Cela peut être l'une des valeurs suivantes:
; | #PB_List_First : Déplacer l'élément vers le début de la liste
; | #PB_List_Last : Déplacer l'élément à la fin de la liste
; | #PB_List_Before : Déplacer l'élément avant la *ElementRelatif
; | #PB_List_After : Déplacer l'élément après la *ElementRelatif
;
;*ElementRelatif| (facultatif) Indique l'adresse d'un autre élément par rapport duquel l'élément courant
; | doit être déplacé. Ce paramètre est requis lorsque la "Localisation" paramètre est
; | #PB_List_Before ou #PB_List_After.
; | Vous pouvez obtenir cette adresse à partir d'un élément en utilisant l'opérateur "@" sur
; | le nom de la liste.
; Indique l'adresse d'un autre élément par rapport à laquelle l'élément courant doit être déplacé.
; Valeur de retour
; ----------------
; Renvois l'adresse des données dans l'élément de la première liste en cas de succès et de zéro si il
; s'il n'ya pas d'éléments dans la liste.
;
; Example :
; --------
NewList Numbers()
; ----------------------
For k=0 To 10 ; Boucle qui crée et montre l'état initial de
AddElement(Numbers()) ; la liste ....
Numbers() = k
Debug Str(k)+" : "+Str(Numbers())
Next
Debug "----------" ;
SelectElement(Numbers(), 5) ; Positionne l'index à la 5ième position (Valeur=4)
*Relative = @Numbers() ; Mémorise l'adresse de l'élement de cette position
;
SelectElement(Numbers(), 0) ; positionne l'index à la position 0 et
MoveElement(Numbers(), #PB_List_After, *Relative) ; déplace le contenu "0" APRES l'adresse mémorisé soit
; après 5 ièmme donc à la 6ième position... (ex : valeur(5))
; VERIFICATION ...
n=0 ; Ici on vérifie l'état de la liste après avoir déplacé
ForEach Numbers() ; et on peut voir que le 0 étant "partis" de sa position
Debug Str(n)+" : "+Str(Numbers()) ; pour gagner la position 5 les autres se sont emprèssé
n+1 ; d'occuper sa place soit le 1->0,2->1,3->2,4->3,5->4
Next ; Et le Zéro venir occuper la position 5 soit 0->5...
;
; ATTENTION : Il y a donc bien eu décalage des positions des éléments.
;
Debug "----------"
SelectElement(Numbers(), 10) ; Positionne l'index à la 10ème position
MoveElement(Numbers(), #PB_List_First) ; et deplace 10 en première position
; et par la même occasion redescend tout les suivants
; d'une position... Le zéro qui précédement était en
n=0 ; position 5 passe en position 6... et le 9 en 10ième...
ForEach Numbers()
Debug Str(n)+" : "+Str(Numbers()) ; Ici cela montre l'état final de la liste et des
n+1 ; dernières positions après les deux "déplacements"...
Next
;
; ===============================================================
; - Ajouté SplitList()
; ===============================================================
; syntaxe :
; ----------
;
SplitList(SourceList(), DestinationList() [, KeepCurrent])
;
; Description :
; -------------
; Déplace les éléments SourceList() à partir du l'élément courant vers la DestinationList().
; C'est une opération rapide car les données elles-même ne sont pas déplacés mais divise la liste.
;
; Parametres :
; -------------
; SourceList() | Indique la liste dont les éléments seront partagés. L'élément courant de cette liste
; | précise le moment où de diviser la liste. S'il n'ya pas d'élément courant, alors tous
; | les éléments restent dans SourceList ().
;
; DestinationList() | Indique la liste de déplacer les éléments à. Tous les éléments existants dans cette
; | liste sont effacés avant les nouveaux éléments sont ajoutés.
; -- (facultatif) --|
; KeepCurrent | Indique si l'élément courant dans SourceList() reste dans SourceList()
; | ou est déplacé vers DestinationList(). Si ce paramètre est #vrai, alors l'élément
; | actuel reste en SourceList(). Si elle est #Faux (par défaut), alors l'élément
; | courant est déplacé vers DestinationList().
;
; Exemple :
; ---------
NewList A()
NewList B()
For i = 0 To 10 ; Création de la liste A()
AddElement(A()) ;
A() = i ; Valeur...
Next i
;
SelectElement(A(), 5) ; Selection de l'index à la valeur "5" de la liste A()
SplitList(A(), B()) ; Division de la liste A() à partir de 5 qui est déplacé dans B()
;
Debug " -- A() -- " ; Montrons l'état des deux listes après l'opération SlipList()
ForEach A() ;
Debug A() ; On doit donc trouver de 0 à 4
Next
; Attention : si on avait écris :=> SplitList(A(), B(),#True)
; --------- Alors cela aurait été de 0 à 5 pour A() et de 6 à 10 pour B()
; Car #True indique de garder dans A() la valeur pointée...
Debug " -- B() -- "
ForEach B()
Debug B() ; ET ICI = > On doit donc trouver de 5 à 10
Next
;
; ===============================================================
; - Ajouté RandomizeList()
; ===============================================================
; syntaxe :
; ----------
;
RandomizeList(LinkedList() [, Start, End])
;
; Description :
; -------------
; "Reorganise" les éléments de la liste sous une forme aléatoire.
; Parameters :
; -------------
; LinkedList() indique la liste à rendre aléatoire.
; Start, End (optionel) permet de délimiter la partie de la liste
; qui sera rendue aléatoire...
;
; ===============================================================
; - Ajouté RandomizeArray()
; ===============================================================
; syntaxe :
; ----------
;
RandomizeArray(ArrayName() [, Start, End])
;
; Description :
; ------------
; Même principe que RandomizeList() mais pour un tableau...
;
; ===============================================================
; - Ajouté PushListPosition(), PopListPosition()
; PushMapPosition(), PopMapPosition()
; ===============================================================
; Syntaxe :
; ----------
;
PushListPosition(), PopListPosition()
;
; Description :
; ------------
; Se souvient l'élément courant (le cas échéant) de la liste afin qu'il puisse plus tard
; être restaurée en utilisant PopListPosition(). La position est mémorisé sur une Structure
; de pile, donc plusieurs appels à cette fonction sont possibles. (LIFO, idem ASM Push, Pop)
;
; Remarques :
; -----------
; Cette fonction peut être utilisée pour mémoriser l'élément courant, donc une itération
; peuvent être faites sur la liste en utilisant NextElement() ou ForEach PUIS l'élément
; courant peut être rétabli après l'itération en utilisant PopListPosition().
; Plusieurs appels peuvent être faits à cette fonction, aussi longtemps que chacun est équilibré
; par un PopListPosition().
;
; Note : Il n'est pas autorisé à supprimer un élément par une des fonctions DeleteElement() ou ClearList().
; tant que l'on n'est pas revenus avec un PopListPosition(). Cela peut entraîner un plantage.
;
; Example :
; ---------
NewList Numbers()
AddElement(Numbers()): Numbers() = 1
AddElement(Numbers()): Numbers() = 2
AddElement(Numbers()): Numbers() = 5
AddElement(Numbers()): Numbers() = 3
AddElement(Numbers()): Numbers() = 5
AddElement(Numbers()): Numbers() = 2
;
; Elimination d'une valeur en double par un boucle imbriquée.
;
ForEach Numbers()
Value = Numbers()
PushListPosition(Numbers())
While NextElement(Numbers())
If Numbers() = Value
DeleteElement(Numbers())
EndIf
Wend
PopListPosition(Numbers())
Next
ForEach Numbers()
Debug Numbers()
Next
; ==========================================================================================
