Difference between revisions of "Dialog creation/de"

From FreeCAD Documentation
Jump to navigation Jump to search
(Created page with "==Bild mit QLabel und Gif animiert mit QMovie anzeigen==")
(Updating to match new version of source page)
 
(46 intermediate revisions by 2 users not shown)
Line 1: Line 1:
 
<languages/>
 
<languages/>
{{docnav/de
 
|[[Line drawing function/de|Linienzeichenfunktion]]
 
}}
 
  
Auf dieser Seite zeigen wir, wie man einen einfachen Qt-Dialog aufbaut mit [http://qt-project.org/doc/qt-4.8/designer-manual.html Qt-Designer], dem offiziellen Werkzeug von Qt, um Schnittstellen zu entwerfen. Das Ergebnis wandeln wir dann um in Python-Code und verwenden es anschließend innerhalb von FreeCAD. Ich werde in diesem Beispiel davon ausgehen, dass Sie bereits wissen, wie man Python-Skripte bearbeitet und ausführt und dass Sie einfache Dinge in einem Terminal-Fenster wie navigieren, etc. ebenfalls können. Ebenso muss natürlich auch pyqt installiert sein.
+
{{TOCright}}
 +
 
 +
== Einführung ==
 +
 
 +
Auf dieser Seite werden wir zeigen, wie man mit [http://qt-project.org/doc/qt-4.8/designer-manual.html Qt Designer], Qt's offiziellem Werkzeug für die Gestaltung von Oberflächen, eine einfache grafische Oberfläche erstellt; der Dialog wird in [[Python/de|Python]] Code umgewandelt und dann innerhalb von FreeCAD verwendet. Wir gehen davon aus, dass der Benutzer weiß, wie man [[Python/de|Python]] allgemein bearbeitet und ausführt.
 +
 
 +
In diesem Beispiel ist die gesamte Oberfläche in [[Python/de|Python]] definiert. Obwohl dies bei kleinen Schnittstellen möglich ist, empfiehlt es sich bei größeren Schnittstellen, die erstellten  {{FileName|.ui}} Dateien direkt in das Programm zu laden. Siehe [[Interface_creation_with_UI_files/de|Obeflächenerstellung mit UI Dateien]] für weitere Informationen.
 +
 
 +
[[File:FreeCAD_creating_interfaces.svg|600px]]
 +
{{Caption|Zwei allgemeine Methoden zur Erstellung von Oberflächen, durch Einfügen der Schnittstelle in die Python Datei oder durch die Verwendung von {{incode|.ui}} Dateien.}}
 +
 
 +
== Gestalten des Dialogs ==
  
== Das Entwerfen des Dialogs ==
+
In CAD Anwendungen ist es sehr wichtig, eine gute UI (Benutzeroberfläche) zu entwerfend. Beinahe alles, das der Benutzer tun wird, wird über ein Teil der Oberfläche passieren: das Lesen von Dialog Kästen, drücken von Knöpfen, die Auswahl zwischen Piktogrammen, usw. Es ist also sehr wichtig, sich genau zu überlegen, was du tun willst, wie der Benutzer sich verhalten soll und wie der Ablauf deiner Aktion aussehen soll.
In CAD-Anwendungen ist es sehr wichtig, eine gute UI (Benutzerschnittstelle) zu entwerfend. Beinahe alles, das der Benutzer tun wird, wird über ein Teil der Schnittstelle passieren: das Lesen von Dialog-Kästen, drücken von Knöpfen, die Auswahl zwischen Piktogrammen, usw. So ist es sehr wichtig, genau darüber nachzudenken, was Sie tun wollen, wie Sie wollen, dass sich der Benutzer verhält und wie der Arbeitsablauf Ihrer Handlung sein wird.
 
  
Ein paar Konzepte sollte man bei der Gestaltung der Schnittstelle kennen:
+
Ein paar Konzepte sollte man bei der Gestaltung der Oberfläche kennen:
 
* [http://de.wikipedia.org/wiki/Dialogfenster Dialoge]: Ein modaler Dialog erscheint auf Ihrem Schirm, unterbricht die Handlung des Hauptfensters, zwingt den Benutzer auf den Dialog zu antworten, während ein nichtmodaler Dialog Sie nicht hindert, am Hauptfenster weiter zu arbeiten. In einigen Fällen ist der erste besser, in anderen Fällen nicht.
 
* [http://de.wikipedia.org/wiki/Dialogfenster Dialoge]: Ein modaler Dialog erscheint auf Ihrem Schirm, unterbricht die Handlung des Hauptfensters, zwingt den Benutzer auf den Dialog zu antworten, während ein nichtmodaler Dialog Sie nicht hindert, am Hauptfenster weiter zu arbeiten. In einigen Fällen ist der erste besser, in anderen Fällen nicht.
 
* Erkennen, was erforderlich ist und was optional: Stellen Sie sicher, dass der Benutzer weiß, was er tun muss. Etikettieren Sie alles mit der richtigen Beschreibung, verwenden Sie tooltips usw.
 
* Erkennen, was erforderlich ist und was optional: Stellen Sie sicher, dass der Benutzer weiß, was er tun muss. Etikettieren Sie alles mit der richtigen Beschreibung, verwenden Sie tooltips usw.
Line 22: Line 29:
 
[[Image:Qtdesigner-screenshot.jpg]]
 
[[Image:Qtdesigner-screenshot.jpg]]
  
Die Bedienung ist recht einfach. Auf der linken Leiste haben Sie Elemente, die Sie auf Ihr Widget ziehen können. Rechts haben Sie Eigenschaften-Tafeln, die alle Arten von änderbaren Eigenschaften von ausgewählten Elementen zeigen. Beginnen Sie mit dem Erstellen eines neuen Widgets. Wählen Sie "Dialog ohne Knöpfe", da wir nicht die Standard-OK/Abbrechen Knöpfe wollen. Jetzt ziehen auf Ihr Widget '''3 Label''', eins für den Titel, eins mit Namen "Höhe" und eins mit Namen "Breite". Label sind einfache Texte, die auf Ihrem Widget angezeigt werden, nur um den Benutzer zu informieren. Wenn Sie ein Label auswählen, werden auf der rechten Seite mehrere Eigenschaften erscheinen, die Sie nach Bedarf ändern können, wie Schriftart, Größe, usw.
+
== Erstellen des Dialogs ==
 
+
Qt Designer ist sehr einfach zu benutzen. Auf der linken Leiste hast du Elemente, die auf dein Widget gezogen werden können. Auf der rechten Seite hast du Eigenschaftspaneels, die alle Arten von editierbaren Eigenschaften der ausgewählten Elemente anzeigen. Beginne also mit der Erstellung eines neuen Widgets.  
Dann fügen Sie '''2 LineEdits''' ein, dies sind Textfelder, die der Benutzer ausfüllen kann, eins für die Höhe und eins für die Breite. Auch hier können wir Eigenschaften bearbeiten. Warum nicht, zum Beispiel, einen Standardwert vorgeben? Zum Beispiel 1,00 für jeden. Auf diese Weise werden beide Werte bereits ausgefüllt sein, wenn der Benutzer den Dialog sieht, und wenn es so stimmt, kann er den Knopf direkt drücken und spart wertvolle Zeit. Dann fügen Sie einen '''PushButton''' hinzu, das ist die Schaltfläche, die der Benutzer drücken muss, nachdem er die zwei Felder füllte.
+
# Wähle "Dialog ohne Schaltflächen", da wir die Standardschaltflächen {{KEY|OK}}/{{KEY|Abbrechen}} nicht wollen.  
 +
# Wir brauchen '''Labels''' (Beschriftungen). Labels sind einfache Textzeichenfolgen, die auf deinem Widget erscheinen, um den Endbenutzer zu informieren. Wenn du ein Label auswählst, beachte, dass auf der rechten Seite verschiedene Eigenschaften erscheinen, die du ändern kannst, wie z.B.: Schriftstil, Höhe, usw... Lass uns also 3 separate Label auf unser Widget ziehen: 
 +
#* Ein Label für den Titel
 +
#* Ein weiteres Label zum Schreiben von "'''Height'''"
 +
#* Ein weiteres Label zum Schreiben von "'''Width'''"
 +
# Wir brauchen jetzt LineEdits (eigentlich 2 davon). Ziehe zwei davon auf das Widget. '''LineEdits''' sind Textfelder, die der Endbenutzer ausfüllen kann. Wir brauchen also einen LineEdit für die ''Höhe'' und einen für die ''Breite''. Auch hier können wir Eigenschaften bearbeiten. Warum nicht z.B. einen Standardwert setzen, sagen wir z.B.: 1,00 für jedes. Auf diese Weise werden beide Werte bereits ausgefüllt sein, wenn der Benutzer den Dialog sieht. Wenn der Endbenutzer zufrieden ist, kann er direkt auf die Schaltfläche drücken und so wertvolle Zeit sparen.  
 +
# Als nächstes können wir einen '''PushButton''' (Druckknopf) hinzufügen. Dies ist die Schaltfläche, die der Endbenutzer drücken muss, nachdem er beide Felder ausgefüllt hat.
  
Beachten Sie, dass ich sehr einfache Steuerungen gewählt habe, aber Qt noch viele andere Optionen hat, zum Beispiel könnten Sie Spinboxes statt LineEdits usw. verwenden. Werfen Sie doch einen Blick darauf, was verfügbar ist, vielleicht kommen Ihnen dabei noch weitere Ideen.
+
'''Hinweis:''' dass wir hier sehr einfache Bedienelemente gewählt haben. Qt hat viel mehr Optionen, zum Beispiel könnte man '''Spinboxes''' anstelle von '''LineEdits''' verwenden, usw... Schaudir an, was verfügbar ist, erkunde... Du wirst sicher andere Ideen haben.
  
Das ist soweit alles, was wir im Qt-Designer tun müssen. Eine letzte Sache, wir sollten alle unsere Elemente mit einfacheren Namen bezeichnen, so dass es leichter wird, sie in unseren Skripten zu identifizieren:
+
Das ist soweit alles, was wir im Qt Designer tun müssen. Eine letzte Sache noch: Benennen wir alle unsere Elemente mit einfacheren Namen um, damit sie in unseren Skripten leichter zu identifizieren sind:
  
 
[[Image:Qtpropeditor.jpg]]
 
[[Image:Qtpropeditor.jpg]]
  
 
== Umwandeln unseres Dialogs zu Python ==
 
== Umwandeln unseres Dialogs zu Python ==
Jetzt werden wir unser Widget irgendwo speichern. Er wird als .ui-Datei gespeichert, die wir einfach mittels pyuic zu einem Python-Skript wandeln werden. Unter Windows ist das pyuic-Programm meistens mit pyqt gebündelt (zu überprüfen), auf Linux werden Sie es wahrscheinlich extra mit Ihrem Paketmanager installieren müssen (auf Debian-beruhenden Systemen, ist es ein Teil des pyqt4-dev-tools Pakets). Für die Konvertierung müssen Sie ein Terminal-Fenster (oder ein Fenster der Eingabeaufforderung unter Windows) öffnen, in welchem Sie zu Ihrer .ui-Datei navigieren und dort dann folgendes eingeben:
+
Jetzt werden wir unser Widget irgendwo speichern. Er wird als .ui Datei gespeichert, die wir einfach mittels pyuic zu einem Python Skript wandeln werden. Unter Windows ist das pyuic Programm meistens mit pyqt gebündelt (zu überprüfen), auf Linux weirst du es wahrscheinlich extra mit deinem Paketmanager installieren müssen (auf Debian-basierten Systemen, ist es ein Teil des pyqt4-dev-tools Pakets). Für die Konvertierung musst du ein Terminalfenster (oder ein Fenster der Eingabeaufforderung unter Windows) öffnen, in welchem du zu deiner .ui Datei navigierst und dort dann folgendes eingibst:
 
{{Code|code=
 
{{Code|code=
 
pyuic mywidget.ui > mywidget.py
 
pyuic mywidget.ui > mywidget.py
 
}}
 
}}
Unter Windows ist pyuic.py in "C:\Python27\Lib\site-packages\PyQt4\uic\"zu finden. Zu Konvertierung legen wir die Batch-Datei "compQt4.bat" an:
+
Unter Windows befindet sich pyuic.py in "C:\Python27\Lib\site-Pakete\PyQt4\uic\pyuic.py".
 +
Erstelle für die Umwandlung eine Batchdatei mit dem Namen "compQt4.bat":
 
{{Code|code=
 
{{Code|code=
 
@"C:\Python27\python" "C:\Python27\Lib\site-packages\PyQt4\uic\pyuic.py" -x %1.ui > %1.py
 
@"C:\Python27\python" "C:\Python27\Lib\site-packages\PyQt4\uic\pyuic.py" -x %1.ui > %1.py
 
}}
 
}}
In der DOS-Konsole tippen Sie (ohne Dateierweiterung):
+
In der DOS Konsole tippe ohne Erweiterung
 
{{Code|code=
 
{{Code|code=
 
compQt4 myUiFile
 
compQt4 myUiFile
 
}}
 
}}
  
Unter Linux: to do
+
In Linux: Zu Tun
  
Nachdem sich FreeCAD nach v0.13 zunehmend von PyQt zugunsten von [http://qt-project.org/wiki/PySide PySide] entfernt hat (wählen Sie Ihre [http://pyside.readthedocs.org/en/latest/building/ building PySide]-Installation), müssen Sie zur Erstellung der Datei basierend auf PySide folgendes angeben:
+
Nachdem sich FreeCAD nach v0.13 zunehmend von PyQt zugunsten von [http://qt-project.org/wiki/PySide PySide] entfernt hat (Wähle deine PySide Installation [http://pyside.readthedocs.org/en/latest/building/ PySide bauen]), um die Datei auf der Basis von PySide zu erstellen, musst du jetzt verwenden:
  
 
{{Code|code=
 
{{Code|code=
Line 54: Line 68:
 
}}
 
}}
 
Unter Windows ist uic.py in "C:\Python27\Lib\site-packages\PySide\scripts\" zu finden.
 
Unter Windows ist uic.py in "C:\Python27\Lib\site-packages\PySide\scripts\" zu finden.
Erstellen Sie eine Batch-Datei namens "compSide.bat":
+
Zum Erstellen der Batchdatei "compSide.bat":
 
{{Code|code=
 
{{Code|code=
 
@"C:\Python27\python" "C:\Python27\Lib\site-packages\PySide\scripts\uic.py" %1.ui > %1.py
 
@"C:\Python27\python" "C:\Python27\Lib\site-packages\PySide\scripts\uic.py" %1.ui > %1.py
 
}}
 
}}
In der DOS-Konsole tippen Sie (ohne Dateierweiterung):
+
In die DOS Konsole tippe ohne Erweiterung
 
{{Code|code=
 
{{Code|code=
 
compSide myUiFile
 
compSide myUiFile
 
}}
 
}}
Unter Linux: to do
+
In Linux: Zu Tun
  
Auf einigen Systemen wird das Programm pyuic4 statt pyuic heißen. Das wird die .ui-Datei in ein Python-Skript umwandeln. Wenn wir die mywidget.py-Datei öffnen, ist der Inhalt sehr leicht zu verstehen:
+
Auf einigen Systemen wird das Programm pyuic4 statt pyuic genannt. Dadurch wird die .ui Datei einfach in ein Python Skript umgewandelt. Wenn wir die Datei mywidget.py öffnen, ist ihr Inhalt sehr leicht zu verstehen:
 
{{Code|code=
 
{{Code|code=
 
from PySide import QtCore, QtGui
 
from PySide import QtCore, QtGui
Line 86: Line 100:
 
         ...
 
         ...
 
}}
 
}}
Wie Sie sehen, hat es eine sehr einfache Struktur: eine Klasse genannt Ui_Dialog wird erstellt, die die Elemente der Benutzeroberfläche unseres Widgets speichert. Diese Klasse hat zwei Methoden, eine für die Einrichtung des Widgets und eine für die Übersetzung ihres Inhalts, was ein Teil des allgemeinen Qt-Mechanismus für die Übersetzung von Interface-Elementen ist. Das Setup-Verfahren erzeugt einfach eins nach dem anderen die Widgets, wie wir sie in Qt-Designer definiert haben und setzt ihre Optionen, die wir ebenfalls gewählt haben. Dann wird die ganze Schnittstelle schließlich übersetzt, die SLOTS werden verbunden (wir werden darüber später sprechen).
+
Wie du siehst, hat es eine sehr einfache Struktur: eine Klasse genannt Ui_Dialog wird erstellt, die die Elemente der Benutzeroberfläche unseres Widgets speichert. Diese Klasse hat zwei Methoden, eine für die Einrichtung des Widgets und eine für die Übersetzung ihres Inhalts, was ein Teil des allgemeinen Qt Mechanismus für die Übersetzung von Oberflächenelementen ist. Das Einrichtungsverfahren erzeugt einfach eins nach dem anderen die Widgets, wie wir sie in Qt Designer festgelegt haben und setzt ihre Optionen, die wir ebenfalls gewählt haben. Dann wird die ganze Schnittstelle schließlich übersetzt, die Slots werden verbunden (wir werden darüber später sprechen).
  
Wir können jetzt ein neues Widget erstellen und diese Klasse verwenden, um seine Schnittstelle zu schaffen. Wir können bereits unser Widget in Aktion sehen, indem wir unsere mywidget.py Datei an einem Ort speichern, wo FreeCAD es findet (im FreeCAD bin-Verzeichnis, oder in einem der Mod-Unterverzeichnisse), und dann im FreeCAD Python-Interpreter eintippen:
+
Wir können jetzt ein neues Widget erstellen und diese Klasse verwenden, um seine Oberfläche zu schaffen. Wir können bereits unser Widget in Aktion sehen, indem wir unsere mywidget.py Datei an einem Ort speichern, wo FreeCAD es findet (im FreeCAD bin Verzeichnis, oder in einem der Mod Unterverzeichnisse), und dann im FreeCAD Python Interpreter eintippen:
 
{{Code|code=
 
{{Code|code=
 
from PySide import QtGui
 
from PySide import QtGui
Line 97: Line 111:
 
d.show()
 
d.show()
 
}}
 
}}
Und unser Dialog wird erscheinen! Beachten Sie, dass unser Python-Interpreter immer noch arbeitet, wir haben einen nichtmodalen Dialog. Um es zu abzuschließen, können wir (abgesehen von einem Klick auf das Schließen-Symbol, natürlich) eingeben:
+
Und unser Dialog wird erscheinen! Beachte, dass unser Python Interpreter immer noch arbeitet, wir haben einen nichtmodalen Dialog. Um es zu abzuschließen, können wir (abgesehen von einem Klick auf das Schließen Symbol, natürlich) eingeben:
 
{{Code|code=
 
{{Code|code=
 
d.hide()
 
d.hide()
 
}}
 
}}
  
== Lassen wir unseren Dialog etwas tun ==
+
== Unseren Dialog etwas tun lassen ==
Wo wir jetzt unseren Dialog schon anzeigen und ausblenden können, gibt es nur eines zu tun: Es muss auch etwas ausführen! Wenn Sie ein bisschen mit dem Qt-Designer spielen, entdecken Sie schnell eine ganze Abteilung genannt "Signale und Slots". Grundsätzlich funktioniert es so: Elemente auf Ihren Widgets (in Qt-Terminologie, diese Elemente sind selbst Widgets) können Signale senden. Diese Signale unterscheiden sich je nach Widget-Typ. Zum Beispiel kann eine Taste ein Signal senden, wenn sie gedrückt wird und wenn sie losgelassen wird. Diese Signale können mit Slots verbunden werden, die spezielle Funktionen von anderen Widgets (z. B. einen Dialog, einen "close"-Slot, auf den Sie das Signal von einem Schließen-Button verbinden) oder benutzerdefinierte Funktionen sein können. Die Seite [http://www.riverbankcomputing.co.uk/static/Docs/PyQt4/html/classes.html PyQt Reference Documentation] listet alle Qt-Widgets, was sie tun können, welche Signale sie senden können, etc.
+
Nun, da wir unseren Dialog ein- und ausblenden können, müssen wir nur noch einen letzten Teil hinzufügen: Damit er etwas bewirkt! Wenn du ein wenig mit dem Qt Designer spielst, wirst du schnell einen ganzen Abschnitt namens "Signals and Slots" entdecken. Im Grunde funktioniert es so: Elemente auf deinen Widgets (in der Qt Terminologie sind diese Elemente selbst Widgets) können Signale senden. Diese Signale unterscheiden sich je nach Widget Typ. Zum Beispiel kann eine Taste ein Signal senden, wenn sie gedrückt wird und wenn sie losgelassen wird. Diese Signale können mit Slots verbunden werden, was eine spezielle Funktionalität anderer Widgets sein kann (z.B. hat ein Dialog einen "Schließ" Slot, mit dem du das Signal von einer Schaltfläche zum Schließen verbinden kannst), oder es können benutzerdefinierte Funktionen sein. Die [http://www.riverbankcomputing.co.uk/static/Docs/PyQt4/html/classes.html PyQt Referenzdokumentation] listet alle qt Widgets auf, was sie können, welche Signale sie senden können, usw..
  
Was wir hier tun werden, ist eine neue Funktion zu erstellen, die eine Ebene erzeugt, beruhend auf Höhe und Breite, und in Verbindung steht diese Funktion mit dem "gedrückt"-Signal, das unser "Create"-Knopf abgibt. Also wollen wir mit dem Importieren unserer FreeCAD Module beginnen, indem Sie die folgende Zeile am Anfang des Skripts, wo wir bereits QtCore und QtGui importieren, einfügen:
+
Was wir hier tun werden, ist eine neue Funktion zu erstellen, die eine Ebene erzeugt, beruhend auf Höhe und Breite, und in Verbindung steht diese Funktion mit dem gedrückt Signal, das unser "Create" Knopf abgibt. Also lass uns mit dem Importieren unserer FreeCAD Module beginnen, durch setzen der folgenden Zeile an den Anfang des Skripts, wo wir bereits QtCore und QtGui importieren:
 
{{Code|code=
 
{{Code|code=
 
import FreeCAD, Part
 
import FreeCAD, Part
 
}}
 
}}
Jetzt werden wir eine neue Funktion in unsere Ui_Dialog-Klasse einfügen:
+
Dann lass uns eine neue Funktion zu unserer Ui_Dialog Klasse hinzufügen:
 
{{Code|code=
 
{{Code|code=
 
def createPlane(self):
 
def createPlane(self):
Line 130: Line 144:
 
         self.hide()
 
         self.hide()
 
}}
 
}}
Nun müssen wir Qt klarmachen, dass der Knopf mit der Funktion verbunden werden muss. Dazu geben wir die folgende Zeile ein, aber VOR der Zeile QtCore.QMetaObject.connectSlotsByName(Dialog):
+
Dann müssen wir Qt mitteilen, dass die Schaltfläche mit der Funktion verbunden werden soll, indem wir die folgende Zeile unmittelbar vor QtCore.QMetaObject.connectSlotsByName(Dialog) setzen:
 
{{Code|code=
 
{{Code|code=
 
QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)
 
QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)
 
}}
 
}}
Dies, wie Sie sehen, verbindet das pressed()-Signal unseres create-Objekts (den "Create!" button), zu einem Slot mit Namen createPlane, den wir gerade definiert haben. Das ist alles! Jetzt, als eine Feinschliff, können wir eine kleine Funktion hinzufügen, um den Dialog zu erzeugen, dadurch wird der Aufruf erleichtert. Außerhalb der Ui_Dialog Klasse, wollen wir diesen Code hinzufügen:
+
Dies verbindet, wie du siehst, das pressed() Signal unseres create Objekts (die Schaltfläche "Create!") mit einem Slot namens createPlane, den wir gerade definiert haben. Das war's! Als letzten Schliff können wir nun noch eine kleine Funktion zum Erstellen des Dialogs hinzufügen, die einfacher aufzurufen sein wird. Außerhalb der Klasse Ui_Dialog fügen wir diesen Code hinzu:
 
{{Code|code=
 
{{Code|code=
 
class plane():
 
class plane():
Line 143: Line 157:
 
       self.d.show()
 
       self.d.show()
 
}}
 
}}
(Python-Erinnerung: Die __init__-Methode einer Klasse wird automatisch ausgeführt, wenn ein neues Objekt erzeugt wird!)
+
(Python Erinnerung: Die __init__ Methode einer Klasse wird automatisch ausgeführt, wenn ein neues Objekt erzeugt wird!)
 
+
Dann brauchen wir von FreeCAD aus nur folgendes zu tun:
Dann brauchen wir in FreeCAD (Pythonkonsole) nur noch folgendes zu tun:
 
 
{{Code|code=
 
{{Code|code=
 
import mywidget
 
import mywidget
 
myDialog = mywidget.plane()
 
myDialog = mywidget.plane()
 
}}
 
}}
Das ist alles, Leute ... Jetzt können Sie alle möglichen Dinge versuchen, wie zum Beispiel das Einfügen Ihres Widgets in die FreeCAD-Oberfläche (siehe [[Code snippets/de]]-Seite) oder erstellen Sie weitere, fortgeschrittene benutzerdefinierte Tools, durch die Verwendung anderer Elemente auf Ihrem Widget.
+
Das ist alles, Leute... Jetzt kannst du alle möglichen Dinge ausprobieren, wie z.B. dein Widget in die FreeCAD Oberfläche einzufügen (siehe die [[Code snippets/de|Code Schnipsel]] Seite), oder viel fortgeschrittenere, eigene Werkzeuge zu erstellen, indem du andere Elemente auf deinem Widget verwendest.
 
 
== Das komplette Script ==
 
  
Dies ist das komplette Script, nur als Referenz:
+
== Das komplette Skript ==
 +
Dies ist das vollständige Skript, als Referenz:
 
{{Code|code=
 
{{Code|code=
# -*- coding: utf-8 -*-
 
 
 
# Form implementation generated from reading ui file 'mywidget.ui'
 
# Form implementation generated from reading ui file 'mywidget.ui'
 
#
 
#
Line 196: Line 206:
  
 
   def retranslateUi(self, Dialog):
 
   def retranslateUi(self, Dialog):
       Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
+
       Dialog.setWindowTitle("Dialog")
       self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
+
       self.title.setText("Plane-O-Matic")
       self.label_width.setText(QtGui.QApplication.translate("Dialog", "Width", None, QtGui.QApplication.UnicodeUTF8))
+
       self.label_width.setText("Width")
       self.label_height.setText(QtGui.QApplication.translate("Dialog", "Height", None, QtGui.QApplication.UnicodeUTF8))
+
       self.label_height.setText("Height")
       self.create.setText(QtGui.QApplication.translate("Dialog", "Create!", None, QtGui.QApplication.UnicodeUTF8))
+
       self.create.setText("Create!")
 
+
      print("tyty")
 
   def createPlane(self):
 
   def createPlane(self):
 
       try:
 
       try:
Line 221: Line 231:
  
 
class plane():
 
class plane():
  def __init__(self):
+
  def __init__(self):
      self.d = QtGui.QWidget()
+
      self.d = QtGui.QWidget()
      self.ui = Ui_Dialog()
+
      self.ui = Ui_Dialog()
      self.ui.setupUi(self.d)
+
      self.ui.setupUi(self.d)
      self.d.show()
+
      self.d.show()
}}
 
==Erstellung eines Dialogs mit Knöpfen==
 
 
 
===Methode 1===
 
Ein Beispiel einer Dialog-Box komplett mit Verbindungen.
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
# Create by flachyjoe
 
 
 
from PySide import QtCore, QtGui
 
 
 
try:
 
    _fromUtf8 = QtCore.QString.fromUtf8
 
except AttributeError:
 
    def _fromUtf8(s):
 
        return s
 
 
 
try:
 
    _encoding = QtGui.QApplication.UnicodeUTF8
 
    def _translate(context, text, disambig):
 
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
 
except AttributeError:
 
    def _translate(context, text, disambig):
 
        return QtGui.QApplication.translate(context, text, disambig)
 
 
 
 
 
class Ui_MainWindow(object):
 
 
 
    def __init__(self, MainWindow):
 
        self.window = MainWindow
 
 
 
        MainWindow.setObjectName(_fromUtf8("MainWindow"))
 
        MainWindow.resize(400, 300)
 
        self.centralWidget = QtGui.QWidget(MainWindow)
 
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))
 
 
 
        self.pushButton = QtGui.QPushButton(self.centralWidget)
 
        self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
 
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
 
        self.pushButton.clicked.connect(self.on_pushButton_clicked) #connection pushButton
 
 
 
        self.lineEdit = QtGui.QLineEdit(self.centralWidget)
 
        self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
 
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
 
        self.lineEdit.returnPressed.connect(self.on_lineEdit_clicked) #connection lineEdit
 
 
 
        self.checkBox = QtGui.QCheckBox(self.centralWidget)
 
        self.checkBox.setGeometry(QtCore.QRect(30, 90, 81, 20))
 
        self.checkBox.setChecked(True)
 
        self.checkBox.setObjectName(_fromUtf8("checkBoxON"))
 
        self.checkBox.clicked.connect(self.on_checkBox_clicked) #connection checkBox
 
 
 
        self.radioButton = QtGui.QRadioButton(self.centralWidget)
 
        self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
 
        self.radioButton.setObjectName(_fromUtf8("radioButton"))
 
        self.radioButton.clicked.connect(self.on_radioButton_clicked) #connection radioButton
 
 
 
        MainWindow.setCentralWidget(self.centralWidget)
 
 
 
        self.menuBar = QtGui.QMenuBar(MainWindow)
 
        self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 26))
 
        self.menuBar.setObjectName(_fromUtf8("menuBar"))
 
        MainWindow.setMenuBar(self.menuBar)
 
 
 
        self.mainToolBar = QtGui.QToolBar(MainWindow)
 
        self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
 
        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
 
 
 
        self.statusBar = QtGui.QStatusBar(MainWindow)
 
        self.statusBar.setObjectName(_fromUtf8("statusBar"))
 
        MainWindow.setStatusBar(self.statusBar)
 
 
 
        self.retranslateUi(MainWindow)
 
 
 
    def retranslateUi(self, MainWindow):
 
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
 
        self.pushButton.setText(_translate("MainWindow", "OK", None))
 
        self.lineEdit.setText(_translate("MainWindow", "tyty", None))
 
        self.checkBox.setText(_translate("MainWindow", "CheckBox", None))
 
        self.radioButton.setText(_translate("MainWindow", "RadioButton", None))
 
 
 
    def on_checkBox_clicked(self):
 
        if self.checkBox.checkState()==0:
 
            App.Console.PrintMessage(str(self.checkBox.checkState())+"  CheckBox KO\r\n")
 
        else:   
 
            App.Console.PrintMessage(str(self.checkBox.checkState())+" CheckBox OK\r\n")
 
#        App.Console.PrintMessage(str(self.lineEdit.setText("tititi"))+" LineEdit\r\n") #write text to the lineEdit window !
 
#        str(self.lineEdit.setText("tititi")) #écrit le texte dans la fenêtre lineEdit
 
        App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit\r\n")
 
 
 
    def on_radioButton_clicked(self):
 
        if self.radioButton.isChecked():
 
            App.Console.PrintMessage(str(self.radioButton.isChecked())+" Radio OK\r\n")
 
        else:
 
            App.Console.PrintMessage(str(self.radioButton.isChecked())+"  Radio KO\r\n")
 
 
 
    def on_lineEdit_clicked(self):
 
#        if self.lineEdit.textChanged():
 
            App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit Display\r\n")
 
 
 
    def on_pushButton_clicked(self):
 
        App.Console.PrintMessage("Terminé\r\n")
 
        self.window.hide()
 
 
 
MainWindow = QtGui.QMainWindow()
 
ui = Ui_MainWindow(MainWindow)
 
MainWindow.show()
 
}}
 
Hier das gleiche Fenster, aber mit einem Piktogramm (icon) auf jedem Knopf.
 
 
 
Laden Sie die verbundenen Piktogramme herunter (rechtsklick auf "Copy the image below...")
 
 
 
[[File:Icone01.png]]  [[File:Icone02.png]]  [[File:Icone03.png]]
 
 
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
 
 
from PySide import QtCore, QtGui
 
 
 
try:
 
    _fromUtf8 = QtCore.QString.fromUtf8
 
except AttributeError:
 
    def _fromUtf8(s):
 
        return s
 
 
 
try:
 
    _encoding = QtGui.QApplication.UnicodeUTF8
 
    def _translate(context, text, disambig):
 
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
 
except AttributeError:
 
    def _translate(context, text, disambig):
 
        return QtGui.QApplication.translate(context, text, disambig)
 
 
 
 
 
class Ui_MainWindow(object):
 
 
 
    def __init__(self, MainWindow):
 
        self.window = MainWindow
 
        path = FreeCAD.ConfigGet("UserAppData")
 
#        path = FreeCAD.ConfigGet("AppHomePath")
 
 
 
        MainWindow.setObjectName(_fromUtf8("MainWindow"))
 
        MainWindow.resize(400, 300)
 
        self.centralWidget = QtGui.QWidget(MainWindow)
 
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))
 
 
 
        self.pushButton = QtGui.QPushButton(self.centralWidget)
 
        self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
 
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
 
        self.pushButton.clicked.connect(self.on_pushButton_clicked) #connection pushButton
 
 
 
        self.lineEdit = QtGui.QLineEdit(self.centralWidget)
 
        self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
 
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
 
        self.lineEdit.returnPressed.connect(self.on_lineEdit_clicked) #connection lineEdit
 
 
 
        self.checkBox = QtGui.QCheckBox(self.centralWidget)
 
        self.checkBox.setGeometry(QtCore.QRect(30, 90, 100, 20))
 
        self.checkBox.setChecked(True)
 
        self.checkBox.setObjectName(_fromUtf8("checkBoxON"))
 
        self.checkBox.clicked.connect(self.on_checkBox_clicked) #connection checkBox
 
 
 
        self.radioButton = QtGui.QRadioButton(self.centralWidget)
 
        self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
 
        self.radioButton.setObjectName(_fromUtf8("radioButton"))
 
        self.radioButton.clicked.connect(self.on_radioButton_clicked) #connection radioButton
 
 
 
        MainWindow.setCentralWidget(self.centralWidget)
 
 
 
        self.menuBar = QtGui.QMenuBar(MainWindow)
 
        self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 26))
 
        self.menuBar.setObjectName(_fromUtf8("menuBar"))
 
        MainWindow.setMenuBar(self.menuBar)
 
 
 
        self.mainToolBar = QtGui.QToolBar(MainWindow)
 
        self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
 
        MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
 
 
 
        self.statusBar = QtGui.QStatusBar(MainWindow)
 
        self.statusBar.setObjectName(_fromUtf8("statusBar"))
 
        MainWindow.setStatusBar(self.statusBar)
 
 
 
        self.retranslateUi(MainWindow)
 
 
 
        # Affiche un icone sur le bouton PushButton
 
        # self.image_01 = "C:\Program Files\FreeCAD0.13\Icone01.png" # adapt the icon name
 
        self.image_01 = path+"Icone01.png" # adapt the name of the icon
 
        icon01 = QtGui.QIcon()
 
        icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
 
        self.pushButton.setIcon(icon01)
 
        self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button
 
 
 
        # Affiche un icone sur le bouton RadioButton
 
        # self.image_02 = "C:\Program Files\FreeCAD0.13\Icone02.png" # adapt the name of the icon
 
        self.image_02 = path+"Icone02.png" # adapter le nom de l'icone
 
        icon02 = QtGui.QIcon()
 
        icon02.addPixmap(QtGui.QPixmap(self.image_02),QtGui.QIcon.Normal, QtGui.QIcon.Off)
 
        self.radioButton.setIcon(icon02)
 
        # self.radioButton.setLayoutDirection(QtCore.Qt.RightToLeft) #  This command reverses the direction of the button
 
 
 
        # Affiche un icone sur le bouton CheckBox
 
        # self.image_03 = "C:\Program Files\FreeCAD0.13\Icone03.png" # the name of the icon
 
        self.image_03 = path+"Icone03.png" # adapter le nom de l'icone
 
        icon03 = QtGui.QIcon()
 
        icon03.addPixmap(QtGui.QPixmap(self.image_03),QtGui.QIcon.Normal, QtGui.QIcon.Off)
 
        self.checkBox.setIcon(icon03)
 
        # self.checkBox.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button
 
 
 
 
 
    def retranslateUi(self, MainWindow):
 
        MainWindow.setWindowTitle(_translate("MainWindow", "FreeCAD", None))
 
        self.pushButton.setText(_translate("MainWindow", "OK", None))
 
        self.lineEdit.setText(_translate("MainWindow", "tyty", None))
 
        self.checkBox.setText(_translate("MainWindow", "CheckBox", None))
 
        self.radioButton.setText(_translate("MainWindow", "RadioButton", None))
 
 
 
    def on_checkBox_clicked(self):
 
        if self.checkBox.checkState()==0:
 
            App.Console.PrintMessage(str(self.checkBox.checkState())+"  CheckBox KO\r\n")
 
        else:   
 
            App.Console.PrintMessage(str(self.checkBox.checkState())+" CheckBox OK\r\n")
 
          # App.Console.PrintMessage(str(self.lineEdit.setText("tititi"))+" LineEdit\r\n") # write text to the lineEdit window !
 
          # str(self.lineEdit.setText("tititi")) #écrit le texte dans la fenêtre lineEdit
 
        App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit\r\n")
 
 
 
    def on_radioButton_clicked(self):
 
        if self.radioButton.isChecked():
 
            App.Console.PrintMessage(str(self.radioButton.isChecked())+" Radio OK\r\n")
 
        else:
 
            App.Console.PrintMessage(str(self.radioButton.isChecked())+"  Radio KO\r\n")
 
 
 
    def on_lineEdit_clicked(self):
 
          # if self.lineEdit.textChanged():
 
          App.Console.PrintMessage(str(self.lineEdit.displayText())+" LineEdit Display\r\n")
 
 
 
    def on_pushButton_clicked(self):
 
        App.Console.PrintMessage("Terminé\r\n")
 
        self.window.hide()
 
 
 
