Esempio n. 1
0
    def _populate_datasets_tree(self):
        """
        Initialize the tree widget of datasets and volumes.
        """
        self._data_treewidget.clear()

        if self._repos_info is None:
            return

        for dset_uuid, dset_info in sorted(self._repos_info.items()):
            dset_item = QTreeWidgetItem(self._data_treewidget,
                                        QStringList(dset_uuid))
            dset_item.setData(0, Qt.UserRole, (dset_uuid, ""))
            for data_name in dset_info["DataInstances"].keys():
                data_item = QTreeWidgetItem(dset_item, QStringList(data_name))
                data_item.setData(0, Qt.UserRole, (dset_uuid, data_name))
                if self._mode == 'specify_new':
                    # If we're in specify_new mode, only the dataset parent items are selectable.
                    flags = data_item.flags()
                    flags &= ~Qt.ItemIsSelectable
                    flags &= ~Qt.ItemIsEnabled
                    data_item.setFlags(flags)

        # Expand everything
        self._data_treewidget.expandAll()

        # Select the first item by default.
        if self._mode == "select_existing":
            first_item = self._data_treewidget.topLevelItem(0).child(0)
        else:
            first_item = self._data_treewidget.topLevelItem(0)
        self._data_treewidget.setCurrentItem(first_item, 0)
    def __init__(self, methodName):
        """Run once on class initialisation."""
        unittest.TestCase.__init__(self, methodName)
        myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
        rasterFileInfo = QFileInfo(myPath)
        mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(),
                                      rasterFileInfo.completeBaseName())
        rasterRenderer = QgsMultiBandColorRenderer(
            mRasterLayer.dataProvider(), 2, 3, 4)
        mRasterLayer.setRenderer(rasterRenderer)
        #pipe = mRasterLayer.pipe()
        #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer'
        QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer])

        # create composition with composer map
        self.mMapRenderer = QgsMapRenderer()
        layerStringList = QStringList()
        layerStringList.append(mRasterLayer.id())
        self.mMapRenderer.setLayerSet(layerStringList)
        self.mMapRenderer.setProjectionsEnabled(False)
        self.mComposition = QgsComposition(self.mMapRenderer)
        self.mComposition.setPaperSize(297, 210)
        self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100)
        self.mComposerMap.setFrameEnabled(True)
        self.mComposition.addComposerMap(self.mComposerMap)
Esempio n. 3
0
 def __init__(self, parent=None):
     """
     Constructor
     """
     QDialog.__init__(self, parent)
     self.setupUi(self)
     self.parent = parent
     self.pxSchedTbl = parent.pxCurSelGaInOsObj
     self.setWindowTitle("Configure Schedule Table <%s>" %
                         (self.pxSchedTbl.xScheduleTableName))
     self.vDisableAllTab()
     self.pxCurSelEp = None
     self.pxCurSelEpSubIndex = -1
     self.pxCurSelTreeItem = None
     #根据table 刷新界面树,初始化
     index = 0
     for ep in self.pxSchedTbl.xSchedTblEpList:
         defaultName = QString('Expiry Point %s(%s)' % (index, ep[0]))
         pxTreeIlem = QTreeWidgetItem(self.trSchedTable,
                                      QStringList(defaultName))
         self.trSchedTable.addTopLevelItem(pxTreeIlem)
         index += 1
         for epsub in ep[1]:
             defaultName = QString(epsub)
             pxTreeIlem2 = QTreeWidgetItem(None, QStringList(defaultName))
             pxTreeIlem.addChild(pxTreeIlem2)
             pxTreeIlem.setExpanded(True)
     #刷新基本控件
     self.cbxSchedTblRepeatable.setChecked(
         self.pxSchedTbl.xSchedTblRepeatable)
     self.cbxSchedTblAutostartable.setChecked(
         self.pxSchedTbl.xSchedTblAutostartable)
     self.cmbxSchedTblAutoStartType.setCurrentIndex(
         self.vDoGetAutostartType())
     self.cmbxSchedTblSyncStrategy.setCurrentIndex(
         self.vDoGetSyncStrategy())
     self.spbxSchedTblAbsRel.setValue(self.pxSchedTbl.xSchedTblAbsRelValue)
     self.spbxSchedTblFinalDelay.setValue(
         self.pxSchedTbl.xSchedTblFinalDelay)
     self.spbxSchedTblMaxAdvance.setValue(
         self.pxSchedTbl.xSchedTblMaxAdvance)
     self.spbxSchedTblMaxRetard.setValue(self.pxSchedTbl.xSchedTblMaxRetard)
     self.spbxSchedTblPrecision.setValue(
         self.pxSchedTbl.xSchedTblExplicitPrecision)
     index = -1
     i = 0
     for cnt in self.parent.pxGaInOSCounterCfgList:
         name = cnt.xCounterName
         self.cmbxSchedTblDrivingCounter.addItem(name)
         if (self.pxSchedTbl.xSchedTblDrivingCounter == name):
             index = i
         i += 1
     #模拟一次点击刷新控件
     self.on_cbxSchedTblAutostartable_clicked(
         self.pxSchedTbl.xSchedTblAutostartable)
     #初始化控件
     self.btnAdd.setText("Add Expiry Point")
     self.btnAdd.setDisabled(False)
     self.btnInsert.setDisabled(True)
     self.btnDelete.setDisabled(True)
Esempio n. 4
0
 def get_string_list(self, column):
     """Returns a column as a QStringList"""
     tempList = QStringList()
     result = QtSql.QSqlQuery('''SELECT DISTINCT %s FROM presentations''' % column)
     while result.next():
         tempList.append(result.value(0).toString())
     return tempList
Esempio n. 5
0
    def set_root_folder(self, root_folder):
        self.tree.clear()
        self.clear_all_load_animations()
        
        if self.root_folder != None:
            del self.root_folder
        self.root_folder = root_folder

        # Add root
        columns = QStringList()
        columns.append(root_folder.get_name())
        columns.append(root_folder.get_size())
        root_item = QTreeWidgetItem(columns)

        self.set_icon(root_folder.mime_type, root_item)
        
        self.tree.addTopLevelItem(root_item)
        root_item.setExpanded(True)
        root_folder.tree_item = root_item

        self.generate_children(root_folder)
        self.add_loading_widgets(root_folder)

        self.tree.setCurrentItem(root_item)
        self.start_load_anim(root_folder)
        
        self.tree.header().resizeSections(QHeaderView.ResizeToContents)
