void WatchWidget::CreateWidgets()
{
  m_toolbar = new QToolBar;
  m_toolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  m_table = new QTableWidget;

  m_table->setColumnCount(5);
  m_table->verticalHeader()->setHidden(true);
  m_table->setContextMenuPolicy(Qt::CustomContextMenu);
  m_table->setSelectionMode(QAbstractItemView::SingleSelection);

  m_load = AddAction(m_toolbar, tr("Load"), this, &WatchWidget::OnLoad);
  m_save = AddAction(m_toolbar, tr("Save"), this, &WatchWidget::OnSave);

  m_load->setEnabled(false);
  m_save->setEnabled(false);

  auto* layout = new QVBoxLayout;
  layout->addWidget(m_toolbar);
  layout->addWidget(m_table);

  QWidget* widget = new QWidget;
  widget->setLayout(layout);

  setWidget(widget);
}

void kexInputKey::InitActions(void) {
    kexStr actionDef;
    kexKeyMap *keys;
    kexArray<kexHashKey> *list;
    kexStr name;
    int value;

    if( !gameManager.GameDef()                                      ||
        !gameManager.GameDef()->GetString("actionDef", actionDef)   ||
        !(keys = defManager.FindDefEntry(actionDef))) {
            common.Warning("kexInputKey::InitActions: No input action definition found\n");
            return;
    }

    list = keys->GetHashList();

    for(int i = 0; i < keys->GetHashSize(); i++) {
        for(unsigned int j = 0; j < list[i].Length(); j++) {
            name = list[i][j].GetName();
            if(!keys->GetInt(name, value)) {
                common.Warning("kexInputKey::InitActions: entry %s contains non-integer value (%s)\n",
                    name.c_str(), list[i][j].GetString());
                continue;
            }

            AddAction((byte)value, (kexStr("+") + name).c_str());
            AddAction((byte)value, (kexStr("-") + name).c_str());
        }
    }
}

void WatchWidget::ShowContextMenu()
{
  QMenu* menu = new QMenu(this);

  if (m_table->selectedItems().size())
  {
    auto row_variant = m_table->selectedItems()[0]->data(Qt::UserRole);

    if (!row_variant.isNull())
    {
      int row = row_variant.toInt();

      if (row >= 0)
      {
        // i18n: This kind of "watch" is used for watching emulated memory.
        // It's not related to timekeeping devices.
        AddAction(menu, tr("&Delete Watch"), this, [this, row] { DeleteWatch(row); });
        AddAction(menu, tr("&Add Memory Breakpoint"), this,
                  [this, row] { AddWatchBreakpoint(row); });
      }
    }
  }

  menu->addSeparator();

  AddAction(menu, tr("Update"), this, &WatchWidget::Update);

  menu->exec(QCursor::pos());
}

IcecastFilterWidget::IcecastFilterWidget(QWidget* parent)
    : QWidget(parent),
      ui_(new Ui_IcecastFilterWidget),
      menu_(new QMenu(tr("Display options"), this)),
      sort_mode_mapper_(new QSignalMapper(this)) {
  ui_->setupUi(this);

  // Icons
  ui_->options->setIcon(IconLoader::Load("configure"));

  // Options actions
  QActionGroup* group = new QActionGroup(this);
  AddAction(group, ui_->action_sort_genre_popularity,
            IcecastModel::SortMode_GenreByPopularity);
  AddAction(group, ui_->action_sort_genre_alphabetically,
            IcecastModel::SortMode_GenreAlphabetical);
  AddAction(group, ui_->action_sort_station,
            IcecastModel::SortMode_StationAlphabetical);

  // Options menu
  menu_->setIcon(ui_->options->icon());
  menu_->addActions(group->actions());
  ui_->options->setMenu(menu_);

  connect(sort_mode_mapper_, SIGNAL(mapped(int)), SLOT(SortModeChanged(int)));
}