MainWindow = QtGui.QMainWindow()
 
ui = Ui_MainWindow(MainWindow)
 
MainWindow.show()
 
}}
 
Hier der Code, um das Piktogramm auf dem '''pushButton''' anzuzeigen, den Namen eines anderen Knopfes zu ändern ('''radioButton, checkBox''') und den Pfad des Piktogramms.
 
{{Code|code=
 
        # Affiche un icône sur le bouton PushButton
 
        # self.image_01 = "C:\Program Files\FreeCAD0.13\icone01.png" # the name of the icon
 
        self.image_01 = path+"icone01.png" # the name of the icon
 
        icon01 = QtGui.QIcon()
 
        icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
 
        self.pushButton.setIcon(icon01)
 
        self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button
 
}}
 
Der Befehl '''UserAppData''' liefert den Benutzer-Pfad,
 
'''AppHomePath''' den Installationspfad von FreeCAD
 
{{Code|code=
 
#        path = FreeCAD.ConfigGet("UserAppData")
 
        path = FreeCAD.ConfigGet("AppHomePath")
 
}}
 
Dieser Befehl vertauscht die horizontale Ausrichtung der Schaltfläche (rechts und links).
 
{{Code|code=
 
self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button
 
}}
 
 
 
===Methode 2===
 
