vlr-reaction-set

[Patrick_35]

Bonjour

J'ai vu que j'avais une erreur d'automation dans un réacteur objet car je modifiais l'objet en question dans la routine du réacteur appelé. J'ai trouvé qu'avec la fonction vlr-reaction-set, ça me résolvait le problème mais j'avoue que je ne comprends pas tout. Si quelqu’un pouvait m’expliquer dans le détail…

 

@+

[Tramber]

Demande à Patrick_35 (rires).

 

Vu que Serge ne fait plus de détour par ici depuis un an !

 

[winfield]

Présentation du "Programme Patrick_35"

imaginé par Patrick_35

codé par Patrick_35

testé par Patrick_35

débogué par Patrick_35

incompris par Patrick_35

aidé par ...

 

Petit Scarabé pourra quitter le temple quand il aura trouvé :D

[Patrick_35]

Ouin, c'est juste une bouteille jetée à la mer

J'ai l'impression de rassembler à un robinson crusoé sur son ile et qui n'a même pas son vendredi

 

@+

[bonuscad]

Courage Patrick, ;)

 

Moi aussi j'ai eu des bouteilles à la mer, et quand ces bouteilles ont pu revenir, et bien j'ai rien compris. :casstet:

 

Les antipodes, c'est pas si mal, mais il faut assumer :P

 

Bonne chances quand même!

[BTO]

Bonjour,

 

Dans quelle proportion l'objet est-il modifié ? L'objet modifié doit rester compatible avec le reactor initiale (plutôt la fonction callback initiale), est-ce le cas ?

 

Comment as-tu procédé ? en réaffectant la même fonction callback ? ( Eventuellement similaire sous un autre nom ) normalement ça ne devrait pas être le cas.

 

Bruno Toniutti.

[Patrick_35]

Bonjour BTO et merci de ta réponse

Je lie un ensemble d'objet (dans ce cas des attributs) en vlr-reactors-object et que je conserve aussi en vlax-ldata (et pour faire au plus simple, je ne fais dans mes tests, qu'une seul chaîne d'"attributs)

Je modifie un attribut avec attedit (donc que du texte en modif), mon vlr-reactor-object réagit et me renvoi à ma routine et ce que je constate, c'est que cette routine est appelée plusieurs fois ???

Si je décortique un peu plus en profondeur le réacteur fait un appel à ma routine avec comme argument l'objet édité, le réacteur (que l’on peut encore décortiquer en vlr-data et vlr-owners). Je vérifie mon vlr-owners avec mon vlax-ldata et je constate que ça correspond parfaitement (sauf que la liste est inversée, mais bon…)

Je ne comprends pas quand je modifie dans ma routine le texte d’un attribut faisant partie du vlr-reactor-object , je me retrouve avec une erreur automation : Aucune description....

Je peux l’inhiber avec un vl-catch-all-apply, mais ça ne me satisfait qu’à moitié

En espérant être clair

 

@+

[BTO]

Patrick,

maintenant que tu le précises, cela est particulier puisque ça porte sur un reactor qui réagit au niveau de sous-entités, je n'ai jamais programmer cela.

Par contre voici, une réponse de Luis Esquivel :

http://discussion.autodesk.com/thread.jspa?messageID=4781038

Reply From: Luis Esquivel

Date: Mar/24/05 - 15:33 (GMT)

 

Peut être que cela te permettra de trouver une solution à ton code.

 

Bruno Toniutti, ce soir en vacances.

 

[Edité le 19/5/2006 par BTO]

[Patrick_35]

Merci beaucoup BTO

J'avais bien pensé au vlr-commandended de l'editor-reactor mais passant par la fin de la commande "ATTEDIT" et non en regardant la liste modifiée, ce qui est loin d'être idiot et en plus j'utilise :vlr-modified et non le :vlr-subObjModified vu que je n'utilisais pas l'editor-reactor

Mais cela me pose une question. Si on modifie un attribut qui appartient à un object-reactor par le biais d'un lisp ou en vba, le réacteur va réagir ?

Et tant que j'y suis. J'ai constaté quand utilisant le _undo avec des réacteurs, Autocad réagissait parfois mal.

 

@+

 

ps : Bonne vacances

[GEGEMATIC]

