def Initialize(self): # load the module import SurfaceToolsGui import FreeCADGui # Set path to icon labels FreeCADGui.addIconPath('./Gui/Resources/Icons/')
def Initialize(self): """This function is executed when FreeCAD starts""" import RebarTools from BillOfMaterial.BOMPreferences import BOMPreferences from pathlib import Path self.rebar_commands = RebarTools.ReinforcementCommands self.appendToolbar("RebarCommands", self.rebar_commands) BOMPreferences() FreeCADGui.addPreferencePage( str( Path(RebarTools.__file__).parent.absolute() / "BillOfMaterial" / "BOMPreferences.ui" ), "Reinforcement", ) FreeCADGui.addIconPath( str( Path(RebarTools.__file__).parent.absolute() / "icons" / "preferences" ) )
def Initialize(self): # load the module # import GD&T tools try: from . import datum_feature from . import datum_system from . import geometric_tolerance from . import annotation_plane from . import inventory except ImportError: FreeCAD.Console.PrintWarning( "Error: Initializing one or more of the GD&T modules failed, GD&T will not work as expected.\n" ) self.cmdList = [ 'dd_datumFeature', 'dd_datumSystem', 'dd_geometricTolerance', 'dd_annotationPlane' ] self.inventory = ['dd_inventory'] self.appendToolbar("GD&T Tools", self.cmdList + self.inventory) self.appendMenu("GD&T Tools", self.cmdList + self.inventory) gui.addIconPath(str(ICON_DIR)) gui.addPreferencePage( str(DIR / 'Resources' / 'ui' / 'preferences-gdt.ui'), 'GDT') Log("Loading Geometric Dimensioning & Tolerancing... done\n")
def Initialize(self): def QT_TRANSLATE_NOOP(scope, text): return text #import GDMLCommands, GDMLResources commands=['CycleCommand','ExpandCommand', \ 'PolyHedraCommand', 'BoxCommand','ConeCommand','ElTubeCommand', \ 'EllipsoidCommand','SphereCommand', \ 'TrapCommand','TubeCommand','AddCompound', \ 'TessellateCommand', 'Mesh2TessCommand'] toolbarcommands=['CycleCommand','ExpandCommand', 'PolyHedraCommand', 'BoxCommand','ConeCommand', \ 'ElTubeCommand', 'EllipsoidCommand','SphereCommand', \ 'TrapCommand','TubeCommand','AddCompound', \ 'TessellateCommand', 'Mesh2TessCommand'] parttoolbarcommands = ['Part_Cut', 'Part_Fuse', 'Part_Common'] meshtoolbarcommands = ['Mesh_FromPartShape'] self.appendToolbar(QT_TRANSLATE_NOOP('Workbench', 'GDMLTools'), toolbarcommands) self.appendMenu('GDML', commands) self.appendToolbar(QT_TRANSLATE_NOOP('Workbech', 'GDML Part tools'), parttoolbarcommands) FreeCADGui.addIconPath(joinDir("Resources/icons")) FreeCADGui.addLanguagePath(joinDir("Resources/translations")) FreeCADGui.addPreferencePage(joinDir("Resources/ui/GDML-base.ui"), "GDML")
def Initialize(self): import kicadStepUpCMD, sys global pref_page pref_page = True # False #True # import FreeCADGui submenu = ['demo.kicad_pcb','d-pak.kicad_mod', 'demo-sketch.FCStd', 'demo.step',\ 'footprint-template.FCStd', 'footprint-Edge-template.FCStd', 'footprint-template-roundrect-polylines.FCStd',\ 'footprint-RF-antenna.FCStd', 'footprint-RF-antenna-w-solder-Mask.FCStd', 'RF-antenna-dxf.dxf', \ 'complex-Polyline-footprint.FCStd', 'footprint-complex-arc-pads.FCStd', \ 'footprint-SPU0410LR5H.FCStd',\ 'kicadStepUp-cheat-sheet.pdf', 'kicad-3D-to-MCAD.pdf', 'Generating-a-KiCAD-footprint-and-Model-from-3D-Step-Data.pdf' ] dirs = self.ListDemos() #self.appendToolbar("ksu Tools", ["ksuTools"]) self.appendToolbar("ksu Tools", ["ksuToolsEditPrefs","ksuTools","ksuToolsOpenBoard","ksuToolsLoadFootprint",\ "ksuToolsExportModel","ksuToolsPushPCB","ksuToolsFootprintGen","Separator","ksuToolsAddTracks","ksuToolsAddSilks","Separator",\ "ksuToolsCollisions","ksuToolsImport3DStep","ksuToolsExport3DStep","ksuToolsMakeUnion",\ "ksuToolsMakeCompound", "ksuToolsSimpleCopy", "ksuToolsDeepCopy", "ksuToolsCheckSolid"]) #, "ksuToolsPushMoved","ksuToolsSync3DModels"]) self.appendToolbar("ksu Sketching", ["ksuTools3D2D", "ksuTools2D2Sketch", "ksuTools2DtoFace",\ "ksuToolsLoopSelection","ksuToolsEdges2Sketch","ksuToolsOffset2D","ksuToolsExtrude","ksuToolsMergeSketches",\ "ksuToolsSimplifySketck", "ksuToolsBsplineNormalize", "ksuToolsConstrainator", "ksuToolsSkValidate", "ksuToolsDiscretize"]) #, "ksuToolsPushMoved","ksuToolsSync3DModels"]) ksuTB = ["ksuToolsOpenBoard","ksuToolsPushPCB","ksuToolsPushMoved","ksuToolsSync3DModels","ksuToolsPullPCB","ksuToolsPullMoved","ksuAsm2Part",\ "Separator","ksuToolsGeneratePositions","ksuToolsComparePositions",\ "Separator","ksuToolsToggleTreeView","Separator","ksuRemoveTimeStamp","ksuRemoveSuffix","Separator","ksuToolsLoadFootprint","ksuToolsFootprintGen"] #ksuTB.extend(["Separator","ksuToolsAligner","ksuToolsMover","ksuToolsCaliper"]) self.appendToolbar("ksu PushPull", ksuTB) combined_path = '\t'.join(sys.path) if 'Manipulator' in combined_path: ksuDTB=["ksuToolsAligner","ksuToolsMover","ksuToolsCaliper","Separator","ksuToolsDefeaturingTools"] self.appendToolbar("ksu Design Tools", ksuDTB) Hlp_TB = ["ksuToolsToggleTreeView", "Restore_Transparency", "ksuToolsTransparencyToggle", "ksuToolsHighlightToggle",\ "ksuToolsVisibilityToggle", "ksuToolsStepImportModeSTD", "ksuToolsStepImportModeComp",\ "ksuToolsCopyPlacement", "ksuToolsResetPlacement", "ksuToolsResetPartPlacement", "ksuToolsAddToTree",\ "ksuToolsRemoveFromTree", "ksuToolsRemoveSubTree", "checkSolidExpSTEP"] #if 'LinkView' in dir(FreeCADGui): # Hlp_TB.remove("ksuToolsHighlightToggle") self.appendToolbar("ksu Show", ["ksuToolsTurnTable", "ksuToolsExplode"]) self.appendToolbar("ksu Helpers", Hlp_TB) #self.appendMenu("ksu Tools", ["ksuTools","ksuToolsEdit"]) self.appendMenu("ksu Tools", ["ksuTools","ksuToolsEditPrefs"]) self.appendMenu("ksu PushPull", ["ksuToolsOpenBoard","ksuToolsPushPCB","ksuToolsPushMoved","ksuToolsSync3DModels","ksuToolsPullPCB","ksuToolsPullMoved",\ "Separator","ksuToolsGeneratePositions","ksuToolsComparePositions",\ "Separator","ksuRemoveTimeStamp","ksuRemoveSuffix",\ "Separator","ksuToolsLoadFootprint","ksuToolsFootprintGen"]) self.appendMenu(["ksu Tools", "Demo"], submenu) #FreeCADGui.addPreferencePage( a2plib.pathOfModule() + '/GuiA2p/ui/a2p_prefs.ui','A2plus' ) if pref_page: FreeCADGui.addPreferencePage( ksuWB_ui_path + '/ksu_prefs.ui', 'kicadStepUpGui' ) FreeCADGui.addPreferencePage(kSU_MainPrefPage,"kicadStepUpGui") FreeCADGui.addIconPath(ksuWB_icons_path) Log ("Loading ksuModule... done\n")
def Initialize(self): # load the module import SurfaceGui import FreeCADGui import Surface # Set path to icon labels FreeCADGui.addIconPath('./Gui/Resources/Icons/')
def Initialize(self): "This function is executed when FreeCAD starts" import GazeboSDFExportStatic, GazeboSDFExport, CreateJoint # import here all the needed files that create your FreeCAD commands self.list = ['RC_GazeboSDFExportStatic','RC_GazeboSDFExport', 'RC_CreateJoint'] # A list of command names created in the line above self.appendToolbar("RobotCreator",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 FreeCADGui.addIconPath( '~/.FreeCAD/Mod/RobotCreator/icons' )
def Initialize(self): from gearfunc import CreateCycloideGear, CreateInvoluteGear, CreateBevelGear self.appendToolbar("Gear", ["CreateInvoluteGear", "CreateCycloideGear", "CreateBevelGear"]) self.appendMenu("Gear", ["CreateInvoluteGear", "CreateCycloideGear","CreateBevelGear"]) Gui.addIconPath(FreeCAD.getHomePath()+"Mod/gear/icons/") Gui.addCommand('CreateInvoluteGear', CreateInvoluteGear()) Gui.addCommand('CreateCycloideGear', CreateCycloideGear()) Gui.addCommand('CreateBevelGear', CreateBevelGear())
def Initialize(self): # imports from .commands import CreatePlate, CreateSeparator, CreateWasher, CreateScrew self.appendToolbar("Construction Toy", self.commands) self.appendMenu("Construction Toy", self.commands) Gui.addIconPath(App.getHomePath() + "Mod/constructiontoy/icons/") Gui.addCommand('CreatePlate', CreatePlate()) Gui.addCommand('CreateSeparator', CreateSeparator()) Gui.addCommand('CreateWasher', CreateWasher()) Gui.addCommand('CreateScrew', CreateScrew())
def Initialize(self): # run self-tests depsOK = False try: from pivy import coin if FreeCADGui.getSoDBVersion() != coin.SoDB.getVersion(): raise AssertionError("FreeCAD and Pivy use different versions of Coin. This will lead to unexpected behaviour.") except AssertionError: FreeCAD.Console.PrintWarning("Error: FreeCAD and Pivy use different versions of Coin. This will lead to unexpected behaviour.\n") except ImportError: FreeCAD.Console.PrintWarning("Error: Pivy not found, DDA workbench will be disabled.\n") except: FreeCAD.Console.PrintWarning("Error: Unknown error while trying to load Pivy\n") else: try: import PyQt4 except ImportError: FreeCAD.Console.PrintWarning("Error: PyQt4 not found, DDA workbench will be disabled.\n") else: depsOK = True # import FreeCAD , FreeCADGui import DDA_rc import FreeCADGui FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") # try: import DDAShapes # except: # FreeCAD.Console.PrintWarning("'DDAShapes' moudle import failed.") import DGPlayer , DFCalculation , DDAPanel # try: import drawGui # except: # FreeCAD.Console.PrintWarning("'drawGui' moudle import failed.") import DDAToolbars import interfaceTools import storeScene import loadDataTools import DDAStdCommands import AnalysisDDAResult # FreeCADGui.addPreferencePage(":/DDA-preferences.ui","DDA") # FreeCADGui.addPreferencePage(":/userprefs-base.ui","DDA") # FreeCAD.Console.PrintMessage('Loading DDA GUI...\n') import DDAGui list = ['DDA_NewDoc' , 'DDA_Undo' , 'DDA_Redo', 'Std_ViewFitAll' , 'DDA_ChooseProjectPath' , 'DDA_Examples', 'DDA_DL' , 'DDA_DC','DFCalculation','PlayDF', 'DDA_DGAnalysiser' ] # list = ['DDA_NewDoc' , 'DDA_Undo' , 'DDA_Redo', 'DDA_ChooseProjectPath' , 'DDA_SetPanelSize' , 'DDA_DL' , 'DDA_DC','DFCalculation','PlayDF'] self.appendToolbar('DDACmds' , list)
def Initialize(self): from gearfunc import CreateCycloideGear, CreateInvoluteGear from gearfunc import CreateBevelGear, CreateInvoluteRack, CreateCrownGear self.appendToolbar("Gear", self.commands) self.appendMenu("Gear", self.commands) Gui.addIconPath(App.getHomePath() + "Mod/gear/icons/") Gui.addCommand('CreateInvoluteGear', CreateInvoluteGear()) Gui.addCommand('CreateCycloideGear', CreateCycloideGear()) Gui.addCommand('CreateBevelGear', CreateBevelGear()) Gui.addCommand('CreateInvoluteRack', CreateInvoluteRack()) Gui.addCommand('CreateCrownGear', CreateCrownGear())
def Initialize(self): from .commands import CreateCycloideGear, CreateInvoluteGear from .commands import CreateBevelGear, CreateInvoluteRack, CreateCrownGear self.appendToolbar("Gear", self.commands) self.appendMenu("Gear", self.commands) Gui.addIconPath(App.getHomePath()+"Mod/gear/icons/") Gui.addCommand('CreateInvoluteGear', CreateInvoluteGear()) Gui.addCommand('CreateCycloideGear', CreateCycloideGear()) Gui.addCommand('CreateBevelGear', CreateBevelGear()) Gui.addCommand('CreateInvoluteRack', CreateInvoluteRack()) Gui.addCommand('CreateCrownGear', CreateCrownGear())
def checkImports(): def missingDependency(file): module = os.path.join(os.path.dirname(EmptyFile.__file__), "libs", file) python = os.path.join( os.path.dirname(sys.executable), os.path.basename(sys.executable).replace('FreeCAD', 'python')) subprocess.call(u"\"%s\" -m pip install \"%s\"" % (python, module)) import os, subprocess, traceback, FreeCAD, FreeCADGui, EmptyFile try: if (not hasattr(FreeCADGui, 'InventorLoaderPrefs')): addinpath = os.path.abspath(os.path.dirname(EmptyFile.__file__)) FreeCADGui.addIconPath(os.path.join(addinpath, 'Resources')) FreeCADGui.addPreferencePage( os.path.join(addinpath, 'Resources/ui/PrefsInventorLoader.ui'), 'Import-Export') FreeCADGui.InventorImporterPrefs = True except: FreeCAD.Console.PrintError(">E: %s\n" % traceback.format_exc()) try: import olefile except: missingDependency("olefile-0.46.zip") try: import xlrd except: missingDependency("xlrd-1.2.0.tar.gz") try: import xlwt except: missingDependency("xlwt-1.3.0.tar.gz") try: import xlutils except: missingDependency("xlutils-2.0.0.tar.gz") import importerUtils try: import SheetMetalCmd importerUtils.setUseSheetMetal(True) except: importerUtils.setUseSheetMetal(False) from InventorWorkbench import InventorWorkbench Gui.addWorkbench(InventorWorkbench)
def Initialize(self): #"This function is executed when FreeCAD starts" import EB_Commands, MeasureEdges # import here all the needed files that create your FreeCAD commands self.listTests = ([ "Clear_Console", "EnableConnectionToEB", "DisableConnectionToEB", "ShowTestsConsole" ]) self.appendToolbar("EB Tests", self.listTests) self.list = ([ "Get_EB_Shape", "Get_EB_Shape_Step", "Add_EB_Shape_With_Shift", "Add_EB_Shape_With_Shift_Step", "Add_EB_Step_Assembly", "Select_EB_Shape" ]) # A list of command names created in the line above self.appendToolbar( "EB Commands", self.list) # creates a new toolbar with your commands self.appendMenu("Engineering Base", self.list) # creates a new menu self.listAux = ([ "Get_DIN_Rail_TS35", "Get_Terminal_Block", "Get_GuiTab" ]) self.appendToolbar("EB Aux", self.listAux) # import Draft tools, icons try: import os, Draft_rc, DraftTools, DraftGui, Draft from DraftTools import translate FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") except Exception as inst: print(inst) FreeCAD.Console.PrintError( "Error: Initializing one or more of the Draft modules failed, Draft will not work as expected.\n" ) self.createList = [ "Draft_Line", "Draft_Wire", "Draft_Circle", "Draft_Ellipse", "Draft_Polygon", "Draft_Rectangle", "Draft_Point" ] self.appendToolbar("Create", self.createList) self.moveList = [ "Mover_For_Object", "Draft_Move", "Draft_Rotate", "Move_Piont_To_Point", "Rotate_Sel_Object_15" ] self.appendToolbar("EB Move", self.moveList) self.visibilityList = [ "Set_Transparancy", "Set_Display_Mode_Wire_Frame", "Set_Display_Mode_Flat_Lines", "Set_Visibility_True" ] self.appendToolbar("EB Visibility", self.visibilityList)
def Initialize(self): def QT_TRANSLATE_NOOP(scope, text): return text #import GDMLCommands, GDMLResources commands=['CycleCommand','ColourMapCommand','ExpandCommand', \ 'ExpandMaxCommand','SetMaterialCommand', \ 'BoxCommand','ConeCommand','ElTubeCommand', \ 'EllipsoidCommand','SphereCommand', \ 'TorusCommand','TrapCommand','TubeCommand', \ 'Sketcher_NewSketch','Part_Extrude', \ 'BooleanCutCommand','BooleanIntersectionCommand', \ 'BooleanUnionCommand', \ 'TessellateCommand','TessellateGmshCommand', \ 'DecimateCommand', \ 'Mesh_FromPartShape','Mesh_Evaluation', \ 'Mesh2TessCommand','Tess2MeshCommand', 'TetrahedronCommand', \ 'AddCompound'] toolbarcommands=['CycleCommand','ColourMapCommand','ExpandCommand', 'ExpandMaxCommand', 'SetMaterialCommand', \ 'Separator','Std_Part','BoxCommand','ConeCommand', \ 'ElTubeCommand', 'EllipsoidCommand','SphereCommand', \ 'TorusCommand','TrapCommand','TubeCommand', \ 'Sketcher_NewSketch','Part_Extrude', \ 'Separator', 'BooleanCutCommand','BooleanIntersectionCommand', \ 'BooleanUnionCommand','Separator', \ 'TessellateCommand','TessellateGmshCommand', \ 'DecimateCommand', \ 'Mesh_FromPartShape','Mesh_Evaluation', \ 'Mesh2TessCommand','Tess2MeshCommand','TetrahedronCommand', \ 'AddCompound'] #parttoolbarcommands = ['Part_Cut','Part_Fuse','Part_Common'] #meshtoolbarcommands = ['Mesh_FromPartShape','Mesh_Evaluation'] self.appendToolbar(QT_TRANSLATE_NOOP('Workbench','GDMLTools'),toolbarcommands) self.appendMenu('GDML',commands) #self.appendToolbar(QT_TRANSLATE_NOOP('Workbech','GDML Part tools'),parttoolbarcommands) #self.appendToolbar(QT_TRANSLATE_NOOP('Workbech','GDML Mesh Tools'),meshtoolbarcommands) FreeCADGui.addIconPath(joinDir("Resources/icons")) FreeCADGui.addLanguagePath(joinDir("Resources/translations")) FreeCADGui.addPreferencePage(joinDir("Resources/ui/GDML-base.ui"),"GDML")
def Initialize(self): def QT_TRANSLATE_NOOP(scope, text): return text #import 2SCommands commands=['toSPlaneCommand','toSketchCommand','toMacroCommand', \ 'toCurveFitCommand', \ 'toScaleCommand','toResetOriginCommand'] toolbarcommands=['toSPlaneCommand','toSketchCommand','toMacroCommand', \ 'toCurveFitCommand', \ 'toScaleCommand','toResetOriginCommand'] import PartGui parttoolbarcommands = ['Part_Loft'] self.appendToolbar(QT_TRANSLATE_NOOP('Workbench', \ 'toSketch_Tools'),toolbarcommands) self.appendToolbar(QT_TRANSLATE_NOOP('Workbench', \ 'toSketch_Tools Part Tools'),parttoolbarcommands) self.appendMenu('toSketch', commands) FreeCADGui.addIconPath(joinDir("Resources/icons")) FreeCADGui.addLanguagePath(joinDir("Resources/translations"))
import os try: import FreeCADGui as Gui import FreeCAD except ImportError: print("module not loaded with freecad") import glider_metadata Dir = os.path.dirname(glider_metadata.__file__) Gui.addIconPath(Dir + "/icons") class gliderWorkbench(Gui.Workbench): """probe workbench object""" MenuText = "glider" ToolTip = "glider workbench" Icon = "glider_workbench.svg" toolBox = [ "CreateGlider", "ImportGlider", "ShapeCommand", "ArcCommand", "AoaCommand", "ZrotCommand", "AirfoilCommand", "AirfoilMergeCommand", "BallooningCommand", "BallooningMergeCommand", "CellCommand", "LineCommand",
def isEnabled(self,but): "returns true if the given button is turned on" for b in self.toolbarButtons: if str(b.objectName()) == "SnapButton" + but: return (b.isEnabled() and b.isChecked()) return False def show(self): "shows the toolbar" if not hasattr(self,"toolbar"): self.makeSnapToolBar() mw = getMainWindow() bt = mw.findChild(QtGui.QToolBar,"Draft Snap") if not bt: mw.addToolBar(self.toolbar) self.toolbar.show() def setGrid(self): "sets the grid, if visible" if self.grid: if self.grid.Visible: self.grid.set() if not hasattr(FreeCADGui,"Snapper"): FreeCADGui.Snapper = Snapper() if not hasattr(FreeCAD,"DraftWorkingPlane"): import WorkingPlane, Draft_rc FreeCAD.DraftWorkingPlane = WorkingPlane.plane() print FreeCAD.DraftWorkingPlane FreeCADGui.addIconPath(":/icons")
def Initialize(self): "This function is executed when FreeCAD starts" import BOPTools # as bop import Design456_Extrude # import all needed files import Design456_Extract import Design456_ExtrudeFace import Design456_SplitObject import Design456_loftOnDirection import Design456_Part as designPart import Design456_Part_Tools as pTools import Design456_Part_Utils as pUtils import Design456_2Ddrawing as TwoDDraw import Design456_SelectionGate as SelGate import Design456_Alignment as align # from Part import CommandShapes #Tube not working Gui.runCommand('Std_PerspectiveCamera', 1) self.appendToolbar("Design456_Part", designPart.Design456_Part.list) self.appendToolbar("Design456_Tools", pTools.Design456_Part_Tools.list) self.appendToolbar("Design456_2DTools", pUtils.Design456_Part_Utils.list) self.appendToolbar("Design456_2Ddrawing", TwoDDraw.Design456_2Ddrawing.list) self.appendToolbar("Selection Mode", SelGate.Design456_SelectionGate.list) self.appendToolbar("Design456_Alignments", align.Design456_Alignment.list) self.appendMenu("Design456_Part", designPart.Design456_Part.list) self.appendMenu("Design456_Tools", pTools.Design456_Part_Tools.list) self.appendMenu("Design456_2Ddrawing", TwoDDraw.Design456_2Ddrawing.list) self.appendMenu("Design456_2DTools", pUtils.Design456_Part_Utils.list) self.appendMenu("Design456_Alignments", align.Design456_Alignment.list) # Design456_Part #self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Drafting"), self.drawing_commands) # Design456_Part # DRAFT def QT_TRANSLATE_NOOP(context, text): return text # Run self-tests dependencies_OK = False try: from pivy import coin if Gui.getSoDBVersion() != coin.SoDB.getVersion(): raise AssertionError("FreeCAD and Pivy use different versions " "of Coin. " "This will lead to unexpected behavior.") except AssertionError: App.Console.PrintWarning("Error: FreeCAD and Pivy " "use different versions of Coin. " "This will lead to unexpected " "behavior.\n") except Exception: App.Console.PrintWarning("Error: Pivy not found, " "Draft Workbench will be disabled.\n") except Exception: App.Console.PrintWarning("Error: Unknown error " "while trying to load Pivy.\n") else: dependencies_OK = True if not dependencies_OK: return # END DRAFT # Import Draft tools, icons try: import Draft_rc import DraftTools import DraftGui import DraftFillet Gui.addLanguagePath(":/translations") Gui.addIconPath(":/icons") except Exception as exc: App.Console.PrintError(exc) App.Console.PrintError("Error: Initializing one or more " "of the Draft modules failed, " "Draft will not work as expected.\n") try: # Set up command lists import draftutils.init_tools as it self.drawing_commands = it.get_draft_drawing_commands() self.annotation_commands = it.get_draft_annotation_commands() self.modification_commands = it.get_draft_modification_commands() self.context_commands = it.get_draft_context_commands() self.line_commands = it.get_draft_line_commands() self.utility_commands = it.get_draft_utility_commands() self.utility_small = it.get_draft_small_commands() # Set up toolbars self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft creation tools"), self.drawing_commands) self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft annotation tools"), self.annotation_commands) self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft modification tools"), self.modification_commands) self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft utility tools"), self.utility_small) # Set up menus self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Drafting"), self.drawing_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Annotation"), self.annotation_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Modification"), self.modification_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Utilities"), self.utility_commands + self.context_commands) # Set up preferences pages if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(Gui.draftToolBar, "loadedPreferences"): Gui.addPreferencePage(":/ui/preferences-draft.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) Gui.addPreferencePage(":/ui/preferences-draftinterface.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) Gui.addPreferencePage(":/ui/preferences-draftsnap.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) Gui.addPreferencePage(":/ui/preferences-draftvisual.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) Gui.addPreferencePage(":/ui/preferences-drafttexts.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) Gui.draftToolBar.loadedPreferences = True # END DRAFT except Exception as exc: App.Console.PrintError(exc) App.Console.PrintError("Error: Initializing one or more " "of the Draft modules failed, " "Draft will not work as expected.\n")
def Initialize(self): """When the workbench is first loaded.""" def QT_TRANSLATE_NOOP(context, text): return text # Run self-tests dependencies_OK = False try: from pivy import coin if FreeCADGui.getSoDBVersion() != coin.SoDB.getVersion(): raise AssertionError("FreeCAD and Pivy use different versions " "of Coin. " "This will lead to unexpected behaviour.") except AssertionError: FreeCAD.Console.PrintWarning("Error: FreeCAD and Pivy " "use different versions of Coin. " "This will lead to unexpected " "behaviour.\n") except ImportError: FreeCAD.Console.PrintWarning("Error: Pivy not found, " "Draft Workbench will be disabled.\n") except Exception: FreeCAD.Console.PrintWarning("Error: Unknown error " "while trying to load Pivy.\n") else: dependencies_OK = True if not dependencies_OK: return # Import Draft tools, icons try: import Draft_rc import DraftTools import DraftGui import DraftFillet from draftguitools import gui_circulararray from draftguitools import gui_polararray from draftguitools import gui_orthoarray from draftguitools import gui_arrays FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") except Exception as exc: FreeCAD.Console.PrintError(exc) FreeCAD.Console.PrintError("Error: Initializing one or more " "of the Draft modules failed, " "Draft will not work as expected.\n") # Set up command lists import draftutils.init_tools as it self.drawing_commands = it.get_draft_drawing_commands() self.annotation_commands = it.get_draft_annotation_commands() self.modification_commands = it.get_draft_modification_commands() self.context_commands = it.get_draft_context_commands() self.line_commands = it.get_draft_line_commands() self.utility_commands = it.get_draft_utility_commands() # Set up toolbars self.appendToolbar(QT_TRANSLATE_NOOP("Draft", "Draft creation tools"), self.drawing_commands) self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft annotation tools"), self.annotation_commands) self.appendToolbar( QT_TRANSLATE_NOOP("Draft", "Draft modification tools"), self.modification_commands) # Set up menus self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Drafting"), self.drawing_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Annotation"), self.annotation_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Modification"), self.modification_commands) self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Utilities"), self.utility_commands + self.context_commands) # Set up preferences pages if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(FreeCADGui.draftToolBar, "loadedPreferences"): FreeCADGui.addPreferencePage( ":/ui/preferences-draft.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftsnap.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftvisual.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-drafttexts.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.draftToolBar.loadedPreferences = True FreeCAD.Console.PrintLog('Loading Draft workbench, done.\n')
def Initialize(self): import sys PyVersion = sys.version_info[0] if PyVersion == 2: import a2p_Resources2 else: import a2p_Resources3 import a2plib import a2p_importpart import a2p_recursiveUpdatePlanner import a2p_convertPart import a2p_solversystem import a2p_MuxAssembly import a2p_partinformation import a2p_constraintDialog import a2p_constraintcommands import a2p_bom # bom == bill of materials == partslist if a2plib.getRecursiveUpdateEnabled(): partCommands = [ 'a2p_ImportPart', 'a2p_ImportShapeReferenceCommand', 'a2p_updateImportedParts', 'a2p_recursiveUpdateImportedPartsCommand', 'a2p_movePart', 'a2p_MovePartUnderConstraints', 'a2p_duplicatePart', 'a2p_ConvertPart', 'a2p_editImportedPart', 'a2p_SaveAndExit_Command', ] else: partCommands = [ 'a2p_ImportPart', 'a2p_ImportShapeReferenceCommand', 'a2p_updateImportedParts', 'a2p_movePart', 'a2p_MovePartUnderConstraints', 'a2p_duplicatePart', 'a2p_ConvertPart', 'a2p_editImportedPart', 'a2p_SaveAndExit_Command', ] if a2plib.SHOW_CONSTRAINTS_ON_TOOLBAR: constraintCommands = [ 'a2p_ConstraintDialogCommand', 'a2p_EditConstraintCommand', 'a2p_DeleteConnectionsCommand', 'a2p_PointIdentityConstraintCommand', 'a2p_PointOnLineConstraintCommand', 'a2p_PointOnPlaneConstraintCommand', 'a2p_SphericalSurfaceConstraintCommand', 'a2p_CircularEdgeConnection', 'a2p_AxialConstraintCommand', 'a2p_AxisParallelConstraintCommand', 'a2p_AxisPlaneParallelCommand', 'a2p_AxisPlaneNormalCommand', 'a2p_AxisPlaneAngleCommand', 'a2p_PlanesParallelConstraintCommand', 'a2p_PlaneCoincidentConstraintCommand', 'a2p_AngledPlanesConstraintCommand', 'a2p_CenterOfMassConstraintCommand', ] else: constraintCommands = [ 'a2p_ConstraintDialogCommand', 'a2p_EditConstraintCommand', 'a2p_DeleteConnectionsCommand', ] solverCommands = [ 'a2p_SolverCommand', 'a2p_ToggleAutoSolveCommand', 'a2p_FlipConstraintDirectionCommand', 'a2p_Show_Hierarchy_Command' ] viewCommands = [ 'a2p_isolateCommand', 'a2p_ViewConnectionsCommand', 'a2p_Restore_Transparency', 'a2p_ToggleTransparencyCommand', 'a2p_Show_PartLabels_Command', 'a2p_Show_DOF_info_Command', ] miscCommands = [ 'a2p_SimpleAssemblyShapeCommand', 'a2p_repairTreeViewCommand', 'a2p_CreatePartInformationSheet_Command', 'a2p_CreatePartlist', ] self.appendToolbar( 'A2p_Part', partCommands ) self.appendToolbar( 'A2p_Constraint', constraintCommands ) self.appendToolbar( 'A2p_Solver', solverCommands ) self.appendToolbar( 'A2p_View', viewCommands ) self.appendToolbar( 'A2p_Misc', miscCommands ) self.appendMenu( 'A2plus', partCommands ) self.appendMenu( ['A2plus', 'Constraint'], constraintCommands ) self.appendMenu( ['A2plus', 'Solver'], solverCommands ) self.appendMenu( ['A2plus', 'View'], viewCommands ) self.appendMenu( ['A2plus', 'Misc'], miscCommands ) menuEntries = [ 'a2p_absPath_to_relPath_Command', 'a2p_MigrateProxiesCommand' ] self.appendMenu( ['A2plus', 'Misc'], menuEntries ) FreeCADGui.addIconPath(':/icons') FreeCADGui.addPreferencePage( a2plib.pathOfModule() + '/GuiA2p/Resources/ui/a2p_prefs.ui','A2plus' )
def Initialize(self): "This function is executed when FreeCAD starts" import BOPTools # as bop import Design456_Part as designPart import Design456_2Ddrawing as TwoDDraw import Design456_Part_Tools as _tools import Design456_Alignment as _alignment import Design456_SelectionGate as SelGate import DirectModeling.directModelingCommands as dModeling import DefeaturingWB.DefeaturingTools import DefeaturingWB.DefeaturingCMD import DefeaturingWB.FuzzyTools import Design456Init from Design456Pref import Design456Preferences import Design456_Segmented as _segmented # from Part import CommandShapes #Tube not working Gui.runCommand('Std_PerspectiveCamera', 1) self.appendToolbar("Design456_Part", designPart.Design456_Part.list) self.appendToolbar("Design456 2Ddrawing", TwoDDraw.Design456_2Ddrawing.list) self.appendToolbar("Design456_Segmented", _segmented.Design456_Segmented.list) self.appendToolbar("Design456 Tools", _tools.Design456_Part_Tools.list) self.appendToolbar("Design456 Alignment", _alignment.Design456_Alignment_Tools.list) self.appendToolbar("Selection Mode", SelGate.Design456_SelectionGate.list) self.appendToolbar("Direct Modeling", dModeling.Design456_DirectModeling.list) self.appendMenu("Design456_Part", designPart.Design456_Part.list) self.appendMenu("Design456_2Ddrawing", TwoDDraw.Design456_2Ddrawing.list) self.appendMenu("Design456 Tools", _tools.Design456_Part_Tools.list) self.appendMenu("Design456 Alignment", _alignment.Design456_Alignment_Tools.list) # Defeaturing WB added to Design456 self.appendToolbar("Defeaturing Tools", [ "DefeaturingTools", "DF_SelectLoop", "refineFeatureTool", "DefeatShapeFeature" ]) #self.appendMenu("ksu Tools", ["ksuTools","ksuToolsEdit"]) self.appendMenu( "Defeaturing Tools", ["refineFeatureTool", "DefeaturingTools", "DF_SelectLoop"]) self.appendToolbar("Fuzzy Tools", ["FuzzyCut", "FuzzyUnion", "FuzzyCommon"]) self.appendMenu("Fuzzy Tools", ["FuzzyCut", "FuzzyUnion", "FuzzyCommon"]) Gui.addIconPath(Design456Init.ICON_PATH) # Design456_Part # self.appendMenu(QT_TRANSLATE_NOOP("Draft", "&Drafting"), self.drawing_commands) # Design456_Part # DRAFT def QT_TRANSLATE_NOOP(context, text): return text # Run self-tests dependencies_OK = False try: from pivy import coin import FreeCAD import FreeCADGui if FreeCADGui.getSoDBVersion() != coin.SoDB.getVersion(): raise AssertionError("FreeCAD and Pivy use different versions " "of Coin. " "This will lead to unexpected behaviour.") except AssertionError: FreeCAD.Console.PrintWarning("Error: FreeCAD and Pivy " "use different versions of Coin. " "This will lead to unexpected " "behaviour.\n") except ImportError: FreeCAD.Console.PrintWarning("Error: Pivy not found, " "Draft Workbench will be disabled.\n") except Exception: FreeCAD.Console.PrintWarning("Error: Unknown error " "while trying to load Pivy.\n") else: dependencies_OK = True if not dependencies_OK: return # Import Draft tools, icons try: import Draft_rc import DraftTools import DraftGui import DraftFillet import FreeCAD import FreeCADGui FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") except Exception as exc: FreeCAD.Console.PrintError(exc) FreeCAD.Console.PrintError("Error: Initializing one or more " "of the Draft modules failed, " "Draft will not work as expected.\n") try: # Set up command lists import draftutils.init_tools as it self.drawing_commands = it.get_draft_drawing_commands() self.annotation_commands = it.get_draft_annotation_commands() self.modification_commands = it.get_draft_modification_commands() self.utility_commands_menu = it.get_draft_utility_commands_menu() self.utility_commands_toolbar = it.get_draft_utility_commands_toolbar( ) self.context_commands = it.get_draft_context_commands() # Set up toolbars it.init_toolbar(self, QT_TRANSLATE_NOOP("Draft", "Draft creation tools"), self.drawing_commands) it.init_toolbar( self, QT_TRANSLATE_NOOP("Draft", "Draft annotation tools"), self.annotation_commands) it.init_toolbar( self, QT_TRANSLATE_NOOP("Draft", "Draft modification tools"), self.modification_commands) it.init_toolbar(self, QT_TRANSLATE_NOOP("Draft", "Draft utility tools"), self.utility_commands_toolbar) # Set up menus it.init_menu(self, [QT_TRANSLATE_NOOP("Draft", "&Drafting")], self.drawing_commands) it.init_menu(self, [QT_TRANSLATE_NOOP("Draft", "&Annotation")], self.annotation_commands) it.init_menu(self, [QT_TRANSLATE_NOOP("Draft", "&Modification")], self.modification_commands) it.init_menu(self, [QT_TRANSLATE_NOOP("Draft", "&Utilities")], self.utility_commands_menu) # Set up preferences pages if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(FreeCADGui.draftToolBar, "loadedPreferences"): FreeCADGui.addPreferencePage( ":/ui/preferences-draft.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftinterface.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftsnap.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftvisual.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-drafttexts.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.draftToolBar.loadedPreferences = True FreeCAD.Console.PrintLog('Loading Draft workbench, done.\n') # END DRAFT except Exception as exc: App.Console.PrintError(exc) App.Console.PrintError("Error: Initializing one or more " "of the Draft modules failed, " "Design456 will not work as expected.\n")
def Initialize(self): """This function is executed when FreeCAD starts""" ''' disabling numpad shortcuts to use for positioning and quick launch ''' preset = [ ("Std_ViewAxo", "CTRL+0"), ("Std_ViewFront", "CTRL+1"), ("Std_ViewTop", "CTRL+2"), ("Std_ViewRight", "CTRL+3"), ("Std_ViewRear", "CTRL+4"), ("Std_ViewBottom", "CTRL+5"), ("Std_ViewLeft", "CTRL+6"), ("Std_BoxSelection", "b"), ] for (cmd, shortcut) in preset: FreeCAD.ParamGet( "User parameter:BaseApp/Preferences/Shortcut").SetString( cmd, shortcut) def QT_TRANSLATE_NOOP(scope, text): return text try: import os, Draft_rc, DraftTools, DraftGui, Arch, Arch_rc, WFrame from DraftTools import translate FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") except Exception as inst: print(inst) FreeCAD.Console.PrintError( "Error: Initializing one or more of the Draft modules failed, Draft will not work as expected.\n" ) self.wframe = [ "Draft_Layer", "WF_Beam", "WF_Panel", "Arch_CutPlane", "Arch_CutLine", "WF_Copy", "WF_Stretch", "WF_List", "WF_EditAttributes", "WF_SelectByAttributes", "WF_AlignViewWPlane" ] self.wframeExport = ["WF_AddContainer", "WF_AddView", "WF_Export"] self.appendToolbar("Wood Frame", self.wframe) self.appendToolbar("Wood Frame Export", self.wframeExport) self.appendMenu("Wood Frame", self.wframe) # creates a new menu # self.appendMenu(["An existing Menu","My submenu"],self.list) # appends a submenu to an existing menu #add draft toolbar self.drafttools = [ "Draft_Line", "Draft_Wire", "Draft_Circle", "Draft_Arc", "Draft_Arc_3Points", "Draft_Ellipse", "Draft_Polygon", "Draft_Rectangle", "Draft_Text", "Draft_Dimension", "Draft_BSpline", "Draft_Point", "Draft_ShapeString", "Draft_Facebinder", "Draft_BezierTools", "Draft_Label" ] self.draftmodtools = [ "Draft_Move", "Draft_Rotate", "Draft_Offset", "Draft_Trimex", "Draft_Join", "Draft_Split", "Draft_Upgrade", "Draft_Downgrade", "Draft_Scale", "Draft_Edit", "Draft_WireToBSpline", "Draft_AddPoint", "Draft_DelPoint", "Draft_Shape2DView", "Draft_Draft2Sketch", "Draft_Array", "Draft_PathArray", "Draft_PointArray", "Draft_Clone", "Draft_Drawing", "Draft_Mirror", "Draft_Stretch" ] self.draftextratools = [ "Draft_WireToBSpline", "Draft_AddPoint", "Draft_DelPoint", "Draft_ShapeString", "Draft_PathArray", "Draft_Mirror", "Draft_Stretch" ] self.draftcontexttools = [ "Draft_ApplyStyle", "Draft_ToggleDisplayMode", "Draft_AddToGroup", "Draft_AutoGroup", "Draft_SelectGroup", "Draft_SelectPlane", "Draft_ShowSnapBar", "Draft_ToggleGrid", "Draft_UndoLine", "Draft_FinishLine", "Draft_CloseLine" ] self.utils = [ "Draft_Heal", "Draft_FlipDimension", "Draft_ToggleConstructionMode", "Draft_ToggleContinueMode", "Draft_Edit", "Draft_Slope", "Draft_SetWorkingPlaneProxy", "Draft_AddConstruction" ] self.snapList = [ 'Draft_Snap_Lock', 'Draft_Snap_Midpoint', 'Draft_Snap_Perpendicular', 'Draft_Snap_Grid', 'Draft_Snap_Intersection', 'Draft_Snap_Parallel', 'Draft_Snap_Endpoint', 'Draft_Snap_Angle', 'Draft_Snap_Center', 'Draft_Snap_Extension', 'Draft_Snap_Near', 'Draft_Snap_Ortho', 'Draft_Snap_Special', 'Draft_Snap_Dimensions', 'Draft_Snap_WorkingPlane' ] self.appendToolbar( QT_TRANSLATE_NOOP("Workbench", "Draft creation tools"), self.drafttools) self.appendToolbar( QT_TRANSLATE_NOOP("Workbench", "Draft modification tools"), self.draftmodtools) # self.appendToolbar(QT_TRANSLATE_NOOP("Workbench","Draft mod tools"),self.draftextratools) self.appendMenu(QT_TRANSLATE_NOOP("draft", "&Draft"), self.drafttools + self.draftmodtools) self.appendMenu([ QT_TRANSLATE_NOOP("draft", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Utilities") ], self.utils + self.draftcontexttools) self.appendMenu([ QT_TRANSLATE_NOOP("draft", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Snapping") ], self.snapList) if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(FreeCADGui.draftToolBar, "loadedArchPreferences"): FreeCADGui.addPreferencePage(":/ui/preferences-arch.ui", "Arch") FreeCADGui.addPreferencePage( ":/ui/preferences-archdefaults.ui", "Arch") FreeCADGui.draftToolBar.loadedArchPreferences = True if not hasattr(FreeCADGui.draftToolBar, "loadedPreferences"): FreeCADGui.addPreferencePage(":/ui/preferences-draft.ui", "Draft") FreeCADGui.addPreferencePage(":/ui/preferences-draftsnap.ui", "Draft") FreeCADGui.addPreferencePage(":/ui/preferences-draftvisual.ui", "Draft") FreeCADGui.addPreferencePage(":/ui/preferences-drafttexts.ui", "Draft") FreeCADGui.draftToolBar.loadedPreferences = True Log('Loading Draft module...done\n')
import sys import time import os from PySide2 import QtWidgets, QtGui, QtCore import FreeCAD import FreeCADGui DIR = os.path.dirname(__file__) FreeCADGui.addIconPath(os.path.join(DIR, "icons")) class AppImagePreferencePage: def __init__(self): ui_file = os.path.join(DIR, "ui", "preferences.ui") self.form = FreeCADGui.PySideUic.loadUi(ui_file) self.form.check_updates_button.clicked.connect(self.start_updater) self.revision = int(FreeCAD.Version()[2].split(" ")[0]) self.progress_dialog = None # Dialog boxes self.box = QtWidgets.QMessageBox() self.box.setWindowModality(QtCore.Qt.WindowModality.ApplicationModal) # importing the plugin and creating an instance self.loader = QtCore.QPluginLoader() self.loader.setFileName("libQAppImageUpdate") self.loaded = self.loader.load() if self.loaded: self.updater = self.loader.instance() self.updater.quit.connect(self.quit_freecad)
def Initialize(self): """When the workbench is first loaded.""" def QT_TRANSLATE_NOOP(context, text): return text import Draft_rc import DraftTools import DraftGui from draftguitools import gui_circulararray from draftguitools import gui_polararray from draftguitools import gui_orthoarray from draftguitools import gui_arrays import Arch_rc import Arch # Set up command lists self.archtools = ["Arch_Wall", "Arch_StructureTools", "Arch_Rebar", "Arch_CurtainWall","Arch_BuildingPart", "Arch_Project", "Arch_Site", "Arch_Building", "Arch_Floor", "Arch_Reference", "Arch_Window", "Arch_Roof", "Arch_AxisTools", "Arch_SectionPlane", "Arch_Space", "Arch_Stairs", "Arch_PanelTools", "Arch_Equipment", "Arch_Frame", "Arch_Fence", "Arch_Truss", "Arch_Profile","Arch_MaterialTools", "Arch_Schedule", "Arch_PipeTools", "Arch_CutPlane", "Arch_CutLine", "Arch_Add", "Arch_Remove", "Arch_Survey"] self.utilities = ["Arch_Component", "Arch_CloneComponent", "Arch_SplitMesh", "Arch_MeshToShape", "Arch_SelectNonSolidMeshes", "Arch_RemoveShape", "Arch_CloseHoles", "Arch_MergeWalls", "Arch_Check", "Arch_ToggleIfcBrepFlag", "Arch_3Views", "Arch_IfcSpreadsheet", "Arch_ToggleSubs"] # Add the rebar tools from the Reinforcement addon, if available try: import RebarTools except Exception: pass else: class RebarGroupCommand: def GetCommands(self): return tuple(RebarTools.RebarCommands + ["Arch_Rebar"]) def GetResources(self): _tooltip = ("Create various types of rebars, " "including U-shaped, L-shaped, and stirrup") return {'MenuText': QT_TRANSLATE_NOOP("Arch", 'Rebar tools'), 'ToolTip': QT_TRANSLATE_NOOP("Arch", _tooltip)} def IsActive(self): return not FreeCAD.ActiveDocument is None FreeCADGui.addCommand('Arch_RebarTools', RebarGroupCommand()) self.archtools[2] = "Arch_RebarTools" # Set up Draft command lists import draftutils.init_tools as it self.draft_drawing_commands = it.get_draft_drawing_commands() self.draft_annotation_commands = it.get_draft_annotation_commands() self.draft_modification_commands = it.get_draft_modification_commands() self.draft_context_commands = it.get_draft_context_commands() self.draft_line_commands = it.get_draft_line_commands() self.draft_utility_commands = it.get_draft_utility_commands() # Set up toolbars self.appendToolbar(QT_TRANSLATE_NOOP("Workbench", "Arch tools"), self.archtools) self.appendToolbar(QT_TRANSLATE_NOOP("Draft", "Draft creation tools"), self.draft_drawing_commands) self.appendToolbar(QT_TRANSLATE_NOOP("Draft", "Draft annotation tools"), self.draft_annotation_commands) self.appendToolbar(QT_TRANSLATE_NOOP("Draft", "Draft modification tools"), self.draft_modification_commands) # Set up menus self.appendMenu([QT_TRANSLATE_NOOP("arch", "&Arch"), QT_TRANSLATE_NOOP("arch", "Utilities")], self.utilities) self.appendMenu(QT_TRANSLATE_NOOP("arch", "&Arch"), self.archtools) self.appendMenu([QT_TRANSLATE_NOOP("arch", "&Draft"), QT_TRANSLATE_NOOP("arch", "Creation")], self.draft_drawing_commands) self.appendMenu([QT_TRANSLATE_NOOP("arch", "&Draft"), QT_TRANSLATE_NOOP("arch", "Annotation")], self.draft_annotation_commands) self.appendMenu([QT_TRANSLATE_NOOP("arch", "&Draft"), QT_TRANSLATE_NOOP("arch", "Modification")], self.draft_modification_commands) self.appendMenu([QT_TRANSLATE_NOOP("arch", "&Draft"), QT_TRANSLATE_NOOP("arch", "Utilities")], self.draft_utility_commands + self.draft_context_commands) FreeCADGui.addIconPath(":/icons") FreeCADGui.addLanguagePath(":/translations") # Set up preferences pages if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(FreeCADGui.draftToolBar, "loadedArchPreferences"): FreeCADGui.addPreferencePage(":/ui/preferences-arch.ui", QT_TRANSLATE_NOOP("Arch", "Arch")) FreeCADGui.addPreferencePage(":/ui/preferences-archdefaults.ui", QT_TRANSLATE_NOOP("Arch", "Arch")) FreeCADGui.draftToolBar.loadedArchPreferences = True if not hasattr(FreeCADGui.draftToolBar, "loadedPreferences"): FreeCADGui.addPreferencePage(":/ui/preferences-draft.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage(":/ui/preferences-draftsnap.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage(":/ui/preferences-draftvisual.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage(":/ui/preferences-drafttexts.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.draftToolBar.loadedPreferences = True FreeCAD.Console.PrintLog('Loading Arch workbench, done.\n')
def Initialize(self): """ Run at start of FreeCAD. """ import WF try: import WF_general import WF_centerLinePoint import WF_extremaLinePoint import WF_alongLinePoint import WF_nPointsPoint # import WF_centerCirclePoint import WF_centerFacePoint import WF_projectedPoint # import WF_pointFacePoint # import WF_lineFacePoint import WF_twoPointsLine import WF_nPointsLine import WF_threePointsPlane import WF_linePointPlane # import WF_perpendicularLinePointPlane except ImportError: m_error = "Error: One of WF_ module not found," m_error += "WorkFeature workbench will be disabled.\n" App.Console.PrintWarning(m_error) m_error = "Error: Unknown error while trying" m_error += "to load one of WF_ module !\n" App.Console.PrintWarning(m_error) # Set menu and commands for Points self.General_menu = ["Work Feature", "General"] self.General_commands_list = [ "ShowHideDynamic", "ShowHideInteractive", "ShowHideNo", "Refresh", ] self.appendCommandbar("General", self.General_commands_list) self.appendMenu(self.General_menu, self.General_commands_list) self.appendToolbar("WF General", self.General_commands_list) # Set menu and commands for Points self.Point_menu = ["Work Feature", "Points"] self.Point_commands_list = [ "CenterLinePoint", # done but to test "ExtremaLinePoint", # done but to test "AlongLinePoint", # done but to test "NPointsPoint", # done but to test # "CenterCirclePoint", "CenterFacePoint", # "PointFacePoint", # "LineFacePoint", "ProjectedPoint" ] self.appendCommandbar("Points", self.Point_commands_list) self.appendMenu(self.Point_menu, self.Point_commands_list) self.appendToolbar("WF Points", self.Point_commands_list) # Set menu and commands for Lines self.m_Line_menu = ["Work Feature", "Lines"] self.m_Line_commands_list = [ "TwoPointsLine", # done but to test "NPointsLine", # done but to test ] self.appendCommandbar("Lines", self.m_Line_commands_list) self.appendMenu(self.m_Line_menu, self.m_Line_commands_list) self.appendToolbar("WF Lines", self.m_Line_commands_list) # Set menu and commands for Planes self.m_Plane_menu = ["Work Feature", "Planes"] self.m_Plane_commands_list = [ "ThreePointsPlane", # done but to test "LinePointPlane", # done but to test # "PerpendicularLinePointPlane", ] self.appendCommandbar("Planes", self.m_Plane_commands_list) self.appendMenu(self.m_Plane_menu, self.m_Plane_commands_list) self.appendToolbar("WF Planes", self.m_Plane_commands_list) # m_submenu = ['WorkFeature.pdf'] # self.appendMenu(["Work Feature", "Help"], m_submenu) Gui.addIconPath(PATH_WF_ICONS) Gui.addResourcePath(PATH_WF_ICONS) Gui.addPreferencePage(PATH_WF_UI + "/WorkFeature_prefs.ui", "Work Feature") WF.set_release(WF_Release) Log('Loading WorkFeature workbench...done\n') if M_DEBUG: print("DEBUG : WF_Release is " + str(WF_Release))
import FreeCADGui as Gui import FreeCAD Gui.addIconPath(FreeCAD.getHomePath() + "Mod/glider/icons") from profiles import LoadProfile from glider import CreateGlider Gui.addCommand("LoadProfile", LoadProfile()) Gui.addCommand("CreateGlider", CreateGlider())
def Initialize(self): from a2p_translateUtils import QT_TRANSLATE_NOOP from a2p_translateUtils import translate from a2p_translateUtils import tr_ import sys PyVersion = sys.version_info[0] if PyVersion == 2: import a2p_Resources2 else: import a2p_Resources3 import a2plib # add translations path FreeCADGui.addLanguagePath(a2plib.getLanguagePath()) FreeCADGui.updateLocale() print("languagePath of A2plus Workbench is: {}".format( a2plib.getLanguagePath())) import a2p_importpart import a2p_recursiveUpdatePlanner import a2p_convertPart import a2p_solversystem import a2p_MuxAssembly import a2p_partinformation import a2p_constraintDialog import a2p_constraintcommands import a2p_bom # bom == bill of materials == partslist import a2p_constraintServices import a2p_searchConstraintConflicts import CD_A2plusupdater # for Constraint Diagnostic function if a2plib.getRecursiveUpdateEnabled(): partCommands = [ 'a2p_ImportPart', 'a2p_ImportShapeReferenceCommand', 'a2p_updateImportedParts', 'a2p_recursiveUpdateImportedPartsCommand', 'a2p_movePart', 'a2p_MovePartUnderConstraints', 'a2p_duplicatePart', 'a2p_ConvertPart', 'a2p_editImportedPart', 'a2p_SaveAndExit_Command', ] else: partCommands = [ 'a2p_ImportPart', 'a2p_ImportShapeReferenceCommand', 'a2p_updateImportedParts', 'a2p_movePart', 'a2p_MovePartUnderConstraints', 'a2p_duplicatePart', 'a2p_ConvertPart', 'a2p_editImportedPart', 'a2p_SaveAndExit_Command', ] if a2plib.SHOW_CONSTRAINTS_ON_TOOLBAR: constraintCommands = [ 'a2p_ConstraintDialogCommand', 'a2p_EditConstraintCommand', 'a2p_reAdjustConstraintDirectionsCommand', 'a2p_DeleteConnectionsCommand', 'a2p_PointIdentityConstraintCommand', 'a2p_PointOnLineConstraintCommand', 'a2p_PointOnPlaneConstraintCommand', 'a2p_SphericalSurfaceConstraintCommand', 'a2p_CircularEdgeConnection', 'a2p_AxialConstraintCommand', 'a2p_AxisParallelConstraintCommand', 'a2p_AxisPlaneParallelCommand', 'a2p_AxisPlaneNormalCommand', 'a2p_AxisPlaneAngleCommand', 'a2p_PlanesParallelConstraintCommand', 'a2p_PlaneCoincidentConstraintCommand', 'a2p_AngledPlanesConstraintCommand', 'a2p_CenterOfMassConstraintCommand', ] else: constraintCommands = [ 'a2p_ConstraintDialogCommand', 'a2p_EditConstraintCommand', 'a2p_reAdjustConstraintDirectionsCommand', 'a2p_DeleteConnectionsCommand', ] if a2plib.GRAPHICALDEBUG: solverCommands = [ 'a2p_SolverCommand', 'a2p_ToggleAutoSolveCommand', 'a2p_FlipConstraintDirectionCommand', 'a2p_Show_Hierarchy_Command', 'a2p_SearchConstraintConflictsCommand', 'a2p_cleanUpDebug3dCommand' ] else: solverCommands = [ 'a2p_SolverCommand', 'a2p_ToggleAutoSolveCommand', 'a2p_FlipConstraintDirectionCommand', 'a2p_Show_Hierarchy_Command', 'a2p_SearchConstraintConflictsCommand' ] viewCommands = [ 'a2p_isolateCommand', 'a2p_ViewConnectionsCommand', 'a2p_Restore_Transparency', 'a2p_ToggleTransparencyCommand', 'a2p_Show_PartLabels_Command', 'a2p_Show_DOF_info_Command', ] miscCommands = [ 'a2p_SimpleAssemblyShapeCommand', 'a2p_repairTreeViewCommand', 'a2p_CreatePartInformationSheet_Command', 'a2p_CreatePartlist', ] self.appendToolbar('A2p_Part', partCommands) self.appendToolbar('A2p_Constraint', constraintCommands) self.appendToolbar('A2p_Solver', solverCommands) self.appendToolbar('A2p_View', viewCommands) self.appendToolbar('A2p_Misc', miscCommands) self.appendMenu('A2plus', partCommands) self.appendMenu( ['A2plus', translate("A2plus_appendMenu", 'Constraint')], constraintCommands) self.appendMenu( ['A2plus', translate("A2plus_appendMenu", 'Solver')], solverCommands) self.appendMenu( ['A2plus', translate("A2plus_appendMenu", 'View')], viewCommands) self.appendMenu( ['A2plus', translate("A2plus_appendMenu", 'Misc')], miscCommands) menuEntries = [ 'a2p_absPath_to_relPath_Command', 'a2p_MigrateProxiesCommand' ] self.appendMenu(['A2plus', 'Misc'], menuEntries) FreeCADGui.addIconPath(':/icons') FreeCADGui.addPreferencePage( a2plib.pathOfModule() + '/GuiA2p/Resources/ui/a2p_prefs.ui', 'A2plus') DiagnosticCommands = [ 'rnp_Constraint_Viewer', 'rnp_Update_A2pParts', ] self.appendToolbar('A2Diagnostics', DiagnosticCommands)
#* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * #* USA * #* * #*************************************************************************** import PySide from PySide import QtCore, QtGui import FreeCAD import FreeCADGui import os import Ship_rc FreeCADGui.addLanguagePath(":/Ship/translations") FreeCADGui.addIconPath(":/Ship/icons") class LoadExample: def Activated(self): import shipLoadExample shipLoadExample.load() def GetResources(self): MenuText = QtCore.QT_TRANSLATE_NOOP( 'Ship_LoadExample', 'Load an example ship geometry') ToolTip = QtCore.QT_TRANSLATE_NOOP( 'Ship_LoadExample', 'Load an example ship hull geometry.') return {'Pixmap': 'Ship_Load',
def Initialize(self): # run self-tests depsOK = False try: from pivy import coin if FreeCADGui.getSoDBVersion() != coin.SoDB.getVersion(): raise AssertionError( "FreeCAD and Pivy use different versions of Coin. This will lead to unexpected behaviour." ) except AssertionError: FreeCAD.Console.PrintWarning( "Error: FreeCAD and Pivy use different versions of Coin. This will lead to unexpected behaviour.\n" ) except ImportError: FreeCAD.Console.PrintWarning( "Error: Pivy not found, DDA workbench will be disabled.\n") except: FreeCAD.Console.PrintWarning( "Error: Unknown error while trying to load Pivy\n") else: try: import PyQt4 except ImportError: FreeCAD.Console.PrintWarning( "Error: PyQt4 not found, DDA workbench will be disabled.\n" ) else: depsOK = True # import FreeCAD , FreeCADGui import DDA_rc import FreeCADGui FreeCADGui.addLanguagePath(":/translations") FreeCADGui.addIconPath(":/icons") # try: import DDAShapes # except: # FreeCAD.Console.PrintWarning("'DDAShapes' moudle import failed.") import DGPlayer, DFCalculation, DDAPanel # try: import drawGui # except: # FreeCAD.Console.PrintWarning("'drawGui' moudle import failed.") import DDAToolbars import interfaceTools import storeScene import loadDataTools import DDAStdCommands import AnalysisDDAResult # FreeCADGui.addPreferencePage(":/DDA-preferences.ui","DDA") # FreeCADGui.addPreferencePage(":/userprefs-base.ui","DDA") # FreeCAD.Console.PrintMessage('Loading DDA GUI...\n') import DDAGui list = [ 'DDA_NewDoc', 'DDA_Undo', 'DDA_Redo', 'Std_ViewFitAll', 'DDA_ChooseProjectPath', 'DDA_DL', 'DDA_DC', 'DFCalculation', 'PlayDF', 'DDA_DGAnalysiser', 'DDA_Examples' ] # list = ['DDA_NewDoc' , 'DDA_Undo' , 'DDA_Redo', 'DDA_ChooseProjectPath' , 'DDA_SetPanelSize' , 'DDA_DL' , 'DDA_DC','DFCalculation','PlayDF'] self.appendToolbar('DDACmds', list)
import FreeCADGui as Gui import FreeCAD Gui.addIconPath(FreeCAD.getHomePath() + "Mod/glider/icons") from shape import ChangeShape from examples import LoadGlider from profiles import LoadProfile, ChangeProfile, RunXfoil, CompareProfile, MergeProfile Gui.addCommand('LoadGlider', LoadGlider()) Gui.addCommand('ChangeShape', ChangeShape()) Gui.addCommand('LoadProfile', LoadProfile()) Gui.addCommand('ChangeProfile', ChangeProfile()) Gui.addCommand('RunXfoil', RunXfoil()) Gui.addCommand('CompareProfile', CompareProfile()) Gui.addCommand('MergeProfile', MergeProfile())
def SoGroup_getByName(self, name): for child in self: if name == child.getName(): return child return None coin.SoGroup.__iadd__ = SoGroup__iadd__ coin.SoGroup.__isub__ = SoGroup__isub__ coin.SoGroup.getByName = SoGroup_getByName ######################################################################################## Dir = os.path.abspath(os.path.dirname(__file__)) Gui.addIconPath(os.path.join(Dir, 'icons')) class gliderWorkbench(Gui.Workbench): MenuText = 'glider' ToolTip = 'glider workbench' Icon = os.path.join(Dir, 'icons', 'glider_workbench.svg') toolBox = [ 'CreateGlider', 'ImportGlider', 'ShapeCommand', 'ArcCommand', 'AoaCommand', 'ZrotCommand', 'AirfoilCommand', 'AirfoilMergeCommand', 'BallooningCommand', 'BallooningMergeCommand', 'CellCommand', 'LineCommand', 'LineObserveCommand', 'CutCommand', 'ColorCommand', 'Gl2dExport' ] featureBox = [
def Initialize(self): """When the workbench is first loaded.""" def QT_TRANSLATE_NOOP(context, text): return text import Draft_rc import DraftTools import DraftGui import Arch_rc import Arch from ArchStructure import _ArchStructureGroupCommand from ArchAxis import _ArchAxisGroupCommand from ArchPanel import CommandPanelGroup from ArchMaterial import _ArchMaterialToolsCommand from ArchPipe import _ArchPipeGroupCommand stru_group = _ArchStructureGroupCommand axis_group = _ArchAxisGroupCommand pan_group = CommandPanelGroup mat_group = _ArchMaterialToolsCommand pipe_group = _ArchPipeGroupCommand # Set up command lists self.archtools = [ "Arch_Wall", ([QT_TRANSLATE_NOOP("Workbench", "Structure tools")], list(stru_group.GetCommands(stru_group))), # tuple len=2: submenu ("Arch_StructureTools", ), # tuple len=1: toolbar flyout "Arch_Rebar_Submenu", # will be replaced or removed "Arch_Rebar", # may be replaced "Arch_CurtainWall", "Arch_BuildingPart", "Arch_Project", "Arch_Site", "Arch_Building", "Arch_Floor", "Arch_Reference", "Arch_Window", "Arch_Roof", ([QT_TRANSLATE_NOOP("Workbench", "Axis tools")], list(axis_group.GetCommands(axis_group))), ("Arch_AxisTools", ), "Arch_SectionPlane", "Arch_Space", "Arch_Stairs", ([QT_TRANSLATE_NOOP("Workbench", "Panel tools")], list(pan_group.GetCommands(pan_group))), ("Arch_PanelTools", ), "Arch_Equipment", "Arch_Frame", "Arch_Fence", "Arch_Truss", "Arch_Profile", ([QT_TRANSLATE_NOOP("Workbench", "Material tools")], list(mat_group.GetCommands(mat_group))), ("Arch_MaterialTools", ), "Arch_Schedule", ([QT_TRANSLATE_NOOP("Workbench", "Pipe tools")], list(pipe_group.GetCommands(pipe_group))), ("Arch_PipeTools", ), "Arch_CutPlane", "Arch_CutLine", "Arch_Add", "Arch_Remove", "Arch_Survey" ] self.utilities = [ "Arch_Component", "Arch_CloneComponent", "Arch_SplitMesh", "Arch_MeshToShape", "Arch_SelectNonSolidMeshes", "Arch_RemoveShape", "Arch_CloseHoles", "Arch_MergeWalls", "Arch_Check", "Arch_ToggleIfcBrepFlag", "Arch_3Views", "Arch_IfcSpreadsheet", "Arch_ToggleSubs" ] # Add the rebar tools from the Reinforcement addon, if available try: import RebarTools except Exception: del self.archtools[3] # remove "Arch_Rebar_Submenu" else: class RebarGroupCommand: def GetCommands(self): return tuple(RebarTools.RebarCommands + ["Arch_Rebar"]) def GetResources(self): return { 'MenuText': QT_TRANSLATE_NOOP("Arch_RebarTools", "Rebar tools"), 'ToolTip': QT_TRANSLATE_NOOP( "Arch_RebarTools", "Create various types of rebars, " "including U-shaped, L-shaped, and stirrup") } def IsActive(self): return not FreeCAD.ActiveDocument is None FreeCADGui.addCommand('Arch_RebarTools', RebarGroupCommand()) self.archtools[3] = ([ QT_TRANSLATE_NOOP("Workbench", "Rebar tools") ], RebarTools.RebarCommands + ["Arch_Rebar"]) self.archtools[4] = ("Arch_RebarTools", ) # Set up Draft command lists import draftutils.init_tools as it self.draft_drawing_commands = it.get_draft_drawing_commands() self.draft_annotation_commands = it.get_draft_annotation_commands() self.draft_modification_commands = it.get_draft_modification_commands() self.draft_utility_commands = it.get_draft_utility_commands_menu() self.draft_context_commands = it.get_draft_context_commands() # Set up toolbars it.init_toolbar(self, QT_TRANSLATE_NOOP("Workbench", "Arch tools"), self.archtools) it.init_toolbar(self, QT_TRANSLATE_NOOP("Workbench", "Draft creation tools"), self.draft_drawing_commands) it.init_toolbar( self, QT_TRANSLATE_NOOP("Workbench", "Draft annotation tools"), self.draft_annotation_commands) it.init_toolbar( self, QT_TRANSLATE_NOOP("Workbench", "Draft modification tools"), self.draft_modification_commands) # Set up menus it.init_menu(self, [ QT_TRANSLATE_NOOP("Workbench", "&Arch"), QT_TRANSLATE_NOOP("Workbench", "Utilities") ], self.utilities) it.init_menu(self, [QT_TRANSLATE_NOOP("Workbench", "&Arch")], self.archtools) it.init_menu(self, [ QT_TRANSLATE_NOOP("Workbench", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Creation") ], self.draft_drawing_commands) it.init_menu(self, [ QT_TRANSLATE_NOOP("Workbench", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Annotation") ], self.draft_annotation_commands) it.init_menu(self, [ QT_TRANSLATE_NOOP("Workbench", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Modification") ], self.draft_modification_commands) it.init_menu(self, [ QT_TRANSLATE_NOOP("Workbench", "&Draft"), QT_TRANSLATE_NOOP("Workbench", "Utilities") ], self.draft_utility_commands) FreeCADGui.addIconPath(":/icons") FreeCADGui.addLanguagePath(":/translations") # Set up preferences pages if hasattr(FreeCADGui, "draftToolBar"): if not hasattr(FreeCADGui.draftToolBar, "loadedArchPreferences"): FreeCADGui.addPreferencePage(":/ui/preferences-arch.ui", QT_TRANSLATE_NOOP("Arch", "Arch")) FreeCADGui.addPreferencePage( ":/ui/preferences-archdefaults.ui", QT_TRANSLATE_NOOP("Arch", "Arch")) FreeCADGui.draftToolBar.loadedArchPreferences = True if not hasattr(FreeCADGui.draftToolBar, "loadedPreferences"): FreeCADGui.addPreferencePage( ":/ui/preferences-draft.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftsnap.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-draftvisual.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.addPreferencePage( ":/ui/preferences-drafttexts.ui", QT_TRANSLATE_NOOP("Draft", "Draft")) FreeCADGui.draftToolBar.loadedPreferences = True FreeCAD.Console.PrintLog('Loading Arch workbench, done.\n')
#* 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 * #* * #*************************************************************************** from PyQt4 import QtCore, QtGui import FreeCAD, FreeCADGui, os # Load resources import Plot_rc FreeCADGui.addLanguagePath(":/Plot/translations") FreeCADGui.addIconPath(":/Plot/icons") """ # Setup tranlations from plotUtils import Paths path = Paths.translationsPath() FreeCADGui.addLanguagePath(path) import os import FreeCAD translator = QtCore.QTranslator() dirList=os.listdir(path) for fname in dirList: valid = translator.load(os.path.join(path, fname)) if valid: QtGui.QApplication.installTranslator(translator) """