QmlCompilation* Compiler::compilation()
{
Q_D(Compiler);
return d->compilation;
}
/*!
\internal
*/
void QGraphicsSceneMouseEvent::setScenePos(const QPointF &pos)
{
Q_D(QGraphicsSceneMouseEvent);
d->scenePos = pos;
}
/*!
\internal
*/
void QGraphicsSceneMouseEvent::setLastScreenPos(const QPoint &pos)
{
Q_D(QGraphicsSceneMouseEvent);
d->lastScreenPos = pos;
}
/*!
\internal
This function set the source widget, i.e., the widget that
created the drop event, to \a source.
*/
void QGraphicsSceneDragDropEvent::setSource(QWidget *source)
{
Q_D(QGraphicsSceneDragDropEvent);
d->source = source;
}
/*!
\internal
*/
void QGraphicsSceneResizeEvent::setNewSize(const QSizeF &size)
{
Q_D(QGraphicsSceneResizeEvent);
d->newSize = size;
}
/*!
\internal
Sets the possible drop actions that the drag can
result in to \a actions.
\sa Qt::DropActions, possibleActions()
*/
void QGraphicsSceneDragDropEvent::setPossibleActions(Qt::DropActions actions)
{
Q_D(QGraphicsSceneDragDropEvent);
d->possibleActions = actions;
}
void QGraphicsSceneDragDropEvent::acceptProposedAction()
{
Q_D(QGraphicsSceneDragDropEvent);
d->dropAction = d->proposedAction;
}
/*!
Clears the roleNames of this proxy model.
*/
void QAbstractProxyModel::resetInternalData()
{
Q_D(QAbstractProxyModel);
d->roleNames = d->model->roleNames();
}
/*!
\reimp
*/
bool QAbstractProxyModel::submit()
{
Q_D(QAbstractProxyModel);
return d->model->submit();
}
void Compiler::unsetBasePath()
{
Q_D(Compiler);
d->basePathSet = false;
}
void Compiler::setBasePath(const QString &path)
{
Q_D(Compiler);
d->basePathSet = true;
d->basePath = path;
}
QQmlEngine* Compiler::engine()
{
Q_D(Compiler);
return d->engine;
}
Compiler::Compiler(QQmlEngine *engine, CompilerOptions *options, QObject *parent) :
QObject(*(new CompilerPrivate(options)), parent)
{
Q_D(Compiler);
d->engine = engine;
}
bool Compiler::addImport(const QV4::CompiledData::Import *import, QList<QQmlError> *errors)
{
Q_D(Compiler);
const QString &importUri = stringAt(import->uriIndex);
const QString &importQualifier = stringAt(import->qualifierIndex);
if (import->type == QV4::CompiledData::Import::ImportScript) {
// TBD: qqmltypeloader.cpp:1320
QmlCompilation::ScriptReference scriptRef;
scriptRef.location = import->location;
scriptRef.qualifier = importQualifier;
scriptRef.compilation = NULL;
d->compilation->scripts.append(scriptRef);
} else if (import->type == QV4::CompiledData::Import::ImportLibrary) {
QString qmldirFilePath;
QString qmldirUrl;
if (QQmlMetaType::isLockedModule(importUri, import->majorVersion)) {
//Locked modules are checked first, to save on filesystem checks
if (!d->compilation->importCache->addLibraryImport(d->compilation->importDatabase, importUri, importQualifier, import->majorVersion,
import->minorVersion, QString(), QString(), false, errors))
return false;
} else if (d->compilation->importCache->locateQmldir(d->compilation->importDatabase, importUri, import->majorVersion, import->minorVersion,
&qmldirFilePath, &qmldirUrl)) {
// This is a local library import
if (!d->compilation->importCache->addLibraryImport(d->compilation->importDatabase, importUri, importQualifier, import->majorVersion,
import->minorVersion, qmldirFilePath, qmldirUrl, false, errors))
return false;
if (!importQualifier.isEmpty()) {
// Does this library contain any qualified scripts?
QUrl libraryUrl(qmldirUrl);
QQmlTypeLoader* typeLoader = &QQmlEnginePrivate::get(d->compilation->engine)->typeLoader;
const QQmlTypeLoader::QmldirContent *qmldir = typeLoader->qmldirContent(qmldirFilePath, qmldirUrl);
// File loading will import the dependency and takes care of
// everything there. Adding a script reference here just seems
// to add an unnecessary reference that might actually be a bug.
// In case something is needed, see: qqmltypeloader.cpp:1343
}
} else {
// Is this a module?
qDebug() << "Importing local module" << importUri;
if (QQmlMetaType::isAnyModule(importUri)) {
if (!d->compilation->importCache->addLibraryImport(d->compilation->importDatabase, importUri, importQualifier, import->majorVersion,
import->minorVersion, QString(), QString(), false, errors))
return false;
} else {
QQmlError error;
error.setDescription("Unresolved import " + importUri);
error.setLine(import->location.line);
error.setColumn(import->location.column);
error.setUrl(d->compilation->url);
appendError(error);
return false;
// TBD: else add to unresolved imports qqmltypeloader.cpp:1356
}
}
} else {
// qqmltypeloader.cpp:1383
Q_ASSERT(import->type == QV4::CompiledData::Import::ImportFile);
QUrl qmldirUrl;
if (importQualifier.isEmpty()) {
qmldirUrl = compilation()->loadUrl.resolved(QUrl(importUri + QLatin1String("/qmldir")));
if (!QQmlImports::isLocal(qmldirUrl)) {
qDebug() << "File import from network not supported";
QQmlError error;
error.setDescription("File import from network not supported");
errors->append(error);
return false;
}
}
if (!compilation()->importCache->addFileImport(compilation()->importDatabase, importUri, importQualifier, import->majorVersion,
import->minorVersion, /*incomplete*/ false, errors))
return false;
}
return true;
}
/*!
\internal
Sets the mouse position relative to the screen to \a pos.
\sa screenPos(), setScenePos(), setPos()
*/
void QGraphicsSceneDragDropEvent::setScreenPos(const QPoint &pos)
{
Q_D(QGraphicsSceneDragDropEvent);
d->screenPos = pos;
}
/*!
\reimp
*/
void QAbstractProxyModel::revert()
{
Q_D(QAbstractProxyModel);
d->model->revert();
}
void QGraphicsSceneDragDropEvent::setModifiers(Qt::KeyboardModifiers modifiers)
{
Q_D(QGraphicsSceneDragDropEvent);
d->modifiers = modifiers;
}
/*!
\reimp
*/
bool QAbstractProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
Q_D(QAbstractProxyModel);
return d->model->setData(mapToSource(index), value, role);
}
void QGraphicsSceneDragDropEvent::setProposedAction(Qt::DropAction action)
{
Q_D(QGraphicsSceneDragDropEvent);
d->proposedAction = action;
}
/*!
\reimp
*/
void QAbstractProxyModel::fetchMore(const QModelIndex &parent)
{
Q_D(QAbstractProxyModel);
d->model->fetchMore(mapToSource(parent));
}
/*!
This function lets the receiver of the drop set the drop
action that was performed to \a action, which should be one
of the
\l{QGraphicsSceneDragDropEvent::possibleActions()}{possible
actions}. Call \c accept() in stead of \c
acceptProposedAction() if you use this function.
\sa dropAction(), accept(), possibleActions()
*/
void QGraphicsSceneDragDropEvent::setDropAction(Qt::DropAction action)
{
Q_D(QGraphicsSceneDragDropEvent);
d->dropAction = action;
}
/*!
\reimp
*/
void QAbstractProxyModel::sort(int column, Qt::SortOrder order)
{
Q_D(QAbstractProxyModel);
d->model->sort(column, order);
}
/*!
\internal
This function sets the MIME data for the event.
*/
void QGraphicsSceneDragDropEvent::setMimeData(const QMimeData *data)
{
Q_D(QGraphicsSceneDragDropEvent);
d->mimeData = data;
}
/*!
Sets the internal list of cookies held by this cookie jar to be \a
cookieList. This function is suitable for derived classes to
implement loading cookies from permanent storage, or their own
cookie acceptance policies by reimplementing
setCookiesFromUrl().
\sa allCookies(), setCookiesFromUrl()
*/
void QNetworkCookieJar::setAllCookies(const QList<QNetworkCookie> &cookieList)
{
Q_D(QNetworkCookieJar);
d->allCookies = cookieList;
}
/*!
\internal
*/
void QGraphicsSceneMoveEvent::setNewPos(const QPointF &pos)
{
Q_D(QGraphicsSceneMoveEvent);
d->newPos = pos;
}
/*!
\internal
*/
void QGraphicsSceneHoverEvent::setLastScenePos(const QPointF &pos)
{
Q_D(QGraphicsSceneHoverEvent);
d->lastScenePos = pos;
}
/*!
\internal
*/
void QGraphicsSceneMouseEvent::setButtonDownScreenPos(Qt::MouseButton button, const QPoint &pos)
{
Q_D(QGraphicsSceneMouseEvent);
d->buttonDownScreenPos.insert(button, pos);
}
void QGraphicsSceneDragDropEvent::setPos(const QPointF &pos)
{
Q_D(QGraphicsSceneDragDropEvent);
d->pos = pos;
}
/*!
\internal
*/
void QGraphicsSceneMouseEvent::setButtons(Qt::MouseButtons buttons)
{
Q_D(QGraphicsSceneMouseEvent);
d->buttons = buttons;
}
void Compiler::appendErrors(const QList<QQmlError> &errors)
{
Q_D(Compiler);
d->errors.append(errors);
}
