input)
62 | {
63 | if (column == data.Count)
64 | {
65 | object[] items= new object[data.Count];
66 | data.CopyTo(items,0);
67 | input.Add(items);
68 | return;
69 | }
70 | var list = data[column] as System.Collections.IList;
71 | if (list != null)
72 | {
73 | foreach (var item in list)
74 | {
75 | data[column] = item;
76 | BuildInputHelper(column + 1, data, ref input);
77 | }
78 | data[column] = list;
79 | }
80 | else
81 | BuildInputHelper(column + 1, data, ref input);
82 | }
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Python interpreter addon for Grasshopper
2 | ========================================
3 |
4 | We are having fun building this Grasshopper-Python component, you are welcome to join us.
5 |
6 | Discussions for help on using or configuring this addon can be found at:
7 |
8 | * http://www.grasshopper3d.com/forum/categories/vb-c-and-python-coding/listForCategory
9 | * http://python.rhino3d.com/
10 |
11 | 
12 |
13 | Installation / Configuration
14 | ----------------------------
15 | You can get a version of this addon ready for installation from http://www.food4rhino.com/project/ghpython
16 |
17 | If you are building this addon from source, use the _GrasshopperDeveloperSettings command to add the output directory for your .gha to the list of directories Grasshopper pays attention to.
18 |
19 |
20 | Contributing to GhPython
21 | ------------------------
22 | There are many ways to contribute to this project:
23 |
24 | * Test the addon and report bugs/wishes to the issue list at https://github.com/mcneel/ghpython/issues
25 | * Create sample python scripts that we can embed in the addon to help others learn
26 | * Create sample ghx files for using this addon to help others learn
27 | * Directly edit the source code using git. If you need help with this, please let us know.
28 |
29 | Compiling the Source
30 | --------------------
31 | You are going to need:
32 |
33 | * The latest Rhino5 WIP (http://www.rhino3d.com/nr.htm)
34 | * Grasshopper (http://www.grasshopper3d.com)
35 | * Visual C# 2012
36 |
37 | Steps:
38 |
39 | * Get the source code by downloading everything as a zip or using git
40 | * Copy the appropriate DLLs to the references directory (read the readme.txt in the references directory for a list of DLLs)
41 | * Start GhPython.sln and build!!!
42 |
43 | Authors
44 | -------
45 | Steve Baer - https://github.com/sbaer steve@mcneel.com
46 |
47 | Giulio Piacentino - https://github.com/piac giulio@mcneel.com
48 |
49 | Legal Stuff
50 | -----------
51 | Copyright (c) 2011-2013 Robert McNeel & Associates. All Rights Reserved.
52 |
53 | Permission is hereby granted, free of charge, to any person obtaining a copy of
54 | this software and associated documentation files (the "Software"), to deal in
55 | the Software without restriction, including without limitation the rights to use,
56 | copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
57 | Software.
58 |
59 | THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. ALL IMPLIED
60 | WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF MERCHANTABILITY ARE HEREBY
61 | DISCLAIMED.
62 |
63 | Rhinoceros is a registered trademark of Robert McNeel & Associates.
64 |
65 |  
66 |
--------------------------------------------------------------------------------
/Samples/pygha/makeLine.py:
--------------------------------------------------------------------------------
1 | import clr
2 |
3 | ###############################################################
4 | # 1. This is a sample of the code to create a Line component in Python.
5 | # David can make this slightly simpler by never using protected nested types.
6 |
7 | clr.AddReference("Grasshopper")
8 | import Grasshopper
9 |
10 | import System, Rhino
11 | clr.AddReference("RhinoCommon")
12 | import Rhino.Geometry as rh
13 |
14 | class MyLineComponent(Grasshopper.Kernel.GH_Component):
15 |
16 | def __new__(cls):
17 |
18 | # Information is: Name, Nickname, Description, Category, Subcategory
19 | instance = Grasshopper.Kernel.GH_Component.__new__(cls, "Line from ends", "Line", "Makes a line from two points.", "PYTHON", "Py")
20 | return instance
21 |
22 | def get_ComponentGuid(self):
23 | return System.Guid("8549a015-74c5-479f-8633-c01a9d06a7fa")
24 |
25 | def SetUpParam(self, p, name, nickname, description):
26 | p.Name = name
27 | p.NickName = nickname
28 | p.Description = description
29 |
30 |
31 | def RegisterInputParams(self, pManager):
32 | p0 = Grasshopper.Kernel.Parameters.Param_Point()
33 | self.SetUpParam(p0, "Point A", "A", "The first point")
34 | p0.Access = Grasshopper.Kernel.GH_ParamAccess.item
35 | self.Params.Input.Add(p0)
36 |
37 | p1 = Grasshopper.Kernel.Parameters.Param_Point()
38 | self.SetUpParam(p1, "Point B", "B", "The second point")
39 | p1.Access = Grasshopper.Kernel.GH_ParamAccess.item
40 | self.Params.Input.Add(p1)
41 |
42 |
43 | def RegisterOutputParams(self, pManager):
44 | l0 = Grasshopper.Kernel.Parameters.Param_Line()
45 | self.SetUpParam(l0, "Line", "L", "The resulting line")
46 | self.Params.Output.Add(l0)
47 |
48 | def SolveInstance(self, DA):
49 | pointA = Rhino.Geometry.Point3d(0,0,0)
50 | pointB = Rhino.Geometry.Point3d(0,0,0)
51 |
52 | v0 = DA.GetData(0, pointA)
53 | v1 = DA.GetData(1, pointB)
54 | if v0[0] and v1[1]:
55 | line = rh.Line(v0[1], v1[1])
56 | DA.SetData(0, line)
57 |
58 | def get_Internal_Icon_24x24(self):
59 | import base64
60 | o = """iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAAAXNSR0IArs4c6QAAAARnQU1BAACx
61 | jwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41
62 | LjEwMPRyoQAAAalJREFUSEvVlD1Lw1AYhZsPWhpiCzFYEGsoCKVGsB2ySUZJwWy1hLahoVTUXVBx
63 | sk466eLg6CD+gY7+AhcdnHQQdLSToGDx47ylgbSb3rt44XATwvuccz/yxmL/cMwgs8M7twpgAF1B
64 | n+l0+rDdbk+wmsgArECX0Dv0HapcLp/CQGQxoOJuFBo+J5PJHuANFvig1nEcM5VKPY2bGIZxDYMi
65 | swEBTNNcxfQVNbFt+wIGSS4GgGiqqt5omvZAJrIsv7VarQ0ecGV4uHNIazWbTT+TydxCd3hf4mFQ
66 | FAShl8/n90KY7/uG67onMJhkNfAAUKrVagOwTUgKgTzg8/Qj4fYcERTABGvaaP3g6lmW1QmCYJ8V
67 | ro0lI3hfUZQdAkPUb/48qAU8SpJkDwk6zblc7rxWq3UAp+9MY5nuNG4J9Zdd6DUej7sAT0ELTORh
68 | 8RkZhEokEs+VSmULcIEHnJb/EjUQRfGjUCis84ATY7A946LtipwJk9fI9gDc13X9vlQqdT3PW2Pt
69 | 8YPtiULr9foxoNuQA00zRUfxbDabPeANHQmFlIs8krKu9Ff1P/WNhQUWh+7RAAAAAElFTkSuQmCC"""
70 | return System.Drawing.Bitmap(System.IO.MemoryStream(System.Convert.FromBase64String(o)))
--------------------------------------------------------------------------------
/Samples/helpText.html:
--------------------------------------------------------------------------------
1 | This component allows to use both RhinoCommon and RhinoScript from within
2 | Grasshopper. Here some Q&As.
3 |
4 | How can I use the rhinoscriptsyntax?
5 | By importing RhinoScript, for example by writing:
6 | import rhinoscriptsyntax as rs
7 | ...and then calling some rhinoscript functions...
8 | line = rs.AddLine((1, 2, 3), (10, 11, 12))
9 | a = line
10 |
11 | How can I use RhinoCommon?
12 | By importing from the Rhino module, for example by writing:
13 | from Rhino.Geometry import Point3d, Line
14 | ...and then assigning some new geometry to the results
15 | a = Line(Point3d(1, 2, 3), Point3d(10, 11, 12))
16 |
17 | What is "ghdoc" and how does it relate to the rhinoscriptsyntax?
18 | The ghdoc variable is provided by the component for better RhinoScript
19 | library support.
20 | This library is imperative, and it is build from a set of
21 | functions that act on geometrical types through one level of indirection:
22 | most of the time, the user does not work with the geometry itself
23 | but with an identifier (Guid) of geometry that is present in a document.
24 | This is exactly what ghdoc is: it is a reference to the document that the RhinoScript
25 | library implicitly targets with all Add__() calls (for example, AddLine()).
26 | The scriptcontext module has a doc variable with the currenly active document,
27 | that can be assigned by you to ghdoc, or RhinoDoc.ActiveDoc, the Rhino document.
28 |
29 |
30 | Is RhinoScript use within GhPython less ideal than RhinoCommon?
31 | While targeting the ghdoc variable, the special Grasshopper document
32 | is used, therefore we can use Grasshopper while leaving the Rhino document unchanged.
33 | This saves uncountable Undo's, and makes it easy to structure ideas
34 | through the Grasshopper definition.
35 | This means that both RhinoCommon or RhinoScript are good in practice.
36 |
37 | Is the rhinoscriptsyntax target irrelevant if using solely RhinoCommon
38 | classes?
39 | Yes. If you create class instances (objects), you will need to create
40 | also your own collection objects to store them (mostly lists, trees). You
41 | can imagine the ghdoc as being an alternative to them, just that you do
42 | not access data by index (number), but by Guid. So you can use the
43 | RhinoScript or the RhinoCommon libraries independently or mix them.
44 | The RhinoScript implementation in Rhino is open-source and is all written
45 | in RhinoCommon. Also the ghdoc implementation is open-source, and is
46 | here.
47 |
48 |
49 | Are there RhinoScript and/or RhinoCommon objects which are not
50 | recognized as valid Grasshopper geometry?
51 | Yes, sure, Grasshopper handles only a portion of all available types.
52 | Basically, unhandled types are all the types that do not exists in the
53 | 'Params' tab.
54 | For example, there is no textdot and no leader. When/if Grasshopper one day
55 | will support these types, these calls will be implemented.
56 |
57 | How do I use DataTree's?
58 | Here
59 | is a small sample.
60 | However, 80% of the times it is not necessary to program for
61 | DataTrees, as the logic itself can be applied per-list and Grasshopper handles
62 | list-iteration.
63 |
64 | Any more tips?
65 | It's probably quite easy to get started, but then you might need to know some more tips to be
66 | proficient. Many tricks have to do with Python (for example, do you know the type() and dir() functions)?
67 | Other might have more to do with the component setup. (There's even a secret ghenv variable).
68 |
69 | Can I ask more questions?
70 | Yes, on the forum...
--------------------------------------------------------------------------------
/Assemblies/PythonInstantiatorProxy.cs:
--------------------------------------------------------------------------------
1 | #if GH_0_9
2 |
3 | using System;
4 | using System.Drawing;
5 | using System.IO;
6 | using System.Reflection;
7 | using System.Security.Cryptography;
8 | using System.Text;
9 | using Grasshopper;
10 | using Grasshopper.Kernel;
11 | using Rhino;
12 |
13 | namespace GhPython.Assemblies
14 | {
15 | class PythonInstantiatorProxy : IGH_ObjectProxy
16 | {
17 | dynamic _operations;
18 | object _pythonType;
19 |
20 | private Bitmap _icon;
21 | private bool _obsolete;
22 | private bool _compliant;
23 | private GH_Exposure _exposure;
24 | private string _location;
25 | private IGH_InstanceDescription _description;
26 |
27 | internal PythonInstantiatorProxy(IGH_DocumentObject obj, object pythonType, dynamic operations, string location)
28 | {
29 | _operations = operations;
30 | _pythonType = pythonType;
31 |
32 | _location = string.Empty;
33 | _description = new GH_InstanceDescription(obj);
34 | Guid = obj.ComponentGuid;
35 | _icon = obj.Icon_24x24;
36 | _exposure = obj.Exposure;
37 | _obsolete = obj.Obsolete;
38 | _compliant = true;
39 | if (obj is IGH_ActiveObject)
40 | {
41 | IGH_ActiveObject actobj = (IGH_ActiveObject)obj;
42 | if (!actobj.SDKCompliancy(RhinoApp.ExeVersion, RhinoApp.ExeServiceRelease))
43 | {
44 | this._compliant = false;
45 | }
46 | }
47 | Type = obj.GetType();
48 | this.LibraryGuid = GH_Convert.StringToGuid(location);
49 | this._location = location;
50 | if (this._location.Length > 0)
51 | {
52 | this._location = this._location.Replace("file:///", string.Empty);
53 | this._location = this._location.Replace("/", Convert.ToString(Path.DirectorySeparatorChar));
54 | }
55 | }
56 |
57 | private PythonInstantiatorProxy() { }
58 |
59 | public string Location
60 | {
61 | get
62 | {
63 | return this._location;
64 | }
65 | }
66 |
67 | public Guid LibraryGuid
68 | {
69 | get;
70 | private set;
71 | }
72 |
73 | public Bitmap Icon
74 | {
75 | get
76 | {
77 | if (this._icon == null && GH_InstanceServer.IsComponentServer)
78 | {
79 | IGH_DocumentObject obj = GH_InstanceServer.ComponentServer.EmitObject(this.Guid);
80 | if (obj != null)
81 | {
82 | this._icon = obj.Icon_24x24;
83 | }
84 | if (this._icon == null)
85 | {
86 | this._icon = Grasshopper.GUI.GH_StandardIcons.BlankObjectIcon_24x24;
87 | }
88 | }
89 | return this._icon;
90 | }
91 | }
92 |
93 | public IGH_InstanceDescription Desc
94 | {
95 | get
96 | {
97 | return this._description;
98 | }
99 | }
100 |
101 | public Type Type
102 | {
103 | get;
104 | private set;
105 | }
106 |
107 | public GH_ObjectType Kind
108 | {
109 | get
110 | {
111 | return GH_ObjectType.CompiledObject;
112 | }
113 | }
114 |
115 | public Guid Guid
116 | {
117 | get;
118 | private set;
119 | }
120 |
121 | public GH_Exposure Exposure
122 | {
123 | get
124 | {
125 | return this._exposure;
126 | }
127 | set
128 | {
129 | this._exposure = value;
130 | }
131 | }
132 |
133 | public bool SDKCompliant
134 | {
135 | get
136 | {
137 | return this._compliant;
138 | }
139 | }
140 |
141 | public bool Obsolete
142 | {
143 | get
144 | {
145 | return this._obsolete;
146 | }
147 | }
148 |
149 | public IGH_ObjectProxy DuplicateProxy()
150 | {
151 | PythonInstantiatorProxy dup = new PythonInstantiatorProxy();
152 | dup._description = new GH_InstanceDescription(this.Desc);
153 | dup.Guid = this.Guid;
154 | dup.Type = this.Type;
155 | dup._location = this.Location;
156 | dup._exposure = this.Exposure;
157 | dup.LibraryGuid = this.LibraryGuid;
158 | dup._compliant = this.SDKCompliant;
159 | dup._obsolete = this.Obsolete;
160 | if (this._icon != null)
161 | {
162 | dup._icon = (Bitmap)this._icon.Clone();
163 | }
164 | return dup;
165 | }
166 |
167 | public IGH_DocumentObject CreateInstance()
168 | {
169 | try
170 | {
171 | object docObject = _operations.Invoke(_pythonType);
172 | if (docObject != null)
173 | {
174 | return (docObject as IGH_DocumentObject);
175 | }
176 | }
177 | catch
178 | {
179 | }
180 | return null;
181 | }
182 | }
183 | }
184 | #endif
--------------------------------------------------------------------------------
/Component/ZUIPythonComponent.cs:
--------------------------------------------------------------------------------
1 | using System.Linq;
2 | using Grasshopper.Kernel;
3 | using Grasshopper.Kernel.Parameters;
4 | using Grasshopper.Kernel.Parameters.Hints;
5 | using System;
6 | using System.Collections.Generic;
7 | using System.Runtime.InteropServices;
8 |
9 | namespace GhPython.Component
10 | {
11 | [Guid("410755B1-224A-4C1E-A407-BF32FB45EA7E")]
12 | public class ZuiPythonComponent : ScriptingAncestorComponent, IGH_VariableParameterComponent
13 | {
14 | protected override void AddDefaultInput(GH_InputParamManager pManager)
15 | {
16 | pManager.AddParameter(CreateParameter(GH_ParameterSide.Input, pManager.ParamCount));
17 | pManager.AddParameter(CreateParameter(GH_ParameterSide.Input, pManager.ParamCount));
18 | }
19 |
20 | protected override void AddDefaultOutput(GH_OutputParamManager pManager)
21 | {
22 | pManager.RegisterParam(CreateParameter(GH_ParameterSide.Output, pManager.ParamCount));
23 | }
24 |
25 | internal override void FixGhInput(Param_ScriptVariable i, bool alsoSetIfNecessary = true)
26 | {
27 | i.Name = i.NickName;
28 |
29 | if (string.IsNullOrEmpty(i.Description))
30 | i.Description = string.Format("Script variable {0}", i.NickName);
31 | i.AllowTreeAccess = true;
32 | i.Optional = true;
33 | i.ShowHints = true;
34 | i.Hints = GetHints();
35 |
36 | if (alsoSetIfNecessary && i.TypeHint == null)
37 | i.TypeHint = i.Hints[1];
38 | }
39 |
40 | static readonly List g_hints = new List();
41 | static List GetHints()
42 | {
43 | lock (g_hints)
44 | {
45 | if (g_hints.Count == 0)
46 | {
47 | g_hints.Add(new NoChangeHint());
48 | g_hints.Add(new GhDocGuidHint());
49 |
50 | g_hints.AddRange(PossibleHints);
51 |
52 | g_hints.RemoveAll(t =>
53 | {
54 | var y = t.GetType();
55 | return (y == typeof (GH_DoubleHint_CS) || y == typeof (GH_StringHint_CS));
56 | });
57 | g_hints.Insert(4, new NewFloatHint());
58 | g_hints.Insert(6, new NewStrHint());
59 |
60 | g_hints.Add(new GH_BoxHint());
61 |
62 | g_hints.Add(new GH_HintSeparator());
63 |
64 | g_hints.Add(new GH_LineHint());
65 | g_hints.Add(new GH_CircleHint());
66 | g_hints.Add(new GH_ArcHint());
67 | g_hints.Add(new GH_PolylineHint());
68 |
69 | g_hints.Add(new GH_HintSeparator());
70 |
71 | g_hints.Add(new GH_CurveHint());
72 | g_hints.Add(new GH_MeshHint());
73 | g_hints.Add(new GH_SurfaceHint());
74 | g_hints.Add(new GH_BrepHint());
75 | g_hints.Add(new GH_GeometryBaseHint());
76 | }
77 | }
78 | return g_hints;
79 | }
80 |
81 | #region IGH_VariableParameterComponent implementation
82 |
83 | public IGH_Param CreateParameter(GH_ParameterSide side, int index)
84 | {
85 | switch (side)
86 | {
87 | case GH_ParameterSide.Input:
88 | {
89 | return new Param_ScriptVariable
90 | {
91 | NickName = GH_ComponentParamServer.InventUniqueNickname("xyzuvwst", this.Params.Input),
92 | Name = NickName,
93 | Description = "Script variable " + NickName,
94 | };
95 | }
96 | case GH_ParameterSide.Output:
97 | {
98 | return new Param_GenericObject
99 | {
100 | NickName = GH_ComponentParamServer.InventUniqueNickname("abcdefghijklmn", this.Params.Output),
101 | Name = NickName,
102 | Description = "Script variable " + NickName,
103 | };
104 | }
105 | default:
106 | {
107 | return null;
108 | }
109 | }
110 | }
111 |
112 | bool IGH_VariableParameterComponent.DestroyParameter(GH_ParameterSide side, int index)
113 | {
114 | if(side == GH_ParameterSide.Input && !HiddenCodeInput && index == 0)
115 | m_inner_codeInput = Code;
116 |
117 | return true;
118 | }
119 |
120 | bool IGH_VariableParameterComponent.CanInsertParameter(GH_ParameterSide side, int index)
121 | {
122 | return index > -1;
123 | }
124 |
125 | bool IGH_VariableParameterComponent.CanRemoveParameter(GH_ParameterSide side, int index)
126 | {
127 | return (this as IGH_VariableParameterComponent).CanInsertParameter(side, index);
128 | }
129 |
130 | public override void VariableParameterMaintenance()
131 | {
132 | foreach (Param_ScriptVariable variable in Params.Input.OfType())
133 | FixGhInput(variable);
134 |
135 | foreach (Param_GenericObject i in Params.Output.OfType())
136 | {
137 | i.Name = i.NickName;
138 | if (string.IsNullOrEmpty(i.Description))
139 | i.Description = i.NickName;
140 | }
141 | }
142 |
143 | protected override void SetScriptTransientGlobals()
144 | {
145 | base.SetScriptTransientGlobals();
146 |
147 | m_py.ScriptContextDoc = g_document;
148 | m_marshal = new NewComponentIOMarshal(g_document, this);
149 | m_py.SetVariable(DOCUMENT_NAME, g_document);
150 | m_py.SetIntellisenseVariable(DOCUMENT_NAME, g_document);
151 | }
152 |
153 | public override Guid ComponentGuid
154 | {
155 | get { return typeof(ZuiPythonComponent).GUID; }
156 | }
157 |
158 | #endregion
159 | }
160 | }
161 |
--------------------------------------------------------------------------------
/Component/PythonEnvironment.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using Grasshopper.Kernel;
3 | using Rhino.Runtime;
4 | using System.Reflection;
5 | using System.Linq;
6 | using System.Collections.Generic;
7 | using System.Collections;
8 |
9 | namespace GhPython.Component
10 | {
11 | public class PythonEnvironment
12 | {
13 | internal const string GHPYTHONLIB_NAME = "ghpythonlib";
14 |
15 | internal PythonEnvironment(GH_Component component, PythonScript script)
16 | {
17 | Component = component;
18 | Script = script;
19 |
20 | if (script != null)
21 | {
22 | Type scriptType = script.GetType();
23 |
24 | var scopeField = scriptType.GetField("m_scope");
25 | if (scopeField != null)
26 | {
27 | LocalScope = scopeField.GetValue(script);
28 | }
29 |
30 | var intellisenseField = scriptType.GetField("m_intellisense",
31 | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
32 | if (intellisenseField != null)
33 | {
34 | Intellisense = intellisenseField.GetValue(script);
35 | if (Intellisense != null)
36 | {
37 | var intellisenseType = Intellisense.GetType();
38 | var scopeProperty = intellisenseType.GetProperty("Scope");
39 | IntellisenseScope = scopeProperty.GetValue(Intellisense, null);
40 | }
41 | }
42 |
43 | var baseType = scriptType.BaseType;
44 | if (baseType != null && baseType != typeof(object))
45 | {
46 | var hostType = baseType.Assembly.GetType("RhinoPython.Host");
47 | if (hostType != null)
48 | {
49 | var engineInfo = hostType.GetProperty("Engine");
50 | if (engineInfo != null)
51 | {
52 | Engine = engineInfo.GetValue(null, null);
53 |
54 | if (Engine != null)
55 | {
56 | var runtimeInfo = Engine.GetType().GetProperty("Runtime");
57 | Runtime = runtimeInfo.GetValue(Engine, null);
58 | }
59 | }
60 |
61 | var scopeInfo = hostType.GetProperty("Scope", BindingFlags.NonPublic |
62 | BindingFlags.GetProperty |
63 | BindingFlags.Static);
64 | if (scopeInfo != null)
65 | ScriptScope = scopeInfo.GetValue(null, null);
66 | }
67 | }
68 | }
69 | }
70 |
71 | public GH_Component Component { get; internal set; }
72 |
73 | public PythonScript Script { get; internal set; }
74 |
75 | public object LocalScope { get; internal set; }
76 |
77 | public object ScriptScope { get; internal set; }
78 |
79 | public object Intellisense { get; internal set; }
80 |
81 | public object IntellisenseScope { get; internal set; }
82 |
83 | public object Engine { get; internal set; }
84 |
85 | public object Runtime { get; internal set; }
86 |
87 | public Version Version { get { return Assembly.GetExecutingAssembly().GetName().Version; } }
88 |
89 | public IGH_DataAccess DataAccessManager { get; internal set; }
90 |
91 | public void LoadAssembly(Assembly assembly)
92 | {
93 | FunctionalityLoad(assembly);
94 |
95 | IList list = GetIntellisenseList();
96 | if (list == null) return;
97 |
98 | foreach (var namesp in GetToplevelNamespacesForAssembly(assembly))
99 | {
100 | if (!list.Contains(namesp))
101 | list.Add(namesp);
102 | }
103 | }
104 |
105 | public void AddGhPythonPackage()
106 | {
107 | IList list = GetIntellisenseList();
108 | if (list == null) return;
109 |
110 | bool contained = false;
111 | for (int i = 0; i < list.Count; i++)
112 | {
113 | var itemString = list[i] as string;
114 | if (itemString == null) continue;
115 |
116 | if (itemString.Equals(GHPYTHONLIB_NAME, StringComparison.InvariantCulture))
117 | contained = true;
118 | }
119 |
120 | // adds package
121 | if (!contained)
122 | list.Add(GHPYTHONLIB_NAME);
123 | }
124 |
125 | private IList GetIntellisenseList()
126 | {
127 | IList list = null;
128 |
129 | // now intellisense
130 | if (IntellisenseScope == null) return list;
131 |
132 | // we really want to get intellisense right away. No matter what
133 | // so, we first make it cache, then add to it
134 |
135 | var intellisense_type = Intellisense.GetType();
136 | var m = intellisense_type.GetMethod("GetModuleList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod);
137 | m.Invoke(Intellisense, null);
138 |
139 | var ex_m_autocomplete_modules = intellisense_type.GetField("m_autocomplete_modules",
140 | BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Instance);
141 |
142 | if (ex_m_autocomplete_modules == null) return list;
143 | return ex_m_autocomplete_modules.GetValue(Intellisense) as IList;
144 | }
145 |
146 | private void FunctionalityLoad(Assembly assembly)
147 | {
148 | var runtime = Runtime as dynamic;
149 | runtime.LoadAssembly(assembly);
150 | }
151 |
152 | private static IEnumerable GetToplevelNamespacesForAssembly(Assembly assembly)
153 | {
154 | return assembly.GetTypes().Select(GetTopLevelNamespace)
155 | .Where(s => !string.IsNullOrEmpty(s)).Distinct();
156 | }
157 |
158 | // question by David here:
159 | // http://stackoverflow.com/questions/1549198/finding-all-namespaces-in-an-assembly-using-reflection-dotnet
160 | static string GetTopLevelNamespace(Type t)
161 | {
162 | string ns = t.Namespace ?? "";
163 | int firstDot = ns.IndexOf('.');
164 | return firstDot == -1 ? ns : ns.Substring(0, firstDot);
165 | }
166 | }
167 | }
168 |
--------------------------------------------------------------------------------
/Component/SpecialHints/AllNewHints.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using Grasshopper.Kernel.Parameters;
3 | using Grasshopper.Kernel.Parameters.Hints;
4 | using Rhino.Geometry;
5 | using System.Collections.Generic;
6 | using System.Runtime.InteropServices;
7 |
8 | namespace GhPython.Component
9 | {
10 | [Guid("39FBC626-7A01-46AB-A18E-EC1C0C41685B")]
11 | public class NewFloatHint : GH_DoubleHint_CS, IGH_TypeHint
12 | {
13 | Guid IGH_TypeHint.HintID { get { return this.GetType().GUID; } }
14 |
15 | string IGH_TypeHint.TypeName { get { return "float"; } }
16 | }
17 |
18 | [Guid("37261734-EEC7-4F50-B6A8-B8D1F3C4396B")]
19 | public class NewStrHint : GH_StringHint_CS, IGH_TypeHint
20 | {
21 | Guid IGH_TypeHint.HintID { get { return this.GetType().GUID; } }
22 |
23 | string IGH_TypeHint.TypeName { get { return "str"; } }
24 | }
25 |
26 | [Guid("87F87F55-5B71-41F4-8AEA-21D494016F81")]
27 | public class GhDocGuidHint : GH_NullHint, IGH_TypeHint
28 | {
29 | Guid IGH_TypeHint.HintID { get { return this.GetType().GUID; } }
30 | bool IGH_TypeHint.Cast(object data, out object target)
31 | {
32 | bool toReturn = base.Cast(data, out target);
33 |
34 | if (toReturn && target != null)
35 | {
36 | Type t = target.GetType();
37 |
38 | if (t == typeof(Line))
39 | target = new LineCurve((Line)target);
40 |
41 | else if (t == typeof(Arc))
42 | target = new ArcCurve((Arc)target);
43 |
44 | else if (t == typeof(Circle))
45 | target = new ArcCurve((Circle)target);
46 |
47 | else if (t == typeof(Ellipse))
48 | target = ((Ellipse)target).ToNurbsCurve();
49 |
50 | else if (t == typeof(Box))
51 | target = Brep.CreateFromBox((Box)target);
52 |
53 | else if (t == typeof(BoundingBox))
54 | target = Brep.CreateFromBox((BoundingBox)target);
55 |
56 | else if (t == typeof(Rectangle3d))
57 | target = ((Rectangle3d)target).ToNurbsCurve();
58 |
59 | else if (target is Polyline)
60 | target = new PolylineCurve((Polyline)target);
61 | }
62 |
63 | return toReturn;
64 | }
65 |
66 | string IGH_TypeHint.TypeName { get { return "ghdoc Object when geometry (rhinoscriptsyntax)"; } }
67 | }
68 |
69 | [Guid("35915213-5534-4277-81B8-1BDC9E7383D2")]
70 | public class NoChangeHint : GH_NullHint, IGH_TypeHint
71 | {
72 | Guid IGH_TypeHint.HintID { get { return this.GetType().GUID; } }
73 |
74 | string IGH_TypeHint.TypeName { get { return "No Type Hint"; } }
75 | }
76 |
77 |
78 | static class PythonHints
79 | {
80 | static readonly Dictionary _new_marshallings = new Dictionary {
81 | { typeof(NewFloatHint).GUID, new NewFloatHint() },
82 | { typeof(NewStrHint).GUID, new NewStrHint() },
83 | { typeof(NoChangeHint).GUID, new NoChangeHint() },
84 | { typeof(GhDocGuidHint).GUID, new GhDocGuidHint() },
85 | };
86 |
87 |
88 | static readonly Dictionary _old_to_rs = new Dictionary {
89 | { typeof(GH_DoubleHint_CS), typeof(NewFloatHint).GUID },
90 |
91 | { typeof(GH_NullHint), typeof(GhDocGuidHint).GUID },
92 | { typeof(DynamicHint), typeof(GhDocGuidHint).GUID },
93 |
94 | { typeof(GH_Point3dHint), typeof(GhDocGuidHint).GUID },
95 |
96 | { typeof(GH_ArcHint), typeof(GhDocGuidHint).GUID },
97 | { typeof(SpecialArcHint), typeof(GhDocGuidHint).GUID },
98 |
99 | { typeof(GH_BoxHint), typeof(GhDocGuidHint).GUID },
100 | { typeof(SpecialBoxHint), typeof(GhDocGuidHint).GUID },
101 |
102 | { typeof(GH_CircleHint), typeof(GhDocGuidHint).GUID },
103 | { typeof(SpecialCircleHint), typeof(GhDocGuidHint).GUID },
104 |
105 | { typeof(GH_LineHint), typeof(GhDocGuidHint).GUID },
106 | { typeof(SpecialLineHint), typeof(GhDocGuidHint).GUID },
107 |
108 | { typeof(GH_PolylineHint), typeof(GhDocGuidHint).GUID },
109 | { typeof(SpecialPolylineHint), typeof(GhDocGuidHint).GUID },
110 |
111 | { typeof(GH_CurveHint), typeof(GhDocGuidHint).GUID },
112 | { typeof(GH_SurfaceHint), typeof(GhDocGuidHint).GUID },
113 | { typeof(GH_MeshHint), typeof(GhDocGuidHint).GUID },
114 | { typeof(GH_BrepHint), typeof(GhDocGuidHint).GUID },
115 | { typeof(GH_GeometryBaseHint), typeof(GhDocGuidHint).GUID },
116 | };
117 |
118 | static readonly Dictionary _old_to_common = new Dictionary {
119 | { typeof(GH_DoubleHint_CS), typeof(NewFloatHint) },
120 |
121 | { typeof(GH_NullHint), typeof(NoChangeHint) },
122 | { typeof(DynamicHint), typeof(NoChangeHint) },
123 |
124 | { typeof(SpecialArcHint), typeof(GH_ArcHint) },
125 | { typeof(SpecialBoxHint), typeof(GH_BoxHint) },
126 | { typeof(SpecialCircleHint), typeof(GH_CircleHint) },
127 | { typeof(SpecialLineHint), typeof(GH_LineHint) },
128 | { typeof(SpecialPolylineHint), typeof(GH_PolylineHint) },
129 | };
130 |
131 |
132 | public static bool ToNewRhinoscriptHint(IGH_TypeHint probe, out IGH_TypeHint newHint)
133 | {
134 | newHint = null;
135 | if (probe == null) return false;
136 |
137 | var probeType = probe.GetType();
138 |
139 | if (_old_to_rs.ContainsKey(probeType))
140 | {
141 | newHint = _new_marshallings[_old_to_rs[probeType]];
142 | return true;
143 | }
144 | return false;
145 | }
146 |
147 | public static void ToNewRhinoCommonHint(Param_ScriptVariable sc)
148 | {
149 | if (sc == null || sc.TypeHint == null) return;
150 |
151 | Type probeType = sc.TypeHint.GetType();
152 |
153 | if (_old_to_common.ContainsKey(probeType))
154 | {
155 | var type = _old_to_common[probeType];
156 | if (type != null)
157 | sc.TypeHint = System.Activator.CreateInstance(type) as IGH_TypeHint;
158 | }
159 | }
160 | }
161 | }
--------------------------------------------------------------------------------
/Component/SafeComponent.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Diagnostics;
3 | using Grasshopper;
4 | using Grasshopper.Kernel;
5 | using System.Windows.Forms;
6 |
7 | namespace GhPython.Component
8 | {
9 | ///
10 | /// This is an abstract class which automatically calls its own destructor when the user deletes it or
11 | /// closes the document. It handles most cases well, and relies on the GC for any other case. Please use the standard constructor
12 | /// if you need to execute something also when the assembly loads, and the Initialize() method to setup any single component
13 | /// when it first lands and executes on the canvas. Remember to call base.Dispose(disposing) if you override Dispose(bool).
14 | ///
15 | public abstract class SafeComponent : GH_Component, IDisposable
16 | {
17 | GH_Document m_doc;
18 |
19 | bool m_initializationDone;
20 | bool m_orphan;
21 | bool m_locked;
22 | bool m_afterDisposal;
23 |
24 | ///
25 | /// Do not use this constructor for initialization, but always use the Initialize() method, which will run only once.
26 | /// This constructor is called more times at startup for indexing the picture and some other external reasons.
27 | ///
28 | protected SafeComponent(string name, string abbreviation, string description, string category, string subCategory) :
29 | base(name, abbreviation, description, category, subCategory)
30 | {
31 | if (Instances.DocumentServer.DocumentCount > 0)
32 | {
33 | m_doc = Instances.DocumentServer[0];
34 |
35 | CheckIfSetupActionsAreNecessary();
36 | }
37 | }
38 |
39 | protected GH_Document Doc
40 | {
41 | get
42 | {
43 | CheckIfSetupActionsAreNecessary();
44 | return m_doc;
45 | }
46 | }
47 |
48 | public void CheckIfSetupActionsAreNecessary()
49 | {
50 | if (m_afterDisposal) return;
51 |
52 | if (m_orphan)
53 | {
54 | m_orphan = false;
55 | GC.ReRegisterForFinalize(this);
56 | }
57 |
58 | if (!m_initializationDone)
59 | {
60 | if (m_doc == null)
61 | {
62 | m_doc = OnPingDocument();
63 |
64 | if (m_doc == null) return;
65 | }
66 |
67 | m_doc.ObjectsDeleted += GrasshopperObjectsDeleted;
68 | Instances.DocumentServer.DocumentRemoved += GrasshopperDocumentClosed;
69 | m_doc.SolutionStart += AfterDocumentChanged;
70 |
71 | m_initializationDone = true;
72 | Initialize();
73 | }
74 | }
75 |
76 | protected sealed override void SolveInstance(IGH_DataAccess DA)
77 | {
78 | CheckIfSetupActionsAreNecessary();
79 | SafeSolveInstance(DA);
80 | }
81 |
82 | protected abstract void SafeSolveInstance(IGH_DataAccess da);
83 |
84 | private void GrasshopperDocumentClosed(GH_DocumentServer sender, GH_Document doc)
85 | {
86 | if (doc != null && (m_doc != null && doc.DocumentID == m_doc.DocumentID))
87 | {
88 | Dispose();
89 | }
90 | }
91 |
92 | private void GrasshopperObjectsDeleted(object sender, GH_DocObjectEventArgs e)
93 | {
94 | if (e != null && e.Attributes != null)
95 | {
96 | for (int i = 0; i < e.ObjectCount; i++)
97 | {
98 | if (e.Attributes[i] != null && e.Attributes[i].InstanceGuid == this.InstanceGuid)
99 | {
100 | Dispose();
101 | }
102 | Debug.Assert(e.Attributes[i] != null, "e.Attributes[i] is null");
103 | }
104 | }
105 | Debug.Assert(e != null && e.Attributes != null, "e or e.Attributes is null");
106 | }
107 |
108 | void AfterDocumentChanged(object sender, GH_SolutionEventArgs args)
109 | {
110 |
111 | if (this.Locked != m_locked)
112 | {
113 | m_locked = this.Locked;
114 | OnLockedChanged(m_locked);
115 | }
116 | }
117 |
118 | protected virtual void OnLockedChanged(bool nowIsLocked)
119 | {
120 | }
121 |
122 | private void DeregisterComponent()
123 | {
124 | if (m_doc != null && m_initializationDone)
125 | {
126 | m_doc.ObjectsDeleted -= GrasshopperObjectsDeleted;
127 |
128 | if (Instances.DocumentServer != null)
129 | Instances.DocumentServer.DocumentRemoved -= GrasshopperDocumentClosed;
130 |
131 | m_doc.SolutionStart -= AfterDocumentChanged;
132 | }
133 | }
134 |
135 | public override void RemovedFromDocument(GH_Document document)
136 | {
137 | base.RemovedFromDocument(document);
138 |
139 | Dispose();
140 | }
141 |
142 | ///
143 | /// Initializes the component when it first executes and at no other earlier or later time. It runs once for each component
144 | ///
145 | protected virtual void Initialize()
146 | {
147 | }
148 |
149 | ///
150 | /// If you override this, be very sure you always call base.Dispose(disposing) or MyBase.Dispose(disposing) in
151 | /// Vb.Net from within your code.
152 | ///
153 | /// If disposing equals false, the method has been called by the
154 | /// runtime from inside the finalizer and you should not reference other objects. Only unmanaged resources
155 | /// can be disposed.
156 | protected virtual void Dispose(bool disposing)
157 | {
158 | m_afterDisposal = true;
159 | try
160 | {
161 | if (!m_orphan)
162 | {
163 | DeregisterComponent();
164 | m_orphan = true;
165 | m_initializationDone = false;
166 |
167 | if (disposing)
168 | {
169 | GC.SuppressFinalize(this);
170 | }
171 | }
172 | }
173 | catch (Exception ex)
174 | {
175 | GhPython.Forms.PythonScriptForm.LastHandleException(ex);
176 | }
177 | }
178 |
179 | ///
180 | /// The IDisposable implementation. You do not normally need to call this. The creator of this object will call it.
181 | ///
182 | public void Dispose()
183 | {
184 | m_afterDisposal = true;
185 | Dispose(true);
186 | }
187 |
188 | ~SafeComponent()
189 | {
190 | Dispose(false);
191 | }
192 | }
193 | }
--------------------------------------------------------------------------------
/package/components.py:
--------------------------------------------------------------------------------
1 | import clr
2 | clr.AddReference("Grasshopper")
3 | import Grasshopper as GH
4 |
5 | experimental_mode = False
6 |
7 | def __make_function__(helper):
8 | def component_function(*args, **kwargs):
9 | if experimental_mode:
10 | success, fastdata = helper.runfast(args, kwargs)
11 | if success: return fastdata
12 |
13 | comp = helper.proxy.CreateInstance()
14 | comp.ClearData()
15 | if args:
16 | for i, arg in enumerate(args):
17 | if arg is None: continue
18 | param = comp.Params.Input[i]
19 | param.PersistentData.Clear()
20 | if hasattr(arg, '__iter__'): #TODO deal with polyline, str
21 | [param.AddPersistentData(a) for a in arg]
22 | else:
23 | param.AddPersistentData(arg)
24 | if kwargs:
25 | for param in comp.Params.Input:
26 | name = param.Name.lower()
27 | if name in kwargs:
28 | param.PersistentData.Clear()
29 | arg = kwargs[name]
30 | if hasattr(arg, '__iter__'): #TODO deal with polyline, str
31 | [param.AddPersistentData(a) for a in arg]
32 | else:
33 | param.AddPersistentData(arg)
34 | doc = GH.Kernel.GH_Document()
35 | doc.AddObject(comp, False, 0)
36 | comp.CollectData()
37 | comp.ComputeData()
38 | output = helper.create_output(comp.Params)
39 | comp.ClearData()
40 | doc.Dispose()
41 | return output
42 | return component_function
43 |
44 |
45 | class namespace_object(object):
46 | def __init__(self):
47 | pass
48 |
49 |
50 | class function_helper(object):
51 | def __init__(self, proxy, name):
52 | self.proxy = proxy
53 | # obviosly hand picking components won't work for the long run, but this
54 | # lets me experiment with a small set to figure out the issues involved
55 | fast_components = ("MeshXRay", "Vector2Pt", "Line", "CurveClosestPoint")
56 | self.supports_fast = name in fast_components
57 | self.fast_component = None
58 | self.return_type = None
59 |
60 | def create_output(self, params, output_values=None):
61 | from collections import namedtuple
62 | if not output_values:
63 | output_values = []
64 | for output in params.Output:
65 | data = output.VolatileData.AllData(True)
66 | #We could call Value, but ScriptVariable seems to do a better job
67 | v = [x.ScriptVariable() for x in data]
68 | if len(v)<1:
69 | output_values.append(None)
70 | elif len(v)==1:
71 | output_values.append(v[0])
72 | else:
73 | output_values.append(v)
74 | if len(output_values)==1: return output_values[0]
75 | if self.return_type is None:
76 | names = [output.Name.lower() for output in params.Output]
77 | try:
78 | self.return_type = namedtuple('Output', names, rename=True)
79 | except:
80 | self.return_type = False
81 | if not self.return_type: return output_values
82 | return self.return_type(*output_values)
83 |
84 | def runfast(self, args, kwargs):
85 | if not self.supports_fast: return False, None
86 | if self.fast_component == None:
87 | self.fast_component = self.proxy.CreateInstance()
88 | import GhPython
89 | output = GhPython.ScriptHelpers.FastComponent.Run(self.fast_component, args, kwargs)
90 | if output:
91 | if len(output[0])==1:
92 | output = [a[0] for a in output]
93 | output = self.create_output(self.fast_component.Params, output)
94 | return True, output
95 |
96 |
97 | def __build_module():
98 | def function_description(description, params):
99 | rc = ['',description, "Input:"]
100 | for param in params.Input:
101 | s = "\t{0} [{1}] - {2}"
102 | if param.Optional:
103 | s = "\t{0} (in, optional) [{1}] - {2}"
104 | rc.append(s.format(param.Name.lower(), param.TypeName, param.Description))
105 | if params.Output.Count == 1:
106 | param = params.Output[0]
107 | rc.append("Returns: [{0}] - {1}".format(param.TypeName, param.Description))
108 | elif params.Output.Count > 1:
109 | rc.append("Returns:")
110 | for out in params.Output:
111 | s = "\t{0} [{1}] - {2}"
112 | rc.append(s.format(out.Name.lower(), out.TypeName, out.Description))
113 | return '\n'.join(rc)
114 |
115 | import sys, types, re
116 | core_module = sys.modules['ghpythonlib.components']
117 | translate_from = u"|+-*\u2070\u00B9\u00B2\u00B3\u2074\u2075\u2076\u2077\u2078\u2079"
118 | translate_to = "X__x0123456789"
119 | transl = dict(zip(translate_from, translate_to))
120 | for obj in GH.Instances.ComponentServer.ObjectProxies:
121 | if obj.Exposure == GH.Kernel.GH_Exposure.hidden or obj.Obsolete:
122 | continue
123 | t = clr.GetClrType(GH.Kernel.IGH_Component)
124 | if not (t.IsAssignableFrom(obj.Type)):
125 | continue
126 | m = core_module
127 | library_id = obj.LibraryGuid
128 | assembly = GH.Instances.ComponentServer.FindAssembly(library_id)
129 | if assembly is None: continue
130 | if not assembly.IsCoreLibrary:
131 | module_name = assembly.Assembly.GetName().Name.split('.', 1)[0]
132 | if module_name.upper().startswith("GH_"): module_name = module_name[3:]
133 | if module_name in core_module.__dict__:
134 | m = core_module.__dict__[module_name]
135 | else:
136 | m = namespace_object()
137 | setattr(core_module, module_name, m)
138 | name = obj.Desc.Name
139 | if "LEGACY" in name or "#" in name: continue
140 | name = re.sub("[^a-zA-Z0-9]", lambda match: transl[match.group()] if (match.group() in transl) else '', name)
141 | if not name[0].isalpha(): name = 'x' + name
142 | function = __make_function__(function_helper(obj, name))
143 | setattr(m, name, function)
144 | comp = obj.CreateInstance()
145 | a = m.__dict__[name]
146 | a.__name__ = name
147 | a.__doc__ = function_description(obj.Desc.Description, comp.Params)
148 |
149 |
150 | __build_module()
--------------------------------------------------------------------------------
/Properties/Resources.Designer.cs:
--------------------------------------------------------------------------------
1 | //------------------------------------------------------------------------------
2 | //
3 | // This code was generated by a tool.
4 | // Runtime Version:4.0.30319.269
5 | //
6 | // Changes to this file may cause incorrect behavior and will be lost if
7 | // the code is regenerated.
8 | //
9 | //------------------------------------------------------------------------------
10 |
11 | namespace GhPython.Properties {
12 | using System;
13 |
14 |
15 | ///
16 | /// A strongly-typed resource class, for looking up localized strings, etc.
17 | ///
18 | // This class was auto-generated by the StronglyTypedResourceBuilder
19 | // class via a tool like ResGen or Visual Studio.
20 | // To add or remove a member, edit your .ResX file then rerun ResGen
21 | // with the /str option, or rebuild your VS project.
22 | [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
23 | [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 | [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 | internal class Resources {
26 |
27 | private static global::System.Resources.ResourceManager resourceMan;
28 |
29 | private static global::System.Globalization.CultureInfo resourceCulture;
30 |
31 | [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 | internal Resources() {
33 | }
34 |
35 | ///
36 | /// Returns the cached ResourceManager instance used by this class.
37 | ///
38 | [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 | internal static global::System.Resources.ResourceManager ResourceManager {
40 | get {
41 | if (object.ReferenceEquals(resourceMan, null)) {
42 | global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("GhPython.Properties.Resources", typeof(Resources).Assembly);
43 | resourceMan = temp;
44 | }
45 | return resourceMan;
46 | }
47 | }
48 |
49 | ///
50 | /// Overrides the current thread's CurrentUICulture property for all
51 | /// resource lookups using this strongly typed resource class.
52 | ///
53 | [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 | internal static global::System.Globalization.CultureInfo Culture {
55 | get {
56 | return resourceCulture;
57 | }
58 | set {
59 | resourceCulture = value;
60 | }
61 | }
62 |
63 | internal static System.Drawing.Bitmap _checked {
64 | get {
65 | object obj = ResourceManager.GetObject("_checked", resourceCulture);
66 | return ((System.Drawing.Bitmap)(obj));
67 | }
68 | }
69 |
70 | internal static System.Drawing.Bitmap _unchecked {
71 | get {
72 | object obj = ResourceManager.GetObject("_unchecked", resourceCulture);
73 | return ((System.Drawing.Bitmap)(obj));
74 | }
75 | }
76 |
77 | ///
78 | /// Looks up a localized string similar to <p>This component allows to use both RhinoCommon and RhinoScript from within
79 | ///Grasshopper. Here some Q&As.</p>
80 | ///
81 | ///<p><b>How can I use RhinoCommon?</b></p>
82 | ///<p>By importing from the Rhino module, for example by writing:</p>
83 | ///<pre style="font-size: smaller">from Rhino.Geometry import Point3d, Line</pre>
84 | ///<p>...and then assigning some new geometry to the results</p>
85 | ///<pre style="font-size: smaller">a = Line(Point3d(1, 2, 3), Point3d(10, 11, 12))</pre>
86 | ///
87 | ///<p><b>How can I use RhinoScript?</b></p>
88 | ///<p>By impo [rest of string was truncated]";.
89 | ///
90 | internal static string helpText {
91 | get {
92 | return ResourceManager.GetString("helpText", resourceCulture);
93 | }
94 | }
95 |
96 | internal static System.Drawing.Bitmap python {
97 | get {
98 | object obj = ResourceManager.GetObject("python", resourceCulture);
99 | return ((System.Drawing.Bitmap)(obj));
100 | }
101 | }
102 |
103 | ///
104 | /// Looks up a localized string similar to import Rhino.Geometry as rg
105 | ///import math
106 | ///
107 | ///def Main():
108 | /// global result
109 | /// result = []
110 | /// SubdivideAndRotate(line, 0, result)
111 | ///
112 | ///def WeightedAvaragePts(pt1, pt2, pt1_part):
113 | /// rest = 1 - pt1_part
114 | /// return pt1 * rest + pt2 * pt1_part
115 | ///
116 | ///def SubdivideAndRotate(line, level, allLines):
117 | /// if level == maxLevel:
118 | /// allLines.append(line)
119 | /// return
120 | ///
121 | /// a = line.First #rg.Polyline
122 | /// d = line.Last
123 | /// b = WeightedAvaragePts(a, d, 1.0 / 3.0)
124 | /// c = WeightedAvaragePts(a, d, 2.0 / [rest of string was truncated]";.
125 | ///
126 | internal static string sampleCommon {
127 | get {
128 | return ResourceManager.GetString("sampleCommon", resourceCulture);
129 | }
130 | }
131 |
132 | ///
133 | /// Looks up a localized string similar to # sample script to show how to use this component and the rhinoscriptsyntax
134 | ///'''Constructs a sinusoidal series of circles.
135 | /// Inputs:
136 | /// x: The number of circles. (integer)
137 | /// y: The radius of each circle. (float)
138 | /// Outputs:
139 | /// a: The list of circles. (list of circle)
140 | /// b: The list of radii. (list of float)
141 | ///'''
142 | ///import math
143 | ///import rhinoscriptsyntax as rs
144 | ///
145 | ///if x is None:
146 | /// x = 24 # if nothing is connected to x, set x to something (24).
147 | ///if y is None:
148 | /// y = 0.3 # i [rest of string was truncated]";.
149 | ///
150 | internal static string sampleScript {
151 | get {
152 | return ResourceManager.GetString("sampleScript", resourceCulture);
153 | }
154 | }
155 | }
156 | }
157 |
--------------------------------------------------------------------------------
/Properties/Resources.resx:
--------------------------------------------------------------------------------
1 |
2 |
3 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 | text/microsoft-resx
110 |
111 |
112 | 2.0
113 |
114 |
115 | System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
116 |
117 |
118 | System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
119 |
120 |
121 |
122 | ..\images\python.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
123 |
124 |
125 | ..\images\checked.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
126 |
127 |
128 | ..\images\unchecked.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
129 |
130 |
131 | ..\samples\samplescript.py;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8
132 |
133 |
134 | ..\Samples\helpText.html;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8
135 |
136 |
137 | ..\Samples\sampleCommon.py;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8
138 |
139 |
--------------------------------------------------------------------------------
/ScriptHelpers/GhPyDataAccess.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using Grasshopper.Kernel;
4 |
5 | namespace GhPython.ScriptHelpers
6 | {
7 | // See GH_StructureIterator in grasshopper for real implementation
8 | class GhPyDataAccess : IGH_DataAccess
9 | {
10 | readonly GH_Component m_component;
11 | readonly object[] m_output;
12 | readonly IList