def icon(self):
return QIcon(QPixmap(16, 16))
def test_icon_png(self):
"""Test we can click OK."""
path = ':/plugins/Isogeo/icon.png'
icon = QIcon(path)
self.assertFalse(icon.isNull())
def getIcon(self):
return QIcon(os.path.dirname(__file__) + '/../../images/taudem.png')
def __init__(self, viewWidget, interfaceMode = False):
# initialize the super class
super(XViewPanelMenu, self).__init__( viewWidget )
# define custom properties
self._viewWidget = viewWidget
self._currentPanel = None
self._interfaceMenu = None
self._groupingMenu = None
self._panelGroup = QActionGroup(self)
self._groupingGroup = QActionGroup(self)
# initialize the menu
if not interfaceMode:
self.setTitle('Panel Options')
self.addSection('Panels')
act = self.addAction('Split Panel Left/Right')
act.setIcon(QIcon(resources.find('img/view/split_horizontal.png')))
act.triggered.connect(self.splitHorizontal)
act = self.addAction('Split Panel Top/Bottom')
act.setIcon(QIcon(resources.find('img/view/split_vertical.png')))
act.triggered.connect(self.splitVertical)
self.addSeparator()
act = self.addAction('Add Panel')
act.setIcon(QIcon(resources.find('img/view/add.png')))
act.triggered.connect(self.addPanel)
# create pane options menu
self._interfaceMenu = XViewPanelMenu(viewWidget, True)
self.addMenu(self._interfaceMenu)
menu = self.addMenu('Switch Panels')
menu.setIcon(QIcon(resources.find('img/view/switch.png')))
act = menu.addAction('Move Up')
act.setIcon(QIcon(resources.find('img/view/up.png')))
act = menu.addAction('Move Down')
act.setIcon(QIcon(resources.find('img/view/down.png')))
menu.addSeparator()
act = menu.addAction('Move Left')
act.setIcon(QIcon(resources.find('img/view/left.png')))
act = menu.addAction('Move Right')
act.setIcon(QIcon(resources.find('img/view/right.png')))
menu.triggered.connect(self.switchPanels)
set_tab_menu = self.addMenu('Switch View')
for viewType in viewWidget.viewTypes():
act = set_tab_menu.addAction(viewType.viewName())
act.setIcon(QIcon(viewType.viewIcon()))
act.setCheckable(True)
self._panelGroup.addAction(act)
set_tab_menu.triggered.connect( self.swapTabType )
self.addSeparator()
act = self.addAction('Close Panel (Closes All Tabs)')
act.setIcon(QIcon(resources.find('img/view/close.png')))
act.triggered.connect( self.closePanel )
act = self.addAction('Close All Panels (Clears Dashboard)')
act.setIcon(QIcon(resources.find('img/view/reset.png')))
act.triggered.connect( self.reset )
self.addSection('Tabs')
act = self.addAction('Rename Tab')
act.setIcon(QIcon(resources.find('img/edit.png')))
act.triggered.connect( self.renamePanel )
act = self.addAction('Detach Tab')
act.setIcon(QIcon(resources.find('img/view/detach.png')))
act.triggered.connect( self.detachPanel )
act = self.addAction('Detach Tab (as a Copy)')
act.setIcon(QIcon(resources.find('img/view/detach_copy.png')))
act.triggered.connect( self.detachPanelCopy )
act = self.addAction('Close Tab')
act.setIcon(QIcon(resources.find('img/view/tab_remove.png')))
act.triggered.connect( self.closeView )
self.addSection('Views')
# create view grouping options
self._groupingMenu = self.addMenu('Set Group')
icon = QIcon(resources.find('img/view/group.png'))
self._groupingMenu.setIcon(icon)
act = self._groupingMenu.addAction('No Grouping')
act.setData(qt.wrapVariant(0))
act.setCheckable(True)
self._groupingMenu.addSeparator()
self._groupingGroup.addAction(act)
for i in range(1, 6):
act = self._groupingMenu.addAction('Group %i' % i)
act.setData(qt.wrapVariant(i))
act.setCheckable(True)
self._groupingGroup.addAction(act)
self._groupingMenu.triggered.connect(self.assignGroup)
else:
self.setTitle( 'Add View' )
for viewType in viewWidget.viewTypes():
act = self.addAction(viewType.viewName())
act.setIcon(QIcon(viewType.viewIcon()))
self.triggered.connect( self.addView )
self.addSeparator()
def __init__(self, parent):
QDialog.__init__(self, parent)
palette = QPalette()
brush = QBrush(QColor(255, 255, 255, 255))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Active, QPalette.Base, brush)
palette.setBrush(QPalette.Active, QPalette.Window, brush)
palette.setBrush(QPalette.Inactive, QPalette.Base, brush)
palette.setBrush(QPalette.Inactive, QPalette.Window, brush)
palette.setBrush(QPalette.Disabled, QPalette.Base, brush)
palette.setBrush(QPalette.Disabled, QPalette.Window, brush)
self.setPalette(palette)
self.ui = Ui_FlightPlannerBase()
self.ui.setupUi(self)
self.newDlgExisting = False
self.chbHideCloseInObst = QCheckBox(self.ui.grbResult)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.chbHideCloseInObst.setFont(font)
self.chbHideCloseInObst.setObjectName("chbHideCloseInObst")
self.ui.vlResultGroup.addWidget(self.chbHideCloseInObst)
self.chbHideCloseInObst.setText("Hide close-in obstacles")
self.chbHideCloseInObst.setVisible(False)
self.ui.tblHistory.setSelectionBehavior(1)
# self.ui.tabCtrlGeneral.setTabsClosable(True)
self.ui.btnUpdateQA.setVisible(False)
self.ui.btnUpdateQA_2.setVisible(False)
''' combo boxes event '''
self.ui.cmbObstSurface.currentIndexChanged.connect(
self.cmbObstSurfaceChanged)
self.ui.cmbUnits.currentIndexChanged.connect(self.changeResultUnit)
''' buttons clicked connect '''
self.ui.btnClose.clicked.connect(self.reject)
self.ui.btnClose_2.clicked.connect(self.reject)
self.ui.btnHistoryClose.clicked.connect(self.reject)
self.ui.btnConstruct.clicked.connect(self.btnConstruct_Click)
self.ui.btnEvaluate.clicked.connect(self.btnEvaluate_Click)
self.ui.btnOpenData.clicked.connect(self.openData)
self.ui.btnSaveData.clicked.connect(self.saveData)
self.ui.btnPDTCheck.clicked.connect(self.btnPDTCheck_Click)
self.ui.btnExportResult.clicked.connect(self.exportResult)
self.ui.tblHistory.clicked.connect(self.tblHistory_Click)
self.ui.btnUpdateQA.clicked.connect(self.btnUpdateQA_Click)
self.ui.btnUpdateQA_2.clicked.connect(self.btnUpdateQA_2_Click)
self.ui.btnCriticalLocate.clicked.connect(self.criticalLocate)
self.connect(self.ui.tblObstacles,
SIGNAL("tableViewObstacleMouseReleaseEvent_rightButton"),
self.tableViewObstacleMouseTeleaseEvent_rightButton)
self.connect(self.ui.tblObstacles, SIGNAL("pressedEvent"),
self.tblObstacles_pressed)
''' properties '''
self.parametersPanel = None
self.obstaclesModel = None
self.surfaceType = ""
self.surfaceSubGroupNames = []
self.uiStateInit()
self.obstacleTableInit()
self.newDlgExisting = True
self.resultColumnNames = []
self.stdItemModelHistory = QStandardItemModel()
# self.stdItemModelHistory.
self.ui.tblHistory.setModel(self.stdItemModelHistory)
icon = QIcon()
icon.addPixmap(QPixmap("Resource/btnImage/dlgIcon.png"), QIcon.Normal,
QIcon.Off)
self.setWindowIcon(icon)
self.resultLayerList = []
self.symbolLayers = []
self.selectedObstacleMoselIndex = None
self.changedCriticalObstacleValue = []
def __init__(self, uiparent):
super(MenuBuilderDialog, self).__init__()
self.setupUi(self)
# reference to caller
self.uiparent = uiparent
self.combo_profile.lineEdit().setPlaceholderText(
self.tr("Profile name"))
# add icons
self.button_add_menu.setIcon(
QIcon(":/plugins/MenuBuilder/resources/plus.svg"))
self.button_delete_profile.setIcon(
QIcon(":/plugins/MenuBuilder/resources/delete.svg"))
# custom qtreeview
self.target = CustomQtTreeView(self)
self.target.setGeometry(QRect(440, 150, 371, 451))
self.target.setAcceptDrops(True)
self.target.setDragEnabled(True)
self.target.setDragDropMode(QAbstractItemView.DragDrop)
self.target.setObjectName("target")
self.target.setDropIndicatorShown(True)
self.target.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.target.setHeaderHidden(True)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.target.sizePolicy().hasHeightForWidth())
self.target.setSizePolicy(sizePolicy)
self.target.setAutoFillBackground(True)
self.verticalLayout_2.addWidget(self.target)
self.browser = QgsBrowserModel()
self.source.setModel(self.browser)
self.source.setHeaderHidden(True)
self.source.setDragEnabled(True)
self.source.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.menumodel = MenuTreeModel(self)
self.target.setModel(self.menumodel)
self.target.setAnimated(True)
# add a dock widget
self.dock_widget = QDockWidget("Menus")
self.dock_widget.resize(400, 300)
self.dock_widget.setFloating(True)
self.dock_widget.setObjectName(self.tr("Menu Tree"))
self.dock_widget_content = QWidget()
self.dock_widget.setWidget(self.dock_widget_content)
dock_layout = QVBoxLayout()
self.dock_widget_content.setLayout(dock_layout)
self.dock_view = DockQtTreeView(self.dock_widget_content)
self.dock_view.setDragDropMode(QAbstractItemView.DragOnly)
self.dock_menu_filter = QLineEdit()
self.dock_menu_filter.setPlaceholderText(
self.tr("Filter by table description (postgis only)"))
dock_layout.addWidget(self.dock_menu_filter)
dock_layout.addWidget(self.dock_view)
self.dock_view.setHeaderHidden(True)
self.dock_view.setDragEnabled(True)
self.dock_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.dock_view.setAnimated(True)
self.dock_view.setObjectName("treeView")
self.proxy_model = LeafFilterProxyModel(self)
self.proxy_model.setFilterRole(Qt.ToolTipRole)
self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.profile_list = []
self.table = 'qgis_menubuilder_metadata'
self.layer_handler = {
'vector': self.load_vector,
'raster': self.load_raster
}
# connect signals and handlers
self.combo_database.activated.connect(
partial(self.set_connection, dbname=None))
self.combo_schema.activated.connect(self.update_profile_list)
self.combo_profile.activated.connect(
partial(self.update_model_idx, self.menumodel))
self.button_add_menu.released.connect(self.add_menu)
self.button_delete_profile.released.connect(self.delete_profile)
self.dock_menu_filter.textEdited.connect(self.filter_update)
self.dock_view.doubleClicked.connect(self.load_from_index)
self.buttonBox.rejected.connect(self.reject)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.button(QDialogButtonBox.Apply).clicked.connect(
self.apply)
def __init__(self, data):
QListWidgetItem.__init__(self, QIcon(self.icons[data[0]]), "\n")
self._data = data
def initGui( self ):
if not valid: return
if int( self.QgisVersion ) < 1:
QMessageBox.warning(
self.iface.getMainWindow(), "Gdal Tools",
QCoreApplication.translate( "GdalTools", "QGIS version detected: " ) +unicode( self.QgisVersion )+".xx\n"
+ QCoreApplication.translate( "GdalTools", "This version of Gdal Tools requires at least QGIS version 1.0.0\nPlugin will not be enabled." ) )
return None
from tools.GdalTools_utils import GdalConfig, LayerRegistry
self.GdalVersionNum = GdalConfig.versionNum()
LayerRegistry.setIface( self.iface )
# find the Raster menu
rasterMenu = None
menu_bar = self.iface.mainWindow().menuBar()
actions = menu_bar.actions()
rasterText = QCoreApplication.translate( "QgisApp", "&Raster" )
for a in actions:
if a.menu() is not None and a.menu().title() == rasterText:
rasterMenu = a.menu()
break
if rasterMenu is None:
# no Raster menu, create and insert it before the Help menu
self.menu = QMenu( rasterText, self.iface.mainWindow() )
lastAction = actions[ len( actions ) - 1 ]
menu_bar.insertMenu( lastAction, self.menu )
else:
self.menu = rasterMenu
self.menu.addSeparator()
# projections menu (Warp (Reproject), Assign projection)
self.projectionsMenu = QMenu( QCoreApplication.translate( "GdalTools", "Projections" ), self.iface.mainWindow() )
self.projectionsMenu.setObjectName("projectionsMenu")
self.warp = QAction( QIcon(":/icons/warp.png"), QCoreApplication.translate( "GdalTools", "Warp (Reproject)..." ), self.iface.mainWindow() )
self.warp.setObjectName("warp")
self.warp.setStatusTip( QCoreApplication.translate( "GdalTools", "Warp an image into a new coordinate system") )
QObject.connect( self.warp, SIGNAL( "triggered()" ), self.doWarp )
self.projection = QAction( QIcon( ":icons/projection-add.png" ), QCoreApplication.translate( "GdalTools", "Assign Projection..." ), self.iface.mainWindow() )
self.projection.setObjectName("projection")
self.projection.setStatusTip( QCoreApplication.translate( "GdalTools", "Add projection info to the raster" ) )
QObject.connect( self.projection, SIGNAL( "triggered()" ), self.doProjection )
self.extractProj = QAction( QIcon( ":icons/projection-export.png" ), QCoreApplication.translate( "GdalTools", "Extract Projection..." ), self.iface.mainWindow() )
self.extractProj.setObjectName("extractProj")
self.extractProj.setStatusTip( QCoreApplication.translate( "GdalTools", "Extract projection information from raster(s)" ) )
QObject.connect( self.extractProj, SIGNAL( "triggered()" ), self.doExtractProj )
self.projectionsMenu.addActions( [ self.warp, self.projection, self.extractProj ] )
# conversion menu (Rasterize (Vector to raster), Polygonize (Raster to vector), Translate, RGB to PCT, PCT to RGB)
self.conversionMenu = QMenu( QCoreApplication.translate( "GdalTools", "Conversion" ), self.iface.mainWindow() )
self.conversionMenu.setObjectName("conversionMenu")
if self.GdalVersionNum >= 1300:
self.rasterize = QAction( QIcon(":/icons/rasterize.png"), QCoreApplication.translate( "GdalTools", "Rasterize (Vector to Raster)..." ), self.iface.mainWindow() )
self.rasterize.setObjectName("rasterize")
self.rasterize.setStatusTip( QCoreApplication.translate( "GdalTools", "Burns vector geometries into a raster") )
QObject.connect( self.rasterize, SIGNAL( "triggered()" ), self.doRasterize )
self.conversionMenu.addAction( self.rasterize )
if self.GdalVersionNum >= 1600:
self.polygonize = QAction( QIcon(":/icons/polygonize.png"), QCoreApplication.translate( "GdalTools", "Polygonize (Raster to Vector)..." ), self.iface.mainWindow() )
self.polygonize.setObjectName("polygonize")
self.polygonize.setStatusTip( QCoreApplication.translate( "GdalTools", "Produces a polygon feature layer from a raster") )
QObject.connect( self.polygonize, SIGNAL( "triggered()" ), self.doPolygonize )
self.conversionMenu.addAction( self.polygonize )
self.translate = QAction( QIcon(":/icons/translate.png"), QCoreApplication.translate( "GdalTools", "Translate (Convert Format)..." ), self.iface.mainWindow() )
self.translate.setObjectName("translate")
self.translate.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") )
QObject.connect( self.translate, SIGNAL( "triggered()" ), self.doTranslate )
self.paletted = QAction( QIcon( ":icons/24-to-8-bits.png" ), QCoreApplication.translate( "GdalTools", "RGB to PCT..." ), self.iface.mainWindow() )
self.paletted.setObjectName("paletted")
self.paletted.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert a 24bit RGB image to 8bit paletted" ) )
QObject.connect( self.paletted, SIGNAL( "triggered()" ), self.doPaletted )
self.rgb = QAction( QIcon( ":icons/8-to-24-bits.png" ), QCoreApplication.translate( "GdalTools", "PCT to RGB..." ), self.iface.mainWindow() )
self.rgb.setObjectName("rgb")
self.rgb.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert an 8bit paletted image to 24bit RGB" ) )
QObject.connect( self.rgb, SIGNAL( "triggered()" ), self.doRGB )
self.conversionMenu.addActions( [ self.translate, self.paletted, self.rgb ] )
# extraction menu (Clipper, Contour)
self.extractionMenu = QMenu( QCoreApplication.translate( "GdalTools", "Extraction" ), self.iface.mainWindow() )
self.extractionMenu.setObjectName("extractionMenu")
if self.GdalVersionNum >= 1600:
self.contour = QAction( QIcon(":/icons/contour.png"), QCoreApplication.translate( "GdalTools", "Contour..." ), self.iface.mainWindow() )
self.contour.setObjectName("contour")
self.contour.setStatusTip( QCoreApplication.translate( "GdalTools", "Builds vector contour lines from a DEM") )
QObject.connect( self.contour, SIGNAL( "triggered()" ), self.doContour )
self.extractionMenu.addAction( self.contour )
self.clipper = QAction( QIcon( ":icons/raster-clip.png" ), QCoreApplication.translate( "GdalTools", "Clipper..." ), self.iface.mainWindow() )
self.clipper.setObjectName("clipper")
#self.clipper.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") )
QObject.connect( self.clipper, SIGNAL( "triggered()" ), self.doClipper )
self.extractionMenu.addActions( [ self.clipper ] )
# analysis menu (DEM (Terrain model), Grid (Interpolation), Near black, Proximity (Raster distance), Sieve)
self.analysisMenu = QMenu( QCoreApplication.translate( "GdalTools", "Analysis" ), self.iface.mainWindow() )
self.analysisMenu.setObjectName("analysisMenu")
if self.GdalVersionNum >= 1600:
self.sieve = QAction( QIcon(":/icons/sieve.png"), QCoreApplication.translate( "GdalTools", "Sieve..." ), self.iface.mainWindow() )
self.sieve.setObjectName("sieve")
self.sieve.setStatusTip( QCoreApplication.translate( "GdalTools", "Removes small raster polygons") )
QObject.connect( self.sieve, SIGNAL( "triggered()" ), self.doSieve )
self.analysisMenu.addAction( self.sieve )
if self.GdalVersionNum >= 1500:
self.nearBlack = QAction( QIcon(":/icons/nearblack.png"), QCoreApplication.translate( "GdalTools", "Near Black..." ), self.iface.mainWindow() )
self.nearBlack.setObjectName("nearBlack")
self.nearBlack.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert nearly black/white borders to exact value") )
QObject.connect( self.nearBlack, SIGNAL( "triggered()" ), self.doNearBlack )
self.analysisMenu.addAction( self.nearBlack )
if self.GdalVersionNum >= 1700:
self.fillNodata = QAction( QIcon(":/icons/fillnodata.png"), QCoreApplication.translate( "GdalTools", "Fill nodata..." ), self.iface.mainWindow() )
self.fillNodata.setObjectName("fillNodata")
self.fillNodata.setStatusTip( QCoreApplication.translate( "GdalTools", "Fill raster regions by interpolation from edges") )
QObject.connect( self.fillNodata, SIGNAL( "triggered()" ), self.doFillNodata )
self.analysisMenu.addAction( self.fillNodata )
if self.GdalVersionNum >= 1600:
self.proximity = QAction( QIcon(":/icons/proximity.png"), QCoreApplication.translate( "GdalTools", "Proximity (Raster Distance)..." ), self.iface.mainWindow() )
self.proximity.setObjectName("proximity")
self.proximity.setStatusTip( QCoreApplication.translate( "GdalTools", "Produces a raster proximity map") )
QObject.connect( self.proximity, SIGNAL( "triggered()" ), self.doProximity )
self.analysisMenu.addAction( self.proximity )
if self.GdalVersionNum >= 1500:
self.grid = QAction( QIcon(":/icons/grid.png"), QCoreApplication.translate( "GdalTools", "Grid (Interpolation)..." ), self.iface.mainWindow() )
self.grid.setObjectName("grid")
self.grid.setStatusTip( QCoreApplication.translate( "GdalTools", "Create raster from the scattered data") )
QObject.connect( self.grid, SIGNAL( "triggered()" ), self.doGrid )
self.analysisMenu.addAction( self.grid )
if self.GdalVersionNum >= 1700:
self.dem = QAction( QIcon( ":icons/dem.png" ), QCoreApplication.translate( "GdalTools", "DEM (Terrain Models)..." ), self.iface.mainWindow() )
self.dem.setObjectName("dem")
self.dem.setStatusTip( QCoreApplication.translate( "GdalTools", "Tool to analyze and visualize DEMs" ) )
QObject.connect( self.dem, SIGNAL( "triggered()" ), self.doDEM )
self.analysisMenu.addAction( self.dem )
#self.analysisMenu.addActions( [ ] )
# miscellaneous menu (Build overviews (Pyramids), Tile index, Information, Merge, Build Virtual Raster (Catalog))
self.miscellaneousMenu = QMenu( QCoreApplication.translate( "GdalTools", "Miscellaneous" ), self.iface.mainWindow() )
self.miscellaneousMenu.setObjectName("miscellaneousMenu")
if self.GdalVersionNum >= 1600:
self.buildVRT = QAction( QIcon(":/icons/vrt.png"), QCoreApplication.translate( "GdalTools", "Build Virtual Raster (Catalog)..." ), self.iface.mainWindow() )
self.buildVRT.setObjectName("buildVRT")
self.buildVRT.setStatusTip( QCoreApplication.translate( "GdalTools", "Builds a VRT from a list of datasets") )
QObject.connect( self.buildVRT, SIGNAL( "triggered()" ), self.doBuildVRT )
self.miscellaneousMenu.addAction( self.buildVRT )
self.merge = QAction( QIcon(":/icons/merge.png"), QCoreApplication.translate( "GdalTools", "Merge..." ), self.iface.mainWindow() )
self.merge.setObjectName("merge")
self.merge.setStatusTip( QCoreApplication.translate( "GdalTools", "Build a quick mosaic from a set of images") )
QObject.connect( self.merge, SIGNAL( "triggered()" ), self.doMerge )
self.info = QAction( QIcon( ":/icons/raster-info.png" ), QCoreApplication.translate( "GdalTools", "Information..." ), self.iface.mainWindow() )
self.info.setObjectName("info")
self.info.setStatusTip( QCoreApplication.translate( "GdalTools", "Lists information about raster dataset" ) )
QObject.connect( self.info, SIGNAL("triggered()"), self.doInfo )
self.overview = QAction( QIcon( ":icons/raster-overview.png" ), QCoreApplication.translate( "GdalTools", "Build Overviews (Pyramids)..." ), self.iface.mainWindow() )
self.overview.setObjectName("overview")
self.overview.setStatusTip( QCoreApplication.translate( "GdalTools", "Builds or rebuilds overview images" ) )
QObject.connect( self.overview, SIGNAL( "triggered()" ), self.doOverview )
self.tileindex = QAction( QIcon( ":icons/tiles.png" ), QCoreApplication.translate( "GdalTools", "Tile Index..." ), self.iface.mainWindow() )
self.tileindex.setObjectName("tileindex")
self.tileindex.setStatusTip( QCoreApplication.translate( "GdalTools", "Build a shapefile as a raster tileindex" ) )
QObject.connect( self.tileindex, SIGNAL( "triggered()" ), self.doTileIndex )
self.miscellaneousMenu.addActions( [ self.merge, self.info, self.overview, self.tileindex ] )
self.menu.addMenu( self.projectionsMenu )
self.menu.addMenu( self.conversionMenu )
self.menu.addMenu( self.extractionMenu )
if not self.analysisMenu.isEmpty():
self.menu.addMenu( self.analysisMenu )
self.menu.addMenu( self.miscellaneousMenu )
self.settings = QAction( QCoreApplication.translate( "GdalTools", "GdalTools Settings..." ), self.iface.mainWindow() )
self.settings.setObjectName("settings")
self.settings.setStatusTip( QCoreApplication.translate( "GdalTools", "Various settings for Gdal Tools" ) )
QObject.connect( self.settings, SIGNAL( "triggered()" ), self.doSettings )
self.menu.addAction( self.settings )
def __init__(self,
y_scale_title_text,
plots,
clear_button=None,
parent=None,
scales_visible=True,
curve_outer_border_visible=True,
curve_motion_granularity=10,
canvas_color=QColor(245, 245, 245),
external_timer=None):
QWidget.__init__(self, parent)
self.setMinimumSize(300, 250)
self.stop = True
self.plot = Plot(self, y_scale_title_text, plots, scales_visible,
curve_outer_border_visible, curve_motion_granularity,
canvas_color)
self.set_fixed_y_scale = self.plot.set_fixed_y_scale
self.plot_buttons = []
self.first_show = True
if clear_button == None:
self.clear_button = QPushButton('Clear Graph')
else:
self.clear_button = clear_button
self.clear_button.clicked.connect(self.clear_clicked)
vlayout = QVBoxLayout(self)
vlayout.setContentsMargins(0, 0, 0, 0)
if len(plots) > 1:
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
button_layout = QVBoxLayout()
button_layout.setContentsMargins(0, 0, 0, 0)
button_layout.addSpacing(self.plot.get_legend_offset_y())
for i, plot in enumerate(plots):
pixmap = QPixmap(10, 1)
QPainter(pixmap).fillRect(0, 0, 10, 1, plot[1])
button = QToolButton(self)
button.setText(plot[0])
button.setIcon(QIcon(pixmap))
button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
button.setCheckable(True)
button.setChecked(True)
button.toggled.connect(
functools.partial(self.plot.show_curve, i))
self.plot_buttons.append(button)
button_layout.addWidget(button)
button_layout.addStretch(1)
hlayout.addWidget(self.plot)
hlayout.addLayout(button_layout)
vlayout.addLayout(hlayout)
else:
vlayout.addWidget(self.plot)
if clear_button == None:
vlayout.addWidget(self.clear_button)
self.counter = 0
self.update_funcs = []
for plot in plots:
self.update_funcs.append(plot[2])
if external_timer == None:
self.timer = QTimer(self)
self.timer.timeout.connect(self.add_new_data)
self.timer.start(100)
else:
# assuming that the external timer runs with 100ms interval
external_timer.timeout.connect(self.add_new_data)
def icon(self):
return QIcon(os.path.join(os.path.dirname(__file__), "zoom-slider.png"))
def start(filenames=None, projects_path=None,
extra_plugins=None, linenos=None):
app = QApplication(sys.argv)
QCoreApplication.setOrganizationName('NINJA-IDE')
QCoreApplication.setOrganizationDomain('NINJA-IDE')
QCoreApplication.setApplicationName('NINJA-IDE')
app.setWindowIcon(QIcon(resources.IMAGES['icon']))
# Check if there is another session of ninja-ide opened
# and in that case send the filenames and projects to that session
running = ipc.is_running()
start_server = not running[0]
if running[0] and (filenames or projects_path):
sended = ipc.send_data(running[1], filenames, projects_path, linenos)
running[1].close()
if sended:
sys.exit()
else:
running[1].close()
# Create and display the splash screen
splash_pix = QPixmap(resources.IMAGES['splash'])
splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
splash.setMask(splash_pix.mask())
splash.show()
app.processEvents()
# Set the cursor to unblinking
global cursor_flash_time
cursor_flash_time = app.cursorFlashTime()
app.setCursorFlashTime(0)
#Set the codec for strings (QString)
QTextCodec.setCodecForCStrings(QTextCodec.codecForName('utf-8'))
#Translator
qsettings = QSettings()
language = QLocale.system().language()
lang = unicode(qsettings.value(
'preferences/interface/language', language).toString()) + '.qm'
lang_path = file_manager.create_path(resources.LANGS, unicode(lang))
if file_manager.file_exists(lang_path):
settings.LANGUAGE = lang_path
elif file_manager.file_exists(file_manager.create_path(
resources.LANGS_DOWNLOAD, unicode(lang))):
settings.LANGUAGE = file_manager.create_path(
resources.LANGS_DOWNLOAD, unicode(lang))
translator = QTranslator()
if settings.LANGUAGE:
translator.load(settings.LANGUAGE)
app.installTranslator(translator)
#Loading Syntax
splash.showMessage("Loading Syntax", Qt.AlignRight | Qt.AlignTop, Qt.black)
json_manager.load_syntax()
#Read Settings
splash.showMessage("Loading Settings", Qt.AlignRight | Qt.AlignTop,
Qt.black)
settings.load_settings()
#Set Stylesheet
if settings.USE_STYLESHEET:
with open(resources.NINJA_THEME) as f:
qss = f.read()
app.setStyleSheet(qss)
#Loading Themes
splash.showMessage("Loading Themes", Qt.AlignRight | Qt.AlignTop, Qt.black)
scheme = unicode(qsettings.value('preferences/editor/scheme',
"default").toString())
if scheme != 'default':
scheme = file_manager.create_path(resources.EDITOR_SKINS,
scheme + '.color')
if file_manager.file_exists(scheme):
resources.CUSTOM_SCHEME = json_manager.parse(open(scheme))
#Loading Shortcuts
resources.load_shortcuts()
#Loading GUI
splash.showMessage("Loading GUI", Qt.AlignRight | Qt.AlignTop, Qt.black)
ide = IDE(start_server)
#Showing GUI
ide.show()
#Loading Session Files
splash.showMessage("Loading Files and Projects",
Qt.AlignRight | Qt.AlignTop, Qt.black)
#Files in Main Tab
mainFiles = qsettings.value('openFiles/mainTab', []).toList()
tempFiles = []
for file_ in mainFiles:
fileData = file_.toList()
tempFiles.append((unicode(fileData[0].toString()),
fileData[1].toInt()[0]))
mainFiles = tempFiles
#Files in Secondary Tab
secondaryFiles = qsettings.value('openFiles/secondaryTab', []).toList()
tempFiles = []
for file_ in secondaryFiles:
fileData = file_.toList()
tempFiles.append((unicode(fileData[0].toString()),
fileData[1].toInt()[0]))
secondaryFiles = tempFiles
#Current File
current_file = unicode(
qsettings.value('openFiles/currentFile', '').toString())
#Projects
projects = qsettings.value('openFiles/projects', []).toList()
projects = [unicode(project.toString()) for project in projects]
#Include files received from console args
file_with_nro = map(lambda f: (f[0], f[1] - 1), zip(filenames, linenos))
file_without_nro = map(lambda f: (f, 0), filenames[len(linenos):])
mainFiles += file_with_nro + file_without_nro
#Include projects received from console args
if projects_path:
projects += projects_path
mainFiles.reverse()
secondaryFiles.reverse()
ide.load_session_files_projects(mainFiles, secondaryFiles, projects,
current_file)
#Load external plugins
if extra_plugins:
ide.load_external_plugins(extra_plugins)
splash.finish(ide)
ide.notify_plugin_errors()
sys.exit(app.exec_())
def getIcon(self):
return QIcon(dirname(__file__) + '/../../icon.png')
def getIcon(self):
"""Load algorithme icon"""
return QIcon(
os.path.dirname(__file__) + os.sep + ".." + os.sep + "images" +
os.sep + "chloe_icon.png")
def __init__(self, parent = None):
QDialog.__init__(self)
self.setObjectName(("ui_WorkspaceMngForm"))
self.resize(200, 200)
font = QFont()
font.setFamily(("Arial"))
font.setBold(False)
font.setWeight(50)
self.setFont(font)
self.vlForm = QVBoxLayout(self)
self.vlForm.setObjectName(("vl_ProjectMngForm"))
self.vlForm.setSpacing(9)
self.vlForm.setMargin(9)
self.setWindowTitle("Workspace Manage Dialog")
self.basicFrame = Frame(self)
self.vlForm.addWidget(self.basicFrame)
self.frameName = Frame(self.basicFrame, "HL")
self.basicFrame.Add = self.frameName
self.frame = Frame(self.frameName)
self.frameName.Add = self.frame
self.comboProjectWorkspace = ComboBoxPanel(self.frame)
self.comboProjectWorkspace.Caption = "Project"
self.comboProjectWorkspace.LabelWidth = 120
self.frame.Add = self.comboProjectWorkspace
self.comboSubProjectWorkspace = ComboBoxPanel(self.frame)
self.comboSubProjectWorkspace.Caption = "Sub-Project"
self.comboSubProjectWorkspace.LabelWidth = 120
self.frame.Add = self.comboSubProjectWorkspace
self.textNameWorkspace = TextBoxPanel(self.frame)
self.textNameWorkspace.Caption = "Workspace Name"
self.textNameWorkspace.LabelWidth = 120
self.textNameWorkspace.Width = 120
self.frame.Add = self.textNameWorkspace
self.textFullName = TextBoxPanel(self.frame)
self.textFullName.Caption = "Full Name"
self.textFullName.LabelWidth = 120
self.textFullName.Width = 120
self.textFullName.Visible = False
self.frame.Add = self.textFullName
self.groubox = GroupBox(self.frameName)
self.groubox.Caption = "Workspaces"
self.frameName.Add = self.groubox
self.listBoxWorkspace = ListBox(self.groubox)
self.groubox.Add = self.listBoxWorkspace
self.textPathWorkspace = TextBoxPanel(self.basicFrame)
self.textPathWorkspace.Caption = "Workspace Path"
self.textPathWorkspace.imageButton.setIcon(QIcon())
self.textPathWorkspace.Button = "opens.png"
self.textPathWorkspace.LabelWidth = 120
# self.textPathWorkspace.Enabled = False
self.textPathWorkspace.textBox.setMaximumWidth(10000)
self.textPathWorkspace.textBox.setMinimumWidth(100)
self.basicFrame.Add = self.textPathWorkspace
self.btnFrame = Frame(self.basicFrame, "HL")
self.basicFrame.Add = self.btnFrame
self.buttonAddWorkspace = QPushButton(self.btnFrame)
self.buttonAddWorkspace.setObjectName("buttonAddWorkspace")
self.buttonAddWorkspace.setText("Add")
self.btnFrame.Add = self.buttonAddWorkspace
self.buttonModifyWorkspace = QPushButton(self.btnFrame)
self.buttonModifyWorkspace.setObjectName("buttonModifyWorkspace")
self.buttonModifyWorkspace.setText("Modify")
self.btnFrame.Add = self.buttonModifyWorkspace
self.buttonDeleteWorkspace = QPushButton(self.btnFrame)
self.buttonDeleteWorkspace.setObjectName("buttonDeleteWorkspace")
self.buttonDeleteWorkspace.setText("Delete")
self.btnFrame.Add = self.buttonDeleteWorkspace
self.buttonSaveWorkspace = QPushButton(self.btnFrame)
self.buttonSaveWorkspace.setObjectName("buttonSaveWorkspace")
self.buttonSaveWorkspace.setText("Save")
self.buttonSaveWorkspace.setVisible(False)
self.btnFrame.Add = self.buttonSaveWorkspace
self.buttonCloseWorkspace = QPushButton(self.btnFrame)
self.buttonCloseWorkspace.setObjectName("buttonCloseWorkspace")
self.buttonCloseWorkspace.setText("Close")
self.btnFrame.Add = self.buttonCloseWorkspace
self.connect(self.listBoxWorkspace, SIGNAL("Event_0"), self.listBoxWorkspace_SelectedIndexChanged)
self.connect(self.comboProjectWorkspace, SIGNAL("Event_0"), self.comboProjectWorkspace_SelectedIndexChanged)
self.connect(self.comboSubProjectWorkspace, SIGNAL("Event_0"), self.comboSubProjectWorkspace_SelectedIndexChanged)
self.connect(self.textPathWorkspace, SIGNAL("Event_1"), self.buttonBrowseWorkspace_Click)
self.connect(self.textNameWorkspace, SIGNAL("Event_0"), self.setFullName)
self.buttonCloseWorkspace.clicked.connect(self.buttonCloseWorkspace_Click)
self.buttonSaveWorkspace.clicked.connect(self.buttonSaveWorkspace_Click)
self.buttonDeleteWorkspace.clicked.connect(self.buttonDeleteWorkspace_Click)
self.buttonModifyWorkspace.clicked.connect(self.buttonModifyWorkspace_Click)
self.buttonAddWorkspace.clicked.connect(self.buttonAddWorkspace_Click)
self.editFlag = False
for pi in AirCraftOperation.g_projectList.ProjectsList:
if (pi.Pt == enumProjectType.ptWorkspace):
self.listBoxWorkspace.Add(pi.Name)
elif (pi.Pt == enumProjectType.ptProject):
self.comboProjectWorkspace.Add(pi.Name)
elif (pi.Pt == enumProjectType.ptSubProject):
self.comboSubProjectWorkspace.Add(pi.Name)
self.comboProjectWorkspace_SelectedIndexChanged()
def __init__(self, *args):
QDialog.__init__(self, *args)
self.setupUi(self)
self.setWindowIcon(QIcon(":/icons/qtsixa.png"))
def initWidgets(self):
#tooltips = self.alg.getParameterDescriptions()
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameters:
if param.isAdvanced:
self.grpAdvanced.show()
break
# Create widgets and put them in layouts
for param in self.alg.parameters:
if param.hidden:
continue
desc = param.description
if isinstance(param, ParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
try:
if param.optional:
desc += self.tr(' [optional]')
except:
pass
widget = self.getWidgetFromParameter(param)
self.valueItems[param.name] = widget
if isinstance(param, ParameterVector) and \
not self.alg.allowOnlyOpenedLayers:
layout = QHBoxLayout()
layout.setSpacing(2)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(
os.path.dirname(__file__) + '/../images/iterate.png')
button.setIcon(icon)
button.setToolTip(self.tr('Iterate over this layer'))
button.setCheckable(True)
layout.addWidget(button)
self.iterateButtons[param.name] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
#~ if param.name in tooltips.keys():
#~ tooltip = tooltips[param.name]
#~ else:
#~ tooltip = param.description
#~ widget.setToolTip(tooltip)
if isinstance(param, ParameterBoolean):
widget.setText(desc)
if param.isAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
widget)
else:
label = QLabel(desc)
#label.setToolTip(tooltip)
self.labels[param.name] = label
if param.isAdvanced:
self.layoutAdvanced.addWidget(label)
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
label)
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
widget)
self.widgets[param.name] = widget
for output in self.alg.outputs:
if output.hidden:
continue
label = QLabel(output.description)
widget = OutputSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (OutputRaster, OutputVector, OutputTable)):
check = QCheckBox()
check.setText(
self.tr('Open output file after running algorithm'))
check.setChecked(True)
self.layoutMain.insertWidget(self.layoutMain.count() - 1,
check)
self.checkBoxes[output.name] = check
self.valueItems[output.name] = widget
def getIcon(self):
return QIcon(os.path.join(pluginPath, 'images', 'script.png'))
def icon(self):
return QIcon()
def load_menus(self, profile=None, schema=None):
"""
Load menus in the main windows qgis bar
"""
if not schema:
schema = self.combo_schema.currentText()
if not profile:
profile = self.combo_profile.currentText()
# remove previous menus
for menu in self.uiparent.menus:
self.uiparent.iface.mainWindow().menuBar().removeAction(
menu.menuAction())
with self.transaction():
cur = self.connection.cursor()
select = """
select name, profile, model_index, datasource_uri
from {}.{}
where profile = '{}'
""".format(schema, self.table, profile)
cur.execute(select)
rows = cur.fetchall()
# item accessor ex: '0-menu/0-submenu/1-item/'
menudict = {}
# reference to parent item
parent = ''
# reference to qgis main menu bar
menubar = self.uiparent.iface.mainWindow().menuBar()
for name, profile, model_index, datasource_uri in self.sortby_modelindex(
rows):
uri_struct = QgsMimeDataUtils.Uri(datasource_uri)
indexes = json.loads(model_index)
# root menu
parent = '{}-{}/'.format(indexes[0][0], indexes[0][1])
if parent not in menudict:
menu = QMenu(self.uiparent.iface.mainWindow())
self.uiparent.menus.append(menu)
menu.setObjectName(indexes[0][1])
menu.setTitle(indexes[0][1])
menubar.insertMenu(
self.uiparent.iface.firstRightStandardMenu().menuAction(),
menu)
menudict[parent] = menu
else:
# menu already there
menu = menudict[parent]
for idx, subname in indexes[1:-1]:
# intermediate submenus
parent += '{}-{}/'.format(idx, subname)
if parent not in menudict:
submenu = menu.addMenu(subname)
submenu.setObjectName(subname)
submenu.setTitle(subname)
menu = submenu
# store it for later use
menudict[parent] = menu
continue
# already treated
menu = menudict[parent]
# last item = layer
layer = QAction(name, self.uiparent.iface.mainWindow())
if uri_struct.providerKey in ICON_MAPPER:
layer.setIcon(QIcon(ICON_MAPPER[uri_struct.providerKey]))
if uri_struct.providerKey == 'postgres':
# set tooltip to postgres comment
comment = self.get_table_comment(uri_struct.uri)
layer.setStatusTip(comment)
layer.setToolTip(comment)
layer.setData(uri_struct.uri)
layer.setWhatsThis(uri_struct.providerKey)
layer.triggered.connect(self.layer_handler[uri_struct.layerType])
menu.addAction(layer)
def getIcon(self):
return QIcon(':/processing/images/script.png')
def __init__(self, menuEdit, toolbar):
QObject.__init__(self)
undoAction = menuEdit.addAction(
QIcon(resources.IMAGES['undo']),
self.tr("Undo (%1+Z)").arg(settings.OS_KEY))
redoAction = menuEdit.addAction(
QIcon(resources.IMAGES['redo']),
self.tr("Redo (%1)").arg(
resources.get_shortcut("Redo").toString(
QKeySequence.NativeText)))
cutAction = menuEdit.addAction(
QIcon(resources.IMAGES['cut']),
self.tr("&Cut (%1+X)").arg(settings.OS_KEY))
copyAction = menuEdit.addAction(
QIcon(resources.IMAGES['copy']),
self.tr("&Copy (%1+C)").arg(settings.OS_KEY))
pasteAction = menuEdit.addAction(
QIcon(resources.IMAGES['paste']),
self.tr("&Paste (%1+V)").arg(settings.OS_KEY))
menuEdit.addSeparator()
findAction = menuEdit.addAction(
QIcon(resources.IMAGES['find']),
self.tr("Find (%1)").arg(
resources.get_shortcut("Find").toString(
QKeySequence.NativeText)))
findReplaceAction = menuEdit.addAction(
QIcon(resources.IMAGES['findReplace']),
self.tr("Find/Replace (%1)").arg(
resources.get_shortcut("Find-replace").toString(
QKeySequence.NativeText)))
findWithWordAction = menuEdit.addAction(
self.tr("Find using word under cursor (%1)").arg(
resources.get_shortcut("Find-with-word").toString(
QKeySequence.NativeText)))
findInFilesAction = menuEdit.addAction(
QIcon(resources.IMAGES['find']),
self.tr("Find in Files (%1)").arg(
resources.get_shortcut("Find-in-files").toString(
QKeySequence.NativeText)))
jumpAction = menuEdit.addAction(
self.tr("Jump to Line (%1)").arg(
resources.get_shortcut("Jump").toString(
QKeySequence.NativeText)))
locatorAction = menuEdit.addAction(
QIcon(resources.IMAGES['locator']),
self.tr("Code Locator (%1)").arg(
resources.get_shortcut("Code-locator").toString(
QKeySequence.NativeText)))
menuEdit.addSeparator()
upperAction = menuEdit.addAction(
self.tr("Convert selected Text to: UPPER"))
lowerAction = menuEdit.addAction(
self.tr("Convert selected Text to: lower"))
titleAction = menuEdit.addAction(
self.tr("Convert selected Text to: Title Word"))
menuEdit.addSeparator()
prefAction = menuEdit.addAction(QIcon(resources.IMAGES['pref']),
self.tr("Preference&s"))
self.toolbar_items = {
'undo': undoAction,
'redo': redoAction,
'cut': cutAction,
'copy': copyAction,
'paste': pasteAction,
'find': findAction,
'find-replace': findReplaceAction,
'find-files': findInFilesAction,
'code-locator': locatorAction
}
self.connect(cutAction, SIGNAL("triggered()"), self._editor_cut)
self.connect(copyAction, SIGNAL("triggered()"), self._editor_copy)
self.connect(pasteAction, SIGNAL("triggered()"), self._editor_paste)
self.connect(redoAction, SIGNAL("triggered()"), self._editor_redo)
self.connect(undoAction, SIGNAL("triggered()"), self._editor_undo)
self.connect(upperAction, SIGNAL("triggered()"), self._editor_upper)
self.connect(lowerAction, SIGNAL("triggered()"), self._editor_lower)
self.connect(titleAction, SIGNAL("triggered()"), self._editor_title)
self.connect(findAction, SIGNAL("triggered()"),
status_bar.StatusBar().show)
self.connect(findWithWordAction, SIGNAL("triggered()"),
status_bar.StatusBar().show_with_word)
self.connect(jumpAction, SIGNAL("triggered()"),
lambda: self.jump_to_editor_line())
self.connect(findReplaceAction, SIGNAL("triggered()"),
status_bar.StatusBar().show_replace)
self.connect(findInFilesAction, SIGNAL("triggered()"),
self._show_find_in_files)
self.connect(locatorAction, SIGNAL("triggered()"),
status_bar.StatusBar().show_locator)
self.connect(prefAction, SIGNAL("triggered()"), self._show_preferences)
def getIcon(self):
return QIcon(':/processing/images/model.png')
def __init__(self, menuFile, toolbar, ide):
QObject.__init__(self)
newAction = menuFile.addAction(QIcon(resources.IMAGES['new']),
self.tr("&New File (%1)").arg(
resources.get_shortcut("New-file").toString(
QKeySequence.NativeText)))
newProjectAction = menuFile.addAction(
QIcon(resources.IMAGES['newProj']),
self.tr("New Pro&ject (%1)").arg(
resources.get_shortcut("New-project").toString(
QKeySequence.NativeText)))
menuFile.addSeparator()
saveAction = menuFile.addAction(QIcon(resources.IMAGES['save']),
self.tr("&Save (%1)").arg(
resources.get_shortcut("Save-file").toString(
QKeySequence.NativeText)))
saveAsAction = menuFile.addAction(QIcon(resources.IMAGES['saveAs']),
self.tr("Save &As"))
saveAllAction = menuFile.addAction(QIcon(resources.IMAGES['saveAll']),
self.tr("Save All"))
saveProjectAction = menuFile.addAction(QIcon(
resources.IMAGES['saveAll']),
self.tr("Save Pro&ject (%1)").arg(
resources.get_shortcut("Save-project").toString(
QKeySequence.NativeText)))
menuFile.addSeparator()
reloadFileAction = menuFile.addAction(
QIcon(resources.IMAGES['reload-file']),
self.tr("Reload File (%1)").arg(
resources.get_shortcut("Reload-file").toString(
QKeySequence.NativeText)))
menuFile.addSeparator()
openAction = menuFile.addAction(QIcon(resources.IMAGES['open']),
self.tr("&Open (%1)").arg(
resources.get_shortcut("Open-file").toString(
QKeySequence.NativeText)))
openProjectAction = menuFile.addAction(
QIcon(resources.IMAGES['openProj']),
self.tr("Open &Project (%1)").arg(
resources.get_shortcut("Open-project").toString(
QKeySequence.NativeText)))
openProjectTypeAction = menuFile.addAction(
QIcon(resources.IMAGES['openProj']), self.tr("Open Project &Type"))
menuFile.addSeparator()
activateProfileAction = menuFile.addAction(
QIcon(resources.IMAGES['activate-profile']),
self.tr("Activate Profile"))
deactivateProfileAction = menuFile.addAction(
QIcon(resources.IMAGES['deactivate-profile']),
self.tr("Deactivate Profile"))
menuFile.addSeparator()
printFile = menuFile.addAction(QIcon(resources.IMAGES['print']),
self.tr("Pr&int File (%1)").arg(
resources.get_shortcut("Print-file").toString(
QKeySequence.NativeText)))
closeAction = menuFile.addAction(
ide.style().standardIcon(QStyle.SP_DialogCloseButton),
self.tr("&Close Tab (%1)").arg(
resources.get_shortcut("Close-tab").toString(
QKeySequence.NativeText)))
closeProjectsAction = menuFile.addAction(
ide.style().standardIcon(QStyle.SP_DialogCloseButton),
self.tr("&Close All Projects"))
menuFile.addSeparator()
exitAction = menuFile.addAction(
ide.style().standardIcon(QStyle.SP_DialogCloseButton),
self.tr("&Exit"))
self.toolbar_items = {
'new-file': newAction,
'new-project': newProjectAction,
'save-file': saveAction,
'save-as': saveAsAction,
'save-all': saveAllAction,
'save-project': saveProjectAction,
'reload-file': reloadFileAction,
'open-file': openAction,
'open-project': openProjectAction,
'activate-profile': activateProfileAction,
'deactivate-profile': deactivateProfileAction,
'print-file': printFile,
'close-file': closeAction,
'close-projects': closeProjectsAction}
self.connect(newAction, SIGNAL("triggered()"),
ide.mainContainer.add_editor)
self.connect(newProjectAction, SIGNAL("triggered()"),
ide.explorer.create_new_project)
self.connect(openAction, SIGNAL("triggered()"),
ide.mainContainer.open_file)
self.connect(saveAction, SIGNAL("triggered()"),
ide.mainContainer.save_file)
self.connect(saveAsAction, SIGNAL("triggered()"),
ide.mainContainer.save_file_as)
self.connect(saveAllAction, SIGNAL("triggered()"),
ide.actions.save_all)
self.connect(saveProjectAction, SIGNAL("triggered()"),
ide.actions.save_project)
self.connect(openProjectAction, SIGNAL("triggered()"),
ide.explorer.open_project_folder)
self.connect(openProjectTypeAction, SIGNAL("triggered()"),
self._open_project_type)
self.connect(closeAction, SIGNAL("triggered()"),
ide.mainContainer.actualTab.close_tab)
self.connect(exitAction, SIGNAL("triggered()"),
ide.close)
QObject.connect(reloadFileAction, SIGNAL("triggered()"),
ide.mainContainer.reload_file)
self.connect(printFile, SIGNAL("triggered()"), ide.actions.print_file)
self.connect(closeProjectsAction, SIGNAL("triggered()"),
ide.explorer.close_opened_projects)
self.connect(deactivateProfileAction, SIGNAL("triggered()"),
ide.actions.deactivate_profile)
self.connect(activateProfileAction, SIGNAL("triggered()"),
ide.actions.activate_profile)
def icon(self):
return QIcon(
os.path.join(os.path.dirname(__file__), "attribute-table.png"))
def add_action(
self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
# Create the dialog (after translation) and keep reference
#self.dlg = volumDialog() ### isso causava o bug da janela de dialogo nao abrir...
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(
self.menu,
action)
self.actions.append(action)
return action
def __init__(self, name, icon):
self._menu = QMenu(name)
self._menu.setIcon(
QIcon(os.path.join(":/plugins/tmsforkorea/weblayers/icons", icon)))
def __init__(self, parent=None, aptinkerQSettings=None):
"""Constructor"""
QDialog.__init__(self, parent=parent)
self.setupUi(self)
self.setWindowFlags(Qt.Window) # To add Maximize & Minimize buttons
self.setWindowTitle('Select Configuration from Database')
# Load Startup Preferences for Config Table
self.default_config_pref = dict(
vis_col_key_list=config.DEF_VIS_COL_KEYS['config_setup'][:])
if osp.exists(PREF_CONFIG_JSON_FILEPATH):
with open(PREF_CONFIG_JSON_FILEPATH, 'r') as f:
self.config_pref = json.load(f)
else:
self.config_pref = self.default_config_pref
# Load Startup Preferences for Config Meta Table
self.default_config_meta_pref = dict(vis_col_key_list=[
'config_id', 'config_ctime', 'config_name', 'username',
'config_ref_step_size', 'config_masar_id'
])
if osp.exists(PREF_CONFIG_META_JSON_FILEPATH):
with open(PREF_CONFIG_META_JSON_FILEPATH, 'r') as f:
self.config_meta_pref = json.load(f)
else:
self.config_meta_pref = self.default_config_meta_pref
self.configDBViewWidget = ConfigDBViewWidget(
self.groupBox_selected_conf)
self.tableView_config = self.configDBViewWidget.tableView
self.configMetaDBViewWidget = ConfigMetaDBViewWidget(
self.groupBox_search_result)
self.tableView_config_meta = self.configMetaDBViewWidget.tableView
self.textEdit_description = \
self.configMetaDBViewWidget.textEdit_description
self.settings = QSettings('APHLA', 'TinkerConfigDBSelector')
self.loadViewSettings()
self._aptinkerQSettings = aptinkerQSettings
self.pushButton_search.setIcon(QIcon(':/search.png'))
all_ctime_operators = [
self.comboBox_time_created_1.itemText(i)
for i in range(self.comboBox_time_created_1.count())
]
self.comboBox_time_created_1.setCurrentIndex(
all_ctime_operators.index(''))
self.dateTimeEdit_time_created_1.setDateTime(
QDateTime.currentDateTime())
self.dateTimeEdit_time_created_2.setDateTime(
QDateTime.currentDateTime())
self.search_params = dict(config_id_1='',
config_id_2='',
ref_step_size_1='',
ref_step_size_2='',
config_name='',
config_desc='',
username='',
ctime_1='',
ctime_2='',
synced_gruop_weight='',
masar_id_1='',
masar_id_2='')
db_id_validator = QIntValidator()
db_id_validator.setBottom(1)
self.lineEdit_config_id_1.setValidator(db_id_validator)
self.lineEdit_config_id_2.setValidator(db_id_validator)
self.lineEdit_masar_id_1.setValidator(db_id_validator)
self.lineEdit_masar_id_2.setValidator(db_id_validator)
self.prev_valid_ref_step_sizes = dict(lineEdit_ref_step_size_1=np.nan,
lineEdit_ref_step_size_2=np.nan)
# Set up Config Table
self.config_model = ConfigModel()
self.tableModel_config = self.config_model.table
proxyModel = QSortFilterProxyModel()
proxyModel.setSourceModel(self.tableModel_config)
proxyModel.setDynamicSortFilter(False)
tbV = self.tableView_config
tbV.setModel(proxyModel)
tbV.setItemDelegate(
ConfigDBTableViewItemDelegate(tbV, self.tableModel_config,
tbV.parent()))
self.db = self.config_model.db
if '[config_meta_table text view]' not in self.db.getViewNames(
square_brackets=True):
self.db.create_temp_config_meta_table_text_view()
# Set up Config Meta Table
self.config_meta_all_col_keys = self.configMetaDBViewWidget.all_col_keys
self.search_result = {k: [] for k in self.config_meta_all_col_keys}
self.tableModel_config_meta = MetaTableModel(
self.search_result, self.configMetaDBViewWidget)
proxyModel = QSortFilterProxyModel()
proxyModel.setSourceModel(self.tableModel_config_meta)
proxyModel.setDynamicSortFilter(False)
tbV = self.tableView_config_meta
tbV.setModel(proxyModel)
self.selectionModel = QItemSelectionModel(proxyModel)
tbV.setSelectionModel(self.selectionModel)
# Apply Visible Column Preference to Config Table
(col_keys, col_names) = config.COL_DEF.getColumnDataFromTable(
'column_table',
column_name_list=['column_key', 'short_descrip_name'],
condition_str='column_key in ({0:s})'.format(','.join([
'"{0:s}"'.format(k)
for k in self.config_pref['vis_col_key_list']
])))
config_vis_col_name_list = [
col_names[col_keys.index(k)]
for k in self.config_pref['vis_col_key_list']
]
self.configDBViewWidget.on_column_selection_change(
config_vis_col_name_list, force_visibility_update=True)
# Apply Visible Column Preference to Config Meta Table
config_meta_vis_col_name_list = [
self.configMetaDBViewWidget.col_names_wo_desc[
self.configMetaDBViewWidget.col_keys_wo_desc.index(k)]
for k in self.config_meta_pref['vis_col_key_list']
]
self.configMetaDBViewWidget.on_column_selection_change(
config_meta_vis_col_name_list, force_visibility_update=True)
# Make connection
self.connect(self.lineEdit_ref_step_size_1,
SIGNAL('editingFinished()'), self.validate_ref_step_size)
self.connect(self.lineEdit_ref_step_size_2,
SIGNAL('editingFinished()'), self.validate_ref_step_size)
self.connect(self.pushButton_search, SIGNAL('clicked()'),
self.update_search)
self.connect(
self.selectionModel,
SIGNAL(
'currentRowChanged(const QModelIndex &, const QModelIndex &)'),
self.on_selection_change)
self.connect(self.configMetaDBViewWidget, SIGNAL('exportConfigToFile'),
self.exportConfigToFile)
self.connect(self.configMetaDBViewWidget,
SIGNAL('editConfigNameOrDescription'),
self.editConfigNameOrDescription)
def __init__(self, parent):
super(ProjectExecution, self).__init__()
self._parent = parent
grid = QGridLayout(self)
grid.addWidget(QLabel(self.tr("Main File:")), 0, 0)
self.path = QLineEdit()
ui_tools.LineEditButton(
self.path, self.path.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.path.setText(self._parent._item.mainFile)
self.path.setReadOnly(True)
self.btnBrowse = QPushButton(
QIcon(self.style().standardPixmap(self.style().SP_FileIcon)), '')
grid.addWidget(self.path, 0, 1)
grid.addWidget(self.btnBrowse, 0, 2)
# this should be changed, and ALL pythonPath names to
# python_custom_interpreter or something like that. this is NOT the
# PYTHONPATH
self.txtPythonPath = QLineEdit()
self.txtPythonPath.setText(self._parent._item.pythonPath)
self.btnPythonPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Python Custom Interpreter:")), 1, 0)
grid.addWidget(self.txtPythonPath, 1, 1)
grid.addWidget(self.btnPythonPath, 1, 2)
# THIS IS THE MODAFUCKA REAL PYTHONPATH BRO, YEAH !!!
grid.addWidget(QLabel(self.tr("Custom PYTHONPATH:")), 2, 0)
self.PYTHONPATH = QPlainTextEdit() # TODO : better widget
self.PYTHONPATH.setPlainText(self._parent._item.PYTHONPATH)
self.PYTHONPATH.setToolTip(self.tr("One path per line"))
grid.addWidget(self.PYTHONPATH, 2, 1)
# Additional builtins/globals for pyflakes
grid.addWidget(QLabel(self.tr("Additional builtins/globals:")), 3, 0)
self.additional_builtins = QLineEdit()
self.additional_builtins.setText(' '.join(
self._parent._item.additional_builtins))
self.additional_builtins.setToolTip(
self.tr(
"Space-separated list of symbols that will be considered as "
"builtin in every file"))
grid.addWidget(self.additional_builtins, 3, 1)
self.txtPreExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPreExec, self.txtPreExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPreExec.setReadOnly(True)
self.txtPreExec.setText(self._parent._item.preExecScript)
self.btnPreExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Pre-exec Script:")), 4, 0)
grid.addWidget(self.txtPreExec, 4, 1)
grid.addWidget(self.btnPreExec, 4, 2)
self.txtPostExec = QLineEdit()
ui_tools.LineEditButton(
self.txtPostExec, self.txtPostExec.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtPostExec.setReadOnly(True)
self.txtPostExec.setText(self._parent._item.postExecScript)
self.btnPostExec = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Post-exec Script:")), 5, 0)
grid.addWidget(self.txtPostExec, 5, 1)
grid.addWidget(self.btnPostExec, 5, 2)
grid.addItem(
QSpacerItem(5, 10, QSizePolicy.Expanding, QSizePolicy.Expanding),
6, 0)
# Properties
grid.addWidget(QLabel(self.tr("Properties:")), 7, 0)
self.txtParams = QLineEdit()
self.txtParams.setToolTip(
self.tr("Separate the params with commas (ie: help, verbose)"))
self.txtParams.setText(self._parent._item.programParams)
grid.addWidget(QLabel(self.tr("Params (comma separated):")), 8, 0)
grid.addWidget(self.txtParams, 8, 1)
#Widgets for virtualenv properties
self.txtVenvPath = QLineEdit()
ui_tools.LineEditButton(
self.txtVenvPath, self.txtVenvPath.clear,
self.style().standardPixmap(self.style().SP_TrashIcon))
self.txtVenvPath.setText(self._parent._item.venv)
self._dir_completer = QCompleter()
self._dir_completer.setModel(QDirModel(self._dir_completer))
self.txtVenvPath.setCompleter(self._dir_completer)
self.btnVenvPath = QPushButton(QIcon(resources.IMAGES['open']), '')
grid.addWidget(QLabel(self.tr("Virtualenv Folder:")), 9, 0)
grid.addWidget(self.txtVenvPath, 9, 1)
grid.addWidget(self.btnVenvPath, 9, 2)
self.connect(self.btnBrowse, SIGNAL("clicked()"), self.select_file)
self.connect(self.btnPythonPath, SIGNAL("clicked()"),
self._load_python_path)
self.connect(self.btnVenvPath, SIGNAL("clicked()"),
self._load_python_venv)
self.connect(self.btnPreExec, SIGNAL("clicked()"),
self.select_pre_exec_script)
self.connect(self.btnPostExec, SIGNAL("clicked()"),
self.select_post_exec_script)
def setIcon(ti):
ti.icon = QIcon(PWD + '/icon/todo.png')
ti.setIcon(ti.icon)
def __init__(self, parent, resoution=None):
QWidget.__init__(self, parent)
while not isinstance(parent, QDialog):
parent = parent.parent()
self.setObjectName(
"AngleGradientBoxPanel" +
str(len(parent.findChildren(AngleGradientBoxPanel))))
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(sizePolicy)
self.hLayoutBoxPanel = QHBoxLayout(self)
self.hLayoutBoxPanel.setSpacing(0)
self.hLayoutBoxPanel.setContentsMargins(0, 0, 0, 0)
self.hLayoutBoxPanel.setObjectName(("hLayoutBoxPanel"))
self.frameBoxPanel = QFrame(self)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.frameBoxPanel.sizePolicy().hasHeightForWidth())
self.frameBoxPanel.setSizePolicy(sizePolicy)
self.frameBoxPanel.setFrameShape(QFrame.NoFrame)
self.frameBoxPanel.setFrameShadow(QFrame.Raised)
self.frameBoxPanel.setObjectName(("frameBoxPanel"))
self.hLayoutframeBoxPanel = QHBoxLayout(self.frameBoxPanel)
self.hLayoutframeBoxPanel.setSpacing(0)
self.hLayoutframeBoxPanel.setMargin(0)
self.hLayoutframeBoxPanel.setObjectName(("hLayoutframeBoxPanel"))
self.captionLabel = QLabel(self.frameBoxPanel)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.captionLabel.sizePolicy().hasHeightForWidth())
self.captionLabel.setSizePolicy(sizePolicy)
self.captionLabel.setMinimumSize(QSize(200, 0))
self.captionLabel.setMaximumSize(QSize(200, 16777215))
font = QFont()
font.setBold(False)
font.setWeight(50)
self.captionLabel.setFont(font)
self.captionLabel.setObjectName(("captionLabel"))
self.hLayoutframeBoxPanel.addWidget(self.captionLabel)
self.frameBoxPanelIn = QFrame(self.frameBoxPanel)
self.frameBoxPanelIn.setFrameShape(QFrame.StyledPanel)
self.frameBoxPanelIn.setFrameShadow(QFrame.Raised)
self.frameBoxPanelIn.setObjectName(("frameBoxPanelIn"))
self.hLayoutframeBoxPanelIn = QHBoxLayout(self.frameBoxPanelIn)
self.hLayoutframeBoxPanelIn.setSpacing(0)
self.hLayoutframeBoxPanelIn.setMargin(0)
self.hLayoutframeBoxPanelIn.setObjectName(("hLayoutframeBoxPanelIn"))
self.txtDegree = QLineEdit(self.frameBoxPanelIn)
self.txtDegree.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.txtDegree.setFont(font)
self.txtDegree.setObjectName(self.objectName() + "_txtDegree")
self.txtDegree.setText("0.0")
self.txtDegree.setMinimumWidth(70)
self.txtDegree.setMaximumWidth(70)
self.hLayoutframeBoxPanelIn.addWidget(self.txtDegree)
self.labelDegree = QLabel(self.frameBoxPanelIn)
self.labelDegree.setObjectName(("labelDegree"))
self.labelDegree.setText(" " + define._degreeStr + " ")
self.hLayoutframeBoxPanelIn.addWidget(self.labelDegree)
self.txtPercent = QLineEdit(self.frameBoxPanelIn)
self.txtPercent.setEnabled(True)
font = QFont()
font.setBold(False)
font.setWeight(50)
self.txtPercent.setFont(font)
self.txtPercent.setObjectName(self.objectName() + "_txtPercent")
self.txtPercent.setText("0.0")
self.txtPercent.setMinimumWidth(70)
self.txtPercent.setMaximumWidth(70)
self.hLayoutframeBoxPanelIn.addWidget(self.txtPercent)
self.labelPercent = QLabel(self.frameBoxPanelIn)
self.labelPercent.setObjectName(("labelPercent"))
self.labelPercent.setText(" %")
self.hLayoutframeBoxPanelIn.addWidget(self.labelPercent)
self.hLayoutframeBoxPanel.addWidget(self.frameBoxPanelIn)
# self.angleGradientBox = QLineEdit(self.frameBoxPanel)
# self.angleGradientBox.setEnabled(True)
# font = QFont()
# font.setBold(False)
# font.setWeight(50)
# self.angleGradientBox.setFont(font)
# self.angleGradientBox.setObjectName(("angleGradientBox"))
# self.angleGradientBox.setText("0.0")
# self.angleGradientBox.setMinimumWidth(70)
# self.angleGradientBox.setMaximumWidth(70)
# self.hLayoutframeBoxPanel.addWidget(self.angleGradientBox)
self.imageButton = QPushButton(self.frameBoxPanel)
self.imageButton.setText((""))
icon = QIcon()
icon.addPixmap(QPixmap(("Resource/convex_hull.png")), QIcon.Normal,
QIcon.Off)
self.imageButton.setIcon(icon)
self.imageButton.setObjectName(("imageButton"))
self.imageButton.setVisible(False)
self.hLayoutframeBoxPanel.addWidget(self.imageButton)
self.hLayoutBoxPanel.addWidget(self.frameBoxPanel)
spacerItem = QSpacerItem(0, 0, QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hLayoutBoxPanel.addItem(spacerItem)
self.txtDegree.textChanged.connect(self.txtDegreeChanged)
self.txtPercent.textChanged.connect(self.txtPercentChanged)
self.imageButton.clicked.connect(self.imageButtonClicked)
self.numberResolution = resoution
str0 = String.Number2String(6.6788, "0.00000")
self.captionUnits = ""
self.hidePercentBox()
self.flag = 0
