ou est l'erreur?

bsr a tous

j'ai essayer ce code pour mettre une image a un item_sub
mais le hic il n'y a pas ce que je veut. jusqu' a présent
j'ai tjr obtenu des crache et là je n'ai pas de crach


code

dim hdl1%,hdl2%
dim bmp$,res%

bmp$="c:\program files\panoramic\GFX\ouvrir.bmp"
dll_on "user32.dll"
main_menu 1

sub_menu 10 : parent 10,1 : caption 10,"Fichier"
sub_menu 11 : parent 11,10 : caption 11,"Ouvrir"
hdl1%=handle(10)
hdl2%=handle(11)
res%=dll_call5("SetMenuItemBitmaps",hdl1%,hdl2%,0,adr(bmp$),adr(bmp$))

dll_off

a+

Ca, c'est une question pour Klaus.
Mais si il y a moyen de mettre une icone en passant par là....
... je vais suivre avec intérêt.  

J'avais proposé la même chose il y a 2 jours en passant par un picture.

Mais a priori ce n'est pas possible. dixit klaus.

ok mais je pense qu'il y a une possibilités je vais quand même continué
a cherché
plus têtu que moi tu meure lol

Peut être Jack pourrait nous dire si cela est possible ou non ?

@Pascal10000:
Voici ce que dit la doc de MicroSoft pour cette fonction:

Citation :

BOOL WINAPI SetMenuItemBitmaps(
_In_ HMENU hMenu,
_In_ UINT uPosition,
_In_ UINT uFlags,
_In_opt_ HBITMAP hBitmapUnchecked,
_In_opt_ HBITMAP hBitmapChecked
);

Il se trouve que les deux derniers paramètres ne sont pas l'adresse d'une chaîne de caractères contenant le nom d'un fichier BMP, mais le handle d'un objet Windows de type BitMap. Or, on n'a aucun moyen en Panoramic d'avoir accès à ce handle. C'est la raison pour laquelle ton code ne marche pas.

J'ai déjà essayé d'avoir des icônes dans les mens, mais j'ai échoué aussi. Si un jour ça devait être possible, seul Jack pourra l'implémenter.

Et...si on ouvre les fichiers dans des pictures hider et que l' on passe le handle du picture ?....

Bon, je sors...