La question est ancienne, je pense que tu as fini par y répondre, mais pour parler de mon expérience à ce sujet, voilà ma petite contrib

news://news.planetar.net:119/eivu7t$bp6@planetar.CADFRANCE

Dans ce post, je présentais rectangle je reste, un programme idiot, qui avait le mérite de montrer tous les pb de réaction à une modification.

 

Typiquement, la solution que j'ai utilisée est celle du tutorial Autodesk:

 

Lorsque l'evenenemnt Begin_command intervient, je filtre les commandes succeptibles de modifier une entité, et de quelle manière

 

lorsqu'arrive le entity_modified, j'ajoute simplement le nom de l'entité à la liste des entités modifiées

 

Lorque j'ai le command_ended, je lance ma fonction de réaction, en ut_ilisant une variable qui prévient l' entity_modified qu'il faut ignorer l'évenement, car il provient d'une commande de réaction.

 

Pour la gestion des réacteur, et leur effacement, j'ai rennoncé à supprimer un réacteur lorsque l'on efface une entité : la gestion des _undo, _redo faisait que ça ne marchait pas bien.

 

Il vaut mieux supprimer les réacteurs orphelins à l'ouverture du dessin.

 

[Patrick_35]

Merci, sauf que le lien ne fonctionne pas.

J'ai reussi à controuner le problème, mais la question est toujours d'actualité

 

@+

[GEGEMATIC]

Le lien est vers un fil de discussion sur planetar: je n'ai pas fait attention au fait qu'ici on est sur un forum php, et que la balise html n'est pas copiée

je te remet le liens :

news://news.planetar.net:119/eivu7t$bp6@planetar.CADFRANCE

 

sinon le post est du 09/11/2006 sur planetar

 

Rectangle_je_reste est open source, rectrue est en VLX et distribué avec PowerClic

 

Je te reposte le message d'origine :

 

Voilà une version simplifiée de Rectrue, que j'ai posté précédemment.

Si Rectrue permet d'avoir réellement de vrais rectangle, Rectangle je reste ne le permet pas.

C'est volontairement que j'ai simplifié le code, pour qu'il soit plus pédagogique au niveau des réacteurs que

des fonctionnalités.

Pour qu'il soit sans mystere, il peut fonctionner indépendemment de PowerClic, j'ai ajouté les routines utilisées.

Ci dessous le texte d'en tête de ce programme :

 

Rectangle_je_reste: une approche simplifiée d'un réacteur persistant sur un objet,

en vue de le modifier lui même

© G-EAUX 2006, Gérald Lemoine : http://www.g-eaux.com

derniere modification le: 11/8/06

s'appuie également sur le code exemple Autodesk : gpathreact du tutorial visual lisp

 

But de la manoeuvre :

le tutorial gpath est truffé de faux amis, confondant réaction au sens de réacteur,

et réaction classique au changement de chemin:

de plus le programme est volumineux

apprendre les réacteurs persistants dans ces conditions, c'est de la folie pure.

Mais seuls Visualisp et arx permettent l'usage de réacteurs persistants dans de bonne condition.

 

Le programme Rectrue permet lui de faire de vrais rectangles, qui le restent quoi qu'il arrive.

mais pour donner un exemple des réacteurs, ça devenait trop compliqué

j'ai donc fait une version simplifiée pour illustrer le mécanisme:

dans cette version, la réaction est un peu idiote, le rectangle grossit toujours, et reste parrallèle au SCG quoi qu'il arrive

 

Le principe :

je veux régir lorqu'on modifie un rectangle, avec les grip, pour qu'il reprenne une forme de rectangle:

je créée deux réacteur persitants :

:vlr-modified

:vlr-erased

(erased pour nettoyer le récateur lors de l'effacement: c'est plus propre, mais ça n'a rien d'obligatoire)

 

Mais on ne peut pas réagir sur une entité notifiée directement sur l'evenement "modified"

donc il faut le faire lors de l'evennement "endcommand"

mais on ne peut pas avoir le même traitement endcommand pour chaque commande:

par exemple, une commande _qsave n'a aucun rapport avec nos rectangles:

donc il faut également agir au niveau de commandwillstart, pour savoir quelle commande va être exécutée,

