Workbench creation/pl: Difference between revisions

From FreeCAD Documentation
(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 pole robocze 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|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 Pythoni.
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==


You need a folder, with any name you like, placed in the user Mod directory, with an {{incode|Init.py}} file, and, optionally an {{incode|InitGui.py}} file. The Init file is executed when FreeCAD starts, and the {{incode|InitGui.py}} file is executed immediately after, but only when FreeCAD starts in GUI mode. That's all it needs for FreeCAD to find your workbench at startup and add it to its interface.
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.


The user Mod directory is a sub-directory of the user application data directory (you can find the latter by typing {{incode|App.getUserAppDataDir()}} in the [[Python_console|Python console]]):
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]]):
* On Linux it is usually {{FileName|/home/<username>/.FreeCAD/Mod/}}.
* 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}}).
* On Windows it is {{FileName|%APPDATA%\FreeCAD\Macro\}}, which is usually {{FileName|C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\}}.
* W systemie Windows jest to {{FileName|%APPDATA%\FreeCAD\Mod\}}, który zwykle jest {{FileName|C:\Users\<username>\Appdata\Roaming\FreeCAD\Mod\}}.
* On macOS it is usually {{FileName|/Users/<username>/Library/Application Support/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:


* In the Init.py file you just add a couple of things used even when FreeCAD works in console mode, for example the file importers and exporters
* 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>
=== The Init.py file ===
===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 LICENCE text file. *
# * 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)", "importOwn")
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]].


The {{incode|FreeCAD.addImportType()}} and {{incode|addEXportType()}} functions allow you to give the name and extension of a file type, and a Python module responsible for its import. In the example above, an {{incode|importOwn.py}} module will handle {{incode|.own}} files. See [[Code_snippets|Code snippets]] for more examples.
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===


This is the InitGui.py file:
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"] # A list of command names created in the line above
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.


====Preferences====
<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:
* the preferences icon needs to be named "preferences-" + "modulename" + ".svg" (all lowercase)
* 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
* in the main *.py directory, run pyside-rcc -o myResources.py myqrc.qrc
* w głównym katalogu *.py, uruchom pyside-rcc -o myResources.py myqrc.qrc
* in InitGui.py, add import myResource(.py)
* w InitGui.py, dodaj import myResource(.py)
* update your repository(git) with myResources.py and myqrc.qrc
* 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 has created a nice script to compile resources for the A2Plus workbench. See below.
@kbwbe stworzył fajny skrypt do kompilacji zasobów dla środowiska A2Plus. Zobacz poniżej.


Dodawanie stron preferencji:
Adding your preference page(s):
* You need to compile the Qt designer plugin that allows you to add preference settings with [[Compile_on_Linux#Qt_designer_plugin|Qt Designer]]
* Musisz skompilować wtyczkę Qt Designer, która umożliwia dodawanie ustawień preferencji za pomocą [[Compile_on_Linux/pl#Qt_designer_plugin|Qt Designer]]
* Create a blank widget in Qt Designer (no buttons or anything)
* 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)
* In any of those, make sure you fill the PrefName (the name of your preference value) and PrefPath (ex: Mod/MyWorkbenchName), which will save your value under BaseApp/Preferences/Mod/MyWorkbenchName
* 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
* In your workbench, for ex. inside the InitGui file, inside the Initialize method (but any other place works too), add: FreeCADGui.addPreferencePage("/path/to/myUiFile.ui","MyGroup"), "MyGroup" being one of the preferences groups on the left. FreeCAD will automatically look for a "preferences-mygroup.svg" file in its known locations (which you can extend with FreeCADGui.addIconPath())
* 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())''.
* Make sure the addPreferencePage() method is called only once, otherwise your pref page will be added several times
* Upewnij się, że metoda addPreferencePage() jest wywoływana tylko raz, w przeciwnym razie strona preferencji zostanie dodana kilka razy.


====Distribution====
<span id="Distribution"></span>
====Dystrybucja====


To distribute your Python workbench, you may either simply host the files in some location and instruct your users to download them and place them in their Mod directory manually, or you may host them in an online git repository (GitHub, GitLab, Framagit, and Debian Salsa are currently supported locations) and configure them for the [[Std_AddonMgr|Addon Manager]] to install. Instructions for inclusion on FreeCAD's official Addons list can be found on the [https://github.com/FreeCAD/FreeCAD-addons/blob/master/README.md FreeCAD Addons GitHub repository]. To use the Addon Manager, a [[Package_Metadata|package.xml metadata file]] should be included, which instructs the Addon Manager how to find your workbench's icon, and allows display of a description, version number, etc. It can also be used to specify other workbenches or Python packages that your Workbench either depends on, is blocked by, or is intended to replace.
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 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:
}}
}}


Each line should consist of a comma-separated list of items your Workbench depends on. Workbenches may be either an internal FreeCAD Workbench, e.g. "FEM", or an external Addon, for example "Curves". The required and optional Python libraries should be specified with their canonical Python names, such as you would use with {{incode|pip install}}. For example:
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.


Coding C++ workbenches works in a pretty similar way. This is a typical Workbench.cpp file to include in the Gui part of your module:
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:
}}
}}


====Preferences====
<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++===


Similarly, you can code your commands in C++, typically have a Commands.cpp file in your Gui module. This is a typical Commands.cpp file:
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="&quot;Compiling&quot;_your_resource_file"></span>
=="Compiling" your resource file==
=="Kompilacja" pliku zasobów==


compileA2pResources.py from the A2Plus workbench:
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 LICENCE text file. *
#* 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:
}}
}}


== Related ==
<span id="Related"></span>
==Powiązane==


* [[Translating_an_external_workbench|Translating an external workbench]]
* [[Translating_an_external_workbench/pl|Tłumaczenie interfejsu zewnętrznych środowisk pracyh]]
* [https://forum.freecadweb.org/viewtopic.php?t=47460 Forum discussion: Namespaced Workbenches]
* [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]]
|[[Localisation/pl|Lokalizacja]]
|[[Extra_python_modules|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