IcecastFilterWidget::IcecastFilterWidget(QWidget *parent)
  : QWidget(parent),
    ui_(new Ui_IcecastFilterWidget),
    sort_mode_mapper_(new QSignalMapper(this))
{
  ui_->setupUi(this);

  // Icons
  ui_->options->setIcon(IconLoader::Load("configure"));

  // Options actions
  QActionGroup* group = new QActionGroup(this);
  AddAction(group, ui_->action_sort_genre_popularity, IcecastModel::SortMode_GenreByPopularity);
  AddAction(group, ui_->action_sort_genre_alphabetically, IcecastModel::SortMode_GenreAlphabetical);
  AddAction(group, ui_->action_sort_station, IcecastModel::SortMode_StationAlphabetical);

  // Options menu
  QMenu* options_menu = new QMenu(this);
  options_menu->addActions(group->actions());
  ui_->options->setMenu(options_menu);

  connect(sort_mode_mapper_, SIGNAL(mapped(int)), SLOT(SortModeChanged(int)));

#ifdef Q_OS_DARWIN
  delete ui_->filter;
  MacLineEdit* lineedit = new MacLineEdit(this);
  ui_->horizontalLayout->insertWidget(1, lineedit);
  filter_ = lineedit;
#else
  filter_ = ui_->filter;
#endif
}

void MenuBar::AddFileMenu()
{
  QMenu* file_menu = addMenu(tr("&File"));
  m_open_action = AddAction(file_menu, tr("&Open..."), this, &MenuBar::Open,
                            QKeySequence(QStringLiteral("Ctrl+O")));
  m_exit_action = AddAction(file_menu, tr("E&xit"), this, &MenuBar::Exit,
                            QKeySequence(QStringLiteral("Alt+F4")));
}

//-----------------------------------------------------------------------------
//! Create menu from common actions 
//-----------------------------------------------------------------------------
tVesselsSettingsMenuLowrance::tVesselsSettingsMenuLowrance( QWidget* parent )
: tVesselsSettingsMenuCommon( parent )
{
    SetTitle( tr( "Vessels", "TITLE" ) );

    tDistanceUnits distanceUnits = (tDistanceUnits)tUnitsSettings::Instance()->Units( UNITS_DISTANCE );

    // Must match tVesselsSettings.cpp
    QStringList lengthOptions;
    lengthOptions << tr( "Off" );
    if ( distanceUnits == UNITS_DISTANCE_NAUTICAL_MILES )
    {            
        lengthOptions << tr( "1 NM", "nautical miles" );
        lengthOptions << tr( "10 NM", "nautical miles" );
        lengthOptions << tr( "100 NM", "nautical miles" );
    }

    else if ( distanceUnits == UNITS_DISTANCE_KILOMETERS )
    {        
        lengthOptions << tr( "1 km", "kilometers" );
        lengthOptions << tr( "10 km", "kilometers" );
        lengthOptions << tr( "100 km", "kilometers" );
    }

    else if ( distanceUnits == UNITS_DISTANCE_MILES )
    {        
        lengthOptions << tr( "1 mile", "miles" );
        lengthOptions << tr( "10 miles", "miles" );
        lengthOptions << tr( "100 miles", "miles" );
    }

    lengthOptions << tr( "1 min", "minutes" ) 
                  << tr( "2 min", "minutes" )
                  << tr( "10 min", "minutes" )
                  << tr( "30 min", "minutes" )
                  << tr( "60 min", "minutes" )
                  << tr( "120 min", "minutes" );

    int initialIndex = 0;
    if ( m_VesselsSettings.ExtensionLines() &&
         m_VesselsSettings.CourseExtensionConfig() != tVesselsSettings::Extension_Infinite )
    {
        initialIndex = static_cast<int>( m_VesselsSettings.CourseExtensionConfig() ) + 1; //Plus one to step over "Off"
    }

    m_pCourseExtensionAct = new tListAction( tr( "Course extension" ), lengthOptions, initialIndex );
    Connect( m_pCourseExtensionAct, SIGNAL( ValueFinalised( int ) ), this, SLOT( OnCourseExtensionFinalised( int ) ) );

    // HDS 5x (sonar-only) doesn't fully expose AIS, but does have MARPA
    //  MARPA only really needs the course extension and dangerous vessels menu items
    if( tProductSettings::Instance().AISAllowed() )
    {
        AddAction( m_pSetMMSIAct );
        AddAction( m_pHideIconsAct );
    }
    AddAction( m_pCourseExtensionAct );
    AddAction( m_pDangerousVesselsAct );
}

void __fastcall TReconcileErrorForm::InitReconcileActions() {
  AddAction(raSkip);
  AddAction(raCancel);
  AddAction(raCorrect);
  if (FCurColIdx > 0) {
    AddAction(raRefresh);
    AddAction(raMerge);
  }
  ActionGroup->ItemIndex = 0;
}