Esempio n. 6
0
	def __init__(self, parent=None, TreeFileName=DefaultTreeFileName):
		QTreeWidget.__init__(self, parent)
		self.parent = parent
		self.setGeometry(0,0, self.parent.width(), self.parent.height())
		self.setColumnCount(2)
		self.setColumnWidth(0,270)
		#self.header().setStretchLastSection(False)
		#self.resizeColumnToContents(1)
		headerTitles = QStringList()
		headerTitles.append(QString("Parameter"))
		headerTitles.append(QString("Value"))
		self.setHeaderLabels(headerTitles)
		self.setEditTriggers(QTreeWidget.DoubleClicked|QTreeWidget.EditKeyPressed)
		self.rootItems = []
		self.currentItemChanged.connect(self.visit)
		self.itemDoubleClicked.connect(self.edit_)
		self.editing = None
		self.expandAll()
		self.ScenarioName = ''
		self.NodeDescriptions = dict()  # textual parameter descriptions
		self.ParamScenario = dict()  # name of corresponding scenario for parameters
		self.changed = False
		self.ApplicationPath = ''
		self.TreeFileName = TreeFileName
		self.RunCfgFileName = DefaultCfgFileName
		self.load()
		self.parent.setWindowTitle(self.NodeValue('Title').replace('_',' ') + ' ' + DefaultTtitle)
Esempio n. 7
0
    def __init__(self, methodName):
        """Run once on class initialisation."""
        unittest.TestCase.__init__(self, methodName)
        myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
        rasterFileInfo = QFileInfo(myPath)
        mRasterLayer = QgsRasterLayer(rasterFileInfo.filePath(),
                                      rasterFileInfo.completeBaseName())
        rasterRenderer = QgsMultiBandColorRenderer(
            mRasterLayer.dataProvider(), 2, 3, 4)
        mRasterLayer.setRenderer(rasterRenderer)
        #pipe = mRasterLayer.pipe()
        #assert pipe.set(rasterRenderer), 'Cannot set pipe renderer'
        QgsMapLayerRegistry.instance().addMapLayers([mRasterLayer])

        # create composition with composer map
        self.mMapRenderer = QgsMapRenderer()
        layerStringList = QStringList()
        layerStringList.append(mRasterLayer.id())
        self.mMapRenderer.setLayerSet(layerStringList)
        self.mMapRenderer.setProjectionsEnabled(False)
        self.mComposition = QgsComposition(self.mMapRenderer)
        self.mComposition.setPaperSize(297, 210)
        self.mComposerMap = QgsComposerMap(self.mComposition, 20, 20, 200, 100)
        self.mComposerMap.setFrameEnabled(True)
        self.mComposition.addComposerMap(self.mComposerMap)
Esempio n. 8
0
    def update_autocomplete_fields(self):
        self.titleList = QStringList(self.db.get_string_list("Title"))
        self.speakerList = QStringList(self.db.get_string_list("Speaker"))
        self.categoryList = QStringList(self.db.get_string_list("Category"))
        self.eventList = QStringList(self.db.get_string_list("Event"))
        self.roomList = QStringList(self.db.get_string_list("Room"))

        self.titleCompleter = QCompleter(self.titleList)
        self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.speakerCompleter = QCompleter(self.speakerList)
        self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.categoryCompleter = QCompleter(self.categoryList)
        self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.eventCompleter = QCompleter(self.eventList)
        self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive)
        self.roomCompleter = QCompleter(self.roomList)
        self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive)

        self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter)
        self.talkDetailsWidget.presenterLineEdit.setCompleter(
            self.speakerCompleter)
        self.talkDetailsWidget.categoryLineEdit.setCompleter(
            self.categoryCompleter)
        self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter)
        self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter)
Esempio n. 9
0
 def get_string_list(self, column):
     """Returns a column as a QStringList"""
     tempList = QStringList()
     result = QtSql.QSqlQuery('''SELECT DISTINCT %s FROM presentations''' % column)
     while result.next():
         tempList.append(result.value(0).toString())
     return tempList
Esempio n. 10
0
 def _nameList(self, filt=None, without=None, upto=None):
     # need to search all tables for a string list of object names
     # filt is a ModuleBase subclass to filter by
     # without is a row number to exclude from the current table
     # upto means only look at objects up to "upto" row in the current table
     if (filt, without, upto) in self._cachedNameList:
         timestamp, sl = self._cachedNameList[(filt, without, upto)]
         if self._parent.lastModified() < timestamp:
             return sl
     sl = QStringList()
     for name in self._parent.getTableNames():
         table = self._parent._tables[name]
         # if we have a filter, then make sure this table is a subclass of it
         if filt is not None and not issubclass(table.ob, filt):
             # if we are only going up to a certain table and this is it
             if table == self and upto is not None:
                 return sl
             continue
         for i, trow in enumerate(table.rows):
             if table == self:
                 # if the current table is self, make sure we are excluding
                 # the without row
                 if without is not None and without == i:
                     continue
                 # make sure we only go up to upto
                 if upto is not None and upto == i:
                     return sl
             # add a non-null name, which is not commented out to the list
             if not trow[2].isNull() and not \
                     (not trow[0].isNull() and trow[0].toBool() == True):
                 sl.append(trow[2].toString())
     # store the cached value
     self._cachedNameList[(filt, without, upto)] = (time.time(), sl)
     return sl
