Tworzenie środowiska pracy

From FreeCAD Documentation
Revision as of 08:31, 29 October 2023 by Kaktus (talk | contribs) (Created page with "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...")

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 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 LICENCE text file.                                 *
# *                                                                         *
# *   FreeCAD is distributed in the hope that it will be useful,            *
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
# *   GNU Lesser General Public License for more details.                   *
# *                                                                         *
# *   You should have received a copy of the GNU Library General Public     *
# *   License along with FreeCAD; if not, write to the Free Software        *
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
# *   USA                                                                   *
# *                                                                         *
# ***************************************************************************/

FreeCAD.addImportType("My own format (*.own)", "importOwn")
FreeCAD.addExportType("My own format (*.own)", "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.

The format of the metadata.txt file is plain text, with three optional lines:

workbenches=
pylibs=
optionalpylibs=

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 pip install. For example:

workbenches=FEM,Curves
pylibs=ezdxf
optionalpylibs=metadata,git

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.).

To ensure that your addon is being read correctly by the Addon Manager, you can enable a "developer mode" in which the Addon Manager examines all available addons and ensures their metadata contains the required elements. To enable this mode select: Edit → Preferences... → Addon Manager → Addon manager options → Addon developer mode, see Preferences Editor.

C++ workbenches

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:

import MyModuleGui

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:

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

You can add a Preferences page for C++ workbenches too. The steps are similar to those for Python.

Dystrybucja

There are two options to distribute a C++ workbench, you can either host precompiled versions for the different operating systems yourself, or you can request for your code to be merged into the FreeCAD source code. As mentioned above this requires a LGPL2+ license, and you must first present your workbench to the community in the FreeCAD forum for review.

FreeCAD commands

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.

Python command definition

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())

C++ command definition

Similarly, you can code your commands in C++, typically in a Commands.cpp file in your Gui module. This is a typical Commands.cpp file:

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());
}

"Compiling" your resource file

compileA2pResources.py from the A2Plus workbench:

#!/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 LICENCE 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