def setUpClass(cls):
        """Run before all tests"""
        # Create test layer
        srcpath = os.path.join(TEST_DATA_DIR, 'provider')
        cls.basetestfile = os.path.join(srcpath, 'delimited_wkt.csv')

        url = QUrl.fromLocalFile(cls.basetestfile)
        url.addQueryItem("crs", "epsg:4326")
        url.addQueryItem("type", "csv")
        url.addQueryItem("wktField", "wkt")
        url.addQueryItem("spatialIndex", "no")
        url.addQueryItem("subsetIndex", "no")
        url.addQueryItem("watchFile", "no")

        cls.vl = QgsVectorLayer(url.toString(), u'test', u'delimitedtext')
        assert cls.vl.isValid(), "{} is invalid".format(cls.basetestfile)
        cls.provider = cls.vl.dataProvider()

        cls.basetestpolyfile = os.path.join(srcpath, 'delimited_wkt_poly.csv')

        url = QUrl.fromLocalFile(cls.basetestpolyfile)
        url.addQueryItem("crs", "epsg:4326")
        url.addQueryItem("type", "csv")
        url.addQueryItem("wktField", "wkt")
        url.addQueryItem("spatialIndex", "no")
        url.addQueryItem("subsetIndex", "no")
        url.addQueryItem("watchFile", "no")

        cls.vl_poly = QgsVectorLayer(url.toString(), u'test_polygon', u'delimitedtext')
        assert cls.vl_poly.isValid(), "{} is invalid".format(cls.basetestpolyfile)
        cls.poly_provider = cls.vl_poly.dataProvider()
Exemple #2
0
 def __getReply(self, params):
     url = QUrl('http://ws.audioscrobbler.com/2.0/')
     url.addQueryItem('api_key', self.__last_fm_key)
     for key, value in params.iteritems():
         url.addQueryItem(key, value)
     request = QNetworkRequest(url)
     return self.__networkManager.get(request)
Exemple #3
0
class DownloadFtp(Download):
    def __init__(self, file_share, local_path, date):
        Download.__init__(self, file_share, local_path, date)
        self.ftp = QFtp(self)
        self.ftp.dataTransferProgress.connect(self.update_progress)
        self.ftp.done.connect(self.download_finished)
        self.ftp.stateChanged.connect(self.state_changed)
        self.url = QUrl(self._file_share.url)
        self.out_file = QFile(self.local_path)

        self.read_bytes = self.out_file.size() 
 
    def start_download(self):
        self.ftp.connectToHost(self.url.host(), self.url.port(21))
        self.ftp.login()
        
        if self.out_file.open(QIODevice.WriteOnly):
            self.ftp.get(self.url.path(), self.out_file)

    def stop(self):
        self.ftp

    def state_changed(self, state):
        if state == 1 or state == 2:
            self._state = 1

    def download_finished(self, _):
        print "finished !"

    def update_progress(self, read_bytes, total_bytes):
        self.read_bytes = read_bytes
Exemple #4
0
 def setup(self, parent=None, caption=str("Sélectionnez")) :
     self.setFileMode(self.ExistingFiles)
     icon = QtGui.QIcon()
     icon.addPixmap(QtGui.QPixmap(_fromUtf8("resources/PL128.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
     self.setWindowIcon(icon)
     mydir = str(os.environ['USERPROFILE'])
     thedir = QDir("C:/")
     self.setDirectory(thedir)
     url = []
     url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.DocumentsLocation)))
     url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.DesktopLocation)))
     url.append(QUrl.fromLocalFile(QDesktopServices.storageLocation(QDesktopServices.HomeLocation)))
     url.append(QUrl('file:'))
     self.setSidebarUrls(url)
     # self.setDirectory(mydir)
     self.setWindowModality(QtCore.Qt.ApplicationModal)
     MyFileDialog.setNameFilter(self, "Epub (*.epub)")
     self.setLabelText(self.LookIn, "Regarder dans :")
     self.setLabelText(self.FileName, "Fichier")
     self.setLabelText(self.FileType, "Type de fichier")
     self.setLabelText(self.Accept, "Ouvrir")
     self.setLabelText(self.Reject, "Annuler")
     self.setWindowTitle("Sélectionnez un ou plusieurs fichiers")
     self.setOption(self.DontUseNativeDialog, False)
     # self.setOption(self.DontResolveSymlinks, True)
     self.setOption(self.ShowDirsOnly, False)
     self.tree = self.findChild(QtGui.QTreeView)
     self.init_ui()
     self.filesSelected.connect(self.cur_change)
     self.filesSelected.connect(self.choose_file)
Exemple #5
0
 def load(self, url=None, encoding=None, keepUndo=False):
     """Load the specified or current url (if None was specified).
     
     Currently only local files are supported. An IOError is raised
     when trying to load a nonlocal URL.
     
     If loading succeeds and an url was specified, the url is make the
     current url (by calling setUrl() internally).
     
     If keepUndo is True, the loading can be undone (with Ctrl-Z).
     
     """
     if url is None:
         url = QUrl()
     u = url if not url.isEmpty() else self.url()
     text = self.load_data(u, encoding or self._encoding)
     if keepUndo:
         c = QTextCursor(self)
         c.select(QTextCursor.Document)
         c.insertText(text)
     else:
         self.setPlainText(text)
     self.setModified(False)
     if not url.isEmpty():
         self.setUrl(url)
     self.loaded()
     app.documentLoaded(self)
Exemple #6
0
 def command(self, command):
     """Perform one command."""
     command = command.split()
     cmd = command[0]
     args = command[1:]
     
     win = QApplication.activeWindow()
     if win not in app.windows:
         if not app.windows:
             import mainwindow
             mainwindow.MainWindow().show()
         win = app.windows[0]
     
     if cmd == b'open':
         url = QUrl.fromEncoded(args[0])
         win.openUrl(url, self.encoding)
     elif cmd == b'encoding':
         self.encoding = str(args[0])
     elif cmd == b'activate_window':
         win.activateWindow()
         win.raise_()
     elif cmd == b'set_current':
         url = QUrl.fromEncoded(args[0])
         win.setCurrentDocument(app.openUrl(url, self.encoding))
     elif cmd == b'set_cursor':
         line, column = map(int, args)
         cursor = win.textCursor()
         pos = cursor.document().findBlockByNumber(line - 1).position() + column
         cursor.setPosition(pos)
         win.currentView().setTextCursor(cursor)
     elif cmd == b'bye':
         self.close()
Exemple #7
0
    def downloadFile(self, url, archivo_destino):
        url = QUrl(url)
        fileName = archivo_destino
        directorio_usuario_para_pilas = os.path.dirname(archivo_destino)

        if not os.path.exists(directorio_usuario_para_pilas):
            os.mkdir(directorio_usuario_para_pilas)

        if QFile.exists(fileName):
            QFile.remove(fileName)

        self.outFile = QFile(fileName)

        if not self.outFile.open(QIODevice.WriteOnly):
            QMessageBox.information(self, 'Error', 'Lo siento, no se puede descargar el archivo desde %s: %s.' % (self.url, self.outFile.errorString()))
            self.outFile = None
            return

        mode = QHttp.ConnectionModeHttp
        port = url.port()
        if port == -1:
            port = 0
        self.http.setHost(url.host(), mode, port)
        self.httpRequestAborted = False

        path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/")
        if path:
            path = str(path)
        else:
            path = '/'

        self.httpGetId = self.http.get(path, self.outFile)
Exemple #8
0
 def save(self, url=None, encoding=None):
     """Saves the document to the specified or current url.
     
     Currently only local files are supported. An IOError is raised
     when trying to save a nonlocal URL.
     
     If saving succeeds and an url was specified, the url is made the
     current url (by calling setUrl() internally).
     
     """
     if url is None:
         url = QUrl()
     u = url if not url.isEmpty() else self.url()
     filename = u.toLocalFile()
     # currently, we do not support non-local files
     if not filename:
         raise IOError("not a local file")
     # keep the url if specified when we didn't have one, even if saving
     # would fail
     if self.url().isEmpty() and not url.isEmpty():
         self.setUrl(url)
     with app.documentSaving(self):
         with open(filename, "wb") as f:
             f.write(self.encodedText())
             f.flush()
             os.fsync(f.fileno())
         self.setModified(False)
         if not url.isEmpty():
             self.setUrl(url)
     self.saved()
     app.documentSaved(self)
