C++ QAction::property方法代码示例

bool GCF::ActionContainerWidget::event(QEvent* e)
{
    switch(e->type())
    {
    case QEvent::ActionAdded:
    {
        QActionEvent* ae = (QActionEvent*)e;
        QAction* action = ae->action();
        QWidget* actionWidget = 0;

        int row=-1, col=-1;
        int rowSpan = action->property("rowSpan").toInt();
        int colSpan = action->property("colSpan").toInt();
        if(!rowSpan)
            rowSpan = 1;
        if(!colSpan)
            colSpan = 1;
        if(rowSpan > d->maxRows)
            rowSpan = d->maxRows;

        actionWidget = createWidget(action, rowSpan, colSpan);

        d->gridLayout->findCell(rowSpan, colSpan, &row, &col);
        d->gridLayout->addWidget(actionWidget, row, col, rowSpan, colSpan, Qt::AlignJustify);

        d->actionWidgetMap[action] = actionWidget;
        action->setProperty("row", row);
        action->setProperty("col", col);

        actionWidget->show();

    }
    return true;

    case QEvent::ActionRemoved:
    {
        QActionEvent* ae = (QActionEvent*)e;
        QAction* action = ae->action();
        QWidget* actionWidget = d->actionWidgetMap.contains(action) ? d->actionWidgetMap[action] : 0;

        int row = action->property("row").toInt();
        int col = action->property("col").toInt();
        int rowSpan = action->property("rowSpan").toInt();
        int colSpan = action->property("colSpan").toInt();

        if(actionWidget && qobject_cast<QToolButton*>(actionWidget))
            delete actionWidget;

        d->actionWidgetMap.remove(action);
        d->gridLayout->markCells(false, row, col, rowSpan, colSpan);
    }
    return true;

    default:
        break;
    }

    return QWidget::event(e);
}

void MainWindow::actionResolution(){
    QAction *action = (QAction*)sender();

    setWidth( action->property("width").toInt());
    setHeight(action->property("height").toInt());

    updateResolution();
}

void SettingsWindow::onAction()
{
    QAction *triggeredAction = static_cast<QAction*>(sender());
    foreach (QAction *action, ui->toolBar->actions())
        action->setIcon(action->property("iconNormal").value<QIcon>());
    triggeredAction->setIcon(triggeredAction->property("iconActive").value<QIcon>());
    ui->stackedWidget->slideInIdx(triggeredAction->property("page").toInt());
}

	void CustomWebView::savePixmap ()
	{
		QAction *action = qobject_cast<QAction*> (sender ());
		if (!action)
		{
			qWarning () << Q_FUNC_INFO
					<< "sender is not an action"
					<< sender ();
			return;
		}

		const QPixmap& px = action->property ("Poshuku/OrigPX").value<QPixmap> ();
		if (px.isNull ())
			return;

		const QUrl& url = action->property ("Poshuku/OrigURL").value<QUrl> ();
		const QString origName = url.scheme () == "data" ?
				QString () :
				QFileInfo (url.path ()).fileName ();

		QString filter;
		QString fname = QFileDialog::getSaveFileName (0,
				tr ("Save pixmap"),
				QDir::homePath () + '/' + origName,
				tr ("PNG image (*.png);;JPG image (*.jpg);;All files (*.*)"),
				&filter);

		if (fname.isEmpty ())
			return;

		if (QFileInfo (fname).suffix ().isEmpty ())
		{
			if (filter.contains ("png"))
				fname += ".png";
			else if (filter.contains ("jpg"))
				fname += ".jpg";
		}

		QFile file (fname);
		if (!file.open (QIODevice::WriteOnly))
		{
			emit gotEntity (Util::MakeNotification ("Poshuku",
						tr ("Unable to save the image. Unable to open file for writing: %1.")
							.arg (file.errorString ()),
						PCritical_));
			return;
		}

		const QString& suf = QFileInfo (fname).suffix ();
		const bool isLossless = suf.toLower () == "png";
		px.save (&file,
				suf.toUtf8 ().constData (),
				isLossless ? 0 : 100);
	}