Eine weitere Methode zur Anzeige eines Fensters, hier durch Erstellung einer Datei '''QtForm.py''', die das Header-Programm enthält (ein Modul aufgerufen mit '''import QtForm''') und ein zweites Modul, das das Code-Fenster all dieser Zusatzteile enthält und Ihren Code (das aufrufende Modul).
 
 
 
Diese Methode erfordert zwei separate Dateien, erlaubt aber die Verkürzung Ihres Programms durch den Import der Datei ''QtForm.py''.
 
Dann verteilen Sie diese beiden Dateien zusammen, denn sie sind "untrennbar".
 
 
 
Die Datei '''QtForm.py'''
 
{{Code|code=
 
 
 
# -*- coding: utf-8 -*-
 
# Create by flachyjoe
 
from PySide import QtCore, QtGui
 
 
 
try:
 
    _fromUtf8 = QtCore.QString.fromUtf8
 
except AttributeError:
 
  def _fromUtf8(s):
 
      return s
 
 
 
try:
 
    _encoding = QtGui.QApplication.UnicodeUTF8
 
    def _translate(context, text, disambig):
 
      return QtGui.QApplication.translate(context, text, disambig, _encoding)
 
except AttributeError:
 
  def _translate(context, text, disambig):
 
      return QtGui.QApplication.translate(context, text, disambig)
 
 
 
class Form(object):
 
  def __init__(self, title, width, height):
 
      self.window = QtGui.QMainWindow()
 
      self.title=title
 
      self.window.setObjectName(_fromUtf8(title))
 
      self.window.setWindowTitle(_translate(self.title, self.title, None))
 
      self.window.resize(width, height)
 
 
 
  def show(self):
 
      self.createUI()
 
      self.retranslateUI()
 
      self.window.show()
 
 
 
  def setText(self, control, text):
 
      control.setText(_translate(self.title, text, None))
 
}}
 
