event palette

sbosarl · le 17 octobre 2017

Bonjour,

Je va dire « Au secours sur les évents palette «

En C# avec palette défini en WPF , j’ai repris l exemple de gile palette avec MVVM

L’idée est de groupé mes variable lisp sur une palette et de dialoguer dans les deux sens ,

Sens palette vers lisp :aucun problème je force la valeur du setq

Sens lisp vers palette : Cela fonction bien sur le dessin initiale du lancement de la cde palette C#

MAIS lors de l’ouverture d’un autre dessin aucun effet

Comment faire pour avoir un event LispEnded sur chaque dessin comme les Layers

extrait code gile

		public DataItemCollection Layers => AcAp.UIBindings.Collections.Layers;
	//  .....
		public PaletteTabViewModel()
   	{   TextRadius = "10";
  			Layer = Layers.CurrentItem;
       	Layers.CollectionChanged += (s, e) => Layer = Layers.CurrentItem;
}

extrait de mon code

		public DataItemCollection Layers => AcAp.UIBindings.Collections.Layers;
   	public Document Doc => AcAp.DocumentManager.MdiActiveDocument;
		public PaletteTabViewModel()
   	{  	
TextRadius = "10";
       	Layer = Layers.CurrentItem;
       	Layers.CollectionChanged += (s, e) => Layer = Layers.CurrentItem;
       	Doc.LispEnded += (s,e)   => EventFinLisp();
}

(gile) · le 19 octobre 2017

Salut,

C'est quoi tes "variables LISP" ?

Sous quelle forme sont-elle exposées au code .NET ?

Montre ton code pour modifier ces variable depuis la palette ou vers la palette (le code que tu montres est celui de l'exemple et de la gestion des calques qui n'a rien à voir avec ce que tu demandes).

Si tu veux une mise à jour à chaque changement de dessin, tu peux utiliser l'évènement DocumentManager.DocumentActivated.

En général, pour utiliser le Binding avec WPF on expose des propriétés dans une classe qui implémente INotitfyPropertyChanged et/ou on utilise des collection de type ObservableCollection (comme UIBindings.Collections).

sbosarl · le 20 octobre 2017

salut , je regarde ce weekend pour te passé les codes, un peu charrette aujourd’hui hui

sbosarl · le 23 octobre 2017

Salut,

Point important je pense, avoir eu les yeux plus gros que le ventre ,

je vais regarder du cote de tes liens

Petite info métier : je suis dessinateur dans une société de plomberie-chauffage et ventilation .

Sur l’ensemble de mes lisp j’ai une dizaine de variable numérique qui ne sont jamais remis à 0 (sauf changement dessins)

exemple « epais » = largeur de ma gaine de ventilation en cm. 12.5 pour taille 125

Le code c’est un code non fini et mal structuré , je le transmets dans l’état (combobox diamVMC1 et variable epais)

Et merci

Mon lien

sbosarl · le 24 octobre 2017

salut ,

j’ai peu être trouvée mais sa me semble bizarre , j'ai donc un évent imbriquer

voir ligne //ajout *

 
public PaletteTabViewModel()
   	{ TextRadius = "10";
       	Layer = Layers.CurrentItem;
       	Layers.CollectionChanged += (s, e) => Layer = Layers.CurrentItem;
//ajout *
       	AcAp.DocumentManager.DocumentActivated += new DocumentCollectionEventHandler(Docactive);
//fin ajout *
//idem ajout pour 1dessin
		Doc.LispEnded += (s, e) => EventFinLisp();
   	}
//ajout *
   	public void Docactive(object senderObj,
	DocumentCollectionEventArgs Evetdoc)
   	{                	Doc.LispEnded += (s, e) => EventFinLisp(); }
//fin ajout *
    	/// <summary>
   	/// prise en compte unite et valeur 
   	/// </summary>
   	public void EventFinLisp()
   	{
       	ECoefUnits eCoefUnits = new ECoefUnits();
       	double ValueGetLsp = Convert.ToDouble(value_lsp(GetLispSym("epais")));
       	TextDiam = (ValueGetLsp * eCoefUnits.CoefUnits).ToString();
       	int delTa1 = ListDiam.data.Count;
       	counT1 = 0;
       	foreach (var Elem in ListDiam.data)//liste combobox
       	{            	if (TextDiam == Elem)
           	{ 
               	Elemdiam = Elem;//elemdiam = SelectedItem combobox
           	}
           	counT1 += 1;
       	}
   	}

