Ejemplo n.º 1
0
    def __init__(self, db, dbName, tableName):
        QtGui.QTabWidget.__init__(self)

        self.db = db
        self.dbName = dbName
        self.tableName = tableName

        self.setupUi(self)
        self.txtLimit.setValue(self.defaultLimit)

        self.lblQueryDesc.setText("SELECT * FROM %s WHERE" % self.db.quoteIdentifier(self.tableName))
        QObject.connect(self.txtWhere, SIGNAL("returnPressed()"), self.refreshData)

        self.db.setDatabase(self.dbName)

        #Retrieve
        self.refreshInfo()
        self.refreshStructure()
        self.refreshIndexes()

        #Data
        self.tableModel = QPyTableModel(self, self.db)
        self.tableModel.setTable(self.tableName)
        self.tableData.setModel(self.tableModel)

        self.refreshData()
Ejemplo n.º 2
0
 def __init__(self,username,containerItem = None,parent = None):
     QObject.__init__(self,parent)
     HashableMixin.__init__(self)
     self._username = username
     self._contentItems = []
     self._authorizer = Authorizer(self._username)
     self._containerItem = containerItem
Ejemplo n.º 3
0
 def __init__(self, data, parent=None):
     QObject.__init__(self, parent)
     self.populated = False
     self.itemData = data
     self.childItems = []
     if parent:
         parent.appendChild(self)
Ejemplo n.º 4
0
    def __init__(self, hazard_layer, exposure_layer, function):
        """Constructor for the impact calculator thread.

        :param hazard_layer: read_layer object containing the Hazard.
            data.
        :type hazard_layer: read_layer

        :param exposure_layer: read_layer object containing the Exposure data.
        :type exposure_layer: read_layer

        :param function: Function that defines how the Hazard assessment
            will be computed.
        :type function: FunctionProvider

        :raises: InsufficientParametersError if not all parameters are set.
        """
        threading.Thread.__init__(self)
        QObject.__init__(self)
        self._hazardLayer = hazard_layer
        self._exposureLayer = exposure_layer
        self._function = function
        self._impactLayer = None
        self._result = None
        self._exception = None
        self._traceback = None
Ejemplo n.º 5
0
 def __init__(self, widget):
     QObject.__init__(self)
     self.parent = widget
     self.ser = serial.Serial()
     self.mutex = QtCore.QMutex(mode=QtCore.QMutex.Recursive)
     self.moveThread = thread.WorkerThread()
     self.moveThread.canDropJobs = True
Ejemplo n.º 6
0
 def __init__(self, navigationInterpreter, positionModel, editor):
     QObject.__init__(self)
     self.baseInterpret = navigationInterpreter
     self.posModel      = positionModel
     self.rubberBand = QRubberBand(QRubberBand.Rectangle, editor)
     self.origin = QPoint()
     self.originpos = object()
Ejemplo n.º 7
0
    def __init__(self, source_node, source_channel,
                 sink_node, sink_channel, enabled=True, properties=None,
                 parent=None):
        QObject.__init__(self, parent)
        self.source_node = source_node

        if isinstance(source_channel, six.string_types):
            source_channel = source_node.output_channel(source_channel)
        elif source_channel not in source_node.output_channels():
            raise ValueError("%r not in in nodes output channels." \
                             % source_channel)

        self.source_channel = source_channel

        self.sink_node = sink_node

        if isinstance(sink_channel, six.string_types):
            sink_channel = sink_node.input_channel(sink_channel)
        elif sink_channel not in sink_node.input_channels():
            raise ValueError("%r not in in nodes input channels." \
                             % source_channel)

        self.sink_channel = sink_channel

        if not compatible_channels(source_channel, sink_channel):
            raise IncompatibleChannelTypeError(
                    "Cannot connect %r to %r" \
                    % (source_channel.type, sink_channel.type)
                )

        self.__enabled = enabled
        self.__dynamic_enabled = False
        self.__tool_tip = ""
        self.properties = properties or {}
 def __init__(self, parent = None):
     """
     Constructor
     
     @param parent reference to the parent object (QObject)
     """
     QObject.__init__(self, parent)
Ejemplo n.º 9
0
def generate_category_widget(symbolCategory, symbols, synchronizer):
    """ Generate the widget for a single symbolCategory. """

    # layout for current tab
    currentWidget = QWidget()
    layout        = SymbolSelectorGridLayout()
    currentWidget.setLayout(layout)

    # sort symbols in requested order
    rawList = []
    for symbol in symbols:
        rawList.append((int(symbol["category_pos"]), symbol))

    #rawList.sort(lambda x,y: cmp(x[0], y[0]))
    rawList.sort(key=(lambda x: x[0]))

    # add them to the tab
    widgetList = {}
    for (row, symbolEntry) in enumerate(rawList):
        symbol = symbolEntry[1]
        newItem = SymbolSelectorItem(symbol, synchronizer)
        newLabel = SymbolSelectorLabel(symbol)
        layout.append_row(newItem, newLabel)

        QObject.connect(newLabel, SIGNAL("label_clicked()"),
                        newItem.click_me)

        widgetList[(symbol["name"], symbol["category"])] = newItem

    scrollArea = QScrollArea()
    scrollArea.setWidget(currentWidget)
    return (scrollArea, widgetList)
Ejemplo n.º 10
0
 def __init__(self, destdir, persist_limit, **kwargs):
     QObject.__init__(self)
     persist_limit = PersistLimit(persist_limit)
     BuildDownloadManager.__init__(self, destdir,
                                   session=get_http_session(),
                                   persist_limit=persist_limit,
                                   **kwargs)