Esempio n. 11
0
    def __saveScreenshot(self):
        format = "png"
        initialPath = QDesktopServices.storageLocation(
            QDesktopServices.PicturesLocation)
        # initialPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
        if initialPath.isEmpty():
            initialPath = QDir.currentPath()
        initialPath += "/untitled." + format

        fileDialog = QtGui.QFileDialog(self, u"存储为", initialPath)
        fileDialog.setAcceptMode(QtGui.QFileDialog.AcceptSave)
        fileDialog.setFileMode(QtGui.QFileDialog.AnyFile)
        fileDialog.setDirectory(initialPath)
        mimeTypes = QStringList()

        for bf in QImageWriter.supportedImageFormats():
            mimeTypes.append(QLatin1String(bf))

        # fileDialog.setMin setMimeTypeFilters(mimeTypes)
        # fileDialog.selectMimeTypeFilter("image/" + format);
        fileDialog.setDefaultSuffix(format)
        if fileDialog.accept():
            return

        fileName = fileDialog.selectedFiles().first()

        if not self.originalPixmap.save(fileName):
            QtGui.QMessageBox.Warning(
                self, u"保存错误",
                u"图像无法存储到 \"%s\"." % str(QDir.toNativeSeparators(fileName)))
Esempio n. 12
0
    def onSelectFolder(self):

        Fdialog = QFileDialog()
        Fdialog.setFileMode(QFileDialog.DirectoryOnly)
        if Fdialog.exec_():
            folderPath = QStringList(Fdialog.selectedFiles())
            self.ui.dirEdit.setText(folderPath.takeFirst())
Esempio n. 13
0
 def __init__(self):
     # Nothing loaded yet
     self.altTag = QString()
     self.altDict = None
     self.mainTag = QString()
     self.mainDict = None
     # Tags of any not-found dicts so we only give one diagnostic per dict
     self.errTags = set()
     # Populate our list of available dictionaries by finding
     # all the file-pairs of the form <tag>.dic and <tag>.aff in the
     # folder whose path is saved by ppqt in IMC.dictPath.
     # Save the dict tags in the string list self.listOfDicts.
     self.listOfDicts = QStringList()
     # Get a list of all files in that folder. We don't need to sort them,
     # we use the "in" operator to find the X.dic matching an X.aff
     # Defensive programming: dict folder should exist but maybe the user
     # moved stuff.
     try:
         fnames = os.listdir(IMC.dictPath)
     except OSError:
         fnames = []  # no dict folder?!
     for fn in fnames:
         if u'.aff' == fn[-4:]:
             # this is a tag.aff file, look for a matching tag.dic
             dn = fn[:-4]
             if (dn + u'.dic') in fnames:
                 self.listOfDicts.append(QString(dn))
     # Initialize our main dictionary to the one last-chosen by the user
     # with a default of en_US. The current main dict is saved in the
     # settings during the terminate() method below.
     deftag = IMC.settings.value(u"main/spellDictTag",
                                 QString(u"en_US")).toString()
     # Try to load the main dictionary. Sets self.mainDict/.mainTag.
     self.setMainDict(deftag)
 def __init__(self):
     """
     Constructor
     """
     ConfigurationPageBase.__init__(self)
     self.setupUi(self)
     self.setObjectName("EditorKeywordsPage")
     
     # set initial values
     self.__keywords = {
         "": QStringList(["", "", "", "", "", "", "", "", "", ""])
     }
     languages = [''] + QScintilla.Lexers.getSupportedLanguages().keys()
     languages.sort()
     for lang in languages:
         if lang:
             lex = QScintilla.Lexers.getLexer(lang)
             if isinstance(lex, LexerContainer):
                 continue
             keywords = Preferences.getEditorKeywords(lang)[:]
             if keywords.isEmpty():
                 keywords = QStringList("")
                 for kwSet in range(1, 10):
                     kw = lex.keywords(kwSet)
                     if kw is None:
                         kw = ""
                     keywords.append(kw)
             self.__keywords[lang] = keywords
         self.languageCombo.addItem(lang)
     
     self.currentLanguage = QString()
     self.currentSet = 1
     self.on_languageCombo_activated(self.currentLanguage)
Esempio n. 15
0
 def _nameList(self, filt = None, without = None, upto = None):
     # need to search all tables for a string list of object names
     # filt is a ModuleBase subclass to filter by
     # without is a row number to exclude from the current table
     # upto means only look at objects up to "upto" row in the current table
     if (filt, without, upto) in self._cachedNameList:
         timestamp, sl = self._cachedNameList[(filt, without, upto)]
         if self._parent.lastModified() < timestamp:
             return sl
     sl = QStringList()
     for name in self._parent.getTableNames():
         table = self._parent._tables[name]
         # if we have a filter, then make sure this table is a subclass of it
         if filt is not None and not issubclass(table.ob, filt):
             # if we are only going up to a certain table and this is it
             if table == self and upto is not None:
                 return sl
             continue
         for i,trow in enumerate(table.rows):
             if table == self:
                 # if the current table is self, make sure we are excluding
                 # the without row
                 if without is not None and without == i:
                     continue
                 # make sure we only go up to upto
                 if upto is not None and upto == i:
                     return sl
             # add a non-null name, which is not commented out to the list
             if not trow[2].isNull() and not \
                     (not trow[0].isNull() and trow[0].toBool() == True):
                 sl.append(trow[2].toString())
     # store the cached value
     self._cachedNameList[(filt, without, upto)] = (time.time(), sl)
     return sl
Esempio n. 16
0
 def on_addInstalledApiFileButton_clicked(self):
     """
     Private slot to add an API file from the list of installed API files
     for the selected lexer language.
     """
     installedAPIFiles = self.__currentAPI.installedAPIFiles()
     if len(installedAPIFiles) > 0:
         installedAPIFilesPath = QFileInfo(installedAPIFiles[0]).path()
         installedAPIFilesShort = QStringList()
         for installedAPIFile in installedAPIFiles:
             installedAPIFilesShort.append(QFileInfo(installedAPIFile).fileName())
         file, ok = KQInputDialog.getItem(
             self,
             self.trUtf8("Add from installed APIs"),
             self.trUtf8("Select from the list of installed API files"),
             installedAPIFilesShort,
             0,
             False,
         )
         if ok:
             self.apiList.addItem(
                 Utilities.toNativeSeparators(QFileInfo(QDir(installedAPIFilesPath), file).absoluteFilePath())
             )
     else:
         KQMessageBox.warning(
             self,
             self.trUtf8("Add from installed APIs"),
             self.trUtf8("""There are no APIs installed yet.""" """ Selection is not available."""),
         )
         self.addInstalledApiFileButton.setEnabled(False)
