stephan35

Bonjour à tous ! Merci pour le lisp ZIP, il fonctionne parfaitement, J'ai tenté de le décortiquer ...... :casstet: Je tente de faire un zip manuellement avec ce que patrick_35 m'a donné ..... :casstet: Il me manque les bases .... mais tout se passe ici : (vlax-invoke zip 'copyhere (vla-item nom fic)) Je tente de faire genre :Zip Destination fichier_à_ajouter et je bloque sur le vla-item .... (setq sh (vlax-create-object "shell.application")) (setq zip (vlax-invoke sh 'namespace (strcat "C:/" "toto.zip"))) ;(vlax-invoke zip 'copyhere (vla-item nom fic)) (vlax-invoke zip 'copyhere (strcat $rep "/" (Odcl_Control_GetText Boites_Open_EFIC))) (vlax-release-object sh) Merci A+ [Edité le 14/3/2007 par stephan35]

Merci patrick_35 Je jette un oeil et je te tiens au parfum ... a+ :D

en ligne de commande ??? :casstet: Je n'ai pas réussi !

J'ai trouvé ça : http://www.progesoft.com/compra/index.asp?left=../icad/linux_news1&lang=eng&abspage=1 C'est comme le canada dry, ça ressemble, mais ça n'est pas ! ;)

Bonjour à tous, Est-il possible d'ajouter dans un jeu de feuille un fichier sans présentation ???? Et comment faire ??? Merci à vous

