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

void PopupMenu::mouseReleaseEvent(QMouseEvent *e)
{
  DEBUG_PRST_ROUTES(stderr, "PopupMenu::mouseReleaseEvent this:%p\n", this);
   if(_contextMenu && _contextMenu->isVisible())
     return;
     
// Removed by Tim. Why not stay-open scrollable menus?
//    if(MusEGlobal::config.scrollableSubMenus)
//    {
//      QMenu::mouseReleaseEvent(e);
//      return;
//    }
   
   QAction* action = actionAt(e->pos());
   if (!(action && action == activeAction() && !action->isSeparator() && action->isEnabled()))
      action=NULL;

#ifdef POPUP_MENU_DISABLE_STAY_OPEN
   if (action && action->menu() != NULL  &&  action->isCheckable())
      action->activate(QAction::Trigger);

   QMenu::mouseReleaseEvent(e);

   if (action && action->menu() != NULL  &&  action->isCheckable())
      close();

   return;

#else
   
  // Check for Ctrl to stay open.
  const bool stay_open = _stayOpen && (MusEGlobal::config.popupsDefaultStayOpen || (e->modifiers() & Qt::ControlModifier));
  // Stay open? Or does the action have a submenu, but also a checkbox of its own?
  if(action && (stay_open || (action->isEnabled() && action->menu() && action->isCheckable())))
  {
    DEBUG_PRST_ROUTES(stderr, "PopupMenu::mouseReleaseEvent: stay open\n");
    action->trigger();  // Trigger the action. 
    e->accept();
    if(!stay_open)
      closeUp();
    return;     // We handled it.
  }
  // Otherwise let ancestor QMenu handle it...
  e->ignore();
  QMenu::mouseReleaseEvent(e);

#endif   // POPUP_MENU_DISABLE_STAY_OPEN
}

void ActionsManager::setupLocalAction(QAction *localAction, const QLatin1String &globalAction, bool connectTrigger)
{
	if (!localAction)
	{
		return;
	}

	QAction *action = getAction(globalAction);

	if (action)
	{
		localAction->setCheckable(action->isCheckable());
		localAction->setChecked(action->isChecked());
		localAction->setEnabled(action->isEnabled());
		localAction->setIcon(action->icon());
		localAction->setText(action->text());
		localAction->setShortcut(action->shortcut());
		localAction->setObjectName(action->objectName());

		if (connectTrigger)
		{
			connect(localAction, SIGNAL(triggered()), action, SLOT(trigger()));
		}
	}
}

void QRToolBar::setChecked(int id, bool checked) {
   eAssert(id < (int) numButtons(), ("index (%d) out of bounds (0..%d) for QRToolBar::setChecked!",
           id, numButtons()-1));
   QAction *action = getAction(id);
   eAssert(action->isCheckable(), ("cannot set checked state to button %s[%d], as it is not-checkable type!", QROSE::getName(this).c_str(), id));
   action->setChecked(checked);
}

bool QActionProto::isCheckable() const
{
  QAction *item = qscriptvalue_cast<QAction*>(thisObject());
  if (item)
    return item->isCheckable();
  return false;
}

bool QRToolBar::isChecked(int id) const {
   eAssert(id < (int) numButtons(), ("index (%d) out of bounds (0..%d) for QRToolBar::isEnabled!",
           id, numButtons()-1));
   QAction *action = getAction(id);
   eAssert(action->isCheckable(), ("cannot verify checked state to button %s[%d], as it is not-checkable type!", QROSE::getName(this).c_str(), id));

   return action->isChecked();
}