Esempio n. 17
0
 def list(self):
     q = QSqlQueryModel()
     q.setQuery("SELECT name FROM platform")
     strlist = QStringList()
     strlist.append(u"全部")
     for i in range(q.rowCount()):
         strlist.append(q.record(i).value(0).toString())
     return strlist
Esempio n. 18
0
 def save(self):
     """
     Public slot to save the Icons configuration.
     """
     dirList = QStringList()
     for i in range(self.iconDirectoryList.count()):
         dirList.append(self.iconDirectoryList.item(i).text())
     Preferences.setIcons("Path", dirList)
Esempio n. 19
0
    def getThemeList(self):

        dir = QDir("/usr/share/enlightenment/data/themes")
        dir.setFilter( QDir.NoSymLinks | QDir.Files )
        a = QStringList()
        a.append("*.edj")
        dir.setNameFilters(a)
        return dir.entryList()
Esempio n. 20
0
 def set_devlist(self, devlist, isWIN32):
     qslist = QStringList()
     if isWIN32:
         for dev in devlist:
             qslist.append(QString(dev.description))
     else:
         for dev in self.capturer.devlist:
             qslist.append(QString(dev.name))
     self.devComboBox.addItems(qslist)
Esempio n. 21
0
def buildQStringList(items):
    """
	@rtype: QStringList
	"""
    returnData = QStringList()
    for item in items:
        returnData.append(item)

    return returnData
Esempio n. 22
0
def buildQStringList(items):
	"""
	@rtype: QStringList
	"""
	returnData = QStringList()
	for item in items:
		returnData.append(item)

	return returnData
Esempio n. 23
0
 def reloadTreeChannel(self, index, list):
     tree=self.trJ1939Tp.topLevelItem(index);
     for index in range(0, tree.childCount()):
         temp=tree.takeChild(0);
         del temp;
     for obj in list:
         item=QTreeWidgetItem(tree,QStringList(obj.name));
         for obj2 in obj.PgsList:
             item2 = QTreeWidgetItem(item,QStringList(obj2.name));
Esempio n. 24
0
 def addRxChannel(self):
     id = len(self.cfg.rxChannelList)
     name = QString('vRxChannel%s' % (id))
     item = QTreeWidgetItem(self.curtree, QStringList(name))
     obj = J1939TpChannel(name)
     self.cfg.rxChannelList.append(obj)
     obj.PgsList.append(J1939TpPgs('vRxPg0'))
     QTreeWidgetItem(item, QStringList('vRxPg0'))
     self.curtree.setExpanded(True)
Esempio n. 25
0
 def addTxChannel(self):
     id = len(self.cfg.txChannelList);
     name=QString('vTxChannel%s'%(id));
     item=QTreeWidgetItem(self.curtree,QStringList(name));
     obj = J1939TpChannel(name);
     self.cfg.txChannelList.append(obj);
     obj.PgsList.append(J1939TpPgs('vTxPg0'));
     QTreeWidgetItem(item,QStringList('vTxPg0'));
     self.curtree.setExpanded(True);
Esempio n. 26
0
class StringListModel(QAbstractListModel):
    def __init__(self, stringList, parent=None):
        super(StringListModel, self).__init__(parent)
        self.stringList = QStringList(stringList)

    # int rowCount(const QModelIndex &parent = QModelIndex()) const;
    # QVariant data(const QModelIndex &index, int role) const;
    # QVariant headerData(int section, Qt::Orientation orientation,
    #                     int role = Qt::DisplayRole) const;
    # 编辑功能用到的两个函数
    # Qt::ItemFlags flags(const QModelIndex &index) const;
    # bool setData(const QModelIndex &index, const QVariant &value,
    #              int role = Qt::EditRole);

    def rowCount(self, parent=None, *args, **kwargs):
        return self.stringList.count()

    def data(self, index, role=Qt.DisplayRole):

        if (not index.isValid()):
            return QVariant()

        if (index.row() >= self.stringList.count):
            return QVariant()

        if (role == Qt.DisplayRole or role == Qt.EditRole):
            return self.stringList[index.row()]
        else:
            return QVariant()

    def headerData(self, section, orientation, role=Qt.DisplayRole):

        if (role != Qt.DisplayRole):
            return QVariant()

        if (orientation == Qt.Horizontal):
            return QString("Column %1").arg(section)
        else:
            return QString("Row %1").arg(section)

    # 以下是实现编辑功能添加的两个函数
    def flags(self, index):

        if (not index.isValid()):
            return Qt.ItemIsEnabled

        return super(StringListModel, self).flags(index) | Qt.ItemIsEditable

    def setData(self, index, value, role=Qt.DisplayRole):

        if (index.isValid() and role == Qt.EditRole):

            self.stringList.replace(index.row(), value.toString())
            self.emit(SIGNAL("dataChanged(QModelIndex,QModelIndex)"), index,
                      index)
            return True
        return False
Esempio n. 27
0
def fieldNames(layer):
    fields = layer.dataProvider().fields()

    if QGis.QGIS_VERSION_INT < 10900:
        from PyQt4.QtCore import QStringList
        fieldNames = QStringList()
        for field in fields.values():
            fieldNames.append(field.name())
    else:
        return map(lambda field: field.name(), fields)
Esempio n. 28
0
 def __editorGetApisFromApiList(self):
     """
     Private slot to retrieve the api filenames from the list.
     
     @return list of api filenames (QStringList)
     """
     apis = QStringList()
     for row in range(self.apiList.count()):
         apis.append(self.apiList.item(row).text())
     return apis
Esempio n. 29
0
 def reloadGui(self):
     tree = self.trSchedTable.topLevelItem(0)
     for tbl in self.cfg.table:
         item = QTreeWidgetItem(
             tree, QStringList('Expiry Point(offset = %s)' % (tbl.offset)))
         tree.addChild(item)
         for action in tbl.actionList:
             item2 = QTreeWidgetItem(item, QStringList(action))
             item.addChild(item2)
         item.setExpanded(True)
     tree.setExpanded(True)
 def __extractFileFilters(self):
     """
     Private method to extract the file filters.
     """
     filters = QStringList()
     for row in range(self.fileFiltersList.count()):
         filters.append(self.fileFiltersList.item(row).text())
     if self.__showsOpenFilters:
         self.openFileFilters = filters
     else:
         self.saveFileFilters = filters
