KGF_dll - nouvelles versions

Merci, Minibug !
Le petit truc de Synedit_Function était vraiment un détail, une petite "bouchée au chocolat" pour Panoramiciens.
Par contre, la synchronisation de listes et le scroll horizontal/vertical d'un grid, c'est vraiment un morceau important (quoique avec un code source tout petit !) qui ajoute une fonctionnalité vraiment importante, utile et manquante dans Panoramic !

Nouvelle version:
KGF.dll V7.20 du 08/02/2017

Nouveautés:
-SyneditFunction: nouveau code opération 40

Modules modifiés:
KGF.dll
KGF.chm

La doc et les sources sont à jour.

Ce code a été créé pour une raison de facilité de codage en Panoramic. l est identique au code 39 (liste des raccourcis avec leurs numéros de ligne), mais le résultat est retourné dans un tableau entier de 10 cellules, de type dim tableau%(9). La première cellule (indice 0) contient 0 si l'opération s'est mal terminée pour une raison ou une autre, et 9 si elle s'est bien terminée. Les autres cellules (indices de 1 à 9) contiennent les numéros de ligne pour les raccourcis de 1 à 9. Un numéro de ligne de 0 signifie "raccourci non défini". Ainsi, il est beaucoup plus facile de travailler avec les numéros de ligne que s'il fallait faire val(item_read$(numero_de_liste,numero_de_raccourci)).

Voici le programme de démo étendu aux codes 39 et 40:

Code:: ' test_Synedit_Marqueur.bas

label change, close0, test1, test2

dim res%, SE%, raccourcis%(9), i%

dll_on "KGF.dll"

res% = dll_call0("SyneditInitialize")
on_close 0,close0

edit 1 : hide 1 : on_change 1,change

SE% = dll_call2("SyneditCreate",handle(0),handle(1))
res% = dll_call5("SyneditGeometry",SE%,10,10,400,300)

res% = dll_call3("SyneditFunction",SE%,1,1)

width 0,700
button 2 : top 2,350 : left 2,10 : caption 2,"test 1" : on_click 2,test1
button 3 : top 3,350 : left 3,110 : caption 3,"test 2" : on_click 3,test2
memo 4 : top 4,10 : left 4,450 : width 4,100 : height 4,400 : bar_both 4
memo 5 : top 5,10 : left 5,550 : width 5,100 : height 5,400 : bar_both 5

end

change:
caption 0,text$(1)
return

close0:
res% = dll_call1("KillProcessByHandle",handle(0))
return

test1:
res% = dll_call3("SyneditFunction",SE%,39,handle(4))
return

test2:
res% = dll_call3("SyneditFunction",SE%,40,adr(raccourcis%))
item_add 5,str$(raccourcis%(0))+" raccourcis"
for i%=1 to 9
item_add 5,"["+str$(i%)+"]=> ligne "+str$(raccourcis%(i%))
next i%
return

Le code fonction 39 fonctionne à merveille Klaus.
J' ai réussi ma gestion des signets sur 20 objets synedit.
Bon, c' est folklo mais çà fonctionne.

Regarde sur mon webdav, le zip PPE.
Plus de gestion de projets Twisted Evil

, il gère 20 onglets, plus serait de la gourmandise... Laughing

Ps: tout n' est pas fonctionnel, je prends mon temps.

Citation :: Bon, c' est folklo mais çà fonctionne.

Super ! Pour éviter le côté "folklo", essaie le code 40 qui vient de faire l'objet de la nouvelle version de ce soir... plus facile à utiliser puisque tu auras les numéros de ligne directement dans un tableau d'entiers.

EDIT

Est-ce que tu as vu que, lorsque le curseur est placé dans mot, la frappe de F1 donne une aide contextuelle ? Cela affiche automatiquement la page de Panoramic.chm si elle existe, ou la page de KGF.chm. Ca, c'est fait dans KGF.dll, sans avoir à intervenir dans le progamme Panoramic.

Et F2 affiche la liste "auto-complete" de Panoramic, puis ctrl/F2 la liste "auto-complete" de KGF.dll, dans Synedit_Editor. Ca, ça a besoin d'un soutien de codage en Panoramic.

Là je vais avoir besoin d' exemples j' ai essayé pour kgf mais j' ai du mal m' y prendre et cela ne fonctionne pas.
Embarassed

