internal virtual IntPtr NonConstPointer(bool createIfMissing) { #if RHINO_SDK if (createIfMissing && IntPtr.Zero == m_native_pointer) { m_serial_number = g_next_serial_number++; Type t = GetType(); Guid managed_type_id = t.GUID; string description = Description; if (this is UserDictionary) { Guid id = RhinoApp.Rhino5Id; m_native_pointer = UnsafeNativeMethods.CRhCmnUserData_New(m_serial_number, managed_type_id, id, description); } else { PlugIns.PlugIn plugin = PlugIns.PlugIn.Find(t.Assembly); Guid plugin_id = plugin.Id; m_native_pointer = UnsafeNativeMethods.CRhCmnUserData_New(m_serial_number, managed_type_id, plugin_id, description); } } #endif return(m_native_pointer); }
/// <summary> /// Call once to register a panel type which will get dynamically created /// and embedded in a Rhino docking/floating location. /// </summary> /// <param name="plugIn"> /// Plug-in restringing the panel /// </param> /// <param name="type"> /// Type of the control object to be displayed in the panel /// </param> /// <param name="caption"> /// Panel caption also used as a tool-tip. On Windows the panel may be /// displayed using the icon, caption or both. On Mac the icon will be /// used and the caption will be the tool-tip. /// </param> /// <param name="icon"> /// The panel icon. On Windows the panel may be displayed using the icon, /// caption or both. On Mac the icon will be used and the caption will be /// the tool-tip. /// </param> /// <param name="panelType"> /// See <see cref="PanelType"/> /// </param> public static void Register(PlugIns.PlugIn plugIn, Type type, string caption, Icon icon, PanelType panelType) { // Plug-in that owns the panel, currently required. Investigate changing to // System.Reflection.Assembly to allow Pixel.Rhino.UI to register panels directly if (plugIn == null) { throw new ArgumentNullException(nameof(plugIn)); } Register(GetPlugInId(plugIn), type, caption, icon, panelType); }
/// <summary> /// Search the plug-in's dictionary for the specified plug-in and if it is /// not found then add it to the dictionary. /// </summary> /// <param name="plugIn"></param> /// <returns></returns> internal static RdkPlugIn GetRdkPlugIn(PlugIns.PlugIn plugIn) { var found = FromRhinoPlugIn(plugIn); if (null != found) { return(found); } var plugin_pointer = plugIn.NonConstPointer(); return(AddPlugInToDictionary(plugin_pointer, plugIn.Id, plugIn.m_runtime_serial_number)); }
private static Guid GetPlugInId(PlugIns.PlugIn plugIn) { try { var id = plugIn.Id; if (id != Guid.Empty) { return(id); } // Probabbly called by the plug-in constructor and the plug-in has not // been initialized by the plug-in loader yet so get the Id from the assembly var attribute = plugIn.GetType().Assembly.GetCustomAttributes(typeof(System.Runtime.InteropServices.GuidAttribute), true)[0] as System.Runtime.InteropServices.GuidAttribute; return(new Guid(attribute.Value)); } catch { return(Guid.Empty); } }
/// <summary> /// Gets the object that is returned by PlugIn.GetPlugInObject for a given /// plug-in. This function attempts to find and load a plug-in with a given Id. /// When a plug-in is found, it's GetPlugInObject function is called and the /// result is returned here. /// Note the plug-in must have already been installed in Rhino or the plug-in manager /// will not know where to look for a plug-in with a matching id. /// </summary> /// <param name="pluginId">Guid for a given plug-in.</param> /// <returns> /// Result of PlugIn.GetPlugInObject for a given plug-in on success. /// </returns> public static object GetPlugInObject(Guid pluginId) { if (pluginId == Guid.Empty) { return(null); } // see if the plug-in is already loaded before doing any heavy lifting PlugIns.PlugIn p = Rhino.PlugIns.PlugIn.GetLoadedPlugIn(pluginId); if (p != null) { return(p.GetPlugInObject()); } // load plug-in UnsafeNativeMethods.CRhinoPlugInManager_LoadPlugIn(pluginId); p = Rhino.PlugIns.PlugIn.GetLoadedPlugIn(pluginId); if (p != null) { return(p.GetPlugInObject()); } IntPtr iunknown = UnsafeNativeMethods.CRhinoApp_GetPlugInObject(pluginId); if (IntPtr.Zero == iunknown) { return(null); } object rc; try { rc = System.Runtime.InteropServices.Marshal.GetObjectForIUnknown(iunknown); } catch (Exception) { rc = null; } return(rc); }
/// <summary> /// Search the Render Development Kit(RDK) plug-in dictionary for a render /// plug-in with the matching Rhino plug-in Id. /// </summary> /// <param name="plugIn">Rhino plug-in to search for.</param> /// <returns> /// If the plug-in is in the RDK dictionary then the dictionary plug-in /// object is returned, if not then null is returned. /// </returns> public static RdkPlugIn FromRhinoPlugIn(PlugIns.PlugIn plugIn) { return((null == plugIn) ? null : FromPlugInId(plugIn.Id)); }
/* * public static Pixel.Rhino.Geometry.Curve TryCopyFromOnCurve(object source) * { * if (source != null) * { * try * { * Type base_type = Type.GetType("RMA.OpenNURBS.OnCurve"); * System.Type t = source.GetType(); * if (t.IsAssignableFrom(base_type)) * { * System.Reflection.PropertyInfo pi = t.GetProperty("InternalPointer"); * IntPtr ptr = (IntPtr)pi.GetValue(source, null); * Pixel.Rhino.Geometry.Curve crv = Pixel.Rhino.Geometry.Curve.CreateCurveHelper(ptr, null); * crv.NonConstPointer(); * return crv; * } * } * catch (Exception) * { * } * } * return null; * } * * /// <summary> * /// Do not hold on to the returned class outside the scope of your current function. * /// </summary> * /// <param name="source">-</param> * /// <returns>-</returns> * public static Pixel.Rhino.Display.DisplayPipeline ConvertFromMRhinoDisplayPipeline(object source) * { * if (source != null) * { * try * { * Type base_type = Type.GetType("RMA.Pixel.Rhino.MRhinoDisplayPipeline"); * System.Type t = source.GetType(); * if (t.IsAssignableFrom(base_type)) * { * System.Reflection.PropertyInfo pi = t.GetProperty("InternalPointer"); * IntPtr ptr = (IntPtr)pi.GetValue(source, null); * return new Pixel.Rhino.Display.DisplayPipeline(ptr); * } * } * catch (Exception) * { * } * } * return null; * } */ #if RHINO_SDK /// <summary> /// Gets a C++ plug-in pointer for a given RhinoCommon plug-in. /// <para>This is a Rhino SDK function.</para> /// </summary> /// <param name="plugin">A plug-in.</param> /// <returns>A pointer.</returns> /// <since>5.0</since> public static IntPtr PlugInPointer(PlugIns.PlugIn plugin) { return(null == plugin ? IntPtr.Zero : plugin.NonConstPointer()); }
/// <summary> /// You typically register your panel class in your plug-in's OnLoad /// function. This will register your custom call with Rhino, Rhino will /// create an instance of your class the first time your panel is created /// and embed this instance of your class in a panel container. /// </summary> /// <param name="plugin">Plug-in this panel is associated with</param> /// <param name="panelType"> /// Class type to construct when a panel is shown. If your class is /// derived from Eto.Forms.Control it will work on both the Mac and /// Windows version of Rhino. In addition Windows Rhino will support any /// class types that implement the IWin32Window interface or that are /// derived from System.Windows.FrameworkElement. Mac Rhino will also /// support classes that are derived from NsView. In addition to the /// type requirements the class must have a public constructor with no /// parameters or a constructor with a single uint that represents the /// document serial number and have a GuidAttribute applied with a /// unique Id. n Windows there is only one panel created which gets /// recycled for each new document. On the Mac a panel will be created /// for each open document and destroyed when the document closes. In /// certain situations in Mac Rhino a a panel may get created and /// destroyed multiple times when opening/closing a panel while editing a /// document. /// </param> /// <param name="caption"> /// Displays in the panel tab on Windows or at the top of the modeless /// window on Mac. /// </param> /// <param name="icon"> /// Currently only used in Windows, use a 32bit depth icon in order to /// get proper transparency. /// </param> /// <since>5.0</since> public static void RegisterPanel(PlugIns.PlugIn plugin, Type panelType, string caption, System.Drawing.Icon icon) { RegisterPanel(plugin, panelType, caption, icon, PanelType.PerDoc); }
/// <summary> /// Call once to register a panel type which will get dynamically created /// and embedded in a Rhino docking/floating location. /// </summary> /// <param name="plugIn"> /// Plug-in restringing the panel /// </param> /// <param name="type"> /// Type of the control object to be displayed in the panel /// </param> /// <param name="caption"> /// Panel caption also used as a tool-tip. On Windows the panel may be /// displayed using the icon, caption or both. On Mac the icon will be /// used and the caption will be the tool-tip. /// </param> /// <param name="icon"> /// The panel icon. On Windows the panel may be displayed using the icon, /// caption or both. On Mac the icon will be used and the caption will be /// the tool-tip. /// </param> /// <param name="panelType"> /// See <see cref="PanelType"/> /// </param> /// <since>6.1</since> public static void RegisterPanel(PlugIns.PlugIn plugIn, Type type, string caption, System.Drawing.Icon icon, PanelType panelType) { PanelSystem.Register(plugIn, type, caption, icon, panelType); }