Une idée comme cela!

Invité

Tout en voulant rester sur la touche, il m'est venu une idée qui pourrait vous intéresser.

Je suis en train de faire un programme particulier avec mon nouveau éditeur, et à chaque fois que je veux rajouter des objets dans mon programme, je ne sais pas quel numéro mettre. Savoir si celui-ci est déjà pris ou non. Et il m'est venu une idée. Je suis en train de le mettre en pratique, mais en dehors de mon éditeur, qui est hors sujet ici, je vois que vous vous intéressez à NotePad++ je crois. Il vous faut, soit appeler directement un programme par le biais de Panoramic.exe, ou alors développer un programme qui fait la même chose, en se servant de la fonction chain.

Cette deuxième possibilité apporte des possibilités en permettant d'inclure des codes de contrôle du source, donc de mettre des raccourcis, comme je l'ai souvent fait pour moi-même.

Il s'agit ici de la numérotation des objets. Voici mon principe:
On met au départ une ligne de définition, soit en commentaire, soit dans une variable, ou même directement, puisque le code est relu avant d'être envoyé, donc on peut reprendre la ligne avant lancement:

voici: considérons qu'on a trois sujets important dans le programme, sisons:
montage , test , peinture (ce sont des exemples, mais il faut des noms pour comprendre).
Disons qu'on a une partie du source dont les objets concernent montage, une autre partie des objets: teste, et la dernière partie: peinture. On procède ainsi:
definition{montage=100} {teste} {peinture}. ou:
definition$ ="montage=100 ,teste , peinture", la méthode appartient à celui qui adopte le principe.

Ca veut dire quoi tout cela:
Cela veut dire que le premier objet pour montage commence à 100. Ensuite, lorsque tous les objets aurons étés répertoriés, s'ajoutera les objets teste, puis peinture. Voyons l'explication autrement:

montage} (correspondant à un objet n° 100
montage}1 : correspondant à 101
montage}2 ...
montage}3
teste} viendra à la suite, et ici: 104
teste}1 soit: 105
teste}2
teste}3
peinture}1 soit 108, etc...
ce qui revient à dire que l'on programme ainsi:
container montage} :parent montage} , 0.......etc
button montage}1:parent montage}1,montage}

( ça peut-être plus simple: a} , a}1, puis b}.....)
On ne s'occupe plus des numéros. Une fois que le programme est près à être envoyé, le loader, le chargeur, ou préprocesseur, peut importe le nom que vous lui donné, recherche dans le source les mots définis au départ, les mets en liste de la façon suivante:
Au départ, selon la definition, il les mets dans l'ordre dans un dlist:montage},teste}, peinture}. Il les insère à la bonne place, et pour retrouver le numéro, il suffit de savoir à quel hauteur il est dans la liste.
Une fois que la liste complète est faite, il reprend le source, et remplace les raccourcis par les vrais numéros.

Je vous laisse avec cette idée. Personnellement je suis en train de l'inclure dans mon éditeur, et ce n'est pas pour vous inciter à aller le voir, d'autant que j'ai pas encore pensé à la version 32 bits. Mais en plus j'ai inclu un truc comme ceci, et c'est très intéressant: si je ne me souviens plus très bien de quel objet il s'agit, il me suffit de rajouter au mot raccourcis, comme montage}10£. En marquant "£", j'ai un memo qui s'affiche avec toutes les lignes du gui, qui possède ce raccourcis. Le "£" est effacé de suite par Auto-It, et un double-clic sur le memo le ferme, j'ai l'information, et je continu.
Voyez avec NotePad++ ou un autre éditeur (PsPad par exemple), si cela vous intéresse. Dans ce cas, l'un de vous peut le développer.

Bonne nuit.

Ton idée est intéressante, et à plus d'un titre. C'est une solution possible à l'éternel problème de la numérotation des objets, en particulier dans un contexte où l'on veut réutiliser des morceaux de code dans plusieurs programmes, en évitant les conflits de numéros des d'objets.