Exemple #9
0
 def showPackage(self, item):
     row = item.row()
     tmp = self.packageTable.item(row, 1)
     package = tmp.text()
     home = QUrl(self.home)
     curr = QUrl("../../library/%s/html/00Index.html" % package)
     self.htmlViewer.setSource(home.resolved(curr))
    def downloadFile(self):
        url = QUrl(self.url_to_download)

        fileName = QFileDialog.getSaveFileName(self, "Enregistrer la liste des dossiers", self.nameFile, "conf")

        if QFile.exists(fileName):
            QFile.remove(fileName)

        self.outFile = QFile(fileName)
        if not self.outFile.open(QIODevice.WriteOnly):
            QMessageBox.information(self, 'Erreur','Impossible d\'enregistrer le fichier %s: %s.' % (fileName, self.outFile.errorString()))
            self.outFile = None
            return

        #Création que la connexion HTTPS
        mode = QHttp.ConnectionModeHttps
        port = 0
        self.http.setHost(url.host(), mode, port)
        
        self.requeteHTTPannule = False
        path = QUrl.toPercentEncoding(url.path(), "!$&'()*+,;=:@/")
        if path:
            path = str(path)
        else:
            path = '/'

        #Concaténation des paramètres à l'URL
        path = path+("?")
        for item in url.queryItems():
            path = path + item[0] + "=" + item[1] + "&" 
        
        self.http.setUser(self.login, self.password)
        self.httpGetId = self.http.get(path, self.outFile)
Exemple #11
0
    def createRequest(self, op, req, data):
        #print "createRequest: req.url()", req.url()

        if req.url().host() != "webodf":
            return super(WebODFNetworkManager, self).createRequest(op, req, data);

        path = QUrl("http://webodf/").resolved(req.url()).path()

        print "Request for", path

        if op == QNetworkAccessManager.GetOperation:
            reply = None;
            if path.startswith("/dijit"):
                path = "/wodo" + path # TODO: why gets wodo/ lost?
            resourcePath = Resources.get("documentsharing"+path)
            if os.path.exists(resourcePath):
                print "reply for resource:", resourcePath
                reply = ResourceReply(resourcePath, self)
            elif path == self.genesisDocumentPath:
                print "reply for genesis document:", self.genesisDocumentPath
                reply = ResourceReply(self.genesisDocumentPath, self)
            else:
                avatarUrl = self.sessionBackend.resolveAvatarUrl(path)
                if avatarUrl != "":
                    print "reply for avatar url:", avatarUrl
                    reply = ResourceReply(avatarUrl, self)

            if reply is not None:
                return  reply

            print "Request for unknown resource:", path

        return super(WebODFNetworkManager, self).createRequest(op, req, data)
Exemple #12
0
	def from_user_input(userInput):
		# Toma una URL en string y la transforma a un QUrl bien formado
		userInput = QString(userInput)
		
		trimmedString = userInput.trimmed()

		url = QUrl.fromEncoded(trimmedString.toUtf8(), QUrl.TolerantMode)
		urlPrepended = QUrl.fromEncoded((QLatin1String("http://") + trimmedString).toUtf8(), QUrl.TolerantMode)
	
		# Check the most common case of a valid url with scheme and host
		# We check if the port would be valid by adding the scheme to handle the case host:port
		# where the host would be interpretted as the scheme
		if (url.isValid()
			and not url.scheme().isEmpty()
			and (not url.host().isEmpty() or not url.path().isEmpty())
			and urlPrepended.port() == -1):
			return url
	
		# Else, try the prepended one and adjust the scheme from the host name
		if (urlPrepended.isValid() and (not urlPrepended.host().isEmpty() or not urlPrepended.path().isEmpty())):
			dotIndex = trimmedString.indexOf(".")
			hostscheme = trimmedString.left(dotIndex).toLower()
			if (hostscheme == QLatin1String("ftp")):
				urlPrepended.setScheme(QLatin1String("ftp"))
			return urlPrepended
	
		return QUrl() 
 def test_rowid(self):
     source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp"))
     query = QUrl.toPercentEncoding("select rowid as uid, * from vtab limit 1 offset 3")
     l = QgsVectorLayer("?layer=ogr:%s:vtab&query=%s" % (source, query), "vtab2", "virtual", False)
     # the last line must have a fixed rowid (not an autoincrement)
     for f in l.getFeatures():
         lid = f.attributes()[0]
     self.assertEqual(lid, 3)
Exemple #14
0
 def load_account_page(self, account, tab=None, task=None):
     self.tab = tab
     self.task = task
     self.account = account
     url = QUrl(account.server.settings_url)
     for name, value in self.query_items:
         url.addQueryItem(name, value)
     self.load(url)
Exemple #15
0
def email(subject, body):
    """Opens the e-mail composer with the given subject and body, with version information added to it."""
    subject = "[{0} {1}] {2}".format(appinfo.appname, appinfo.version, subject)
    body = "{0}\n\n{1}\n\n".format(debuginfo.version_info_string(' -- '), body)
    url = QUrl("mailto:" + appinfo.maintainer_email)
    url.addQueryItem("subject", subject)
    url.addQueryItem("body", body)
    helpers.openUrl(url, "email")
Exemple #16
0
 def dropEvent(self, e):
     logger.debug(msg("Drag drop event"))
     file_url = QUrl(e.mimeData().text())
     if file_url.isValid() and file_url.isLocalFile():
         fname = file_url.toLocalFile()
         if fname in self.watcher.files():
             logger.debug(msg("already watching file", fname))
         else:
             self.watch_file(file_url.toLocalFile())
    def test_filter_rect(self):
        source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp"))

        query = QUrl.toPercentEncoding("select * from vtab where _search_frame_=BuildMbr(-2.10,49.38,-1.3,49.99,4326)")
        l2 = QgsVectorLayer("?layer=ogr:%s:vtab&query=%s&uid=objectid" % (source, query), "vtab2", "virtual", False)
        self.assertEqual(l2.isValid(), True)
        self.assertEqual(l2.dataProvider().featureCount(), 1)
        a = [fit.attributes()[4] for fit in l2.getFeatures()]
        self.assertEqual(a, [u"Basse-Normandie"])
    def test_sql2(self):
        l2 = QgsVectorLayer(os.path.join(self.testDataDir, "france_parts.shp"), "france_parts", "ogr", False)
        self.assertEqual(l2.isValid(), True)
        QgsMapLayerRegistry.instance().addMapLayer(l2)

        query = QUrl.toPercentEncoding("SELECT * FROM france_parts")
        l4 = QgsVectorLayer("?query=%s" % query, "tt", "virtual")
        self.assertEqual(l4.isValid(), True)

        self.assertEqual(l4.dataProvider().geometryType(), 3)
        self.assertEqual(l4.dataProvider().crs().postgisSrid(), 4326)

        n = 0
        r = QgsFeatureRequest(QgsRectangle(-1.677, 49.624, -0.816, 49.086))
        for f in l4.getFeatures(r):
            self.assertEqual(f.geometry() is not None, True)
            self.assertEqual(f.attributes()[0], 2661)
            n += 1
        self.assertEqual(n, 1)

        # use uid
        query = QUrl.toPercentEncoding("SELECT * FROM france_parts")
        l5 = QgsVectorLayer("?query=%s&geometry=geometry:polygon:4326&uid=ObjectId" % query, "tt", "virtual")
        self.assertEqual(l5.isValid(), True)

        idSum = sum(f.id() for f in l5.getFeatures())
        self.assertEqual(idSum, 10659)

        r = QgsFeatureRequest(2661)
        idSum2 = sum(f.id() for f in l5.getFeatures(r))
        self.assertEqual(idSum2, 2661)

        r = QgsFeatureRequest()
        r.setFilterFids([2661, 2664])
        self.assertEqual(sum(f.id() for f in l5.getFeatures(r)), 2661 + 2664)

        # test attribute subset
        r = QgsFeatureRequest()
        r.setFlags(QgsFeatureRequest.SubsetOfAttributes)
        r.setSubsetOfAttributes([1])
        s = [(f.id(), f.attributes()[1]) for f in l5.getFeatures(r)]
        self.assertEqual(sum(map(lambda x: x[0], s)), 10659)
        self.assertEqual(sum(map(lambda x: x[1], s)), 3064.0)

        # test NoGeometry
        # by request flag
        r = QgsFeatureRequest()
        r.setFlags(QgsFeatureRequest.NoGeometry)
        self.assertEqual(all([f.geometry() is None for f in l5.getFeatures(r)]), True)

        # test subset
        self.assertEqual(l5.dataProvider().featureCount(), 4)
        l5.setSubsetString("ObjectId = 2661")
        idSum2 = sum(f.id() for f in l5.getFeatures(r))
        self.assertEqual(idSum2, 2661)
        self.assertEqual(l5.dataProvider().featureCount(), 1)