void TrayIcon::nextWallpaper()
{
    try
    {
        WallpaperResult result;
        QRect desktopSize = Desktop::GetSize();

        _trayIcon->setIcon(*_iconLoading);

        QAction *action = qobject_cast<QAction *>(sender());
        if (action && action->property("categoryIndex") != QVariant::Invalid)
        {
            int categoryIndex = action->property("categoryIndex").toInt();
            QList<SourceViewModel*> sources;
            sources.append(_settingsViewModel->GetSources()[categoryIndex]);

            result = _providersManager->DownloadRandomImage(
                    sources,
                    desktopSize.width(),
                    desktopSize.height());
        }
        else
        {
            result = _providersManager->DownloadRandomImage(
                    _settingsViewModel->GetSources(),
                    desktopSize.width(),
                    desktopSize.height());
        }

        if (result.image.length() > 0)
        {
            Desktop::SetWallpaper(result.image);
        }

        updateTrayIcon();

        _currentUrl = result.url;
        _currentDescription = result.urlDescription;
        _currentName = result.name;

        _trayIcon->showMessage(result.name,
                               result.urlDescription,
                               QSystemTrayIcon::Information, 4000);

        _timeCounter = 0;
        updateToolTip();
    }
    catch (...)
    {
    }
}

void FilterExpressionToolBar::onCustomMenuHandler(const QPoint& pos)
{
    QAction * filterAction = actionAt(pos);
    if ( ! filterAction )
        return;

    QMenu * filterMenu = new QMenu(this);

    QAction *actFilter = filterMenu->addAction(tr("Filter Button Preferences..."));
    connect(actFilter, SIGNAL(triggered()), this, SLOT(toolBarShowPreferences()));
    actFilter->setProperty(dfe_property_label_, filterAction->property(dfe_property_label_));
    actFilter->setProperty(dfe_property_expression_, filterAction->property(dfe_property_expression_));
    actFilter->setData(filterAction->data());
    filterMenu->addSeparator();
    QAction * actEdit = filterMenu->addAction(tr("Edit"));
    connect(actEdit, SIGNAL(triggered()), this, SLOT(editFilter()));
    actEdit->setProperty(dfe_property_label_, filterAction->property(dfe_property_label_));
    actEdit->setProperty(dfe_property_expression_, filterAction->property(dfe_property_expression_));
    actEdit->setData(filterAction->data());
    QAction * actDisable = filterMenu->addAction(tr("Disable"));
    connect(actDisable, SIGNAL(triggered()), this, SLOT(disableFilter()));
    actDisable->setProperty(dfe_property_label_, filterAction->property(dfe_property_label_));
    actDisable->setProperty(dfe_property_expression_, filterAction->property(dfe_property_expression_));
    actDisable->setData(filterAction->data());
    QAction * actRemove = filterMenu->addAction(tr("Remove"));
    connect(actRemove, SIGNAL(triggered()), this, SLOT(removeFilter()));
    actRemove->setProperty(dfe_property_label_, filterAction->property(dfe_property_label_));
    actRemove->setProperty(dfe_property_expression_, filterAction->property(dfe_property_expression_));
    actRemove->setData(filterAction->data());

    filterMenu->exec(mapToGlobal(pos));
}

void MainWindow::columnMenuChanged()
{
    QAction* action = static_cast<QAction*>(sender());

    if (action->isChecked())
    {
        QSettings().setValue(action->property("setting").toString(), true);
        ui->tableView->showColumn(action->property("columnIndex").toInt());
    }
    else
    {
        QSettings().setValue(action->property("setting").toString(), false);
        ui->tableView->hideColumn(action->property("columnIndex").toInt());
    }
}

void OBSBasic::ChangeSceneCollection()
{
	QAction *action = reinterpret_cast<QAction*>(sender());
	std::string fileName;

	if (!action)
		return;

	fileName = QT_TO_UTF8(action->property("fileName").value<QString>());
	if (fileName.empty())
		return;

	const char *oldName = config_get_string(App()->GlobalConfig(),
			"Basic", "SceneCollection");
	if (action->text().compare(QT_UTF8(oldName)) == 0) {
		action->setChecked(true);
		return;
	}

	SaveProjectNow();

	Load(fileName.c_str());
	RefreshSceneCollections();

	const char *newName = config_get_string(App()->GlobalConfig(),
			"Basic", "SceneCollection");
	const char *newFile = config_get_string(App()->GlobalConfig(),
			"Basic", "SceneCollectionFile");

	blog(LOG_INFO, "Switched to scene collection '%s' (%s.json)",
			newName, newFile);
	blog(LOG_INFO, "------------------------------------------------");

	UpdateTitleBar();
}