Je suis bluffé par la clarté de ton exposé, qui montre clairement l'intérêt d'une telle démarche. Reste la mise en oeuvre. Mais comme tu dis, avec un éditeur tiers comme Notepad++, c'est parfaitement jouable.

Invité

A oui, tien! je n'avais pas pensé à cela:

Citation :: en particulier dans un contexte où l'on veut réutiliser des morceaux de code dans plusieurs programmes, en évitant les conflits de numéros des d'objets.

Dans ce cas, il vaut mieux ne pas mettre le numéro de départ dans la définition, et le faire avec une variable dédiée.

Il peut y avoir un code du genre:
definition:montage, teste,peinture (le mot definition je l'ai choisi par rapport à define, mais c'est un mot -clé qui peut-être utilisé. mais il y a certainement mieux)

Et
depart_objet% = 100
chaque source à insérée n'aurait pas de définition, mais utiliserait son propre mot-clé. Seul le programme qui inclu ces source aurait la définition.

source avec montage ici en exemple:
container montage} : left montage},100
memo montage}1 :parent montage}1,montage} :left montage}1,10 :' etc.....

Le fait de mettre par exemple "montage}", avec "}", premièrement évite d'avoir selon les éditeurs de ne pas mettre "{}" automatiquement, si on mettait "{". Deuxièmement, la séparation du mot, et du n°, permet une recherche plus rapide avec instr() sur le mot, et après on prend le numéro.

Une seule parenthèse: l'idée est ici d'insérer un mot représentant un numéro, à sa place dans la liste, mais c'est pas obligatoire. On peut simplement l'ajouter si il n'est pas présent. A partir du moment que le programme met le même numéro pour le même objet, ça ne changera rien pour le fonctionnement. Seule la lecture du code final est plus lisible, si les numéros se suive.

Sur ce, je repars au bois.

A aussi: cela est possible avec Panoramic_Editor. Il suffit de mettre en première ligne:
execute "le programme qui traite le code", Au départ si il voit dans le source cette première ligne, il la retire.

Bonjour a tous
je ne suis vraiment pas a votre niveau en programmation
cela dit j aplique deja la methode en manuel avec des plages de numerotation dedie
par exemple 1xx pour les objets 3D , 2xx pour le terrain etc
l avantage en manuel et de ne pas avoir a renumeroter tout a chaque rajout
si cela peut vous aider :-)

Invité

Bonjour.
Je viens d'adapter le principe pour mon éditeur.
Si ça vous intérresse, je ferais une adaptation pour d'autre éditeur.
Moi, je l'ai inclus dans mon programme, et non dans le loader, celui qui fait l'exécution. Il faut donc une adaptation.

Maintenant il faut que vous en trouvez l'utilité. Elle est évidente pour moi.

Le principe que j'ai adopté est le suivant:
L'instruction de définition des mots clés est le suivant:
#definition:montage=100,teste,peinture
ou bien celui-ci:
#definition:montage ,teste,peinture

J'ai commencé par "#" pour faire comprendre que cette instruction est seule sur la ligne, et est mise en remarque. Elle pourrait être n'importe où dans le programme, puisqu'il y a deux passes.
La variable que j'ai associé est definition%. Si est n'est pas inclu, elle démarre à 1. Comme c'est à partir d'un programme extérieur que l'assemblage est fait, pour une autre valeur, il est bien évident qu'il faut marquer la valeur du n° de l'objet de départ, car le loader, est un exécutable et on n'y touche pas.

Pour les commandes, 'ai choisi cette présentation: [montage] [montage1]. En exemple: memo [montage1]. left [montage1],10. Width [montage1],width([montage0])
Au fur à mesure qu'un nouveau mot de ce type est trouvé, il est ajouté à un dlist. A la fin il y a un tri du dlist, ce qui remet tout en place.

Les commentaires et les chaines entre guillemets sont écartées d'un mot ayant cette ressemblance.

Voila, voila voila voila! Ouf!