Exemple #19
0
def startmain():
    import optparse
    optparse._ = _ # let optparse use our translations
    parser = optparse.OptionParser(
        usage = _("{appname} [options] file ...").format(appname=info.name),
        version = "{0} {1}".format(info.appname, info.version),
        description = _("A LilyPond Music Editor"))
    parser.add_option('-e', '--encoding', metavar=_("ENC"),
        help=_("Encoding to use"))
    parser.add_option('-l', '--line', type="int", metavar=_("NUM"),
        help=_("Line number to go to, starting at 1"))
    parser.add_option('-c', '--column', type="int", metavar=_("NUM"),
        help=_("Column to go to, starting at 0"), default=0)
    parser.add_option('--start', metavar=_("NAME"),
        help=_("Session to start ('{none}' for empty session)").format(none="none"),
        dest="session")

    args = QApplication.arguments()
    if os.name == 'nt' and args and 'python' in os.path.basename(args[0]).lower():
        args = args[2:]
    else:
        args = args[1:]
    options, files = parser.parse_args(args)

    # load specified session
    doc = None
    if options.session and options.session != "none":
        doc = sessions.loadSession(options.session)
        
    # Just create one MainWindow
    win = mainwindow.MainWindow()
    win.show()
    
    if files:
        # make urls
        for arg in files:
            if re.match(r'^(https?|s?ftp)://', arg):
                url = QUrl(arg)
            elif arg.startswith('file://'):
                url = QUrl.fromLocalFile(arg[7:])
            elif arg.startswith('file:'):
                url = QUrl.fromLocalFile(os.path.abspath(arg[5:]))
            else:
                url = QUrl.fromLocalFile(os.path.abspath(arg))
            doc = win.openUrl(url, options.encoding)
    elif not options.session:
        # no docs, load default session
        doc = sessions.loadDefaultSession()
    win.setCurrentDocument(doc or document.Document())
    if files and options.line is not None:
        # set the last loaded document active and apply navigation if requested
        pos = doc.findBlockByNumber(options.line - 1).position() + options.column
        cursor = QTextCursor(doc)
        cursor.setPosition(pos)
        win.currentView().setTextCursor(cursor)
        win.currentView().centerCursor()
Exemple #20
0
def logo_element():
    """Create a sanitised local url to the logo for insertion into html.

    :returns: A sanitised local url to the logo.
    :rtype: str
    """
    path = os.path.join(resources_path(), 'img', 'logos', 'inasafe-logo.png')
    url = QUrl(path)
    path = url.toLocalFile()
    return path
    def test_DynamicGeometry(self):
        l1 = QgsVectorLayer(QUrl.fromLocalFile(os.path.join(self.testDataDir, "delimitedtext/testextpt.txt")).toString() + "?type=csv&delimiter=%7C&geomType=none&subsetIndex=no&watchFile=no", "test", "delimitedtext", False)
        self.assertEqual(l1.isValid(), True)
        QgsMapLayerRegistry.instance().addMapLayer(l1)

        query = QUrl.toPercentEncoding("select *,makepoint(x,y) as geom from vtab1")
        l2 = QgsVectorLayer("?layer_ref=%s&query=%s&geometry=geom:point:0&uid=id" % (l1.id(), query), "vtab", "virtual", False)
        self.assertEqual(l2.isValid(), True)

        QgsMapLayerRegistry.instance().removeMapLayer(l1)
    def test_reopen2(self):
        source = QUrl.toPercentEncoding(os.path.join(self.testDataDir, "france_parts.shp"))
        tmp = QUrl.fromLocalFile(os.path.join(tempfile.gettempdir(), "t.sqlite")).toString()
        l = QgsVectorLayer("%s?layer=ogr:%s:vtab&nogeometry" % (tmp, source), "vtab2", "virtual", False)
        self.assertEqual(l.isValid(), True)

        l2 = QgsVectorLayer(tmp, "tt", "virtual", False)
        self.assertEqual(l2.isValid(), True)
        self.assertEqual(l2.dataProvider().geometryType(), 100)
        self.assertEqual(l2.dataProvider().featureCount(), 4)
    def test_refLayers2(self):
        l1 = QgsVectorLayer(QUrl.fromLocalFile(os.path.join(self.testDataDir, "delimitedtext/test.csv")).toString() + "?type=csv&geomType=none&subsetIndex=no&watchFile=no", "test", "delimitedtext", False)
        self.assertEqual(l1.isValid(), True)
        QgsMapLayerRegistry.instance().addMapLayer(l1)

        # referenced layers cannot be stored !
        tmp = QUrl.fromLocalFile(os.path.join(tempfile.gettempdir(), "t.sqlite")).toString()
        l2 = QgsVectorLayer("%s?layer_ref=%s" % (tmp, l1.id()), "tt", "virtual", False)
        self.assertEqual(l2.isValid(), False)
        self.assertEqual("Cannot store referenced layers" in l2.dataProvider().error().message(), True)
Exemple #24
0
def url(arg):
    """Converts a filename-like argument to a QUrl."""
    if re.match(r'^(https?|s?ftp)://', arg):
        return QUrl(arg)
    elif arg.startswith('file://'):
        return QUrl.fromLocalFile(os.path.abspath(arg[7:]))
    elif arg.startswith('file:'):
        return QUrl.fromLocalFile(os.path.abspath(arg[5:]))
    else:
        return QUrl.fromLocalFile(os.path.abspath(arg))
Exemple #25
0
def _render_header(title, mode, phrase, filters):
    r = []
    r.append(ADV_HEADER)
    r.append('<h1>{0}</h1>'.format(title))
    r.append('<ul class="nav">\n')

    modes = [(name, spec) for (name, spec) in MODE_DICT.items()]
    modes.sort(key=itemgetter(0))

    for (name, spec) in modes:
        href = QUrl('search:///')
        if phrase:
            href.addQueryItem('phrase', phrase)
        if filters:
            href.addQueryItem('filters', filters)
        href.addQueryItem('mode', name)
        if name != mode:
            r.append(
                '<li><a href="{href}">{title}</a></li>\n'.format(
                    href=href.toEncoded(), title=spec['title']))
        else:
            r.append(
                '<li><span class="sel">{title}<span></li>\n'.format(
                    href=href.toEncoded(), title=spec['title']))

    r.append('</ul>\n')

    return ''.join(r)
class DelayNagvisWidget(DelayWidget):
	def __init__(self, name, cfg, parent = None):
		DelayWidget.__init__(self, name, cfg, parent)

		self.realUrl = QUrl()
		self.realUrl.setUrl(self.config.loadLinks()[str(self.objectName())]['data'])

	def resizeEvent(self, event):
		self.url.setUrl('%s&width=%d&height=%d' % (self.realUrl.toString(),
								self.width()/self.webView.zoomFactor()-20,
								self.height()/self.webView.zoomFactor()-65))
    def _sendRequest(self, url, params):
        if self.asynchonous:
            url = QUrl(url)
            for key, value in params.iteritems():
                url.addQueryItem(key, value)
            request = QNetworkRequest(url)
            self.reply = self.manager.get(request)

        else:
            response = urllib2.urlopen(self.url + '?' + urllib.urlencode(params))
            data = json.load(response)
            self.loadData(data)