void MainWindow::actionScale(){
    QAction *action = (QAction*)sender();

    int scaleProperty = action->property("scale").toInt();
    int scaleCurrent = scale();

    switch(scaleProperty){
        case(eZoomIn):
            scaleProperty = scaleCurrent;
            ++scaleProperty;
            break;

        case(eZoomOut):
            scaleProperty = scaleCurrent;
            if(scaleProperty > 1)
                --scaleProperty;
            break;

        case(eFitToWindow):
            int width = scale() * ui.centralWidget->width() / ui.glCanvas->width();
            int height = scale() * ui.centralWidget->height() / ui.glCanvas->height();

            scaleProperty = std::min(width, height);
            break;
    }

    setScale(scaleProperty);

    updateResolution();
}

void MainWindow::actionOrientation(){
    QAction *action = (QAction*)sender();

    setOrientation(static_cast<Orientation>(action->property("orientation").toInt()));

    updateOrientation();
}

void MainWindow::actionFps(){
    QAction *action = (QAction*)sender();

    setFps(action->property("fps").toInt());

    updateFps();
}

void MediaView::updateSubscriptionAction(Video *video, bool subscribed) {
    QAction *subscribeAction = MainWindow::instance()->getAction("subscribeChannel");

    QString subscribeTip;
    QString subscribeText;
    if (!video) {
        subscribeText = subscribeAction->property("originalText").toString();
        subscribeAction->setEnabled(false);
    } else if (subscribed) {
        subscribeText = tr("Unsubscribe from %1").arg(video->getChannelTitle());
        subscribeTip = subscribeText;
        subscribeAction->setEnabled(true);
    } else {
        subscribeText = tr("Subscribe to %1").arg(video->getChannelTitle());
        subscribeTip = subscribeText;
        subscribeAction->setEnabled(true);
    }
    subscribeAction->setText(subscribeText);
    subscribeAction->setStatusTip(subscribeTip);

    if (subscribed) {
        subscribeAction->setIcon(IconUtils::icon("bookmark-remove"));
    } else {
        subscribeAction->setIcon(IconUtils::icon("bookmark-new"));
    }

    MainWindow::instance()->setupAction(subscribeAction);
}

void DatasetsListWidget::sl_renameDataset() {
    GCOUNTER(cvar, tvar, "WD::Dataset::Rename Dataset");
    QAction *a = dynamic_cast<QAction*>(sender());
    CHECK(NULL != a, );

    int idx = a->property("idx").toInt();
    CHECK(idx < tabs->count(), );

    bool error = false;
    QString text = tabs->tabText(idx);
    do {
        bool ok = false;
        text = QInputDialog::getText(this,
            tr("Rename Dataset"),
            tr("New dataset name:"),
            QLineEdit::Normal,
            text, &ok);
        if (!ok) {
            return;
        }
        U2OpStatusImpl os;
        ctrl->renameDataset(idx, text, os);
        if (os.hasError()) {
            QMessageBox::critical(this, tr("Error"), os.getError());
        }
        error = os.hasError();
    } while (error);

    tabs->setTabText(idx, text);
}

void CSceneWidget::contextMenuEvent(QContextMenuEvent *event)
{
    if(QGraphicsItem *item = itemAt(event->pos()))
    {
        _currentItem = qgraphicsitem_cast<CGraphicsItem *>(item);
        if(!qFuzzyCompare(item->zValue(), qreal(0.0))) // ignore first item, first item is background
        {
            QListIterator<QAction *> it(_itemsMenu->actions());
            while(it.hasNext())
            {
                QAction *action = it.next();
                if(action->property("action").toString().compare("hidebox") == 0)
                {
                    action->setChecked(!_currentItem->isEditMode());
                    action->setText(_currentItem->isEditMode()?tr("Hide box"):tr("Show box"));
                    break;
                }
            }
            _itemsMenu->exec(event->globalPos());
        }
        else
        {
            _sceneMenu->exec(event->globalPos());
        }
    }

    _currentItem = 0;
    update();
}

void MainWindow::updateAutoScale(){
    if(autoScale()){
        ui.centralWidget->setMinimumSize(1, 1);

    }else{
        ui.centralWidget->setMinimumSize(0, 0);

        QAction *action = resolutionGroup_->checkedAction();
        if(action){
            setWidth(action->property("width").toInt());
            setHeight(action->property("height").toInt());
        }
    }

    resolutionGroup_->setEnabled(!autoScale());

    updateResolution();
}