DemoOcclusion::DemoOcclusion()
{
  SetTitle("Occlusion Demo");
  AddAction('1', "Increase Occlusion", std::bind(&DemoOcclusion::OcclusionInc, this));
  AddAction('2', "Decrease Occlusion", std::bind(&DemoOcclusion::OcclusionDec, this));

  OccludeValue = 0;

  YSE::System().occlusionCallback(OcclusionFunction);
	sound.create("..\\TestResources\\pulse1.ogg", nullptr, true);
	sound.occlusion(true);
  sound.play();
}

//-----------------------------------------------------------------------------
//! Create menu from common actions 
//-----------------------------------------------------------------------------
tCZoneSettingsMenuSimrad::tCZoneSettingsMenuSimrad( QWidget* parent )
: tCZoneSettingsMenuCommon( parent )
{
    SetTitle( "CZone" );   // don't need to translate brand name

    AddAction( m_pSetBatteryFullAction );
    AddAction( m_pShowOnStartupAction );
    AddAction( m_pBacklightAction );
    AddSeparator();
    AddAction( m_pSetDipswitchAction );
//    AddAction( m_pReclaimAction );

}

void MenuBar::AddStateLoadMenu(QMenu* emu_menu)
{
  m_state_load_menu = emu_menu->addMenu(tr("&Load State"));
  AddAction(m_state_load_menu, tr("Load State from File"), this, &MenuBar::StateLoad);
  AddAction(m_state_load_menu, tr("Load State from Selected Slot"), this, &MenuBar::StateLoadSlot);
  m_state_load_slots_menu = m_state_load_menu->addMenu(tr("Load State from Slot"));
  AddAction(m_state_load_menu, tr("Undo Load State"), this, &MenuBar::StateLoadUndo);

  for (int i = 1; i <= 10; i++)
  {
    QAction* action = m_state_load_slots_menu->addAction(QStringLiteral(""));

    connect(action, &QAction::triggered, this, [=]() { emit StateLoadSlotAt(i); });
  }
}

bool CCharShape::RotateNode (size_t node_name, int axis, ETR_DOUBLE angle) {
	TCharNode *node = GetNode (node_name);
	if (node == NULL) return false;

	if (axis > 3) return false;

	TMatrix<4, 4> rotMatrix;
	char caxis = '0';
	switch (axis) {
		case 1:
			caxis = 'x';
			break;
		case 2:
			caxis = 'y';
			break;
		case 3:
			caxis = 'z';
			break;
	}

	rotMatrix.SetRotationMatrix(angle, caxis);
	node->trans = node->trans * rotMatrix;
	rotMatrix.SetRotationMatrix(-angle, caxis);
	node->invtrans = rotMatrix * node->invtrans;

	if (newActions && useActions) AddAction (node_name, axis, NullVec3, angle);
	return true;
}

/* Handles startup.
*/
static AIErr StartupPlugin ( SPInterfaceMessage* message )
{
	AIErr error = kNoErr;
	error = AcquireSuites( message->d.basic );
	if (!error) {
		// Allocate our globals - Illustrator will keep track of these.
		error = message->d.basic->AllocateBlock( sizeof(Globals), (void **) &g );
		if ( !error ) { 
			message->d.globals = g;
		}
	}
	if (!error) {
		error = AddMenu(message);
	}
	if (!error) {	
		error = AddFilter(message);
	}
	if (!error) {
		error = AddTool(message);
	}
	if (!error) {
		error = AddAction(message);
	}
	ReleaseSuites( message->d.basic );
	return error;
}

QAction* NodeInstanceWidget::AddActionDelete()
{
	return AddAction( tr("Delete"), [this](){
		deleteLater();
		emit DeleteNodeInstance(mNodeInstance);
	});
}

bool CCharShape::RotateNode (size_t node_name, int axis, double angle) {
    TCharNode *node = GetNode (node_name);
    if (node == NULL) return false;

    if (axis > 3) return false;

    TMatrix rotMatrix;
    char caxis = '0';
    switch (axis) {
    case 1:
        caxis = 'x';
        break;
    case 2:
        caxis = 'y';
        break;
    case 3:
        caxis = 'z';
        break;
    }

    MakeRotationMatrix (rotMatrix, angle, caxis);
    MultiplyMatrices (node->trans, node->trans, rotMatrix);
    MakeRotationMatrix (rotMatrix, -angle, caxis);
    MultiplyMatrices (node->invtrans, rotMatrix, node->invtrans);

    if (newActions && useActions) AddAction (node_name, axis, NullVec, angle);
    return true;
}