void PopupProxy::tryInsertItem( HistoryItem const * const item,
                                int& remainingHeight,
                                const int index )
{
    QAction *action = new QAction(m_proxy_for_menu);
    QPixmap image( item->image() );
    if ( image.isNull() ) {
        // Squeeze text strings so that do not take up the entire screen (or more)
        QString text = m_proxy_for_menu->fontMetrics().elidedText( item->text().simplified(), Qt::ElideMiddle, m_menu_width );
        text.replace( '&', "&&" );
        action->setText(text);
    } else {
#if 0 // not used because QAction#setIcon does not respect this size; it does scale anyway. TODO: find a way to set a bigger image
        const QSize max_size( m_menu_width,m_menu_height/4 );
        if ( image.height() > max_size.height() || image.width() > max_size.width() ) {
            image = image.scaled( max_size, Qt::KeepAspectRatio, Qt::SmoothTransformation );
        }
#endif
        action->setIcon(QIcon(image));
    }

    action->setData(item->uuid());

    // if the m_proxy_for_menu is a submenu (aka a "More" menu) then it may the case, that there is no other action in that menu yet.
    QAction *before = index < m_proxy_for_menu->actions().count() ? m_proxy_for_menu->actions().at(index) : 0;
    // insert the new action to the m_proxy_for_menu
    m_proxy_for_menu->insertAction(before, action);

    // Determine height of a menu item.
    QStyleOptionMenuItem style_options;
    // It would be much easier to use QMenu::initStyleOptions. But that is protected, so until we have a better
    // excuse to subclass that, I'd rather implement this manually.
    // Note 2 properties, tabwidth and maxIconWidth, are not available from the public interface, so those are left out (probably not 
    // important for height. Also, Exlsive checkType is disregarded as  I don't think we will ever use it)
    style_options.initFrom(m_proxy_for_menu);
    style_options.checkType = action->isCheckable() ? QStyleOptionMenuItem::NonExclusive : QStyleOptionMenuItem::NotCheckable;
    style_options.checked = action->isChecked();
    style_options.font = action->font();
    style_options.icon = action->icon();
    style_options.menuHasCheckableItems = true;
    style_options.menuRect = m_proxy_for_menu->rect();
    style_options.text = action->text();

    int font_height = QFontMetrics(m_proxy_for_menu->fontMetrics()).height();

    int itemheight = m_proxy_for_menu->style()->sizeFromContents(QStyle::CT_MenuItem,
                                                              &style_options,
                                                              QSize( 0, font_height ),
                                                              m_proxy_for_menu).height();
    // Subtract the used height
    remainingHeight -= itemheight;
}

//--------------------------------------------------------------------------------------------------
/// 
//--------------------------------------------------------------------------------------------------
void CmdFeature::refreshCheckedState()
{
    std::map<QString, QAction*>::iterator it;
    bool isChecked = this->isCommandChecked();

    for (it = m_customTextToActionMap.begin(); it != m_customTextToActionMap.end(); ++it)
    {
        QAction* act = it->second;
        if (act->isCheckable())
        {
            it->second->setChecked(isChecked);
        }
    }
}

QVariant ActionModel::data(const QModelIndex &index, int role) const
{
  if (!index.isValid())
    return QVariant();

  QMutexLocker lock(Probe::objectLock());
  QAction *action = m_actions.at(index.row());
  if (!Probe::instance()->isValidObject(action))
    return QVariant();

  const int column = index.column();
  if (role == Qt::DisplayRole) {
    switch (column) {
    case AddressColumn:
      return Util::addressToString(action);
    case NameColumn:
      return action->text();
    case CheckablePropColumn:
      return action->isCheckable();
    case CheckedPropColumn:
      return VariantHandler::displayString(action->isChecked());
    case PriorityPropColumn:
      return Util::enumToString(action->priority(), 0, action);
    case ShortcutsPropColumn:
      return toString(action->shortcuts());
    default:
      return QVariant();
    }
  } else if (role == Qt::DecorationRole) {
    if (column == NameColumn) {
      return action->icon();
    } else if (column == ShortcutsPropColumn && m_duplicateFinder->hasAmbiguousShortcut(action)) {
      QIcon icon = QIcon::fromTheme(QStringLiteral("dialog-warning"));
      if (!icon.isNull()) {
        return icon;
      } else {
        return QColor(Qt::red);
      }
    }
  } else if (role == Qt::ToolTipRole) {
    if (column == ShortcutsPropColumn && m_duplicateFinder->hasAmbiguousShortcut(action)) {
      return tr("Warning: Ambiguous shortcut detected.");
    }
  } else if (role == ObjectModel::ObjectRole) {
    return QVariant::fromValue<QObject*>(action);
  }

  return QVariant();
}

void PopupMenu::clearAllChecks() const
{
   QList<QAction*> list = actions();
   for(int i = 0; i < list.size(); ++i)
   {
      QAction* act = list[i];
      if(PopupMenu* menu = qobject_cast<PopupMenu*>(act->menu()))
         menu->clearAllChecks();     // Recursive.
      if(act->isCheckable())
      {
         act->blockSignals(true);
         act->setChecked(false);
         act->blockSignals(false);
      }
   }
}