Die aufrufende Datei, die das Fenster und Ihren Code enthält.
 
 
 
Die Datei my_file.py
 
 
 
Die Verbindungen fehlen noch, eine gute Übung.
 
{{Code|code=
 
 
 
# -*- coding: utf-8 -*-
 
# Create by flachyjoe
 
from PySide import QtCore, QtGui
 
import QtForm
 
 
 
class myForm(QtForm.Form):
 
  def createUI(self):
 
      self.centralWidget = QtGui.QWidget(self.window)
 
      self.window.setCentralWidget(self.centralWidget)
 
     
 
      self.pushButton = QtGui.QPushButton(self.centralWidget)
 
      self.pushButton.setGeometry(QtCore.QRect(30, 170, 93, 28))
 
      self.pushButton.clicked.connect(self.on_pushButton_clicked)
 
     
 
      self.lineEdit = QtGui.QLineEdit(self.centralWidget)
 
      self.lineEdit.setGeometry(QtCore.QRect(30, 40, 211, 22))
 
     
 
      self.checkBox = QtGui.QCheckBox(self.centralWidget)
 
      self.checkBox.setGeometry(QtCore.QRect(30, 90, 81, 20))
 
      self.checkBox.setChecked(True)
 
     
 
      self.radioButton = QtGui.QRadioButton(self.centralWidget)
 
      self.radioButton.setGeometry(QtCore.QRect(30, 130, 95, 20))
 
 
 
  def retranslateUI(self):
 
      self.setText(self.pushButton, "Fermer")
 
      self.setText(self.lineEdit, "essais de texte")
 
      self.setText(self.checkBox, "CheckBox")
 
      self.setText(self.radioButton, "RadioButton")
 
 
 
  def on_pushButton_clicked(self):
 
      self.window.hide()
 
 
 
myWindow=myForm("Fenetre de test",400,300)
 
myWindow.show()
 
}}
 
 
 
'''Weiteres Beispiel'''
 
<center>
 
<gallery widths="400" heights="200">
 
Image:Qt_Example_00.png|Qt-Beispiel 1
 
Image:Qt_Example_01.png|Qt-Beispiel-Details
 
</gallery>
 
</center>
 
{{clear}}
 
 
 
Behandelt werden:
 
 
 
# Piktogramm für Fenster
 
# horizontaler Schieber (horizontalSlider)
 
# Fortschrittbalken, horizontal (progressBar horizontal)
 
# vertikaler Schieber (verticalSlider)
 
# Fortschrittbalken, vertikal (progressBar vertical)
 
# lineEdit
 
# lineEdit
 
# doubleSpinBox
 
# doubleSpinBox
 
# doubleSpinBox
 
# Knopf (button)
 
# Knopf (button)
 
# Radio-Knopf mit Piktogrammen (radioButton with icons)
 
# Ankreuzfeld mit Piktogramm [aktiviert/deaktiviert] (checkBox with icon checked and unchecked)
 
# textEdit
 
# Grafikansicht mit zwei Graphen (graphicsView with 2 graphes)
 
Die Code-Seite und die Piktogramme [[Qt_Example/de|Qt_Beispiel]]
 
 
 
==Personalisiertes Piktogramm in der Combo-Ansicht==
 
 
 
Hier ein Beispiel der Erstellung eines Objekts mit verschiedenen Eigenschaften, verbunden mit einem persönlichen Piktogramm.
 
 
 
Laden Sie das Beispielpiktogramm in das gleiche Verzeichnis herunter wie das Makro [[File:FreeCADIco.png|Beispielpiktogramm für das Makro|24px]]
 
 
 
Drei Verwendungszwecke eines Piktogramms, ein Dateipiktogramm im .png-Format auf der Diskette, ein Piktogramm im .xpm-Format im gleichen Makro und ein Piktogramm verfügbar in den FreeCAD-Ressourcen.
 
 
 
[[File:Qt_Example_02.png|icon personalised]]
 
{{clear}}
 
 
 
{{Code|code=
 
import PySide
 
import FreeCAD, FreeCADGui, Part
 
from pivy import coin
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import *
 
from PySide.QtCore import *
 
import Draft
 
 
 
global path
 
param = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Macro")# macro path in FreeCAD preferences
 
path = param.GetString("MacroPath","") + "/"                        # macro path
 
path = path.replace("\\","/")                                      # convert the "\" to "/"
 
 
 
 
 
class IconViewProviderToFile:                                      # Class ViewProvider create Property view of object
 
    def __init__( self, obj, icon):
 
        self.icone = icon
 
       
 
    def getIcon(self):                                              # GetIcon
 
        return self.icone
 
       
 
    def attach(self, obj):                                          # Property view of object
 
        self.modes = []
 
        self.modes.append("Flat Lines")
 
        self.modes.append("Shaded")
 
        self.modes.append("Wireframe")
 
        self.modes.append("Points")
 
        obj.addDisplayMode( coin.SoGroup(),"Flat Lines" )          # Display Mode
 
        obj.addDisplayMode( coin.SoGroup(),"Shaded" )
 
        obj.addDisplayMode( coin.SoGroup(),"Wireframe" )
 
        obj.addDisplayMode( coin.SoGroup(),"Points" )
 
        return self.modes
 
 
 
    def getDisplayModes(self,obj):
 
        return self.modes
 
 
 
#####################################################
 
########## Example with icon to file # begin ########
 
#####################################################
 
 
 
object1 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_In_File_Disk")                                    # create your object
 
object1.addProperty("App::PropertyString","Identity", "ExampleTitle0", "Identity of object").Identity = "FCSpring"        # Identity of object
 
object1.addProperty("App::PropertyFloat" ,"Pitch",    "ExampleTitle0", "Pitch betwen 2 heads").Pitch  = 2.0              # other Property Data
 
object1.addProperty("App::PropertyBool"  ,"View",    "ExampleTitle1", "Hello world").View            = True              # ...
 
object1.addProperty("App::PropertyColor" ,"LineColor","ExampleTitle2", "Color to choice").LineColor  = (0.13,0.15,0.37)  # ...
 
#...other Property Data
 
#...other Property Data
 
#
 
object1.ViewObject.Proxy = IconViewProviderToFile( object1, path + "FreeCADIco.png")                                      # icon download to file
 
App.ActiveDocument.recompute()
 
#
 
#__Detail__:
 
# FreeCAD.ActiveDocument.addObject( = create now object personalized
 
# "App::FeaturePython",            = object as FeaturePython
 
# "Icon_In_File_Disk")              = internal name of your object
 
#
 
#
 
# "App::PropertyString",    = type of Property , availlable : PropertyString, PropertyFloat, PropertyBool, PropertyColor
 
# "Identity",              = name of the feature
 
# "ExampleTitle0",          = title of the "section"
 
# "Identity of object")    = tooltip displayed on mouse
 
# .Identity                = variable (same of name of the feature)
 
# object1.ViewObject.Proxy  = create the view object and gives the icon
 
#
 
########## example with icon to file end
 
 
 
 
 
 
 
#####################################################
 
########## Example with icon in macro # begin #######
 
#####################################################
 
 
 
def setIconInMacro(self):        # def contener the icon in format .xpm
 
    # File format XPM created by Gimp "https://www.gimp.org/"
 
    # Choice palette Tango
 
    # Create your masterwork ...
 
    # For export the image in XPM format
 
    #    Menu File > Export as > .xpm
 
    # (For convert image true color in Tango color palette :
 
    #    Menu Image > Mode > Indexed ... > Use custom palette > Tango Icon Theme > Convert)
 
    return """
 
            /* XPM */
 
            static char * XPM[] = {
 
            "22 24 5 1",
 
            " c None",
 
            ". c #CE5C00",
 
            "+ c #EDD400",
 
            "@ c #F57900",
 
            "# c #8F5902",
 
            "                      ",
 
            "                      ",
 
            "  ....                ",
 
            "  ..@@@@..            ",
 
            "  . ...@......        ",
 
            "  .+++++++++...      ",
 
            "  .      ....++...    ",
 
            "  .@..@@@@@@.+++++..  ",
 
            "  .@@@@@..#  ++++ ..  ",
 
            "  .      ++++  .@..  ",
 
            "  .++++++++  .@@@.+.  ",
 
            " .      ..@@@@@. ++.  ",
 
            " ..@@@@@@@@@.  +++ .  ",
 
            " ....@...# +++++ @..  ",
 
            " .    ++++++++ .@. .  ",
 
            " .++++++++  .@@@@ .  ",
 
            " .  #....@@@@. ++.  ",
 
            " .@@@@@@@@@.. +++ .  ",
 
            " ........  +++++...  ",
 
            " ...  ..+++++ ..@..  ",
 
            "    ......  .@@@ +.  ",
 
            "          ......++.  ",
 
            "                ...  ",
 
            "                      "};
 
        """
 
 
 
object2 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_XPM_In_Macro")                                    #
 
object2.addProperty("App::PropertyString","Identity","ExampleTitle","Identity of object").Identity = "FCSpring"
 
#...other Property Data
 
#...other Property Data
 
#
 
object2.ViewObject.Proxy = IconViewProviderToFile( object2, setIconInMacro(""))              # icon in macro (.XPM)
 
App.ActiveDocument.recompute()
 
########## example with icon in macro end
 
 
 
 
 
 
 
####################################################################
 
########## Example with icon to FreeCAD ressource # begin ##########
 
####################################################################
 
 
 
object3 = FreeCAD.ActiveDocument.addObject("App::FeaturePython", "Icon_Ressource_FreeCAD")                              #
 
object3.addProperty("App::PropertyString","Identity","ExampleTitle","Identity of object").Identity = "FCSpring"
 
#...other Property Data
 
#...other Property Data
 
#
 
object3.ViewObject.Proxy = IconViewProviderToFile( object3, ":/icons/Draft_Draft.svg")      # icon to FreeCAD ressource
 
App.ActiveDocument.recompute()
 
########## example with icon to FreeCAD ressource end
 
 
 
}}
 
 
 