Exemple #28
0
	def onNameSelectChange(self):
		try:
			l = self.links[str(self.nameSelect.currentText())]
			u = QUrl(l['data'])

			self.name.setText(u.userName())
			self.passwd.setText(u.password())
			self.urlEdit.setText(u.toString(QUrl.RemoveUserInfo))
			self.typeSelect.setCurrentIndex(self.typeSelect.findText(l['type']))
		except Exception as e:
			#print e
			pass
    def test1(self):
        d = QgsVirtualLayerDefinition()
        self.assertEqual(d.toString(), "")
        d.setFilePath("/file")
        self.assertEqual(d.toString(), "file:///file")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).filePath(), "/file")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).filePath(), "/file")
        d.setFilePath("C:\\file")
        self.assertEqual(d.toString(), "file:///C:%5Cfile")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).filePath(), "C:\\file")
        d.setQuery("SELECT * FROM mytable")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).query(), "SELECT * FROM mytable")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).query(), "SELECT * FROM mytable")

        q = u"SELECT * FROM tableéé /*:int*/"
        d.setQuery(q)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).query(), q)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).query(), q)

        s1 = u"file://foo&bar=okié"
        d.addSource("name", s1, "provider", "utf8")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[0].source(), s1)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[0].source(), s1)

        n1 = u"éé ok"
        d.addSource(n1, s1, "provider")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[1].name(), n1)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[1].name(), n1)

        d.addSource("ref1", "id0001")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[2].reference(), "id0001")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[2].reference(), "id0001")

        s = "dbname='C:\\tt' table=\"test\" (geometry) sql="
        d.addSource("nn", s, "spatialite")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).sourceLayers()[3].source(), s)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).sourceLayers()[3].source(), s)

        d.setGeometryField("geom")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).geometryField(), "geom")
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).geometryField(), "geom")

        d.setGeometryWkbType(QgsWKBTypes.Point)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(d.toUrl()).geometryWkbType(), QgsWKBTypes.Point)
        self.assertEqual(QgsVirtualLayerDefinition.fromUrl(QUrl.fromEncoded(d.toString())).geometryWkbType(), QgsWKBTypes.Point)

        f = QgsFields()
        f.append(QgsField("a", QVariant.Int))
        f.append(QgsField("f", QVariant.Double))
        f.append(QgsField("s", QVariant.String))
        d.setFields(f)
        f2 = QgsVirtualLayerDefinition.fromUrl(d.toUrl()).fields()
        self.assertEqual(f[0].name(), f2[0].name())
        self.assertEqual(f[0].type(), f2[0].type())
        self.assertEqual(f[1].name(), f2[1].name())
        self.assertEqual(f[1].type(), f2[1].type())
        self.assertEqual(f[2].name(), f2[2].name())
        self.assertEqual(f[2].type(), f2[2].type())
Exemple #30
0
def extract_domain(hstr, qstr=True):
	if not isinstance(hstr, QUrl):
		hstr = QUrl(hstr)
	hstr = hstr.authority()
	if not isinstance(hstr, unicode):
		hstr = unicode(hstr)
	if '.' not in hstr or REGEXP_IP_ADDRESS.match(hstr):
		return QString(hstr) if qstr else hstr
	hstr = hstr.split('.')
	lhstr = len(hstr)
	hstr = hstr[lhstr-2] + '.' + hstr[lhstr-1]
	return QString(hstr) if qstr else hstr
Exemple #31
0
    def __init__(self, layer, settingsdict={}):
        #show the user this may take a long time...
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))

        self.settingsdict = settingsdict
        provider = layer.dataProvider()  # OGR provider
        kolumnindex = provider.fieldNameIndex(
            'obsid')  # To find the column named 'obsid'
        observations = layer.selectedFeatures()

        reportfolder = os.path.join(QDir.tempPath(), 'midvatten_reports')
        if not os.path.exists(reportfolder):
            os.makedirs(reportfolder)
        reportpath = os.path.join(reportfolder, "w_qual_report.html")
        #f = open(reportpath, "wb" )
        f = codecs.open(reportpath, "wb", "utf-8")

        #write some initiating html
        rpt = r"""<head><title>%s</title></head>""" % ru(
            QCoreApplication.translate(
                u'Wqualreport',
                u'water quality report from Midvatten plugin for QGIS'))
        rpt += r""" <meta http-equiv="content-type" content="text/html; charset=utf-8" />"""  #NOTE, all report data must be in 'utf-8'
        rpt += "<html><body>"
        #rpt += "<table width=\"100%\" border=\"1\">\n"
        #rpt2 = rpt.encode("utf-8")
        f.write(rpt)

        dbconnection = db_utils.DbConnectionManager()

        for i, object in enumerate(observations):
            attributes = observations[i]
            obsid = attributes[kolumnindex]
            try:
                print('about to get data for ' + obsid + ', at time: ' +
                      str(time.time()))  #debug
            except:
                pass
            ReportData = self.GetData(
                self.settingsdict['database'], obsid,
                dbconnection)  # one observation at a time
            try:
                print('done with getting data for ' + obsid + ', at time: ' +
                      str(time.time()))  #debug
            except:
                pass
            if ReportData:
                self.WriteHTMLReport(ReportData, f)
            try:
                print('wrote html report for ' + obsid + ', at time: ' +
                      str(time.time()))  #debug
            except:
                pass

        dbconnection.closedb()
        #write some finishing html and close the file
        f.write("\n</body></html>")
        f.close()

        QApplication.restoreOverrideCursor(
        )  #now this long process is done and the cursor is back as normal

        if ReportData:
            QDesktopServices.openUrl(QUrl.fromLocalFile(reportpath))
Exemple #32
0
 def loadTestSite(self):
     #url = QUrl("file:///home/mlatu/work/saltyStele/test.html")
     url = QUrl("file:///d:/test.html")
     self.browser.load(url)
Exemple #33
0
 def _open_url(url):
     QDesktopServices.openUrl(QUrl(url))
Exemple #34
0
    def __init__(self,
                 parent=None,
                 bridge=None,
                 options=None,
                 *,
                 highchart='Chart',
                 enable_zoom=False,
                 enable_select=False,
                 selection_callback=None,
                 javascript='',
                 debug=False,
                 **kwargs):
        options = (options or {}).copy()
        enable_select = enable_select or ''

        if not isinstance(options, dict):
            raise ValueError('options must be dict')
        if enable_select not in ('', '+', 'x', 'y', 'xy', 'x+', 'y+', 'xy+'):
            raise ValueError("enable_select must be '+', 'x', 'y', or 'xy'")
        if enable_select and not selection_callback:
            raise ValueError('enable_select requires selection_callback')

        super().__init__(parent,
                         bridge,
                         debug=debug,
                         url=QUrl(self._HIGHCHARTS_HTML))
        self.debug = debug
        self.highchart = highchart
        self.enable_zoom = enable_zoom
        enable_point_select = '+' in enable_select
        enable_rect_select = enable_select.replace('+', '')
        if enable_zoom:
            _merge_dicts(
                options,
                _kwargs_options(
                    dict(mapNavigation_enableMouseWheelZoom=True,
                         mapNavigation_enableButtons=False)))
        if enable_select:
            self._selection_callback = selection_callback
            self.frame.addToJavaScriptWindowObject('__highchart', self)
            _merge_dicts(
                options,
                _kwargs_options(
                    dict(chart_events_click='/**/unselectAllPoints/**/')))
        if enable_point_select:
            _merge_dicts(
                options,
                _kwargs_options(
                    dict(plotOptions_series_allowPointSelect=True,
                         plotOptions_series_point_events_click=
                         '/**/clickedPointSelect/**/')))
        if enable_rect_select:
            _merge_dicts(
                options,
                _kwargs_options(
                    dict(chart_zoomType=enable_rect_select,
                         chart_events_selection='/**/rectSelectPoints/**/')))
        if kwargs:
            _merge_dicts(options, _kwargs_options(kwargs))

        self.frame.loadFinished.connect(lambda: self.evalJS('''
                {javascript};
                var options = {options};
                fixupOptionsObject(options);
                Highcharts.setOptions(options);
                '''.format(javascript=javascript, options=json(options))))
        # Give above scripts time to load
        qApp.processEvents(QEventLoop.ExcludeUserInputEvents)
        qApp.processEvents(QEventLoop.ExcludeUserInputEvents)
Exemple #35
0
def openfolder(folder):
    """
    Open a folder using the OS
    :param folder: The path to the folder to open.
    """
    QDesktopServices.openUrl(QUrl.fromLocalFile(folder))
Exemple #36
0
 def htmlUrl(self):
     """Helper to get the url of the html doc."""
     myPath = os.path.join(TEST_DATA_DIR, "html_table.html")
     myUrl = QUrl("file:///" + myPath)
     return myUrl
Exemple #37
0
 def openHelpURL(self, q_string):
     url = QUrl(q_string)
     QDesktopServices.openUrl(url)
Exemple #38
0
 def load(self, url):
     self.page.mainFrame().setUrl(QUrl(url))
Exemple #39
0
def openfolder(folder):
    QDesktopServices.openUrl(QUrl.fromLocalFile(folder)) 
Exemple #40
0
	def _return_pressed(self):
		url = QUrl(self.text())
		browser.load(url)
