Workbench creation/pl: Difference between revisions
(Created page with "==Struktura środowiska pracy==") |
No edit summary |
||
(59 intermediate revisions by 3 users not shown) | |||
Line 8: | Line 8: | ||
{{TOCright}} |
{{TOCright}} |
||
<span id="Introduction"></span> |
|||
==Wprowadzenie== |
==Wprowadzenie== |
||
Ta strona pokaże Ci, jak dodać nowe |
Ta strona pokaże Ci, jak dodać nowe środowisko pracy do interfejsu programu FreeCAD. [[Workbenches/pl|Środowiska pracy]] są kontenerami dla poleceń FreeCAD. Mogą być zakodowane w Pythonie, w C++ lub w mieszance obu tych języków, co ma tę zaletę, że łączy szybkość C++ z elastycznością Pythona. We wszystkich przypadkach jednak Twoje środowisko pracy będzie uruchamiane przez zestaw dwóch plików Python. Mogą to być "wewnętrzne" środowiska, dołączone do dystrybucji programu FreeCAD, lub "zewnętrzne", dystrybuowane za pomocą [[Std_AddonMgr/pl|Menadżera dodatków]] lub instalowane ręcznie przez pobranie z jakiegoś repozytorium online. Wewnętrzne środowiska pracy mogą być napisane w C++, środowisku Python lub kombinacji tych dwóch środowisk, podczas gdy zewnętrzne środowiska pracy muszą być napisane wyłącznie w środowisku Python. |
||
<span id="The_workbench_structure"></span> |
|||
==Struktura środowiska pracy== |
==Struktura środowiska pracy== |
||
Potrzebny jest folder o dowolnej nazwie, umieszczony w katalogu Mod użytkownika, z plikiem {{incode|Init.py}} i opcjonalnie plikiem {{incode|InitGui.py}}. Plik {{incode|Init.py}} jest wykonywany podczas uruchamiania FreeCAD, a plik {{incode|InitGui.py}} jest wykonywany natychmiast po nim, ale tylko wtedy, gdy FreeCAD uruchamia się w trybie GUI. To wszystko, czego potrzebuje FreeCAD, aby znaleźć środowisko pracy podczas uruchamiania i dodać je do swojego interfejsu. |
|||
Katalog Mod użytkownika jest podkatalogiem katalogu danych aplikacji użytkownika (można go znaleźć wpisując {{incode|App.getUserAppDataDir()}} w [[Python_console/pl|konsoli Python]]): |
|||
* |
* W systemie Linux jest to zazwyczaj {{FileName|/home/<nazwa użytkownika>/.local/share/FreeCAD/Mod/}} ({{VersionPlus/pl|0.20}}) lub {{FileName|/home/<username>/.FreeCAD/Mod/}} ({{VersionMinus/pl|0.19}}). |
||
* |
* W systemie Windows jest to {{FileName|%APPDATA%\FreeCAD\Mod\}}, który zwykle jest {{FileName|C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\}}. |
||
* |
* Na macOS jest to zazwyczaj {{FileName|/Users/<username>/Library/Application Support/FreeCAD/Mod/}}. |
||
Katalog Mod powinien wyglądać następująco: |
|||
The Mod directory should look like this: |
|||
{{Code|code= |
{{Code|code= |
||
Line 30: | Line 32: | ||
}} |
}} |
||
Wewnątrz tych plików można robić, co się chce. Zazwyczaj są one używane w ten sposób: |
|||
Inside those files you can do whatever you want. Usually they are used like this: |
|||
* |
* W pliku Init.py wystarczy dodać kilka rzeczy używanych nawet wtedy, gdy FreeCAD działa w trybie konsoli, na przykład importerów i eksporterów plików. |
||
* W pliku InitGui.py zazwyczaj definiuje się środowisko pracy, które zawiera nazwę, ikonę i serię poleceń FreeCAD ''(patrz poniżej)''. Ten plik Pythona definiuje również funkcje, które są wykonywane podczas ładowania FreeCAD ''(starasz się robić tam jak najmniej, aby nie spowalniać uruchamiania)'', kolejną, która jest wykonywana, gdy środowisko pracy jest aktywowane ''(to tam będziesz wykonywał większość pracy)'', a trzecią, gdy środowisko pracy jest dezaktywowane ''(dzięki czemu możesz usuwać rzeczy w razie potrzeby)''. |
|||
* In the InitGui.py file you usually define a workbench, which contains a name, an icon, and a series of FreeCAD commands (see below). That python file also defines functions that are executed when FreeCAD loads (you try to do as little as possible there, so you don't slow down the startup), another that gets executed when the workbench is activated (that's where you'll do most of the work), and a third one when the workbench is deactivated (so you can remove things if needed). |
|||
Opisana tutaj struktura i zawartość plików środowiska pracy jest klasycznym sposobem tworzenia nowego środowiska pracy. Można użyć niewielkiej odmiany w strukturze plików podczas tworzenia nowego środowiska pracy w Pythonie, ten alternatywny sposób najlepiej opisać jako "środowisko pracy z przestrzenią nazw", otwierając możliwość użycia narzędzia pip do zainstalowania środowiska pracy. Obie struktury działają, więc jest to bardziej kwestia preferencji podczas tworzenia nowego środowiska roboczego. Przedstawiony tutaj styl i struktura środowiska roboczego są dostępne w globalnej przestrzeni nazw FreeCAD, podczas gdy w przypadku alternatywnego stylu i struktury środowisko robocze znajduje się w dedykowanej przestrzeni nazw. Więcej informacji na ten temat można znaleźć w sekcji [[Workbench_creation#Powiązane|Powiązane]]. |
|||
The structure and file content for a workbench described here is the classic way of creating a new workbench. One can use a slight variation in the structure of files when making a new Python workbench, that alternative way is best described as a "namespaced workbench", opening up the possibility to use pip to install the workbench. Both structures work, so it is more a question of preference when creating a new workbench. The style and structure for workbenches presented here are available in the global namespace of FreeCAD, whereas for the alternative style and structure the workbench resides in a dedicated namespace. For further readings on the topic see [[Workbench creation#Related|Related]]. |
|||
<span id="C++_workbench_structure"></span> |
|||
=== C++ workbench structure === |
|||
==C++ struktura środowiska pracy== |
|||
Jeśli zamierzasz zakodować swoje środowisko pracy w Pythonie, nie musisz zachować szczególnej ostrożności i możesz po prostu umieścić inne pliki Python razem z plikami Init.py i InitGui.py. Podczas pracy z C++ należy jednak zachować większą ostrożność i zacząć od przestrzegania jednej podstawowej zasady FreeCAD: Rozdzielenie środowiska pracy na część aplikacji ''(która może działać w trybie konsoli, bez żadnego elementu GUI)'' i część Gui, która zostanie załadowana tylko wtedy, gdy FreeCAD działa z pełnym środowiskiem GUI. Tak więc podczas tworzenia środowiska pracy C++, najprawdopodobniej utworzysz dwa moduły, App i Gui. Te dwa moduły muszą być oczywiście wywoływalne z Pythona. Każdy moduł FreeCAD (App lub Gui) składa się co najmniej z pliku inicjującego moduł. Jest to typowy plik AppMyModuleGui.cpp: |
|||
If you are going to code your workbench in python, you don't need to take special care, and can simply place your other python files together with your Init.py and InitGui.py files. When working with C++, however, you should take greater care, and start with respecting one fundamental rule of FreeCAD: The separation of your workbench between an App part (that can run in console mode, without any GUI element), and a Gui part, which will only be loaded when FreeCAD runs with its full GUI environment. So when developing a C++ workbench, you will actually most likely create two modules, an App and a Gui. These two modules must of course be callable from python. Any FreeCAD module (App or Gui) consists, at the very least, of a module init file. This is a typical AppMyModuleGui.cpp file: |
|||
{{Code|code= |
{{Code|code= |
||
Line 76: | Line 79: | ||
}} |
}} |
||
<span id="The_Init.py_file"></span> |
|||
=== |
===Plik Init.py=== |
||
{{code|code= |
{{code|code= |
||
Line 90: | Line 94: | ||
# * as published by the Free Software Foundation; either version 2 of * |
# * as published by the Free Software Foundation; either version 2 of * |
||
# * the License, or (at your option) any later version. * |
# * the License, or (at your option) any later version. * |
||
# * for detail see the |
# * for detail see the LICENSE text file. * |
||
# * * |
# * * |
||
# * FreeCAD is distributed in the hope that it will be useful, * |
# * FreeCAD is distributed in the hope that it will be useful, * |
||
Line 105: | Line 109: | ||
FreeCAD.addImportType("My own format (*.own)", "importOwn") |
FreeCAD.addImportType("My own format (*.own)", "importOwn") |
||
FreeCAD.addExportType("My own format (*.own)", " |
FreeCAD.addExportType("My own format (*.own)", "exportOwn") |
||
print("I am executing some stuff here when FreeCAD starts!") |
print("I am executing some stuff here when FreeCAD starts!") |
||
}} |
}} |
||
Możesz wybrać dowolną licencję dla swojego środowiska pracy, ale pamiętaj, że jeśli chcesz, aby Twoje środowisko pracy było w pewnym momencie zintegrowane z kodem źródłowym FreeCAD i rozpowszechniane z nim, musi to być LGPL2+, jak w powyższym przykładzie. Zobacz stronę wyjaśniającą zagadnienia [[License/pl|Licencji]]. |
|||
You can choose any license you like for your workbench, but be aware that if you wish to see your workbench integrated into and distributed with the FreeCAD source code at some point, it needs to be LGPL2+ like the example above. See [[Licence|Licence]]. |
|||
Funkcje {{incode|FreeCAD.addImportType()}} i {{incode|addEXportType()}} pozwalają na podanie nazwy i rozszerzenia typu pliku oraz modułu Python odpowiedzialnego za jego import. W powyższym przykładzie moduł {{incode|importOwn.py}} będzie obsługiwał pliki {{incode|.own}}. Więcej przykładów można znaleźć na stronie [[Code_snippets/pl|Wycinki kodów]]. |
|||
<span id="Python_workbenches"></span> |
|||
=== Python workbenches === |
|||
===Środowiska pracy w Python=== |
|||
To jest plik InitGui.py: |
|||
{{Code|code= |
{{Code|code= |
||
Line 129: | Line 134: | ||
""" |
""" |
||
import MyModuleA, MyModuleB # import here all the needed files that create your FreeCAD commands |
import MyModuleA, MyModuleB # import here all the needed files that create your FreeCAD commands |
||
self.list = ["MyCommand1", "MyCommand2"] # |
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.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("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 |
self.appendMenu(["An existing Menu", "My submenu"], self.list) # appends a submenu to an existing menu |
||
def Activated(self): |
def Activated(self): |
||
Line 145: | Line 150: | ||
"""This function is executed whenever the user right-clicks on screen""" |
"""This function is executed whenever the user right-clicks on screen""" |
||
# "recipient" will be either "view" or "tree" |
# "recipient" will be either "view" or "tree" |
||
self.appendContextMenu("My commands",self.list) # add commands to the context menu |
self.appendContextMenu("My commands", self.list) # add commands to the context menu |
||
def GetClassName(self): |
def GetClassName(self): |
||
Line 155: | Line 160: | ||
}} |
}} |
||
Poza tym możesz zrobić co chcesz: możesz umieścić cały kod workbencha w InitGui.py, jeśli chcesz, ale zwykle wygodniej jest umieścić różne funkcje workbencha w osobnych plikach. Dzięki temu pliki te są mniejsze i łatwiejsze do przeglądania. Następnie importujesz te pliki do pliku InitGui.py. Możesz zorganizować te pliki w dowolny sposób, dobrym przykładem jest jeden dla każdego dodawanego polecenia FreeCAD. |
|||
Other than that, you can do anything you want: you could put your whole workbench code inside the InitGui.py if you want, but it is usually more convenient to place the different functions of your workbench in separate files. So those files are smaller and easier to read. Then you import those files into your InitGui.py file. You can organize those files the way you want, a good example is one for each FreeCAD command you add. |
|||
= |
<span id="Preferences"></span> |
||
====Ustawienia==== |
|||
Można dodać stronę preferencji dla środowiska pracy Python. Strony preferencji szukają ikony preferencji o określonej nazwie w systemie zasobów Qt. Jeśli ikony nie ma w systemie zasobów lub nie ma poprawnej nazwy, ikona nie pojawi się na stronie preferencji. |
|||
You can add a Preferences page for your Python workbench. The Preferences pages look for a preference icon with a specific name in the Qt Resource system. If your icon isn't in the resource system or doesn't have the correct name, your icon won't appear on the Preferences page. |
|||
Dodawanie ikony środowiska pracy: |
|||
Adding your workbench icon: |
|||
* |
* ikona preferencji musi mieć nazwę "preferences-" + "modulename" + ".svg" ''(wszystkie małe litery)'', |
||
* utwórz plik qrc zawierający wszystkie nazwy ikon, |
|||
* make a qrc file containing all icon names |
|||
* |
* w głównym katalogu *.py, uruchom pyside-rcc -o myResources.py myqrc.qrc |
||
* |
* w InitGui.py, dodaj import myResource(.py) |
||
* |
* zaktualizuj swoje repozytorium ''(git)'' za pomocą myResources.py i myqrc.qrc |
||
Będziesz musiał powtórzyć te kroki, jeśli dodasz / zmienisz ikony. |
|||
You'll need to redo the steps if you add/change icons. |
|||
@kbwbe |
@kbwbe stworzył fajny skrypt do kompilacji zasobów dla środowiska A2Plus. Zobacz poniżej. |
||
Dodawanie stron preferencji: |
|||
Adding your preference page(s): |
|||
* |
* Musisz skompilować wtyczkę Qt Designer, która umożliwia dodawanie ustawień preferencji za pomocą [[Compile_on_Linux/pl#Qt_designer_plugin|Qt Designer]] |
||
* |
* Utwórz pusty widżet w Qt Designer ''(bez przycisków ani niczego)'' |
||
* Zaprojektuj swoją stronę preferencji, każde ustawienie, które musi zostać zapisane ''(preferencje)'' musi być jednym z widżetów Gui::Pref*, które zostały dodane przez wtyczkę. |
|||
* Design your preference page, any setting that must be saved (preferences) must be one of the Gui::Pref* widgets that were added by the plugin) |
|||
* |
* W każdym z nich upewnij się, że wypełniłeś PrefName ''(nazwa wartości preferencji)'' i PrefPath ''(np. Mod/MyWorkbenchName)'', co spowoduje zapisanie wartości w BaseApp/Preferences/Mod/MyWorkbenchName. |
||
* Zapisz plik UI w swoim środowisku pracy, upewnij się, że jest on obsługiwany przez cmake. |
|||
* Save the ui file in your workbench, make sure it's handled by cmake |
|||
* |
* W swoim środowisku pracy, np. wewnątrz pliku InitGui, wewnątrz metody Initialize ''(ale każde inne miejsce też działa)'', dodaj: FreeCADGui.addPreferencePage("/path/to/myUiFile.ui", "MyGroup"), przy czym "MyGroup" jest jedną z grup preferencji po lewej stronie. FreeCAD automatycznie wyszuka plik "preferences-mygroup.svg" w swoich znanych lokalizacjach ''(które można rozszerzyć za pomocą FreeCADGui.addIconPath())''. |
||
* |
* Upewnij się, że metoda addPreferencePage() jest wywoływana tylko raz, w przeciwnym razie strona preferencji zostanie dodana kilka razy. |
||
= |
<span id="Distribution"></span> |
||
====Dystrybucja==== |
|||
Aby rozpowszechniać swoje środowisko pracy Python, możesz po prostu hostować pliki w jakiejś lokalizacji i poinstruować użytkowników, aby pobrali je i umieścili w swoim katalogu Mod samodzielnie, lub możesz hostować je w internetowym repozytorium git ''(GitHub, GitLab, Framagit i Debian Salsa są obecnie obsługiwanymi lokalizacjami)'' i skonfigurować je do zainstalowania przez [[Std_AddonMgr/pl|Menedżer dodatków]]. Instrukcje dotyczące włączenia do oficjalnej listy dodatków FreeCAD można znaleźć na stronie [https://github.com/FreeCAD/FreeCAD-addons/blob/master/README.md FreeCAD Addons GitHub repozytorium]. Aby korzystać z Menedżera dodatków, należy dołączyć plik metadanych [[Package_Metadata/pl|package.xml]], który instruuje Menedżera dodatków, jak znaleźć ikonę środowiska pracy i umożliwia wyświetlanie opisu, numeru wersji itp. Może on być również użyty do określenia innych środowisk pracy lub pakietów Python, od których zależy, przez które jest blokowany lub które ma zastąpić. |
|||
Aby uzyskać krótki przewodnik na temat tworzenia podstawowego pliku package.xml i dodawania środowiska roboczego do [[Std_AddonMgr/pl|Menedżera dodatków]], zobacz stronę [[Add_Workbench_to_Addon_Manager/pl|Dodaj środowisko pracy do Menadżera dodatków]]. |
|||
Optionally, you can include a separate metadata file describing your Python dependencies. This may be either a file called metadata.txt describing your workbench's external dependencies (on either other Addons, Workbenches, or Python modules), or a [https://pip.pypa.io/en/latest/reference/requirements-file-format/ requirements.txt] describing your Python dependencies. Note that if using a requirements.txt file, only the names of the specified packages are used for dependency resolution: pip command options, include options and version information are not supported by the Addon Manager. Users may manually run the requirements file using pip if those features are required. |
|||
Opcjonalnie można dołączyć oddzielny plik metadanych opisujący zależności środowiska Python. Może to być albo plik o nazwie metadata.txt opisujący zewnętrzne zależności środowiska roboczego ''(od innych dodatków, środowisk roboczych lub modułów Pythona)'', albo plik [https://pip.pypa.io/en/latest/reference/requirements-file-format/ requirements.txt] opisujący zależności Python. Należy pamiętać, że w przypadku korzystania z pliku requirements.txt tylko nazwy określonych pakietów są używane do rozwiązywania zależności: opcje polecenia programu, opcje dołączania i informacje o wersji nie są obsługiwane przez Menedżera dodatków. Użytkownicy mogą ręcznie uruchomić plik wymagań za pomocą programu, jeśli te funkcje są wymagane. |
|||
The format of the metadata.txt file is plain text, with three optional lines: |
|||
Format pliku metadata.txt to zwykły tekst z trzema opcjonalnymi wierszami: |
|||
{{Code|code= |
{{Code|code= |
||
Line 195: | Line 204: | ||
}} |
}} |
||
Każdy wiersz powinien składać się z oddzielonej przecinkami listy elementów, od których zależy środowisko pracy. Środowiska te mogą być albo wewnętrznym środowiskiem pracy FreeCAD, np. "MES", albo zewnętrznym dodatkiem, na przykład "Krzywe". Wymagane i opcjonalne biblioteki Python powinny być określone za pomocą ich kanonicznych nazw Python, takich jak {{incode|pip install}}. Na przykład: |
|||
{{Code|code= |
{{Code|code= |
||
Line 203: | Line 212: | ||
}} |
}} |
||
Możesz również dołączyć skrypt, który jest uruchamiany po odinstalowaniu pakietu. Jest to plik o nazwie "uninstall.py" znajdujący się na najwyższym poziomie dodatku. Jest on wykonywany, gdy użytkownik odinstalowuje dodatek za pomocą Menedżera dodatków. Użyj go, aby wyczyścić wszystko, co dodatek mógł zrobić w systemie użytkownika, a co nie powinno przetrwać po usunięciu dodatku ''(np. usunięcie plików pamięci podręcznej itp.)''. |
|||
You may also include a script that is run when your package is uninstalled. This is a file called "uninstall.py" located at the top level of your Addon. It is executed when a user uninstalls your Addon using the Addon Manager. Use it to clean up anything your Addon may have done to the users system that should not persist when the Addon is gone (e.g. removing cache files, etc.). |
|||
Aby upewnić się, że dodatek jest poprawnie odczytywany przez Menedżera dodatków, można włączyć "tryb deweloperski", w którym Menedżer dodatków sprawdza wszystkie dostępne dodatki i upewnia się, że ich metadane zawierają wymagane elementy. Aby włączyć ten tryb, wybierz: {{MenuCommand|Edycja → Preferencje ... → Menadżer dodatków → Opcje Menedżera dodatków → Tryb dewelopera dodatków}}, zobacz stronę [[Preferences_Editor/pl#Opcje_Menadżera_dodatków|Edytor ustawień]] aby uzyskać szczegółowe informacje. |
|||
===C++ workbenches=== |
|||
<span id="C++_workbenches"></span> |
|||
If you are going to code your workbench in C++, you will probably want to code the workbench definition itself in C++ too (although it is not necessary: you could also code only the tools in C++, and leave the workbench definition in Python). In that case, the InitGui.py file becomes very simple: It might contain just one line: |
|||
===Środowiska pracy w C++=== |
|||
Jeśli zamierzasz zakodować swoje środowisko pracy w C++, prawdopodobnie będziesz chciał również zakodować samą definicję środowiska pracy w C++ ''(choć nie jest to konieczne: możesz również zakodować tylko narzędzia w C++, a definicję środowiska pracy pozostawić w Pythonie)''. W takim przypadku plik InitGui.py staje się bardzo prosty: Może zawierać tylko jedną linię: |
|||
{{Code|code=import MyModuleGui}} |
{{Code|code=import MyModuleGui}} |
||
gdzie MyModule jest kompletnym środowiskiem pracy C++, w tym poleceniami i definicją środowiska pracy. |
|||
where MyModule is your complete C++ workbench, including the commands and workbench definition. |
|||
Kodowanie środowisk pracy C++ działa w dość podobny sposób. Jest to typowy plik Workbench.cpp, który należy dołączyć do części Gui modułu: |
|||
{{Code|code= |
{{Code|code= |
||
Line 235: | Line 247: | ||
}} |
}} |
||
= |
<span id="Preferences"></span> |
||
====Ustawienia==== |
|||
Można również dodać stronę preferencji dla środowiska pracy języka C++. Kroki są podobne do tych w Pythonie. |
|||
<span id="Distribution"></span> |
|||
====Dystrybucja==== |
|||
Istnieją dwie opcje dystrybucji środowiska pracy C++, można albo samodzielnie hostować wstępnie skompilowane wersje dla różnych systemów operacyjnych, albo poprosić o scalenie kodu z kodem źródłowym FreeCAD. Jak wspomniano powyżej, wymaga to licencji LGPL2+ i należy najpierw przedstawić swoje środowisko pracy społeczności do przeglądu na [https://forum.freecad.org forum FreeCAD]. |
|||
You can add a Preferences page for C++ workbenches too. The steps are similar to those for Python. |
|||
<span id="FreeCAD_commands"></span> |
|||
== FreeCAD commands == |
|||
==Polecenia FreeCAD== |
|||
Polecenia FreeCAD są podstawowym elementem składowym interfejsu FreeCAD. Mogą pojawiać się jako przycisk na paskach narzędzi i jako pozycja w menu. Ale to jest to samo polecenie. Polecenie jest prostą klasą Python, która musi zawierać kilka predefiniowanych atrybutów i funkcji, które definiują nazwę polecenia, jego ikonę i co należy zrobić, gdy polecenie jest aktywowane. |
|||
FreeCAD commands are the basic building block of the FreeCAD interface. They can appear as a button on toolbars, and as a menu entry in menus. But it is the same command. A command is a simple Python class, that must contain a couple of predefined attributes and functions, that define the name of the command, its icon, and what to do when the command is activated. |
|||
<span id="Python_command_definition"></span> |
|||
=== Python command definition === |
|||
===Definicja polecenia w Python=== |
|||
{{Code|code= |
{{Code|code= |
||
Line 267: | Line 287: | ||
}} |
}} |
||
<span id="C++_command_definition"></span> |
|||
=== C++ command definition === |
|||
===Definicja polecenia w C++=== |
|||
Podobnie, można kodować polecenia w C++, zazwyczaj w pliku Commands.cpp w module Gui. To jest typowy plik Commands.cpp: |
|||
{{Code|code=DEF_STD_CMD_A(CmdMyCommand); |
{{Code|code=DEF_STD_CMD_A(CmdMyCommand); |
||
Line 308: | Line 329: | ||
}} |
}} |
||
<span id=""Compiling"_your_resource_file"></span> |
|||
=="Compiling" your resource file== |
|||
=="Kompilacja" pliku zasobów== |
|||
compileA2pResources.py |
compileA2pResources.py ze środowiska roboczego A2Plus: |
||
{{Code|code=#!/usr/bin/env python |
{{Code|code=#!/usr/bin/env python |
||
Line 324: | Line 346: | ||
#* as published by the Free Software Foundation; either version 2 of * |
#* as published by the Free Software Foundation; either version 2 of * |
||
#* the License, or (at your option) any later version. * |
#* the License, or (at your option) any later version. * |
||
#* for detail see the |
#* for detail see the LICENSE text file. * |
||
#* * |
#* * |
||
#* This program is distributed in the hope that it will be useful, * |
#* This program is distributed in the hope that it will be useful, * |
||
Line 370: | Line 392: | ||
}} |
}} |
||
= |
<span id="Related"></span> |
||
==Powiązane== |
|||
* [[Translating_an_external_workbench| |
* [[Translating_an_external_workbench/pl|Tłumaczenie interfejsu zewnętrznych środowisk pracyh]] |
||
* [https://forum.freecadweb.org/viewtopic.php?t=47460 |
* [https://forum.freecadweb.org/viewtopic.php?t=47460 Dyskusja na forum: Namespaced Workbenches] |
||
* [https://github.com/FreeCAD/freecad.workbench_starterkit freecad.workbench_starterkit] |
* [https://github.com/FreeCAD/freecad.workbench_starterkit freecad.workbench_starterkit] |
||
{{Docnav |
{{Docnav/pl |
||
|[[Localisation| |
|[[Localisation/pl|Lokalizacja]] |
||
|[[Extra_python_modules| |
|[[Extra_python_modules/pl|Dodatkowe moduły Python]] |
||
}} |
}} |
||
Latest revision as of 14:44, 12 May 2024
Wprowadzenie
Ta strona pokaże Ci, jak dodać nowe środowisko pracy do interfejsu programu FreeCAD. Środowiska pracy są kontenerami dla poleceń FreeCAD. Mogą być zakodowane w Pythonie, w C++ lub w mieszance obu tych języków, co ma tę zaletę, że łączy szybkość C++ z elastycznością Pythona. We wszystkich przypadkach jednak Twoje środowisko pracy będzie uruchamiane przez zestaw dwóch plików Python. Mogą to być "wewnętrzne" środowiska, dołączone do dystrybucji programu FreeCAD, lub "zewnętrzne", dystrybuowane za pomocą Menadżera dodatków lub instalowane ręcznie przez pobranie z jakiegoś repozytorium online. Wewnętrzne środowiska pracy mogą być napisane w C++, środowisku Python lub kombinacji tych dwóch środowisk, podczas gdy zewnętrzne środowiska pracy muszą być napisane wyłącznie w środowisku Python.
Struktura środowiska pracy
Potrzebny jest folder o dowolnej nazwie, umieszczony w katalogu Mod użytkownika, z plikiem Init.py
i opcjonalnie plikiem InitGui.py
. Plik Init.py
jest wykonywany podczas uruchamiania FreeCAD, a plik InitGui.py
jest wykonywany natychmiast po nim, ale tylko wtedy, gdy FreeCAD uruchamia się w trybie GUI. To wszystko, czego potrzebuje FreeCAD, aby znaleźć środowisko pracy podczas uruchamiania i dodać je do swojego interfejsu.
Katalog Mod użytkownika jest podkatalogiem katalogu danych aplikacji użytkownika (można go znaleźć wpisując App.getUserAppDataDir()
w konsoli Python):
- W systemie Linux jest to zazwyczaj /home/<nazwa użytkownika>/.local/share/FreeCAD/Mod/ (wersja 0.20 i powyżej) lub /home/<username>/.FreeCAD/Mod/ (wersja 0.19 i poniżej).
- W systemie Windows jest to %APPDATA%\FreeCAD\Mod\, który zwykle jest C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\.
- Na macOS jest to zazwyczaj /Users/<username>/Library/Application Support/FreeCAD/Mod/.
Katalog Mod powinien wyglądać następująco:
/Mod/
+-- MyWorkbench/
+-- Init.py
+-- InitGui.py
Wewnątrz tych plików można robić, co się chce. Zazwyczaj są one używane w ten sposób:
- W pliku Init.py wystarczy dodać kilka rzeczy używanych nawet wtedy, gdy FreeCAD działa w trybie konsoli, na przykład importerów i eksporterów plików.
- W pliku InitGui.py zazwyczaj definiuje się środowisko pracy, które zawiera nazwę, ikonę i serię poleceń FreeCAD (patrz poniżej). Ten plik Pythona definiuje również funkcje, które są wykonywane podczas ładowania FreeCAD (starasz się robić tam jak najmniej, aby nie spowalniać uruchamiania), kolejną, która jest wykonywana, gdy środowisko pracy jest aktywowane (to tam będziesz wykonywał większość pracy), a trzecią, gdy środowisko pracy jest dezaktywowane (dzięki czemu możesz usuwać rzeczy w razie potrzeby).
Opisana tutaj struktura i zawartość plików środowiska pracy jest klasycznym sposobem tworzenia nowego środowiska pracy. Można użyć niewielkiej odmiany w strukturze plików podczas tworzenia nowego środowiska pracy w Pythonie, ten alternatywny sposób najlepiej opisać jako "środowisko pracy z przestrzenią nazw", otwierając możliwość użycia narzędzia pip do zainstalowania środowiska pracy. Obie struktury działają, więc jest to bardziej kwestia preferencji podczas tworzenia nowego środowiska roboczego. Przedstawiony tutaj styl i struktura środowiska roboczego są dostępne w globalnej przestrzeni nazw FreeCAD, podczas gdy w przypadku alternatywnego stylu i struktury środowisko robocze znajduje się w dedykowanej przestrzeni nazw. Więcej informacji na ten temat można znaleźć w sekcji Powiązane.
C++ struktura środowiska pracy
Jeśli zamierzasz zakodować swoje środowisko pracy w Pythonie, nie musisz zachować szczególnej ostrożności i możesz po prostu umieścić inne pliki Python razem z plikami Init.py i InitGui.py. Podczas pracy z C++ należy jednak zachować większą ostrożność i zacząć od przestrzegania jednej podstawowej zasady FreeCAD: Rozdzielenie środowiska pracy na część aplikacji (która może działać w trybie konsoli, bez żadnego elementu GUI) i część Gui, która zostanie załadowana tylko wtedy, gdy FreeCAD działa z pełnym środowiskiem GUI. Tak więc podczas tworzenia środowiska pracy C++, najprawdopodobniej utworzysz dwa moduły, App i Gui. Te dwa moduły muszą być oczywiście wywoływalne z Pythona. Każdy moduł FreeCAD (App lub Gui) składa się co najmniej z pliku inicjującego moduł. Jest to typowy plik AppMyModuleGui.cpp:
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();
}
}
Plik Init.py
"""FreeCAD init script of XXX module"""
# ***************************************************************************
# * Copyright (c) 2015 John Doe john@doe.com *
# * *
# * 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 LICENSE 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)", "exportOwn")
print("I am executing some stuff here when FreeCAD starts!")
Możesz wybrać dowolną licencję dla swojego środowiska pracy, ale pamiętaj, że jeśli chcesz, aby Twoje środowisko pracy było w pewnym momencie zintegrowane z kodem źródłowym FreeCAD i rozpowszechniane z nim, musi to być LGPL2+, jak w powyższym przykładzie. Zobacz stronę wyjaśniającą zagadnienia Licencji.
Funkcje FreeCAD.addImportType()
i addEXportType()
pozwalają na podanie nazwy i rozszerzenia typu pliku oraz modułu Python odpowiedzialnego za jego import. W powyższym przykładzie moduł importOwn.py
będzie obsługiwał pliki .own
. Więcej przykładów można znaleźć na stronie Wycinki kodów.
Środowiska pracy w Python
To jest plik InitGui.py:
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 the workbench is first activated.
It is executed once in a FreeCAD session followed by the Activated function.
"""
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 whenever the workbench is activated"""
return
def Deactivated(self):
"""This function is executed whenever the workbench is deactivated"""
return
def ContextMenu(self, recipient):
"""This function 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
# This is not a template, the returned string should be exactly "Gui::PythonWorkbench"
return "Gui::PythonWorkbench"
Gui.addWorkbench(MyWorkbench())
Poza tym możesz zrobić co chcesz: możesz umieścić cały kod workbencha w InitGui.py, jeśli chcesz, ale zwykle wygodniej jest umieścić różne funkcje workbencha w osobnych plikach. Dzięki temu pliki te są mniejsze i łatwiejsze do przeglądania. Następnie importujesz te pliki do pliku InitGui.py. Możesz zorganizować te pliki w dowolny sposób, dobrym przykładem jest jeden dla każdego dodawanego polecenia FreeCAD.
Ustawienia
Można dodać stronę preferencji dla środowiska pracy Python. Strony preferencji szukają ikony preferencji o określonej nazwie w systemie zasobów Qt. Jeśli ikony nie ma w systemie zasobów lub nie ma poprawnej nazwy, ikona nie pojawi się na stronie preferencji.
Dodawanie ikony środowiska pracy:
- ikona preferencji musi mieć nazwę "preferences-" + "modulename" + ".svg" (wszystkie małe litery),
- utwórz plik qrc zawierający wszystkie nazwy ikon,
- w głównym katalogu *.py, uruchom pyside-rcc -o myResources.py myqrc.qrc
- w InitGui.py, dodaj import myResource(.py)
- zaktualizuj swoje repozytorium (git) za pomocą myResources.py i myqrc.qrc
Będziesz musiał powtórzyć te kroki, jeśli dodasz / zmienisz ikony.
@kbwbe stworzył fajny skrypt do kompilacji zasobów dla środowiska A2Plus. Zobacz poniżej.
Dodawanie stron preferencji:
- Musisz skompilować wtyczkę Qt Designer, która umożliwia dodawanie ustawień preferencji za pomocą Qt Designer
- Utwórz pusty widżet w Qt Designer (bez przycisków ani niczego)
- Zaprojektuj swoją stronę preferencji, każde ustawienie, które musi zostać zapisane (preferencje) musi być jednym z widżetów Gui::Pref*, które zostały dodane przez wtyczkę.
- W każdym z nich upewnij się, że wypełniłeś PrefName (nazwa wartości preferencji) i PrefPath (np. Mod/MyWorkbenchName), co spowoduje zapisanie wartości w BaseApp/Preferences/Mod/MyWorkbenchName.
- Zapisz plik UI w swoim środowisku pracy, upewnij się, że jest on obsługiwany przez cmake.
- W swoim środowisku pracy, np. wewnątrz pliku InitGui, wewnątrz metody Initialize (ale każde inne miejsce też działa), dodaj: FreeCADGui.addPreferencePage("/path/to/myUiFile.ui", "MyGroup"), przy czym "MyGroup" jest jedną z grup preferencji po lewej stronie. FreeCAD automatycznie wyszuka plik "preferences-mygroup.svg" w swoich znanych lokalizacjach (które można rozszerzyć za pomocą FreeCADGui.addIconPath()).
- Upewnij się, że metoda addPreferencePage() jest wywoływana tylko raz, w przeciwnym razie strona preferencji zostanie dodana kilka razy.
Dystrybucja
Aby rozpowszechniać swoje środowisko pracy Python, możesz po prostu hostować pliki w jakiejś lokalizacji i poinstruować użytkowników, aby pobrali je i umieścili w swoim katalogu Mod samodzielnie, lub możesz hostować je w internetowym repozytorium git (GitHub, GitLab, Framagit i Debian Salsa są obecnie obsługiwanymi lokalizacjami) i skonfigurować je do zainstalowania przez Menedżer dodatków. Instrukcje dotyczące włączenia do oficjalnej listy dodatków FreeCAD można znaleźć na stronie FreeCAD Addons GitHub repozytorium. Aby korzystać z Menedżera dodatków, należy dołączyć plik metadanych package.xml, który instruuje Menedżera dodatków, jak znaleźć ikonę środowiska pracy i umożliwia wyświetlanie opisu, numeru wersji itp. Może on być również użyty do określenia innych środowisk pracy lub pakietów Python, od których zależy, przez które jest blokowany lub które ma zastąpić.
Aby uzyskać krótki przewodnik na temat tworzenia podstawowego pliku package.xml i dodawania środowiska roboczego do Menedżera dodatków, zobacz stronę Dodaj środowisko pracy do Menadżera dodatków.
Opcjonalnie można dołączyć oddzielny plik metadanych opisujący zależności środowiska Python. Może to być albo plik o nazwie metadata.txt opisujący zewnętrzne zależności środowiska roboczego (od innych dodatków, środowisk roboczych lub modułów Pythona), albo plik requirements.txt opisujący zależności Python. Należy pamiętać, że w przypadku korzystania z pliku requirements.txt tylko nazwy określonych pakietów są używane do rozwiązywania zależności: opcje polecenia programu, opcje dołączania i informacje o wersji nie są obsługiwane przez Menedżera dodatków. Użytkownicy mogą ręcznie uruchomić plik wymagań za pomocą programu, jeśli te funkcje są wymagane.
Format pliku metadata.txt to zwykły tekst z trzema opcjonalnymi wierszami:
workbenches=
pylibs=
optionalpylibs=
Każdy wiersz powinien składać się z oddzielonej przecinkami listy elementów, od których zależy środowisko pracy. Środowiska te mogą być albo wewnętrznym środowiskiem pracy FreeCAD, np. "MES", albo zewnętrznym dodatkiem, na przykład "Krzywe". Wymagane i opcjonalne biblioteki Python powinny być określone za pomocą ich kanonicznych nazw Python, takich jak pip install
. Na przykład:
workbenches=FEM,Curves
pylibs=ezdxf
optionalpylibs=metadata,git
Możesz również dołączyć skrypt, który jest uruchamiany po odinstalowaniu pakietu. Jest to plik o nazwie "uninstall.py" znajdujący się na najwyższym poziomie dodatku. Jest on wykonywany, gdy użytkownik odinstalowuje dodatek za pomocą Menedżera dodatków. Użyj go, aby wyczyścić wszystko, co dodatek mógł zrobić w systemie użytkownika, a co nie powinno przetrwać po usunięciu dodatku (np. usunięcie plików pamięci podręcznej itp.).
Aby upewnić się, że dodatek jest poprawnie odczytywany przez Menedżera dodatków, można włączyć "tryb deweloperski", w którym Menedżer dodatków sprawdza wszystkie dostępne dodatki i upewnia się, że ich metadane zawierają wymagane elementy. Aby włączyć ten tryb, wybierz: Edycja → Preferencje ... → Menadżer dodatków → Opcje Menedżera dodatków → Tryb dewelopera dodatków, zobacz stronę Edytor ustawień aby uzyskać szczegółowe informacje.
Środowiska pracy w C++
Jeśli zamierzasz zakodować swoje środowisko pracy w C++, prawdopodobnie będziesz chciał również zakodować samą definicję środowiska pracy w C++ (choć nie jest to konieczne: możesz również zakodować tylko narzędzia w C++, a definicję środowiska pracy pozostawić w Pythonie). W takim przypadku plik InitGui.py staje się bardzo prosty: Może zawierać tylko jedną linię:
import MyModuleGui
gdzie MyModule jest kompletnym środowiskiem pracy C++, w tym poleceniami i definicją środowiska pracy.
Kodowanie środowisk pracy C++ działa w dość podobny sposób. Jest to typowy plik Workbench.cpp, który należy dołączyć do części Gui modułu:
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;
};
}
Ustawienia
Można również dodać stronę preferencji dla środowiska pracy języka C++. Kroki są podobne do tych w Pythonie.
Dystrybucja
Istnieją dwie opcje dystrybucji środowiska pracy C++, można albo samodzielnie hostować wstępnie skompilowane wersje dla różnych systemów operacyjnych, albo poprosić o scalenie kodu z kodem źródłowym FreeCAD. Jak wspomniano powyżej, wymaga to licencji LGPL2+ i należy najpierw przedstawić swoje środowisko pracy społeczności do przeglądu na forum FreeCAD.
Polecenia FreeCAD
Polecenia FreeCAD są podstawowym elementem składowym interfejsu FreeCAD. Mogą pojawiać się jako przycisk na paskach narzędzi i jako pozycja w menu. Ale to jest to samo polecenie. Polecenie jest prostą klasą Python, która musi zawierać kilka predefiniowanych atrybutów i funkcji, które definiują nazwę polecenia, jego ikonę i co należy zrobić, gdy polecenie jest aktywowane.
Definicja polecenia w Python
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())
Definicja polecenia w C++
Podobnie, można kodować polecenia w C++, zazwyczaj w pliku Commands.cpp w module Gui. To jest typowy plik Commands.cpp:
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());
}
"Kompilacja" pliku zasobów
compileA2pResources.py ze środowiska roboczego A2Plus:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#***************************************************************************
#* *
#* Copyright (c) 2019 kbwbe *
#* *
#* Portions of code based on hamish's assembly 2 *
#* *
#* 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 LICENSE text file. *
#* *
#* This program 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 Library General Public License for more details. *
#* *
#* You should have received a copy of the GNU Library General Public *
#* License along with this program; if not, write to the Free Software *
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 *
#* USA *
#* *
#***************************************************************************
# This script compiles the A2plus icons for py2 and py3
# For Linux only
# Start this file in A2plus main directory
# Make sure pyside-rcc is installed
import os, glob
qrc_filename = 'temp.qrc'
if os.path.exists(qrc_filename):
os.remove(qrc_filename)
qrc = '''<RCC>
\t<qresource prefix="/">'''
for fn in glob.glob('./icons/*.svg'):
qrc = qrc + '\n\t\t<file>%s</file>' % fn
qrc = qrc + '''\n\t</qresource>
</RCC>'''
print(qrc)
f = open(qrc_filename,'w')
f.write(qrc)
f.close()
os.system(
'pyside-rcc -o a2p_Resources2.py {}'.format(qrc_filename))
os.system(
'pyside-rcc -py3 -o a2p_Resources3.py {}'.format(qrc_filename))
os.remove(qrc_filename)
Powiązane
- Tłumaczenie interfejsu zewnętrznych środowisk pracyh
- Dyskusja na forum: Namespaced Workbenches
- freecad.workbench_starterkit
- Tworzenie skryptów FreeCAD: Python, Wprowadzenie do środowiska Python, Poradnik: Tworzenie skryptów Python, Podstawy tworzenia skryptów FreeCAD
- Moduły: Moduły wbudowane, Jednostki miar, Ilość
- Środowiska pracy: Tworzenie Środowiska pracy, Polecenia Gui, Polecenia, Instalacja większej liczby Środowisk pracy
- Siatki i elementy: Skrytpy w Środowisku Siatek, v, Konwerska Mesh na Part, PythonOCC
- Obiekty parametryczne: Obiekty tworzone skryptami, Obsługa obrazu (Ikonka niestandardowa w widoku drzewa)
- Scenegraph: Coin (Inventor) scenegraph, Pivy
- Interfejs graficzny: Stworzenie interfejsu, Kompletne stworzenie interfejsu w środowisku Python (1, 2, 3, 4, 5), PySide, PySide examples początkujący, średniozaawansowany, zaawansowany
- Makrodefinicje: Makrodefinicje, Instalacja makrodefinicji
- Osadzanie programu: Osadzanie programu FreeCAD, Osadzanie GUI FreeCAD
- Pozostałe: Wyrażenia, Wycinki kodu, Funkcja kreślenia linii, Biblioteka matematyczna FreeCAD dla wektorów (deprecated)
- Węzły użytkowników: Centrum użytkownika, Centrum Power użytkowników, Centrum programisty