Ejemplo n.º 11
0
 def __init__(self):
     QObject.__init__(self)
     TestRunner.__init__(self)
     self.verdict = None
     self.launcher = None
     self.launcher_kwargs = {}
     self.run_error = False
Ejemplo n.º 12
0
    def __init__(self, navigationInterpreter, positionModel, BoxContr, widget):
        '''
        Class which interacts directly with the image scene

        :param navigationInterpreter:
        :param positionModel:
        :param BoxContr:
        :param widget: The main widget

        '''


        QObject.__init__(self)


        self.baseInterpret = navigationInterpreter
        self._posModel      = positionModel
        self.rubberBand = RedRubberBand(QRubberBand.Rectangle, widget)

        self.boxController=BoxContr

        self.leftClickReleased.connect(BoxContr.addNewBox)
        self.rightClickReceived.connect(BoxContr.onChangedPos)
        #self.deleteSelectedItemsSignal.connect(BoxContr.deleteSelectedItems)


        self.origin = QPoint()
        self.originpos = object()
Ejemplo n.º 13
0
    def __init__(self,editor,connectionInput,boxListModel, delegateMethod=None):
        '''
        Class which controls all boxes on the scene

        :param scene:
        :param connectionInput: The imput slot to which connect all the new boxes
        :param boxListModel:

        '''

        scene = editor.imageScenes[2]
        self._editor = editor
        
        QObject.__init__(self,parent=scene.parent())
        self._setUpRandomColors()
        self.scene=scene
        self.connectionInput=connectionInput
        self._currentBoxesList=[]
        #self._currentActiveItem=[]
        #self.counter=1000
        self.currentColor=self._getNextBoxColor()
        self.boxListModel=boxListModel
        self.scene.selectionChanged.connect(self.handleSelectionChange)

        boxListModel.boxRemoved.connect(self.deleteItem)
        boxListModel.signalSaveAllBoxesToCSV.connect(self.saveBoxesToCSV)

        self.delegateMethod = delegateMethod
Ejemplo n.º 14
0
 def __init__(self, x, y, filename, mythDB, startAtEnd = False):
    QObject.__init__(self)
    
    self.filename = filename
    self.mythDB = mythDB
    self.startAtEnd = startAtEnd
    self.ended = False
    self.lastPosition = 0
    self.emitFinished = True
    self.currentChannel = None
    self.previousChannel = None
    self.guide = None
    self.commskip = True
    
    self.getSkipList()
    self.bookmark = self.mythDB.bookmark(self.filename)
    self.program = self.mythDB.getProgram(self.filename)
    self.recording = self.mythDB.programInUse(self.program)
    
    self.videoOutput = VideoOutput(None, self.keyPressHandler)
    self.createOverlays()
    self.videoOutput.readyForOverlay.connect(self.placeOverlays)
    self.videoOutput.move(x, y)
    self.videoOutput.showFullScreen()
    
    self.startBackend()
Ejemplo n.º 15
0
 def __init__(self, gelement, parent=None):
     QObject.__init__(self, parent)
     self._gelement = gelement
     self._gelement.get_bus().add_signal_watch()
     self._gelement.get_bus().connect('message', self.cb_bus)
     if GObjectLoop._instance is None:
         GObjectLoop()
Ejemplo n.º 16
0
    def __init__( self, tiling, stackedImageSources, cache_size=100,
                  request_queue_size=100000, n_threads=2,
                  layerIdChange_means_dirty=False, parent=None ):
        QObject.__init__( self, parent = parent )

        self.tiling = tiling
        self.axesSwapped = False
        self._sims = stackedImageSources
        self._cache_size = cache_size
        self._request_queue_size = request_queue_size
        self._n_threads = n_threads
        self._layerIdChange_means_dirty = layerIdChange_means_dirty

        self._current_stack_id = self._sims.stackId
        self._cache = _TilesCache(self._current_stack_id, self._sims,
                                  maxstacks=self._cache_size)

        self._sims.layerDirty.connect(self._onLayerDirty)
        self._sims.visibleChanged.connect(self._onVisibleChanged)
        self._sims.opacityChanged.connect(self._onOpacityChanged)
        self._sims.sizeChanged.connect(self._onSizeChanged)
        self._sims.orderChanged.connect(self._onOrderChanged)
        self._sims.stackIdChanged.connect(self._onStackIdChanged)
        if self._layerIdChange_means_dirty:
            self._sims.layerIdChanged.connect(self._onLayerIdChanged)

        self._keepRendering = True
Ejemplo n.º 17
0
    def __init__(self, parent=None):
        QFrame.__init__(self, parent)
        self.setAutoFillBackground(True)
        self.palette().setColor(self.backgroundRole(), spec.POV_COLOR)

        self.benderButtons = bender.Buttons(self)
        self.bender = bender.Bender(self)
        self.bender.setValue(150)
        self.wheelPad = pk.widgets.WheelPad(self)
        self.history = History(self.bender, parent=self)
        self.history.setMinimumHeight(50)
        
        QObject.connect(self.benderButtons, SIGNAL('bendUp()'),
                        self.bender.bendUp)
        QObject.connect(self.benderButtons, SIGNAL('bendDown()'),
                        self.bender.bendDown)
        QObject.connect(self.benderButtons, SIGNAL('bendBack()'),
                        self.bender.bendBack)
        QObject.connect(self.bender, SIGNAL('valueChanged(float)'),
                        self.emitTempo)
        QObject.connect(self.wheelPad, SIGNAL('moved_y(int)'),
                        self.slotWheel)
        
        Layout = QVBoxLayout(self)
        Layout.setMargin(0)
        Layout.addWidget(self.history)
        Layout.addWidget(self.benderButtons)
        Layout.setStretchFactor(self.benderButtons, 0)
        Layout.addWidget(self.wheelPad)
        Layout.setStretchFactor(self.wheelPad, 1)