void ActionMapper::rebuildMenu(const QString& menu, QMenu* qmenu, const ShortcutController& shortcuts) {
	for (const QString& actionName : m_menus[menu]) {
		if (actionName.isNull()) {
			qmenu->addSeparator();
			continue;
		}
		if (m_hiddenActions.contains(actionName)) {
			continue;
		}
		if (actionName[0] == '.') {
			QString name = actionName.mid(1);
			QMenu* newMenu = qmenu->addMenu(m_menuNames[name]);
			rebuildMenu(name, newMenu, shortcuts);
			continue;
		}
		Action* action = &m_actions[actionName];
		QAction* qaction = qmenu->addAction(action->visibleName());
		qaction->setEnabled(action->isEnabled());
		if (action->isExclusive() || action->booleanAction()) {
			qaction->setCheckable(true);
		}
		if (action->isActive()) {
			qaction->setChecked(true);
		}
		const Shortcut* shortcut = shortcuts.shortcut(actionName);
		if (shortcut && shortcut->shortcut() > 0) {
			qaction->setShortcut(QKeySequence(shortcut->shortcut()));
		} else if (!m_defaultShortcuts[actionName].isEmpty()) {
			qaction->setShortcut(m_defaultShortcuts[actionName][0]);
		}
		QObject::connect(qaction, &QAction::triggered, [qaction, action](bool enabled) {
			if (qaction->isCheckable()) {
				action->trigger(enabled);
			} else {
				action->trigger();
			}
		});
		QObject::connect(action, &Action::enabled, qaction, &QAction::setEnabled);
		QObject::connect(action, &Action::activated, qaction, &QAction::setChecked);
		QObject::connect(action, &Action::destroyed, qaction, &QAction::deleteLater);
		if (shortcut) {
			QObject::connect(shortcut, &Shortcut::shortcutChanged, qaction, [qaction](int shortcut) {
				qaction->setShortcut(QKeySequence(shortcut));
			});
		}
	}
}

void TabBar::contextMenuEvent(QContextMenuEvent* event)
{
    if (event->x() < 0) return;

    int index = tabAt(event->x());

    if (index == -1)
        m_sessionMenu->exec(QCursor::pos());
    else
    {
        readyTabContextMenu();

        updateMoveActions(index);

        int sessionId = sessionAtTab(index);
        updateToggleActions(sessionId);
        updateToggleKeyboardInputMenu(sessionId);
        updateToggleMonitorActivityMenu(sessionId);
        updateToggleMonitorSilenceMenu(sessionId);

        m_mainWindow->setContextDependentActionsQuiet(true);

        QAction* action = m_tabContextMenu->exec(QCursor::pos());

        emit tabContextMenuClosed();

        if (action)
        {
            if (action->isCheckable())
                m_mainWindow->handleContextDependentToggleAction(action->isChecked(), action, sessionId);
            else
                m_mainWindow->handleContextDependentAction(action, sessionId);
        }

        m_mainWindow->setContextDependentActionsQuiet(false);

        updateMoveActions(m_tabs.indexOf(m_selectedSessionId));
        updateToggleActions(m_selectedSessionId);
        updateToggleKeyboardInputMenu(m_selectedSessionId);
        updateToggleMonitorActivityMenu(m_selectedSessionId);
        updateToggleMonitorSilenceMenu(m_selectedSessionId);
    }

    QWidget::contextMenuEvent(event);
}

