715 lines
23 KiB
Python
715 lines
23 KiB
Python
# -*- coding: utf-8 -*-
|
|
# ***************************************************************************
|
|
# * *
|
|
# * Copyright (c) 2017 - Amritpal Singh <amrit3701@gmail.com> *
|
|
# * *
|
|
# * 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 *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
__title__ = "RebarCommands"
|
|
__author__ = "Amritpal Singh"
|
|
__url__ = "https://www.freecadweb.org"
|
|
|
|
import FreeCADGui, FreeCAD
|
|
from PySide import QtCore
|
|
from PySide.QtCore import QT_TRANSLATE_NOOP
|
|
from PVPlantResources import DirIcons as DirIcons
|
|
import os
|
|
|
|
|
|
class CommandPVPlantSite:
|
|
"the PVPlant Site command definition"
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "icon.svg")),
|
|
'MenuText': QT_TRANSLATE_NOOP("Arch_Site", "Site"),
|
|
'Accel': "S, I",
|
|
'ToolTip': QT_TRANSLATE_NOOP("Arch_Site", "Creates a site object including selected objects.")}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return ((not (FreeCAD.ActiveDocument is None)) and
|
|
(FreeCAD.ActiveDocument.getObject("Site") is None))
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantSite
|
|
PVPlantSite.makePVPlantSite()
|
|
return
|
|
|
|
|
|
'''class CommandPVPlantGeoreferencing:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "Location.svg")),
|
|
'Accel': "G, R",
|
|
'MenuText': QT_TRANSLATE_NOOP("Georeferencing","Georeferencing"),
|
|
'ToolTip': QT_TRANSLATE_NOOP("Georeferencing","Referenciar el lugar")}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantGeoreferencing
|
|
taskd = PVPlantGeoreferencing.MapWindow()
|
|
#taskd.setParent(FreeCADGui.getMainWindow())
|
|
#taskd.setWindowFlags(QtCore.Qt.Window)
|
|
taskd.show()#exec_()'''
|
|
|
|
|
|
class CommandProjectSetup:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "flash.svg")),
|
|
'Accel': "P, S",
|
|
'MenuText': "Project Setup",
|
|
'ToolTip': "Setup all the variable for this project"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project import ProjectSetup
|
|
taskd = ProjectSetup.ProjectSetupDialog()
|
|
taskd.setParent(FreeCADGui.getMainWindow())
|
|
taskd.setWindowFlags(QtCore.Qt.Window)
|
|
taskd.show()
|
|
|
|
|
|
class CommandTerrain:
|
|
"the PVPlant Terrain command definition"
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "terrain.svg")),
|
|
'MenuText': "Terrain",
|
|
'Accel': "S, T",
|
|
'ToolTip': "Creates a Terrain object from setup dialog."}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return (not (FreeCAD.ActiveDocument is None) and
|
|
not (FreeCAD.ActiveDocument.getObject("Site") is None) and
|
|
(FreeCAD.ActiveDocument.getObject("Terrain") is None))
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantTerrain
|
|
PVPlantTerrain.makeTerrain()
|
|
# task = _TerrainTaskPanel()
|
|
# FreeCADGui.Control.showDialog(task)
|
|
return
|
|
|
|
|
|
class CommandCreateTerrainMesh:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "surface.svg")),
|
|
'MenuText': QT_TRANSLATE_NOOP("PVPlant", "Create Surface"),
|
|
'Accel': "C, S",
|
|
'ToolTip': QT_TRANSLATE_NOOP("PVPlant", "Creates a surface form a cloud of points.")}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantCreateTerrainMesh
|
|
TaskPanel = PVPlantCreateTerrainMesh.TaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandDivideArea:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "area.svg")),
|
|
'Accel': "A, D",
|
|
'MenuText': "Divide Area",
|
|
'ToolTip': "Allowed Area"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
sel = FreeCADGui.Selection.getSelection()[0]
|
|
|
|
|
|
class CommandBoundary:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "area.svg")),
|
|
'Accel': "A, B",
|
|
'MenuText': "Area",
|
|
'ToolTip': "Allowed Area"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantArea
|
|
sel = FreeCADGui.Selection.getSelection()[0]
|
|
obj = PVPlantArea.makeArea([ver.Point for ver in sel.Shape.Vertexes])
|
|
# taskd = _PVPlantPlacementTaskPanel()
|
|
# FreeCADGui.Control.showDialog(taskd)
|
|
|
|
|
|
class CommandFrameArea:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "FrameArea.svg")),
|
|
'Accel': "A, F",
|
|
'MenuText': "Frame Area",
|
|
'ToolTip': "Frame Area"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
makeFramedArea(None, sel)
|
|
|
|
|
|
class CommandProhibitedArea:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "area_forbidden.svg")),
|
|
'Accel': "A, F",
|
|
'MenuText': "Prohibited Area",
|
|
'ToolTip': "Prohibited Area"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantArea
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
PVPlantArea.makeProhibitedArea(sel[0])
|
|
|
|
|
|
class CommandPVSubplant:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "subplant.svg")),
|
|
'Accel': "A, P",
|
|
'MenuText': "PV Subplant",
|
|
'ToolTip': "PV Subplant"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantArea
|
|
area = PVPlantArea.makePVSubplant()
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
for obj in sel:
|
|
if obj.Name[:7] == "Tracker":
|
|
frame_list = area.Frames
|
|
frame_list.append(obj)
|
|
area.Frames = frame_list
|
|
|
|
|
|
class CommandOffsetArea:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "offset.svg")),
|
|
'Accel': "A, O",
|
|
'MenuText': "OffsetArea",
|
|
'ToolTip': "OffsetArea"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
if FreeCAD.ActiveDocument:
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantArea
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
base = None
|
|
if sel:
|
|
base = sel[0]
|
|
obj = PVPlantArea.makeOffsetArea(base)
|
|
|
|
|
|
class CommandSplitArea:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "split_area.svg")),
|
|
'Accel': "A, S",
|
|
'MenuText': "Split Area",
|
|
'ToolTip': "Split Area"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return (not FreeCAD.ActiveDocument is None and
|
|
not FreeCAD.ActiveDocument.findObjects(Name="ProhibitedArea") is None and
|
|
not FreeCAD.ActiveDocument.findObjects(Name="OffsetArea") is None)
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantAreaUtils
|
|
TaskPanel = PVPlantAreaUtils.splitAreaTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
return
|
|
|
|
|
|
class CommandJoinAreas:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "split_area.svg")),
|
|
'Accel': "A, J",
|
|
'MenuText': "Join Areas",
|
|
'ToolTip': "Join Areas"}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return (not FreeCAD.ActiveDocument is None and
|
|
not FreeCAD.ActiveDocument.findObjects(Name="ProhibitedArea") is None and
|
|
not FreeCAD.ActiveDocument.findObjects(Name="OffsetArea") is None)
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
from Project.Area import PVPlantAreaUtils
|
|
TaskPanel = PVPlantAreaUtils.splitAreaTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
return
|
|
|
|
|
|
class CommandContours:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "TerrainContours.svg")),
|
|
'Accel': "T, C",
|
|
'MenuText': 'Curvas de nivel',
|
|
'ToolTip': 'Curvas de nivel'
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
# return not FreeCAD.ActiveDocument is None
|
|
if FreeCAD.ActiveDocument is None:
|
|
return False
|
|
return True
|
|
if FreeCADGui.Selection.getSelection() is not None:
|
|
selection = FreeCADGui.Selection.getSelection()[-1]
|
|
if selection.TypeId == 'Mesh::Feature':
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantTerrainAnalisys
|
|
TaskPanel = PVPlantTerrainAnalisys.ContourTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandSlopeAnalisys:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "TerrainSlope.svg")),
|
|
'Accel': "T, S",
|
|
'MenuText': 'Analisis de Pendiente',
|
|
'ToolTip': 'Analisis de Pendiente'
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantTerrainAnalisys
|
|
TaskPanel = PVPlantTerrainAnalisys.SlopeTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandHeightAnalisys:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "TerrainHeight.svg")),
|
|
'Accel': "T, H",
|
|
'MenuText': 'Analisis de Altura',
|
|
'ToolTip': 'Analisis de Altura'
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantTerrainAnalisys
|
|
TaskPanel = PVPlantTerrainAnalisys.HeightTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandOrientationAnalisys:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "TerrainOrientation.svg")),
|
|
'Accel': "T, H",
|
|
'MenuText': 'Analisis de Orientación',
|
|
'ToolTip': 'Analisis de Orientación'}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantTerrainAnalisys
|
|
TaskPanel = PVPlantTerrainAnalisys.OrientationTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandTrench: # V1:
|
|
"""Gui command for the Line tool."""
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
"""Set icon, menu and tooltip."""
|
|
return {'Pixmap': str(os.path.join(DirIcons, "trench.svg")),
|
|
'MenuText': "Trench",
|
|
'Accel': "C, T",
|
|
'ToolTip': "Creates a Trench object from setup dialog."}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
active = not (FreeCAD.ActiveDocument is None)
|
|
terrain = not (FreeCAD.ActiveDocument.getObject("Terrain") is None)
|
|
active = active and terrain
|
|
if terrain:
|
|
active = active and not (FreeCAD.ActiveDocument.getObject("Terrain").Mesh is None)
|
|
return active
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
"""Execute when the command is called."""
|
|
from Civil import PVPlantTrench
|
|
sel = FreeCADGui.Selection.getSelection()
|
|
done = False
|
|
|
|
if len(sel) > 0:
|
|
import Draft
|
|
for obj in sel:
|
|
if Draft.getType(obj) == "Wire":
|
|
FreeCAD.ActiveDocument.openTransaction("Create Trench")
|
|
PVPlantTrench.makeTrench(obj)
|
|
FreeCAD.ActiveDocument.commitTransaction()
|
|
FreeCAD.ActiveDocument.recompute()
|
|
done = True
|
|
break
|
|
|
|
if not done:
|
|
taskd = PVPlantTrench.TrenchTaskPanel()
|
|
if taskd:
|
|
FreeCADGui.Control.showDialog(taskd)
|
|
else:
|
|
print(" No ha sido posible crear el formulario")
|
|
|
|
|
|
class CommandSemiAutomaticTrench: # V1:
|
|
"""Gui command for the Line tool."""
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
"""Set icon, menu and tooltip."""
|
|
return {'Pixmap': str(os.path.join(DirIcons, "trench.svg")),
|
|
'MenuText': "Semi-Automatic Trench Generator",
|
|
'Accel': "T, S",
|
|
'ToolTip': "Creates a Trench object from setup dialog."}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
active = not (FreeCAD.ActiveDocument is None)
|
|
terrain = not (FreeCAD.ActiveDocument.getObject("Terrain") is None)
|
|
active = active and terrain
|
|
if terrain:
|
|
active = active and not (FreeCAD.ActiveDocument.getObject("Terrain").Mesh is None)
|
|
return active
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
"""Execute when the command is called."""
|
|
from Civil import PVPlantTrench
|
|
semi = PVPlantTrench.semiAutomaticTrench()
|
|
|
|
|
|
class CommandCalculateEarthworks:
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "pico.svg")),
|
|
'Accel': "C, E",
|
|
'MenuText': QT_TRANSLATE_NOOP("Placement", "Movimiento de tierras"),
|
|
'ToolTip': QT_TRANSLATE_NOOP("Placement", "Calcular el movimiento de tierras")}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
active = not (FreeCAD.ActiveDocument is None)
|
|
if not (FreeCAD.ActiveDocument.getObject("Terrain") is None):
|
|
active = active and not (FreeCAD.ActiveDocument.getObject("Terrain").Mesh is None)
|
|
return active
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantEarthWorks
|
|
TaskPanel = PVPlantEarthWorks.EarthWorksTaskPanel()
|
|
FreeCADGui.Control.showDialog(TaskPanel)
|
|
|
|
|
|
class CommandManhole:
|
|
"the PVPlant Manhole command definition"
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'Pixmap': str(os.path.join(DirIcons, "manhole.svg")),
|
|
'MenuText': "Manhole",
|
|
'Accel': "C, M",
|
|
'ToolTip': "Creates a Manhole object from setup dialog."}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not (FreeCAD.ActiveDocument is None)
|
|
if FreeCAD.ActiveDocument is not None:
|
|
if FreeCADGui.Selection.getCompleteSelection():
|
|
for ob in FreeCAD.ActiveDocument.Objects:
|
|
if ob.Name[:4] == "Site":
|
|
return True
|
|
|
|
@staticmethod
|
|
def Activated():
|
|
import PVPlantManhole
|
|
task_panel = PVPlantManhole._ManholeTaskPanel()
|
|
FreeCADGui.Control.showDialog(task_panel)
|
|
return
|
|
|
|
|
|
if FreeCAD.GuiUp:
|
|
FreeCADGui.addCommand('PVPlantSite', CommandPVPlantSite())
|
|
import PVPlantGeoreferencing
|
|
|
|
FreeCADGui.addCommand('PVPlantGeoreferencing', PVPlantGeoreferencing.CommandPVPlantGeoreferencing())
|
|
FreeCADGui.addCommand('ProjectSetup', CommandProjectSetup())
|
|
FreeCADGui.addCommand('Terrain', CommandTerrain())
|
|
FreeCADGui.addCommand('PVPlantCreateTerrainMesh', CommandCreateTerrainMesh())
|
|
|
|
|
|
class CommandAreaGroup:
|
|
@staticmethod
|
|
def GetCommands():
|
|
return tuple([ # 'Area',
|
|
'FrameArea',
|
|
'ForbiddenArea',
|
|
'PVSubplant',
|
|
'OffsetArea'
|
|
])
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'MenuText': 'Areas',
|
|
'ToolTip': 'Areas'
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
|
|
# FreeCADGui.addCommand('Area', CommandBoundary())
|
|
FreeCADGui.addCommand('FrameArea', CommandFrameArea())
|
|
FreeCADGui.addCommand('ForbiddenArea', CommandProhibitedArea())
|
|
FreeCADGui.addCommand('PVSubplant', CommandPVSubplant())
|
|
FreeCADGui.addCommand('OffsetArea', CommandOffsetArea())
|
|
FreeCADGui.addCommand('PVPlantAreas', CommandAreaGroup())
|
|
|
|
FreeCADGui.addCommand('SplitArea', CommandSplitArea())
|
|
FreeCADGui.addCommand('JoinAreas', CommandJoinAreas())
|
|
|
|
|
|
class CommandTerrainAnalisysGroup:
|
|
@staticmethod
|
|
def GetCommands():
|
|
return tuple(['Contours',
|
|
'HeightAnalisys',
|
|
'SlopeAnalisys',
|
|
'OrientationAnalisys'
|
|
])
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'MenuText': QT_TRANSLATE_NOOP("", 'Terrain Analisys'),
|
|
'ToolTip': QT_TRANSLATE_NOOP("", 'Terrain Analisys')
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
|
|
FreeCADGui.addCommand('Contours', CommandContours())
|
|
FreeCADGui.addCommand('SlopeAnalisys', CommandSlopeAnalisys())
|
|
FreeCADGui.addCommand('HeightAnalisys', CommandHeightAnalisys())
|
|
FreeCADGui.addCommand('OrientationAnalisys', CommandOrientationAnalisys())
|
|
FreeCADGui.addCommand('TerrainAnalisys', CommandTerrainAnalisysGroup())
|
|
|
|
|
|
class CommandTrenchGroup:
|
|
@staticmethod
|
|
def GetCommands():
|
|
return tuple(['PVPlantTrench',
|
|
'PVPlantSemiAutomaticTrench',
|
|
])
|
|
|
|
@staticmethod
|
|
def GetResources():
|
|
return {'MenuText': 'Rack Types',
|
|
'ToolTip': 'Rack Types'
|
|
}
|
|
|
|
@staticmethod
|
|
def IsActive():
|
|
active = not (FreeCAD.ActiveDocument is None)
|
|
terrain = not (FreeCAD.ActiveDocument.getObject("Terrain") is None)
|
|
active = active and terrain
|
|
if terrain:
|
|
active = active and not (FreeCAD.ActiveDocument.getObject("Terrain").Mesh is None)
|
|
return active
|
|
|
|
|
|
FreeCADGui.addCommand('PVPlantTrench', CommandTrench())
|
|
FreeCADGui.addCommand('PVPlantSemiAutomaticTrench', CommandSemiAutomaticTrench())
|
|
FreeCADGui.addCommand('Trenches', CommandTrenchGroup())
|
|
FreeCADGui.addCommand('PVPlantEarthworks', CommandCalculateEarthworks())
|
|
|
|
FreeCADGui.addCommand('PVPlantManhole', CommandManhole())
|
|
|
|
import PVPlantPlacement
|
|
FreeCADGui.addCommand('PVPlantPlacement', PVPlantPlacement.CommandPVPlantPlacement())
|
|
FreeCADGui.addCommand('PVPlantAdjustToTerrain', PVPlantPlacement.CommandAdjustToTerrain())
|
|
FreeCADGui.addCommand('PVPlantConvertTo', PVPlantPlacement.CommandConvert())
|
|
|
|
import hydro.hydrological as hydro
|
|
FreeCADGui.addCommand('HydrologicalAnalysis', hydro.CommandHydrologicalAnalysis())
|
|
|
|
import Vegetation.PVPlantTreeGenerator as TreeGenerator
|
|
FreeCADGui.addCommand('PVPlantTree', TreeGenerator.CommandTree())
|
|
|
|
import Project.GenerateExternalDocument as GED
|
|
FreeCADGui.addCommand('newExternalDocument', GED.CommandGenerateExternalDocument())
|
|
|
|
from Mechanical.Frame import PVPlantFrame
|
|
class CommandRackGroup:
|
|
|
|
def GetCommands(self):
|
|
return tuple(['PVPlantFixedRack',
|
|
'PVPlantTrackerSetup',
|
|
'PVPlantTracker'
|
|
])
|
|
|
|
def GetResources(self):
|
|
return {'MenuText': QT_TRANSLATE_NOOP("", 'Rack Types'),
|
|
'ToolTip': QT_TRANSLATE_NOOP("", 'Rack Types')
|
|
}
|
|
|
|
def IsActive(self):
|
|
return not FreeCAD.ActiveDocument is None
|
|
|
|
FreeCADGui.addCommand('PVPlantFixedRack', PVPlantFrame.CommandFixedRack())
|
|
FreeCADGui.addCommand('PVPlantTrackerSetup', PVPlantFrame.CommandTrackerSetup())
|
|
FreeCADGui.addCommand('PVPlantTracker', PVPlantFrame.CommandTracker())
|
|
FreeCADGui.addCommand('RackType', CommandRackGroup())
|
|
|
|
|
|
import PVPlantFence
|
|
FreeCADGui.addCommand('PVPlantFenceGroup', PVPlantFence.CommandFenceGroup())
|
|
|
|
projectlist = [ # "Reload",
|
|
"PVPlantSite",
|
|
"ProjectSetup",
|
|
"PVPlantGeoreferencing",
|
|
"Separator",
|
|
# "ImportGrid",
|
|
"Terrain",
|
|
"TerrainAnalisys",
|
|
"PVPlantCreateTerrainMesh",
|
|
"Separator",
|
|
# "PointsGroup",
|
|
"PVPlantAreas",
|
|
"SplitArea",
|
|
"Separator",
|
|
"Trenches",
|
|
"PVPlantEarthworks",
|
|
# "PVPlantPad",
|
|
# "PVPlantRoad",
|
|
"PVPlantManhole",
|
|
# "PVPlantFoundation"
|
|
# "GraphTerrainProfile",
|
|
# "Trace",
|
|
"Separator",
|
|
'HydrologicalAnalysis',
|
|
'newExternalDocument',
|
|
]
|
|
|
|
pv_mechanical = [
|
|
"RackType",
|
|
"PVPlantPlacement",
|
|
"PVPlantAdjustToTerrain",
|
|
"PVPlantConvertTo",
|
|
]
|
|
|
|
objectlist = ['PVPlantTree',
|
|
'PVPlantFence',] |