liste elements complementaire

 		#region Get lisp : recupere la variable de toto = (!toto)

 	[system.Security.SuppressUnmanagedCodeSecurity]
   	[DllImport("accore.dll", EntryPoint = "acedGetSym",
  		CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Cdecl)]
   	extern static private int AcedGetSym(string args, out IntPtr result);

   	/// <summary>
   	/// Obtenez une valeur variable LISP.(Get a LISP variable value.)
   	/// </summary>
   	/// <param name="name">The variable name.</param>
   	/// <returns>The variable value or null if failed.</returns>

   	/// <param name = "name"> Le nom de la variable. </param> 
   	/// <returns> La valeur de la variable ou null est en panne. </returns> 
   	public static ResultBuffer GetLispSym(string name)
   	{
       	IntPtr ip = IntPtr.Zero;
       	int status = AcedGetSym(name, out ip);
       	if (status == (int)PromptStatus.OK && ip != IntPtr.Zero)
       	{
           	return ResultBuffer.Create(ip, true);
       	}
       	return null;
   	}
	#endregion
	
   	#region fonction value_lsp

   	/// <summary>
   	/// liste des valeur d'un reslbuffer
   	/// </summary>
   	/// <param name="tyPeL"></param>
   	/// <returns></returns>
   	public string value_lsp(ResultBuffer tyPeL)
   	{  string ret = "0";
       	if (tyPeL != null)
       	{  foreach (TypedValue Tv2 in tyPeL)
           	{ if (Tv2.Value.ToString() != "-1")
               	{ ret = Tv2.Value.ToString(); }
               	
           	}
       	}

       	return ret;
   	}
   	#endregion

	#region coeficient suivant unitées
	
	public class ECoefUnits
{ private int coefunits;
public int CoefUnits
   	{get  {  int Insunits = Convert.ToInt32(AcAp.GetSystemVariable("INSUNITS").ToString());
       	if (Insunits == 7)
       	{ coefunits = 100000; }
       	else if (Insunits == 6)
       	{ coefunits = 1000; }
       	else if (Insunits == 5)
       	{ coefunits = 10; }
       	else { coefunits = 1; }
           	return coefunits; }
   	set { coefunits = value; }
   	}
	}
#endregion

et patie xml

   	<ComboBox Margin="20,63,35.6,57.4" 
       	HorizontalAlignment="Stretch" 
           	Name="diamVMC1"   
			Width="Auto"
 	
     	
       	Loaded="Combobox_Loaded"  SelectionChanged="Combobox_Selec" Grid.Row="2"
  		SelectedItem = "{Binding Elemdiam, UpdateSourceTrigger=PropertyChanged}"
       	AlternationCount = "2" >


       	<ComboBox.Resources>

           	<Style  TargetType="{x:Type ComboBoxItem}">
               	<Style.Triggers>
                   	<Trigger Property="ItemsControl.AlternationIndex" Value="0">
                       	<Setter Property="Background">
                           	<Setter.Value>
                               	<LinearGradientBrush EndPoint="0.5,0.1" StartPoint="0.5,0">
                                   	<GradientStop Color="#FF3A371F" Offset="0"/>
                                   	<GradientStop Color="#FFDCF4FA" Offset="1"/>

                               	</LinearGradientBrush>
                           	</Setter.Value>
                       	</Setter>
                   	</Trigger>
                   	<Trigger Property="ItemsControl.AlternationIndex" Value="1">
                       	<Setter Property="Background">
                           	<Setter.Value>
                               	<LinearGradientBrush EndPoint="0.5,0.1" StartPoint="0.5,0">
                                   	<GradientStop Color="Black" Offset="0"/>
                                   	<GradientStop Color="White" Offset="1"/>
                               	</LinearGradientBrush>
                           	</Setter.Value>
                       	</Setter>
                   	</Trigger>
               	</Style.Triggers>
           	</Style>
       	</ComboBox.Resources>
</ComboBox>

(gile) · le 29 octobre 2017

Salut,

Tout d'abord, je me permettrais une remarque d'ordre général : j'évite tant que possible d'utiliser des variables globales LISP a fortiori si ces variables doivent être utilisées dans un autre environnement de programmation plus "rigoureux" comme .NET.

J'utiliserais plutôt des valeurs stockées dans des dictionnaires ou des variables système personnalisées (il est possible de créer ses propres variables système depuis AutoCAD 2011).

Sinon, il n'est plus nécessaire depuis AutoCAD 2013 d'utiliser P/Invoke avec acedGetSym et acedSetSym. Les méthodes Document.GetLispSymbol() et Document.SetLispSymbol() permettent la même chose en "pur .NET" (code managé).

