public MainWindow() { InitializeComponent(); listBox = new ListBox(); Content = listBox; myButton = new Button { Content = "Click me" }; myButton.Click += (sender, args) => { myButton.Content = "Lorem ipsum dolor sit amet."; myButton.FontSize = 24; }; dummyGrid = new Grid(); dummyGrid.ColumnDefinitions.Add(new ColumnDefinition() { Width = GridLength.Auto }); dummyGrid.RowDefinitions.Add(new RowDefinition() { Height = GridLength.Auto }); dummyGrid.Children.Add(myButton); var frameworkElement = FrameworkElementAdapters.ContractToViewAdapter( FrameworkElementAdapters.ViewToContractAdapter(dummyGrid)); listBox.Items.Add(frameworkElement); // Automatically adjust HwndHost's size when the grid changes dummyGrid.SizeChanged += (sender, args) => { frameworkElement.Width = args.NewSize.Width; frameworkElement.Height = args.NewSize.Height; }; }
/// <summary> /// Initializes the given entry point by calling <see cref="HostedEntryPoint.Initialize"/> /// returning the given framework as an INativeHandleContract. /// </summary> public INativeHandleContract Initialize(Dictionary <string, string> configuration, out Dictionary <string, string> returnedConfiguration) { _element = _entryPoint.Initialize(configuration); returnedConfiguration = configuration; return(FrameworkElementAdapters.ViewToContractAdapter(_element)); }
private void LoadDomain() { if (scriptDomain == null) { try { AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve; AppDomainSetup setup = new AppDomainSetup() { ApplicationBase = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), PrivateBinPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), }; scriptDomain = AppDomain.CreateDomain(DomainName, AppDomain.CurrentDomain.Evidence, setup); VSContext.InitializeAppDomain(scriptDomain); #if USE_APP_DOMAIN proxy = (VSInteractiveWindowProxy)scriptDomain.CreateInstanceAndUnwrap(typeof(VSInteractiveWindowProxy).Assembly.FullName, typeof(VSInteractiveWindowProxy).FullName); var control = FrameworkElementAdapters.ContractToViewAdapter(proxy.CreateControl()); #else var control = new VSInteractiveWindowControl(); #endif grid.Children.Clear(); grid.Children.Add(control); } catch (Exception ex) { #if DEBUG System.Windows.MessageBox.Show("Loading domain failed:\n" + ex.ToString()); #endif } } }
public void DoTheTrick() { var uControl = LoadAssembly("assemblyName", "interfaceName"); panel.Content = FrameworkElementAdapters.ContractToViewAdapter(uControl); remoteWorker.RemoteInvoke("methodName", new object[] { }); }
public INativeHandleContract RegisterContent() { FrameworkElement element = m_View.RegisterContent(); INativeHandleContract contract = FrameworkElementAdapters.ViewToContractAdapter(element); return(contract); }
public object ToContract(Control control) { var content = DesignPanel.GetContent(control); var view = content.ToNative(true); return(FrameworkElementAdapters.ViewToContractAdapter(view)); }
public INativeHandleContract GetAddInUI() { FrameworkElement fe = this.wpfAddInView as FrameworkElement; // return instance directly instead of creating new one by wpfAddInView.GetAddInUI(); INativeHandleContract inhc = FrameworkElementAdapters.ViewToContractAdapter(fe); return(inhc); }
/// <summary> /// Gets the user interface. /// </summary> /// <returns></returns> public INativeHandleContract GetUserInterface( ) { FrameworkElement fe = _view.GetUserInterface( ); INativeHandleContract inhc = FrameworkElementAdapters.ViewToContractAdapter(fe); return(inhc); }
public Window1() { InitializeComponent(); m_stackPanel = new StackPanel { Orientation = Orientation.Vertical }; m_stackPanel.Background = Brushes.Red; m_expander = new Expander { ExpandDirection = ExpandDirection.Right, Background = Brushes.Blue, IsExpanded = true, }; m_expander.Expanded += CheckStuff; m_expander.Collapsed += CheckStuff; Rectangle r = new Rectangle { Fill = Brushes.LightGray, Height = 300, Width = 300 }; m_expander.Content = r; StackPanel stackPanel = new StackPanel(); stackPanel.Children.Add(m_expander); m_expanderAddIn = FrameworkElementAdapters.ContractToViewAdapter(FrameworkElementAdapters.ViewToContractAdapter(stackPanel)); Binding binding = new Binding("ActualHeight"); binding.Source = m_expander; m_expanderAddIn.SetBinding(FrameworkElement.HeightProperty, binding); m_stackPanel.Children.Add(m_expanderAddIn); Content = m_stackPanel; }
private void StartHost() { var processInfo = new ProcessStartInfo { Arguments = new TypedArgs(parentProcessId, PluginInfo.AssemblyFile, instanceName).ToArgs(), CreateNoWindow = true, // Note: The command window might be helpful to search for errors. UseShellExecute = false, FileName = "PluginHost.exe", WorkingDirectory = Path.GetDirectoryName(PluginInfo.AssemblyFile) }; using (var readyEvent = new EventWaitHandle(false, EventResetMode.ManualReset, instanceName + ".Ready")) { var pluginProcess = Process.Start(processInfo); pluginProcess.EnableRaisingEvents = true; pluginProcess.Exited += PluginProcessExited; if (!readyEvent.WaitOne(3000)) { throw new InvalidOperationException("Plugin host process not ready."); } } var url = "ipc://" + instanceName + "/PluginLoader"; pluginLoader = (IPluginLoader)Activator.GetObject(typeof(IPluginLoader), url); // TODO: This won't work if the plugin crashes during startup! var contract = pluginLoader.LoadPlugin(PluginInfo.AssemblyFile, PluginInfo.PluginControllerName); RemoteView = FrameworkElementAdapters.ContractToViewAdapter(contract); }
public Control FromContract(object contract) { var view = FrameworkElementAdapters.ContractToViewAdapter((INativeHandleContract)contract); view.Focusable = false; // otherwise editor loses focus when switching back to its tab.. may be a better way around this. return(new Control(new NativeControl(view))); }
/// <summary> /// By default returns real control object. /// </summary> /// <param name="contractAdapter">If <b>True</b>, the <see cref="System.AddIn.Contract.INativeHandleContract"/> instance returned.</param> /// <returns>Control object</returns> public object GetControl(bool contractAdapter = false) { if (contractAdapter) { return(FrameworkElementAdapters.ViewToContractAdapter(Control)); } return(Control); }
public RemotePlugin(IPlugin plugin) { _plugin = plugin; var control = plugin.CreateControl(); var localContract = FrameworkElementAdapters.ViewToContractAdapter(control); Contract = new NativeHandleContractInsulator(localContract); }
public INativeHandleContract GetAddInUI(IPersonContract personContract) { Person_ContractToViewAddInSideAdapter personView = new Person_ContractToViewAddInSideAdapter(personContract); FrameworkElement fe = this.addInView.GetAddInUI(personView); INativeHandleContract addInUIHwnd = FrameworkElementAdapters.ViewToContractAdapter(fe); return(addInUIHwnd); }
/// <summary> /// ContractBase.QueryContract must be overridden to: /// * Safely return a window handle for an add-in UI to the host /// application's application. /// * Enable tabbing between host application UI and add-in UI, in the /// "add-in is a UI" scenario. /// </summary> public override IContract QueryContract(string contractIdentifier) { if (contractIdentifier.Equals(typeof(INativeHandleContract).AssemblyQualifiedName)) { return(FrameworkElementAdapters.ViewToContractAdapter(this.wpfAddInView)); } return(base.QueryContract(contractIdentifier)); }
public static async Task <INativeHandleContract> CreateViewContract(string threadName, Func <FrameworkElement> factory) { INativeHandleContract contract = null; var dispatcher = await GetOrCreateDispatcherAsync(threadName); await dispatcher.BeginInvoke(() => contract = FrameworkElementAdapters.ViewToContractAdapter(factory())); return(contract); }
public INativeHandleContract GetAddInStatusUI() { // Convert the FrameworkElement from the add-in to an INativeHandleContract // that will be passed across the isolation boundary to the host application. FrameworkElement fe = this.wpfAddInView.GetAddInStatusUI(); INativeHandleContract inhc = FrameworkElementAdapters.ViewToContractAdapter(fe); return(inhc); }
public FrameworkElement GetAddInUI() { // Convert the INativeHandleContract that was passed from the add-in side // of the isolation boundary to a FrameworkElement INativeHandleContract inhc = this._wpfAddInContract.GetAddInUI(); FrameworkElement fe = FrameworkElementAdapters.ContractToViewAdapter(inhc); return(fe); }
public FrameworkElement GetAddInUI(IPersonView personView) { Person_ViewToContractHostSideAdapter personContract = new Person_ViewToContractHostSideAdapter(personView); INativeHandleContract addInUIHwnd = this.addInContract.GetAddInUI(personContract); FrameworkElement addInUI = FrameworkElementAdapters.ContractToViewAdapter(addInUIHwnd); return(addInUI); }
/// <summary> /// Tear down any app domain that currently exists, create a new one and reload the control in /// the given app domain. /// </summary> public async void Reload() { UnloadDomain(); Status = ControlHostStatus.Waiting; if (!File.Exists(_configuration.PathToAssembly)) { // try again in a little bit _timer.Start(); return; } AdditionalInformation = null; Status = ControlHostStatus.Loading; try { // creating an app-domain (and loading everything etc.) takes a while, so do it on a background // thread and resume later. await Task.Run(() => { _lastDomain = AppDomainUtils.CreateShadowAppDomain("Document-Host") .ResolveAssembliesFrom(_rootDictionary); _currentEntryPoint = _lastDomain.CreateInstanceOf <InAppDomainController>() .FindEntryPoint(_assemblyToObserve); }); // dictionaries are serialized (read: copied) instead of passed by reference across app-domains Dictionary <string, string> tempConfiguration; var reference = _currentEntryPoint.Initialize(_configuration.Data, out tempConfiguration); _configuration.Data = tempConfiguration; var proxyElement = FrameworkElementAdapters.ContractToViewAdapter(reference); Host = proxyElement; proxyElement.Loaded += delegate { Keyboard.Focus(proxyElement); TraversalRequest request = new TraversalRequest(FocusNavigationDirection.Next); Host.MoveFocus(request); }; Status = ControlHostStatus.Valid; } catch (Exception exception) { AdditionalInformation = exception.ToString(); UnloadDomain(ignoreShutdown: true); Status = ControlHostStatus.Waiting; } }
/// <summary> /// Gets the options user interface. /// </summary> /// <returns></returns> public FrameworkElement GetOptionsUserInterface( ) { ///// // Convert the INativeHandleContract that was passed from the add-in side // of the isolation boundary to a FrameworkElement ///// INativeHandleContract inhc = _contract.GetOptionsUserInterface( ); FrameworkElement fe = FrameworkElementAdapters.ContractToViewAdapter(inhc); return(fe); }
private INativeHandleContract LoadPluginCore(string assembly, string typeName) { var objectHandle = Activator.CreateInstance(assembly, typeName); pluginController = (IPluginController)objectHandle.Unwrap(); pluginController.Initialize(); var view = pluginController.CreateMainView(); var contract = FrameworkElementAdapters.ViewToContractAdapter((FrameworkElement)view); var insulator = new NativeHandleContractInsulator(contract); return(insulator); }
/// <summary> /// Gets the tool bar. /// </summary> /// <returns></returns> public FrameworkElement GetToolBar( ) { ///// // Convert the INativeHandleContract that was passed from the add-in side // of the isolation boundary to a FrameworkElement ///// INativeHandleContract inhc = _contract.GetToolBar( ); FrameworkElement toolbar = FrameworkElementAdapters.ContractToViewAdapter(inhc); return(toolbar); }
public object ToContract(Control control) { var view = control.ToNative(true); var holder = new swc.ScrollViewer { HorizontalScrollBarVisibility = swc.ScrollBarVisibility.Disabled, VerticalScrollBarVisibility = swc.ScrollBarVisibility.Disabled, Content = view }; return(FrameworkElementAdapters.ViewToContractAdapter(holder)); }
public void ShowWindow(IRemoteControl window) { if (window == null) { throw new ArgumentException("Window argument cannot be null"); } bool IsContract = false; bool IsAirspaceDecoration = false; object Control = null; try { Control = window.GetControl(); } catch (SerializationException) { INativeHandleContract contract = window.GetControl(true) as INativeHandleContract; if (contract != null) { Control = FrameworkElementAdapters.ContractToViewAdapter(contract); IsContract = true; IsAirspaceDecoration = window.EnableAirspaceFix; } } if (Control != null) { if (CurrentWindow != null) { WindowStack.Push(CurrentWindow); } if (IsContract && IsAirspaceDecoration) { Control = new AirspaceDecorator() { AirspaceMode = AirspaceMode.Redirect, IsInputRedirectionEnabled = true, IsOutputRedirectionEnabled = true, Background = Brushes.White, Content = Control }; } CurrentWindow = window; CurrentWindow.OnShow(); UpdateTransition(Control, ((IsContract && !IsAirspaceDecoration) || (this.IsContract && !this.IsAirspaceDecoration)) ? TransitionType.Normal : DefaultTransition); this.IsContract = IsContract; this.IsAirspaceDecoration = IsAirspaceDecoration; } }
/// <summary> /// Gets the add in UI. /// </summary> /// <returns></returns> public INativeHandleContract GetAddInUi() { // Convert the FrameworkElement from the add-in to an INativeHandleContract // that will be passed across the isolation boundary to the host application. var frameworkElement = view.GetAddInUi(); if (frameworkElement == null) { return(null); } var nativeHandleContract = FrameworkElementAdapters.ViewToContractAdapter(frameworkElement); return(nativeHandleContract); }
/// <summary> /// Gets the add in UI. /// </summary> /// <returns></returns> public FrameworkElement GetAddInUi() { // Convert the INativeHandleContract that was passed from the add-in side // of the isolation boundary to a FrameworkElement var nativeHandleContract = contract.GetAddInUi(); if (nativeHandleContract == null) { return(null); } var frameworkElement = FrameworkElementAdapters.ContractToViewAdapter(nativeHandleContract); return(frameworkElement); }
//public INativeHandleContract GetAddInUI() //{ // // Convert the FrameworkElement from the add-in to an INativeHandleContract // // that will be passed across the isolation boundary to the host application. // FrameworkElement fe = this._wpfAddInView.GetAddInUI(); // INativeHandleContract inhc = FrameworkElementAdapters.ViewToContractAdapter(fe); // return inhc; //} public INativeHandleContract GetAddInUI() { // Convert the FrameworkElement from the add-in to an INativeHandleContract // that will be passed across the isolation boundary to the host application. System.AddIn.Contract.INativeHandleContract value = null; _ad.DoWork( delegate { //This special adapter has one purposes: //1. Cut off the standard WPF tabbing support to ensure that it doesn't do its work on the wrong thread (by ensuring it doesn't do it at all) FrameworkElement fe = _wpfAddInView.GetAddInUI(); INativeHandleContract inhc = FrameworkElementAdapters.ViewToContractAdapter(fe); value = new MyNativeHandle(inhc); } ); return(value); }
public FrameworkElement GetControl() { FrameworkElement element = null; var contract = _contract.GetControl(); var handle = new ContractHandle(contract); Application.Current.Dispatcher.Invoke(new Action(() => { element = FrameworkElementAdapters.ContractToViewAdapter(contract); //element = FrameworkElementAsyncAdapters.ContractToViewAdapter(contract); element.Unloaded += (s, e) => handle.Dispose(); })); return(element); }
public INativeHandleContract GetControl(string AssemblyName, string strFullNamespaceName) { var assembly = Assembly.LoadFrom(m_strAssemblyDirectory + AssemblyName); var type1 = typeof(IUPiAssemblyProcedure); var type2 = typeof(IUPiCardProcedure); var type3 = typeof(IUPiDatabaseFrame); var type4 = typeof(IUPiUserFrame); var t = from T in assembly.GetTypes() where type1.IsAssignableFrom(T) || type2.IsAssignableFrom(T) || type3.IsAssignableFrom(T) || type4.IsAssignableFrom(T) select T; if (t.Count <Type>() == 0) { return(null); } var tName = t.First <Type>().FullName; _currentInstance = assembly.CreateInstance(tName); return(FrameworkElementAdapters.ViewToContractAdapter((FrameworkElement)_currentInstance)); }