Esempio n. 31
0
 def reloadCtrlGui(self):
     tree=self.trCanCfg.topLevelItem(1);
     for index in range(0, tree.childCount()):
         temp=tree.takeChild(0);
         del temp;
     for obj in self.cfg.CanCtrlList:
         item=QTreeWidgetItem(tree,QStringList(obj.name));
         tree.addChild(item);
         for hoh in obj.hohList:
             item2=QTreeWidgetItem(item,QStringList(hoh.name));
             item.addChild(item2);
Esempio n. 32
0
 def reloadTaskGui(self):
     tree = self.trModule.topLevelItem(1)
     for index in range(0, tree.childCount()):
         temp = tree.takeChild(0)
         del temp
     for obj in self.cfg.taskList:
         item = QTreeWidgetItem(tree, QStringList(obj.name))
         tree.addChild(item)
         for ent in obj.eventList:
             item2 = QTreeWidgetItem(item, QStringList(ent.name))
             item.addChild(item2)
Esempio n. 33
0
	def mimeTypes(self):
		"""
		Reimplements the :meth:`QAbstractItemModel.mimeTypes` method.
		
		:return: Mime types.
		:rtype: QStringList
		"""

		types = QStringList()
		types.append("application/x-umbragraphmodeldatalist")
		return types
Esempio n. 34
0
    def detailsButtonClicked(self):
        changedList = QStringList()
        (install, remove, unauthenticated) = self._deb.required_changes
        for i in install:
            changedList.append(_("To be installed: %s") % i)
        for r in remove:
            changedList.append(_("To be removed: %s") % r)

        KMessageBox.informationList(
            self,
            _("<b>To install the following changes are required:</b>"),
            changedList, _("Details"))
Esempio n. 35
0
 def __init__(self, dataSource, columns, logger):
     super(TableModelBase, self).__init__()
     self.dataSource = dataSource
     self.columns = columns
     self.logger = logger
     if self.columns != None:
         self.setColumnCount(len(self.columns))
         stringList = QStringList()
         for colName, _ in self.columns:
             stringList.append(colName)
         self.setHorizontalHeaderLabels(stringList)
     self.keys = []
Esempio n. 36
0
def select_git_directory():
    settings = QSettings("majerti", "gitbuster")
    settings.beginGroup("Last run")

    filepath = '/'
    last_directory = settings.value("directory", QVariant(QDir.homePath()))
    dirs_list = settings.value("recent directories",
                               QStringList()).toStringList()
    custom_entries = settings.value("custom entries",
                                    QStringList()).toStringList()

    recent_dirs_urls = [QUrl.fromLocalFile(dir) for dir in dirs_list]
    home_url = QUrl.fromLocalFile(QDir.homePath())
    custom_entries_urls = [QUrl.fromLocalFile(dir) for dir in custom_entries]

    while not is_top_git_directory(unicode(filepath)):
        file_dialog = QFileDialog(None, "Open git repository",
                                  last_directory.toString())
        file_dialog.setFileMode(QFileDialog.Directory)
        file_dialog.setOptions(QFileDialog.ShowDirsOnly)
        if recent_dirs_urls:
            file_dialog.setSidebarUrls(
                [home_url,] +
                custom_entries_urls +
                recent_dirs_urls[-6:]
            )
        ret = file_dialog.exec_()

        custom_entries = QStringList()
        custom_entries_urls = []
        for url in file_dialog.sidebarUrls():
            if url not in recent_dirs_urls and url != home_url:
                custom_entries.append(QString(url.path()))
                custom_entries_urls.append(url)
        settings.setValue("custom entries", custom_entries)

        if ret:
            filepath = file_dialog.selectedFiles()[0]
        else:
            return ret

        if not filepath:
            return filepath

    if not dirs_list.contains(filepath):
        dirs_list.append(filepath)
        settings.setValue("recent directories", dirs_list)

    settings.setValue("directory", filepath)
    settings.endGroup()
    settings.sync()

    return unicode(filepath)
Esempio n. 37
0
 def addApp(self):
     """ popup to add a show"""
     listsuggest = self.nextep.getSuggestions()
     listsug = QStringList()
     for i in listsuggest:
         listsug.append(i[0])
     (tvshow, isok) = QtGui.QInputDialog.getItem (self.parent, \
                   "add a tv show", 'Which show do you want to track?', \
                   listsug, editable = True)
     if (isok and tvshow):
         self.parent.nextep.addShow(str(tvshow))
         print "should add", tvshow, " :p"