void OMenu :: AddAction (OEHAction *action )
{

  if ( action )
    AddAction(action->get_qaction());

}

logical OMenu :: SetupActions (OEHAction *action )
{
  QAction       *before_action = NULL;
  OEHAction     *oeh_action    = NULL;
  OPopupMenu    *sub_menu      = NULL;
  int            count         = 0;
  int            indx0         = 0;
  logical        term          = NO;
BEGINSEQ
  if( !qwidget )                                     ERROR
  if( !action || !action->get_childs() )             ERROR
  if ( !qwidget->actions().isEmpty() )
    before_action = qwidget->actions().first();
  count = action->get_childs()->size();
  
  menu_action = action;
  qwidget->setObjectName(action->GetName());

  while ( indx0 < count )
  {
    oeh_action = action->get_childs()->at(indx0++);
    if ( oeh_action->IsSeparated() )
      AddSeparator(before_action);
    if ( !oeh_action->get_childs() || oeh_action->get_childs()->size() <= 0 )
      AddAction(oeh_action->get_qaction(),before_action);
    else if ( oeh_action->IsGrouped() )
      AddActions(&oeh_action->get_group()->actions(),before_action);
    else
      AddMenu(oeh_action,before_action);
  }
RECOVER
  term = YES;
ENDSEQ
  return(term);
}

STDMETHODIMP CPropertyChoice::AddActionsByCLSID (CALPCLSID *pcaClsIds)
{
HRESULT hr = E_FAIL;

	if (!m_fIsInitialized) {
		hr = InitNew();
		if (FAILED(hr)) return hr;
	}

// hinzufügen der einzelnen Aktionen
	for (ULONG i = 0; i < pcaClsIds -> cElems; i++) {
		try {
		WPropertyAction WAct (*(pcaClsIds -> ppElems[i]));	// throws hr

			{
			WPersistStreamInit Init = WAct;			// throws hr

				hr = Init -> InitNew();
				if (FAILED(hr)) _com_issue_error(hr);
			}		
			hr = AddAction (WAct);
			if (FAILED(hr)) _com_issue_error(hr);

		} catch (_com_error& hr) {
			return _COM_ERROR(hr);
		}
	}

	return NOERROR;
}

///	\brief	serialize current object state for redo action
///	\param	size - sizeof(IHashString*)
///	\param	param - pointer to IHashString with name of object to serialize
DWORD CUndoRedoComponent::OnRedoSaveObject(DWORD size, void *param)
{
	ASSERT(m_pCurrentCommandData != NULL);

	VERIFY_MESSAGE_SIZE(size, sizeof(IHashString*));
	IHashString *pObjectName = GetName(param);
	if (pObjectName == NULL)
	{
		return MSG_ERROR;
	}

	DWORD res = m_DependantProcessors.ProcessObject(pObjectName, false);
	if (MSG_HANDLED != res)
	{
		return res;
	}

	IUndoRedoAction *pAction = new CObjectSerializeAction(pObjectName);
	res = AddAction(pAction, false);
	if (res != MSG_HANDLED)
	{
		delete pAction;
	}
	return res;
}

nsresult nsEudoraFilters::AddMailboxAction(const char* pMailboxPath, bool isTransfer)
{
  nsresult rv;
  nsCString nameHierarchy;
#if defined(XP_WIN)
  nsCString filePath;
  m_pLocation->GetNativePath(filePath);
  int32_t index = filePath.RFindChar('\\');
  if (index >= 0)
    filePath.SetLength(index);
  if (!nsEudoraWin32::GetMailboxNameHierarchy(filePath, pMailboxPath,
                                              nameHierarchy))
    return NS_ERROR_INVALID_ARG;
#endif
#ifdef XP_MACOSX
  nameHierarchy = pMailboxPath;
#endif

  nsCOMPtr<nsIMsgFolder> folder;
  rv = GetMailboxFolder(nameHierarchy.get(), getter_AddRefs(folder));

  nsAutoCString folderURI;
  if (NS_SUCCEEDED(rv))
    rv = folder->GetURI(folderURI);
  if (NS_FAILED(rv))
    return NS_ERROR_INVALID_ARG;

  rv = AddAction(isTransfer? (nsMsgRuleActionType)nsMsgFilterAction::MoveToFolder : (nsMsgRuleActionType)nsMsgFilterAction::CopyToFolder, 0, 0, 0, nullptr, folderURI.get());

  if (NS_SUCCEEDED(rv) && isTransfer)
    m_hasTransfer = true;

  return rv;
}