Code:: raccourcis%(9)
res% = dll_call3("SyneditFunction",SE%,40,adr(raccourcis%))

Après cet appel, les 10 cellules du tableau raccourcis% sont remplies comme suit:
(0) = nombre de raccourcis (toujours 9 si la fonction a réussi)
(1) = numéro de ligne dy raccourci [1] ou zéro si non défini
...
(9) = numéro de ligne dy raccourci [9] ou zéro si non défini

Simple, noon ?

Oui Klaus, je parlais des fichiers d' aide avec f1, f2 et auto-complete.
désolé, j' aurai du préciser.

Regarde dans Synedit_Editor.bas, comment c'est fait.

Pour l'aide contextuelle par F1, il faut avoir spécifié le chemin d'accès aux fichiers Panoramic.chm et KGF.chm:

Code:: res% = dll_call3("SyneditFunction",0,8,adr(PanoramicChm$)) : ' chemin pour Panoramic.chm
res% = dll_call3("SyneditFunction",0,9,adr(KGFChm$)) : ' chemin pour KGF.chm

Pour le complément automatique par F2:

Code:: dim FlagAutoComplete% : ' flag "AutoComplete a été demandé"
dim FlagAutoCompleteKGF% : ' flag "AutoComplete" pour: 0=Panoramic/FBPano 1=KGF.dll 2=Autre

' ===== compléter automatiquement
sub autocomplete(quoi%)
dim_local s$

select quoi%
case 0: ' F2 - Panoramic
caption 4500,"Complément automatique de mots-clé pour Panoramic/FBPano"
if FlagAutoCompleteKGF%<>0
FlagAutoCompleteKGF% = 0
clear 4502
for i%=1 to count(3403)
item_add 4502,item_read$(3403,i%)
next i%
end_if
case 1: ' ctrl/F2 - KGF.dll
res% = dll_call2("SetKeyboardState",17,0) : ' annuler la touche "contrl"
caption 4500,"Complément automatique de mots-clé pour KGF.dll"
if FlagAutoCompleteKGF%<>1
res% = dll_call2("GetExportedNamesFromDLL",adr(kgf$),handle(99))
FlagAutoCompleteKGF% = 1
clear 4502
for i%=1 to count(99)
item_add 4502,item_read$(99,i%)
next i%
end_if
case 2: ' alt/F2 - autre DLL
res% = dll_call2("SetKeyboardState",18,0) : ' annuler la touche "alt"
if AutreDLL$=""
message "Aucune DLL externe n'a été choisie (menu "+chr$(34)+"Outils"+chr$(34)+")"
exit_sub
end_if
caption 4500,"Complément automatique de mots-clé pour "+file_extract_name$(AutreDLL$)
if FlagAutoCompleteKGF%<>2
res% = dll_call2("GetExportedNamesFromDLL",adr(AutreDLL$),handle(99))
FlagAutoCompleteKGF% = 2
if res%<1
message "Pas de noms exportés pour "+file_extract_name$(AutreDLL$)
exit_sub
end_if
clear 4502
for i%=1 to count(99)
item_add 4502,item_read$(99,i%)
next i%
end_if
end_select

sauto0$ = trim$(mid$(salert$+" ",5,100)) : ' récupérer le mot à compléter
text 4501,sauto0$ : ' charger la fenêtre AutoComplete
show 4500 : ' et la montrer
FlagAutoComplete% = 1 : ' signaler "AutoComplete a été demandé"
inactive 0 : ' désactiver la form 0
set_focus 4501
res% = dll_call5("SendSingleKey",handle(4501),35,0,0,0) : ' VK_END
end_sub

' ===== remplace automatiquement le mot sous le curseur par le mot sélectionné
AutoReplaceWord:
FlagAutoComplete% = 0 : ' signaler "AutoComplete inactif"
hide 4500
active 0

sauto$ = item_index$(4502)
if FlagAutoCompleteKGF%=0 : ' cas autocomplete Panoramic ?
if instr(sauto$,sauto0$)=0 then sauto$ = lower$(sauto$)
end_if
res% = dll_call3("SyneditFunction",act%,2,0)
res% = dll_call3("SyneditFunction",act%,34,adr(sauto$))

return