et ce qu'il conviendra de faire.

Malheureusement, certaines commandes comme copy, peuvent créer plusieurs nouvelle entités, et être intérompues par un "escape"

dans ce cas, pas de commandEnded, dons il faut agire au niveau de commandCancelled

c'est pourquoi, au chargement de ce lisp, des réacteurs sont ajoutés à :

 

:vlr-commandWillStart

:vlr-commandEnded

:vlr-commandCancelled

 

Le mode opératoire est en gros le suivant:

au niveau de :vlr-commandWillStart, on remet à nil les variables globales, puis on leur assigne des valeurs selon le type de commande

au niveau de :vlr-modified, on crée un liste des entités modifiées sur lesquelles intervenir

 

puis on récupère nos entités variables, etc, au niveau de :vlr-commandEnded :vlr-commandCancelled, et on traite les entités à traiter.

 

Avec ce canevas, il y a a peu près tout ce qu'il faut pour réagir convenablement à différentes situations:

copie, mirroir, effacement, d'entité ayant des réacteurs persistants

 

 

 

utilise les variables globales suivantes :

*commandReactor*

*reactorsToRemove*

*liste-des-rectangles-changes*

*change-area-reaction*

*reactorsToCopy*

*realentlast*

 

**************************************************************************

 

 

 

--

 

http://www.g-eaux.com

;;**************************************************************************
;§/dessin/fonction principale: Crée un vrai rectangle /none
;;
(defun c:rectangle_je_reste (  / elast PolylineName)
 (setq elast (entlast))
 (command "rectang" pause pause)
 (setq PolylineName (entlast))
 (if (/= PolylineName elast)
   (progn
     (RJR:associe_reacteur PolylineName)
     (vlax-ldata-put PolylineName "RECTANGLE" "JE_RESTE")
   )
 )
)