Ejemplo n.º 18
0
    def initGui(self):
        # Actions
        self.action_convert = QAction(QIcon(path.join(_current_path, 'convert.png')),
                                      QCoreApplication.translate('RuGeocoder', 'Convert CSV to SHP'),
                                      self.iface.mainWindow())
        QObject.connect(self.action_convert, SIGNAL("triggered()"), self.run_convert)

        self.action_batch_geocoding = QAction(QIcon(path.join(_current_path, 'icon.png')),
                                              QCoreApplication.translate('RuGeocoder', 'Batch geocoding'),
                                              self.iface.mainWindow())
        QObject.connect(self.action_batch_geocoding, SIGNAL('triggered()'), self.run_batch)

        self.action_quick_geocoding = self.__quick_tlb.toggleViewAction()
        self.action_quick_geocoding.setIcon(QIcon(path.join(_current_path, 'edit-find-project.png')))
        self.action_quick_geocoding.setText(QCoreApplication.translate('RuGeocoder', '&Quick geocoding toolbox'))

        # Add toolbar button and menu item
        self.toolbar.addAction(self.action_convert)
        self.iface.addPluginToWebMenu(self.menu_name, self.action_convert)

        self.toolbar.addAction(self.action_batch_geocoding)
        self.iface.addPluginToWebMenu(self.menu_name, self.action_batch_geocoding)

        self.toolbar.addSeparator()

        self.toolbar.addAction(self.action_quick_geocoding)
        self.iface.addPluginToWebMenu(self.menu_name, self.action_quick_geocoding)
    def __init__(self, features, uid, errors):
        QObject.__init__(self)
        self.features = features
        self.last_fid = features[-1][0]
        self.errors = errors
        self.uid = uid

        self.vertices_occur = {}
        self.edges_occur = {}
        self.f_dict = {}
        self.self_loops = []

        for i in self.features:
            self.f_dict[i[0]] = [i[1], i[2]]
            for vertex in vertices_from_wkt_2(i[2]):
                break
            first = vertex
            for vertex in vertices_from_wkt_2(i[2]):
                pass
            last = vertex
            try:
                self.vertices_occur[first] += [i[0]]
            except KeyError, e:
                self.vertices_occur[first] = [i[0]]
            try:
                self.vertices_occur[last] += [i[0]]
            except KeyError, e:
                self.vertices_occur[last] = [i[0]]
Ejemplo n.º 20
0
 def replaceVariable(self, pendingVar, newVar):
     """ replace existing variable in list with new one
     @param pendingVar: var to replace
     @param newVar: new var"""
     vwOld = self.variableList.getVariableWrapper(pendingVar)
     vwNew = self.variableList.replaceVar(pendingVar, newVar)
     QObject.connect(vwNew, SIGNAL('replace(PyQt_PyObject, PyQt_PyObject)'), self.replaceVariable)
	def __init__(self, parent=None, name=None, *args, **kwargs):
		"""
		Initializes the class.

		:param parent: Object parent.
		:type parent: QObject
		:param name: Component name.
		:type name: unicode
		:param \*args: Arguments.
		:type \*args: \*
		:param \*\*kwargs: Keywords arguments.
		:type \*\*kwargs: \*\*
		"""

		LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))

		QObject.__init__(self, parent, *args, **kwargs)

		# --- Setting class attributes. ---
		self.__name = None
		self.name = name

		self.__activated = False
		self.__initialized = False
		self.__deactivatable = True
Ejemplo n.º 22
0
    def __init__(
            self,
            osm_file,
            layers=OSM_LAYERS,
            white_list_column=WHITE_LIST,
            delete_empty_layers=False,
            load_only=False,
            osm_conf=None):
        self.__osmFile = osm_file
        self.__layers = layers

        if not white_list_column:
            white_list_column = {
                'multilinestrings': None,
                'points': None,
                'lines': None,
                'multipolygons': None}

        self.__whiteListColumn = white_list_column
        self.__deleteEmptyLayers = delete_empty_layers
        self.__loadOnly = load_only

        # If an osm_conf is provided ?
        if not osm_conf:
            current_dir = dirname(realpath(__file__))
            self._osm_conf = join(current_dir, 'QuickOSMconf.ini')
        else:
            self._osm_conf = osm_conf.encode("utf-8")

        QObject.__init__(self)
Ejemplo n.º 23
0
 def __init__(self, weboob, parent=None):
     QObject.__init__(self, parent)
     self.weboob = weboob
     self.weboob.callbacks['login'] = self.callback(self.LoginRequest)
     self.mutex = QMutex()
     self.requests = []
     self.connect(self, SIGNAL('new_request'), self.do_request)
Ejemplo n.º 24
0
 def __init__(self):
     QObject.__init__(self)
     self._action = core.actionManager().addAction("mSettings/aSettings",
                                                 _tr( "Settings.."), 
                                                 QIcon(':/enkiicons/settings.png'))
     self._action.setStatusTip(_tr( "Edit settigns.."))
     self._action.triggered.connect(self._onEditSettings)