Exemple #41
0
    def print_impact_table(self, output_path):
        """Pint summary from impact layer to PDF.

        ..note:: The order of the report:
            1. Summary table
            2. Aggregation table
            3. Attribution table

        :param output_path: Output path.
        :type output_path: str

        :return: Path to generated pdf file.
        :rtype: str

        :raises: None
        """
        keywords = self._keyword_io.read_keywords(self.layer)

        if output_path is None:
            output_path = unique_filename(suffix='.pdf', dir=temp_dir())

        summary_table = keywords.get('impact_summary', None)
        full_table = keywords.get('impact_table', None)
        aggregation_table = keywords.get('postprocessing_report', None)
        attribution_table = impact_attribution(keywords)

        # (AG) We will not use impact_table as most of the IF use that as:
        # impact_table = impact_summary + some information intended to be
        # shown on screen (see FloodOsmBuilding)
        # Unless the impact_summary is None, we will use impact_table as the
        # alternative
        html = m.Brand().to_html()
        html += m.Heading(tr('Analysis Results'), **INFO_STYLE).to_html()
        if summary_table is None:
            html += full_table
        else:
            html += summary_table

        if aggregation_table is not None:
            html += aggregation_table

        if attribution_table is not None:
            html += attribution_table.to_html()

        html = html_header() + html + html_footer()

        # Print HTML using composition
        # For QGIS < 2.4 compatibility
        # QgsMapSettings is added in 2.4
        if qgis_version() < 20400:
            map_settings = QgsMapRenderer()
        else:
            map_settings = QgsMapSettings()

        # A4 Portrait
        # TODO: Will break when we try to use larger print layouts TS
        paper_width = 210
        paper_height = 297

        # noinspection PyCallingNonCallable
        composition = QgsComposition(map_settings)
        # noinspection PyUnresolvedReferences
        composition.setPlotStyle(QgsComposition.Print)
        composition.setPaperSize(paper_width, paper_height)
        composition.setPrintResolution(300)

        # Add HTML Frame
        # noinspection PyCallingNonCallable
        html_item = QgsComposerHtml(composition, False)
        margin_left = 10
        margin_top = 10

        # noinspection PyCallingNonCallable
        html_frame = QgsComposerFrame(composition, html_item, margin_left,
                                      margin_top,
                                      paper_width - 2 * margin_left,
                                      paper_height - 2 * margin_top)
        html_item.addFrame(html_frame)

        # Set HTML
        # From QGIS 2.6, we can set composer HTML with manual HTML
        if qgis_version() < 20600:
            html_path = unique_filename(prefix='report',
                                        suffix='.html',
                                        dir=temp_dir())
            html_to_file(html, file_path=html_path)
            html_url = QUrl.fromLocalFile(html_path)
            html_item.setUrl(html_url)
        else:
            # noinspection PyUnresolvedReferences
            html_item.setContentMode(QgsComposerHtml.ManualHtml)
            # noinspection PyUnresolvedReferences
            html_item.setResizeMode(QgsComposerHtml.RepeatUntilFinished)
            html_item.setHtml(html)
            # RMN: This line below breaks in InaSAFE Headless after one
            # successful call. This is because the function is not
            # thread safe. Can't do anything about this, so avoid calling this
            # function in multithreaded way.
            html_item.loadHtml()

        composition.exportAsPDF(output_path)
        return output_path
Exemple #42
0
 def setContent(self, data, mimetype, base_url=''):
     """Set the content `data` of type `mimetype` in the current webframe."""
     super().setContent(data, mimetype, QUrl(base_url))
Exemple #43
0
        kakasi = KakasiController()
        mecab = MecabController()
        if USE_MECAB:
            mecab.ensureOpen()
            tool = mecab
        else:
            tool = kakasi
        addHook('fact.focusLost', onFocusLost)
    except Exception:
        if sys.platform.startswith("win32"):
            from PyQt4.QtGui import QDesktopServices
            from PyQt4.QtCore import QUrl
            from ankiqt.ui.utils import showInfo
            showInfo("Please install anki-reading.exe")
            QDesktopServices.openUrl(
                QUrl("http://ichi2.net/anki/wiki/JapaneseSupport"))
        raise

# Ctrl+g shortcut, based on Samson's regenerate reading field plugin
##########################################################################


def genReading(self):
    # make sure current text is saved
    self.saveFieldsNow()
    # find the first src field available
    reading = None
    for f in srcFields:
        try:
            reading = tool.reading(self.fact[f])
            break
Exemple #44
0
 def _return_pressed(self):
     url = QUrl(self.text())
     # load url into browser frame
     self.cb(url)
Exemple #45
0
        json_string = webURL.read()
        encoding = webURL.info().get_content_charset('utf-8')
        parsed_json = json.loads(json_string.decode(encoding))
        temp_f = parsed_json['current_observation']['temp_c']
        relative_humidity = parsed_json['current_observation']['relative_humidity']
        wind_dir = parsed_json['current_observation']['wind_dir']
        wind_kph = parsed_json['current_observation']['wind_kph']
        self.ln_ctmp.setText(str(temp_f))
        self.ln_relh.setText(str(relative_humidity))
        self.ln_wndsp.setText(str(wind_kph))
        self.ln_wnd.setText(str(wind_dir))
        webURL.close()

if __name__ == "__main__": 
       
    print ("Operation started")
    
    #initdatabases()
     
    app = QtGui.QApplication(sys.argv)
    
    myWindow = MyWindowClass()
       
    myWindow.webView.load(QUrl('http://localhost/attendance/livedata')) 
            
    scheduler.start() 
    
    myWindow.showMaximized()
    
    sys.exit(app.exec_())
Exemple #46
0
def simple_link_handler(url):
    u"""Play the file."""
    if url.startswith("ankiplay"):
        play(url[8:])
    else:
        QDesktopServices.openUrl(QUrl(url))