Esempio n. 38
0
    def __init__(self, cmdline, parent=None):
        super(CmdProc, self).__init__(parent)
        self.cmdline = cmdline
        self.abortbyuser = False
        self.rawoutput = QStringList()

        self._proc = proc = QProcess(self)
        proc.started.connect(self.started)
        proc.finished.connect(self._finished)
        proc.readyReadStandardOutput.connect(self._stdout)
        proc.readyReadStandardError.connect(self._stderr)
        proc.error.connect(self._handleerror)
    def testPrintMapFromTemplate(self):
        """Test that we can get a map to render in the template."""
        myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
        myFileInfo = QFileInfo(myPath)
        myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
                                       myFileInfo.completeBaseName())
        myRenderer = QgsMultiBandColorRenderer(
                        myRasterLayer.dataProvider(), 2, 3, 4)
        #mRasterLayer.setRenderer( rasterRenderer )
        myPipe = myRasterLayer.pipe()
        assert myPipe.set( myRenderer ), "Cannot set pipe renderer"

        QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])

        myMapRenderer = QgsMapRenderer()
        myLayerStringList = QStringList()
        myLayerStringList.append(myRasterLayer.id())
        myMapRenderer.setLayerSet(myLayerStringList)
        myMapRenderer.setProjectionsEnabled(False)

        myComposition = QgsComposition(myMapRenderer)
        myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
        myTemplateFile = file(myFile, 'rt')
        myTemplateContent = myTemplateFile.read()
        myTemplateFile.close()
        myDocument = QDomDocument()
        myDocument.setContent(myTemplateContent)
        myComposition.loadFromTemplate(myDocument)

        # now render the map, first zooming to the raster extents
        myMap = myComposition.getComposerMapById(0)
        myMessage = ('Map 0 could not be found in template %s', myFile)
        assert myMap is not None, myMessage

        myExtent = myRasterLayer.extent()
        myMap.setNewExtent(myExtent)

        myImagePath = os.path.join(str(QDir.tempPath()),
                                   'template_map_render_python.png')

        myPageNumber = 0
        myImage = myComposition.printPageAsRaster(myPageNumber)
        myImage.save(myImagePath)
        assert os.path.exists(myImagePath), 'Map render was not created.'

        # Not sure if this is a predictable way to test but its quicker than
        # rendering.
        myFileSize = QFileInfo(myImagePath).size()
        myExpectedFileSize = 100000
        myMessage = ('Expected file size to be greater than %s, got %s'
                     ' for %s' %
                     (myExpectedFileSize, myFileSize, myImagePath))
        assert myFileSize > myExpectedFileSize, myMessage
Esempio n. 40
0
 def _load_file_symbols(self):
     item = self.currentItem()
     module = introspection.load_module(item.path, str(item.text(0)[:-3]))
     for class_info in introspection.get_classes_and_methods(module):
         class_item = ItemTree(item, QStringList(class_info['name']),
                               item.path)
         class_item.setToolTip(0, class_info['name'])
         for method_info in class_info['methods']:
             method_item = ItemTree(class_item,
                                    QStringList(method_info['name']),
                                    item.path)
             method_item.setToolTip(0, method_info['name'])
Esempio n. 41
0
    def path_from_index(self, index):
        """ Reimplemented. Finds part of a path given the index of
        the last part required.

        """
        data_list = QStringList()
        while index.isValid():
            data_list.prepend(self.model().data(index).toString())
            index = index.parent()
        ret = data_list.join("/")
        print "path from index: %s" % (data_list.join(" :: "))
        return ret
Esempio n. 42
0
    def testPrintMapFromTemplate(self):
        """Test that we can get a map to render in the template."""
        myPath = os.path.join(TEST_DATA_DIR, 'landsat.tif')
        myFileInfo = QFileInfo(myPath)
        myRasterLayer = QgsRasterLayer(myFileInfo.filePath(),
                                       myFileInfo.completeBaseName())
        myRenderer = QgsMultiBandColorRenderer(myRasterLayer.dataProvider(), 2,
                                               3, 4)
        #mRasterLayer.setRenderer( rasterRenderer )
        myPipe = myRasterLayer.pipe()
        assert myPipe.set(myRenderer), "Cannot set pipe renderer"

        QgsMapLayerRegistry.instance().addMapLayers([myRasterLayer])

        myMapRenderer = QgsMapRenderer()
        myLayerStringList = QStringList()
        myLayerStringList.append(myRasterLayer.id())
        myMapRenderer.setLayerSet(myLayerStringList)
        myMapRenderer.setProjectionsEnabled(False)

        myComposition = QgsComposition(myMapRenderer)
        myFile = os.path.join(TEST_DATA_DIR, 'template-for-substitution.qpt')
        myTemplateFile = file(myFile, 'rt')
        myTemplateContent = myTemplateFile.read()
        myTemplateFile.close()
        myDocument = QDomDocument()
        myDocument.setContent(myTemplateContent)
        myComposition.loadFromTemplate(myDocument)

        # now render the map, first zooming to the raster extents
        myMap = myComposition.getComposerMapById(0)
        myMessage = ('Map 0 could not be found in template %s', myFile)
        assert myMap is not None, myMessage

        myExtent = myRasterLayer.extent()
        myMap.setNewExtent(myExtent)

        myImagePath = os.path.join(str(QDir.tempPath()),
                                   'template_map_render_python.png')

        myPageNumber = 0
        myImage = myComposition.printPageAsRaster(myPageNumber)
        myImage.save(myImagePath)
        assert os.path.exists(myImagePath), 'Map render was not created.'

        # Not sure if this is a predictable way to test but its quicker than
        # rendering.
        myFileSize = QFileInfo(myImagePath).size()
        myExpectedFileSize = 100000
        myMessage = ('Expected file size to be greater than %s, got %s'
                     ' for %s' % (myExpectedFileSize, myFileSize, myImagePath))
        assert myFileSize > myExpectedFileSize, myMessage
Esempio n. 43
0
    def __init__(self):
        super(AddNewWord, self).__init__(None)

        self.setWindowTitle("AddNewWord")

        completer = QCompleter(self)
        self.string_list_model = QStringListModel(self)
        completer.setCaseSensitivity(Qt.CaseInsensitive)
        completer.setModel(self.string_list_model)
        self.setCompleter(completer)
        self.connect(self, SIGNAL("editingFinished()"), self.editComplete)

        self.word_list = QStringList()
Esempio n. 44
0
 def vDoRefreshtrInResAssignedAndAvailableTask(self):
     self.trInResAssignedTask.clear()
     self.trInResAvailableTask.clear()
     for tsk in self.pxGaInOSTaskCfgList:
         name = QString('%s' % (tsk.xTaskName))
         if (tsk.xTaskWithInRes == False):
             pxTreeIlem = QTreeWidgetItem(self.trInResAvailableTask,
                                          QStringList(name))
             self.trInResAvailableTask.addTopLevelItem(pxTreeIlem)
         elif (tsk.xTaskInResName == self.pxCurSelGaInOsObj.xInResName):
             pxTreeIlem = QTreeWidgetItem(self.trInResAssignedTask,
                                          QStringList(name))
             self.trInResAssignedTask.addTopLevelItem(pxTreeIlem)
