Пример #1
0
void Packet::update_dest_pos(Node *node)
{
    std::pair<int,int> dest_loc = location(node);
    QQuickItem *item = qobject_cast<QQuickItem*>(pac_obj);
    item->setProperty("dest_x", dest_loc.first+offset);
    item->setProperty("dest_y", dest_loc.second+offset);
}
Пример #2
0
void PaperManager::deletePaper(const QVariant & var)
{
    QQuickItem *paper = var.value<QQuickItem*>();
    if( !paper )
        return;

    const int paperId = paper->property("paperItem").toInt();
    if( paperId == -1 )
        return;

    const int bufferIdx  = p->buffer.indexOf(paper);
    const int currentIdx = (p->current==0)? p->current + bufferIdx : p->current + bufferIdx -1;

    if( currentIdx != p->current )
        return;

    p->papers.removeAll(paperId);
    int nextId = (p->current<p->papers.count())? p->papers.at(p->current) : -1;

    paper->setProperty("paperItem", -1 );
    paper->setProperty("paperItem", nextId );

    Papyrus::database()->deletePaper(paperId);
    reindexBuffer();
    load_buffers();
    emit papersChanged();
}
Пример #3
0
void Fix8Log::aboutSlot()
{

    QDialog *aboutDialog = new QDialog();
    QVBoxLayout *aboutLayout = new QVBoxLayout(0);

    QDialogButtonBox *dialogButtonBox = new QDialogButtonBox();

    dialogButtonBox->addButton(QDialogButtonBox::Ok);
    connect(dialogButtonBox,SIGNAL(clicked(QAbstractButton*)),
            aboutDialog,SLOT(close()));

    QQuickView *aboutView = new QQuickView(QUrl("qrc:qml/helpAbout.qml"));
    QQuickItem *qmlObject = aboutView->rootObject();
    qmlObject->setProperty("color",aboutDialog->palette().color(QPalette::Window));
    qmlObject->setProperty("bgColor",aboutDialog->palette().color(QPalette::Window));
    qmlObject->setProperty("version",QString::number(Globals::version));

    aboutView->setResizeMode(QQuickView::SizeRootObjectToView);

    QWidget *aboutWidget = QWidget::createWindowContainer(aboutView,0);
    aboutWidget->setPalette(aboutDialog->palette());
    aboutWidget->setAutoFillBackground(false);
    aboutDialog->setLayout(aboutLayout);

    aboutLayout->addWidget(aboutWidget,1);
    aboutLayout->addWidget(dialogButtonBox,0);
    aboutDialog->resize(500,400);
    aboutDialog->setWindowTitle(GUI::Globals::appName);
    aboutDialog->exec();
    aboutDialog->deleteLater();

}
void QmlProfilerTraceView::toggleLockMode(bool active)
{
    QQuickItem *rootObject = d->m_mainView->rootObject();
    bool lockMode = !rootObject->property("selectionLocked").toBool();
    if (active != lockMode) {
        rootObject->setProperty("selectionLocked", QVariant(!active));
        rootObject->setProperty("selectedItem", QVariant(-1));
    }
}
Пример #5
0
QQuickItem * DataSetView::createColumnHeader(int col)
{
	//std::cout << "createColumnHeader("<<col<<") called!\n" << std::flush;


	if(_columnHeaderDelegate == NULL)
	{
		_columnHeaderDelegate = new QQmlComponent(qmlEngine(this));
		_columnHeaderDelegate->setData("import QtQuick 2.10\nItem {\n"
			"property alias text: tekst.text\n"
		   "Rectangle	{ color: \"lightGrey\";	anchors.fill: parent }\n"
		   "Text		{ id: tekst; anchors.centerIn: parent }\n"
		"}", QUrl());
	}

	QQuickItem * columnHeader = NULL;

	if(_columnHeaderItems.count(col) == 0  || _columnHeaderItems[col] == NULL)
	{

		if(_columnHeaderStorage.size() > 0)
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createColumnHeader("<<col<<") from storage!\n" << std::flush;
#endif
			columnHeader = _columnHeaderStorage.top();
			_columnHeaderStorage.pop();
		}
		else
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createColumnHeader("<<col<<") ex nihilo!\n" << std::flush;
#endif
			columnHeader = qobject_cast<QQuickItem*>(_columnHeaderDelegate->create());
			columnHeader->setParent(this);
			columnHeader->setParentItem(this);
		}

		columnHeader->setProperty("z", 10);
		columnHeader->setProperty("text", _model->headerData(col, Qt::Orientation::Horizontal).toString());

		columnHeader->setZ(-3);
		columnHeader->setHeight(_dataRowsMaxHeight);
		columnHeader->setWidth(_dataColsMaxWidth[col]);

		columnHeader->setVisible(true);

		_columnHeaderItems[col] = columnHeader;
	}
	else
		columnHeader = _columnHeaderItems[col];

	columnHeader->setX(_colXPositions[col]);
	columnHeader->setY(_viewportY);

	return columnHeader;
}
Пример #6
0
QQuickItem * DataSetView::createRowNumber(int row)
{
	//std::cout << "createRowNumber("<<row<<") called!\n" << std::flush;


	if(_rowNumberDelegate == NULL)
	{
		_rowNumberDelegate = new QQmlComponent(qmlEngine(this));
		_rowNumberDelegate->setData("import QtQuick 2.10\nItem {\n"
			"property alias text: tekst.text\n"
			"Rectangle	{ color: \"lightGrey\";	anchors.fill: parent }\n"
			"Text		{ id: tekst; anchors.centerIn: parent }\n"
		"}", QUrl());
	}

	QQuickItem * rowNumber = NULL;

	if(_rowNumberItems.count(row) == 0  || _rowNumberItems[row] == NULL)
	{

		if(_rowNumberStorage.size() > 0)
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createRowNumber("<<row<<") from storage!\n" << std::flush;
#endif
			rowNumber = _rowNumberStorage.top();
			_rowNumberStorage.pop();
		}
		else
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createRowNumber("<<row<<") ex nihilo!\n" << std::flush;
#endif
			rowNumber = qobject_cast<QQuickItem*>(_rowNumberDelegate->create());
			rowNumber->setParent(this);
			rowNumber->setParentItem(this);
		}

		rowNumber->setProperty("z", 10);
		rowNumber->setProperty("text", QString::fromStdString(std::to_string(row + 1))); //Nobody wants zero-based rows...

		rowNumber->setY(_dataRowsMaxHeight * (1 + row));
		rowNumber->setZ(-3);
		rowNumber->setHeight(_dataRowsMaxHeight);
		rowNumber->setWidth(_rowNumberMaxWidth);

		rowNumber->setVisible(true);

		_rowNumberItems[row] = rowNumber;
	}
	else
		rowNumber = _rowNumberItems[row];

	rowNumber->setX(_viewportX);

	return _rowNumberItems[row];
}
Пример #7
0
void Packet::set_source_node(Node* node)
{   //assign the source node
    source_node = node;
    std::pair<int,int> loc = location(node);
    QQuickItem *item = qobject_cast<QQuickItem*>(pac_obj);
    item->setProperty("x", loc.first+offset);
    item->setProperty("y", loc.second+offset);
    QObject::connect(this->pac_obj, SIGNAL(dest_reached(QString)), this->source_node,SLOT(send_pack(QString)),Qt::UniqueConnection);

}
void QmlProfilerTraceView::resizeEvent(QResizeEvent *event)
{
    QWidget::resizeEvent(event);
    QQuickItem *rootObject = d->m_mainView->rootObject();
    if (rootObject) {
        rootObject->setProperty("width", QVariant(event->size().width()));
        int newHeight = event->size().height() - d->m_timebar->height() - d->m_overview->height();
        rootObject->setProperty("candidateHeight", QVariant(newHeight));
    }
    emit resized();
}
Пример #9
0
QList<quint32> MainView2D::selectFixturesRect(QRectF rect)
{   
    QList<quint32>fxList;

    if (rect.width() == 0 || rect.height() == 0)
        return fxList;

    QMap<quint32, QQuickItem *>::const_iterator i = m_itemsMap.constBegin();
    while (i != m_itemsMap.constEnd())
    {
        QQuickItem *fxItem = i.value();
        qreal itemXPos = fxItem->property("x").toReal();
        qreal itemYPos = fxItem->property("y").toReal();
        qreal itemWidth = fxItem->property("width").toReal();
        qreal itemHeight = fxItem->property("height").toReal();

        QRectF itemRect(itemXPos, itemYPos, itemWidth, itemHeight);

        qDebug() << "Rect:" << rect << "itemRect:" << itemRect;

        if (rect.contains(itemRect))
        {
            if (fxItem->property("isSelected").toBool() == false)
            {
                fxItem->setProperty("isSelected", true);
                fxList.append(i.key());
            }
        }
        ++i;
    }
    return fxList;
}
Пример #10
0
void KonvergoWindow::playerWindowVisible(bool visible)
{
  // adjust webengineview transparecy depending on player visibility
  QQuickItem *web = findChild<QQuickItem *>("web");
  if (web)
    web->setProperty("backgroundColor", visible ? "transparent" : "#111111");
}
Пример #11
0
void QmlProfilerTraceView::changeEvent(QEvent *e)
{
    if (e->type() == QEvent::EnabledChange) {
        QQuickItem *rootObject = d->m_mainView->rootObject();
        rootObject->setProperty("enabled", isEnabled());
    }
}
Пример #12
0
QQuickItem * DataSetView::createTextItem(int row, int col)
{
	//std::cout << "createTextItem("<<row<<", "<<col<<") called!\n" << std::flush;

	if((_cellTextItems.count(col) == 0 && _cellTextItems[col].count(row) == 0) || _cellTextItems[col][row] == NULL)
	{

		if(_itemDelegate == NULL)
		{
			_itemDelegate = new QQmlComponent(qmlEngine(this));
			_itemDelegate->setData("import QtQuick 2.10\nText { property bool active: true; text: \"???\"; color: active ? 'black' : 'grey' }", QUrl());
		}

		QQuickItem * textItem = NULL;

		if(_textItemStorage.size() > 0)
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createTextItem("<<row<<", "<<col<<") from storage!\n" << std::flush;
#endif
			textItem = _textItemStorage.top();
			_textItemStorage.pop();
		}
		else
		{
#ifdef DEBUG_VIEWPORT
			std::cout << "createTextItem("<<row<<", "<<col<<") ex nihilo!\n" << std::flush;
#endif
			textItem = qobject_cast<QQuickItem*>(_itemDelegate->create());
			textItem->setParent(this);
			textItem->setParentItem(this);
		}

		QModelIndex ind(_model->index(row, col));
		bool active = _model->data(ind, _roleNameToRole["active"]).toBool();
		textItem->setProperty("color", active ? "black" : "grey");
		textItem->setProperty("text", _model->data(ind));
		textItem->setX(_colXPositions[col] + _itemHorizontalPadding);
		textItem->setY(-2 + _dataRowsMaxHeight + _itemVerticalPadding + row * _dataRowsMaxHeight);
		textItem->setZ(-4);
		textItem->setVisible(true);

		_cellTextItems[col][row] = textItem;
	}

	return _cellTextItems[col][row];
}
Пример #13
0
void MainView2D::updateFixtureRotation(quint32 itemID, QVector3D degrees)
{
    if (isEnabled() == false || m_itemsMap.contains(itemID) == false)
        return;

    QQuickItem *fxItem = m_itemsMap[itemID];
    fxItem->setProperty("rotation", degrees.y());
}
Пример #14
0
void MainView2D::setFixtureFlags(quint32 itemID, quint32 flags)
{
    QQuickItem *fxItem = m_itemsMap.value(itemID, NULL);

    if (fxItem == NULL)
        return;

    fxItem->setProperty("visible", (flags & MonitorProperties::HiddenFlag) ? false : true);
}
Пример #15
0
void MainView2D::setUniverseFilter(quint32 universeFilter)
{
    PreviewContext::setUniverseFilter(universeFilter);
    QMapIterator<quint32, QQuickItem*> it(m_itemsMap);
    while(it.hasNext())
    {
        it.next();
        quint32 fxID = it.key();
        QQuickItem *fxItem = it.value();
        Fixture *fixture = m_doc->fixture(fxID);
        if (fixture == NULL)
            continue;

        if (universeFilter == Universe::invalid() || fixture->universe() == universeFilter)
            fxItem->setProperty("visible", "true");
        else
            fxItem->setProperty("visible", "false");
    }
}
Пример #16
0
void Packet::create_packet(QString name, QObject *main_panel, QQmlApplicationEngine *engine) {
    // Load Node QML file
    QQmlComponent component(engine, QUrl("qrc:/qml_files/packet.qml"));
    // Create QObject
    pac_obj = component.create();
    // Cast it as a QQuickItem
    QQuickItem *item = qobject_cast<QQuickItem*>(pac_obj);
    // Set the parent as the main_panel (this changes when added to a link)
    item->setParentItem(qobject_cast<QQuickItem*>(main_panel));
    item->setProperty("pack_name", name);
#ifdef Q_OS_ANDROID
    item->setProperty("packet_size", 50);
    offset = 25;
#else
    item->setProperty("packet_size", 20);
    offset = 13;
#endif
    this->name = name;
}
Пример #17
0
/////////////////////////////////////////////////////////
// Toolbar buttons
void QmlProfilerTraceView::toggleRangeMode(bool active)
{
    QQuickItem *rootObject = d->m_mainView->rootObject();
    bool rangeMode = rootObject->property("selectionRangeMode").toBool();
    if (active != rangeMode) {
        if (active)
            d->m_buttonRange->setIcon(QIcon(QLatin1String(":/qmlprofiler/ico_rangeselected.png")));
        else
            d->m_buttonRange->setIcon(QIcon(QLatin1String(":/qmlprofiler/ico_rangeselection.png")));
        rootObject->setProperty("selectionRangeMode", QVariant(active));
    }
}
Пример #18
0
void ModuleInterface::updateCategoryAndLanguageModels() {
    QQuickItem* object = findQmlObject("moduleChooser");
    if (object == 0)
        return;

    getCategoriesAndLanguages();
    setupTextModel(m_categories, &m_categoryModel);
    setupTextModel(m_languages, &m_languageModel);
    updateWorksModel();
    object->setProperty("categoryModel", QVariant::fromValue(&m_categoryModel));
    object->setProperty("languageModel", QVariant::fromValue(&m_languageModel));
}
Пример #19
0
void PaperManager::init_buffer()
{
    if( p->buffer.length() == BUFFER_SIZE )
        return;

    for( int i=0; i<BUFFER_SIZE; i++ )
    {
        QQuickItem *paper = createPaper();
        paper->setProperty( "visible", (BUFFER_SIZE-i <= 2) );
        paper->setProperty( "paperZ", i );

        connect( paper, SIGNAL(closed(QVariant))              , SLOT(paperClosed(QVariant))          );
        connect( paper, SIGNAL(entered(QVariant))             , SLOT(paperEntered(QVariant))         );
        connect( paper, SIGNAL(deleted(QVariant))             , SLOT(deletePaper(QVariant))          );
        connect( paper, SIGNAL(saved(int))                    , SLOT(paperSaved(int))                );
        connect( paper, SIGNAL(outMove(QVariant))             , SLOT(outMove(QVariant))              );
        connect( paper, SIGNAL(outMoveFinished())             , SLOT(outMoveFinished())              );

        p->buffer.prepend( paper );
    }
}
Пример #20
0
void GLWidget::resizeGL(int width, int height)
{
    int x, y, w, h;
    double this_aspect = (double) width / height;
    double video_aspect = m_monitorProfile->dar();

    // Special case optimisation to negate odd effect of sample aspect ratio
    // not corresponding exactly with image resolution.
    if ((int) (this_aspect * 1000) == (int) (video_aspect * 1000))
    {
        w = width;
        h = height;
    }
    // Use OpenGL to normalise sample aspect ratio
    else if (height * video_aspect > width)
    {
        w = width;
        h = width / video_aspect;
    }
    else
    {
        w = height * video_aspect;
        h = height;
    }
    x = (width - w) / 2;
    y = (height - h) / 2;
    m_rect.setRect(x, y, w, h);
    double scale = (double) m_rect.width() / m_monitorProfile->width() * m_zoom;
    QPoint center = m_rect.center();
    QQuickItem* rootQml = rootObject();
    if (rootQml) {
        rootQml->setProperty("center", center);
        rootQml->setProperty("scale", scale);
        if (rootQml->objectName() == "rootsplit") {
            // Adjust splitter pos
            rootQml->setProperty("splitterPos", x + (rootQml->property("realpercent").toDouble() * w));
        }
    }
    emit rectChanged();
}
Пример #21
0
void ActionManager::requestActionPopup(ActionManager::ActionType type, QString message, int buttonsMask, QVariantList data)
{
    QQuickItem *popupItem = qobject_cast<QQuickItem*>(m_view->rootObject()->findChild<QObject *>("popupBox"));
    if (popupItem == NULL)
    {
        qDebug() << "popupBox not found !";
        return;
    }

    qDebug() << "[ActionManager] buttonsMask:" << buttonsMask << data;

    if (message.startsWith("qrc:"))
        popupItem->setProperty("resource", message);
    else
        popupItem->setProperty("message", message);
    popupItem->setProperty("buttonsMask", buttonsMask);

    // save the requested action to be processed when the user
    // confirms or rejects from the popup
    m_deferredAction = QPair<ActionType, QVariantList> (type, data);

    popupItem->setProperty("visible", true);
}
Пример #22
0
void Graph::update_node_position(qreal x, qreal y, QString string)
{
    Node *node = get_node_by_name(string);
    QObject *obj = node->get_q_object();
    std::vector<Link*> lnks = get_link_from_node(node);
    for (std::vector<Link*>::iterator iter = lnks.begin(); iter != lnks.end(); iter++)
    {
        Link *temp = *iter;
        QQuickItem *tmp = qobject_cast<QQuickItem*>(temp->get_q_object());
        QQuickItem *node1 = qobject_cast<QQuickItem*>(obj);
        int y_off = node1->height();
        int x_off = node1->width();
        if (temp->get_source()->get_id() == node->get_id()) {
            tmp->setProperty("x1", x + x_off/2);
            tmp->setProperty("y1", y + y_off/2);
        } else {
            tmp->setProperty("x2", x + x_off/2);
            tmp->setProperty("y2", y + y_off/2);
        }
    }
    node->set_x(x);
    node->set_y(y);
}
Пример #23
0
void PaperManager::paperEntered( const QVariant & var )
{
    p->current--;
    emit currentPaperChanged();
    emit currentIndexChanged();

    QQuickItem *paper = var.value<QQuickItem*>();
    Q_UNUSED(paper)

    if( p->current == 0 )
        return;

    QQuickItem *btm = p->buffer.takeLast();
    p->buffer.prepend( btm );
    reindexBuffer();

    btm->setProperty( "anim", false );
    btm->setProperty( "x", btm->property("closeX") );
    btm->setProperty( "opacity", 1 );
    btm->setProperty( "visible", true );

    load_buffers();
}
void Graph::_drawLabel(float x, float y, QString text, QHash<QString, QQuickItem*> &labelCache) {
    if(labelComponent == NULL) {
        QQmlEngine * engine = new QQmlEngine();
        labelComponent = new QQmlComponent(engine, QUrl("qrc:/src/qml/controls/common/_Text.qml", QUrl::StrictMode));

        if( labelComponent->status() != QQmlComponent::Ready)
        {
            qDebug() << ("Error:"+ labelComponent->errorString() );
            return; // or maybe throw
        }
    }

    if( labelComponent->status() != QQmlComponent::Ready)
    {
        return;
    }


    QQuickItem * label = labelCache[text];

    if (!label) { //TODO: Someday, scene graph might have a better text renderer
        label= qobject_cast<QQuickItem*>(labelComponent->create());
        label->setParentItem(this->parentItem()); //TODO: Who REALLY owns this item? The component? Or the Hash?

        label->setProperty("text", text);
        label->setProperty("width", "parent.width");
        label->children().first()->setProperty("color", m_primaryLineColor.darker());

        labelCache[text] = label;
    }

    if (label != NULL) {
        label->setProperty("x", x);
        label->setProperty("y", y);
    }
}
Пример #25
0
void PaperManager::paperClosed( const QVariant & var )
{
    QQuickItem *paper = var.value<QQuickItem*>();
    if( p->buffer.indexOf(paper) == 0 && p->current != 0 )
    {
        paper->setProperty( "x" ,paper->property("closeX") );
        return;
    }

    if( p->current >= p->papers.count() )
        QMetaObject::invokeMethod( paper, "save" );

    p->current++;
    emit currentPaperChanged();
    emit currentIndexChanged();

    if( p->current == 1 )
    {
        p->buffer.last()->setProperty( "visible" ,true );
        load_buffers();
        return;
    }

    QQuickItem *top = p->buffer.takeFirst();
    p->buffer << top;
    reindexBuffer();

    top->setProperty( "anim" ,false );
    top->setProperty( "x" ,0 );

    top->setProperty( "opacity", 0 );
    QMetaObject::invokeMethod( top, "startAnimation" );
    top->setProperty( "opacity", 1 );

    load_buffers();
}
void TelegramImageElement::initImage()
{
    if(p->image)
        return;

    QQmlEngine *engine = qmlEngine(this);
    QQmlContext *context = qmlContext(this);
    if(!engine || !context)
        return;

    QQmlComponent component(engine);

    QString qmlImageCreationCode = p->qmlImageCreationCode;
    if(qmlImageCreationCode.isEmpty())
        qmlImageCreationCode = QString("import QtQuick %1\n"
                                       "Image { anchors.fill: parent; }").arg(p->qtQuickVersion);

    component.setData(qmlImageCreationCode.toUtf8(), QUrl());
    QQuickItem *item = qobject_cast<QQuickItem *>(component.create(context));
    if(!item)
        return;

    item->setParent(this);
    item->setParentItem(this);

    QHashIterator<QString, QVariant> i(p->properties);
    while(i.hasNext())
    {
        i.next();
        item->setProperty(i.key().toUtf8(), i.value());
    }

    connect(item, SIGNAL(asynchronousChanged()), this, SIGNAL(asynchronousChanged()));

    #if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
        connect(item, SIGNAL(autoTransformChanged()), this, SIGNAL(autoTransformChanged()));
    #endif

    connect(item, SIGNAL(cacheChanged()), this, SIGNAL(cacheChanged()));
    connect(item, SIGNAL(fillModeChanged()), this, SIGNAL(fillModeChanged()));
    connect(item, SIGNAL(mirrorChanged()), this, SIGNAL(mirrorChanged()));
    connect(item, SIGNAL(sourceSizeChanged()), this, SIGNAL(sourceSizeChanged()));

    p->image = item;
}
Пример #27
0
void VCButton::render(QQuickView *view, QQuickItem *parent)
{
    if (view == NULL || parent == NULL)
        return;

    QQmlComponent *component = new QQmlComponent(view->engine(), QUrl("qrc:/VCButtonItem.qml"));

    if (component->isError())
    {
        qDebug() << component->errors();
        return;
    }

    QQuickItem *item = qobject_cast<QQuickItem*>(component->create());

    item->setParentItem(parent);
    item->setProperty("buttonObj", QVariant::fromValue(this));
}
Пример #28
0
void MainView2D::updateFixturePosition(quint32 itemID, QVector3D pos)
{
    if (isEnabled() == false)
        return;

    if (m_itemsMap.contains(itemID) == false)
    {
        quint32 fxID = FixtureUtils::itemFixtureID(itemID);
        quint16 headIndex = FixtureUtils::itemHeadIndex(itemID);
        quint16 linkedIndex = FixtureUtils::itemLinkedIndex(itemID);
        createFixtureItem(fxID, headIndex, linkedIndex, pos, false);
    }
    else
    {
        QQuickItem *fxItem = m_itemsMap[itemID];
        QPointF point = FixtureUtils::item2DPosition(m_monProps, m_monProps->pointOfView(), pos);
        fxItem->setProperty("mmXPos", point.x());
        fxItem->setProperty("mmYPos", point.y());
    }
}
Пример #29
0
void ModuleInterface::updateWorksModel() {
    m_worksModel.clear();
    m_modules.clear();

    QString currentLang = currentLanguage();
    QString currentCat = currentCategory();

    QHash<int, QByteArray> roleNames;
    roleNames[TextRole] =  "modelText";
    m_worksModel.setRoleNames(roleNames);

    BtBookshelfModel* bookshelfModel = CSwordBackend::instance()->model();
    if (bookshelfModel == 0)
        return;
    int count = bookshelfModel->rowCount();
    for (int row=0; row<count; ++row) {
        QModelIndex index = bookshelfModel->index(row);
        CSwordModuleInfo* module = getModule(bookshelfModel, index);
        CSwordModuleInfo::Category category = module->category();
        QString categoryName = module->categoryName(category);
        const CLanguageMgr::Language* language = module->language();
        QString languageName = language->translatedName();
        if (languageName == currentLang &&
                categoryName == currentCat) {
            m_modules << module;
            QString moduleName = module->name();
            QStandardItem* item = new QStandardItem();
            item->setData(moduleName, TextRole);
            m_worksModel.appendRow(item);
        }
    }

    QQuickItem* object = findQmlObject("moduleChooser");
    if (object == 0)
        return;
    object->setProperty("worksModel", QVariant::fromValue(&m_worksModel));
}
Пример #30
0
void QmlProfilerTraceView::setAppKilled()
{
    QQuickItem *rootObject = d->m_mainView->rootObject();
    if (rootObject)
        rootObject->setProperty("appKilled",QVariant(true));
}