class NetworkMixin(object):
    """A mixin that can be used to send network request and receive replies."""

    request_url = str
    error = None
    results = None

    def __init__(self, request_url, geojson=False):
        self.request_url = request_url
        self.manager = QgsNetworkAccessManager.instance()
        self.reply = None
        self.url = QUrl(self.request_url)
        self.req = QNetworkRequest(self.url)
        self.results = QByteArray()
        self.auth_token = get_authtoken()

        # Paginated data
        self._pagination_exhausted = False
        self.geojson = geojson
        if geojson:
            self.combine_new_data = self.combine_new_geojson_data

    def cancel_request(self):
        """Abort the request."""
        self.reply.abort()

    def connect_request(self):
        """Process the request."""
        LOGGER.info('Requesting "%s"', self.request_url)
        self.reply.readyRead.connect(self.connection_read_data)
        self.reply.finished.connect(self.connection_finished)
        self.reply.error.connect(self.connection_error)

    def connect_paginated_request(self, prev_data, callback):
        """Process the request of a paginated resource."""
        LOGGER.info('Requesting "%s" (paginated)', self.request_url)
        self.reply.readyRead.connect(self.connection_read_data)
        self.reply.finished.connect(
            functools.partial(self._handle_paginated_data, prev_data,
                              callback))
        self.reply.error.connect(self.connection_error)

    def connect_get(self):
        """Send get request."""
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)
        self.reply = self.manager.get(self.req)
        self.connect_request()

    def connect_post(self, data):
        """Send post request.

        :param data: Context data to use with template
        :type data: QByteArray
        """
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)
        self.reply = self.manager.post(self.req, data)
        self.connect_request()

    def connect_json_post(self, data):
        """Send post request with json string.

        :param data: Json string data
        :type data: str
        """
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)
        self.req.setRawHeader("Content-Type", "application/json")
        self.reply = self.manager.post(self.req, data)
        self.connect_request()

    def connect_json_put(self, data):
        """Send put request with json string.

        :param data: Json string data
        :type data: str
        """
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)

        self.req.setRawHeader("Content-Type", "application/json")
        json_string = QByteArray(data)
        p_buffer = QBuffer(self.manager)
        p_buffer.setData(json_string)

        self.reply = self.manager.sendCustomRequest(self.req, 'PUT', p_buffer)
        self.connect_request()

    def connect_json_patch(self, data):
        """Send patch request with json string.

        :param data: Json string data
        :type data: str
        """
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)

        self.req.setRawHeader("Content-Type", "application/json")
        json_string = QByteArray(data)
        p_buffer = QBuffer(self.manager)
        p_buffer.setData(json_string)

        self.reply = self.manager.sendCustomRequest(self.req, 'PATCH',
                                                    p_buffer)
        self.connect_request()

    def connect_get_paginated(self, prev_data=None, callback=None):
        if self.auth_token:
            # Add authentication token to request
            self.req.setRawHeader('Authorization',
                                  'token %s' % self.auth_token)
        self.reply = self.manager.get(self.req)
        self.connect_paginated_request(
            prev_data or self.results, callback
            or self._set_results_and_complete)

    def _handle_paginated_data(self, prev_data, callback):
        """
        Once all data from single request is returned, merge it with
        previous responses and follow pagination.
        """
        # Add new request's data to prev_data
        resp_txt = str(self.results)
        merged_data = self.combine_new_data(str(prev_data or ''), resp_txt)
        merged_data = QByteArray(merged_data)

        # Get next page
        next_url = None
        try:
            next_url = json.loads(resp_txt).get('next')
        except ValueError:
            pass

        if next_url:
            next_req = NetworkMixin(next_url, geojson=self.geojson)
            return next_req.connect_get_paginated(prev_data=merged_data,
                                                  callback=callback)

        LOGGER.debug('Pagination finished at "%s"', self.request_url)
        callback(merged_data)

    def _set_results_and_complete(self, results):
        self.results = results
        self._pagination_exhausted = True
        self.connection_finished()

    @staticmethod
    def combine_new_data(old_data_str, new_data_str):
        """
        Merge results from new page of data with results from previous
        pages of data.

        Expects a response in a format such as:
            {
                "count": 10,
                "next": null,
                "previous": null,
                "results": [ ... ]
            }
        """
        old_data = ''
        new_data = ''

        try:
            old_data = json.loads(old_data_str or '[]')
            new_data = json.loads(new_data_str)
        except ValueError:
            pass
        results_new_data = []
        if 'results' in new_data:
            results_new_data = new_data['results']
        return json.dumps(old_data + results_new_data)

    @staticmethod
    def combine_new_geojson_data(old_data_str, new_data_str):
        """
        Merge results from new page of GeoJSON data with results from
        previous pages of data.

        Expects a response in a format such as:
            {
                "count": 10,
                "next": null,
                "previous": null,
                "results": {
                    "type": "FeatureCollection",
                    "features": [ ... ]
                }
            }
        """
        old_data = dict()
        new_data = dict()
        try:
            old_data = json.loads(old_data_str or '[]')
            new_data = json.loads(new_data_str)
        except ValueError:
            pass

        if not old_data and 'results' in new_data:
            return json.dumps(new_data['results'])

        if 'features' in old_data and 'results' in new_data:
            old_data['features'] += new_data['results']['features']

        return json.dumps(old_data)

    def connection_read_data(self):
        """Get data from self.reply and append it to results."""
        self.results += self.reply.readAll()

    def get_json_results(self):
        """Convert results to json object."""
        return json.loads(str(self.results))

    def connection_error(self):
        """Handle error connection."""
        error_result = self.reply.error

        try:
            http_code = int(
                self.reply.attribute(QNetworkRequest.HttpStatusCodeAttribute))
        except TypeError:
            http_code = None

        self.http_code = 404
        if error_result == QNetworkReply.UnknownNetworkError:
            msg = 'The network is unreachable.'
        elif error_result == QNetworkReply.ProtocolUnknownError \
                or error_result == QNetworkReply.HostNotFoundError:
            msg = 'Host not found : %s' % self.url.encodedHost()
        else:
            if http_code:
                msg = 'Error code:' + str(http_code)
                self.http_code = http_code
            else:
                msg = 'Can\'t find the server'

        LOGGER.debug(msg)
        self.error = msg

    @abc.abstractmethod
    def connection_finished(self):
        return

    def is_finished(self, paginated=False):
        return (self._pagination_exhausted
                if paginated else self.reply.isFinished())
Exemple #48
0
# coding: utf-8
from PyQt4.QtCore import QUrl
from PyQt4.QtNetwork import QNetworkRequest, QSslError
from qgis.core import QgsNetworkAccessManager
from qgis.gui import QgsAuthSslErrorsDialog

url = 'http://fm4dd.com/openssl/source/PEM/certs/1024b-rsa-example-cert.pem'

networkAccessManager = QgsNetworkAccessManager.instance()
req = QNetworkRequest(QUrl(url))
reply = networkAccessManager.get(
    req)  # Return a QNetworkReply (http://doc.qt.io/qt-4.8/qnetworkreply.html)

auth_ssl_errors_dialog = QgsAuthSslErrorsDialog(
    reply, [QSslError(QSslError.InvalidNotAfterField)])

auth_ssl_errors_dialog.show()
 def load_html(self):
     htmlPath = os.path.dirname(os.path.realpath(
         __file__)) + '/doc/html/about.html'
     self.aboutView.load(QUrl(htmlPath))
Exemple #50
0
 def urlChanged(self, qUrl):
     url = qUrl.toString()
     # Some integrations/auth will get back to /services with no way to get back to chat
     if Resources.SERVICES_URL_RE.match(url):
         self.systemOpen(url)
         self.load(QUrl("https://" + qUrl.host() + "/messages/general"))
Exemple #51
0
 def _open_path(path):
     url = QUrl.fromLocalFile(str(path))
     QDesktopServices.openUrl(url)
Exemple #52
0
 def loadStarted(self):
     # Some custom CSS to clean/fix UX
     self.settings().setUserStyleSheetUrl(
         QUrl.fromLocalFile(Resources.get_path("resources.css")))
Exemple #53
0
 def openOnlineHelp(self):
     """Opens a link to the Freeseer Online Help"""
     url = QUrl("http://freeseer.github.io")
     QDesktopServices.openUrl(url)
    def setupUi(self):
        self.labels = {}
        self.widgets = {}
        self.checkBoxes = {}
        self.showAdvanced = False
        self.valueItems = {}
        self.dependentItems = {}
        self.resize(650, 450)
        self.buttonBox = QDialogButtonBox()
        self.buttonBox.setOrientation(Qt.Horizontal)
        self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
                                          | QDialogButtonBox.Ok)
        tooltips = self._alg.getParameterDescriptions()
        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        self.verticalLayout = QVBoxLayout()
        self.verticalLayout.setSpacing(5)
        self.verticalLayout.setMargin(20)

        hLayout = QHBoxLayout()
        hLayout.setSpacing(5)
        hLayout.setMargin(0)
        descriptionLabel = QLabel(self.tr("Description"))
        self.descriptionBox = QLineEdit()
        self.descriptionBox.setText(self._alg.name)
        hLayout.addWidget(descriptionLabel)
        hLayout.addWidget(self.descriptionBox)
        self.verticalLayout.addLayout(hLayout)
        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setFrameShadow(QFrame.Sunken)
        self.verticalLayout.addWidget(line)

        for param in self._alg.parameters:
            if param.isAdvanced:
                self.advancedButton = QPushButton()
                self.advancedButton.setText(
                    self.tr('Show advanced parameters'))
                self.advancedButton.setMaximumWidth(150)
                self.advancedButton.clicked.connect(
                    self.showAdvancedParametersClicked)
                self.verticalLayout.addWidget(self.advancedButton)
                break
        for param in self._alg.parameters:
            if param.hidden:
                continue
            desc = param.description
            if isinstance(param, ParameterExtent):
                desc += '(xmin, xmax, ymin, ymax)'
            label = QLabel(desc)
            self.labels[param.name] = label
            widget = self.getWidgetFromParameter(param)
            self.valueItems[param.name] = widget
            if param.name in tooltips.keys():
                tooltip = tooltips[param.name]
            else:
                tooltip = param.description
            label.setToolTip(tooltip)
            widget.setToolTip(tooltip)
            if param.isAdvanced:
                label.setVisible(self.showAdvanced)
                widget.setVisible(self.showAdvanced)
                self.widgets[param.name] = widget
            self.verticalLayout.addWidget(label)
            self.verticalLayout.addWidget(widget)

        for output in self._alg.outputs:
            if output.hidden:
                continue
            if isinstance(output, (OutputRaster, OutputVector, OutputTable,
                                   OutputHTML, OutputFile, OutputDirectory)):
                label = QLabel(output.description + '<' +
                               output.__class__.__name__ + '>')
                item = QLineEdit()
                if hasattr(item, 'setPlaceholderText'):
                    item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
                self.verticalLayout.addWidget(label)
                self.verticalLayout.addWidget(item)
                self.valueItems[output.name] = item

        label = QLabel(' ')
        self.verticalLayout.addWidget(label)
        label = QLabel(self.tr('Parent algorithms'))
        self.dependenciesPanel = self.getDependenciesPanel()
        self.verticalLayout.addWidget(label)
        self.verticalLayout.addWidget(self.dependenciesPanel)

        self.verticalLayout.addStretch(1000)
        self.setLayout(self.verticalLayout)

        self.setPreviousValues()
        self.setWindowTitle(self._alg.name)
        self.verticalLayout2 = QVBoxLayout()
        self.verticalLayout2.setSpacing(2)
        self.verticalLayout2.setMargin(0)
        self.tabWidget = QTabWidget()
        self.tabWidget.setMinimumWidth(300)
        self.paramPanel = QWidget()
        self.paramPanel.setLayout(self.verticalLayout)
        self.scrollArea = QScrollArea()
        self.scrollArea.setWidget(self.paramPanel)
        self.scrollArea.setWidgetResizable(True)
        self.tabWidget.addTab(self.scrollArea, self.tr('Parameters'))
        self.webView = QWebView()

        html = None
        url = None
        isText, help = self._alg.help()
        if help is not None:
            if isText:
                html = help
            else:
                url = QUrl(help)
        else:
            html = self.tr('<h2>Sorry, no help is available for this '
                           'algorithm.</h2>')
        try:
            if html:
                self.webView.setHtml(html)
            elif url:
                self.webView.load(url)
        except:
            self.webView.setHtml(
                self.tr('<h2>Could not open help file :-( </h2>'))
        self.tabWidget.addTab(self.webView, 'Help')
        self.verticalLayout2.addWidget(self.tabWidget)
        self.verticalLayout2.addWidget(self.buttonBox)
        self.setLayout(self.verticalLayout2)
        self.buttonBox.accepted.connect(self.okPressed)
        self.buttonBox.rejected.connect(self.cancelPressed)
        QMetaObject.connectSlotsByName(self)
 def _showHelp(self):
     help_path = os.path.join(PagLuxembourg.main.plugin_dir, 'help', 'user',
                              'index.html')
     QDesktopServices.openUrl(
         QUrl('file:///' + help_path, QUrl.TolerantMode))
