PureBasic

comtois a écrit :Comment traduire ce truc ?

To remove/disable a previous set Callback just call SetWindowCallback(0) again.

comtois a écrit :je ne sais pas ce qu'est la callback et si elle a un petit nom en français ?
J'ai pas cherché, si quelqu'un sait ?

Dräc a écrit :Aujourd’hui cette phrase est fausse :
Le 0 sert à annuler le pointeur d’adresse de la procédure CallBack, mais avec la v4, il faut aussi spécifier la fenêtre ciblée.

Ainsi la phrase devrait etre selon moi:

Pour annuler une Callback définie par SetWindowCallback(@NomDeLaProcedure() [, #Fenetre]) (), il suffit d’appeler SetWindowCallback(0 [, #Fenetre]).

@Title Pointers and memory access

@Section Pointers

To use a pointer, put * before the @ReferenceLink "variables" "variable" name. A pointer is normally a long variable which stores an address.
It is generally associated with a @ReferenceLink "structures" "structured type". So, you can access the structure via the pointer.

@Example

@Code
*MyScreen.Screen = OpenScreen(0,320,200,8,0)
mouseX = *MyScreen\MouseX ; Assuming than the Screen structure contains a MouseX field
@EndCode

There are only three valid methods to set the value of a pointer: @LineBreak
- Get the result from a function (as shown in the above example) @LineBreak
- Copy the value from another pointer @LineBreak
- Find the address of a variable, procedure or label (as shown below) @LineBreak
@LineBreak
Note: Other than in C/C++ in PureBasic the * is @Bold always part of the variable name.
Therefore *ptr and ptr are two different variables.

@LineBreak
@LineBreak
@Underline "Some technical background about pointers in PureBasic:"
@LineBreak
@LineBreak
When you declare a @ReferenceLink "variables" "variable" with an '*', it's a pointer,
which means it will be always the size of the CPU address mode (4 bytes on 32 bits CPU
and 8 bytes on 64 bits one for example). When you attach a structure to a pointer
(for example *MyPoint.Point) it allows to access any memory address in a structured way.
@LineBreak
@LineBreak
Example:
@Code
Point1.Point
Point2.Point
*CurrentPoint.Point = @Point1
*CurrentPoint\x = 10 ; 10 is affected to Point1
*CurrentPoint.Point = @Point2
*CurrentPoint\x = 10 ; 10 is affected to Point2
@EndCode

So a pointer isn't always a 'long' because it needs to have the room to store an
absolute address. On 32 bits processors the address space is limited to 32 bits, so a
pointer takes 32 bits (4 bytes, like a 'long') in memory. On newer 64 bits processors
it takes 64 bits (8 bytes, like a 'quad') in memory, because the absolute address is
on a 64 bits range.
@LineBreak
@LineBreak
The type you affect to a pointer is a different thing. For example: *Pointer.l,
*Pointer.b or *Pointer.q will make no difference at all as the types l, b and q doesn't
have any fields in them. Pointer makes sense mainly with a @ReferenceLink "structures" "structure".
@LineBreak
@LineBreak
A pointer has always the same size (which is processor dependent), whatever type
(structure or not) is put after. A pointer is just an easy way to access a structured
memory area. Also *Pointer.l and *Pointer.Long are the same, except than with the
second one you can really read the long at the specified address, due to the 'l'
structure field.

comtois a écrit :je viens de mettre en ligne une nouvelle version de l'aide

http://perso.wanadoo.fr/comtois/Doc/PureBasic.chm

la principale nouveauté c'est l'ajout des images dans les pages d'aide concernant l'IDE.
Bien sûr ça augmente considérablement la taille de la doc, mais c'est pas grave Dobro a l'ADSL maintenant

Pour ceux qui ne l'auraient pas encore remarqué , désormais il y a un code de couleur dans l'historique ( la page changes.txt)

Vert pour les ajouts
Orange pour les modifications
Rouge pour les suppressions

Il me reste deux pages à faire :
Utiliser le débogueur
Utiliser les outils de débogage

Si un courageux se propose pour faire les images manquantes , je ne suis pas contre

Il faut comparer avec l'aide allemande pour ceux qui ont cvs .

Set the current debug level for the 'Debug' message.
Note: The debug level is set at compile time, which means than you have to put the
@Keyword "DebugLevel" command before any other Debug commands to be sure it affects them all.

Fixe le niveau courant pour les messages 'Debug'.
Note: Le niveau est fixé au moment de la compilation, ce qui signifie que vous devez mettre la commande
@Keyword "DebugLevel" avant toutes les autres commandes debug pour être sûr qu'elles seront bien toutes affectées.

Dräc a écrit :Comtois, je vais te proposer une traduction pour les pointeurs.

La notion est suffisamment pointue et importante pour y prendre soin: aussi je sais déjà que ma proposition risque de fortement dévier de la version originale anglais que je trouve malheureusement plutot confuse (elle explique à trois reprise la meme chose)...

@Section Pointers

To use a pointer, put * before the @ReferenceLink "variables" "variable" name. A pointer is normally a long variable which stores an address.
It is generally associated with a @ReferenceLink "structures" "structured type". So, you can access the structure via the pointer.

@Example

@Code
*MyScreen.Screen = OpenScreen(0,320,200,8,0)
mouseX = *MyScreen\MouseX ; Assuming than the Screen structure contains a MouseX field
@EndCode

There are only three valid methods to set the value of a pointer: @LineBreak
- Get the result from a function (as shown in the above example) @LineBreak
- Copy the value from another pointer @LineBreak
- Find the address of a variable, procedure or label (as shown below) @LineBreak
@LineBreak
Note: Other than in C/C++ in PureBasic the * is @Bold always part of the variable name.
Therefore *ptr and ptr are two different variables.

@LineBreak
@LineBreak
@Underline "Some technical background about pointers in PureBasic:"
@LineBreak
@LineBreak
When you declare a @ReferenceLink "variables" "variable" with an '*', it's a pointer,
which means it will be always the size of the CPU address mode (4 bytes on 32 bits CPU
and 8 bytes on 64 bits one for example). When you attach a structure to a pointer
(for example *MyPoint.Point) it allows to access any memory address in a structured way.
@LineBreak
@LineBreak
Example:
@Code
Point1.Point
Point2.Point
*CurrentPoint.Point = @Point1
*CurrentPoint\x = 10 ; 10 is affected to Point1
*CurrentPoint.Point = @Point2
*CurrentPoint\x = 10 ; 10 is affected to Point2
@EndCode

So a pointer isn't always a 'long' because it needs to have the room to store an
absolute address. On 32 bits processors the address space is limited to 32 bits, so a
pointer takes 32 bits (4 bytes, like a 'long') in memory. On newer 64 bits processors
it takes 64 bits (8 bytes, like a 'quad') in memory, because the absolute address is
on a 64 bits range.
@LineBreak
@LineBreak
The type you affect to a pointer is a different thing. For example: *Pointer.l,
*Pointer.b or *Pointer.q will make no difference at all as the types l, b and q doesn't
have any fields in them. Pointer makes sense mainly with a @ReferenceLink "structures" "structure".
@LineBreak
@LineBreak
A pointer has always the same size (which is processor dependent), whatever type
(structure or not) is put after. A pointer is just an easy way to access a structured
memory area. Also *Pointer.l and *Pointer.Long are the same, except than with the
second one you can really read the long at the specified address, due to the 'l'
structure field.
@LineBreak
@LineBreak
Please note, that PureBasic can't create 64 bit executables (yet).
@LineBreak
As long as PureBasic executables are compiled as 32 bit applications the system will only
provide the program with a 32 bit address space.

L'utilisation des pointeurs est possible en plaçant une * devant le nom d’une variable.
Une telle variable est de type pointeur ou plus simplement est un pointeur.

Un pointeur est une variable dont la valeur contient une adresse mémoire.

Un pointeur est généralement associé avec une structure.
Exemple:
*MonEcran.Ecran = OpenScreen(0,320,200,8,0)
mouseX = *MonEcran\SourisX ; En supposant ici que la structure Ecran contient un champ SourisX

Il existe seulement trois possibilités pour fixer la valeur d'un pointeur:
- Obtenir le résultat par une fonction (voir l'exemple ci-dessous)
- Copier la valeur d'un autre pointeur
- Trouver l'adresse d'une variable, procédure ou label (voir ci-dessous)

A Noter : A l’inverse du C/C++, en PureBasic l’* fait partie entière du nom de la variable.
Aussi ptr et *ptr sont deux variables bien distinctes.
ptr est une variable (régulière) contenant une valeur, *ptr est une autre variable de type pointeur contenant une adresse.

Notion sur les pointeurs en PureBasic

Lorsqu’une variable est déclarée avec une *, il s’agit d’un pointeur, ce qui signifie qu’elle reçoit uniquement une adresse mémoire comme valeur.
Donc la taille en mémoire d’un pointeur sera celle qui permettra de représenter une adresse mémoire du processeur :
- Sur un processeur 32 bits, les adresses sont représentées sur 32 bits, donc un pointeur prendra 32 bits en mémoire (soit 4 bytes comme une variable de type ‘long’).
- Sur les récents processeurs 64 bits, les adresses sont représentées cette fois sur 64 bits donc un pointeur prendra 64 bits en mémoire (soit 8 bytes comme une variable de type ‘quad’).

C’est pour cette raison qu’un pointeur est une variable dite de type pointeur car son encombrement en mémoire sera celui d’une adresse et donc lié à la capacité d’adressage mémoire du processeur.

Il en découle qu’écrire *Pointer.l, *Pointer.b ou *Pointer.q n’a pas de sens puisque l’encombrement mémoire d’un pointeur est imposé par celui d’une adresse et non par celui d’un type.
Donc affecter un type à un pointeur n’a aucun sens.

Par contre, attacher une structure à un pointeur (par exemple *MonPoint.Point) permet d’accéder au contenu mémoires de chaque membre de la structure avec le caractère \ .

Exemple:
@Code
Point1.Point
Point2.Point
*PointCourant.Point = @Point1
*PointCourant\x = 10 ; 10 est affecté à Point1\x
*PointCourant.Point = @Point2
*PointCourant\x = 20 ; 20 est affecté à Point2\x
@EndCode

Dans cet exemple, la variable Point1 réside à l’adresse @Point1 en mémoire.
En écrivant *PointCourant.Point = @Point1, la variable *PointCourant est une variable de type pointeur et sa valeur est égale à @Point1.
On dit que *PointCourant pointe sur Point1 car sa valeur représente l’adresse de la variable Point en mémoire.
Comme la structure Point est attachée à *PointCourant (car *PointCourant.Point) on peut accéder (lire ou écrire) le contenu de Point1\x en écrivant *PointCourant\x.

En écrivant *PointCourant.Point = @Point2, on déplace *PointCourant pour qu’il pointe sur Point2.
En écrivant à nouveau *PointCourant\x, on accède cette fois ci au contenu de Point2\x.

Les pointeurs permettent donc de se déplacer, de lire et d’écrire facilement en mémoire.
De plus ils permettent aux programmeurs d’accéder à de grandes quantités de données sans coût supplémentaire suite à une duplication de ces données. Copier un pointeur est beaucoup plus rapide.

A noter que PureBasic ne permet pas encore de créer des exécutables 64 bits.

Tant que les exécutables PureBasic seront compilés en 32 bits, le système ne leur offrira seulement des adressages long de 32 bits.

comtois a écrit :au sujet de DebugLevel , J'ai traduit ça

Set the current debug level for the 'Debug' message.
Note: The debug level is set at compile time, which means than you have to put the
@Keyword "DebugLevel" command before any other Debug commands to be sure it affects them all.

Comme ça

Fixe le niveau courant pour les messages 'Debug'.
Note: Le niveau est fixé au moment de la compilation, ce qui signifie que vous devez mettre la commande
@Keyword "DebugLevel" avant toutes les autres commandes debug pour être sûr qu'elles seront bien toutes affectées.

ça vous semble correct ?

Concernant le callback , je vais reprendre la proposition de Dräc.

il y a d'autres ajouts dans l'aide anglaise , je suis en train de regarder, je reviendrai sûrement vous soumettre mes traductions pour correction.

Fixe le niveau courant pour les messages 'Debug'.
Note: Le niveau est fixé au moment de la compilation, ce qui signifie que vous devez mettre la commande
@Keyword "DebugLevel" avant les commandes debug pour être sûr qu'elles seront bien toutes affectées.