Bonjour à tous, Je tente désepérement de faire un zip de mon répertoire, sans utiliser un programme externe, et ceci avec la commande etransmit, mais problèmes : Etransmit prend par défaut le fichier en cours, on peut rajouter une liste de fichier mais pas avec la commande en ligne -etransmit (N'est-ce pas ?) Etransmit peut sauvegarder un jeu de feuille, mais je ne peut pas rajouter les fichiers DWG de mon répertoire car ils n'ont pas de présentation , et comme chacun le sait, le jeu de feuille ne prend en compte que les présentations !( n'est-ce pas ?) [surligneur] Donc il ne reste plus que le LISP ?[/surligneur] ou comment faire ???? :casstet: Merci à vous !

Salut le crabe ! Non, effectivement, il fallait tout lire ! Donc pour tout le monde : après un -etransmit quels sont les options ou la commande qui me permet d'ajouter des fichiers à ma sauvegarde ? Ou en vlisp ou Lisp .... :casstet: Merci à tous !

Voici la seconde partie des résultats : [surligneur] DINGUE !!! [/surligneur] La méthode vlax-*** est à proscrire pour des traitements répétitifs , c'est trop long ... 2min 18 pour 280 / 500 , bref, j'ai coupé en cours de route ... :( Cette méthode est cependant plus simple à écrire, c'est vrai ! à revérifier ....

Je souhaite passer tout mon répertoire courant dans ma sauvegarde Zip avec etransmit , Je ne gère pas les feuilles, car pas de présentation ! Et le tout en ligne de commande .... :casstet: Comment fait-on ??? Merci

Voici une partie des résultats : [surligneur] FRAPPADINGUE ![/surligneur] Donc sur une boucle de 500 (répété 3 fois) La méthode Linéaire est de 32 Sec Le méthode fonction imbriquées 38 sec :( J'ai raccourcis mes noms de fonctions et de variables Même teste: La méthode Linéaire est de 27 Sec Le méthode fonction imbriquées 20 sec Conclusion proposée : Raccourcir les noms de variable à 6 char max, idem pour les fonctions ! si quelqu'un pouvais confirmer ! Je continue avec le méthode de patrick_35 .... ;)

Pour une raison simple, repond nil si le fichier est ouvert !, et dans mon cas je peux avoir besoin d'ouvrir un fichier en lecture seul ou déjà ouvert . Merci A+

WWWWWWWWAAAAAAOOOOWWWWWW Et ! Pas ceinture noire pour rien ! ;) Bon et bien, je pense que j'ai de quoi potasser !!! Je fais mes petits tests comparatifs, et je donne mes résultats !!!! Merci beaucoup et à +

Ok merci, Cependant, malgré tout, tu scrutes la totalité de la séquence bloc ! :cool: , Donc perte de temps ! Si je veux juste extraire la valeur contenue dans l'étiquette "L1" je suis obligé de faire un teste pour chaque att du foreach ???? N'est-ce pas ? Et avec le SSGET, on ne peut toujours pas, non plus, accèder directement à un attribut spécifique ! [surligneur] as-tu une solution ???[/surligneur] Je vais quand même comparer les 2 versions (Lisp <> Vlisp) ! avec le test sur chaque att Merci, a+ Ps: je viens de me rendre compte que le sujet vient de changer ??? [Edité le 6/3/2007 par stephan35]

on tourne en rond ? Tu peux me la refaire avec comme entrée : (defun @Macro_checksum_fichier ( $file / $tmp #filetime #filesize) (if $file (progn (if (vl-file-size $file) (progn (setq objWsh (vlax-create-object "Scripting.FileSystemObject")) (setq objFile (vlax-invoke-method objWsh 'GetFile $file)) (strcat (@Macro_julian (vlax-get objFile 'DateLastModified))"*"(itoa (vlax-get objFile 'Size))) ) (progn (MsgBox "Erreur" 16 (strcat $file " n'existe pas !")) ) ) ) ) ) (@Macro_julian) retourne la date ! :casstet: ????

Tu a ni plus ni moins faits que de redonner la formule de didier :cool: bien essayer ... Commande: (getvar "cdate" ) 2.00703e+007 Qui n'est pas du même ordre que (vlax-get objFile 'DateCreated) ce qui donne 38979.6 ... Vois-tu le problème ??? :casstet: :casstet: :casstet: :casstet: :casstet: :casstet: :casstet: Merci quand même !

3dsmax le gère pas le bi-processoring ??? comme ça .... en passant ?

Pour aller plus vite ....... : J'ai un bloc avec une série d'attributs : (list "RA""RB""RC""RD""RE""RF""RG""RH" ....... etc d'ailleurs mon bug viendrait de la longueur de cette liste :casstet: Imaginons une fonction qui permette d'explorer un bloc pour en extraite le contenu d'un attribut : ;#SSN nom de l'entité d'un jeu de selection ;$T Type = "ATTRIB" ;$E Etiquette $Valeur si nil , on lit, si = "***" on écrit la valeur (defun @S_AE ( #SSN $T $E #t $valeur / &Be $Be0 R) (if (not #SSN)(progn (alert (strcat "@S_AE \nValeur nil pour #SSN"))(exit))) (if (not $T)(progn (alert (strcat "@S_AE \nValeur nil pour $R"))(exit))) (if (not $E)(progn (alert (strcat "@S_AE \nValeur nil pour $V"))(exit))) (if (not #t)(progn (alert (strcat "@S_AE \nValeur nil pour #t"))(exit))) (setq &Be (entget #SSN)) (setq $Be0 (@R0 &Be)) (while (and (/= $Be0 "SEQEND") (/= (entnext #SSN) nil)) (setq &Be (entget (setq #SSN (entnext #SSN)))) (setq $Be0 (@R0 &Be)) (if (= $Be0 $T) ;Attribut (if (= $E (@R2 &Be)) ; Si Etiquette ok (if (not $valeur) (progn (cond ((= #t 8)(setq R (@R8 &Be))) ((= #t 1)(setq R (@R1 &Be))) ((= #t 2)(setq R (@R2 &Be))) ) ) (progn (cond ((= #t 8)(setq R (@W8 &Be $valeur))) ((= #t 1)(setq R (@W1 &Be $valeur))) ((= #t 2)(setq R (@W2 &Be $valeur))) ) ) ) ) ) ) R ) Mon problème est que dans certains cas, j'ai 25 attributs dans un bloc, donc je vais le scruté 25 fois pour en extraire les valeurs !!! Donc j'ai développé une fonction qui construit une liste en une seul passe de bloc, qui pour chaque attribut regarde si celui-ci est à extraire, puis l'ajoute a la liste résultante .... :casstet: (+ Rapide) [surligneur] N'y aurait-il pas une solution qui permet rapidement d'extraire la valeur d'un attribut ou de tout autre élément d'un bloc dans devoir passer le bloc en revue ????? (sans handle et sans n° entité bien surrrr !)[/surligneur] à vos clavier .... ;) :casstet: :casstet: :casstet: :casstet: :casstet: :casstet: :casstet: Merci

Aîe Aîe Aîe Aîe Aîe Aîe Aîe Aîe Aîe Aîe Aîe Aîe !!!!!!! Bon ça ne marche pas ? :cool: Si ici : (defun @R1 ($b / ) (princ (strcat "\nFonction @R1, argument " $b)) ) (defun @R2 ($b / ) (princ (strcat "\nFonction @R2, argument " $b)) ) (defun @R3 ($b / ) (princ (strcat "\nFonction @R3, argument " $b)) ) (defun @Princ (@macro $a / ) (@macro $a) (princ) ) (@Princ @R1 "opop") (@Princ @R2 "opop") (@Princ @R3 "opop") Fonction @R1, argument opop Fonction @R2, argument opop Fonction @R3, argument opop Alors : (defun @X_SS (@Macro #SS / #C) (if (not #SS)(progn (alert (strcat "@X_SS \nValeur nil pour #SS"))(exit))) (if (not @Macro)(progn (alert (strcat "@X_SS \nMacro nil pour @MX_SS"))(exit))) (setq #C 0) (if #SS (repeat (sslength #SS) (@Macro (setq #SSN (ssname #SS #C))) (setq #C (1+ #C)) ) ) ) (defun @MX_SS ( #SSN / ) (setq &Liste_Globale(@S_AL_@R-1_@R2_@R1 #SSN "ATTRIB" (list "RA""RB""RC""RD""RE""RF""RG""RH""RI""RJ""RK""RL""RM""RN""RO""RP""RQ""RR""RS""RT""RU""RV""RW""RX""RY""RZ""DATEA""DATEB""DATEC""DATED""DATEE""DATEF""DATEG""DATEH""DATEI""DATEJ""DATEK""DATEL""DATEM""DATEN""DATEO""DATEP""DATEQ""DATER""DATES""DATET""DATEU""DATEV""DATEW""DATEX""DATEY""DATEZ""DESIGNATIONA""DESIGNATIONB""DESIGNATIONC""DESIGNATIOND""DESIGNATIONE""DESIGNATIONF""DESIGNATIONG""DESIGNATIONH""DESIGNATIONI""DESIGNATIONJ""DESIGNATIONK""DESIGNATIONL""DESIGNATIONM""DESIGNATIONN""DESIGNATIONO""DESIGNATIONP""DESIGNATIONQ""DESIGNATIONR""DESIGNATIONS""DESIGNATIONT""DESIGNATIONU""DESIGNATIONV""DESIGNATIONW""DESIGNATIONX""DESIGNATIONY""DESIGNATIONZ""PREPA""PREPB""PREPC""PREPD""PREPE""PREPF""PREPG""PREPH""PREPI""PREPJ""PREPK""PREPL""PREPM""PREPN""PREPO""PREPP""PREPQ""PREPR""PREPS""PREPT""PREPU""PREPV""PREPW""PREPX""PREPY""PREPZ""VERIFA""VERIFB""VERIFC""VERIFD""VERIFE""VERIFF""VERIFG""VERIFH""VERIFI""VERIFJ""VERIFK""VERIFL""VERIFM""VERIFN""VERIFO""VERIFP""VERIFQ""VERIFR""VERIFS""VERIFT""VERIFU""VERIFV""VERIFW""VERIFX""VERIFY""VERIFZ""APPA""APPB""APPC""APPD""APPE""APPF""APPG""APPH""APPI""APPJ""APPK""APPL""APPM""APPN""APPO""APPP""APPQ""APPR""APPS""APPT""APPU""APPV""APPW""APPX""APPY""APPZ"))) ) (@X_SS @MX_SS #SS) devrait fonctionner ?????? :casstet: Hum Hum ....

Il est vrai qu'il faut laissé une floppée de commentaire, pour le cas ou on y revient 6 mois après .... ;) Mais aussi, avec une simple convention de repère que l'on s'impose, les choses vont toutes seules ... (en téhorie ...) ;) Exemple: pour les variables : $tmp = chaine #tmp = valeur &tmp = liste niveau 0 &&tmp = liste imbriquée &&&tmp = etc @tmp = fonction (@tmp $tmp) = fonction avec 1 chaine en entrée et l'on peut tout imaginer .... d'ailleurs pourquoi ne pas proposer à autodesk de faire de la déclaration de variable pour le lisp ......... (ça va mettre le bazar ? :casstet: ) A+

Et oui çà marche ! En écrivant l'énoncée du problème j'avais corrigé mon erreur ... :casstet: (@princ @R1 "po") et non (@princ (@R1) "po") , milles excuses !!!!!! :( Je ne sais pas si je dois le prendre comme un compliment ? ;) En fait, je remprends l'ensemble de mes listings en compilant les lignes d'écritures, soit au bas mot 250 lisp à revoir,et je me suis apperçu que dans 60% des cas je réécrivais ce que j'avais déjà écrit ailleur avec une ou deux variantes .... Comme tout le monde j'avais quelques fonctions définient dans le AutoCAD.lsp mais j'en ai créé une ribambelle à droite à gauche etc., Mon objectif est de réduire au minima les lignes de codes en créant des tronc commun, les variantes seront passées en paramètres dans les fonctions, y compris les fonctions appelées dans les fonctions .... :casstet: on y vient : tous mes ssget seront par exemple réduit à une fonction, idem pour l'exploration du résultat du ssget, exemple : (setq $nom_bloc (@R2 (setq &e (entget (setq #e (car(entsel))))))) ; Selectionne dans le document tous les blocs portant ce nom (@SS_@R0_@R2 (@R0 &e)(@R2 &e)) @R0 = assoc 0 &e @R2 = assoc 2 &e (defun @R2 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R2 \nValeur nil pour &entget"))(exit))) (cdr(assoc 2 &entget)) ) Puis une macro qui explore le jeu de selection : (defun @X_SS (#SS @macro/ #C) ;(if (not #SS)(progn (alert (strcat "@X_SS \nValeur nil pour #SS"))(exit))) (if (not @MX_SS)(progn (alert (strcat "@X_SS \nMacro nil pour @MX_SS"))(exit))) (setq #C 0) (if #SS (repeat (sslength #SS) (setq #SSN (ssname #SS #C)) (@Macro #SSN) (setq #C (1+ #C)) ) ) ) Une macro de traitement dans le jeu de selection (defun @MX_SS ( #SSN / ) (print (@S_AE #SSN "ATTRIB" "L3" 1 nil)) (@S_AE #SSN "ATTRIB" "L3" 1 (strcat ":" (@S_AE #SSN "ATTRIB" "L3" 8 nil) ":" (@S_AE #SSN "ATTRIB" "L3" 1 nil) ) ) ) Et enfin on l'utilise (@X_SS #SS @MX_SS) Etc. Bref, sur un test comparatif , répétérif (repeat 500) sur une routine développé de la sorte et une autre développé en linéaire ,le temps gagné est divisé par 20 ;) (et je ne sais pas pourquoi !) ... :casstet: Voilà ! [Edité le 5/3/2007 par stephan35]

Bonjour à tous, Mon problème est le suivant: Je crée des fonctions: (defun @R1 ( $a / ) ... ) (defun @R2 ( $a / ) ... ) (defun @R3 ($a / ) ... ) Je créé une fonction principale dans laquelle je veux appeler une fonction secondaire en parametre variable : (defun @Princ ( @macro $a / ) (@macro $a) ) Si je tape : (@princ @R1 "po") je cherche à appliquer (@macro $a) = (@R1 $a) !!! :casstet: Est-ce possible ??? Merci !

J'aime les chats ! ;)

Bien-entendue , on peut toujours faire plus court, cependant ton exemple ne permet pas de choisir l'attribut dans lequel on va ecrire l'information ... :casstet: il va falloir écrire une routine de scrutation d'attribut .... :casstet: Etant donné, comme je l'avais expliqué, que je mettais mes applicatifs à jour, et ce, pour un gain de temps de traitement, et d'optimisation d'écriture (+ 3Mo dans 300 lsp), je proposais à speedy d'en profiter .... :D L'orientation objet permettrai de réutiliser ceux-ci sans réécriture ... Exemple : (@R1 &entget) te retourne simplement le cdr (assoc 1 , avec le test entget non nil (@X_SS #SS) Explore le jeu de selection #SS et execute la macro variable (@MX_SS #SSN) pour chasue entité #SSN Etc . A partir de conventions d'écriture , on peut facilement relire un developpement utilisant cette méthode .... essayer c'est l'adopter ! ;) A+

Salut, Brut de fonderie, voilà le code qui va remplacer tous mes devs (sur le principe) si tu es bon en lisp, tu ne devrais pas trop avoir de soucis ... :casstet: Mes conventions : & = Liste # = Nom entité ou chiffre $ = chaine ascii @xxx = fonction Contre toute logique, après moultes essais cette méthode est 20 fois plus rapide que la version linéraire, à tout hasard, si quelqu'un avait une explication ... ;) (defun c:ttb() ; Macro extrait valeur d'un attribut (defun @S_AE ( #SSN $T $E #t $valeur / &Be $Be0 R) (if (not #SSN)(progn (alert (strcat "@S_AE \nValeur nil pour #SSN"))(exit))) (if (not $T)(progn (alert (strcat "@S_AE \nValeur nil pour $R"))(exit))) (if (not $E)(progn (alert (strcat "@S_AE \nValeur nil pour $V"))(exit))) (if (not #t)(progn (alert (strcat "@S_AE \nValeur nil pour #t"))(exit))) (setq &Be (entget #SSN)) (setq $Be0 (@R0 &Be)) (while (and (/= $Be0 "SEQEND") (/= (entnext #SSN) nil)) (setq &Be (entget (setq #SSN (entnext #SSN)))) (setq $Be0 (@R0 &Be)) (if (= $Be0 $T) ;Attribut (if (= $E (@R2 &Be)) ; Si Etiquette ok (if (not $valeur) (progn (cond ((= #t 8)(setq R (@R8 &Be))) ((= #t 1)(setq R (@R1 &Be))) ((= #t 2)(setq R (@R2 &Be))) ) ) (progn (cond ((= #t 8)(setq R (@W8 &Be $valeur))) ((= #t 1)(setq R (@W1 &Be $valeur))) ((= #t 2)(setq R (@W2 &Be $valeur))) ) ) ) ) ) ) R ) ; Macro eXplore le jeu de selection (defun @X_SS (#SS / #C) (if (not #SS)(progn (alert (strcat "@X_SS \nValeur nil pour #SS"))(exit))) (if (not @MX_SS)(progn (alert (strcat "@X_SS \nMacro nil pour @MX_SS"))(exit))) (setq #C 0) (repeat (sslength #SS) (setq #SSN (ssname #SS #C)) (@MX_SS #SSN) (setq #C (1+ #C)) ) (setq @MX_SS nil) ) ;;; (defun @MX_SS () ;;; (print #SSN) ;;; ) ; Macro selection Type Valeur (defun @SS_@R0_@R2 (@R0 @R2 / ) (if (and @R0 @R2) (setq #SS (ssget "X" (list(cons 0 @R0 )(cons 2 @R2)))) (alert (strcat "@SS_@R0_@R2 \nValeur nil pour &entget")) ) #SS ) (defun @R-1 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R-1 \nValeur nil pour &entget"))(exit))) (cdr(assoc -1 &entget)) ) (defun @R330 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R330 \nValeur nil pour &entget"))(exit))) (cdr(assoc 330 &entget)) ) (defun @R300 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R300 \nValeur nil pour &entget"))(exit))) (cdr(assoc 300 &entget)) ) (defun @R2 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R2 \nValeur nil pour &entget"))(exit))) (cdr(assoc 2 &entget)) ) (defun @R8 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R8 \nValeur nil pour &entget"))(exit))) (cdr(assoc 8 &entget)) ) (defun @R1 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R1 \nValeur nil pour &entget"))(exit))) (cdr(assoc 1 &entget)) ) (defun @R0 ( &entget / tmp ) (if (not &entget)(progn (alert (strcat "@R0 \nValeur nil pour &entget"))(exit))) (cdr(assoc 0 &entget)) ) (defun @W1 ( &entget $Valeur / tmp ) (if (not &entget)(progn (alert (strcat "@W1 \nValeur nil pour &entget"))(exit))) (if (not $Valeur)(progn (alert (strcat "@W1 \nValeur nil pour $Valeur"))(exit))) (setq &entget (subst (cons '1 $Valeur) (assoc 1 &entget) &entget)) (entmod &entget) (entupd (@R-1 &entget));Pour faire une mise a jour ponctuelle ) (setq $nom_bloc (@R2 (setq &e (entget (setq #e (car(entsel))))))) ; Selectionne dans le document tous les blocs portant ce nom (@SS_@R0_@R2 (@R0 &e)(@R2 &e)) ; Explore le jeu de selection mettre à 500 pour comparer mes 2 dev (repeat 1 (defun @MX_SS ( #SSN / ) (print (@S_AE #SSN "ATTRIB" "L3" 1 nil)) (@S_AE #SSN "ATTRIB" "L3" 1 (strcat ":" (@S_AE #SSN "ATTRIB" "L3" 8 nil) ":" (@S_AE #SSN "ATTRIB" "L3" 1 nil) ) ) ; Version 2 ;(@S_AE #SSN "ATTRIB" "L3" 1 "ooooooooooo") ;Pour faire une mise a jour globale ;(entupd #SSN) ) (@X_SS #SS) ) ) nota: n'esite pas à poster des commentaires ... ;) bon courrage :P

Merci gile ! a+