et, dans la reconnaissance de l'évènement généré par Synedit, on fait:
nalert% = instr("CHNSDOAMKEmeakdc",left$(salert$,1)) : ' déterminer le code envoyé par la DLL
select nalert%
...
case 13: ' on a frappé F2 (auto-complete Panoramic) (code "a")
autocomplete(0)
case 14: ' on a frappé ctrl/F2 (auto-complete KGF.dll) (code "k")
autocomplete(1)
case 15: ' on a frappé alt/F2 (auto-complete autre DLL) (code "d")
autocomplete(2)
...

Ok Klaus, je vais regarder tout çà de près demain matin.
Heu...tout à l' heure... Laughing

Là il ne me reste que affraid

3 petites heures à dormir, je dois me lever tôt.

Nouvelle version:
KGF.dll V7.21 du 10/02/2017

Nouveautés:
- ScrollGrid: nouveau paramètre abs%

Modules modifiés:
KGF.dll
KGF.chm

La doc et les sources sont à jour.

La fonction passe de 3 à 4 paramètres. Le nouveau paramètre est un indicateur pour choisir le type de décalage: relatif (0) ou absolu (<>0). En outre, on ne passe plus handle(grid%) pour identifier l'objet GRID, mais object_internal(grid%).

Voici le programme de démo, adapté à ces améliorations:

Code:: ' demo_ScrollGridToRow.bas

label decaler

dim i%, res%

dll_on "KGF.dll"

full_space 0

grid 1 : width 1,800 : height 1,600 : top 1,27
grid_row 1,300 : grid_column 1,100

alpha 10 : top 10,10 : left 10,830 : caption 10,"Ligne:"
alpha 11 : top 11,40 : left 11,830 : caption 11,"Colonne:"
spin 20 : top 20,10 : left 20,880 : width 20,60 : min 20,-300 : max 20,300 : position 20,1
spin 21 : top 21,40 : left 21,880 : width 21,60 : min 21,-100 : max 21,100 : position 21,1
check 25 : top 25,25 : left 25,960 : width 25,200 : caption 25,"Décalage en absolu" : mark_on 25
button 30 : top 30,70 : left 30,880 : caption 30,"Décaler" : on_click 30,decaler

for i%=1 to 300
  grid_write 1,i%,1,"R"+str$(i%)
next i%
for i%=1 to 200
  grid_write 1,1,i%,"C"+str$(i%)
next i%

end

decaler:
  res% = dll_call4("ScrollGrid",object_internal(1),checked(25),position(20),position(21))
  return

Cela permet de décaler la partie visible d'un objet GRID au gré des besoins.

J'ai remanié la documentation de KGF.dll dans le fichier KGF.chm et dans la doc en ligne.

J'ai créé une nouvelle catégorie "Support graphique" (en bas de la liste), et j'y ai placé toutes les fonctions, déjà existantes, ayant pour objet d'effectuer des calculs par rapport à des points, rectangles, cercles, ellipses et polygones. Elles sont ainsi plus faciles à retrouver.

Ces fonctions peuvent en particulier servir à la détection de collisions, dans des jeux 2D.

Merci Klaus !

J' ai une petite incohérence avec Synedit.

j' ai remarqué qu' en sélectionnant à la souris des lignes dans un objet synedit
puis en utilisant la fonction 13, les lignes sélectionnées étaient repliées.

J' ai donc essayer de faire un repliage par block

:
return

sub
end_sub

' */
' /*

hors, cela ne marche pas à tout les coups.
je te mets les deux sub

Code:: sub DetectBlock()
dim_local res%,lig$,Crit$

if variable("debBlock%")=0 : dim debBlock% : else : debBlock%=0 : end_if
if variable("finBlock%")=0 : dim finBlock% : else : finBlock%=0 : end_if

clear ListePliage%
' récupération du numéro de la ligne de départ
debBlock% = dll_call3("SyneditFunction",Selected_SE%,30,0)
' sélection de la ligne
res% = dll_call3("SyneditFunction",Selected_SE%,14,1)
' récupération du texte de la ligne
res% = dll_call3("SyneditFunction",Selected_SE%,17,handle(ListePliage%))
lig$ = trim$(item_read$(ListePliage%,1))