Exemple #56
0
def qgis_composer_renderer(impact_report, component):
    """Default Map Report Renderer using QGIS Composer.

    Render using qgis composer for a given impact_report data and component
    context.

    :param impact_report: ImpactReport contains data about the report that is
        going to be generated.
    :type impact_report: safe.report.impact_report.ImpactReport

    :param component: Contains the component metadata and context for
        rendering the output.
    :type component:
        safe.report.report_metadata.QgisComposerComponentsMetadata

    :return: Whatever type of output the component should be.

    .. versionadded:: 4.0
    """
    context = component.context
    """:type: safe.report.extractors.composer.QGISComposerContext"""
    qgis_composition_context = impact_report.qgis_composition_context
    inasafe_context = impact_report.inasafe_context

    # load composition object
    composition = QgsComposition(qgis_composition_context.map_settings)

    # load template
    main_template_folder = impact_report.metadata.template_folder

    # we do this condition in case custom template was found
    if component.template.startswith('../qgis-composer-templates/'):
        template_path = os.path.join(main_template_folder, component.template)
    else:
        template_path = component.template

    with open(template_path) as template_file:
        template_content = template_file.read()

    document = QtXml.QDomDocument()
    document.setContent(template_content)

    load_status = composition.loadFromTemplate(
        document, context.substitution_map)

    if not load_status:
        raise TemplateLoadingError(
            tr('Error loading template: %s') % template_path)

    # replace image path
    for img in context.image_elements:
        item_id = img.get('id')
        path = img.get('path')
        image = composition_item(composition, item_id, QgsComposerPicture)
        """:type: qgis.core.QgsComposerPicture"""
        if image and path:
            image.setPicturePath(path)

    # replace html frame
    for html_el in context.html_frame_elements:
        item_id = html_el.get('id')
        mode = html_el.get('mode')
        composer_item = composition.getComposerItemById(item_id)
        try:
            html_element = composition.getComposerHtmlByItem(composer_item)
        except:
            pass
        """:type: qgis.core.QgsComposerHtml"""
        if html_element:
            if mode == 'text':
                text = html_el.get('text')
                text = text if text else ''
                html_element.setContentMode(QgsComposerHtml.ManualHtml)
                html_element.setHtml(text)
                html_element.loadHtml()
            elif mode == 'url':
                url = html_el.get('url')
                html_element.setContentMode(QgsComposerHtml.Url)
                qurl = QUrl.fromLocalFile(url)
                html_element.setUrl(qurl)

    original_crs = impact_report.impact_function.impact.crs()
    destination_crs = qgis_composition_context.map_settings.destinationCrs()
    coord_transform = QgsCoordinateTransform(original_crs, destination_crs)

    # resize map extent
    for map_el in context.map_elements:
        item_id = map_el.get('id')
        split_count = map_el.get('grid_split_count')
        layers = map_el.get('layers')
        map_extent_option = map_el.get('extent')
        composer_map = composition_item(composition, item_id, QgsComposerMap)
        """:type: qgis.core.QgsComposerMap"""
        if composer_map:
            composer_map.setKeepLayerSet(True)
            layer_set = [l.id() for l in layers if isinstance(l, QgsMapLayer)]
            composer_map.setLayerSet(layer_set)
            if map_extent_option and isinstance(
                    map_extent_option, QgsRectangle):
                # use provided map extent
                extent = coord_transform.transform(map_extent_option)
                for l in [layer for layer in layers if
                          isinstance(layer, QgsMapLayer)]:
                    layer_extent = coord_transform.transform(l.extent())
                    if l.name() == map_overview['id']:
                        map_overview_extent = layer_extent
            else:
                # if map extent not provided, try to calculate extent
                # from list of given layers. Combine it so all layers were
                # shown properly
                map_overview_extent = None
                extent = QgsRectangle()
                extent.setMinimal()
                for l in [layer for layer in layers if
                          isinstance(layer, QgsMapLayer)]:
                    # combine extent if different layer is provided.
                    layer_extent = coord_transform.transform(l.extent())
                    extent.combineExtentWith(layer_extent)
                    if l.name() == map_overview['id']:
                        map_overview_extent = layer_extent

            width = extent.width()
            height = extent.height()
            longest_width = width if width > height else height
            half_length = longest_width / 2
            margin = half_length / 5
            center = extent.center()
            min_x = center.x() - half_length - margin
            max_x = center.x() + half_length + margin
            min_y = center.y() - half_length - margin
            max_y = center.y() + half_length + margin

            # noinspection PyCallingNonCallable
            square_extent = QgsRectangle(min_x, min_y, max_x, max_y)

            if component.key == 'population-infographic' and (
                    map_overview_extent):
                square_extent = map_overview_extent

            composer_map.zoomToExtent(square_extent)
            composer_map.renderModeUpdateCachedImage()

            actual_extent = composer_map.extent()

            # calculate intervals for grid
            x_interval = actual_extent.width() / split_count
            composer_map.grid().setIntervalX(x_interval)
            y_interval = actual_extent.height() / split_count
            composer_map.grid().setIntervalY(y_interval)

    # calculate legend element
    for leg_el in context.map_legends:
        item_id = leg_el.get('id')
        title = leg_el.get('title')
        layers = leg_el.get('layers')
        symbol_count = leg_el.get('symbol_count')
        column_count = leg_el.get('column_count')

        legend = composition_item(composition, item_id, QgsComposerLegend)
        """:type: qgis.core.QgsComposerLegend"""
        if legend:
            # set column count
            if column_count:
                legend.setColumnCount(column_count)
            elif symbol_count <= 7:
                legend.setColumnCount(1)
            else:
                legend.setColumnCount(symbol_count / 7 + 1)

            # set legend title
            if title is not None:
                legend.setTitle(title)

            # set legend
            root_group = legend.modelV2().rootGroup()
            for l in layers:
                # used for customizations
                tree_layer = root_group.addLayer(l)
                QgsLegendRenderer.setNodeLegendStyle(
                    tree_layer, QgsComposerLegendStyle.Hidden)
            legend.synchronizeWithModel()

    # process to output

    # in case output folder not specified
    if impact_report.output_folder is None:
        impact_report.output_folder = mkdtemp(dir=temp_dir())

    output_format = component.output_format
    component_output_path = impact_report.component_absolute_output_path(
        component.key)
    component_output = None

    doc_format = QgisComposerComponentsMetadata.OutputFormat.DOC_OUTPUT
    template_format = QgisComposerComponentsMetadata.OutputFormat.QPT
    if isinstance(output_format, list):
        component_output = []
        for i in range(len(output_format)):
            each_format = output_format[i]
            each_path = component_output_path[i]

            if each_format in doc_format:
                result_path = create_qgis_pdf_output(
                    impact_report,
                    each_path,
                    composition,
                    each_format,
                    component)
                component_output.append(result_path)
            elif each_format == template_format:
                result_path = create_qgis_template_output(
                    each_path, composition)
                component_output.append(result_path)
    elif isinstance(output_format, dict):
        component_output = {}
        for key, each_format in output_format.iteritems():
            each_path = component_output_path[key]

            if each_format in doc_format:
                result_path = create_qgis_pdf_output(
                    impact_report,
                    each_path,
                    composition,
                    each_format,
                    component)
                component_output[key] = result_path
            elif each_format == template_format:
                result_path = create_qgis_template_output(
                    each_path, composition)
                component_output[key] = result_path
    elif (output_format in
            QgisComposerComponentsMetadata.OutputFormat.SUPPORTED_OUTPUT):
        component_output = None

        if output_format in doc_format:
            result_path = create_qgis_pdf_output(
                impact_report,
                component_output_path,
                composition,
                output_format,
                component)
            component_output = result_path
        elif output_format == template_format:
            result_path = create_qgis_template_output(
                component_output_path, composition)
            component_output = result_path

    component.output = component_output

    return component.output