Esempio n. 45
0
 def _load_tree(self):
     self.clear()
     try:
         if self.globals:
             globals_item = ItemTree(self, QStringList('self.globals'))
             globals_item.isClickable = False
             for glob in self.globals:
                 glob_item = ItemTree(globals_item,
                                      QStringList(glob['name']),
                                      lineno=glob['lineno'])
                 glob_item.setIcon(0, QIcon(resources.images['attribute']))
         if self.classes:
             #classes
             for klass in self.classes:
                 name = "%s(%s)" % (klass['name'], ', '.join(
                     [k for k in klass['superclasses']]))
                 class_item = ItemTree(self,
                                       QStringList(name),
                                       lineno=klass['lineno'])
                 class_item.setIcon(0, QIcon(resources.images['class']))
                 #attributes
                 if klass['attributes']:
                     attributes_item = ItemTree(class_item,
                                                QStringList('Attributes'))
                     attributes_item.isClickable = False
                     for attribute in klass['attributes']:
                         item = ItemTree(attributes_item,
                                         QStringList(attribute['name']),
                                         lineno=attribute['lineno'])
                         item.isAttribute = True
                         item.setIcon(0,
                                      QIcon(resources.images['attribute']))
                 #metodos
                 if klass['methods']:
                     methods_item = ItemTree(class_item,
                                             QStringList('Methods'))
                     methods_item.isClickable = False
                     for method in klass['methods']:
                         item = ItemTree(methods_item,
                                         QStringList(method['name']),
                                         lineno=method['lineno'])
                         item.setIcon(0,
                                      QIcon(resources.images['function']))
         #functions
         if self.functions:
             functions_item = QTreeWidgetItem(self,
                                              QStringList('self.functions'))
             functions_item.isClickable = False
             for func in self.functions:
                 item = ItemTree(functions_item,
                                 QStringList(func['name']),
                                 lineno=func['lineno'])
                 item.setIcon(0, QIcon(resources.images['function']))
         self.expandAll()
     except Exception:
         print 'Error parsing this file for Tree Symbols: method refresh'
Esempio n. 46
0
 def reloadTreeGui(self):
     tree=self.trCanIfCfg.topLevelItem(0);
     for index in range(0, tree.childCount()):
         temp=tree.takeChild(0);
         del temp;
     for obj in self.cfg.channelList:
         item=QTreeWidgetItem(tree,QStringList(obj.name));
         tree.addChild(item);
         for hoh in obj.hthList+obj.hrhList:
             item2=QTreeWidgetItem(item,QStringList(hoh.name));
             item.addChild(item2);
             for pdu in hoh.pduList:
                 item3=QTreeWidgetItem(item2,QStringList(pdu.name));
                 item2.addChild(item3);
Esempio n. 47
0
    def initializePage(self):
        super(PanelPage, self).initializePage()

        rootLayout = QVBoxLayout()
        rootLayout.setContentsMargins(20, 30, 20, 30)

        row0 = QHBoxLayout()
        lable0 = QLabel('  依赖库:')
        lable0.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
        self.lw_files = QListWidget()
        items0 = QStringList()
        for moudel in app.g_configurations.libs:
            items0.append(moudel['name'])
        self.lw_files.addItems(items0)
        row0.addWidget(lable0)
        row0.addWidget(self.lw_files)

        row1 = QHBoxLayout()
        lable1 = QLabel('工程文件:')
        lable1.setAlignment(Qt.AlignTop | Qt.AlignHCenter)
        self.lw_files = QListWidget()
        items1 = QStringList()
        for file in app.g_configurations.config['files']:
            items1.append(file['target'])
        self.lw_files.addItems(items1)
        row1.addWidget(lable1)
        row1.addWidget(self.lw_files)

        rootLayout.addLayout(row0)
        rootLayout.addLayout(row1)
        self.setLayout(rootLayout)
def test_add_addon(qtbot, addons_editor, addons_file):
    with patch("mozregui.addons_editor.QFileDialog") as dlg:
        filePath = addons_file
        dlg.getOpenFileNames.return_value = QStringList(filePath)
        qtbot.mouseClick(addons_editor.ui.add_addon, Qt.LeftButton)
        dlg.getOpenFileNames.assert_called_once_with(
            addons_editor,
            "Choose one or more addon files",
            filter="addon file (*.xpi)",
        )

        # check addons
        assert addons_editor.list_model.rowCount() == len(
            QStringList(filePath))
        assert addons_editor.get_addons() == [filePath]
Esempio n. 49
0
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        uic.loadUi("mainwindow.ui", self)
        strlist = QStringList()
        strlist.append("yafei")
        strlist.append("yafeilinux")
        strlist.append("Qt")
        strlist.append("Qt Creator")

        listModel = QStringListModel(strlist, self)
        self.filterModel = QSortFilterProxyModel(self)
        # 为代理模型添加源模型
        self.filterModel.setSourceModel(listModel)
        # 在视图中使用代理模型
        self.listView.setModel(self.filterModel)
Esempio n. 50
0
 def cargaTablas(self):
       temp = QStringList("Elija Una Fuente")
       connection = None
       try:
             connection =  sqlite3.connect("escenarios.db")
             cursor = connection.cursor()
             cursor.execute("SELECT name FROM escenario")
             data = cursor.fetchall()
             for row in data:
                   temp.append(row[0])
                   #print row[0]
       except sqlite3.Error , e:
             print "Error %s:" % e.args[0]
             if connection:
                   connection.close()
Esempio n. 51
0
 def cargaTablas(self):
     temp = QStringList("Elija Una Fuente")
     connection = None
     try:
         connection = sqlite3.connect("escenarios.db")
         cursor = connection.cursor()
         cursor.execute("SELECT name FROM escenario")
         data = cursor.fetchall()
         for row in data:
             temp.append(row[0])
             #print row[0]
     except sqlite3.Error, e:
         print "Error %s:" % e.args[0]
         if connection:
             connection.close()
 def startIgnoredExceptions(self, attrs):
     """
     Handler method for the "IgnoredExceptions" start tag.
     
     @param attrs list of tag attributes
     """
     self.dbgExcIgnoreList = QStringList()