' détection du bloc
if upper$(left$(lig$,3))="SUB"
Crit$ = "end_sub"
' récupération de la ligne de fin de bloc
finBlock% = dll_call3("SyneditFunction",Selected_SE%,19,adr(Crit$))
else
if right$(lig$,1)=":"
Crit$ = "return"
finBlock% = dll_call3("SyneditFunction",Selected_SE%,19,adr(Crit$))
else
if upper$(left$(lig$,4))="' */"
Crit$ = "' /*"
finBlock% = dll_call3("SyneditFunction",Selected_SE%,19,adr(Crit$))
end_if
end_if
end_if

end_sub

Code:: ' -- Plier/Deplier
sub SyneditPlierDeplier(S%)
dim_local res%,nbrlig%,mess$

' detection du bloc à replier
DetectBlock()
' calcul du nombre de ligne à sélectionner
nbrlig%=finBlock%-debBlock%

mess$= "début : "+str$(debBlock%)+chr$(13)
mess$= mess$+"fin : "+str$(finBlock%)+chr$(13)
mess$= mess$+"Nb lignes : "+str$(nbrlig%)
message mess$

' sélection des lignes
res% = dll_call3("SyneditFunction",S%,14,nbrlig%)
' repliage des lignes sélectionnées
res% = dll_call3("SyneditFunction",S%,13,0)
' retour du curseur sur la ligne de départ
res% = dll_call3("SyneditFunction",S%,18,debBlock%)
' comme j' ai plusieurs objets synedit je ré-active le synédit
res% = dll_call3("SyneditFunction",S%,2,0)
end_sub

En gros le repliage fonctionne sur une sélection à la souris mais pas par programme.

Je vais regarder cela demain...

EDIT

Ce je peux dire dans l'immédiat, c'est ceci:

1. le début de la section à plier est déterminé de la manière suivante:
1.1. si aucun texte n'est sélectionné (surligné), alors on prend le début de la ligne dans laquelle se trouve le curseur.
1.2. si du texte est sélectionné (surligné), on prend le début de la ligne dans laquelle est le début de sélection
2. la fin de la sélection est déterminée de la manière suivante:
2.1. si aucun texte n'est sélectionné (surligné), alors on s'rarrête au début de la première ligne blanche après de point de début du pliage, ou en fin de fichier s'il n'y a pas de ligne blanche
2.2. si du texte est sélectionné (surligné), on prend la position juste après la ligne contenant la fin de la sélection

Ainsi:
- une sélection de quelques caractères au milieu d'une seule ligne conduit au pliage de cette ligne en entier
- une sélection à cheval sur plusieurs lignes prend l'ensemble de ces lignes en entier, que la sélection englobe la totalité de ces lignes ou pas
- un pliage sans sélection prend toujours du début de la ligne du curseur jusqu'au début de la première ligne blanche suivante ou jusqu'en fin de fichier

Ainsi, si tu veux sélectionner une section précise sans tenir compte des lignes blanches, il faut que tu sélectionnes les lignes concernées avant, par programme.

Je regarderai ton code demain.

Bon, j'ai regardé ton code.

En gros, ce que tu essaies de faire, c'est de déterminer le bloc à plier selon les étapes suivantes:
- tu sélectionne la ligne dans laquelle se trouve le curseur et tu récupères son contenu
- si cette ligne débute par SUB, tu cherches END_SUB et tu mémorises son numéro de ligne
- si cette ligne se termine par le caractère ":", tu cherches RETURN et tu mémorises son numéro de ligne
- si cette ligne débute par "' */", tu cherches "' /*" et tu mémorises cette ligne
- dans tous les autres cas, ta variable finblock% reste à zéro

Ensuite, tu veux plier la partie ainsi déterminée. Pour cela, tu commences par sélectionner nbrlig% lignes.

Mais le problème numéro 1 se situe exactement à cet endroit. La sélection a lieu à partir de la position actuelle du curseur. Or, il est où ? Il est là où tu as trouvé ton critère de recherche, ou, si rien n'est trouvé, à une position qui n'est par bien définie et certes pas la bonne.

Solution: repositionner le curseur d'abord sur la ligne debblock% avant de sélectionner ton nombre de lignes.