Exemple #57
0
    def process_request(self):
        socket = self.sender()
        request_data = socket.readAll()

        if not self.authorize_request(request_data):
            socket.write('HTTP/1.1 407 Proxy Authentication Required\r\n')
            if self.debug:
                self.log.write('407 Proxy Authentication Required\n\n')
            socket.write('Proxy-Authenticate: Basic realm="test"\r\n')
            socket.write('\r\n')
            socket.disconnectFromHost()
            return
        else:
            # remove Proxy-Authorization header
            start = request_data.indexOf('Proxy-Authorization:')
            end = request_data.lastIndexOf('\r\n')
            request_data.remove(start, end)
            request_data.append('\r\n')

        pos = request_data.indexOf('\r\n')
        request_line = request_data.left(pos)
        request_data.remove(0, pos + 2)

        entries = request_line.split(' ')
        method = entries[0]
        address = entries[1]
        version = entries[2]
        port = '80'

        if address.count(':') > 1:
            protocol, host, port = address.split(':')
        else:
            protocol, host = address.split(':')

        print 'address', address

        #url = QUrl( protocol + host )
        url = QUrl.fromEncoded(address)
        #url.setHost( host )
        #url.setPort( int(port) )

        if not url.isValid():
            if self.debug:
                self.log.write('Invalid URL: %s\n\n', url)
            socket.disconnectFromHost()
            return

        host = url.host()
        port = 80 if (url.port() < 0) else url.port()
        req = url.encodedPath()
        if url.hasQuery():
            req.append('?').append(url.encodedQuery())
        request_line = method + ' ' + req + ' ' + version + '\r\n'
        request_data.prepend(request_line)

        if self.debug:
            self.log.write(method + ' ' + address + ' ' + version + '\n\n')

        key = host + ':' + QString.number(port)
        proxy_socket = socket.findChild(QTcpSocket, key)
        if proxy_socket:
            proxy_socket.setObjectName(key)
            proxy_socket.setProperty('url', url)
            proxy_socket.setProperty('request_data', request_data)
            proxy_socket.write(request_data)
        else:
            proxy_socket = QTcpSocket(socket)
            proxy_socket.setObjectName(key)
            proxy_socket.setProperty('url', url)
            proxy_socket.setProperty('request_data', request_data)
            proxy_socket.connected.connect(self.send_request)
            proxy_socket.readyRead.connect(self.transfer_data)
            proxy_socket.disconnected.connect(self.close_connection)
            proxy_socket.error.connect(self.close_connection)
            proxy_socket.connectToHost(host, port)
Exemple #58
0
def qgis_composer_html_renderer(impact_report, component):
    """HTML to PDF renderer using QGIS Composer.

    Render using qgis composer for a given impact_report data and component
    context for html input.

    :param impact_report: ImpactReport contains data about the report that is
        going to be generated.
    :type impact_report: safe.report.impact_report.ImpactReport

    :param component: Contains the component metadata and context for
        rendering the output.
    :type component:
        safe.report.report_metadata.QgisComposerComponentsMetadata

    :return: Whatever type of output the component should be.

    .. versionadded:: 4.0
    """
    context = component.context
    """:type: safe.report.extractors.composer.QGISComposerContext"""
    qgis_composition_context = impact_report.qgis_composition_context
    inasafe_context = impact_report.inasafe_context

    # load composition object
    composition = QgsComposition(qgis_composition_context.map_settings)

    if not context.html_frame_elements:
        # if no html frame elements at all, do not generate empty report.
        component.output = ''
        return component.output

    # Add HTML Frame
    for html_el in context.html_frame_elements:
        mode = html_el.get('mode')
        html_element = QgsComposerHtml(composition, False)
        """:type: qgis.core.QgsComposerHtml"""
        margin_left = html_el.get('margin_left', 10)
        margin_top = html_el.get('margin_top', 10)
        width = html_el.get('width', component.page_width - 2 * margin_left)
        height = html_el.get('height', component.page_height - 2 * margin_top)

        html_frame = QgsComposerFrame(
            composition,
            html_element,
            margin_left,
            margin_top,
            width,
            height)
        html_element.addFrame(html_frame)

        if html_element:
            if mode == 'text':
                text = html_el.get('text')
                text = text if text else ''
                html_element.setContentMode(QgsComposerHtml.ManualHtml)
                html_element.setResizeMode(
                    QgsComposerHtml.RepeatUntilFinished)
                html_element.setHtml(text)
                html_element.loadHtml()
            elif mode == 'url':
                url = html_el.get('url')
                html_element.setContentMode(QgsComposerHtml.Url)
                html_element.setResizeMode(
                    QgsComposerHtml.RepeatUntilFinished)
                qurl = QUrl.fromLocalFile(url)
                html_element.setUrl(qurl)

    # process to output

    # in case output folder not specified
    if impact_report.output_folder is None:
        impact_report.output_folder = mkdtemp(dir=temp_dir())
    component_output_path = impact_report.component_absolute_output_path(
        component.key)
    component_output = None

    output_format = component.output_format

    doc_format = QgisComposerComponentsMetadata.OutputFormat.DOC_OUTPUT
    template_format = QgisComposerComponentsMetadata.OutputFormat.QPT
    if isinstance(output_format, list):
        component_output = []
        for i in range(len(output_format)):
            each_format = output_format[i]
            each_path = component_output_path[i]

            if each_format in doc_format:
                result_path = create_qgis_pdf_output(
                    impact_report,
                    each_path,
                    composition,
                    each_format,
                    component)
                component_output.append(result_path)
            elif each_format == template_format:
                result_path = create_qgis_template_output(
                    each_path, composition)
                component_output.append(result_path)
    elif isinstance(output_format, dict):
        component_output = {}
        for key, each_format in output_format.iteritems():
            each_path = component_output_path[key]

            if each_format in doc_format:
                result_path = create_qgis_pdf_output(
                    impact_report,
                    each_path,
                    composition,
                    each_format,
                    component)
                component_output[key] = result_path
            elif each_format == template_format:
                result_path = create_qgis_template_output(
                    each_path, composition)
                component_output[key] = result_path
    elif (output_format in
            QgisComposerComponentsMetadata.OutputFormat.SUPPORTED_OUTPUT):
        component_output = None

        if output_format in doc_format:
            result_path = create_qgis_pdf_output(
                impact_report,
                component_output_path,
                composition,
                output_format,
                component)
            component_output = result_path
        elif output_format == template_format:
            result_path = create_qgis_template_output(
                component_output_path, composition)
            component_output = result_path

    component.output = component_output

    return component.output
 def __init__(self, url):
     self.app = QApplication(sys.argv)
     QWebPage.__init__(self)
     self.loadFinished.connect(self._loadFinished)
     self.mainFrame().load(QUrl(url))
     self.app.exec_()
Exemple #60
0
def drop_request(request):
    """ Drop the request """
    # hack: set invalid URL
    request.setUrl(QUrl(''))