;;**************************************************************************
;§/dessin/réagit à la modification d'un rectangle:  le recrée / VlaObjectUnderReaction
;;
(defun recree_le_rectangle (reactor	  /		oldarea
		    reactordata	  newarea
		    VlaObjectUnderReaction	minpoint
		    maxpoint	  bbox		4pt
		    4ptflat	  lcoords
		   )

 (setq	reactorData
 (vlr-data reactor)
 )

 (setq oldarea (car reactordata))

 (setq VlaObjectUnderReaction (car (vlr-owners reactor)))
 (setq *callback-modification* VlaObjectUnderReaction)
 (if VlaObjectUnderReaction
   (progn
     (vla-GetBoundingBox
VlaObjectUnderReaction
'minpoint
'maxpoint
     )
     (if minpoint
(setq bbox (list (vlax-safearray->list minpoint)
		 (vlax-safearray->list maxpoint)
	   )
)
nil
     )
     (setq 4pt (PW_PRECT (car bbox) (cadr bbox)))
     (setq lcoords (vlax-make-safearray vlax-vbDouble '(0 . 7)))
     ;;(vlax-safearray-get-dim lcoords)
     (setq 4ptflat (pw_flatten_list 4pt))
     (vlax-safearray-fill lcoords 4ptflat)
     (vla-put-coordinates VlaObjectUnderReaction lcoords)
     (setq newarea (vla-get-area VlaObjectUnderReaction))

     ;;voici un exemple d'utilisation de données passées à votre fonction par le réacteur:
     ;;ce n'est pas très interressant , mais c'est un simple exemple...
     (setq newarea (vla-get-area VlaObjectUnderReaction))
     (if (> newarea oldarea)
(prompt "\nRectangle grossit")
(prompt "\nRectangle réduit")
     )

     ;;met à jour le récateur, et ses données associées
     (vlr-data-set reactor (list newarea))

   )
   (vlr-remove reactor)
 )
 (setq *callback-modification* nil)
)


;;**************************************************************************
;§/dessin/réagit à la modification d'un rectangle: réécrit sa nouvelle aire/ ObjectReactor
;;
(defun renseigne_le_rectangle (ObjectReactor / reactorData VlaObjectUnderReaction newarea )
 (setq	reactorData
 (vlr-data ObjectReactor)
 )
 (setq VlaObjectUnderReaction (car (vlr-owners ObjectReactor)))
 (setq *callback-modification* VlaObjectUnderReaction)
 (setq newarea (vla-get-area VlaObjectUnderReaction))

 ;;met à jour le réacteur, et ses données associées
 (vlr-data-set ObjectReactor (list newarea))
 (setq *callback-modification* nil)
)

;;**************************************************************************
;§/rectrue/associe réacteur et reactordata au rectangle /PolylineName
;
(defun RJR:associe_reacteur ( PolylineName /  PolyObj Polyarea  PolyCoords )
     (setq PolyObj (vlax-ename->vla-object PolylineName))
     (setq Polyarea (vla-get-area PolyObj))
     (vlr-pers
(vlr-object-reactor
  ;; The first argument for vlr-object-reactor is
  ;; the "Owner’s List" argument. This is where to
  ;; place the object to be associated with the
  ;; reactor. In this case, it is the vlaObject
  ;; stored in PolylineName.
  (list PolyObj)
  ;; The second argument contains the data that you need for your traitement
  (list Polyarea)
  ;; The third argument is the list of specific reactor
  ;; types that we are interested in using
  '
   (
    ;; reactor that is called upon modification of the object
    (:vlr-modified . RJR:rectang_changed)
    (:vlr-erased . RJR:rectang_erased)
   )
) ;_ end of vlr-object-reactor
     )

)
;;***************************************************************************************************************************

(defun RJR:rectang_changed (VlaObjectUnderReaction reactor arg-list)
 (if (= *callback-modification* VlaObjectUnderReaction)
   (prompt "\nCallBack : Ne réagit pas à la modification !")
   (progn
     (prompt "\nUtilisateur : réagit à la modification !")
     (setq *liste-des-rectangles-changes*
     (cons
       reactor
       *liste-des-rectangles-changes*
     )
     )
     
   )
 )
)


 
;;;--------------------------------------------------------------------;
;;;     Function: RJR:command_will_start                                ;
;;;--------------------------------------------------------------------;
;;;  Description: This is a reactor to any command starting            ;
;;;--------------------------------------------------------------------;
;;;  This is the function where we figure out what will be happening   ;
;;;  to the garden path.  The various reactor globals are set to       ;
;;;  flag the changes that we expect to be made, so that subsequent    ;
;;;  reactor events will perform the correct actions.                  ;
;;;--------------------------------------------------------------------;
(defun RJR:command_will_start
      (reactor command-list / currentCommandName)
 ;; Reset all four reactor globals to nil
 (setq	*reactorsToRemove*
 nil
*liste-des-rectangles-changes*
 nil
*change-area-reaction*
 nil
*reactorsToCopy*
 nil
 )
 (cond	((member (setq currentCommandName (car command-list))
	 '("SCALE" "GRIP_SCALE"	)
 )
 (setq *change-area-reaction* T)
 (princ "\nNOTE: The ")
 (princ currentCommandName)
 (princ "will not modify the rectang proportions")
)
((member currentCommandName
	 '("MIRROR" "GRIP_MIRROR" "COPY" "GRIP_COPY" "PASTECLIP" "U" "UNDO")
 )
 (setq *reactorsToCopy* T)
 (setq *realentlast* (pw_real_entlast))
)
 )
 (princ)

 (princ "RJR:command_will_start ")
 (princ)
)

;;;--------------------------------------------------------------------;
;;;     Function: RJR:command_ended                                     ;
;;;--------------------------------------------------------------------;
;;;  Description: This reactor function is called at the end of any    ;
;;;               command.                                             ;
;;;--------------------------------------------------------------------;
;;;  This is where the majority of work is done.  Once the command     ;
;;;  that the user is performing has ended, we can get to work.  (We   ;
;;;  cannot modify entities while they are being modified by AutoCAD   ;
;;;  itself, so we have to wait until we get a notification that the   ;
;;;  command in progress is complete, and we can have access to the    ;
;;;  entities.)                                                        ;
;;;--------------------------------------------------------------------;
(defun RJR:command_ended	(reactor	  command-list
		 /		  objReactor
		 reactorToChange  reactorData
		 coordinateValues currentPoints
		 newReactorData	  newPts
		 tileList
		 )

 (cond
   ;; CONDITION 1 - POLYLINE ERASED (Erase command)
   ;; If one or more polyline borders are being erased (indicated
   ;; by the presence of *reactorsToRemove*), erase the tiles within
   ;; the border, then remove the reactor.
   (*reactorsToRemove*
    (foreach objReactor *reactorsToRemove*
      ;(gp:erase-tiles objReactor)
      (prompt "\nObjet effacé : supprime le réacteur")
      (vlr-remove objReactor)
     )
     (setq *reactorsToRemove* nil)
    )

   ;; CONDITION 3 - GRIP_STRETCH 
   ;; In this case, we are keeping the associativity of the tiles to
   ;; the path, but the path and the tiles will need to be recalculated
   ;; and redrawn.  A GRIP_STRETCH can only be performed on a single
   ;; POLYLINE at a time.
   ((and *liste-des-rectangles-changes* (not *change-area-reaction*))
    (prompt "\nRecrée les rectangles")
    (foreach reactor *liste-des-rectangles-changes*
      (recree_le_rectangle reactor)
    )
   )
   ;;ne modifie pas la géométrie, mais rensiegne le réacteur sur la nouvelle
   (*change-area-reaction*
    (prompt "\nRe-renseigne les rectangles")
    (foreach reactor *liste-des-rectangles-changes*
      (renseigne_le_rectangle reactor)
    )
   )
   ;;ajoute le réacteur à l'objet
   (*reactorsToCopy*
    (prompt "\nAssocie le réacteur aux rectangles")     
    (setq sel (pw_selafter *realentlast*))
    (setq lsel (pw_listsel sel))
    (foreach l lsel
      (if (= "JE_RESTE" (vlax-ldata-get l "RECTANGLE" ))
    (RJR:associe_reacteur l)
      )
    )
   )
   
  )
 (princ)
 )
;;;--------------------------------------------------------------------;
;§/rectrue/recation quand une commande genre copy, a été interrompue par escape /PolylineName

(defun RJR:command_cancelled (reactor command-list / objReactor)
 ;;ajoute le réacteur à l'objet
 (if *reactorsToCopy*
   (progn
     (prompt "\nAssocie le réacteur aux rectangles")
     (setq sel (pw_selafter *realentlast*))
     (setq lsel (pw_listsel sel))
     (foreach l lsel
(if (= "JE_RESTE" (vlax-ldata-get l "RECTANGLE"))
  (RJR:associe_reacteur l)
)
     )
   )
 )
)

;;;--------------------------------------------------------------------;
;;;     Function: RJR:rectang_erased                                    ;
;;;--------------------------------------------------------------------;
;;;  Description: This reactor function is triggered if the path       ;
;;;               outline is being erased.  In this case, store the    ;
;;;               reactor to the global list *reactorsToRemove*        ;
;;;--------------------------------------------------------------------;
(defun RJR:rectang_erased (outlinePoly reactor parameterList)
 (setq	*reactorsToRemove*
 (cons reactor *reactorsToRemove*)
 )
)


; *****************************************************************************
; Librairie utilisée
; *****************************************************************************
;;§/listes/ ecrase une liste de liste a une liste d'élements/lst
;(pw_flatten_list '((1 2)(3 4) 4.5 (5 6))) -> (1 2 3 4 4.5 5 6)
;
(defun pw_flatten_list (lst / l deb)
 (setq deb (car lst))
 (setq lst (cdr lst))
 (if (not (listp deb))
   (setq deb (list deb))
 )
 (foreach l lst
   (if (listp l)
     (setq deb (append deb l ))
     (setq deb (append deb (list l )))
   )
 )
 deb
)
;******************************************************************************
;;§/dessin/ crée une liste de 4 sommet d'un rectange à partir de sa diagonale/p1 p2
;; sert surtout pour textbox

(defun pw_prect ( p1 p2 / x1 x2 y1 y2 p3 p4)
(setq x1 (car p1) x2 (car p2) )
(setq y1 (cadr p1) y2 (cadr p2))
(setq p3 (list x2 y1 ) p4 (list x1 y2 ))
(mapcar 'pw_pt_2d (list p1 p3 p2 p4))
)

;***************************************************************************
;§/divers/Dilivre un point 2D a partir d'une liste point/pt
(Defun pw_pt_2d (pt)
 (list (car pt) (cadr pt))
)
;****************************************************************************
;§/SELECTIONS/ cree une liste d'entité à partir d'un jeu de selection d'autocad/js
;
(defun pw_LISTSEL (js / rs )
 (cond ((not (equal (type js) 'PICKSET))
          (prompt "\nNot à selection set !"))
       (T (setq rs (pw_lsel2 js)))
 )
rs
)
; ** pw_lsel 2sous programme de listsel
(defun pw_LSEL2 (j / e i r)
(setq i 0)
 (while (setq e (ssname j i))
   (setq r (cons e r))
   (setq i (+ 1 i))     
 )
 (reverse r)
)
;;*************************************************************************
;;§/SELECTIONS/  crée un jeu de selection des entités suivant un element/ent
;;fonction ralentie par la 2006, qui n'axepte pas les sequend
;;donc necessité de faire un entget pour chaque entité
;;
(defun pw_selafter ( ent / sel etyp )
;;si le dessin etait vierge, ent = nil
(if ent
 (setq sel (ssadd))
 (setq sel (ssadd (setq ent (entnext))))
)
(while (setq ent (entnext ent))
 (setq etyp (cdr (assoc 0  (entget ent))))
 (if (not (member etyp '("ATTRIB" "SEQEND")))
  (setq sel (ssadd ent sel))
 )
)
sel
)


;;*************************************************************************
;;§/SELECTIONS/retourne le vrai dernier element, dans le cas ou entlast retourne un element complexe/none
;;rajouté un test sur SEQEND : en effet, si 3dpolyligne = entlast, le entnext du sequend retourne au début
;; du dessin !

(defun pw_real_entlast ( / ent tmp ok eg tp)
(setq ok T)
(if (setq ent (entlast))
 (while (and (setq tmp (entnext ent)) ok)
  (setq eg (entget ent))
  (setq tp (cdr (assoc 0 eg)))
  (if (= "SEQEND" tp)
    (setq ok nil)
  )
  (setq ent tmp)
 )
)
ent
)

;;**************************************************************************
;; AT LOAD - Au chargement
;;**************************************************************************

(if pw-ver
 (progn
   (if	(not (wcmatch pw-ver "7*"))
     (prompt
"\nMettez à jour powerClic vers une version 7 : c'est recommandé"
     )
   )
  )
  (prompt "\nNe pas utiliser PowerClic avec Autocad, c'est de l'inconscience\nenfin moi, ce que j'en dis ...")
)
;;initialisation des différents réacteurs au niveau du document
(if (not *commandReactor*)
 (setq	*commandReactor*
 (VLR-Command-Reactor
   nil				; No data is associated with the command reactor
   '((:vlr-commandWillStart . RJR:command_will_start)
     (:vlr-commandEnded . RJR:command_ended)
     (:vlr-commandCancelled . RJR:command_cancelled)

    )
 ) ;_ end of vlr-command-reactor
 )
)

(Prompt
 "\nVersion pédagogique simplifiée de Rectrue : Tapez la commande \"rectangle_je_reste\" pour dessiner un rectangle"
)
(Prompt
 "\nPuis essayez les commandes copier, rotation, echelle, mirroir et déplacer"
)
(Prompt
 "\nensuite modifiez vos rectangles avec des grips, ou la comande etirer :"
)
(Prompt
 "\nVotre rectangle reste un rectangle, mais dans cette version, il ne peut que grandir"
)
(princ)

[Patrick_35]

Il me reste à prendre un verre d'eau, un peu d'aspro et à regarder de plus près ton lisp.

Merci beaucoup.

 

@+

[GEGEMATIC]

En utilisant la version "commerciale" de rectangle je reste, c'est à dire "rectrue", je me suis aperçu d'un bug :

il existe une famille de commande qui peuvent "détruire" la rectanglitude (c'est dans l'air ...)

les commande BREAK,TRIM, FILLET,CHAMFER

Pire, BREAK,TRIM peuvent créer de nouvelle entité qui conservent l'xdata de marquage de "rectanglitude" alors qu'elle n'en sont plus.

Il convient donc d'ajouter ce groupe de commande dans l'evenement begincommand, et de leur attribuer une gestion spécifique.