Mais il y a un problème numéro 2: en effet, tes critères de recherche sont trop imprécis.
Exemple 1: tu essaies de déterminer si tu es sur un label. Pour cela, tu regardes si la ligne se termine par un ":". C'est un cas de figure, mais loin d'être le seul ! Tu peux avoir une ligne "case 17:" par exemple...
Exemple 2: pour détecter une définition d'une SUB, tu testes si la ligne commence par "SUB". Ce n'est pas assez précis: tu peux avoir "SUB_MENU", une variable du genre "SUBITO%", un appel d'une SUB du genre "SUBURBAIN(3)" etc... Essaie d'utiliser if upper$(left$(lig$,4))="SUB ", ça marchera mieux.
Exemple 3: dans tous les cas, tu cherches un "critère". Le code 19 cependant cherche toujours depuis le début du contenu du Synedit, ce qui n'est évidemment pas ce que tu veux faire. En plus, pour le cas du RETURN par exemple, tu peux avoir plusieurs RETURN dans un sous-programme, précédée ou non d'une commande IF...

Bref, ta recherche n'est pas assez précise. Il faudra que tu parcoures le contenu du Synedit ligne par ligne, à partir de la ligne de départ, et que tu analyses plus finement le contenu de chaque ligne. La simplre présence de ton "critère" est loin d'être suffisante. Que fais-tu d'un "Return" entre guillemets ? En plusl le code 19 est sensible à la casse. Donc, actuellement, tu n'as aucune chance de tomber juste.

