Aller au contenu

Accroche objet


amarand

Messages recommandés

coucou

 

ce que veux dire Fraid

c'est qu'une routine lancée sur ta machine peut initialiser l'accrochage à aucun

c'est même souvent conseillé de le faire en lisp.

 

et encore peut-être que cette dernière se termine mal

ou bien ne remet pas l'accrochage comme trouvé au lancement.

 

est-ce que tu utilises des routines au moins ?

 

sinon, je ne pense pas que tu l'ignores mais, pour mémoire,

les accrochages ne sont pas enregistrés dans le fichier dessin

c'est la session AutoCAD qui est concernée.

 

amicalement

Lien vers le commentaire
Partager sur d’autres sites

Bonjour,

 

Tape _appload

 

puis clic sur Contenu...

 

Si tu as un lisp qui ce charge au démarrage il sera affiché

 

Tu peux le supprimé en perdant peut etre quelques fonctionnalités

 

si tu en a plusieurs cela va etre plus difficile de t'aider a moins de les supprimé tous ou un par un

 

et peut etre que la touche F3 peut résoudre ton probléme

 

 

 

Lien vers le commentaire
Partager sur d’autres sites

Il n'y a aucune raison pour que cela se fasse tout seul.

 

Essaye de repérer a quel moment cela ce produit.

 

Peut etre utilise tu un outil des expressTools que tu quitte un peu violement? (Echap)

Peu probable puisque ils ont une gestion des erreurs qui fonctionne....

 

vois pah :casstet:

Lien vers le commentaire
Partager sur d’autres sites

Ça me rappelle un code de Serge Camiré qui surveillait en temps réel l'état des variables.

Dès qu'une commande ou un lisp modifiait une variable, on en était informé, pratique pour identifier la cause de ce changement d'état de variable.

 

J'ai bien fais une recherche sur le site, mais pas trouvé, à moins qu'il l'ait publié ailleurs.

Si quelqu'un d'autre se souvient...

Choisissez un travail que vous aimez et vous n'aurez pas à travailler un seul jour de votre vie. - Confucius

Lien vers le commentaire
Partager sur d’autres sites

Un petit truc vite fait.

La commande ISVON active des réacteurs qui noteront dans la ligne de commande tout changement de variable système pendant l'exécution d'une commande ou d'un LISP.

La commande ISVOFF désactive ces réacteurs.

 

EDIT: optimisation et ajout de commentaires

;;---------------------------------------------------------;;
;;                        COMMANDES                        ;;
;;---------------------------------------------------------;;

;; ISVON
;; Active les réacteurs pour l'inpection des variables
;; Tous évènements liés à l'exécution de commandes ou de LISP sont gérés
(defun c:ISVON ()
 (c:isvoff)
 (vlr-command-reactor
   nil
   '((:vlr-CommandWillStart . GC:ISVSTART)
     (:vlr-commandCancelled . GC:ISVEND)
     (:vlr-commandFailed . GC:ISVEND)
     (:vlr-commandEnded . GC:ISVEND)
    )
 )
 (vlr-lisp-reactor
   nil
   '((:vlr-LispWillStart . GC:ISVSTART)
     (:vlr-LispCancelled . GC:ISVEND)
     (:vlr-LispEnded . GC:ISVEND)
    )
 )
)