Vollständiges Beispiel der Erstellung eines Würfels zusammen mit Piktogramm
 
 
 
{{Code|code=
 
#https://forum.freecadweb.org/viewtopic.php?t=10255#p83319
 
import FreeCAD, Part, math
 
from FreeCAD import Base
 
from PySide import QtGui
 
 
 
global path
 
param = FreeCAD.ParamGet("User parameter:BaseApp/Preferences/Macro")# macro path in FreeCAD preferences
 
path = param.GetString("MacroPath","") + "/"                        # macro path
 
path = path.replace("\\","/")                                      # convert the "\" to "/"
 
 
 
def setIconInMacro(self):
 
    return """
 
        /* XPM */
 
        static char * xpm[] = {
 
        "22 22 12 1",
 
        " c None",
 
        ". c #A40000",
 
        "+ c #2E3436",
 
        "@ c #CE5C00",
 
        "# c #F57900",
 
        "$ c #FCAF3E",
 
        "% c #5C3566",
 
        "& c #204A87",
 
        "* c #555753",
 
        "= c #3465A4",
 
        "- c #4E9A06",
 
        "; c #729FCF",
 
        "                      ",
 
        "                      ",
 
        "                      ",
 
        "        ..  ..      ",
 
        "      +@#+++.$$      ",
 
        "      +.#+%..$$      ",
 
        "      &*$  &*#*      ",
 
        "      &  =&=  =      ",
 
        "  ++&  +.==  %=    ",
 
        "  ++$@ ..$ %=  &    ",
 
        "  ..-&%.#$$ &## +=$  ",
 
        "  .#  ..$ ..#%%.#$$  ",
 
        "    ;    =+=## %-$#  ",
 
        "    &=  ;&  %=    ",
 
        "      ;+ &=;  %=      ",
 
        "      ++$- +*$-      ",
 
        "      .#&&+.@$$      ",
 
        "      ..$# ..$#      ",
 
        "      ..  ..        ",
 
        "                      ",
 
        "                      ",
 
        "                      "};
 
        """
 
 
 
class PartFeature:
 
    def __init__(self, obj):
 
        obj.Proxy = self
 
 
 
class Box(PartFeature):
 
    def __init__(self, obj):
 
        PartFeature.__init__(self, obj)
 
        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
 
 
 
    def onChanged(self, fp, prop):
 
        try:
 
            if prop == "Length" or prop == "Width" or prop == "Height":
 
                fp.Shape = Part.makeBox(fp.Length,fp.Width,fp.Height)
 
        except:
 
            pass
 
 
 
    def execute(self, fp):
 
        fp.Shape = Part.makeBox(fp.Length,fp.Width,fp.Height)
 
 
 
class ViewProviderBox:
 
    def __init__(self, obj, icon):
 
        obj.Proxy  = self
 
        self.icone = icon
 
       
 
    def getIcon(self):
 
        return self.icone
 
 
 
    def attach(self, obj):
 
        return
 
 
 
    def setupContextMenu(self, obj, menu):
 
        action = menu.addAction("Set default height")
 
        action.triggered.connect(lambda f=self.setDefaultHeight, arg=obj:f(arg))
 
 
 
        action = menu.addAction("Hello World")
 
        action.triggered.connect(self.showHelloWorld)
 
 
 
    def setDefaultHeight(self, view):
 
        view.Object.Height = 15.0
 
 
 
    def showHelloWorld(self):
 
        QtGui.QMessageBox.information(None, "Hi there", "Hello World")
 
 
 
def makeBox():
 
    FreeCAD.newDocument()
 
    a=FreeCAD.ActiveDocument.addObject("Part::FeaturePython","Box")
 
    Box(a)
 
#    ViewProviderBox(a.ViewObject, path + "FreeCADIco.png")    # icon download to file
 
#    ViewProviderBox(a.ViewObject,  ":/icons/Draft_Draft.svg") # icon to FreeCAD ressource
 
    ViewProviderBox(a.ViewObject,  setIconInMacro(""))        # icon in macro (.XPM)
 
    App.ActiveDocument.recompute()
 
 
 
makeBox()
 
 
 
 
 
}}
 
 
 
==Verwendung von QFileDialog zum Schreiben in eine Datei==
 
Vollständiger Code:
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
import PySide
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import *
 
from PySide.QtCore import *
 
path = FreeCAD.ConfigGet("UserAppData")
 
 
 
try:
 
    SaveName = QFileDialog.getSaveFileName(None,QString.fromLocal8Bit("Save a file txt"),path,            "*.txt") # PyQt4
 
#                                                                    "here the text displayed on windows" "here the filter (extension)" 
 
except Exception:
 
    SaveName, Filter = PySide.QtGui.QFileDialog.getSaveFileName(None, "Save a file txt", path,            "*.txt") # PySide
 
#                                                                    "here the text displayed on windows" "here the filter (extension)" 
 
if SaveName == "":                                                            # if the name file are not selected then Abord process
 
    App.Console.PrintMessage("Process aborted"+"\n")
 
else:                                                                        # if the name file are selected or created then
 
    App.Console.PrintMessage("Registration of "+SaveName+"\n")                # text displayed to Report view (Menu > View > Report view checked)
 
    try:                                                                      # detect error ...
 
        file = open(SaveName, 'w')                                            # open the file selected to write (w)
 
        try:                                                                  # if error detected to write ...
 
            # here your code
 
            print("here your code")
 
            file.write(str(1)+"\n")                                          # write the number convert in text with (str())
 
            file.write("FreeCAD the best")                                    # write the the text with ("  ")
 
        except Exception:                                                    # if error detected to write
 
            App.Console.PrintError("Error write file "+"\n")                  # detect error ... display the text in red (PrintError)
 
        finally:                                                              # if error detected to write ... or not the file is closed
 
            file.close()                                                      # if error detected to write ... or not the file is closed
 
    except Exception:
 
        App.Console.PrintError("Error Open file "+SaveName+"\n")      # detect error ... display the text in red (PrintError)
 
 
 
}}
 
 
 
==Verwendung von QFileDialog zum Lesen einer Datei==
 
Vollständiger Code:
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
import PySide
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import *
 
from PySide.QtCore import *
 
path = FreeCAD.ConfigGet("UserAppData")
 
 
 
OpenName = ""
 
try:
 
    OpenName = QFileDialog.getOpenFileName(None,QString.fromLocal8Bit("Read a file txt"),path,            "*.txt") # PyQt4
 
#                                                                    "here the text displayed on windows" "here the filter (extension)" 
 
except Exception:
 
    OpenName, Filter = PySide.QtGui.QFileDialog.getOpenFileName(None, "Read a file txt", path,            "*.txt") #PySide
 
#                                                                    "here the text displayed on windows" "here the filter (extension)" 
 
if OpenName == "":                                                            # if the name file are not selected then Abord process
 
    App.Console.PrintMessage("Process aborted"+"\n")
 
else:
 
    App.Console.PrintMessage("Read "+OpenName+"\n")                          # text displayed to Report view (Menu > View > Report view checked)
 
    try:                                                                      # detect error to read file
 
        file = open(OpenName, "r")                                            # open the file selected to read (r)  # (rb is binary)
 
        try:                                                                  # detect error ...
 
            # here your code
 
            print("here your code")
 
            op = OpenName.split("/")                                          # decode the path
 
            op2 = op[-1].split(".")                                          # decode the file name
 
            nomF = op2[0]                                                    # the file name are isolated
 
 
 
            App.Console.PrintMessage(str(nomF)+"\n")                          # the file name are displayed
 
 
 
            for ligne in file:                                                # read the file
 
                X  = ligne.rstrip('\n\r') #.split()                          # decode the line
 
                print(X)                                                      # print the line in report view other method
 
                                                                              # (Menu > Edit > preferences... > Output window > Redirect internal Python output (and errors) to report view checked)
 
        except Exception:                                                    # if error detected to read
 
            App.Console.PrintError("Error read file "+"\n")                  # detect error ... display the text in red (PrintError)
 
        finally:                                                              # if error detected to read ... or not error the file is closed
 
            file.close()                                                      # if error detected to read ... or not error the file is closed
 
    except Exception:                                                        # if one error detected to read file
 
        App.Console.PrintError("Error in Open the file "+OpenName+"\n")      # if one error detected ... display the text in red (PrintError)
 
 
 
}}
 
 
 
==Verwendung von QColorDialog zur Ermittlung der Farbe==
 
Vollständiger Code:
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
# https://deptinfo-ensip.univ-poitiers.fr/ENS/pyside-docs/PySide/QtGui/QColor.html
 
import PySide
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import *
 
from PySide.QtCore import *
 
path = FreeCAD.ConfigGet("UserAppData")
 
 
 
couleur = QtGui.QColorDialog.getColor()
 
if couleur.isValid():
 
    red  = int(str(couleur.name()[1:3]),16)    # decode hexadecimal to int()
 
    green = int(str(couleur.name()[3:5]),16)    # decode hexadecimal to int()
 
    blue  = int(str(couleur.name()[5:7]),16)    # decode hexadecimal to int()
 
 
 
    print(couleur)                              #
 
    print("hexadecimal ",couleur.name())        # color format hexadecimal mode 16
 
    print("Red  color ",red)                  # color format decimal
 
    print("Green color ",green)                # color format decimal
 
    print("Blue  color ",blue)                  # color format decimal
 
 
 
}}
 
==Benutzen Sie QColorDialog und erstellen Sie Ihre Palettenfarben (Standard und benutzerdefiniert)==
 
 
 
Dieses Beispiel ändert die Standardfarben und die benutzerdefinierten Farben mit dem Tango-FreeCAD-Leitfaden.
 
 
 
Der vollständige Code
 
 
 
 
 