Habituellement quand on veut abonner tous les documents à un gestionnaire d'évènement (LispEnded par exemple), on fait ça en deux temps :

1. abonnement des documents déjà ouverts (il peut y en avoir plusieurs si le code n'est pas exécuté depuis la méthode Initialize() d'une classe implémentant IExtensionApplication).

foreach (Document doc in Application.DocumentManager)
   doc.LispEnded += LispEndedHandler;

2. abonnement des documents créés (ou ouverts) ultérieurement. On utilise l'évènement DocumentCreated qui ne sera lancé qu'à la création (nouveau ou ouvrir) du document (contrairement à DocumentActivated qui est activé à chaque fois qu'on passe d'un dessin à un autre)

Application.DocumentManager.DocumentCreated += DocumentCreatedHandler;

et

private void DocumentCreatedHandler(object sender, DocumentCollectionEventArgs e)
{
   e.Document.LispEnded += LispEndedHandler;
}

(gile) · le 29 octobre 2017

Un exemple simple avec la gestion d'une seule propriété (LispVar) pour une variable LISP nommée "foo".

cette propriété peut être liée à un contrôle de la palette.

using Autodesk.AutoCAD.ApplicationServices;
using System;

namespace NetToLispPalette
{
   public class PaletteTabViewModel : ObservableObject
   {
       const string varName = "foo";
       object lispVar;
       DocumentCollection docs = Application.DocumentManager;

       // Valeur de la variable LISP 'foo'
       public object LispVar
       {
           get { return lispVar; }
           set
           {
               lispVar = value;
               if (value != null)
                   docs.MdiActiveDocument.SetLispSymbol(varName, value);
               RaisePropertyChanged(nameof(LispVar));
           }
       }

       // Constructeur
       public PaletteTabViewModel()
       {
           
           // Abonnement de tous les documents ouverts à LispEnded
           foreach (Document doc in docs)
               doc.LispEnded += Doc_LispEnded;
           // Abonnement des documents créés à Docs_DocumentCreated
           docs.DocumentCreated += Docs_DocumentCreated;
           // Abonnement des documents activés à Docs_DocumentActivated
           docs.DocumentActivated += Docs_DocumentActivated;
       }

       // Mise à jour de la propriété LispVar à la fin de chaque LISP
       private void Doc_LispEnded(object sender, EventArgs e)
       {
           LispVar = ((Document)sender).GetLispSymbol(varName);
       }

       // Abonnement à Doc_LispEnded pour tous les documents créés
       private void Docs_DocumentCreated(object sender, DocumentCollectionEventArgs e)
       {
           e.Document.LispEnded += Doc_LispEnded;
       }

       // Abonnement à Application_Idle pour tous les documents activés
       private void Docs_DocumentActivated(object sender, DocumentCollectionEventArgs e)
       {
           Application.Idle += Application_Idle; ;
       }

       // Mise à jour de la propriété LispVar dès que le document activé est au repos
       private void Application_Idle(object sender, EventArgs e)
       {
           Application.Idle -= Application_Idle; // désabonnement
           var doc = docs.MdiActiveDocument;
           if (doc != null)
               LispVar = doc.GetLispSymbol(varName);
       }
   }
}

(gile) · le 30 octobre 2017