;; ISVOFF
;; Désactive les réacteurs pour l'inpection des variables
(defun c:ISVOFF	()
 (gc:RemoveRea :VLR-Command-Reactor '(:VLR-commandEnded . GC:ISVEND))
 (gc:RemoveRea :VLR-Lisp-Reactor '(:VLR-lispEnded . GC:ISVEND))
)


;;---------------------------------------------------------;;
;;                         ROUTINE                         ;;
;;---------------------------------------------------------;;

;; gc:RemoveRea
;; Supprime les réacteurs en fonction d'un type d'un callback
(defun gc:RemoveRea (reaType callback)
 (foreach r (cdar (vlr-reactors reaType))
   (if	(vl-position callback (vlr-reactions r))
     (vlr-remove r)
   )
 )
)


;;---------------------------------------------------------;;
;;                        CALLBACKS                        ;;
;;---------------------------------------------------------;;

;; gc:isvStart
;; Une commande ou un LISP va démarrer
;; => ajout d'un réacteur pour l'évènement SysVarChanged
(defun gc:isvStart (rea lst)
 (if (/= "(C:ISVOFF)" (car lst))
   (vlr-SysVar-Reactor
     nil
     '((:VLR-sysVarWillChange . GC:GETOLDVALUE)
(:VLR-sysVarChanged . GC:PRINCSYSVAR)
      )
   )
 )
)

;; gc:isvEnd
;; Une commande ou un LISP s'achève, est annulé ou échoue
;; => suppression du réacteur variable système
(defun gc:isvEnd (rea lst)
 (gc:RemoveRea :VLR-SysVar-Reactor '(:VLR-sysVarChanged . GC:PRINCSYSVAR))
)

;; gc:GetOldValue
;; Une variable système va changer
;; => récupération de la valeur initiale
(defun gc:GetOldValue (rea lst)
 (vlr-data-set rea (cons (cons (car lst) (getvar (car lst))) (vlr-data rea)))
)

;; gc:PrincSysVar
;; Une variable système a changé
;; => message sur la ligne de commande
(defun gc:PrincSysVar (rea lst / data)
 (setq data (vlr-data rea))
 (princ (strcat "\n"
	 (car lst)
	 " : "
	 (vl-princ-to-string (cdr (assoc (car lst) data)))
	 " -> "
	 (vl-princ-to-string (getvar (car lst)))
 )
 )
 (vlr-data-set rea (vl-remove (assoc (car lst) data) data))
)

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites

Salut,

 

Comme ça semblait plaire, j'ai ajouté quelques commentaires et un peu amélioré les messages.

 

Le code ci dessus fait la même chose que celui de Serge dans le lien de bonuscad à ceci près qu'on peut activer ou désactiver les réacteurs (ces réacteurs peuvent sensiblement ralentir l'exécution de LISP).

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites

Salut

 

Que veux dire "CALLBACKS " (et son contenu,...) Gilles STP ?

 

C'est un mot anglais que je trouve plus explicite que ce qui pourrait être sa traduction en français : rétro-appel.

 

Ce qu'on appelle 'réacteur' en LISP, c'est le lancement de d'une fonction de 'rétro-appel' (callback) en réaction au déclenchement d'un évènement.

 

Dans le code ci-dessus, par exemple, on définit un réacteur qui réagira au déclenchement de l'évènement :VLR-CommandWillStart (évènement déclenché juste avant l'exécution de chaque commande) en lançant la fonction de rétro-action GC:ISVSTART.

Ce même réacteur réagira aux évènements :VLR-commandCancelled, :VLR-commandFailed et :VLR-commandEnded (déclenchés respectivement quand : une commande a été annulée, une commande a échoué, une commande s'est terminée) en lançant cette fois la fonction de rétro-appel GC:ISVEND.

Gilles Chanteau - gileCAD - GitHub
Développements sur mesure pour AutoCAD

Lien vers le commentaire
Partager sur d’autres sites

Créer un compte ou se connecter pour commenter

Vous devez être membre afin de pouvoir déposer un commentaire

Créer un compte

Créez un compte sur notre communauté. C’est facile !

Créer un nouveau compte

Se connecter

Vous avez déjà un compte ? Connectez-vous ici.

Connectez-vous maintenant
×
×
  • Créer...

Information importante

Nous avons placé des cookies sur votre appareil pour aider à améliorer ce site. Vous pouvez choisir d’ajuster vos paramètres de cookie, sinon nous supposerons que vous êtes d’accord pour continuer. Politique de confidentialité