Aller au contenu

event palette


sbosarl

Messages recommandés

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();
}

Lien vers le commentaire
Partager sur d’autres sites

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).

Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
ADSK_Expert_Elite_Icon_S_Color_Blk_125.png

Lien vers le commentaire
Partager sur d’autres sites

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

Lien vers le commentaire
Partager sur d’autres sites

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>

Lien vers le commentaire
Partager sur d’autres sites

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;
}

Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
ADSK_Expert_Elite_Icon_S_Color_Blk_125.png

Lien vers le commentaire
Partager sur d’autres sites

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);
       }
   }
}

Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
ADSK_Expert_Elite_Icon_S_Color_Blk_125.png

Lien vers le commentaire
Partager sur d’autres sites

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;
       }
   }
}

Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
ADSK_Expert_Elite_Icon_S_Color_Blk_125.png

Lien vers le commentaire
Partager sur d’autres sites

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 ?

Lien vers le commentaire
Partager sur d’autres sites

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.

Gilles Chanteau - gileCAD -
Développements sur mesure pour AutoCAD
ADSK_Expert_Elite_Icon_S_Color_Blk_125.png

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é