bool QgsAuthOAuth2Method::updateNetworkRequest( QNetworkRequest &request, const QString &authcfg,
const QString &dataprovider )
{
Q_UNUSED( dataprovider )
QMutexLocker locker( &mNetworkRequestMutex );
QString msg;
QgsO2 *o2 = getOAuth2Bundle( authcfg );
if ( !o2 )
{
msg = QStringLiteral( "Update request FAILED for authcfg %1: null object for requestor" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Warning );
return false;
}
if ( o2->linked() )
{
// Check if the cache file has been deleted outside core method routines
QString tokencache = QgsAuthOAuth2Config::tokenCachePath( authcfg, !o2->oauth2config()->persistToken() );
if ( !QFile::exists( tokencache ) )
{
msg = QStringLiteral( "Token cache removed for authcfg %1: unlinking authenticator" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Info );
o2->unlink();
}
}
if ( o2->linked() )
{
// First, check if it is expired
bool expired = false;
if ( o2->expires() > 0 ) // QStringLiteral("").toInt() result for tokens with no expiration
{
int cursecs = static_cast<int>( QDateTime::currentDateTime().toMSecsSinceEpoch() / 1000 );
expired = ( ( o2->expires() - cursecs ) < 120 ); // try refresh with expired or two minutes to go
}
if ( expired )
{
msg = QStringLiteral( "Token expired, attempting refresh for authcfg %1" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Info );
// Try to get a refresh token first
// go into local event loop and wait for a fired refresh-related slot
QEventLoop rloop( nullptr );
connect( o2, &QgsO2::refreshFinished, &rloop, &QEventLoop::quit );
// Asynchronously attempt the refresh
// TODO: This already has a timed reply setup in O2 base class (and in QgsNetworkAccessManager!)
// May need to address this or app crashes will occur!
o2->refresh();
// block request update until asynchronous linking loop is quit
rloop.exec( QEventLoop::ExcludeUserInputEvents );
// refresh result should set o2 to (un)linked
}
}
if ( !o2->linked() )
{
// link app
// clear any previous token session properties
o2->unlink();
connect( o2, &QgsO2::linkedChanged, this, &QgsAuthOAuth2Method::onLinkedChanged, Qt::UniqueConnection );
connect( o2, &QgsO2::linkingFailed, this, &QgsAuthOAuth2Method::onLinkingFailed, Qt::UniqueConnection );
connect( o2, &QgsO2::linkingSucceeded, this, &QgsAuthOAuth2Method::onLinkingSucceeded, Qt::UniqueConnection );
connect( o2, &QgsO2::openBrowser, this, &QgsAuthOAuth2Method::onOpenBrowser, Qt::UniqueConnection );
connect( o2, &QgsO2::closeBrowser, this, &QgsAuthOAuth2Method::onCloseBrowser, Qt::UniqueConnection );
connect( o2, &QgsO2::getAuthCode, this, &QgsAuthOAuth2Method::onAuthCode, Qt::UniqueConnection );
connect( this, &QgsAuthOAuth2Method::setAuthCode, o2, &QgsO2::onSetAuthCode, Qt::UniqueConnection );
//qRegisterMetaType<QNetworkReply::NetworkError>( QStringLiteral( "QNetworkReply::NetworkError" )) // for Qt::QueuedConnection, if needed;
connect( o2, &QgsO2::refreshFinished, this, &QgsAuthOAuth2Method::onRefreshFinished, Qt::UniqueConnection );
QgsSettings settings;
QString timeoutkey = QStringLiteral( "qgis/networkAndProxy/networkTimeout" );
int prevtimeout = settings.value( timeoutkey, QStringLiteral( "-1" ) ).toInt();
int reqtimeout = o2->oauth2config()->requestTimeout() * 1000;
settings.setValue( timeoutkey, reqtimeout );
// go into local event loop and wait for a fired linking-related slot
QEventLoop loop( nullptr );
connect( o2, &QgsO2::linkingFailed, &loop, &QEventLoop::quit );
connect( o2, &QgsO2::linkingSucceeded, &loop, &QEventLoop::quit );
// add singlshot timer to quit linking after an alloted timeout
// this should keep the local event loop from blocking forever
QTimer timer( nullptr );
timer.setInterval( reqtimeout * 5 );
timer.setSingleShot( true );
connect( &timer, &QTimer::timeout, o2, &QgsO2::linkingFailed );
timer.start();
// asynchronously attempt the linking
o2->link();
// block request update until asynchronous linking loop is quit
loop.exec();
if ( timer.isActive() )
{
timer.stop();
}
// don't re-apply a setting that wasn't already set
if ( prevtimeout == -1 )
{
settings.remove( timeoutkey );
}
else
{
settings.setValue( timeoutkey, prevtimeout );
}
if ( !o2->linked() )
{
msg = QStringLiteral( "Update request FAILED for authcfg %1: requestor could not link app" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Warning );
return false;
}
}
if ( o2->token().isEmpty() )
{
msg = QStringLiteral( "Update request FAILED for authcfg %1: access token is empty" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Warning );
return false;
}
// update the request
QgsAuthOAuth2Config::AccessMethod accessmethod = o2->oauth2config()->accessMethod();
QUrl url = request.url();
QUrlQuery query( url );
switch ( accessmethod )
{
case QgsAuthOAuth2Config::Header:
request.setRawHeader( O2_HTTP_AUTHORIZATION_HEADER, QStringLiteral( "Bearer %1" ).arg( o2->token() ).toAscii() );
msg = QStringLiteral( "Updated request HEADER with access token for authcfg: %1" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Info );
break;
case QgsAuthOAuth2Config::Form:
// FIXME: what to do here if the parent request is not POST?
// probably have to skip this until auth system support is moved into QgsNetworkAccessManager
msg = QStringLiteral( "Update request FAILED for authcfg %1: form POST token update is unsupported" ).arg( authcfg );
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Warning );
break;
case QgsAuthOAuth2Config::Query:
if ( !query.hasQueryItem( O2_OAUTH2_ACCESS_TOKEN ) )
{
query.addQueryItem( O2_OAUTH2_ACCESS_TOKEN, o2->token() );
url.setQuery( query );
request.setUrl( url );
msg = QStringLiteral( "Updated request QUERY with access token for authcfg: %1" ).arg( authcfg );
}
else
{
msg = QStringLiteral( "Updated request QUERY with access token SKIPPED (existing token) for authcfg: %1" ).arg( authcfg );
}
QgsMessageLog::logMessage( msg, AUTH_METHOD_KEY, Qgis::MessageLevel::Info );
break;
}
return true;
}
void QUrlProto::setQueryItems(const QList<QPair<QString, QString> > &query)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setQueryItems(query);
}
void QUrlProto::setUrl(const QString &url)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setUrl(url);
}
void QUrlProto::setHost(const QString &host)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setHost(host);
}
void QUrlProto::setPort(int port)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setPort(port);
}
void QUrlProto::setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedQueryItems(query);
}
void QUrlProto::setEncodedUserName(const QByteArray &userName)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedUserName(userName);
}
void PacificaServices::downloadFinished(QNetworkReply *reply)
{
const char *prefix = "";
QDomElement root;
QDomNode services;
QDomNode n;
QDomElement e;
int i;
int res;
QUrl url;
QVariant possible_redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
url = possible_redirect.toUrl();
if(!url.isEmpty() && current_url != url && redirect_count < 5)
{
redirect_count++;
current_url = url;
std::cout << "Redirecting to " << url.toString().toStdString() << "\n";
QNetworkRequest request(current_url);
QNetworkReply *reply = manager.get(request);
return;
}
//FIXME handle error.
_services = new QHash<QString, QString>();
//FIXME rename root element once server is updated.
QDomDocument doc("myemsl");
std::cout << doc.setContent(reply) << "\n";
root = doc.documentElement();
QDomNodeList list = root.elementsByTagName("prefix");
for(i = 0; i < list.count(); i++)
{
e = list.at(i).toElement();
prefix = strdup(e.text().toStdString().c_str());
}
QSettings settings;
if(settings.contains("url/prefix"))
{
prefix = strdup(settings.value("url/prefix").toString().toStdString().c_str());
}
list = root.elementsByTagName("services");
for(i = 0; i < list.count(); i++)
{
services = list.at(i);
}
list = services.childNodes();
for(i = 0; i < list.count(); i++)
{
e = list.at(i).toElement();
if(e.nodeName() == "service")
{
if(e.attribute("location", "").toStdString().c_str()[0] == '/')
{
_services->insert(e.attribute("name", NULL), prefix + e.attribute("location", ""));
}
else
{
_services->insert(e.attribute("name", NULL), e.attribute("location", ""));
}
}
}
ready(_services);
}
bool
GlobalActionManager::parseTomahawkLink( const QString& urlIn )
{
QString url = urlIn;
if ( urlIn.startsWith( "http://toma.hk" ) )
url.replace( "http://toma.hk/", "tomahawk://" );
if ( url.contains( "tomahawk://" ) )
{
QString cmd = url.mid( 11 );
cmd.replace( "%2B", "%20" );
tLog() << "Parsing tomahawk link command" << cmd;
QString cmdType = cmd.split( "/" ).first();
QUrl u = QUrl::fromEncoded( cmd.toUtf8() );
// for backwards compatibility
if ( cmdType == "load" )
{
if ( u.hasQueryItem( "xspf" ) )
{
QUrl xspf = QUrl::fromUserInput( u.queryItemValue( "xspf" ) );
XSPFLoader* l = new XSPFLoader( true, this );
tDebug() << "Loading spiff:" << xspf.toString();
l->load( xspf );
connect( l, SIGNAL( ok( Tomahawk::playlist_ptr ) ), ViewManager::instance(), SLOT( show( Tomahawk::playlist_ptr ) ) );
return true;
}
else if ( u.hasQueryItem( "jspf" ) )
{
QUrl jspf = QUrl::fromUserInput( u.queryItemValue( "jspf" ) );
JSPFLoader* l = new JSPFLoader( true, this );
tDebug() << "Loading jspiff:" << jspf.toString();
l->load( jspf );
connect( l, SIGNAL( ok( Tomahawk::playlist_ptr ) ), ViewManager::instance(), SLOT( show( Tomahawk::playlist_ptr ) ) );
return true;
}
}
if ( cmdType == "playlist" )
{
return handlePlaylistCommand( u );
}
else if ( cmdType == "collection" )
{
return handleCollectionCommand( u );
}
else if ( cmdType == "queue" )
{
return handleQueueCommand( u );
}
else if ( cmdType == "station" )
{
return handleStationCommand( u );
}
else if ( cmdType == "autoplaylist" )
{
return handleAutoPlaylistCommand( u );
}
else if ( cmdType == "search" )
{
return handleSearchCommand( u );
}
else if ( cmdType == "play" )
{
return handlePlayCommand( u );
}
else if ( cmdType == "bookmark" )
{
return handlePlayCommand( u );
}
else if ( cmdType == "open" )
{
return handleOpenCommand( u );
}
else if ( cmdType == "view" )
{
return handleViewCommand( u );
}
else if ( cmdType == "import" )
{
return handleImportCommand( u );
}
else
{
tLog() << "Tomahawk link not supported, command not known!" << cmdType << u.path();
return false;
}
}
else
{
tLog() << "Not a tomahawk:// link!";
return false;
}
}
int TorrentPlugin::AddJob (Entity e)
{
QString suggestedFname;
if (e.Entity_.canConvert<QUrl> ())
{
QUrl resource = e.Entity_.toUrl ();
if (resource.scheme () == "magnet")
{
QString at = XmlSettingsManager::Instance ()->
property ("AutomaticTags").toString ();
QStringList tags = e.Additional_ [" Tags"].toStringList ();
Q_FOREACH (QString tag, Core::Instance ()->GetProxy ()->
GetTagsManager ()->Split (at))
tags << Core::Instance ()->GetProxy ()->
GetTagsManager ()->GetID (tag);
QList<QPair<QString, QString> > queryItems = resource.queryItems ();
for (QList<QPair<QString, QString> >::const_iterator i = queryItems.begin (),
end = queryItems.end (); i != end; ++i)
if (i->first == "kt")
{
QStringList humanReadable = i->second
.split ('+', QString::SkipEmptyParts);
Q_FOREACH (QString hr, humanReadable)
tags += Core::Instance ()->GetProxy ()->
GetTagsManager ()->GetID (hr);
}
return Core::Instance ()->AddMagnet (resource.toString (),
e.Location_,
tags,
e.Parameters_);
}
else if (resource.scheme () == "file")
suggestedFname = resource.toLocalFile ();
}
QByteArray entity = e.Entity_.toByteArray ();
QFile file (suggestedFname);
if ((!file.exists () ||
!file.open (QIODevice::ReadOnly)) &&
Core::Instance ()->IsValidTorrent (entity))
{
QTemporaryFile file ("lctemporarybittorrentfile.XXXXXX");
if (!file.open ())
return -1;
file.write (entity);
suggestedFname = file.fileName ().toUtf8 ();
file.setAutoRemove (false);
}
AddTorrentDialog_->Reinit ();
AddTorrentDialog_->SetFilename (suggestedFname);
if (!e.Location_.isEmpty ())
AddTorrentDialog_->SetSavePath (e.Location_);
QString path;
QStringList tags = e.Additional_ [" Tags"].toStringList ();
QVector<bool> files;
QString fname;
bool tryLive = e.Additional_ ["TryToStreamLive"].toBool ();
if (e.Parameters_ & FromUserInitiated)
{
if (!tags.isEmpty ())
AddTorrentDialog_->SetTags (tags);
if (AddTorrentDialog_->exec () == QDialog::Rejected)
return -1;
fname = AddTorrentDialog_->GetFilename (),
path = AddTorrentDialog_->GetSavePath ();
tryLive = AddTorrentDialog_->GetTryLive ();
files = AddTorrentDialog_->GetSelectedFiles ();
tags = AddTorrentDialog_->GetTags ();
if (AddTorrentDialog_->GetAddType () == Core::Started)
e.Parameters_ &= ~NoAutostart;
else
e.Parameters_ |= NoAutostart;
}
else
{
fname = suggestedFname;
path = e.Location_;
QString at = XmlSettingsManager::Instance ()->
property ("AutomaticTags").toString ();
Q_FOREACH (QString tag, Core::Instance ()->GetProxy ()->
GetTagsManager ()->Split (at))
tags << Core::Instance ()->GetProxy ()->
GetTagsManager ()->GetID (tag);
}
int result = Core::Instance ()->AddFile (fname,
path,
tags,
tryLive,
files,
e.Parameters_);
setActionsEnabled ();
file.remove ();
return result;
}
void QOpenGLWebPage::setUrl(const QUrl& url)
{
load(url.toString());
}
void MainWindow::addTransfer(QString uri, Transfer::Mode mode, QString className, int qSel)
{
Queue* queue = 0;
if(m_dlgNewTransfer)
{
m_dlgNewTransfer->addLinks(uri);
return;
}
if(qSel < 0)
{
qSel = getSelectedQueue();
if(qSel < 0)
{
if(g_queues.size())
qSel = 0;
else
return;
}
}
m_dlgNewTransfer = new NewTransferDlg(this);
m_dlgNewTransfer->setWindowTitle(tr("New transfer"));
m_dlgNewTransfer->m_nQueue = qSel;
m_dlgNewTransfer->m_strURIs = uri;
if(!uri.isEmpty() && className.isEmpty())
{
QStringList l = uri.split('\n', QString::SkipEmptyParts);
Transfer::BestEngine eng = Transfer::bestEngine(l[0], mode);
if(eng.type != Transfer::ModeInvalid)
m_dlgNewTransfer->m_mode = eng.type;
}
else
{
m_dlgNewTransfer->m_mode = mode;
m_dlgNewTransfer->m_strClass = className;
}
QList<Transfer*> listTransfers;
show_dialog:
try
{
QStringList uris;
int sep = getSettingsValue("link_separator").toInt();
if(m_dlgNewTransfer->exec() != QDialog::Accepted)
throw RuntimeException();
if(!sep)
uris = m_dlgNewTransfer->m_strURIs.split('\n', QString::SkipEmptyParts);
else
uris = m_dlgNewTransfer->m_strURIs.split(QRegExp("\\s+"), QString::SkipEmptyParts);
if(uris.isEmpty())
throw RuntimeException();
for(int i=0;i<uris.size();i++)
{
QString trm = uris[i].trimmed();
if(trm.isEmpty())
{
uris.removeAt(i);
i--;
}
else
uris[i] = trm;
}
int detectedClass = m_dlgNewTransfer->m_nClass; // used for the multiple cfg dialog
for(int i=0;i<uris.size();i++)
{
Transfer* d;
int classID;
if(m_dlgNewTransfer->m_nClass == -1)
{
// autodetection
Transfer::BestEngine eng;
if(m_dlgNewTransfer->m_mode == Transfer::Download)
eng = Transfer::bestEngine(uris[i], Transfer::Download);
else
eng = Transfer::bestEngine(m_dlgNewTransfer->m_strDestination, Transfer::Upload);
if(eng.nClass < 0)
throw RuntimeException(tr("Couldn't autodetect transfer type for \"%1\"").arg(uris[i]));
else
classID = eng.nClass;
if(detectedClass == -1)
detectedClass = classID;
else if(detectedClass >= 0 && detectedClass != classID)
detectedClass = -2;
}
else
classID = m_dlgNewTransfer->m_nClass;
d = Transfer::createInstance(m_dlgNewTransfer->m_mode, classID);
if(d == 0)
throw RuntimeException(tr("Failed to create a class instance."));
listTransfers << d;
QString source, destination;
source = uris[i].trimmed();
destination = m_dlgNewTransfer->m_strDestination;
if(!m_dlgNewTransfer->m_auth.strUser.isEmpty())
{
QString& obj = (m_dlgNewTransfer->m_mode == Transfer::Download) ? source : destination;
QUrl url = obj;
if(url.userInfo().isEmpty())
{
url.setUserName(m_dlgNewTransfer->m_auth.strUser);
url.setPassword(m_dlgNewTransfer->m_auth.strPassword);
}
obj = url.toString();
}
d->init(source, destination);
d->setUserSpeedLimits(m_dlgNewTransfer->m_nDownLimit,m_dlgNewTransfer->m_nUpLimit);
}
// show the transfer details dialog
if(m_dlgNewTransfer->m_bDetails)
{
// show a typical transfer propeties dialog
if(listTransfers.size() == 1)
{
WidgetHostDlg dlg(this);
m_dlgNewTransfer->setWindowTitle(tr("Transfer details"));
if(WidgetHostChild* q = listTransfers[0]->createOptionsWidget(dlg.getChildHost()))
{
dlg.addChild(q);
if(dlg.exec() != QDialog::Accepted)
throw RuntimeException();
}
}
else if(detectedClass >= 0) // show a dialog designed for multiple
{
if(!Transfer::runProperties(this, m_dlgNewTransfer->m_mode, detectedClass, listTransfers))
throw RuntimeException();
}
else
{
QMessageBox::warning(this, "FatRat", tr("Cannot display detailed configuration when there are multiple transfer types used."));
}
}
if(!m_dlgNewTransfer->m_bPaused)
{
foreach(Transfer* d, listTransfers)
d->setState(Transfer::Waiting);
}
queue = getQueue(m_dlgNewTransfer->m_nQueue, false);
if(!queue)
throw RuntimeException(tr("Internal error."));
queue->add(listTransfers);
}
catch(const RuntimeException& e)
{
qDeleteAll(listTransfers);
listTransfers.clear();
if(!e.what().isEmpty())
{
QMessageBox::critical(this, tr("Error"), e.what());
goto show_dialog;
}
}
delete m_dlgNewTransfer;
m_dlgNewTransfer = 0;
if(queue != 0)
doneQueue(queue,false);
Queue::saveQueuesAsync();
}
void BrowserCopertine::moveToMese( const QString &mese )
{
QUrl url = ui->MostraRiviste->source() ;
url.setFragment( mese ) ;
ui->MostraRiviste->setSource( url );
}
void BrowserApplication::openUrl(const QUrl &url)
{
mainWindow()->loadPage(url.toString());
}
void QUrlProto::setEncodedPath(const QByteArray &path)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedPath(path);
}
bool
GlobalActionManager::handlePlaylistCommand( const QUrl& url )
{
QStringList parts = url.path().split( "/" ).mid( 1 ); // get the rest of the command
if ( parts.isEmpty() )
{
tLog() << "No specific playlist command:" << url.toString();
return false;
}
if ( parts[ 0 ] == "import" )
{
if ( !url.hasQueryItem( "xspf" ) && !url.hasQueryItem( "jspf") )
{
tDebug() << "No xspf or jspf to load...";
return false;
}
if ( url.hasQueryItem( "xspf" ) )
{
createPlaylistFromUrl( "xspf", url.queryItemValue( "xspf" ), url.hasQueryItem( "title" ) ? url.queryItemValue( "title" ) : QString() );
return true;
}
else if ( url.hasQueryItem( "jspf" ) )
{
createPlaylistFromUrl( "jspf", url.queryItemValue( "jspf" ), url.hasQueryItem( "title" ) ? url.queryItemValue( "title" ) : QString() );
return true;
}
}
else if ( parts [ 0 ] == "new" )
{
if ( !url.hasQueryItem( "title" ) )
{
tLog() << "New playlist command needs a title...";
return false;
}
playlist_ptr pl = Playlist::create( SourceList::instance()->getLocal(), uuid(), url.queryItemValue( "title" ), QString(), QString(), false );
ViewManager::instance()->show( pl );
}
else if ( parts[ 0 ] == "add" )
{
if ( !url.hasQueryItem( "playlistid" ) || !url.hasQueryItem( "title" ) || !url.hasQueryItem( "artist" ) )
{
tLog() << "Add to playlist command needs playlistid, track, and artist..." << url.toString();
return false;
}
// TODO implement. Let the user select what playlist to add to
return false;
}
return false;
}
void QUrlProto::setEncodedQuery(const QByteArray &query)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedQuery(query);
}
void QUrlProto::clear()
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->clear();
}
void QUrlProto::setEncodedUrl(const QByteArray &encodedUrl, QUrl::ParsingMode parsingMode)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedUrl(encodedUrl, parsingMode);
}
void QUrlProto::removeEncodedQueryItem(const QByteArray &key)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->removeEncodedQueryItem(key);
}
void QUrlProto::setFragment(const QString &fragment)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setFragment(fragment);
}
void QUrlProto::removeQueryItem(const QString &key)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->removeQueryItem(key);
}
void QUrlProto::setPath(const QString &path)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setPath(path);
}
void QUrlProto::setAuthority(const QString &authority)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setAuthority(authority);
}
void QUrlProto::setQueryDelimiters(char valueDelimiter, char pairDelimiter)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setQueryDelimiters(valueDelimiter, pairDelimiter);
}
void QUrlProto::setEncodedFragment(const QByteArray &fragment)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedFragment(fragment);
}
void QUrlProto::setScheme(const QString &scheme)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setScheme(scheme);
}
void QUrlProto::setEncodedHost(const QByteArray &host)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setEncodedHost(host);
}
void QUrlProto::setUrl(const QString &url, QUrl::ParsingMode parsingMode)
{
QUrl *item = qscriptvalue_cast<QUrl*>(thisObject());
if (item)
item->setUrl(url, parsingMode);
}
void GenericStaticContext::setBaseURI(const QUrl &uri)
{
Q_ASSERT(!uri.isRelative());
m_baseURI = uri;
}