Ejemplo n.º 25
0
    def __init__(self, parent = None):
        QObject.__init__(self, parent)
        self.jinja = Environment(loader = FileSystemLoader("data/templates"), autoescape = True)
        self.jinja.filters["likes"] = filter_likes
        self.jinja.filters["twitterise"] = filter_twitterise
        self.jinja.filters["timesince"] = filter_timesince

        self.mapper = Mapper()
        self.mapper.connect("/", controller = "LolViews", action = "feed")
        self.mapper.connect("/login", controller = "LolViews", action = "login")
        self.mapper.connect("/user/:user", controller = "LolViews", action = "feed")

        self.notes = NotificationServer()

        from PyQt4.QtCore import QSettings
        settings = QSettings()
        if settings.contains("session"):
            from cPickle import loads
            self.session = loads(str(settings.value("session").toString()))
        else:
            self.session = Session()

        self.ff = FriendFeedAPI(self.session)
        
        self.deferredResponses = set()
Ejemplo n.º 26
0
 def __init__(self):
     """Constructor for the KeywordIO object."""
     QObject.__init__(self)
     # path to sqlite db path
     self.keyword_db_path = None
     self.setup_keyword_db_path()
     self.connection = None
Ejemplo n.º 27
0
 def itemCollapsedOrExpanded(self, item):
     if item.isExpanded():
         item.expanded()
     else:  # collapsed
         item.collapsed()
     self.setVisibleRowCount()
     QObject.emit(self, SIGNAL("contentChanged(void)"))
    def __init__(self, theHazardLayer, theExposureLayer,
                 theFunction):
        """Constructor for the impact calculator thread.

        Args:

          * Hazard layer: InaSAFE read_layer object containing the Hazard data.
          * Exposure layer: InaSAFE read_layer object containing the Exposure
            data.
          * Function: a InaSAFE function that defines how the Hazard assessment
            will be computed.

        Returns:
           None
        Raises:
           InsufficientParametersException if not all parameters are
           set.

        Requires three parameters to be set before execution
        can take place:
        """
        threading.Thread.__init__(self)
        QObject.__init__(self)
        self._hazardLayer = theHazardLayer
        self._exposureLayer = theExposureLayer
        self._function = theFunction
        self._impactLayer = None
        self._result = None
        self._exception = None
        self._traceback = None
Ejemplo n.º 29
0
    def __init__(self, distributedObjects):
        """ init tracepoint controller and members.
        @param distributedObjects: passing distributed objects
        @note There are following signals: \n
            * insertDockWidgets() : necessary for plugin system\n
            * clicked(QModelIndex): if a row in tracepointView is clicked\n
            * cleanupModels(): clear Tracepoints\n
            * runClicked((): clear Tracepoint Data on every click on run button\n
        """

        QObject.__init__(self)
        self.distributedObjects = distributedObjects

        """@var self._model: (TracepointModel), this class provides the model for tracepointView"""
        self._model = TracepointModel(self.distributedObjects)
        """@var self.tracepointView: (TracepointView), this class presents data from _model"""
        self.tracepointView = TracepointView()
        self.tracepointView.tracepointView.setModel(self._model)

        #register with session manager to save Tracepoints
        self.distributedObjects.signalProxy.emitRegisterWithSessionManager(self, "Tracepoints")

        self.distributedObjects.signalProxy.insertDockWidgets.connect(self.insertDockWidgets)
        self.tracepointView.tracepointView.clicked.connect(self.updateWaveforms)
        self.distributedObjects.signalProxy.inferiorStoppedNormally.connect(self.updateWaveforms)
        self.distributedObjects.signalProxy.cleanupModels.connect(self._model.clearTracepoints)
        self.distributedObjects.signalProxy.runClicked.connect(self._model.clearTracepointData)
Ejemplo n.º 30
0
 def addVar(self, variableToTrace):
     """ add a var to trace its value
     @param variableToTrace: variable name of the variable that shoudl be traced"""
     vw = self.variableList.addVarByName(variableToTrace)
     QObject.connect(vw, SIGNAL('replace(PyQt_PyObject, PyQt_PyObject)'), self.replaceVariable)
     newValueList = ValueList(variableToTrace, vw.getType())
     self.wave.append(newValueList)
Ejemplo n.º 31
0
# -*- coding: utf-8 -*-

# Creation of a PDF tree from gedcom and options


import os.path
from reportlab.lib.units import mm
from reportlab.lib.pagesizes import A4
from lab.abstractLab import *
from PyQt4.QtCore import QSettings, QObject, QString

qo = QObject()
tr = qo.tr


class Tree:
    def __init__(self, gedcom):
        self.gedcom = gedcom
        self.options = QSettings("A3X", "pySequoia")
        self.max_generations = self.options.value("max_generations").toInt()[0]
        self.notes = []
        self.counter = 0

    def setProgressDialog(self, dialog):
        """Gives a ProgressDialog for displaying progression"""
        self.progressDialog = dialog

    def setProgression(self, progress):
        if hasattr(self, 'progressDialog'):
            self.progressDialog.setValue(progress)
Ejemplo n.º 32
0
 def __init__(self):
     QObject.__init__(self)
Ejemplo n.º 33
0
 def __init__(self):
     QObject.__init__(self)
     self.load()
Ejemplo n.º 34
0
 def name(cls):
     return QObject.tr(translator, 'Export to FTP site')
Ejemplo n.º 35
0
 def name(cls):
     return QObject.tr(translator, 'Export to folder')
Ejemplo n.º 36
0
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

import os
from datetime import datetime
import ftplib

from qgis.core import (QgsProject)
from PyQt4.QtCore import (QObject)
from PyQt4.QtGui import (QFileDialog, QInputDialog, QDialog, QLineEdit)
from utils import (tempFolder)
from ui_ftp_configuration import Ui_FtpConfiguration

translator = QObject()


class Exporter(QObject):
    """
    Generic base class for web map exporters
    """
    def __init__(self):
        super(QObject, self).__init__()

    @classmethod
    def type(cls):
        """
        :return: Unique string for exporter type
        """
        return ''