Esempio n. 53
0
 def __init__(self, interval, projectDir, vcs, parent = None):
     """
     Constructor
     
     @param interval new interval in seconds (integer)
     @param projectDir project directory to monitor (string or QString)
     @param vcs reference to the version control object
     @param parent reference to the parent object (QObject)
     """
     QThread.__init__(self, parent)
     self.setObjectName("VcsStatusMonitorThread")
     
     self.setTerminationEnabled(True)
     
     self.projectDir = QString(projectDir)
     self.vcs = vcs
     
     self.interval = interval
     self.autoUpdate = False
     
     self.statusList = QStringList()
     self.reportedStates = {}
     self.shouldUpdate = False
     
     self.monitorMutex = QMutex()
     self.monitorCondition = QWaitCondition()
     self.__stopIt = False
Esempio n. 54
0
 def __init__(self):
     # Nothing loaded yet
     self.altTag = QString()
     self.altDict = None
     self.mainTag = QString()
     self.mainDict = None
     # Tags of any not-found dicts so we only give one diagnostic per dict
     self.errTags = set()
     # Populate our list of available dictionaries by finding
     # all the file-pairs of the form <tag>.dic and <tag>.aff in the
     # folder whose path is saved by ppqt in IMC.dictPath.
     # Save the dict tags in the string list self.listOfDicts.
     self.listOfDicts = QStringList()
     # Get a list of all files in that folder. We don't need to sort them,
     # we use the "in" operator to find the X.dic matching an X.aff
     # Defensive programming: dict folder should exist but maybe the user
     # moved stuff.
     try :
         fnames = os.listdir(IMC.dictPath)
     except OSError :
         fnames = [] # no dict folder?!
     for fn in fnames:
         if u'.aff' == fn[-4:] :
             # this is a tag.aff file, look for a matching tag.dic
             dn = fn[:-4]
             if (dn + u'.dic') in fnames:
                 self.listOfDicts.append(QString(dn))
     # Initialize our main dictionary to the one last-chosen by the user
     # with a default of en_US. The current main dict is saved in the
     # settings during the terminate() method below.
     deftag = IMC.settings.value(u"main/spellDictTag",
                                 QString(u"en_US")).toString()
     # Try to load the main dictionary. Sets self.mainDict/.mainTag.
     self.setMainDict(deftag)
def __qtReorderFilter(filter, selectedFilter = None):
    """
    Private function to reorder the file filter to cope with a KDE issue introduced
    by distributors usage of KDE file dialogs.
    
    @param filter Qt file filter (QString or string)
    @param selectedFilter this is set to the selected filter (QString or string)
    @return the rearranged Qt file filter (QString)
    """
    if selectedFilter is not None and not Globals.isMacPlatform():
        fileFilters = QStringList(filter.split(';;'))
##        fileFilters.removeAll(selectedFilter)
        fileFilters.prepend(selectedFilter)
        return fileFilters.join(";;")
    else:
        return filter
Esempio n. 56
0
 def GenerateRequests(self):
     generator = self.generators[self.sender()]
     data = generator.GetSettings()
     d = ParamsDialog(data, self,
                      generator.GetName() == "Tightly coupled",
                      generator.GetName() == "Tightly coupled")
     d.exec_()
     if d.result() == QDialog.Accepted:
         generator.UpdateSettings(d.data)
         #TODO: populate the table with new demands
         self.project.demands = generator.Generate(self.project.resources)
         self.ui.demands.clear()
         self.demands = {}
         for demand in self.project.demands:
             it = QTreeWidgetItem(
                 self.ui.demands,
                 QStringList([
                     demand.id,
                     str(demand.startTime),
                     str(demand.endTime),
                     self.tr("No"),
                     self.tr("No")
                 ]))
             cb = QComboBox()
             cb.addItems([self.tr("No"), self.tr("Yes")])
             self.ui.demands.setItemWidget(it, 3, cb)
             QObject.connect(cb, SIGNAL("currentIndexChanged(int)"),
                             it.emitDataChanged)
             it.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled
                         | Qt.ItemIsSelectable)
             self.demands[it] = demand
Esempio n. 57
0
    def _create_control ( self, parent ):
        # If the caller provided a default path instead of a default directory
        # and filename, split the path into it directory and filename
        # components.
        if ((len( self.default_path )      != 0) and
            (len( self.default_directory ) == 0) and
            (len( self.default_filename )  == 0)):
            default_directory, default_filename = \
                os.path.split( self.default_path )
        else:
            default_directory = self.default_directory
            default_filename  = self.default_filename

        # Convert the filter:
        keep    = True
        filters = QStringList()

        for f in self.wildcard.split( '|' ):
            if keep and f:
                filters << f

            keep = not keep

        # Set the default directory:
        if not default_directory:
            default_directory = QDir.currentPath()

        dlg = QFileDialog( parent, self.title, default_directory )

        dlg.setViewMode( QFileDialog.Detail )
        dlg.selectFile( default_filename )
        dlg.setFilters( filters )

        if self.wildcard_index < filters.count():
            dlg.selectFilter( filters[ self.wildcard_index ] )

        if self.action == 'open':
            dlg.setAcceptMode( QFileDialog.AcceptOpen )
            dlg.setFileMode( QFileDialog.ExistingFile )
        elif self.action == 'open files':
            dlg.setAcceptMode( QFileDialog.AcceptOpen )
            dlg.setFileMode( QFileDialog.ExistingFiles )
        else:
            dlg.setAcceptMode( QFileDialog.AcceptSave )
            dlg.setFileMode( QFileDialog.AnyFile )

        return dlg
Esempio n. 58
0
	def saveAccountData(self):
		collId = self.collectionID.text()
		if self.enabledBox.checkState() == Qt.Checked :
			enable = '1'
		else :
			enable = '0'
		collRes = self.collectionResource.text()
		accCommand = self.accountCommand.text()
		params = QStringList() << collId << enable << \
			collRes << self.nameColl << accCommand
		data = params.join(dlm)
		item = self.Parent.editList.accountListBox.currentItem()
		self.Settings.beginGroup('Akonadi account')
		data = self.Settings.setValue(item.text(), data)
		self.Settings.endGroup()
		# data saved
		self.blink(True, False)