Tous les programmes qui s'incorporeraient à un seul programme avec comme seule méthode, cette numérotation, sans en chiffrer aucune, peuvent fonctionner. Il faut seulement que deux programmes incorporés, n'utilisent pas les mêmes mots avec les même chiffres.
Vous auriez une numérotation de 1 à x en continue.

Il y a aussi un avantage, c'est de pouvoir renommer toute une sére en une seule fois, sans avoir à s'inquiéter des paramètres qui ont un même numéro.

Invité

Correction sur 2/3 petits problèmes qui pouvaient se passer le: 3 août 2013
apporte une possibilité de lire une chaîne entre-guillemets pour pouvoir transformer les mots en numéros. Explication dans le post du bas. (4 août 2013

revu la méthode pour permettre la transformation des mots-clés dans une chaine

Bon j'ai repris le code pendant que j'étais encore dessus, et pouvoir passer à autre chose.
Je le mets ici, car il faut le reprendre pour qu'il devienne un LOADER, et là ça concerne ceux qui se servent de NotePad++ par exemple, ce qui n'est pas mon cas. De plus si il n'intéresse personne, il aura trouvé sa place. Cela est la liberté de chacun.

Il est monté comme teste avec un memo, un bouton sommaire, et une forme pour voir le contenu d'un list. Mais normalement le fonctionnement d'un loader est transparent, et le bouton, la form et le list, c'est du gadget. C'est pas leur place. Le list doit devenir un DLIST.

Maintenant c'est une façon de présenter la chose, mais l'idée peut-être reprise autrement. J'ai mon propre fonctionnement, mais des gens (mauvaise langue) me trouvent bizarre! Very Happy

Code:: ' **************************************************************************************************** '
' | Programme a reprendre pour en faire un loader. il doit au départ reprendre le code sauvegardé |
' | ou bien par copie/coller. Il charge , ou met dans le memo 1 pour le traiter, ce que fait ce |
' | programme. Restera ensuite à le sauvegarder, pour pouvoir utiliser le code avec la fonction |
' | CHAIN par exemple, ou passage de paramètres, celui du nom du fichier, pour l'exécuter |
' **************************************************************************************************** '

' **************************************************************************************************** '
' | Si le choix de la reprise de code se fait par le presse papier, vous êtes obligé de vous servir |
' | MEMO,et bar_both, mais si vous récupérez par fichier, alors se servir d'un DLIST |
' **************************************************************************************************** '
width 0,700
rem "Pour la démonstration, le dlist a été remplacé par un LIST dans une autre form 3. Cela montre
rem "les mots qui sont retrouvés, et triés. Le bouton sert à lancer le teste, mais ni form 3, ou le
rem "bouton n'ont pas de raison d'être ici. Le fonctionnement final doit-être transparent, et le code
rem "s'exécuter sans problème. Mais il convient de l'adapter au navigateur à qui ce code est destiné.

label traitement

dim numero$, a$,a%,v% , ligne$ , ligne% , motObjet$, definition%, chaine% , chaine$(10)
dim check$(100), nb_coord% ,u%

memo 1:full_space 1:font_size 1,12:font_bold 1 : bar_both 1 :font_name 1,"Consolas"
button 2 : on_click 2, traitement
form 3 :left 3,700 :' width 3,400:height 3,600
list 10 :parent 10,3 :width 10,60

rem " A votre bon coeur.

end

' ===============================================================================

traitement:
   clear 10
   motObjet$ = ""
   raccourci()
   sort 10
return

sub item_remplace(n%,ligne%,a$)
   item_delete n%,ligne%
   item_insert n%,ligne%,a$
end_sub
' ==============================================================================
sub raccourci()
   if count(1) > 0
   dim_local a$,a%,b$,b% ,c$ ,v%,c%,w%

   motObjet$ = " "
   for a% = 1 to count(1)

   u% =a%
   a$ = item_read$(1,a%)
   if instr(a$,"#definition:") > 0 :' "#definition:montage=100,teste,peinture"
   separt(a$)
   a$ = "rem " + a$
   item_remplace(1,a%,a$)
   else
   rem maintenant que les mots sont dans 10, il faut lire l'ensemble en recherchant "["
   rem on marque les mots comme [montage1]
   if instr(a$,"[") > 0 then conversionPourNumero(a$)
   end_if
   next a%

   rem on a fait la première partie, celui de reconnaitre les mots de remplacement des n° d'objet
   rem Reste à relire tout le programme pour mettre à la place les bons numéros.
   if definition% = 0 then definition% = 1

   for a% = 1 to count(1)
   a$ = item_read$(1,a%)
   ' **********************************************

   IF instr(a$,"[") > 0
   depouillement(a$)
   a$ = ligne$
   rem il faut maintenant lire a$, et voir si il y a un ou plusieurs mots à remplacer.
   ' en remarque le contenu des guillemets est sauvegardé dans chaine$(x) et les mettre à la place de chr$(4) dans a$
   ' là il faut relire la chaine pour mettre à la place les numéros
   repeat
   if instr(a$,chr$(5)) > 0
   w%= instr(a$,chr$(5))
   v% = instr(left$(a$,w%) ,"[")
   else
   v% = instr(a$,"[")
   end_if
   if v% >0
   b$ = mid$(a$,v%,len(a$))
   b$ = upper$(left$(b$,instr(b$,"]") ))

   ' on regarde dans la liste la position de ce mot

   for b% = 1 to count(10)
   if b$ = item_read$(10,b%)
   c% = b%+ definition% -1
   ' on recompose a$ avec le numéro à la place du mot
   a$ = left$(a$,v%-1) + str$(c%) + mid$(a$,v%+len(b$),len(a$))
   exit_for
   end_if
   next b%
   end_if
   until v%=0

   ' puis si il y a chr$(4), mettre à la place le contenu de la chaine sauvegardée.
   if instr(a$,chr$(4)) > 0
   chaine% = 1
   repeat :' dans le cas où plusieurs chaines dans la ligne
   v% = instr(a$,chr$(4))
   if v% > 0
   a$ = left$(a$,v%-1) + chr$(34) + chaine$(chaine%)+ chr$(34) +mid$(a$,v%+1, len(a$))
   chaine% = chaine% +1
   end_if
   until v% = 0
   end_if

   ' puis si il y a chr$(5), enlever chr$(5) placer juste devant pour limiter l'accès
   v% = instr(a$,chr$(5))
   if v% > 0 then a$ = left$(a$, v%-1) + mid$(a$,v% + 1, len(a$)) : ' on retire 1 caractère'
   item_remplace(1,a%,a$)
   END_IF

   if instr(upper$(a$),"TRANSPOSE{") > 0
   v% = instr(upper$(a$),"TRANSPOSE{")
   a$ = left$(a$,v%-1) + mid$(a$,v%+10,len(a$))
   b$ = mid$(a$,v%,len(a$))
   b$ = left$(b$,instr(b$,"}")-1 )+chr$(34)+"" : b% = len(b$)
   a$ = left$(a$,v%-1)+chr$(34)+b$ +mid$(a$,v%+b%,len(a$))
   ' message a$ + chr$(13) + b$ +chr$(13) + str$(b%)+chr$(13) + a$
   item_remplace(1,a%,a$)
   end_if

   ' **********************************************
   next a%

   end_if
end_sub
' *********************************************
rem refaire le dépouillement de la ligne, en excluant les commentaires, et les chaines.
sub depouillement(c$)
   dim_local v%,w% , b$
   chaine% = 0
   if instr(c$,chr$(34)) > 0
   if instr(c$,chr$(34)+"{[") = 0 :' ajouté: { devant un mot code [menu], et être transformé dans certain cas.
   rem on retire l'intérieur des chaines, qu'on met en mémoire, pour ne pas modiifer ou rechercher dans le texte
   repeat
   v% = instr(c$,chr$(34))
   if v% > 0
   b$ = mid$(c$,v%+1,len(c$))
   c$ = left$(c$,v%-1)+chr$(4)
   v%=instr(b$,chr$(34)) :' on retire le 2ème guillemet
   if v% > 0
   chaine% = chaine% +1 : chaine$(chaine%) = left$(b$,v%-1)
   c$ = c$ + mid$(b$,v%+1,len(b$))
   end_if
   ' ainsi il n'y a plus de perturbation avec une chaine
   ' donc si on a memo [a1]: left [a1],10:print " [a2] l'endroit est agréable": ' commentaire
   ' il reste: memo [a1]: left [a1],10:print ?: ' commentaire le ? représentant chr$(4)
   end_if
   until v% = 0
   else
   v% = instr(c$,chr$(34)+"{[")
   c$ = left$(c$,v%)+mid$(c$,v%+2,len(c$)) : v%=0
   end_if
   end_if

   ' ====================================================================================================

   rem reste les commentaires. On sait maintenant qu'ils sont vrais si ils existent.

   v%= instr(upper$(c$),"REM " )
   w%= instr(upper$(c$),"' " )
   if v% = 0 or w% = 0
   v% = max(v%,w%)
   else
   v% = min(v%,w%) :' c'est le plus petit, si ce n'est pas 0
   end_if

   if v% > 0
   if v%=1
   c$ = " "+chr$(5)+c$
   else
   c$ = left$(c$,v%-1) + chr$(5) + mid$(c$,v%,len(c$))
   end_if
   end_if

   rem on a une commande sans commentaire, ni chaine
   a$ = c$ :' oui le problème est ici c'est un a$ local qu'on lit, cela doit venir de: depouillement(a$) mais ligne inutile, ligne$ reprend
   ligne$ = c$ :' controle avec les local et global'
end_sub
' *********************************************

' =============================================================================='
sub conversionPourNumero(a$)
   dim_local v%, w%,b$, numero$ , g% , ap%
   if instr(a$,"[") > 0
   depouillement(a$)
   b$ = ligne$

   if instr(b$,chr$(5)) > 0 then b$ = left$(b$, instr(b$,chr$(5))) :' pour éviter de tester dans les commentaires qui sont après chr$(5)

   repeat
   v% = instr(b$,"[")
   rem il faut aller au séparateur avant
   if v% > 0
   numero$ = mid$(b$,v%,len(b$)):numero$ = upper$(numero$)

   rem on peut avoir: > left [montage1]:width [montage1],([montage2] ) < .
   w% = instr(numero$,"]")
   numero$ = left$(numero$,w%) : ' on aurait par exemple: "[montage1]"
   ' donc on peut faire une recherche dans 1, si il existe, le rajouter pour non, et faire un tri
   if instr(motObjet$," "+ numero$+" ") = 0 then item_add 10,numero$ : motObjet$ = motObjet$+numero$+" "
   if w% > 0 then b$ = mid$(b$,w%+1,len(b$)) : else :exit_repeat
   end_if
   until v% = 0 or w% = 0
   end_if
end_sub

' =============================================================================='
sub separt(a$)
   rem ensuite on s'en sert: [montage] [montage1] [montage2] [teste] [teste1 [peinture] [peinture1]
   rem 100 101 102 103 104 105 106 .
   ' au départ on a :
   rem montage=100
   rem teste
   rem peinture
   ' puis on ajoute les n° si ils ne sont pas présent. TRI ensuite

   if variable("definition%")= 0 then dim definition%
   dim_local a%,nb$,c%,c$ ,suite$,b$ :' "#definition:montage=100,teste, peinture"
   a$ = trim$(mid$(a$,instr(a$,"#definition:")+12,len(a$))) :' "montage=100 ,teste, peinture"

   if instr(a$,"=") > 0 :rem on impose un N° de départ
   b$ = "[" + upper$(trim$(left$(a$, instr(a$,"=")-1 ))) + "]"

   item_add 10,b$:motObjet$ = motObjet$+b$+" " :' "[montage]"
   nb$ = mid$(a$,instr(a$,"=") +1,len(a$) )
   suite$ = trim$(mid$(nb$,instr(nb$,",")+1,len(nb$))) :' "teste , peinture "
   if instr(nb$,",") > 0
   nb$ = left$(nb$, instr(nb$,",")-1) :' "100"
   end_if
   definition% = val(nb$) :' 100 numéro sauvegardé.
   else
   suite$ = a$
   end_if

   explode(",",suite$)
   for a% = 1 to Nb_coord% : item_add 10,"[" + trim$(upper$(check$(a%))) +"]" : next a%
end_sub

' =======================

sub EXPLODE(separ$,chaine$)
' check$( ) , Nb_coord% en global
   dim_local explode%
   dim_local copie$ , v_explode%
   for explode%=1 to 10:check$(explode%)="":next explode%
   explode%=1:copie$=chaine$
   if right$(copie$,1)<> separ$ then copie$ = copie$ +separ$
   repeat
   v_explode%=instr(copie$, separ$ )
   if v_explode%>0 then check$(explode%)=left$(copie$,v_explode%-1):copie$=mid$(copie$,v_explode%+1,len(copie$)):explode%=explode%+1
   until v_explode%=0:Nb_coord%=explode%-1
END_SUB

[/spoiler]
C'est pas un programme, mais un bout de code, pour voir si il fonctionne. En appuyant sur le bouton, les mots de substitution, sont remplacés.

Si ce programme une fois remodelé est adopté, je pense qu'il convient de mettre la touche finale dans les sources à partagés.

Je lève les bras, pour pouvoir passer à autre chose. cheers

Dimanche 4 août:
Je me suis trouvé devant le fait suivant: en ayant mis les numéros en code comme [menu1] ..., j'ai rencontré le problème suivant:
soit un menu ou autre, de ce genre:
main_menu[menu]
sub_menu[menu1] : parent [menu1] , [menu] ....etc...
si je veux par programme activer ou autre une série d'objets avec cette notation de numéros, et faire:
explode("," , "[menu],[menu1],...")
tel que le code était, cela ne pouvait pas fonctionner, car toutes les chaines sont transparentes, et invisible à la 'décompactions' du numéro. Aussi, pour rendre la chose possible, j'ai adopté le principe suivant:
Une chaine entre-guillemets, et non dans une variable, là ça ne marche pas, doit commencer par "{[". pour que la transformation des mots deviennent des numéros.
A partir de là cela fonctionne après la modification apportée) Voir les lignes 132 à 152.