Ejemplo n.º 37
0
    def __init__(self, composerView, iface):
        QObject.__init__(self, composerView)

        self._compView = composerView
        self._stdmTB = self.mainWindow().addToolBar("STDM Document Designer")
        self._selectMoveAction = None
        self._iface = iface

        #Container for custom editor widgets
        self._widgetMappings = {}

        #Hide default dock widgets
        if self.itemDock() is not None:
            self.itemDock().hide()

        if self.atlasDock() is not None:
            self.atlasDock().hide()

        if self.generalDock() is not None:
            self.generalDock().hide()

        # Remove default toolbars
        self._remove_composer_toolbar('mAtlasToolbar')

        self._remove_composer_toolbar('mComposerToolbar')

        #Create dock widget for configuring STDM data source
        self._stdmDataSourceDock = QDockWidget(
            QApplication.translate("ComposerWrapper", "STDM Data Source"),
            self.mainWindow())
        self._stdmDataSourceDock.setObjectName("STDMDataSourceDock")
        self._stdmDataSourceDock.setMinimumWidth(300)
        self._stdmDataSourceDock.setFeatures(QDockWidget.DockWidgetMovable
                                             | QDockWidget.DockWidgetClosable)
        self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
                                        self._stdmDataSourceDock)

        self._dataSourceWidget = ComposerDataSourceSelector()
        self._stdmDataSourceDock.setWidget(self._dataSourceWidget)
        self._stdmDataSourceDock.show()

        #Re-insert dock widgets
        if self.generalDock() is not None:
            self.generalDock().show()

        if self.itemDock() is not None:
            self.itemDock().show()

        #Create dock widget for configuring STDM item properties
        self._stdmItemPropDock = QDockWidget(
            QApplication.translate("ComposerWrapper", "STDM item properties"),
            self.mainWindow())

        self._stdmItemPropDock.setObjectName("STDMItemDock")
        self._stdmItemPropDock.setMinimumWidth(300)
        self._stdmItemPropDock.setFeatures(QDockWidget.DockWidgetMovable
                                           | QDockWidget.DockWidgetClosable)
        self.mainWindow().addDockWidget(Qt.RightDockWidgetArea,
                                        self._stdmItemPropDock)
        self._stdmItemPropDock.show()

        #Re-arrange dock widgets and push up STDM data source dock widget
        if self.generalDock() is not None:
            self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
                                              self.generalDock(), Qt.Vertical)

        if self.itemDock() is not None:
            self.mainWindow().splitDockWidget(self._stdmDataSourceDock,
                                              self.itemDock(), Qt.Vertical)
            if self.generalDock() is not None:
                self.mainWindow().tabifyDockWidget(self.generalDock(),
                                                   self.itemDock())

        if self.itemDock() is not None:
            self.mainWindow().splitDockWidget(self.itemDock(),
                                              self._stdmItemPropDock,
                                              Qt.Vertical)

        #Set focus on composition properties window
        if self.generalDock() is not None:
            self.generalDock().activateWindow()
            self.generalDock().raise_()

        #Connect signals
        self.composition().itemRemoved.connect(self._onItemRemoved)
        self._dataSourceWidget.cboDataSource.currentIndexChanged.connect(
            self.propagateDataSourceSelection)
        self.composerView().selectedItemChanged.connect(self._onItemSelected)

        #Current template document file
        self._currDocFile = None

        #Copy of template document file
        self._copy_template_file = None

        self._selected_item_uuid = unicode()

        self._current_ref_table_index = -1
Ejemplo n.º 38
0
 def customEvent(self, event):
     if event.type() == ExecuteCallEvent.ExecuteCall:
         self._execute()
     else:
         QObject.customEvent(self, event)
Ejemplo n.º 39
0
 def __init__(self, parent):
     QObject.__init__(self, parent)
     self.selection = []
Ejemplo n.º 40
0
    def __init__(self, future, parent=None):
        QObject.__init__(self, parent)
        self._future = future

        self._future._watchers.append(self._stateChanged)
Ejemplo n.º 41
0
    def __init__(self, canvas):
        """Constructor
        :param canvas:
        """
        QObject.__init__(self)
        self.canvas = canvas
        # Set up slots so we can mimic the behaviour of QGIS when layers
        # are added.
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().layersAdded.connect(self.addLayers)
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().layerWasAdded.connect(self.addLayer)
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().removeAll.connect(self.removeAllLayers)

        # For processing module
        self.destCrs = None
        # For keeping track of which layer is active in the legend.
        self.active_layer = None

        # In the next section of code, we are going to do some monkey patching
        # to make the QGIS processing framework think that this mock QGIS IFACE
        # instance is the actual one. It will also ensure that the processing
        # algorithms are nicely loaded and available for use.

        # Since QGIS > 2.0, the module is moved from QGisLayers to dataobjects
        # pylint: disable=F0401, E0611
        if QGis.QGIS_VERSION_INT > 20001:
            from processing.tools import dataobjects
        else:
            from processing.core import QGisLayers as dataobjects

        import processing
        from processing.core.Processing import Processing
        # pylint: enable=F0401, E0611
        processing.classFactory(self)

        # We create our own getAlgorithm function below which will will monkey
        # patch in to the Processing class in QGIS in order to ensure that the
        # Processing.initialize() call is made before asking for an alg.

        @staticmethod
        def mock_getAlgorithm(name):
            """
            Modified version of the original getAlgorithm function.

            :param name: Name of the algorithm to load.
            :type name: str

            :return: An algorithm concrete class.
            :rtype: QgsAlgorithm  ?
            """
            Processing.initialize()
            for provider in Processing.algs.values():
                if name in provider:
                    return provider[name]
            return None

        # Now we let the monkey loose!
        Processing.getAlgorithm = mock_getAlgorithm
        # We also need to make dataobjects think that this iface is 'the one'
        # Note. the placement here (after the getAlgorithm monkey patch above)
        # is significant, so don't move it!
        dataobjects.iface = self