En Panoramic (et en Windows, d'ailleurs), un picture n'a pas de handle. Seuls les objets "fenêtrées" dans le sens de Windows en ont un, or les objets PICTURE (et ALPHA, d'ailleurs) n'en ont pas.

Non. Il existe bien un type d'objet BitMap dans Windows, mais il n'est pas accessible en Panoramic. Fin de l'histoire.

La fonction suivante nous donne le handle du bureau.
Peut-on exploiter cette information dans un code Panoramic ?

Code:

rem ============================================================================
rem             Le handle du bureau
rem ============================================================================
dim ret%
dll_on "user32.dll"
' Cette fonction retourne le Handle de la fenêtre correspondant au bureau.
ret% = dll_call0("GetDesktopWindow")
message "Le handle du bureau est : " + str$(ret%)
rem ============================================================================

ok klaus

peut tu me dire à quel moment peut-on utilisé
utilisé adr() et à quoi on le différentié par rapport
a une chaine string ?

adr() est une fonction destinée à l'utilisation avec une DLL, via les fonctions DLL_callx de Panoramic. Ces fonctions n'acceptent que des paramètres de type entier, et uniquement "par valeur", pas "par référence". Ceci a plusieurs conséquences:
- on ne peut pas passer une valeur flottante à une fonction DLL (ce n'est pas en entier !)
- on ne peut pas passer une chaîne de caractères à une fonction DLL (idem)
- dans une fonction DLL, on ne peut pas affecter une valeur à un paramètre et retrouver cette valeur dands le programme Panoramic appelant (pas de passage "par référence").

La fonction auxiliaire adr() est donc là pour contourner ce problème, dans une certaine mesure. Si tu veux passer le contenu d'une variable flottante (comme dim f) à une fonction DLL, tu passes adr(f) ce qui techniquement est un entier et représente l'adresse en mémoire où se trouve le contenu de la variable f. Encore faut-il que la fonction DLL que tu appelles, soit conçue pour recevoir une adresse d'un flottant pour aller chercher elle-même la valeur à cette adresse. Mais cela résout également le problème du passage "par référence": si la fonction modifie le contenu de la mémoire dont l'adresse est passé en paramètre, elle a de ce fait retourné une valeur via un paramètre.

Le même argumentaire est vrai également pour les variables entières (comme dim i%).

Le même argumentaire est (presque) vrai également pour les variables chaines de caractères (comme dom s$), à ceci près que adr(s$) ne donne pas l'adresse ou débute le texte de la variable s$, mais l'adresse d'un mot de 4 octets en mémoire où se trouve l'adresse du premier caractère de s$.

Voilà de façon détaillée à quoi sert la fonction adr(). Donc, uniquement en lien avec des fonctions d'une DLL appelées par DMM_callx, et uniquement si l'on sait exactement ce qu'on fait, et en particulier si la fonction DLL a été écrite pour recevoir ce type d'information.

ok klaus

je comprend mais c quand même technique
et y a t' il un rapport lorsque dim est est marqué
avec "as intenger"

je t’ennuie avec mes questions non??!

Non, tu ne m'ennuies pas du tout ! Moi aussi, je profite des connaissances des autres membre du forum, lorsque je sèche sur un point (voir la toute nouvelle version de Panoramic que je n'arrivais pas à installer...).

Revenons à nos moutons, pardon, nos DIMs.

Dans les DIMs, tu peux faire ceci:

Code:

dim variable : ' ceci est une variable contenant une valeur flottante
dim valeur% : ' ceci est une variable contenant une valeur entière
dim valeur$ : ' ceci est une variable contenant une chaîne de caractères
dim tableau(10) : ' ceci est un tableau de 11 variables contenant chacune une valeur flottante
dim tableau%(10) : ' ceci est un tableau de 11 variables contenant chacune une valeur entière
dim tableau$(10) : ' ceci est un tableau de 11 variables contenant chacune une chaîne de caractères

Tu peux passer à une fonction DLL:

Code:

dim res%
res% = dll_call1("test",17) : ' passage d'une constante comme valeur entière
res% = dll_call1("test",valeur%) : ' passage direct d'une variable entière
res% = dll_call1("test",int(valeur)) : ' passage de la partie entière d'une valeur flottante
res% = dll_call1("test",adr(valeur)) : ' passage de l'adresse d'une variable flottante
res% = dll_call1("test",adr(valeur%)) : ' passage de l'adresse d'une variable entière
res% = dll_call1("test",adr(valeur$)) : ' passage de l'adresse d'une chaîne de caractères
res% = dll_call1("test",adr(tableau)) : ' passage de l'adresse de la première variable d'un tableau de flottants
res% = dll_call1("test",adr(tableau%)) : ' passage de l'adresse de la première variable d'un tableau d'entiers
res% = dll_call1("test",adr(tableau$)) : ' passage de l'adresse de la première variable d'un tableau de chaînes de caractères (très difficile à exploiter dans une fonction DLL...)

Dans tous ces cas, la fonction DLL_call1 de Panoramic reçoit une valeur entière et la transmet directement à la fonction "test" contenue dans la DLL. Et il faut que "test" soit conçue pour traiter ce type d'information. Si tu regardes la doc des fonctions d KGF.dll, par exemple, tu verras des exemples.

La syntaxe "as integer" n'existe pas en Panoramic.

ok c clair et net
c'est que la programmation est un domaine très complexe
et beaucoups d'étude pour l'apprivoiser lol
merci klaus et bonne continuation a+

Bonsoir,

En parlant d'adresse, une petite question à Klaus :
Est-ce normal de ne pas avoir au final, la même valeur de pointeur ?

Code:

DIM a$,b$
DIM pStr1,pStr2
DIM i
a$="abc"
b$="def"

LPEEK(ADR(a$)) : pStr1= LPEEK_return%
LPEEK(ADR(b$)) : pStr2= LPEEK_return%

PRINT "a$=";a$;"  adr:";HEX$(ADR(a$));"  debut chaine:";HEX$(pStr1)
DUMP(pStr1,3):PRINT
PRINT "b$=";b$;"  adr:";HEX$(ADR(b$));"  debut chaine:";HEX$(pStr2)
DUMP(pStr2,3):PRINT
b$="abc"
LPEEK(ADR(b$)) : pStr2= LPEEK_return%
PRINT
PRINT "a$=";a$;"  adr:";HEX$(ADR(a$));"  debut chaine:";HEX$(pStr1)
DUMP(pStr1,3):PRINT
PRINT "b$=";b$;"  adr:";HEX$(ADR(b$));"  debut chaine:";HEX$(pStr2)
DUMP(pStr2,3):PRINT


END

SUB DUMP(adr%,l%)
  DIM_LOCAL i
  PRINT "Contenu memoire à partir de l'adresse ";HEX$(adr%);" : ";
  FOR i=adr% TO adr%+l%
    PRINT CHR$(PEEK(i));
  NEXT i
  PRINT
END_SUB

SUB LPEEK(adr%)
  IF VARIABLE("LPEEK_return%")=0 THEN DIM LPEEK_return%
  DIM_LOCAL Value%,i%,a$,Value$
  Value% = 0
  FOR i%=0 TO 3
    a$=HEX$(PEEK(adr%+i%)):IF LEN(a$)<2 THEN a$="0"+a$
    Value$ = a$ + Value$
  NEXT i%
  LPEEK_return% = HEX(Value$)
END_SUB

C'est bon Klaus, j'ai ma réponse...

Code:

DIM a$,b$
DIM pStr1,pStr2
DIM i
a$="abc"
b$="def"

LPEEK(ADR(a$)) : pStr1= LPEEK_return%
LPEEK(ADR(b$)) : pStr2= LPEEK_return%

PRINT "a$=";a$;"  adr:";HEX$(ADR(a$));"  debut chaine:";HEX$(pStr1)
DUMP(pStr1,3):PRINT
PRINT "b$=";b$;"  adr:";HEX$(ADR(b$));"  debut chaine:";HEX$(pStr2)
DUMP(pStr2,3):PRINT
b$=a$
LPEEK(ADR(b$)) : pStr2= LPEEK_return%
PRINT
PRINT "a$=";a$;"  adr:";HEX$(ADR(a$));"  debut chaine:";HEX$(pStr1)
DUMP(pStr1,3):PRINT
PRINT "b$=";b$;"  adr:";HEX$(ADR(b$));"  debut chaine:";HEX$(pStr2)
DUMP(pStr2,3):PRINT


END

SUB DUMP(adr%,l%)
  DIM_LOCAL i
  PRINT "Contenu memoire à partir de l'adresse ";HEX$(adr%);" : ";
  FOR i=adr% TO adr%+l%
    PRINT CHR$(PEEK(i));
  NEXT i
  PRINT
END_SUB

SUB LPEEK(adr%)
  IF VARIABLE("LPEEK_return%")=0 THEN DIM LPEEK_return%
  DIM_LOCAL Value%,i%,a$,Value$
  Value% = 0
  FOR i%=0 TO 3
    a$=HEX$(PEEK(adr%+i%)):IF LEN(a$)<2 THEN a$="0"+a$
    Value$ = a$ + Value$
  NEXT i%
  LPEEK_return% = HEX(Value$)
END_SUB

Oui. Lorsque tu fais b$="abc", tu "oublies" l'ancien contenu, tu réserves un nouvel emplacement en mémoire, tu mets "abc" dans ce nouvel emplacement et tu donnes un pointeur vers cet emplacement à la variable b$. De ce fait, adr(b$) change.

Du coup l’intérêt du compteur dans la structure de définition de la chaine est quand même très réduit...

Le compteur ? C'est un élément de gestion des chaînes de Delphi. On le trouve à l'offset -4 par rapport à l'adresse des données. Il est augmenté chaque fois qu'une chaîne est "copiée" dans une autre (utilisée dans un expression, comme paramètre pour une procédure ou une fonction, etc). Et décrémenté chaque fois que la copie est libérée. Exemple:
a$ = "123"
b$ = a$
b$ semble avoir le même contenu que a$. Mais lorsque du analyses les adresses, tu te rends compte que les deux pointent à la même adresse mémoire. La variable b$ a juste reçu un pointeur vers les données de a$. Et le compteur d'utilisation de a$ est incrémenté: il passe à 2.
Maintenant, tu fais:
b$ = trim$( b$)
Le contenu de b$ semble être identique. Mais les adresses sont différentes. Pourquoi ? Dès que le contenu de b$ est modifié, Delphi effectue la copie physique et réserve un espace mémoire distinct pour b$. Du coup, le compteur d'utilisation de a$ est décrémente (revient à 1).

Tout cela est évidemment invisible, vu par Panoramic, et géré de façon parfaitement transparente. Seule précaution à prendre: si tu peux passer deux adresses de strings à une fonction DLL pour recevoir deux information texte différnents, tu as intérêt à réserver l'espace pour chaque chaîne séparément, et non par une copie. Exemple:

Code:

a$ = string$(30,' ')
b$ = a$
res% = dll_call2("test",adr(a$),adr(b$))

va planter puisque les deux adresses sont identiques, et charger a$ d'abord, puis b$ ensuite, va écraser a$ !
Il faut faire ainsi:

Code:

a$ = string$(30,' ')
b$ = string$(30,' ')
res% = dll_call2("test",adr(a$),adr(b$))

Et là, plus de problème.

Coucou, c' est l' obsédé des icônes !

Klaus, la dll a t elle accès à l' objet bmp de windows en création ?

Oui. Qu'est-ce que tu veux faire ?

ca c' est déjà une bonne chose...

la dll a t elle accès au main menu ?

Je m' explique :

Si on charge un fichier bmp ( petite icône ) dans un picture
la dll cree un objet bmp
copy/coller du picture dans l' objet bmp
injection de l'objet dans le main menu (sub menu).


Je sais que je suis têtu, mais bon, breton et corse, que veux tu, on ne se refait pas...
techniquement je suis nul mais j' ai l' esprit assez tordu pour essayer de comprendre la bête à Bill...
Quoique...lui, il arrive à éteindre une machine par le bouton "Démarrer"...

Tu penses bien que j'ai essayé cette piste ! Et même en copiant les multiples fonctions trouvées sur Internet, je n'ai réussi pour le moment qu'à créer la réservation de place pour l'icône dans la ligne du menu, mais l'icône elle-même n'apparaît pas... je continue chercher.

Où penses tu que le pb se pose ?