515 lines
25 KiB
HTML
515 lines
25 KiB
HTML
<html><head><title>Scripted objects/fr</title><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><link type='text/css' href='wiki.css' rel='stylesheet'></head><body><h1>Scripted objects/fr</h1></div>
|
|
|
|
<div id="mw-content-text" lang="fr" dir="ltr" class="mw-content-ltr"><hr/><div class="mw-parser-output"><p>Outre les types d'objets standards tels que les annotations, les mailles et les objets Parts, FreeCAD offre également la possibilité incroyable d'écrire des scripts d'objets 100% Python. Ces "objets" se comporteront exactement comme n'importe quels autres objets dans FreeCAD, et sont, sauvegardés et restaurés automatiquement dans le répertoire de chargement/sauvegarde.
|
|
</p><p>Une particularité doit être comprise, ces objets sont enregistrés dans des fichiers <b>FreeCAD FcStd'<i> avec le module Python </i><a rel="nofollow" class="external text" href="http://docs.python.org/2/library/json.html">json</a> </b>. Ce module transforme un objet (code) Python en une chaîne de caractères (texte), lui permettant d'être ajouté au fichier sauvegardé. Une fois chargé, le module <b>json</b> utilise cette chaîne pour recréer l'objet d'origine, à condition qu'il ait accès au code source qui l'a créé. Cela signifie que si vous enregistrez un tel objet personnalisé et l'ouvrez sur une machine où le code source Python qui a créé l'objet n'est pas présent, l'objet ne sera pas recréé.<br />
|
|
<b>Si vous distribuez ces scripts à d'autres, vous devrez aussi distribuer l'ensemble du script Python qui l'a créé.</b>
|
|
</p><p>Les fonctionnalités de Python suivent les mêmes règles que toutes les fonctionnalités de FreeCAD: ils sont séparés en plusieurs parties celle <b>App (application)</b> et <b>GUI parts (interface graphique)</b>.<br />
|
|
La partie <b>Object App</b> (application), définit la forme géométrique de notre objet, tandis que la <b>partie graphique</b> (GUI), définit la façon dont l'objet sera affiché à l'écran.<br />
|
|
L'outil <b>View Provider Object</b> (créateur de vue), comme toutes les fonctions FreeCAD, n'est disponible que lorsque vous exécutez FreeCAD dans son interface (GUI).<br /><br />
|
|
Il ya plusieurs manières et méthodes disponibles pour créer votre projet. Les méthodes utilisées doivent êtres une des méthodes prédéfinies que vous fourni FreeCAD, et apparaîtra dans la fenêtre <b>Propriété</b>, afin qu'ils puissent être modifiés par l'utilisateur (onglet <b>Données</b>).<br />
|
|
De cette manière, les objets sont <b>FeaturePython</b> (ont toutes les propriétés de Python) et sont totalements paramétriques.<br />
|
|
Vous pouvez paramétrer les <b>propriétés</b> et l'affichage <b>ViewObject</b> de l'objet séparément.
|
|
</p><p><b> Astuce:</b> dans les versions antérieures, nous avons utilisé le module Python <a rel="nofollow" class="external text" href="http://docs.python.org/release/2.5/lib/module-cPickle.html">cPickle</a>. Cependant, ce module exécute du code arbitrairement et provoque ainsi des problèmes de sécurité. Alors, nous avons opté pour le module Python json.
|
|
</p>
|
|
<div id="toc" class="toc"><div class="toctitle"><h2>Contents</h2></div>
|
|
<ul>
|
|
<li class="toclevel-1 tocsection-1"><a href="#Exemples_de_base"><span class="tocnumber">1</span> <span class="toctext">Exemples de base</span></a></li>
|
|
<li class="toclevel-1 tocsection-2"><a href="#Propri.C3.A9t.C3.A9s_disponibles"><span class="tocnumber">2</span> <span class="toctext">Propriétés disponibles</span></a></li>
|
|
<li class="toclevel-1 tocsection-3"><a href="#Property_Type"><span class="tocnumber">3</span> <span class="toctext">Property Type</span></a></li>
|
|
<li class="toclevel-1 tocsection-4"><a href="#Autres_exemples_plus_complexes"><span class="tocnumber">4</span> <span class="toctext">Autres exemples plus complexes</span></a></li>
|
|
<li class="toclevel-1 tocsection-5"><a href="#Cr.C3.A9ation_d.27objets_s.C3.A9lectionnables"><span class="tocnumber">5</span> <span class="toctext">Création d'objets sélectionnables</span></a></li>
|
|
<li class="toclevel-1 tocsection-6"><a href="#Travailler_avec_des_formes_simples"><span class="tocnumber">6</span> <span class="toctext">Travailler avec des formes simples</span></a></li>
|
|
<li class="toclevel-1 tocsection-7"><a href="#Recherche_d.27informations"><span class="tocnumber">7</span> <span class="toctext">Recherche d'informations</span></a></li>
|
|
</ul>
|
|
</div>
|
|
|
|
<h2><span class="mw-headline" id="Exemples_de_base">Exemples de base</span></h2>
|
|
<p>L'exemple suivant (portion) peut être trouvé sur la page, <a rel="nofollow" class="external text" href="https://github.com/FreeCAD/FreeCAD/blob/master/src/Mod/TemplatePyMod/FeaturePython.py">src/Mod/TemplatePyMod/FeaturePython.py</a> qui inclus beaucoup d'autres exemples:
|
|
</p>
|
|
<pre>'''Examples for a feature class and its view provider.'''
|
|
|
|
import FreeCAD, FreeCADGui
|
|
from pivy import coin
|
|
|
|
class Box:
|
|
def __init__(self, obj):
|
|
'''Add some custom properties to our box feature'''
|
|
obj.addProperty("App::PropertyLength","Length","Box","Length of the box").Length=1.0
|
|
obj.addProperty("App::PropertyLength","Width","Box","Width of the box").Width=1.0
|
|
obj.addProperty("App::PropertyLength","Height","Box", "Height of the box").Height=1.0
|
|
obj.Proxy = self
|
|
|
|
def onChanged(self, fp, prop):
|
|
'''Do something when a property has changed'''
|
|
FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
|
|
|
|
def execute(self, fp):
|
|
'''Do something when doing a recomputation, this method is mandatory'''
|
|
FreeCAD.Console.PrintMessage("Recompute Python Box feature\n")
|
|
|
|
class ViewProviderBox:
|
|
def __init__(self, obj):
|
|
'''Set this object to the proxy object of the actual view provider'''
|
|
obj.addProperty("App::PropertyColor","Color","Box","Color of the box").Color=(1.0,0.0,0.0)
|
|
obj.Proxy = self
|
|
|
|
def attach(self, obj):
|
|
'''Setup the scene sub-graph of the view provider, this method is mandatory'''
|
|
self.shaded = coin.SoGroup()
|
|
self.wireframe = coin.SoGroup()
|
|
self.scale = coin.SoScale()
|
|
self.color = coin.SoBaseColor()
|
|
|
|
data=coin.SoCube()
|
|
self.shaded.addChild(self.scale)
|
|
self.shaded.addChild(self.color)
|
|
self.shaded.addChild(data)
|
|
obj.addDisplayMode(self.shaded,"Shaded");
|
|
style=coin.SoDrawStyle()
|
|
style.style = coin.SoDrawStyle.LINES
|
|
self.wireframe.addChild(style)
|
|
self.wireframe.addChild(self.scale)
|
|
self.wireframe.addChild(self.color)
|
|
self.wireframe.addChild(data)
|
|
obj.addDisplayMode(self.wireframe,"Wireframe");
|
|
self.onChanged(obj,"Color")
|
|
|
|
def updateData(self, fp, prop):
|
|
'''If a property of the handled feature has changed we have the chance to handle this here'''
|
|
# fp is the handled feature, prop is the name of the property that has changed
|
|
l = fp.getPropertyByName("Length")
|
|
w = fp.getPropertyByName("Width")
|
|
h = fp.getPropertyByName("Height")
|
|
self.scale.scaleFactor.setValue(float(l),float(w),float(h))
|
|
pass
|
|
|
|
def getDisplayModes(self,obj):
|
|
'''Return a list of display modes.'''
|
|
modes=[]
|
|
modes.append("Shaded")
|
|
modes.append("Wireframe")
|
|
return modes
|
|
|
|
def getDefaultDisplayMode(self):
|
|
'''Return the name of the default display mode. It must be defined in getDisplayModes.'''
|
|
return "Shaded"
|
|
|
|
def setDisplayMode(self,mode):
|
|
'''Map the display mode defined in attach with those defined in getDisplayModes.\
|
|
Since they have the same names nothing needs to be done. This method is optional'''
|
|
return mode
|
|
|
|
def onChanged(self, vp, prop):
|
|
'''Here we can do something when a single property got changed'''
|
|
FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
|
|
if prop == "Color":
|
|
c = vp.getPropertyByName("Color")
|
|
self.color.rgb.setValue(c[0],c[1],c[2])
|
|
|
|
def getIcon(self):
|
|
'''Return the icon in XPM format which will appear in the tree view. This method is\
|
|
optional and if not defined a default icon is shown.'''
|
|
return """
|
|
/* XPM */
|
|
static const char * ViewProviderBox_xpm[] = {
|
|
"16 16 6 1",
|
|
" c None",
|
|
". c #141010",
|
|
"+ c #615BD2",
|
|
"@ c #C39D55",
|
|
"# c #000000",
|
|
"$ c #57C355",
|
|
" ........",
|
|
" ......++..+..",
|
|
" .@@@@.++..++.",
|
|
" .@@@@.++..++.",
|
|
" .@@ .++++++.",
|
|
" ..@@ .++..++.",
|
|
"###@@@@ .++..++.",
|
|
"##$.@@$#.++++++.",
|
|
"#$#$.$$$........",
|
|
"#$$####### ",
|
|
"#$$#$$$$$# ",
|
|
"#$$#$$$$$# ",
|
|
"#$$#$$$$$# ",
|
|
" #$#$$$$$# ",
|
|
" ##$$$$$# ",
|
|
" ####### "};
|
|
"""
|
|
|
|
def __getstate__(self):
|
|
'''When saving the document this object gets stored using Python's json module.\
|
|
Since we have some un-serializable parts here -- the Coin stuff -- we must define this method\
|
|
to return a tuple of all serializable objects or None.'''
|
|
return None
|
|
|
|
def __setstate__(self,state):
|
|
'''When restoring the serialized object from document we have the chance to set some internals here.\
|
|
Since no data were serialized nothing needs to be done here.'''
|
|
return None
|
|
|
|
|
|
def makeBox():
|
|
FreeCAD.newDocument()
|
|
a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Box")
|
|
Box(a)
|
|
ViewProviderBox(a.ViewObject)
|
|
|
|
makeBox() </pre>
|
|
<h2><span class="mw-headline" id="Propri.C3.A9t.C3.A9s_disponibles">Propriétés disponibles</span></h2>
|
|
<p>Les <b>propriétés</b> sont <b>les bases</b> des <b>FeaturePython objets</b>. Grâce à elles, l'utilisateur est en mesure d'interagir et de modifier son objet.<br />
|
|
Après avoir créé un nouveau ObjetPython dans votre document <b>( a = FreeCAD.ActiveDocument.addObject ("App :: FeaturePython", "Box") )</b>, ses propriétés sont directement accessibles, vous pouvez obtenir la liste,<br />
|
|
en faisant:
|
|
</p>
|
|
<pre>obj.supportedProperties() </pre>
|
|
<p>Et voici, la liste des propriétés disponibles:
|
|
</p>
|
|
<pre>App::PropertyBool
|
|
App::PropertyBoolList
|
|
App::PropertyFloat
|
|
App::PropertyFloatList
|
|
App::PropertyFloatConstraint
|
|
App::PropertyQuantity
|
|
App::PropertyQuantityConstraint
|
|
App::PropertyAngle
|
|
App::PropertyDistance
|
|
App::PropertyLength
|
|
App::PropertySpeed
|
|
App::PropertyAcceleration
|
|
App::PropertyForce
|
|
App::PropertyPressure
|
|
App::PropertyInteger
|
|
App::PropertyIntegerConstraint
|
|
App::PropertyPercent
|
|
App::PropertyEnumeration
|
|
App::PropertyIntegerList
|
|
App::PropertyIntegerSet
|
|
App::PropertyMap
|
|
App::PropertyString
|
|
App::PropertyUUID
|
|
App::PropertyFont
|
|
App::PropertyStringList
|
|
App::PropertyLink
|
|
App::PropertyLinkSub
|
|
App::PropertyLinkList
|
|
App::PropertyLinkSubList
|
|
App::PropertyMatrix
|
|
App::PropertyVector
|
|
App::PropertyVectorList
|
|
App::PropertyPlacement
|
|
App::PropertyPlacementLink
|
|
App::PropertyColor
|
|
App::PropertyColorList
|
|
App::PropertyMaterial
|
|
App::PropertyPath
|
|
App::PropertyFile
|
|
App::PropertyFileIncluded
|
|
App::PropertyPythonObject
|
|
Part::PropertyPartShape
|
|
Part::PropertyGeometryList
|
|
Part::PropertyShapeHistory
|
|
Part::PropertyFilletEdges
|
|
Sketcher::PropertyConstraintList </pre>
|
|
<p>Lors de l'ajout de propriétés à vos objets, prenez soin de ceci:
|
|
</p>
|
|
<ul><li> Ne pas utiliser de caractères <b>"<"</b> ou <b>">"</b> dans les descriptions des propriétés (qui coupent des portions de code dans le fichier xml.Fcstd)</li>
|
|
<li> Les propriétés sont stockées dans un fichier texte <b>.Fcstd</b>.</li>
|
|
<li> Toutes les <b>propriétés</b> dont le nom vient après <b>"Shape"</b> sont triés dans l'ordre alphabétique, donc, si vous avez une forme dans vos propriétés, et comme les propriétés sont chargées après la forme, il peut y avoir des comportements inattendus!</li></ul>
|
|
<h2><span class="mw-headline" id="Property_Type">Property Type</span></h2>
|
|
<p>Par défaut, les propriétés peuvent être actualisées. Il est possible de rendre les propriétés en lecture seule, par exemple dans le cas ou l'on veut montrer le résultat d'une méthode. Il est également possible de cacher la propriété.
|
|
Le type de propriété peut être définie à l'aide
|
|
</p>
|
|
<pre>obj.setEditorMode("MyPropertyName", mode) </pre>
|
|
<p>Mode est un <b>int court</b> qui peut avoir la valeur:
|
|
0 -- mode par défaut, lecture et écriture
|
|
1 -- lecture seule
|
|
2 -- caché
|
|
</p><p>Les EditorModes ne sont pas fixés dans le fichier reload de FreeCAD. Cela pourrait être fait par la fonction __setstate__. Voir <a rel="nofollow" class="external free" href="http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=10#p108072">http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=10#p108072</a> En utilisant les propriétés de setEditorMode vous ne savez que lire dans PropertyEditor. Les proriétés pourraient encore être modifiées à partir d'une commande Python. Pour faire une lecture seul le réglage doit être transmis directement à la fonction d'ajout de propriété. Voir le topic <a rel="nofollow" class="external free" href="http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709">http://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709</a> pour voir un exemple.
|
|
</p>
|
|
<h2><span class="mw-headline" id="Autres_exemples_plus_complexes">Autres exemples plus complexes</span></h2>
|
|
<p>Cet exemple utilise le module <a href="https://www.freecadweb.org/wiki/index.php?title=Part_Module/fr" title="Part Module/fr">Part Module</a> pour créer un <a rel="nofollow" class="external text" href="http://fr.wikipedia.org/wiki/Octaèdre">octaèdre</a>, puis crée sa représentation <b><a rel="nofollow" class="external text" href="http://www.coin3d.org/">coin</a> avec pivy</b>
|
|
</p><p>En premier, c'est <b>l'objet document</b> lui-même:
|
|
</p>
|
|
<pre>import FreeCAD, FreeCADGui, Part
|
|
import pivy
|
|
from pivy import coin
|
|
|
|
class Octahedron:
|
|
def __init__(self, obj):
|
|
"Add some custom properties to our box feature"
|
|
obj.addProperty("App::PropertyLength","Length","Octahedron","Length of the octahedron").Length=1.0
|
|
obj.addProperty("App::PropertyLength","Width","Octahedron","Width of the octahedron").Width=1.0
|
|
obj.addProperty("App::PropertyLength","Height","Octahedron", "Height of the octahedron").Height=1.0
|
|
obj.addProperty("Part::PropertyPartShape","Shape","Octahedron", "Shape of the octahedron")
|
|
obj.Proxy = self
|
|
|
|
def execute(self, fp):
|
|
# Define six vetices for the shape
|
|
v1 = FreeCAD.Vector(0,0,0)
|
|
v2 = FreeCAD.Vector(fp.Length,0,0)
|
|
v3 = FreeCAD.Vector(0,fp.Width,0)
|
|
v4 = FreeCAD.Vector(fp.Length,fp.Width,0)
|
|
v5 = FreeCAD.Vector(fp.Length/2,fp.Width/2,fp.Height/2)
|
|
v6 = FreeCAD.Vector(fp.Length/2,fp.Width/2,-fp.Height/2)
|
|
|
|
# Make the wires/faces
|
|
f1 = self.make_face(v1,v2,v5)
|
|
f2 = self.make_face(v2,v4,v5)
|
|
f3 = self.make_face(v4,v3,v5)
|
|
f4 = self.make_face(v3,v1,v5)
|
|
f5 = self.make_face(v2,v1,v6)
|
|
f6 = self.make_face(v4,v2,v6)
|
|
f7 = self.make_face(v3,v4,v6)
|
|
f8 = self.make_face(v1,v3,v6)
|
|
shell=Part.makeShell([f1,f2,f3,f4,f5,f6,f7,f8])
|
|
solid=Part.makeSolid(shell)
|
|
fp.Shape = solid
|
|
|
|
# helper mehod to create the faces
|
|
def make_face(self,v1,v2,v3):
|
|
wire = Part.makePolygon([v1,v2,v3,v1])
|
|
face = Part.Face(wire)
|
|
return face </pre>
|
|
<p>Puis, nous avons <b>view provider object</b>, qui est responsable d'afficher l'objet dans la scène 3D (votre projet à l'écran):
|
|
</p>
|
|
<pre>class ViewProviderOctahedron:
|
|
def __init__(self, obj):
|
|
"Set this object to the proxy object of the actual view provider"
|
|
obj.addProperty("App::PropertyColor","Color","Octahedron","Color of the octahedron").Color=(1.0,0.0,0.0)
|
|
obj.Proxy = self
|
|
|
|
def attach(self, obj):
|
|
"Setup the scene sub-graph of the view provider, this method is mandatory"
|
|
self.shaded = coin.SoGroup()
|
|
self.wireframe = coin.SoGroup()
|
|
self.scale = coin.SoScale()
|
|
self.color = coin.SoBaseColor()
|
|
|
|
self.data=coin.SoCoordinate3()
|
|
self.face=coin.SoIndexedLineSet()
|
|
|
|
self.shaded.addChild(self.scale)
|
|
self.shaded.addChild(self.color)
|
|
self.shaded.addChild(self.data)
|
|
self.shaded.addChild(self.face)
|
|
obj.addDisplayMode(self.shaded,"Shaded");
|
|
style=coin.SoDrawStyle()
|
|
style.style = coin.SoDrawStyle.LINES
|
|
self.wireframe.addChild(style)
|
|
self.wireframe.addChild(self.scale)
|
|
self.wireframe.addChild(self.color)
|
|
self.wireframe.addChild(self.data)
|
|
self.wireframe.addChild(self.face)
|
|
obj.addDisplayMode(self.wireframe,"Wireframe");
|
|
self.onChanged(obj,"Color")
|
|
|
|
def updateData(self, fp, prop):
|
|
"If a property of the handled feature has changed we have the chance to handle this here"
|
|
# fp is the handled feature, prop is the name of the property that has changed
|
|
if prop == "Shape":
|
|
s = fp.getPropertyByName("Shape")
|
|
self.data.point.setNum(6)
|
|
cnt=0
|
|
for i in s.Vertexes:
|
|
self.data.point.set1Value(cnt,i.X,i.Y,i.Z)
|
|
cnt=cnt+1
|
|
|
|
self.face.coordIndex.set1Value(0,0)
|
|
self.face.coordIndex.set1Value(1,1)
|
|
self.face.coordIndex.set1Value(2,2)
|
|
self.face.coordIndex.set1Value(3,-1)
|
|
|
|
self.face.coordIndex.set1Value(4,1)
|
|
self.face.coordIndex.set1Value(5,3)
|
|
self.face.coordIndex.set1Value(6,2)
|
|
self.face.coordIndex.set1Value(7,-1)
|
|
|
|
self.face.coordIndex.set1Value(8,3)
|
|
self.face.coordIndex.set1Value(9,4)
|
|
self.face.coordIndex.set1Value(10,2)
|
|
self.face.coordIndex.set1Value(11,-1)
|
|
|
|
self.face.coordIndex.set1Value(12,4)
|
|
self.face.coordIndex.set1Value(13,0)
|
|
self.face.coordIndex.set1Value(14,2)
|
|
self.face.coordIndex.set1Value(15,-1)
|
|
|
|
self.face.coordIndex.set1Value(16,1)
|
|
self.face.coordIndex.set1Value(17,0)
|
|
self.face.coordIndex.set1Value(18,5)
|
|
self.face.coordIndex.set1Value(19,-1)
|
|
|
|
self.face.coordIndex.set1Value(20,3)
|
|
self.face.coordIndex.set1Value(21,1)
|
|
self.face.coordIndex.set1Value(22,5)
|
|
self.face.coordIndex.set1Value(23,-1)
|
|
|
|
self.face.coordIndex.set1Value(24,4)
|
|
self.face.coordIndex.set1Value(25,3)
|
|
self.face.coordIndex.set1Value(26,5)
|
|
self.face.coordIndex.set1Value(27,-1)
|
|
|
|
self.face.coordIndex.set1Value(28,0)
|
|
self.face.coordIndex.set1Value(29,4)
|
|
self.face.coordIndex.set1Value(30,5)
|
|
self.face.coordIndex.set1Value(31,-1)
|
|
|
|
def getDisplayModes(self,obj):
|
|
"Return a list of display modes."
|
|
modes=[]
|
|
modes.append("Shaded")
|
|
modes.append("Wireframe")
|
|
return modes
|
|
|
|
def getDefaultDisplayMode(self):
|
|
"Return the name of the default display mode. It must be defined in getDisplayModes."
|
|
return "Shaded"
|
|
|
|
def setDisplayMode(self,mode):
|
|
return mode
|
|
|
|
def onChanged(self, vp, prop):
|
|
"Here we can do something when a single property got changed"
|
|
FreeCAD.Console.PrintMessage("Change property: " + str(prop) + "\n")
|
|
if prop == "Color":
|
|
c = vp.getPropertyByName("Color")
|
|
self.color.rgb.setValue(c[0],c[1],c[2])
|
|
|
|
def getIcon(self):
|
|
return """
|
|
/* XPM */
|
|
static const char * ViewProviderBox_xpm[] = {
|
|
"16 16 6 1",
|
|
" c None",
|
|
". c #141010",
|
|
"+ c #615BD2",
|
|
"@ c #C39D55",
|
|
"# c #000000",
|
|
"$ c #57C355",
|
|
" ........",
|
|
" ......++..+..",
|
|
" .@@@@.++..++.",
|
|
" .@@@@.++..++.",
|
|
" .@@ .++++++.",
|
|
" ..@@ .++..++.",
|
|
"###@@@@ .++..++.",
|
|
"##$.@@$#.++++++.",
|
|
"#$#$.$$$........",
|
|
"#$$####### ",
|
|
"#$$#$$$$$# ",
|
|
"#$$#$$$$$# ",
|
|
"#$$#$$$$$# ",
|
|
" #$#$$$$$# ",
|
|
" ##$$$$$# ",
|
|
" ####### "};
|
|
"""
|
|
|
|
def __getstate__(self):
|
|
return None
|
|
|
|
def __setstate__(self,state):
|
|
return None </pre>
|
|
<p>Enfin, une fois que notre objet et son <b>viewobject</b> sont définis, nous n'avons qu'a les appeler:
|
|
</p>
|
|
<pre>FreeCAD.newDocument()
|
|
a=FreeCAD.ActiveDocument.addObject("App::FeaturePython","Octahedron")
|
|
Octahedron(a)
|
|
ViewProviderOctahedron(a.ViewObject) </pre>
|
|
<h2><span class="mw-headline" id="Cr.C3.A9ation_d.27objets_s.C3.A9lectionnables">Création d'objets sélectionnables</span></h2>
|
|
<p>Si vous voulez travailler sur un objet sélectionné, ou du moins une partie de celui-ci, vous cliquez sur l'objet dans la fenêtre, vous devez inclure la forme géométrique à l'intérieur d'un noeud <b>SoFCSelection node</b>.<br />
|
|
Si votre objet a une représentation complexe, avec des widgets, des annotations, etc, vous pouvez n'inclure qu'une partie de celui-ci dans un <b>SoFCSelection</b>.<br />
|
|
Tout ce qui est <b>SoFCSelection</b> est constamment "scanné" par FreeCAD pour voir s'il est sélectionné/présélectionné, il est donc logique de ne rien surcharger avec des <b>scans</b> inutiles.<br /><br />
|
|
Voici un exemple de ce que vous devrez faire pour inclure un <b>self.face</b>:
|
|
</p>
|
|
<pre>selectionNode = coin.SoType.fromName("SoFCSelection").createInstance()
|
|
selectionNode.documentName.setValue(FreeCAD.ActiveDocument.Name)
|
|
selectionNode.objectName.setValue(obj.Object.Name) # here obj is the ViewObject, we need its associated App Object
|
|
selectionNode.subElementName.setValue("Face")
|
|
selectNode.addChild(self.face)
|
|
...
|
|
self.shaded.addChild(selectionNode)
|
|
self.wireframe.addChild(selectionNode) </pre>
|
|
<p>Vous créez Simplement un <b>SoFCSelection</b> node (noeud), puis vous lui ajoutez vos noeuds géométriques, alors seulement vous l'ajoutez à votre noeud principal, au lieu d'ajouter vos noeuds géométriques directement.
|
|
</p>
|
|
<h2><span class="mw-headline" id="Travailler_avec_des_formes_simples">Travailler avec des formes simples</span></h2>
|
|
<p>Si votre objet paramétrique renvoie simplement une forme, vous n'avez pas besoin d'utiliser un objet créateur de vue (<i>view provider object</i>).<br />
|
|
La forme sera affichée à l'aide du module standard de représentation des formes de FreeCAD:
|
|
</p>
|
|
<pre>import FreeCAD as App
|
|
import FreeCADGui
|
|
import FreeCAD
|
|
import Part
|
|
class Line:
|
|
def __init__(self, obj):
|
|
'''"App two point properties" '''
|
|
obj.addProperty("App::PropertyVector","p1","Line","Start point")
|
|
obj.addProperty("App::PropertyVector","p2","Line","End point").p2=FreeCAD.Vector(1,0,0)
|
|
obj.Proxy = self
|
|
|
|
def execute(self, fp):
|
|
'''"Print a short message when doing a recomputation, this method is mandatory" '''
|
|
fp.Shape = Part.makeLine(fp.p1,fp.p2)
|
|
|
|
a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
|
|
Line(a)
|
|
a.ViewObject.Proxy=0 # just set it to something different from None (this assignment is needed to run an internal notification)
|
|
FreeCAD.ActiveDocument.recompute() </pre>
|
|
<p>Même code en utilisant <b>ViewProviderLine</b>
|
|
</p>
|
|
<pre>import FreeCAD as App
|
|
import FreeCADGui
|
|
import FreeCAD
|
|
import Part
|
|
|
|
class Line:
|
|
def __init__(self, obj):
|
|
'''"App two point properties" '''
|
|
obj.addProperty("App::PropertyVector","p1","Line","Start point")
|
|
obj.addProperty("App::PropertyVector","p2","Line","End point").p2=FreeCAD.Vector(100,0,0)
|
|
obj.Proxy = self
|
|
|
|
def execute(self, fp):
|
|
'''"Print a short message when doing a recomputation, this method is mandatory" '''
|
|
fp.Shape = Part.makeLine(fp.p1,fp.p2)
|
|
|
|
class ViewProviderLine:
|
|
def __init__(self, obj):
|
|
''' Set this object to the proxy object of the actual view provider '''
|
|
obj.Proxy = self
|
|
|
|
def getDefaultDisplayMode(self):
|
|
''' Return the name of the default display mode. It must be defined in getDisplayModes. '''
|
|
return "Flat Lines"
|
|
|
|
a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Line")
|
|
Line(a)
|
|
ViewProviderLine(a.ViewObject)
|
|
App.ActiveDocument.recompute() </pre>
|
|
<p><br />
|
|
</p>
|
|
<h2><span class="mw-headline" id="Recherche_d.27informations">Recherche d'informations</span></h2>
|
|
<p>Il y a quelques discussions très intéressantes sur le forum sur les objets scriptés:
|
|
</p><p>- <a rel="nofollow" class="external free" href="http://forum.freecadweb.org/viewtopic.php?f=22&t=13740">http://forum.freecadweb.org/viewtopic.php?f=22&t=13740</a>
|
|
</p><p>- <a rel="nofollow" class="external free" href="http://forum.freecadweb.org/viewtopic.php?t=12139">http://forum.freecadweb.org/viewtopic.php?t=12139</a>
|
|
</p><p>- <a rel="nofollow" class="external free" href="https://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709">https://forum.freecadweb.org/viewtopic.php?f=18&t=13460&start=20#p109709</a>
|
|
</p><p>- <a rel="nofollow" class="external free" href="https://forum.freecadweb.org/viewtopic.php?f=22&t=21330">https://forum.freecadweb.org/viewtopic.php?f=22&t=21330</a>
|
|
</p><p><br />
|
|
En plus de ces exemples, vous pouvez voir dans le code source de FreeCAD <a rel="nofollow" class="external text" href="https://github.com/FreeCAD/FreeCAD/blob/master/src/Mod/TemplatePyMod/FeaturePython.py">src/Mod/TemplatePyMod/FeaturePython.py</a> pour plus d'exemples.
|
|
</p>
|
|
|
|
<div style="clear:both"></div>
|
|
</div>
|
|
|
|
|
|
|
|
</div>
|
|
|
|
</div><div class="printfooter">
|
|
Online version: "<a dir="ltr" href="https://www.freecadweb.org/wiki/index.php?title=Scripted_objects/fr&oldid=228367">http://www.freecadweb.org/wiki/index.php?title=Scripted_objects/fr&oldid=228367</a>"</div>
|
|
<div id="catlinks" class="catlinks" data-mw="interface"></div><div class="visualClear"></div>
|
|
</div>
|
|
</div>
|
|
<div id="mw-navigation">
|
|
<h2>Navigation menu</h2>
|
|
|
|
</body></html> |