Ejemplo n.º 42
0
    def __init__(self, parent=None, function=None):
        QObject.__init__(self, parent)
        self.function = function

        self._future = Future()
Ejemplo n.º 43
0
 def __init__(self):
   QObject.__init__(self)
   self.mRepositories = {}
   self.httpId = {}   # {httpId : repoName}
   self.mInspectionFilter = None
Ejemplo n.º 44
0
 def __init__(self, parent):
     QObject.__init__(self, parent)
     self.setObjectName("Menu")
     self.popup = QMenu(i18n("Scripter"))
     MenuHooks().insertMenuAfter("E&xtras", self.popup)
     self._load_entries()
Ejemplo n.º 45
0
 def __init__(self, visaResource, parent=None):
     VisaInstrument.__init__(self, visaResource)
     QObject.__init__(self, parent)
Ejemplo n.º 46
0
 def __init__(self):
   QObject.__init__(self)
   self.mPlugins = {}   # the dict of plugins (dicts)
   self.repoCache = {}  # the dict of lists of plugins (dicts)
   self.localCache = {} # the dict of plugins (dicts)
   self.obsoletePlugins = [] # the list of outdated 'user' plugins masking newer 'system' ones
Ejemplo n.º 47
0
 def __init__(self, name='', parent=None):
     QObject.__init__(self, parent)
     self.setObjectName(name)
Ejemplo n.º 48
0
 def __init__(self, key):
   QObject.__init__(self)
   self.key = key
Ejemplo n.º 49
0
    def get_value(self):
        return self.password.text()


if __name__ == '__main__':
    '''
        Demo application showing PinMatrix widget in action
    '''
    a = QApplication(sys.argv)

    matrix = PinMatrixWidget()

    def clicked():
        print("PinMatrix value is", matrix.get_value())
        print("Possible button combinations:", matrix.get_strength())
        sys.exit()

    ok = QPushButton('OK')
    QObject.connect(ok, SIGNAL('clicked()'), clicked)

    vbox = QVBoxLayout()
    vbox.addWidget(matrix)
    vbox.addWidget(ok)

    w = QWidget()
    w.setLayout(vbox)
    w.move(100, 100)
    w.show()

    a.exec_()
Ejemplo n.º 50
0
    def __init__(self, canvas):
        """Constructor
        :param canvas:
        """
        QObject.__init__(self)
        self.canvas = canvas
        self.legend = QgisLegend(canvas)
        self.message_bar = QgsMessageBar(None)
        # Set up slots so we can mimic the behaviour of QGIS when layers
        # are added.
        LOGGER.debug('Initialising canvas...')
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().layersAdded.connect(self.addLayers)
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().layerWasAdded.connect(self.addLayer)
        # noinspection PyArgumentList
        QgsMapLayerRegistry.instance().removeAll.connect(self.removeAllLayers)

        # For processing module
        self.destCrs = None
        # For keeping track of which layer is active in the legend.
        self.active_layer = None

        # In the next section of code, we are going to do some monkey patching
        # to make the QGIS processing framework think that this mock QGIS IFACE
        # instance is the actual one. It will also ensure that the processing
        # algorithms are nicely loaded and available for use.

        # noinspection PyUnresolvedReferences
        from processing.tools import dataobjects

        # noinspection PyUnresolvedReferences
        import processing
        # noinspection PyUnresolvedReferences
        from processing.core.Processing import Processing
        # pylint: enable=F0401, E0611
        processing.classFactory(self)

        # We create our own getAlgorithm function below which will will monkey
        # patch in to the Processing class in QGIS in order to ensure that the
        # Processing.initialize() call is made before asking for an alg.

        @staticmethod
        def mock_getAlgorithm(name):
            """
            Modified version of the original getAlgorithm function.

            :param name: Name of the algorithm to load.
            :type name: str

            :return: An algorithm concrete class.
            :rtype: QgsAlgorithm  ?
            """
            Processing.initialize()
            # FIXME: Had some weird bug in QGIS 2.18 MacOSX (KyngChaos)
            try:
                providers = Processing.algs.values()
            except:
                providers = Processing.algs().values()

            for provider in providers:
                if name in provider:
                    return provider[name]
            return None

        # Now we let the monkey loose!
        Processing.getAlgorithm = mock_getAlgorithm
        # We also need to make dataobjects think that this iface is 'the one'
        # Note. the placement here (after the getAlgorithm monkey patch above)
        # is significant, so don't move it!
        dataobjects.iface = self

        # set up a layer tree bridge so that new added layers appear in legend
        self.layer_tree_root = QgsProject.instance().layerTreeRoot()
        self.bridge = QgsLayerTreeMapCanvasBridge(
            self.layer_tree_root, self.canvas)
        self.bridge.setCanvasLayers()
Ejemplo n.º 51
0
 def __init__(self, parent):
     """
     Create a ThunkEventHandler that installs itself in the event loop for ``parent``.
     """
     QObject.__init__(self, parent)
     parent.installEventFilter(self)
Ejemplo n.º 52
0
    def __init__(self, password, encoded_value):
        super(PinButton, self).__init__('?')
        self.password = password
        self.encoded_value = encoded_value

        QObject.connect(self, SIGNAL('clicked()'), self._pressed)
 def __init__(self):
     QObject.__init__(self)
     self._cancelling = False