QWidget* GCF::ActionContainerWidget::createWidget(QAction* action, int rowSpan, int colSpan)
{
    QWidget* ret = 0;
    int gSize=int((fontMetrics().height()+fontMetrics().ascent())*1.2);
    int minWidth = gSize*colSpan;

    QWidgetAction* wAction = qobject_cast<QWidgetAction*>(action);
    if(wAction)
        ret = wAction->requestWidget(this);
    else
    {
        QToolButton* tb = new QToolButton(this);
        tb->setDefaultAction(action);
        tb->setAutoRaise(true);
        /*if(action->menu())
            tb->setMenu(action->menu());*/
        tb->setIconSize(QSize(gSize-4,gSize-4));

        if(action->icon().isNull())
            tb->setToolButtonStyle(Qt::ToolButtonTextOnly);
        else if(colSpan == rowSpan && colSpan >= 2)
            tb->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
        else if(colSpan == rowSpan && colSpan == 1)
            tb->setToolButtonStyle(Qt::ToolButtonIconOnly);
        else if(colSpan >= 2 || rowSpan == 1)
            tb->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
        else if(rowSpan >= 3)
            tb->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);

        int mw = 0;
        if(tb->toolButtonStyle() != Qt::ToolButtonIconOnly)
            mw += fontMetrics().width(action->iconText())+2*fontMetrics().width("_");

        if(!action->icon().isNull())
        {
            switch(tb->toolButtonStyle())
            {
            case Qt::ToolButtonTextUnderIcon:
                if(mw < gSize-4)
                    mw = gSize-4;
                break;
            case Qt::ToolButtonTextBesideIcon:
                mw += gSize-4;
                break;
            }
        }
        if(minWidth < mw)
            minWidth = mw;

        if(action->menu())
        {
            // Connect the default action object to the tool button. This way
            // when the toolbutton with menu is clicked, the default action is
            // shown.
            QList<QAction*> actions = action->menu()->actions();
            QAction* defAction = 0;
            for(int i=0; i<actions.count(); i++)
            {
                QAction* action = actions[i];
                QList<QByteArray> propNames = action->dynamicPropertyNames();
                if(propNames.contains("_default_"))
                {
                    bool val = action->property("_default_").toBool();
                    if(val)
                    {
                        defAction = action;
                        break;
                    }
                }
            }

            if(defAction)
            {
                if(defAction->isCheckable())
                    connect(tb, SIGNAL(clicked()), defAction, SLOT(toggle()));
                else
                    connect(tb, SIGNAL(clicked()), defAction, SLOT(trigger()));

                QFont font = defAction->font();
                font.setBold(true);
                defAction->setFont(font);
            }
        }

        ret = tb;
    }

    ret->setMinimumSize(minWidth, gSize*rowSpan);

    if(!action->icon().isNull())
    {
        QFont font = ret->font();
        // font.setPointSize(font.pointSize()-1);
        ret->setFont(font);
    }

    /*static QPlastiqueStyle Style;
    ret->setStyle(&Style);*/

    return ret;
//.........这里部分代码省略.........

//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void tAutopilotSelectedDeviceMenu::AddDevice( const tN2kName& name, bool selected, bool enabled )
{
    QString nameStr = tGlobal<tNDP2k>::Instance()->DeviceManager().DataSourceStr( name );

    //DbgPrintf( QString("AddDevice nameStr=%1 value=%2").arg( nameStr ).arg( quint64( name.llValue() ) ) );

    if( nameStr == "???" ) // incase the simnet selection is a device we have never seen...
    {
        // Get Simnet Nmea2k DevTag instead
        unsigned char devTag[16] = ""; // DEV_TAG_CHARS
        if( SystemData::bGetDevTag( (unsigned char*)name.ToByteArray().data(), 0, devTag ) )
        {
            nameStr = QString((char *)devTag);
        }
    }

    bool insertDevice = false;
    // Sort names into order of decreasing name
    QList<tAction*> actionList = SubActions();
    int i;
    for( i = 0; i < actionList.size(); ++i )
    {
        quint64 nameInList = quint64( actionList[i]->data().toLongLong() );
        //DbgPrintf( QString("AddDevice: index=%1 nameInList=%2").arg( i ).arg( nameInList ) );
        if ( nameInList > 0 ) //If it's not one of the fixed items at the top or a separator
        {
            if( quint64( name.llValue() ) == nameInList )
            {
                //Already in list - just update
                //DbgPrintf( "Device already in list" );
                QAction* pAction = actionList[i];
                pAction->setText( nameStr );
                if ( pAction->isCheckable() )
                {
                    pAction->setChecked( selected );
                }
                return;
            }
            else if( quint64( name.llValue() ) > nameInList )
            {
                DbgPrintf( "Name greater than nameInList" );
                insertDevice = true;
                break;
            }
        }
    }

    tAction* pAction = new tAction( nameStr, this );
    pAction->setCheckable( true );
    pAction->setChecked( selected );
    pAction->setData( QVariant( name.llValue() ) );
    pAction->setEnabled( enabled );
    if( insertDevice )
    {
        DbgPrintf( QString("Inserting action at index %1").arg( i ) );
        InsertAction( actionList[i], pAction );
    }
    else // Append
    {
        DbgPrintf( QString("Adding action %1").arg( nameStr ) );
        AddAction( pAction );
    }

    m_SelectDeviceActGroup.append( pAction );

    Connect( pAction, SIGNAL( triggered( bool ) ), this, SLOT( SelectDevice( bool ) ) );
}

bool QRToolBar::isCheckable(int id) const {
   eAssert(id < (int) numButtons(), ("index (%d) out of bounds (0..%d) for QRToolBar::isCheckable!",
           id, numButtons()-1));
   QAction *action = getAction(id);
   return action->isCheckable();
}