Fais ce que je te conseille:
1. affine ta détection du type de bloc au départ, en particulier celle avecle ":", et mémorise, non pas le critère, mais le type de bloc que tu veux plier (1=SUB, 2=sousprogramme, 3=commentaire long, ... - tu peux en imaginer d'autres)
2. parcours ensuite ton texte ligne par ligne, et, en fonction du type de bloc (via un SELECT...CASE...END_SELECT) tu codes une détection de fin de bloc appropriée pour chaque cas
3 et finalement, si, et seulement si, une telle fin est trouvée, mémorise la ligne de fin, repositionne le curseur sur la ligne de début, puis sélectionne un nombre de lignes fin-debut+1.

Et là, àa marchera.

Bon, j' ai abandonné pour en revenir à la méthode classique de sélection
à la souris avant repliage.
Embarassed

Lors de la sélection par la fonction 14, le curseur est replacé en début de la
première ligne. Donc, il est inutile de replacer le curseur avant le pliage.
L' anarchie est après le pliage où le curseur n' est pas placé sur la ligne de pliage.

En plus, la fonction faisant appel à une détection de bloc en amont, un appel pour dépliage devient du grand n' importe quoi.

Bref, c' est trop confus dans mon esprit pour le moment, je préfère ajourner
la détection de bloc pour l' instant.
Wink

J' ai réussi la gestion des signets, c' est déjà une satisfaction.
Je vais me consoler avec çà.
Laughing

Nouvelle version:
KGF.dll V7.22 du 30/02/2017

Nouveautés:
- SyneditFunction: nouveau code 41

Modules modifiés:
KGF.dll
KGF.chm

La doc et les sources sont à jour.

Ce nouveau code est appelé à travailler en "collaboration" avec le code 19.

Le code 19 recherche la première occurrence d'une chaîne de caractères dans le fichier, à partir de la ligne 1. Ce code mémorise maintenant le critère de recherche dans l'objet Synedit, de façon interne.

Le code 41 effectue également une recherche de chaîne de caractères, en utilisant le critère mémorisé par le code 19. Le second paramètre par% donne le numéro de ligne de début de recherche, zéro (0) signifiant "début du fichier".

Ainsi, pour trouver l'occurrence suivante d'une chaîne de caractères, après une première recherche par le code 19, il suffit de donner le numéro de ligne retourné par le code 19 en ajoutant 1 (pour passer à la ligne suivante !) au code 41, qui à son tour retourne un numéro de ligne, etc.

Je vais me mettre à jour et tester.
Laughing

J'ai modifié la doc KGF.chm, au niveau de la fonction SyneditFunction.

En effet, celle-ci a maintenant 41 codes opération. Cela fonctionne bien, mais le ource n'est pas très lisible, avec juste les codes numériques. C'est pourquoi j'ai créé une SUB qui définit des constantes avec des noms significatifs pour une meilleure lisibilité. Cette sub est incluse dans la page SyneditFunction de KGF.chm. On peut la récupérer par copier/coller. Mais je la mets ici, également:

Code:: Sub SyneditFunctionCodes()
dim SF_DisplayLineNumbers% : SF_DisplayLineNumbers% = 1
dim SF_Activate% : SF_Activate% = 2
dim SF_ChangeParameters% : SF_ChangeParameters% = 3
dim SF_GetSyntaxList% : SF_GetSyntaxList% = 4
dim SF_ChangeSyntax% : SF_ChangeSyntax% = 5
dim SF_InsertDemoText% : SF_InsertDemoText% = 6 : ' non implémenté
dim SF_ChangeCharacterCode% : SF_ChangeCharacterCode% = 7
dim SF_PanoramicHelpPath% : SF_PanoramicHelpPath% = 8
dim SF_KgfHelpPath% : SF_KgfHelpPath% = 9
dim SF_SearchText% : SF_SearchText% = 10
dim SF_GetColorLabels% : SF_GetColorLabels% = 11
dim SF_GetColorValues% : SF_GetColorValues% = 12
dim SF_FoldUnfold% : SF_FoldUnfold% = 13
dim SF_SelectLines% : SF_SelectLines% = 14
dim SF_LoadIndentifier% : SF_LoadIndentifier% = 15
dim SF_ApplicationFolder% : SF_ApplicationFolder% = 16
dim SF_GetSelectedText% : SF_GetSelectedText% = 17
dim SF_JumpToLine% : SF_JumpToLine% = 18
dim SF_FindStringFromStart% : SF_FindStringFromStart% = 19
dim SF_Handle% : SF_Handle% = 20
dim SF_ReplaceString% : SF_ReplaceString% = 21
dim SF_CopySelection% : SF_CopySelection% = 22
dim SF_TextBackgroundColor% : SF_TextBackgroundColor% = 23
dim SF_GutterBackgroundColor% : SF_GutterBackgroundColor% = 24
dim SF_SearchMode% : SF_SearchMode% = 25
dim SF_TextColor% : SF_TextColor% = 26
dim SF_Print% : SF_Print% = 27
dim SF_LineCount% : SF_LineCount% = 28
dim SF_AppendText% : SF_AppendText% = 29
dim SF_CurrentLine% : SF_CurrentLine% = 30
dim SF_CurrentColumn% : SF_CurrentColumn% = 31
dim SF_SkipSingleWord% : SF_SkipSingleWord% = 32
dim SF_Clear% : SF_Clear% = 33
dim SF_ReplaceCurrentWord% : SF_ReplaceCurrentWord% = 34
dim SF_SetHelpWithMSDN% : SF_SetHelpWithMSDN% = 35
dim SF_GetCursorCoordinates% : SF_GetCursorCoordinates% = 36
dim SF_SelectCharacters% : SF_SelectCharacters% = 37
dim SF_SignalCharacter% : SF_SignalCharacter% = 38
dim SF_GetBookmarksIntoMemo% : SF_GetBookmarksIntoMemo% = 39
dim SF_GetBookmarksIntoArray% : SF_GetBookmarksIntoArray% = 40
dim SF_FindNextString% : SF_FindNextString% = 41
end_sub

Ainsi, au lieu de coder:

Code:: res% = dll_call3("SyneditFunction",SE%(act%),2,0)

on peut coder:

Code:: res% = dll_call3("SyneditFunction",SE%(act%),SF_Activate% ,0)

C'est plus clair, non ?

Je ne sais pas si c' est plus clair, pour mon cas je verrai à l' usage peut-être.
Cela devrait l' être pour ceux qui commence à utiliser ces fonctions et n' ont pas pris l' habitude des numéros de fonction.

En tout cas, vu le morceau qu' est devenu kgf, cela doit devenir compliqué de trouver
des noms de variables originaux...
Laughing

Petite mise en garde ou signalement d' un petit bug

Lorsque l' on utilise la command SORT N Panoramic
après le rattachement d' un LIST Panoramic dans un onglet de l' objet TAB de Kgf
l' objet LIST, sur lequel s' applique la commande SORT N, est détaché de son hôte.

(Du moins, c' est l' impression visuelle que cela donne car son placement en x,y devient très farfelu.)

Peux-tu poster un petit code simple pour le mettre en évidence ?

Simple,simple...je deviens de plus en plus panoramicien et
le simple devient compliqué...
Je vais tenter le coup mais je ne promets rien.
lol!

Hourra ! j' ai réussi à faire un exemple simple...
Laughing

voilà le code :

Code:: dim res%,TO%,txt$,o%(2)

dll_on "C:\KGF\KGF.dll"

height 0,500
width 0,700

TO% = dll_call1("CreateTabObject",handle(0))
res% = dll_call5("TabObjectGeometry",TO%,10,10,width_client(0)-20,height_client(0)-20)
txt$ = "Feuil(1)"
o%(1) = dll_call2("AddTabObjectTab",TO%,adr(txt$))
res% = dll_call6("TabObjectFunction",TO%,5,o%(1),2,0,0)
txt$ = "Feuil(2)"
o%(2) = dll_call2("AddTabObjectTab",TO%,adr(txt$))
res% = dll_call6("TabObjectFunction",TO%,5,o%(2),2,0,0)

' ------------------------------------------------------------------------------
' cas 1 sort_on avant ratachement, le list reste à sa place
' ------------------------------------------------------------------------------
List 1
height 1,height_client(0)-50
width 1,int((width_client(0)-35)/2)
top 1,5
left 1,5
font_name 1,"Courier New"
font_bold 1
sort_on 1
res% = dll_call3("AddObjectToTabObjectTab",TO%,o%(1),handle(1))
item_add 1,"item 1"
item_add 1,"item 3"
item_add 1,"item 2"

' ------------------------------------------------------------------------------
' cas 2 sort N après ratachement (activer la ligne 48 pour voir le pb)
' ------------------------------------------------------------------------------

List 2
height 2,height_client(0)-50
width 2,int((width_client(0)-35)/2)
top 2,5
left 2,left(1)+width(1)+5
font_name 2,"Courier New"
font_bold 2
res% = dll_call3("AddObjectToTabObjectTab",TO%,o%(1),handle(2))
item_add 2,"item 1"
item_add 2,"item 3"
item_add 2,"item 2"
' sort 2
end

Houlala....

Avec object_internal(n)

Code:: dim res%,TO%,txt$,o%(2)

dll_on "C:\KGF\KGF.dll"

height 0,500
width 0,700

TO% = dll_call1("CreateTabObject",handle(0))
res% = dll_call5("TabObjectGeometry",TO%,10,10,width_client(0)-20,height_client(0)-20)
txt$ = "Feuil(1)"
o%(1) = dll_call2("AddTabObjectTab",TO%,adr(txt$))
res% = dll_call6("TabObjectFunction",TO%,5,o%(1),2,0,0)
txt$ = "Feuil(2)"
o%(2) = dll_call2("AddTabObjectTab",TO%,adr(txt$))
res% = dll_call6("TabObjectFunction",TO%,5,o%(2),2,0,0)

' ------------------------------------------------------------------------------
' cas 1 sort_on avant ratachement, le list reste à sa place
' ------------------------------------------------------------------------------
List 1
height 1,height_client(0)-50
width 1,int((width_client(0)-35)/2)
top 1,5
left 1,5
font_name 1,"Courier New"
font_bold 1
sort_on 1
' res% = dll_call3("AddObjectToTabObjectTab",TO%,o%(1),handle(1))
res% = dll_call3("AddSimpleObjectToTabObjectTab",TO%,o%(1),object_internal(1))

item_add 1,"item 1"
item_add 1,"item 3"
item_add 1,"item 2"

' ------------------------------------------------------------------------------
' cas 2 sort N après ratachement (activer la ligne 48 pour voir le pb)
' ------------------------------------------------------------------------------

List 2
height 2,height_client(0)-50
width 2,int((width_client(0)-35)/2)
top 2,5
left 2,left(1)+width(1)+5
font_name 2,"Courier New"
font_bold 2
' res% = dll_call3("AddObjectToTabObjectTab",TO%,o%(1),handle(2))
res% = dll_call3("AddSimpleObjectToTabObjectTab",TO%,o%(1),object_internal(2))
item_add 2,"item 1"
item_add 2,"item 3"
item_add 2,"item 2"
' sort 2
end

Finalement c' est mieux avec le handle... Laughing

» KGF_dll - nouvelles versions
» KGF_dll - nouvelles versions
» KGF_dll - nouvelles versions
» Synedit_Editor - nouvelles versions
» Nouvelles DLL bonus