Ejemplo n.º 54
0
    def __init__(self, parent):
        QObject.__init__(self, parent)

        self.job_id = None
        self.__errors = {}
        self._warnings = []
Ejemplo n.º 55
0
 def __draw__(self):
     global _progress, f
     f = open(filename, "a")
     f.write("Rendering function...\n")
     f.close()
     for i in range(len(Paths["Images"])):
         Visum.Graphic.Backgrounds.ItemByKey(
             Paths["Images"][i]).Draw = False
     if not os.path.exists(self._image_path) or Paths["Images"].count(
             self._image_path) == 0:
         f = open(filename, "a")
         f.write("If not os.path.exists or image not in Paths...\n")
         f.close()
         QObject.connect(self._webpage, SIGNAL("loadStarted()"),
                         self.__loading__)
         QObject.connect(self._webpage, SIGNAL("loadProgress(int)"),
                         self.__progress__)
         QObject.connect(self._webpage, SIGNAL("loadFinished(bool)"),
                         self.__loaded__)
         self._webpage.mainFrame().load(QUrl(self._url))
         self._webpage.mainFrame().evaluateJavaScript(
             "x0 = %f; y0 = %f; x1 = %f; y1 = %f;" %
             (self._param[0], self._param[1], self._param[2],
              self._param[3]))
         self._webpage.mainFrame().evaluateJavaScript(
             "width = %d; height = %d;" %
             (self._multiply * self._dimension[0],
              self._multiply * self._dimension[1]))
         self._webpage.mainFrame().evaluateJavaScript("value = %d;" %
                                                      (self._layer))
         while self._loading:
             QCoreApplication.processEvents()
         QObject.disconnect(self._webpage, SIGNAL("loadStarted()"),
                            self.__loading__)
         QObject.disconnect(self._webpage, SIGNAL("loadProgress(int)"),
                            self.__progress__)
         QObject.disconnect(self._webpage, SIGNAL("loadFinished(bool)"),
                            self.__loaded__)
         loop = QEventLoop()
         timer = QTimer()
         timer.setSingleShot(True)
         timer.timeout.connect(loop.quit)
         timerProgress = QTimer()
         QObject.connect(timerProgress, SIGNAL("timeout()"),
                         self.__on_loop__)
         if self._layer == 10: timer.start(0)
         elif self._layer >= 4 and self._layer <= 9:
             timer.start(800 * self._multiply * 4.0)
             timerProgress.start(800 * self._multiply * 4.0 / 16.0)
         else:
             timer.start(2400 * self._multiply * 4.0)
             timerProgress.start(2400 * self._multiply * 4.0 / 49.0)
         loop.exec_()
         QObject.disconnect(timerProgress, SIGNAL("timeout()"),
                            self.__on_loop__)
         background_params = self._webpage.mainFrame().evaluateJavaScript(
             "getRealBounds();").toString()
         background_params = background_params[1:-1]
         background_params = [
             float(s) for s in background_params.split(", ")
         ]
         self._webpage.setViewportSize(
             self._webpage.mainFrame().contentsSize())
         f = open(filename, "a")
         f.write("Setting up an image file...\n")
         f.close()
         image = QImage(self._webpage.viewportSize(), QImage.Format_RGB32)
         f = open(filename, "a")
         f.write("Starting a painter...\n")
         f.close()
         painter = QPainter(image)
         f = open(filename, "a")
         f.write("Rendering from frame...\n")
         f.write(str(self._webpage.viewportSize()) + "\n")
         f.close()
         self._webpage.mainFrame().render(painter)
         painter.end()
         image.save(self._image_path)
         f = open(filename, "a")
         f.write("Image saved.\n")
         f.close()
         Visum.Graphic.AddBackgroundOnPos(self._image_path,
                                          background_params[0],
                                          background_params[1],
                                          background_params[2],
                                          background_params[3])
         Paths["Images"].append(self._image_path)
         f = open(filename, "a")
         f.write("End of if not os.path.exists or image not in Paths.\n")
         f.close()
     else:
         f = open(filename, "a")
         f.write("If os.path.exists and image in Paths...\n")
         f.close()
         index = Paths["Images"].index(self._image_path)
         Visum.Graphic.Backgrounds.ItemByKey(
             Paths["Images"][index]).Draw = True
         f = open(filename, "a")
         f.write("End of if os.path.exists and image in Paths...\n")
         f.close()
     _progress = 100
     del self._webpage
     f = open(filename, "a")
     f.write("Rendering completed.\n")
     f.close()
Ejemplo n.º 56
0
 def __init__(self, QObject_parent=None):
     QObject.__init__(self, QObject_parent)