Ce que je dis est peut-être du vent, mais il faut bien en parler pour que si l'un d'entre-vous décide d'adapter le principe, pense à ce problème.

Revu la méthode. par exemple pour:
explode("," , "[a1],[a2],[a3]") : print "[a1],[a2]"
cela devient avec un mot clé: explode("," , transpose{[a1],[a2],[a3]}) : print "[a1],[a2]"
Les crochets remplacent les guillemets. Ainsi la chaine est traité, et on peut mettre autre chose après sur la ligne.
le résultat une fois traité: explode("," , "1,2,3") : print "[a1],[a2]", ce qui permet ensuite à partir de mots de remplacement, de faire par exemple:
for a% = 1 to 3 : inactive val(check$(a%)) : next a%. Un exemple pour pouvoir jouer avec les numéros d'objets selon cette méthode.

Vu que le source est complètement repris, on peut faire ses propre mots-clés, et modifier le programme à sa convenance.

Bon, je pense que je suis au bout de la démonstration. Il y a au moins un qui est intéressé (moi). J'utilise maintenant la méthode avec mon éditeur et avec succès, et c'est le principal pour moi.

» Une commande petite comme ça, efficace comme ça!
» Texte sur une image
» Attention : arnaque F-Cat ? Où est la vérité ?
» Je commence une EDI pour la 3D
» Une idée avec CHAIN