231 lines
14 KiB
HTML
231 lines
14 KiB
HTML
<html><head><title>Workbench creation/de</title><meta http-equiv="Content-Type" content="text/html; charset=utf-8"><link type='text/css' href='wiki.css' rel='stylesheet'></head><body><h1>Workbench creation/de</h1></div>
|
|
|
|
<div id="mw-content-text" lang="de" dir="ltr" class="mw-content-ltr"><hr/><div class="mw-parser-output"><p>Diese Seite zeigt, wie FreeCAD neue Arbeitsbereiche hinzugefügt werden. <a href="Workbenches.html" title="Workbenches">Arbeitsbereiche</a> sind Container für FreeCAD Befehle. Sie können in Python, C++ oder in einer Mischung aus beiden programmiert werden. Letzteres hat den Vorteil, die Geschwindigkeit von C++ mit der Flexibilität von Python zu verbinden. In allen Fällen werden Arbeitsbereiche durch einen Satz von zwei Pythondateien gestartet.
|
|
</p>
|
|
<div id="toc" class="toc"><div class="toctitle"><h2>Contents</h2></div>
|
|
<ul>
|
|
<li class="toclevel-1 tocsection-1"><a href="#Struktur_eines_Arbeitsbereichs"><span class="tocnumber">1</span> <span class="toctext">Struktur eines Arbeitsbereichs</span></a>
|
|
<ul>
|
|
<li class="toclevel-2 tocsection-2"><a href="#Struktur_eines_C.2B.2B_Arbeitsbereichs"><span class="tocnumber">1.1</span> <span class="toctext">Struktur eines C++ Arbeitsbereichs</span></a></li>
|
|
<li class="toclevel-2 tocsection-3"><a href="#Die_Init.py_Datei"><span class="tocnumber">1.2</span> <span class="toctext">Die Init.py Datei</span></a></li>
|
|
<li class="toclevel-2 tocsection-4"><a href="#Python_Arbeitsbereiche"><span class="tocnumber">1.3</span> <span class="toctext">Python Arbeitsbereiche</span></a></li>
|
|
<li class="toclevel-2 tocsection-5"><a href="#C.2B.2B_Arbeitsbereiche"><span class="tocnumber">1.4</span> <span class="toctext">C++ Arbeitsbereiche</span></a></li>
|
|
</ul>
|
|
</li>
|
|
<li class="toclevel-1 tocsection-6"><a href="#FreeCAD_Befehle"><span class="tocnumber">2</span> <span class="toctext">FreeCAD Befehle</span></a>
|
|
<ul>
|
|
<li class="toclevel-2 tocsection-7"><a href="#Python_Befehlsdefinition"><span class="tocnumber">2.1</span> <span class="toctext">Python Befehlsdefinition</span></a></li>
|
|
<li class="toclevel-2 tocsection-8"><a href="#C.2B.2B_Befehlsdefinition"><span class="tocnumber">2.2</span> <span class="toctext">C++ Befehlsdefinition</span></a></li>
|
|
</ul>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<h2><span class="mw-headline" id="Struktur_eines_Arbeitsbereichs">Struktur eines Arbeitsbereichs</span></h2>
|
|
<p>Das Vorgehen ist einfach: Sie brauchen einen Ordner mit einem Namen Ihrer Wahl, der im Mod Verzeichnis angelegt wird, und eine <b>Init.py</b> Datei sowie optional eine <b>InitGui.py</b> Datei. Die Init Datei wird immer ausgeführt, wenn FreeCAD startet gefolgt von der InitGui Datei, die nur ausgeführt wird, wenn sich FreeCAD im GUI Modus (nicht im Konsolenmodus) befindet. Dies ist alles, was nötig ist, damit FreeCAD Ihren Arbeitsbereich beim Start findet und ihn zum Interface hinzufügt.
|
|
</p><p>Innerhalb dieser Dateien können Sie beliebige Dinge machen. Üblicherweise werden sie wie folgt verwendet:
|
|
</p>
|
|
<ul><li> In der Init.py Datei fügen Sie in der Regel verschiedene Dinge hinzu, die benutzt werden, auch wenn FreeCAD im Konsolenmodus arbeitet, z.B. Dateiimport- und Exportfilter.</li></ul>
|
|
<ul><li> In der InitGUI.py Datei definieren Sie üblicherweise einen Arbeitsbereich, der einen Namen, ein Symbol und eine Reihe von FreeCAD Befehlen (siehe unten) enthält. Der Arbeitsbereich definiert außerdem Funktionen, die ausgeführt werden, wenn FreeCAD geladen wird (hier sollte so wenig wie möglich getan werden, um das Starten nicht zu verlangsamen), der Arbeitsbereich aktiviert (hier wird die meiste Arbeit geleistet) sowie deaktiviert wird (hier können Dinge, wenn nötig, entfernt werden).</li></ul>
|
|
<h3><span class="mw-headline" id="Struktur_eines_C.2B.2B_Arbeitsbereichs">Struktur eines C++ Arbeitsbereichs</span></h3>
|
|
<p>Wenn Sie einen Arbeitsbereich in Python programmieren, sind keine weiteren Dinge zu beachten und weitere Pythondateien können zusammen mit Init.py sowie InitGui.py gespeichert werden. Wenn Sie jedoch mit C++ arbeiten, sollten Sie besonders eine fundamentale Regel von FreeCAD beachten: Die Trennung des Arbeitsbereichs in einen Anwendungsteil (,der im Konsolenmodus ohne GUI Elemente laufen kann) und einen GUI Teil, der nur geladen wird, wenn FreeCAD in voller GUI Umgebung geladen wird. Wenn Sie also einen C++ Arbeitsbereich erstellen, werden Sie tatsächlich zwei Module erstellen (Applikation und GUI). Diese beiden Module müssen natürlich von Python aus aufrufbar sein. Jedes FreeCAD Modul (Applikation oder GUI) besteht zumindest aus einer Modul Init Datei. Dies ist eine typische AppMyModuleGui.cpp Datei:
|
|
</p>
|
|
<pre>extern "C" {
|
|
void MyModuleGuiExport initMyModuleGui()
|
|
{
|
|
if (!Gui::Application::Instance) {
|
|
PyErr_SetString(PyExc_ImportError, "Cannot load Gui module in console application.");
|
|
return;
|
|
}
|
|
try {
|
|
// import other modules this one depends on
|
|
Base::Interpreter().runString("import PartGui");
|
|
// run some python code in the console
|
|
Base::Interpreter().runString("print('welcome to my module!')");
|
|
}
|
|
catch(const Base::Exception& e) {
|
|
PyErr_SetString(PyExc_ImportError, e.what());
|
|
return;
|
|
}
|
|
(void) Py_InitModule("MyModuleGui", MyModuleGui_Import_methods); /* mod name, table ptr */
|
|
Base::Console().Log("Loading GUI of MyModule... done\n");
|
|
|
|
// initializes the FreeCAD commands (in another cpp file)
|
|
CreateMyModuleCommands();
|
|
|
|
// initializes workbench and object definitions
|
|
MyModuleGui::Workbench::init();
|
|
MyModuleGui::ViewProviderSomeCustomObject::init();
|
|
|
|
// add resources and reloads the translators
|
|
loadMyModuleResource();
|
|
}
|
|
} </pre>
|
|
<h3><span class="mw-headline" id="Die_Init.py_Datei">Die Init.py Datei</span></h3>
|
|
<pre># FreeCAD init script of XXX module
|
|
|
|
#***************************************************************************
|
|
#* (c) John Doe john@doe.com 2015 *
|
|
#* *
|
|
#* This file is part of the FreeCAD CAx development system. *
|
|
#* *
|
|
#* This program is free software; you can redistribute it and/or modify *
|
|
#* it under the terms of the GNU Lesser General Public License (LGPL) *
|
|
#* as published by the Free Software Foundation; either version 2 of *
|
|
#* the License, or (at your option) any later version. *
|
|
#* for detail see the LICENCE text file. *
|
|
#* *
|
|
#* FreeCAD is distributed in the hope that it will be useful, *
|
|
#* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
#* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
#* GNU Lesser General Public License for more details. *
|
|
#* *
|
|
#* You should have received a copy of the GNU Library General Public *
|
|
#* License along with FreeCAD; if not, write to the Free Software *
|
|
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
|
|
#* USA *
|
|
#* *
|
|
#***************************************************************************/
|
|
|
|
FreeCAD.addImportType("My own format (*.own)","importOwn")
|
|
FreeCAD.addExportType("My own format (*.own)","importOwn")
|
|
print "I am executing some stuff here when FreeCAD starts!" </pre>
|
|
<p>Sie können ein Lizenzmodell Ihrer Wahl für Ihren Arbeitsbereich wählen. Sie sollte sich jedoch darüber bewusst sein, dass ein Arbeitsbereich, der zu einem gewissen Zeitpunkt in FreeCAD integriert und mit dem Quellcode veröffentlicht werden soll, der LPGL2+ Lizenz unterliegen muss. Die Funktionen FreeCAD.addImportType() und addEXportType() ermöglichen die Vergabe eines Namens und einer Dateiendung sowie ein Pythonmodul, das für diesen Import zuständig ist. Im obigen Beispiel ist importOwn.py für den Umgang mit .own Dateien verantwortlich. Schauen Sie unter <a href="Code_snippets.html" title="Code snippets">Codeschnipsel</a> nach weiteren Beispielen.
|
|
</p>
|
|
<h3><span class="mw-headline" id="Python_Arbeitsbereiche">Python Arbeitsbereiche</span></h3>
|
|
<div class="mw-highlight mw-content-ltr" dir="ltr"><pre>class MyWorkbench (Workbench):
|
|
|
|
MenuText = "My Workbench"
|
|
ToolTip = "A description of my workbench"
|
|
Icon = """paste here the contents of a 16x16 xpm icon"""
|
|
|
|
def Initialize(self):
|
|
"This function is executed when FreeCAD starts"
|
|
import MyModuleA, MyModuleB # import here all the needed files that create your FreeCAD commands
|
|
self.list = ["MyCommand1, MyCommand2"] # A list of command names created in the line above
|
|
self.appendToolbar("My Commands",self.list) # creates a new toolbar with your commands
|
|
self.appendMenu("My New Menu",self.list) # creates a new menu
|
|
self.appendMenu(["An existing Menu","My submenu"],self.list) # appends a submenu to an existing menu
|
|
|
|
def Activated(self):
|
|
"This function is executed when the workbench is activated"
|
|
return
|
|
|
|
def Deactivated(self):
|
|
"This function is executed when the workbench is deactivated"
|
|
return
|
|
|
|
def ContextMenu(self, recipient):
|
|
"This is executed whenever the user right-clicks on screen"
|
|
# "recipient" will be either "view" or "tree"
|
|
self.appendContextMenu("My commands",self.list) # add commands to the context menu
|
|
|
|
def GetClassName(self):
|
|
# this function is mandatory if this is a full python workbench
|
|
return "Gui::PythonWorkbench"
|
|
|
|
Gui.addWorkbench(MyWorkbench())</pre></div>
|
|
<p>Im Gegensatz hierzu können Sie hier tun, was Sie möchten: Sie könnten Ihren gesamten Arbeitsbereich Code in der InitGui.py platzieren, wenn Sie möchten. Allerdings ist es üblicher und angenehmer, die verschiedenen Funktionen Ihres Arbeitsbereichs in getrennten Dateien zu speichern. Auf diese Weise werden die Dateien kleiner und leichter zu lesen. Danach importieren Sie diese Dateien innerhalb Ihrer InitGui.py Datei. Sie können jene Dateien organisieren ganz wie Sie möchten. Ein gutes Beispiel ist eine Datei für jeden hinzugefügten FreeCAD Befehl.
|
|
</p>
|
|
<h3><span class="mw-headline" id="C.2B.2B_Arbeitsbereiche">C++ Arbeitsbereiche</span></h3>
|
|
<p>Wenn Sie Ihren Arbeitsbereich in C++ programmieren, werden Sie vermutlich die Arbeitsbereichsdefinition selbst ebenfalls in C++ erstellen (,was jedoch nicht nötig ist: Sie auch die nur die Werzeuge in C++ programmieren und die Arbeitsbereichsdefinition in Python belassen). In diesem Fall wird die InitGui.py Datei sehr einfach. Sie könnte etwa nur eine Zeile enthalten:
|
|
</p>
|
|
<pre>import MyModuleGui </pre>
|
|
<p>wobei MyModule Ihr kompletter C++ Arbeitsbereich ist, der die Befehle und Arbeitsbereichsdefinition einschließt.
|
|
</p><p>Die Programmierung von C++ Arbeitsbereichen funktioniert auf sehr ähnlich Art und Weise. Dies eine typische Workbench.cpp Datei, die in den GUI Teil Ihres Moduls eingebunden werden kann.
|
|
</p>
|
|
<pre>namespace MyModuleGui {
|
|
class MyModuleGuiExport Workbench : public Gui::StdWorkbench
|
|
{
|
|
TYPESYSTEM_HEADER();
|
|
|
|
public:
|
|
Workbench();
|
|
virtual ~Workbench();
|
|
|
|
virtual void activated();
|
|
virtual void deactivated();
|
|
|
|
protected:
|
|
Gui::ToolBarItem* setupToolBars() const;
|
|
Gui::MenuItem* setupMenuBar() const;
|
|
};
|
|
} </pre>
|
|
<h2><span class="mw-headline" id="FreeCAD_Befehle">FreeCAD Befehle</span></h2>
|
|
<p>FreeCAD Befehle sind die Grundbausteine des FreeCAD Interface. Sie können als Knöpfe in Werkzeugleisten und als Einträge in Menüs erscheinen. Es handelt sich dabei immer um den selben Befehl. Ein Befehl ist einfach eine Python Klasse, die eine Reihe von vordefinierten Attributen und Funktionen enthält, wie der Befehlsname, das Symbol und der Code, der ausgeführt wird, wenn der Befehl aktiviert wird.
|
|
</p>
|
|
<h3><span class="mw-headline" id="Python_Befehlsdefinition">Python Befehlsdefinition</span></h3>
|
|
<pre>class My_Command_Class():
|
|
"""My new command"""
|
|
|
|
def GetResources(self):
|
|
return {'Pixmap'  : 'My_Command_Icon', # the name of a svg file available in the resources
|
|
'Accel' : "Shift+S", # a default shortcut (optional)
|
|
'MenuText': "My New Command"
|
|
'ToolTip' : "What my new command does"}
|
|
|
|
def Activated(self):
|
|
"Do something here"
|
|
return
|
|
|
|
def IsActive(self):
|
|
"""Here you can define if the command must be active or not (greyed) if certain conditions
|
|
are met or not. This function is optional."""
|
|
return True
|
|
|
|
FreeCADGui.addCommand('My_Command',My_Command_Class()) </pre>
|
|
<h3><span class="mw-headline" id="C.2B.2B_Befehlsdefinition">C++ Befehlsdefinition</span></h3>
|
|
<p>In ähnlicher Art können Sie Befehle in C++ programmieren und haben dazu typischerweise eine Commands.cpp Datei in Ihrem GUI Modul. Dies ist eine typische Commands.cpp Datei.
|
|
</p>
|
|
<pre>DEF_STD_CMD_A(CmdMyCommand);
|
|
|
|
CmdMyCommand::CmdMyCommand()
|
|
 :Command("My_Command")
|
|
{
|
|
sAppModule = "MyModule";
|
|
sGroup = QT_TR_NOOP("MyModule");
|
|
sMenuText = QT_TR_NOOP("Runs my command...");
|
|
sToolTipText = QT_TR_NOOP("Describes what my command does");
|
|
sWhatsThis = QT_TR_NOOP("Describes what my command does");
|
|
sStatusTip = QT_TR_NOOP("Describes what my command does");
|
|
sPixmap = "some_svg_icon_from_my_resource";
|
|
}
|
|
|
|
void CmdMyCommand::activated(int iMsg)
|
|
{
|
|
openCommand("My Command");
|
|
doCommand(Doc,"print('Hello, world!')");
|
|
commitCommand();
|
|
updateActive();
|
|
}
|
|
|
|
bool CmdMyCommand::isActive(void)
|
|
{
|
|
if( getActiveGuiDocument() )
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
void CreateMyModuleCommands(void)
|
|
{
|
|
Gui::CommandManager &rcCmdMgr = Gui::Application::Instance->commandManager();
|
|
rcCmdMgr.addCommand(new CmdMyCommand());
|
|
} </pre>
|
|
<p><br />
|
|
</p>
|
|
</div>
|
|
|
|
|
|
|
|
</div>
|
|
|
|
</div><div class="printfooter">
|
|
Online version: "<a dir="ltr" href="https://www.freecadweb.org/wiki/index.php?title=Workbench_creation/de&oldid=189369">http://www.freecadweb.org/wiki/index.php?title=Workbench_creation/de&oldid=189369</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> |