Ejemplo n.º 57
0
    def __init__(self, logger, opts, parent=None):
        MainWindow.__init__(self, opts, parent)
        Ui_MainWindow.__init__(self)
        self.setupUi(self)
        self.setAttribute(Qt.WA_DeleteOnClose)
        self.setWindowTitle(__appname__ + _(' - LRF Viewer'))

        self.logger = logger
        self.opts = opts
        self.create_document()
        self.spin_box_action = self.spin_box = QSpinBox()
        self.tool_bar.addWidget(self.spin_box)
        self.tool_bar.addSeparator()
        self.slider_action = self.slider = QSlider(Qt.Horizontal)
        self.tool_bar.addWidget(self.slider)
        self.tool_bar.addSeparator()
        self.search = SearchBox2(self)
        self.search.initialize('lrf_viewer_search_history')
        self.search_action = self.tool_bar.addWidget(self.search)
        self.search.search.connect(self.find)

        self.action_next_page.setShortcuts(
            [QKeySequence.MoveToNextPage,
             QKeySequence(Qt.Key_Space)])
        self.action_previous_page.setShortcuts(
            [QKeySequence.MoveToPreviousPage,
             QKeySequence(Qt.Key_Backspace)])
        self.action_next_match.setShortcuts(QKeySequence.FindNext)
        self.addAction(self.action_next_match)
        QObject.connect(self.action_next_page, SIGNAL('triggered(bool)'),
                        self.next)
        QObject.connect(self.action_previous_page, SIGNAL('triggered(bool)'),
                        self.previous)
        QObject.connect(self.action_back, SIGNAL('triggered(bool)'), self.back)
        QObject.connect(self.action_forward, SIGNAL('triggered(bool)'),
                        self.forward)
        QObject.connect(self.action_next_match, SIGNAL('triggered(bool)'),
                        self.next_match)
        QObject.connect(self.action_open_ebook, SIGNAL('triggered(bool)'),
                        self.open_ebook)
        QObject.connect(self.action_configure, SIGNAL('triggered(bool)'),
                        self.configure)
        QObject.connect(self.spin_box, SIGNAL('valueChanged(int)'),
                        self.go_to_page)
        QObject.connect(self.slider, SIGNAL('valueChanged(int)'),
                        self.go_to_page)

        self.graphics_view.setRenderHint(QPainter.Antialiasing, True)
        self.graphics_view.setRenderHint(QPainter.TextAntialiasing, True)
        self.graphics_view.setRenderHint(QPainter.SmoothPixmapTransform, True)

        self.closed = False
Ejemplo n.º 58
0
 def __setup_gui__(self, Dialog):
     global f
     f = open(filename, "a")
     f.write("Setup of gui.\n")
     f.close()
     Dialog.setObjectName("Dialog")
     Dialog.resize(270, 145)
     self.setWindowTitle("Map Layer")
     screen = QDesktopWidget().screenGeometry()
     size = self.geometry()
     self.move((screen.width() - size.width()) / 2,
               (screen.height() - size.height()) / 2)
     self.Render = QPushButton("Render", Dialog)
     self.Render.setGeometry(QRect(85, 90, 100, 25))
     self.Render.setObjectName("Render")
     self.comboBox = QComboBox(Dialog)
     self.comboBox.setGeometry(QRect(100, 34, 115, 18))
     self.comboBox.setEditable(False)
     self.comboBox.setMaxVisibleItems(11)
     self.comboBox.setInsertPolicy(QComboBox.InsertAtBottom)
     self.comboBox.setObjectName("comboBox")
     self.comboBox.addItems([
         "Google Roadmap", "Google Terrain", "Google Satellite",
         "Google Hybrid", "Yahoo Roadmap", "Yahoo Satellite",
         "Yahoo Hybrid", "Bing Roadmap", "Bing Satellite", "Bing Hybrid",
         "Open Street Maps"
     ])
     self.comboBox.setCurrentIndex(10)
     self.label1 = QLabel("Source:", Dialog)
     self.label1.setGeometry(QRect(55, 35, 35, 16))
     self.label1.setObjectName("label1")
     self.slider = QSlider(Dialog)
     self.slider.setOrientation(Qt.Horizontal)
     self.slider.setMinimum(1)
     self.slider.setMaximum(12)
     self.slider.setValue(4)
     self.slider.setGeometry(QRect(110, 61, 114, 16))
     self.label2 = QLabel("Quality: " + str(self.slider.value()), Dialog)
     self.label2.setGeometry(QRect(47, 61, 54, 16))
     self.label2.setObjectName("label2")
     self.doubleSpinBox = QDoubleSpinBox(Dialog)
     self.doubleSpinBox.setGeometry(QRect(160, 5, 40, 20))
     self.doubleSpinBox.setDecimals(0)
     self.doubleSpinBox.setObjectName("doubleSpinBox")
     self.doubleSpinBox.setMinimum(10.0)
     self.doubleSpinBox.setValue(20.0)
     self.doubleSpinBox.setEnabled(False)
     self.checkBox = QCheckBox("Auto refresh", Dialog)
     self.checkBox.setGeometry(QRect(50, 6, 100, 20))
     self.checkBox.setLayoutDirection(Qt.RightToLeft)
     self.checkBox.setObjectName("checkBox")
     self.progressBar = QProgressBar(Dialog)
     self.progressBar.setGeometry(QRect(5, 130, 260, 10))
     self.progressBar.setProperty("value", 0)
     self.progressBar.setTextVisible(False)
     self.progressBar.setObjectName("progressBar")
     self.progressBar.setVisible(False)
     QObject.connect(self.Render, SIGNAL("clicked()"), Dialog.__repaint__)
     QMetaObject.connectSlotsByName(Dialog)
     QObject.connect(self.slider, SIGNAL("valueChanged(int)"),
                     self.__update_slider_label__)
     QObject.connect(self.comboBox, SIGNAL("activated(int)"),
                     self.__combobox_changed__)
     self.timerRepaint = QTimer()
     QObject.connect(self.checkBox, SIGNAL("clicked()"),
                     self.__activate_timer__)
     QObject.connect(self.timerRepaint, SIGNAL("timeout()"),
                     self.__on_timer__)
     f = open(filename, "a")
     f.write("End of setup of gui.\n")
     f.close()
Ejemplo n.º 59
0
 def create_document(self):
     self.document = Document(self.logger, self.opts)
     QObject.connect(self.document, SIGNAL('chapter_rendered(int)'),
                     self.chapter_rendered)
     QObject.connect(self.document, SIGNAL('page_changed(PyQt_PyObject)'),
                     self.page_changed)
Ejemplo n.º 60
0
 def __init__(self, *args):
     QObject.__init__(self)