{{Code|code=
 
# -*- coding: utf-8 -*-
 
# https://deptinfo-ensip.univ-poitiers.fr/ENS/pyside-docs/PySide/QtGui/QColor.html
 
import PySide
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import *
 
from PySide.QtCore import *
 
 
 
###############################################
 
##        Window colors organisation        ##
 
##        __________________________        ##
 
## StandardColor:                            ##
 
##                                          ##
 
##          Colonnes:                      ##
 
##          1:  2:  3:  4:  5:  6:  7:  8:  ##
 
##          _______________________________  ##
 
## Line 1:  0  6  12  18  24  30  36  42  ##
 
## Line 2:  1  7  13  19  25  31  37  43  ##
 
## Line 3:  2  8  14  20  26  32  38  44  ##
 
## Line 4:  3  9  15  21  27  33  39  45  ##
 
## Line 5:  4  10  16  22  28  34  40  46  ##
 
## Line 6:  5  11  17  23  29  35  41  47  ##
 
##                                          ##
 
## CustomColor:                              ##
 
##                                          ##
 
##          Colonnes:                      ##
 
##          1:  2:  3:  4:  5:  6:  7:  8:  ##
 
##          _______________________________  ##
 
## Line 1:  0  2  4  6  8  10  12  14  ##
 
## Line 2:  1  3  5  7  9  11  13  15  ##
 
##                                          ##
 
###############################################
 
 
 
color_Dialog  = QtGui.QColorDialog()
 
# FreeCAD-Tango
 
# Customize the colors in the standard box (in numeric mode)
 
#
 
#### Dialog line 1
 
color_Dialog.setStandardColor( 0, QtGui.QColor(252, 233,  79 , 0).rgba())    # Butte 1
 
color_Dialog.setStandardColor( 6, QtGui.QColor(237, 212,  0 , 0).rgba())    # Butte 2
 
color_Dialog.setStandardColor(12, QtGui.QColor(196, 160,  0 , 0).rgba())    # Butte 3
 
color_Dialog.setStandardColor(18, QtGui.QColor( 48,  43,  0 , 0).rgba())    # Butte 4
 
 
 
color_Dialog.setStandardColor(24, QtGui.QColor(138, 226,  52 , 0).rgba())    # Chameleo 1
 
color_Dialog.setStandardColor(30, QtGui.QColor(115, 210,  22 , 0).rgba())    # Chameleo 2
 
color_Dialog.setStandardColor(36, QtGui.QColor( 78, 154,  6 , 0).rgba())    # Chameleo 3
 
color_Dialog.setStandardColor(42, QtGui.QColor( 23,  42,  4 , 0).rgba())    # Chameleo 4
 
#### Dialog line 2
 
color_Dialog.setStandardColor( 1, QtGui.QColor(252, 175,  62 , 0).rgba())    # Orang 1
 
color_Dialog.setStandardColor( 7, QtGui.QColor(245, 121,  0 , 0).rgba())    # Orang 2
 
color_Dialog.setStandardColor(13, QtGui.QColor(206,  92,  0 , 0).rgba())    # Orang 3
 
color_Dialog.setStandardColor(19, QtGui.QColor( 50,  25,  0 , 0).rgba())    # Orang 4
 
 
 
color_Dialog.setStandardColor(25, QtGui.QColor(114, 159, 207 , 0).rgba())    # Sky Blu 1
 
color_Dialog.setStandardColor(31, QtGui.QColor( 52, 101, 164 , 0).rgba())    # Sky Blu 2
 
color_Dialog.setStandardColor(37, QtGui.QColor( 32,  74, 135 , 0).rgba())    # Sky Blu 3
 
color_Dialog.setStandardColor(43, QtGui.QColor( 11,  21,  33 , 0).rgba())    # Sky Blu 4
 
#### Dialog line 3
 
color_Dialog.setStandardColor( 2, QtGui.QColor(173, 127, 168 , 0).rgba())    # Plu 1
 
color_Dialog.setStandardColor( 8, QtGui.QColor(117,  80, 123 , 0).rgba())    # Plu 2
 
color_Dialog.setStandardColor(14, QtGui.QColor( 92,  53, 102 , 0).rgba())    # Plu 3
 
color_Dialog.setStandardColor(20, QtGui.QColor( 23,  16,  24 , 0).rgba())    # Plu 4
 
 
 
color_Dialog.setStandardColor(26, QtGui.QColor(233, 185, 110 , 0).rgba())    # Chocolat 1
 
color_Dialog.setStandardColor(32, QtGui.QColor(193, 125,  17 , 0).rgba())    # Chocolat 2
 
color_Dialog.setStandardColor(38, QtGui.QColor(143,  89,  2 , 0).rgba())    # Chocolat 3
 
color_Dialog.setStandardColor(44, QtGui.QColor( 39,  25,  3 , 0).rgba())    # Chocolat 4
 
#### Dialog line 4
 
color_Dialog.setStandardColor( 3, QtGui.QColor(239,  41,  41 , 0).rgba())    # Scarle Re 1
 
color_Dialog.setStandardColor( 9, QtGui.QColor(204,  0,  0 , 0).rgba())    # Scarle Re 2
 
color_Dialog.setStandardColor(15, QtGui.QColor(164,  0,  0 , 0).rgba())    # Scarle Re 3
 
color_Dialog.setStandardColor(21, QtGui.QColor( 40,  0,  0 , 0).rgba())    # Scarle Re 4
 
 
 
color_Dialog.setStandardColor(27, QtGui.QColor( 52, 224, 226 , 0).rgba())    # FreeTea 1
 
color_Dialog.setStandardColor(33, QtGui.QColor( 22, 208, 210 , 0).rgba())    # FreeTea 2
 
color_Dialog.setStandardColor(39, QtGui.QColor(  6, 152, 154 , 0).rgba())    # FreeTea 3
 
color_Dialog.setStandardColor(45, QtGui.QColor(  4,  42,  42 , 0).rgba())    # FreeTea 4
 
#### Dialog line 5
 
color_Dialog.setStandardColor( 4, QtGui.QColor(255, 255, 255 , 0).rgba())    # Snow White
 
 
 
color_Dialog.setStandardColor(10, QtGui.QColor(238, 238, 236 , 0).rgba())    # Aluminiu 1
 
color_Dialog.setStandardColor(16, QtGui.QColor(211, 215, 207 , 0).rgba())    # Aluminiu 2
 
color_Dialog.setStandardColor(22, QtGui.QColor(186, 189, 182 , 0).rgba())    # Aluminiu 3
 
 
 
color_Dialog.setStandardColor(28, QtGui.QColor(136, 138, 133 , 0).rgba())    # Aluminiu 4
 
color_Dialog.setStandardColor(34, QtGui.QColor( 85,  87,  83 , 0).rgba())    # Aluminiu 5
 
color_Dialog.setStandardColor(40, QtGui.QColor( 46,  52,  54 , 0).rgba())    # Aluminiu 6
 
 
 
color_Dialog.setStandardColor(46, QtGui.QColor(  0,  0,  0 , 0).rgba())    # Je Black
 
#### Dialog line 6
 
color_Dialog.setStandardColor( 5, QtGui.QColor(255, 255, 255 , 0).rgba())    # Snow White
 
color_Dialog.setStandardColor(11, QtGui.QColor(255,  0,  0 , 0).rgba())    # Aluminiu 1
 
color_Dialog.setStandardColor(17, QtGui.QColor(  0, 255,  0 , 0).rgba())    # Aluminiu 2
 
color_Dialog.setStandardColor(23, QtGui.QColor(  0,  0, 255 , 0).rgba())    # Aluminiu 3
 
 
 
color_Dialog.setStandardColor(29, QtGui.QColor(255, 255,  0 , 0).rgba())    # Aluminiu 4
 
color_Dialog.setStandardColor(35, QtGui.QColor(255,  0, 255 , 0).rgba())    # Aluminiu 5
 
color_Dialog.setStandardColor(41, QtGui.QColor(  0, 255, 255 , 0).rgba())    # Aluminiu 6
 
color_Dialog.setStandardColor(47, QtGui.QColor(  0,  0,  0 , 0).rgba())    # Je Black
 
color_Dialog.setStandardColor(47, QtGui.QColor(  0,  0,  0 , 0).rgba())    # Je Black
 
 
 
#### Customize the colors to Dialog CustomColor (in hexadecimal converted in numeric mode)
 
# Use the Yellow tones for tools that create objects.
 
# Dialog line 1
 
color_Dialog.setCustomColor(0, QtGui.QColor( int("fc",16),int("e9",16),int("4f",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(2, QtGui.QColor( int("ed",16),int("d4",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(4, QtGui.QColor( int("c4",16),int("a0",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(6, QtGui.QColor( int("30",16),int("2b",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
 
 
# Use the Blue tones for tools that modify objects
 
color_Dialog.setCustomColor(8, QtGui.QColor( int("72",16),int("9f",16),int("cf",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(10,QtGui.QColor( int("34",16),int("65",16),int("a4",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(12,QtGui.QColor( int("20",16),int("4a",16),int("87",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(14,QtGui.QColor( int("0b",16),int("15",16),int("21",16) , 0).rgba()) # hexadecimal converted in int
 
 
 
# Use the Teal tones for view-related tools
 
# Dialog line 2
 
color_Dialog.setCustomColor(1, QtGui.QColor( int("34",16),int("e0",16),int("e2",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(3, QtGui.QColor( int("16",16),int("d0",16),int("d2",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(5, QtGui.QColor( int("06",16),int("98",16),int("9a",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(7, QtGui.QColor( int("04",16),int("2a",16),int("2a",16) , 0).rgba()) # hexadecimal converted in int
 
 
 
# Use the Red tones for Constraint related tools
 
color_Dialog.setCustomColor(9, QtGui.QColor( int("ef",16),int("29",16),int("29",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(11,QtGui.QColor( int("cc",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(13,QtGui.QColor( int("a4",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
color_Dialog.setCustomColor(15,QtGui.QColor( int("28",16),int("00",16),int("00",16) , 0).rgba()) # hexadecimal converted in int
 
 
 
Color = color_Dialog.getColor()                                  # Color.name() extract the color in Hexadecimal mode (#ad7fa8)
 
 
 
if Color.isValid():
 
 
 
    print("__.name()___________")
 
    print("hexadecimal        ", Color.name())                  # color format hexadecimal mode 16
 
    red  = int(str( Color.name()[1:3]),16 )                      # decode hexadecimal to int()
 
    green = int(str( Color.name()[3:5]),16 )                      # decode hexadecimal to int()
 
    blue  = int(str( Color.name()[5:7]),16 )                      # decode hexadecimal to int()
 
 
 
    print("Red  color decimal ", str( Color.name()[1:3]), red )  # color format hex to decimal
 
    print("Green color decimal ", str( Color.name()[3:5]), green )# color format hex to decimal
 
    print("Blue  color decimal ", str( Color.name()[5:7]), blue ) # color format hex to decimal
 
 
 
    print("__.red()____________")
 
    print("Red  color decimal ", Color.red() )                  # extract the color RGBa with Qt (0 to 255)
 
    print("Green color decimal ", Color.green() )                # extract the color RGBa with Qt (0 to 255)
 
    print("Blue  color decimal ", Color.blue() )                  # extract the color RGBa with Qt (0 to 255)
 
    print("Alpha      decimal ", Color.alpha() )                # extract the color RGBa with Qt (0 to 255)
 
 
 
    print("__.redF()___________")
 
    print("Red  color float  ", Color.redF() )                  # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
 
    print("Green color float  ", Color.greenF() )                # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
 
    print("Blue  color float  ", Color.blueF() )                # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
 
    print("Alpha      float  ", Color.alphaF() )                # extract the color RGBa with Qt (0.0 to 1.0) as FreeCAD
 
    print("__enjoy_____________")
 
 
 
else:
 
    Color = ""
 
 
 
}}
 
 
 
 
 
==Bild mit QLabel und Gif animiert mit QMovie anzeigen==
 
 
 
{{Code|code=
 
import PySide
 
from PySide import QtGui ,QtCore
 
from PySide.QtGui import QPixmap, QMovie, QLabel
 
from PySide.QtCore import *
 
class MyLabelPatience():
 
    label = QtGui.QLabel()
 
    label.setText("<img src=" + path_Name_Image + "><b><center>Wait please</center> \n\n<center>i search the fonts !\n\n</center></b>")
 
    # center screen
 
    ecran = FreeCADGui.getMainWindow().frameGeometry()
 
    xF = 250; yF = 120
 
    xW = (ecran.width()/2) - (xF/2)
 
    yW = (ecran.height()/2)- (yF/2)
 
    label.setGeometry(xW, yW, xF, yF)
 
    ####
 
    label.setStyleSheet("QLabel {background-color : #F0C300;font: 12pt; }");
 
    label.setWindowFlags(Qt.WindowFlags(Qt.FramelessWindowHint))        # pas de bords (not border)
 
    ### un-comment for use ###############
 
    movie = QtGui.QMovie(path_Name_Image)    # anime le fichier Gif anime (decommenter)
 
    label.setMovie(movie)
 
    movie.start()
 
    ##################
 
 
 
patience = MyLabelPatience().label
 
patience.show()                    #show the image
 
#patience.close()                  #close the Qlabel
 
#MyLabelPatience().movie.start()    #start the animation (after patience.show())
 
#MyLabelPatience().movie.stop()    #stop animation
 
 
 
}}
 
 
 
* Example QLabel with image and text
 
 
 
{{clear}}
 
[[File:Qlabel Image00.png|left|Example QLabel with image]]
 
{{clear}}
 
 
 
* Example QLabel with image animated Gif
 
 
 
{{clear}}
 
[[File:Qlabel Image Animee00.gif|left|Example animated Gif]]
 
{{clear}}
 
==Einige hilfreiche Befehle==
 
 
 
{{Code|code=
 
# Here the code to display the icon on the '''pushButton''',
 
# change the name to another button, ('''radioButton, checkBox''') as well as the path to the icon,
 
 
 
      # Displays an icon on the button PushButton
 
      # self.image_01 = "C:\Program Files\FreeCAD0.13\icone01.png" # he name of the icon
 
      self.image_01 = path+"icone01.png" # the name of the icon
 
      icon01 = QtGui.QIcon()
 
      icon01.addPixmap(QtGui.QPixmap(self.image_01),QtGui.QIcon.Normal, QtGui.QIcon.Off)
 
      self.pushButton.setIcon(icon01)
 
      self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the direction of the button
 
 
 
 
 
# path = FreeCAD.ConfigGet("UserAppData") # gives the user path
 
  path = FreeCAD.ConfigGet("AppHomePath") # gives the installation path of FreeCAD
 
 
 
# This command reverses the horizontal button, right to left
 
self.pushButton.setLayoutDirection(QtCore.Qt.RightToLeft) # This command reverses the horizontal button
 
 
 
# Displays an info button
 
self.pushButton.setToolTip(_translate("MainWindow", "Quitter la fonction", None)) # Displays an info button
 
 
 
# This function gives a color button
 
self.pushButton.setStyleSheet("background-color: red") # This function gives a color button
 
 
 
# This function gives a color to the text of the button
 
self.pushButton.setStyleSheet("color : #ff0000") # This function gives a color to the text of the button
 
 
 
# combinaison des deux, bouton et texte
 
self.pushButton.setStyleSheet("color : #ff0000; background-color : #0000ff;" ) #  combination of the two, button, and text
 
 
 
# replace the icon in the main window
 
MainWindow.setWindowIcon(QtGui.QIcon('C:\Program Files\FreeCAD0.13\View-C3P.png'))
 
 
 
# connects a lineEdit on execute
 
self.lineEdit.returnPressed.connect(self.execute) # connects a lineEdit on "def execute" after validation on enter
 
# self.lineEdit.textChanged.connect(self.execute) # connects a lineEdit on "def execute" with each keystroke on the keyboard
 
 
 
# display text in a lineEdit
 
self.lineEdit.setText(str(val_X)) # Displays the value in the lineEdit (convert to string)
 
 
 
# extract the string contained in a lineEdit
 
val_X = self.lineEdit.text() # extract the (string) string contained in lineEdit
 
val_X = float(val_X0)        # converted the string to an floating
 
val_X = int(val_X0)          # convert the string to an integer
 
 
 
# This code allows you to change the font and its attributes
 
      font = QtGui.QFont()
 
      font.setFamily("Times New Roman")
 
      font.setPointSize(10)
 
      font.setWeight(10)
 
      font.setBold(True) # same result with tags "<b>your text</b>" (in quotes)
 
      self.label_6.setFont(font)
 
      self.label_6.setObjectName("label_6")
 
      self.label_6.setStyleSheet("color : #ff0000") # This function gives a color to the text
 
      self.label_6.setText(_translate("MainWindow", "Select a view", None))
 
}}
 
 
 
Bei der Verwendung von Buchstaben mit [https://de.wikipedia.org/wiki/Diakritisches_Zeichen diakritischen Zeichen] (u.a. Akzentzeichen) kann es zu Fehlermeldungen kommen:
 
 
 
<FONT COLOR="#FF0000">'''UnicodeDecodeError: 'utf8' codec can't decode bytes in position 0-2: invalid data'''</FONT>
 
 
 
<FONT COLOR="#FF0000">UnicodeDecodeError: 'utf8' codec can't decode bytes in position 0-2: invalid data</FONT>
 
{{Code|code=
 
# conversion from a lineEdit
 
App.activeDocument().CopyRight.Text = str(unicode(self.lineEdit_20.text() , 'ISO-8859-1').encode('UTF-8'))
 
DESIGNED_BY = unicode(self.lineEdit_01.text(), 'ISO-8859-1').encode('UTF-8')
 
}}
 
oder mit der Prozedur
 
{{Code|code=
 
def utf8(unio):
 
    return unicode(unio).encode('UTF8')
 
}}
 
 
 
<FONT COLOR="#FF0000">'''UnicodeEncodeError: 'ascii' codec can't encode character u'\xe9' in position 9: ordinal not in range(128)'''</FONT>
 
 
 
{{Code|code=
 
# conversion
 
a = u"Nom de l'élément : "
 
f.write('''a.encode('iso-8859-1')'''+str(element_)+"\n")
 
}}
 
oder mit der Prozedur
 
{{Code|code=
 
def iso8859(encoder):
 
    return unicode(encoder).encode('iso-8859-1')
 
}}
 
oder
 
{{Code|code=
 
iso8859(unichr(176))
 
}}
 
oder
 
{{Code|code=
 
unichr(ord(176))
 
}}
 
oder
 
{{Code|code=
 
uniteSs = "mm"+iso8859(unichr(178))
 
print(unicode(uniteSs, 'iso8859'))
 
}}
 
 
 
== Relevant Links ==
 
* [[Manual:Creating interface tools]]
 
  
{{docnav/de
 
|[[Line drawing function/de|Linienzeichenfunktion]]
 
|[[Licence/de|Lizenz]]
 
 
}}
 
}}
  
{{Userdocnavi/de}}
+
==Weitere Beispiele ==
  
[[Category:Poweruser Documentation/de]]
+
<div class="mw-translate-fuzzy">
 +
* [[Dialog_creation_with_various_widgets/de|Dialogerstellung mit verschiedenen Widgets]] mit {{incode|QPushButton}}, {{incode|QLineEdit}}, {{incode|QCheckBox}}, {{incode|QRadioButton}}, und anderen.
 +
* [[Dialog_creation_reading_and_writing_files/de|Dialogerstellung Lesen und Schreiben von Dateien]] mit {{incode|QFileDialog}}.
 +
* [[Dialog_creation_setting_colors/de|Dialogerstellung Farben festlegen]] mit {{incode|QColorDialog}}.
 +
* [[Dialog_creation_image_and_animated_GIF/de|Dialogerstellung Bild und animierte GIF]] mit {{incode|QLabel}} und {{incode|QMovie}}.
 +
* [[PySide_usage_snippets/de|PySide Verwendungsschnipsel]].
 +
</div>
  
[[Category:Python Code]]
+
== Relevante Verweise ==
  
[[Category:Developer]]
+
* [[Manual:Creating interface tools/de|Handbuch:Erstellen von Oberflächenwerkzeugen]]
 +
* [[Interface_creation_with_UI_files/de|Oberflächenerstellung mit UI Dateien]]
  
[[Category:Developer Documentation]]
 
  
 +
{{Powerdocnavi{{#translation:}}}}
 +
[[Category:Developer Documentation{{#translation:}}]]
 +
[[Category:Python Code{{#translation:}}]]
 
{{clear}}
 
{{clear}}

Latest revision as of 20:52, 20 November 2020

Other languages:
Deutsch • ‎English • ‎Türkçe • ‎español • ‎français • ‎italiano • ‎polski • ‎română • ‎svenska • ‎čeština • ‎русский

Einführung

Auf dieser Seite werden wir zeigen, wie man mit Qt Designer, Qt's offiziellem Werkzeug für die Gestaltung von Oberflächen, eine einfache grafische Oberfläche erstellt; der Dialog wird in Python Code umgewandelt und dann innerhalb von FreeCAD verwendet. Wir gehen davon aus, dass der Benutzer weiß, wie man Python allgemein bearbeitet und ausführt.

In diesem Beispiel ist die gesamte Oberfläche in Python definiert. Obwohl dies bei kleinen Schnittstellen möglich ist, empfiehlt es sich bei größeren Schnittstellen, die erstellten .ui Dateien direkt in das Programm zu laden. Siehe Obeflächenerstellung mit UI Dateien für weitere Informationen.

FreeCAD creating interfaces.svg

Zwei allgemeine Methoden zur Erstellung von Oberflächen, durch Einfügen der Schnittstelle in die Python Datei oder durch die Verwendung von .ui Dateien.


Gestalten des Dialogs

In CAD Anwendungen ist es sehr wichtig, eine gute UI (Benutzeroberfläche) zu entwerfend. Beinahe alles, das der Benutzer tun wird, wird über ein Teil der Oberfläche passieren: das Lesen von Dialog Kästen, drücken von Knöpfen, die Auswahl zwischen Piktogrammen, usw. Es ist also sehr wichtig, sich genau zu überlegen, was du tun willst, wie der Benutzer sich verhalten soll und wie der Ablauf deiner Aktion aussehen soll.

Ein paar Konzepte sollte man bei der Gestaltung der Oberfläche kennen:

  • Dialoge: Ein modaler Dialog erscheint auf Ihrem Schirm, unterbricht die Handlung des Hauptfensters, zwingt den Benutzer auf den Dialog zu antworten, während ein nichtmodaler Dialog Sie nicht hindert, am Hauptfenster weiter zu arbeiten. In einigen Fällen ist der erste besser, in anderen Fällen nicht.
  • Erkennen, was erforderlich ist und was optional: Stellen Sie sicher, dass der Benutzer weiß, was er tun muss. Etikettieren Sie alles mit der richtigen Beschreibung, verwenden Sie tooltips usw.
  • Die Trennung von Befehlen und Parametern: Das wird gewöhnlich mit Knöpfen und Texteingabefeldern getan. Der Benutzer weiß, dass das Klicken eines Knopfs eine Handlung erzeugen wird, indem er einen Wert innerhalb eines Textfeldes ändert, wird irgendwo ein Parameter geändert. Heutzutage aber wissen Benutzer gewöhnlich gut, was ein Knopf ist, was ein Eingangsfeld usw ist. Das Schnittstellen-Werkzeug Qt, das wir verwenden, ist eines der modernsten Werkzeuge und wir werden uns nicht viel darum sorgen müssen, Dinge verständlich zu machen, da sie bereits in sich selbst sehr klar sein werden.

Nachdem wir gut definiert haben, was wir tun werden, ist es Zeit, den Qt-Designer zu öffnen. Lassen Sie uns einen sehr einfachen Dialog entwerfen:

Qttestdialog.jpg

Wir werden dann mit diesem Dialog in FreeCAD eine schöne rechteckige Ebene erzeugen. Vielleicht finden Sie es nicht sehr nützlich, nette rechteckige Fläche zu produzieren, aber es wird leicht sein, sie später zu ändern, um komplexere Dinge zu tun. Wenn Sie es öffnen, sieht Qt-Designer wie folgt aus:

Qtdesigner-screenshot.jpg

Erstellen des Dialogs

Qt Designer ist sehr einfach zu benutzen. Auf der linken Leiste hast du Elemente, die auf dein Widget gezogen werden können. Auf der rechten Seite hast du Eigenschaftspaneels, die alle Arten von editierbaren Eigenschaften der ausgewählten Elemente anzeigen. Beginne also mit der Erstellung eines neuen Widgets.

  1. Wähle "Dialog ohne Schaltflächen", da wir die Standardschaltflächen OK/Abbrechen nicht wollen.
  2. Wir brauchen Labels (Beschriftungen). Labels sind einfache Textzeichenfolgen, die auf deinem Widget erscheinen, um den Endbenutzer zu informieren. Wenn du ein Label auswählst, beachte, dass auf der rechten Seite verschiedene Eigenschaften erscheinen, die du ändern kannst, wie z.B.: Schriftstil, Höhe, usw... Lass uns also 3 separate Label auf unser Widget ziehen:
    • Ein Label für den Titel
    • Ein weiteres Label zum Schreiben von "Height"
    • Ein weiteres Label zum Schreiben von "Width"
  3. Wir brauchen jetzt LineEdits (eigentlich 2 davon). Ziehe zwei davon auf das Widget. LineEdits sind Textfelder, die der Endbenutzer ausfüllen kann. Wir brauchen also einen LineEdit für die Höhe und einen für die Breite. Auch hier können wir Eigenschaften bearbeiten. Warum nicht z.B. einen Standardwert setzen, sagen wir z.B.: 1,00 für jedes. Auf diese Weise werden beide Werte bereits ausgefüllt sein, wenn der Benutzer den Dialog sieht. Wenn der Endbenutzer zufrieden ist, kann er direkt auf die Schaltfläche drücken und so wertvolle Zeit sparen.
  4. Als nächstes können wir einen PushButton (Druckknopf) hinzufügen. Dies ist die Schaltfläche, die der Endbenutzer drücken muss, nachdem er beide Felder ausgefüllt hat.

Hinweis: dass wir hier sehr einfache Bedienelemente gewählt haben. Qt hat viel mehr Optionen, zum Beispiel könnte man Spinboxes anstelle von LineEdits verwenden, usw... Schaudir an, was verfügbar ist, erkunde... Du wirst sicher andere Ideen haben.

Das ist soweit alles, was wir im Qt Designer tun müssen. Eine letzte Sache noch: Benennen wir alle unsere Elemente mit einfacheren Namen um, damit sie in unseren Skripten leichter zu identifizieren sind:

Qtpropeditor.jpg

Umwandeln unseres Dialogs zu Python

Jetzt werden wir unser Widget irgendwo speichern. Er wird als .ui Datei gespeichert, die wir einfach mittels pyuic zu einem Python Skript wandeln werden. Unter Windows ist das pyuic Programm meistens mit pyqt gebündelt (zu überprüfen), auf Linux weirst du es wahrscheinlich extra mit deinem Paketmanager installieren müssen (auf Debian-basierten Systemen, ist es ein Teil des pyqt4-dev-tools Pakets). Für die Konvertierung musst du ein Terminalfenster (oder ein Fenster der Eingabeaufforderung unter Windows) öffnen, in welchem du zu deiner .ui Datei navigierst und dort dann folgendes eingibst:

pyuic mywidget.ui > mywidget.py

Unter Windows befindet sich pyuic.py in "C:\Python27\Lib\site-Pakete\PyQt4\uic\pyuic.py". Erstelle für die Umwandlung eine Batchdatei mit dem Namen "compQt4.bat":

@"C:\Python27\python" "C:\Python27\Lib\site-packages\PyQt4\uic\pyuic.py" -x %1.ui > %1.py

In der DOS Konsole tippe ohne Erweiterung

compQt4 myUiFile

In Linux: Zu Tun

Nachdem sich FreeCAD nach v0.13 zunehmend von PyQt zugunsten von PySide entfernt hat (Wähle deine PySide Installation PySide bauen), um die Datei auf der Basis von PySide zu erstellen, musst du jetzt verwenden:

pyside-uic mywidget.ui -o mywidget.py

Unter Windows ist uic.py in "C:\Python27\Lib\site-packages\PySide\scripts\" zu finden. Zum Erstellen der Batchdatei "compSide.bat":

@"C:\Python27\python" "C:\Python27\Lib\site-packages\PySide\scripts\uic.py" %1.ui > %1.py

In die DOS Konsole tippe ohne Erweiterung

compSide myUiFile

In Linux: Zu Tun

Auf einigen Systemen wird das Programm pyuic4 statt pyuic genannt. Dadurch wird die .ui Datei einfach in ein Python Skript umgewandelt. Wenn wir die Datei mywidget.py öffnen, ist ihr Inhalt sehr leicht zu verstehen:

from PySide import QtCore, QtGui

class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName("Dialog")
        Dialog.resize(187, 178)
        self.title = QtGui.QLabel(Dialog)
        self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
        self.title.setObjectName("title")
        self.label_width = QtGui.QLabel(Dialog)
        ...

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(QtGui.QApplication.translate("Dialog", "Dialog", None, QtGui.QApplication.UnicodeUTF8))
        self.title.setText(QtGui.QApplication.translate("Dialog", "Plane-O-Matic", None, QtGui.QApplication.UnicodeUTF8))
        ...

Wie du siehst, hat es eine sehr einfache Struktur: eine Klasse genannt Ui_Dialog wird erstellt, die die Elemente der Benutzeroberfläche unseres Widgets speichert. Diese Klasse hat zwei Methoden, eine für die Einrichtung des Widgets und eine für die Übersetzung ihres Inhalts, was ein Teil des allgemeinen Qt Mechanismus für die Übersetzung von Oberflächenelementen ist. Das Einrichtungsverfahren erzeugt einfach eins nach dem anderen die Widgets, wie wir sie in Qt Designer festgelegt haben und setzt ihre Optionen, die wir ebenfalls gewählt haben. Dann wird die ganze Schnittstelle schließlich übersetzt, die Slots werden verbunden (wir werden darüber später sprechen).

Wir können jetzt ein neues Widget erstellen und diese Klasse verwenden, um seine Oberfläche zu schaffen. Wir können bereits unser Widget in Aktion sehen, indem wir unsere mywidget.py Datei an einem Ort speichern, wo FreeCAD es findet (im FreeCAD bin Verzeichnis, oder in einem der Mod Unterverzeichnisse), und dann im FreeCAD Python Interpreter eintippen:

from PySide import QtGui
import mywidget
d = QtGui.QWidget()
d.ui = mywidget.Ui_Dialog()
d.ui.setupUi(d)
d.show()

Und unser Dialog wird erscheinen! Beachte, dass unser Python Interpreter immer noch arbeitet, wir haben einen nichtmodalen Dialog. Um es zu abzuschließen, können wir (abgesehen von einem Klick auf das Schließen Symbol, natürlich) eingeben:

d.hide()

Unseren Dialog etwas tun lassen

Nun, da wir unseren Dialog ein- und ausblenden können, müssen wir nur noch einen letzten Teil hinzufügen: Damit er etwas bewirkt! Wenn du ein wenig mit dem Qt Designer spielst, wirst du schnell einen ganzen Abschnitt namens "Signals and Slots" entdecken. Im Grunde funktioniert es so: Elemente auf deinen Widgets (in der Qt Terminologie sind diese Elemente selbst Widgets) können Signale senden. Diese Signale unterscheiden sich je nach Widget Typ. Zum Beispiel kann eine Taste ein Signal senden, wenn sie gedrückt wird und wenn sie losgelassen wird. Diese Signale können mit Slots verbunden werden, was eine spezielle Funktionalität anderer Widgets sein kann (z.B. hat ein Dialog einen "Schließ" Slot, mit dem du das Signal von einer Schaltfläche zum Schließen verbinden kannst), oder es können benutzerdefinierte Funktionen sein. Die PyQt Referenzdokumentation listet alle qt Widgets auf, was sie können, welche Signale sie senden können, usw..

Was wir hier tun werden, ist eine neue Funktion zu erstellen, die eine Ebene erzeugt, beruhend auf Höhe und Breite, und in Verbindung steht diese Funktion mit dem gedrückt Signal, das unser "Create" Knopf abgibt. Also lass uns mit dem Importieren unserer FreeCAD Module beginnen, durch setzen der folgenden Zeile an den Anfang des Skripts, wo wir bereits QtCore und QtGui importieren:

import FreeCAD, Part

Dann lass uns eine neue Funktion zu unserer Ui_Dialog Klasse hinzufügen:

def createPlane(self):
    try:
        # first we check if valid numbers have been entered
        w = float(self.width.text())
        h = float(self.height.text())
    except ValueError:
        print("Error! Width and Height values must be valid numbers!")
    else:
        # create a face from 4 points
        p1 = FreeCAD.Vector(0,0,0)
        p2 = FreeCAD.Vector(w,0,0)
        p3 = FreeCAD.Vector(w,h,0)
        p4 = FreeCAD.Vector(0,h,0)
        pointslist = [p1,p2,p3,p4,p1]
        mywire = Part.makePolygon(pointslist)
        myface = Part.Face(mywire)
        Part.show(myface)
        self.hide()

Dann müssen wir Qt mitteilen, dass die Schaltfläche mit der Funktion verbunden werden soll, indem wir die folgende Zeile unmittelbar vor QtCore.QMetaObject.connectSlotsByName(Dialog) setzen:

QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)

Dies verbindet, wie du siehst, das pressed() Signal unseres create Objekts (die Schaltfläche "Create!") mit einem Slot namens createPlane, den wir gerade definiert haben. Das war's! Als letzten Schliff können wir nun noch eine kleine Funktion zum Erstellen des Dialogs hinzufügen, die einfacher aufzurufen sein wird. Außerhalb der Klasse Ui_Dialog fügen wir diesen Code hinzu:

class plane():
   def __init__(self):
       self.d = QtGui.QWidget()
       self.ui = Ui_Dialog()
       self.ui.setupUi(self.d)
       self.d.show()

(Python Erinnerung: Die __init__ Methode einer Klasse wird automatisch ausgeführt, wenn ein neues Objekt erzeugt wird!) Dann brauchen wir von FreeCAD aus nur folgendes zu tun:

import mywidget
myDialog = mywidget.plane()

Das ist alles, Leute... Jetzt kannst du alle möglichen Dinge ausprobieren, wie z.B. dein Widget in die FreeCAD Oberfläche einzufügen (siehe die Code Schnipsel Seite), oder viel fortgeschrittenere, eigene Werkzeuge zu erstellen, indem du andere Elemente auf deinem Widget verwendest.

Das komplette Skript

Dies ist das vollständige Skript, als Referenz:

# Form implementation generated from reading ui file 'mywidget.ui'
#
# Created: Mon Jun  1 19:09:10 2009
#      by: PyQt4 UI code generator 4.4.4
# Modified for PySide 16:02:2015 
# WARNING! All changes made in this file will be lost!

from PySide import QtCore, QtGui
import FreeCAD, Part 

class Ui_Dialog(object):
   def setupUi(self, Dialog):
       Dialog.setObjectName("Dialog")
       Dialog.resize(187, 178)
       self.title = QtGui.QLabel(Dialog)
       self.title.setGeometry(QtCore.QRect(10, 10, 271, 16))
       self.title.setObjectName("title")
       self.label_width = QtGui.QLabel(Dialog)
       self.label_width.setGeometry(QtCore.QRect(10, 50, 57, 16))
       self.label_width.setObjectName("label_width")
       self.label_height = QtGui.QLabel(Dialog)
       self.label_height.setGeometry(QtCore.QRect(10, 90, 57, 16))
       self.label_height.setObjectName("label_height")
       self.width = QtGui.QLineEdit(Dialog)
       self.width.setGeometry(QtCore.QRect(60, 40, 111, 26))
       self.width.setObjectName("width")
       self.height = QtGui.QLineEdit(Dialog)
       self.height.setGeometry(QtCore.QRect(60, 80, 111, 26))
       self.height.setObjectName("height")
       self.create = QtGui.QPushButton(Dialog)
       self.create.setGeometry(QtCore.QRect(50, 140, 83, 26))
       self.create.setObjectName("create")

       self.retranslateUi(Dialog)
       QtCore.QObject.connect(self.create,QtCore.SIGNAL("pressed()"),self.createPlane)
       QtCore.QMetaObject.connectSlotsByName(Dialog)

   def retranslateUi(self, Dialog):
       Dialog.setWindowTitle("Dialog")
       self.title.setText("Plane-O-Matic")
       self.label_width.setText("Width")
       self.label_height.setText("Height")
       self.create.setText("Create!")
       print("tyty")
   def createPlane(self):
       try:
           # first we check if valid numbers have been entered
           w = float(self.width.text())
           h = float(self.height.text())
       except ValueError:
           print("Error! Width and Height values must be valid numbers!")
       else:
           # create a face from 4 points
           p1 = FreeCAD.Vector(0,0,0)
           p2 = FreeCAD.Vector(w,0,0)
           p3 = FreeCAD.Vector(w,h,0)
           p4 = FreeCAD.Vector(0,h,0)
           pointslist = [p1,p2,p3,p4,p1]
           mywire = Part.makePolygon(pointslist)
           myface = Part.Face(mywire)
           Part.show(myface)

class plane():
  def __init__(self):
      self.d = QtGui.QWidget()
      self.ui = Ui_Dialog()
      self.ui.setupUi(self.d)
      self.d.show()

Weitere Beispiele

Relevante Verweise