Plus proche de ce que tu cherches à faire avec un ComboBox (si j'ai bien compris).

Nota: si une valeur non valide est affectée en LISP, le code .NET réaffecte automatiquement la valeur précédente.

XAML:

<UserControl x:Class="NetToLispPalette.PaletteTab"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
            xmlns:local="clr-namespace:NetToLispPalette"
            mc:Ignorable="d" 
            d:DesignHeight="300" d:DesignWidth="300">
   <Grid Background="WhiteSmoke">
       <Grid.RowDefinitions>
           <RowDefinition Height="Auto"/>
       </Grid.RowDefinitions>
       <Grid Grid.Row="0">
           <Grid.ColumnDefinitions>
               <ColumnDefinition Width="Auto"/>
               <ColumnDefinition Width="*"/>
           </Grid.ColumnDefinitions>
           <Label Margin="5,15,5,5">Largeur de la gaine :</Label>
           <ComboBox x:Name="cbxLayer" Grid.Column ="1" Margin="5,15,10,5"  HorizontalAlignment="Stretch" 
                     ItemsSource="{Binding Largeurs}" SelectedItem="{Binding Epaisseur}" />
       </Grid>
   </Grid>
</UserControl>

Code behind:

using System.Windows.Controls;

namespace NetToLispPalette
{
   /// <summary>
   /// Logique d'interaction pour PaletteTab.xaml
   /// </summary>
   public partial class PaletteTab : UserControl
   {
       public PaletteTab()
       {
           InitializeComponent();
           DataContext = new PaletteTabViewModel();
       }
   }
}

ViewModel:

using Autodesk.AutoCAD.ApplicationServices;
using System;
using System.Collections.Generic;

namespace NetToLispPalette
{
   public class PaletteTabViewModel : ObservableObject
   {

       DocumentCollection docs = Application.DocumentManager;
       HashSet<double> largeurs = new HashSet<double> { 80.0, 125.0, 160.0, 200.0, 250.0, 315.0, 355.0, 400.0 };
       double epaisseur = 125.0; // valeur par défaut

       // Propriété liée à ItemsSource du ComboBox
       public HashSet<double> Largeurs => largeurs;

       // Propriété liée à SelectedItem du ComboBox
       public double Epaisseur
       {
           get { return epaisseur; }
           set
           {
               epaisseur = value;
               docs.MdiActiveDocument.SetLispSymbol("epais", value);
               RaisePropertyChanged(nameof(Epaisseur));
           }
       }

       // Constructeur
       public PaletteTabViewModel()
       {
           Epaisseur = TryGetLispValue();

           // Abonnement de tous les documents ouverts à LispEnded
           foreach (Document doc in docs)
               doc.LispEnded += Doc_LispEnded;
           // Abonnement des documents créés à Docs_DocumentCreated
           docs.DocumentCreated += Docs_DocumentCreated;
           // Abonnement des documents activés à Docs_DocumentActivated
           docs.DocumentActivated += Docs_DocumentActivated;
       }

       // Mise à jour de la propriété Epaisseur à la fin de chaque LISP
       private void Doc_LispEnded(object sender, EventArgs e)
       {
           Epaisseur = TryGetLispValue();
       }

       // Abonnement à Doc_LispEnded pour tous les documents créés
       private void Docs_DocumentCreated(object sender, DocumentCollectionEventArgs e)
       {
           e.Document.LispEnded += Doc_LispEnded;
       }

       // Abonnement à Application_Idle pour tous les documents activés
       private void Docs_DocumentActivated(object sender, DocumentCollectionEventArgs e)
       {
           Application.Idle += Application_Idle; ;
       }

       // Mise à jour de la propriété Epaisseur dès que le document activé est au repos
       private void Application_Idle(object sender, EventArgs e)
       {
           Application.Idle -= Application_Idle; // désabonnement
           var doc = docs.MdiActiveDocument;
           if (doc != null)
               Epaisseur = TryGetLispValue();
       }

       // Retourne la valeur de la variable LISP si elle est valide, sinon la valeur courante de epaisseur
       private double TryGetLispValue()
       {
           double epais;
           try { epais = Convert.ToDouble(docs.MdiActiveDocument.GetLispSymbol("epais")); }
           catch { epais = epaisseur; }
           return largeurs.Contains(epais) ? epais : epaisseur;
       }
   }
}

sbosarl · le 30 octobre 2017

salut,

déjà merci, je vais regarder ça dans le détail .

sbosarl · le 6 novembre 2017

Salut ,

Génial les GetLispSymbol et SetLi…. , c’est un peu mon problème de trouvée les définitions (j’ai du mal pour naviguer avec l’aide Autodesk et l'anglais ) .

Je n’ai pas encore tous regardé par manque de temps

Je me permets encore quelques questions

1) as t il une liste alphabétique de toute les Class Autodesk ?

2) "Application.Idle" cela correspond à quoi ?

(gile) · le 6 novembre 2017

Salut,

1) Tu as une documentation dans le fichier arxmgd.chm dans le dossier ObjectARX 20XX\docs (si tu as bien téléchargé et installé le SDK ObjectARX). On peut aussi avoir le guide des références .NET 2018 en ligne.

2) Application.Idle est un évènement déclenché quand l'application est au repos. En délégant l'évènement DocumentActivated à Idle, on s'assure que le gestionnaire d'évènement ne sera exécuté qu'après la complète initialisation du document.

Connexion

event palette

Messages recommandés

sbosarl

(gile)

sbosarl

sbosarl

sbosarl

(gile)

(gile)

(gile)

sbosarl

sbosarl

(gile)

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante