void SjMainFrame::CreateUnqueueMenu(SjMenu& mainMenu)
{
	long trackCount = m_player.m_queue.GetCount();
	long markedCount = m_display.m_selectedIds.GetCount();

	if( IsOpAvailable(SJ_OP_UNQUEUE) )
	{
		mainMenu.Append(IDO_UNQUEUE_MARKED);
		mainMenu.Enable(IDO_UNQUEUE_MARKED, (markedCount>0));

		mainMenu.Append(IDO_UNQUEUE_ALL_BUT_MARKED);
		mainMenu.Enable(IDO_UNQUEUE_ALL_BUT_MARKED, (markedCount>0 && trackCount>markedCount));
	}
}
void SjMainFrame::CreateViewMenu(SjMenu* viewMenu, bool createMainMenu, bool appendGotoCurrMark)
{
	bool enableQueue = m_player.m_queue.GetCount()!=0;

	if( appendGotoCurrMark )
	{
		viewMenu->Append(IDO_GOTO_CURR_MARK);
	}

	viewMenu->Append(IDT_GOTO_CURR);
	viewMenu->Enable(IDT_GOTO_CURR, enableQueue);

	viewMenu->Append(IDT_WORKSPACE_GOTO_RANDOM);

	viewMenu->AppendSeparator();

	viewMenu->Append(IDT_WORKSPACE_TOGGLE_VIEW);

	if( createMainMenu || IsOpAvailable(SJ_OP_ZOOM) )
	{
		SjMenu* zoomMenu = new SjMenu(viewMenu->ShowShortcuts());
		zoomMenu->Append(IDT_ZOOM_IN);
		zoomMenu->Append(IDT_ZOOM_OUT);
		zoomMenu->Append(IDT_ZOOM_NORMAL);
		zoomMenu->AppendSeparator();
		zoomMenu->AppendCheckItem(IDO_SAMEZOOMINALLVIEWS, _("Same zoom in all views"));
		zoomMenu->Check(IDO_SAMEZOOMINALLVIEWS, (g_accelModule->m_flags&SJ_ACCEL_SAME_ZOOM_IN_ALL_VIEWS)!=0);
		viewMenu->Append(0, _("Zoom"), zoomMenu);
	}

	if( createMainMenu || IsAllAvailable() )
	{
		wxString showCoverText; // default by SjAccelModule
		if( m_browser->GetView() == SJ_BROWSER_COVER_VIEW ) showCoverText = _("Show album name");
		viewMenu->AppendCheckItem(IDT_WORKSPACE_SHOW_COVERS, showCoverText);
		viewMenu->Check(IDT_WORKSPACE_SHOW_COVERS, m_browser->AreCoversShown());
	}

	viewMenu->Append(IDT_TOGGLE_TIME_MODE, m_showRemainingTime? _("Show elapsed time") : _("Show remaining time"));
	viewMenu->Enable(IDT_TOGGLE_TIME_MODE, enableQueue);


	if( createMainMenu || !IsKioskStarted() )
	{
		viewMenu->AppendSeparator();

		viewMenu->AppendCheckItem(IDT_ALWAYS_ON_TOP);
		viewMenu->Check(IDT_ALWAYS_ON_TOP, IsAlwaysOnTop());
	}

	viewMenu->AppendSeparator();

	// add vis. toggle
	if( g_visModule ) {
		viewMenu->AppendCheckItem(IDT_START_VIS, _("Video screen"));
		viewMenu->Check(IDT_START_VIS, g_visModule->IsVisStarted());
	}
}
void SjOscModule::AddMenuOptions(SjMenu& m)
{
	m.AppendCheckItem(IDC_SHOWSPECTRUM, _("Show spectrum"));
	m.Check(IDC_SHOWSPECTRUM, (m_showFlags&SJ_OSC_SHOW_SPECTRUM)!=0);

	m.AppendCheckItem(IDC_SHOWOSCILLOSCOPE, _("Show oscilloscope"));
	m.Check(IDC_SHOWOSCILLOSCOPE, (m_showFlags&SJ_OSC_SHOW_OSC)!=0);

	m.AppendCheckItem(IDC_SHOWSTARFIELD, _("Show starfield"));
	m.Check(IDC_SHOWSTARFIELD, (m_showFlags&SJ_OSC_SHOW_STARFIELD)!=0);

	m.AppendCheckItem(IDC_SHOWFIGURES, _("Show other figures"));
	m.Check(IDC_SHOWFIGURES, (m_showFlags&SJ_OSC_SHOW_FIGURES)!=0);
}
void SjMainFrame::CreateSearchMenu(SjMenu& m)
{
	// History
	if( m_search.IsSet() && m_searchStat.m_totalResultCount > 0 )
	{
		g_advSearchModule->AddToHistory(m_search);
	}

	int i, iCount = g_advSearchModule->GetHistoryCount();
	SjSearchHistory currentSearch(m_search);
	if( iCount )
	{
		for( i=iCount-1; i >= 0; i-- )
		{
			const SjSearchHistory* item = g_advSearchModule->GetHistory(i);
			wxString title = item->GetTitle();
			if( !title.IsEmpty() )
			{
				if( *item == currentSearch )
				{
					m.AppendCheckItem(IDO_SEARCHHISTORY00+i, title);
					m.Check(IDO_SEARCHHISTORY00+i, TRUE);
				}
				else
				{
					m.Append(IDO_SEARCHHISTORY00+i, title);
				}
			}
		}
	}

	if( IsOpAvailable(SJ_OP_MUSIC_SEL_GENRE) )
	{
		// Direct genre selection
		wxArrayString data = m_libraryModule->GetUniqueValues(SJ_TI_GENRENAME);
		iCount = (int)data.GetCount();
		if( iCount )
		{
			#define MAX_SEARCH_GENRE_IN_MENU (IDO_SEARCHGENRE999-IDO_SEARCHGENRE000)
			if( iCount > MAX_SEARCH_GENRE_IN_MENU ) iCount = MAX_SEARCH_GENRE_IN_MENU;

			SjMenu* genreMenu = new SjMenu(m.ShowShortcuts());
			for( i =0; i < iCount; i++ )
			{
				genreMenu->Append(IDO_SEARCHGENRE000+i, data[i]);
			}
			m.Append(0, _("Search for genre"), genreMenu);
		}
	}


	if( IsOpAvailable(SJ_OP_MUSIC_SEL) )
	{
		// Direct music selection
		iCount = g_advSearchModule->GetSearchCount();
		if( iCount )
		{
			#define MAX_MUSIC_SEL_IN_MENU (IDO_SEARCHMUSICSEL999-IDO_SEARCHMUSICSEL000)
			if( iCount > MAX_MUSIC_SEL_IN_MENU ) iCount = MAX_MUSIC_SEL_IN_MENU;

			SjMenu* advSearchMenu = new SjMenu(m.ShowShortcuts());
			wxString name;
			for( i =0; i < iCount; i++ )
			{
				name = g_advSearchModule->GetSearchByIndex(i, FALSE).GetName();
				if( !name.IsEmpty() )
				{
					advSearchMenu->Append(IDO_SEARCHMUSICSEL000+i, name);
				}
			}
			m.Append(0, _("Search for music selection"), advSearchMenu);
		}
	}
}
void SjMainFrame::CreateContextMenu_(SjMenu& mainMenu,
                                     bool prependOpen, int idmSettings, bool appendGotoCurrMark,
                                     bool embedFastSearch)
{
	// prepend open/save items (reverse order!)
	/* -- as we have a normal menu bar since 15.1, the context menu can be more focused
	if( prependOpen && IsAllAvailable() )
	{
		if(  mainMenu.GetMenuItemCount() )
		{
			mainMenu.InsertSeparator(0);
		}

		bool enableQueue = m_player.m_queue.GetCount()!=0;
		mainMenu.Insert(0, IDT_UNQUEUE_ALL);
		mainMenu.Enable(IDT_UNQUEUE_ALL, enableQueue);

		mainMenu.Insert(0, IDT_SAVE_PLAYLIST);
		mainMenu.Enable(IDT_SAVE_PLAYLIST, enableQueue);

		mainMenu.Insert(0, IDT_OPEN_FILES);
	}
	*/

	// search
	// -- as we have a normal menu bar since 15.1, the context menu can be more focused (search only added if embedFastSearch set, formally this was always the case)
	if( embedFastSearch && IsOpAvailable(SJ_OP_SEARCH) )
	{
		// open adv. search dialog
		if( mainMenu.GetMenuItemCount() )
		{
			mainMenu.AppendSeparator();
		}

		if( IsAllAvailable() )
		{
			mainMenu.Append(IDT_ADV_SEARCH);
		}

		// "fast search"
		if( embedFastSearch )
		{
			CreateSearchMenu(mainMenu);
		}

		// end search
		mainMenu.Append(IDO_REALLYENDSEARCH, _("End search"));
		mainMenu.Enable(IDO_REALLYENDSEARCH, HasAnySearch());
	}

	// settings / view  / control
	/* -- as we have a normal menu bar since 15.1, the context menu can be more focused
	if( IsAllAvailable() )
	{

		// seperator abottom (sth. will follow in any case, at least "Go to random album")
		if( mainMenu.GetMenuItemCount() )
		{
			mainMenu.AppendSeparator();
		}

		// settings
		mainMenu.Append(idmSettings);

		// view menu
		SjMenu* viewMenu = new SjMenu(mainMenu.ShowShortcuts());
		CreateViewMenu(viewMenu, false, appendGotoCurrMark);
		mainMenu.Append(0, _("View"), viewMenu);

		// control menu
		SjMenu* playbackMenu = new SjMenu(mainMenu.ShowShortcuts());
		CreatePlaybackMenu(playbackMenu, false);
		mainMenu.Append(0, _("Playback"), playbackMenu);
	}
	*/

	// help
	if( IsKioskStarted() )
	{
		mainMenu.Append(IDO_ABOUT, wxString::Format(_("About %s"), SJ_PROGRAM_NAME)+wxString(wxT("...")));
	}
}
void SjMainFrame::CreatePlaybackMenu(SjMenu* playbackMenu, bool createMainMenu)
{
	bool anythingInQueue = GetQueueCount()>0;
	playbackMenu->Append(IDT_MORE_FROM_CURR_ALBUM);
	playbackMenu->Enable(IDT_MORE_FROM_CURR_ALBUM, anythingInQueue);
	playbackMenu->Append(IDT_MORE_FROM_CURR_ARTIST);
	playbackMenu->Enable(IDT_MORE_FROM_CURR_ARTIST, anythingInQueue);
	playbackMenu->AppendSeparator();

	if( createMainMenu || IsOpAvailable(SJ_OP_PLAYPAUSE) )
	{
		playbackMenu->AppendRadioItem(IDT_PLAY);
		playbackMenu->Check(IDT_PLAY, m_player.IsPlaying());

		playbackMenu->AppendRadioItem(IDT_PAUSE);
		playbackMenu->Check(IDT_PAUSE, m_player.IsPaused());

		playbackMenu->AppendRadioItem(IDT_STOP);
		playbackMenu->Check(IDT_STOP, m_player.IsStopped());

		playbackMenu->AppendCheckItem(IDT_STOP_AFTER_THIS_TRACK);
		playbackMenu->Check(IDT_STOP_AFTER_THIS_TRACK, m_player.StopAfterThisTrack());

		playbackMenu->AppendCheckItem(IDT_STOP_AFTER_EACH_TRACK);
		playbackMenu->Check(IDT_STOP_AFTER_EACH_TRACK, m_player.StopAfterEachTrack());
	}

	if( createMainMenu || IsOpAvailable(SJ_OP_EDIT_QUEUE) )
	{
		if( !IsOpAvailable(SJ_OP_PLAYPAUSE) ) playbackMenu->AppendSeparator();

		playbackMenu->Append(IDT_PREV);
		playbackMenu->Enable(IDT_PREV, HasPrev());

		bool hasNext = HasNextRegardAP();
		playbackMenu->Append(IDT_NEXT, GetNextMenuTitle());
		playbackMenu->Enable(IDT_NEXT, hasNext);

		playbackMenu->Append(IDT_FADE_TO_NEXT);
		playbackMenu->Enable(IDT_FADE_TO_NEXT, hasNext);

	}

	if( createMainMenu || IsOpAvailable(SJ_OP_MAIN_VOL) )
	{
		SjMenu* volMenu = new SjMenu(playbackMenu->ShowShortcuts());

		volMenu->Append(IDT_MAIN_VOL_UP);

		volMenu->Append(IDT_MAIN_VOL_DOWN);

		volMenu->AppendCheckItem(IDT_MAIN_VOL_MUTE);
		volMenu->Check(IDT_MAIN_VOL_MUTE, m_player.GetMainVolMute());

		playbackMenu->Append(0, _("Volume"), volMenu);
	}

	if( createMainMenu || IsOpAvailable(SJ_OP_EDIT_QUEUE) || IsOpAvailable(SJ_OP_REPEAT) || IsOpAvailable(SJ_OP_PLAYPAUSE) )
	{
		playbackMenu->AppendSeparator();

		if( createMainMenu || IsOpAvailable(SJ_OP_REPEAT) )
		{
			wxString repeatText; // default by SjAccelModule
			if( m_player.m_queue.GetRepeat()==1 ) repeatText = _("Repeat one");
			if( m_player.m_queue.GetRepeat()==2 ) repeatText = _("Repeat all");
			playbackMenu->AppendCheckItem(IDT_REPEAT, repeatText);
			playbackMenu->Check(IDT_REPEAT, m_player.m_queue.GetRepeat()!=0);
		}

		if( createMainMenu || IsOpAvailable(SJ_OP_EDIT_QUEUE) )
		{
			playbackMenu->AppendCheckItem(IDT_SHUFFLE);
			playbackMenu->Check(IDT_SHUFFLE, m_player.m_queue.GetShuffle());
		}

		if( createMainMenu || IsOpAvailable(SJ_OP_EDIT_QUEUE) || IsOpAvailable(SJ_OP_PLAYPAUSE) )
		{
			SjMenu* queueMenu = new SjMenu(playbackMenu->ShowShortcuts());

			if( IsOpAvailable(SJ_OP_PLAYPAUSE) )
			{
				queueMenu->AppendCheckItem(IDO_START_PB_ON_ENQUEUE, _("Start playback on first enqueue"));
				queueMenu->Check(IDO_START_PB_ON_ENQUEUE, (g_accelModule->m_flags&SJ_ACCEL_START_PLAYBACK_ON_ENQUEUE)!=0);
			}

			if( IsOpAvailable(SJ_OP_EDIT_QUEUE) )
			{
				queueMenu->AppendCheckItem(IDT_PLAY_NOW_ON_DBL_CLICK);
				queueMenu->Check(IDT_PLAY_NOW_ON_DBL_CLICK, (g_accelModule->m_flags&SJ_ACCEL_PLAY_NOW_ON_DBL_CLICK)!=0);
			}

			playbackMenu->Append(0, _("Queue"), queueMenu);
		}
	}

}
void SjKaraokeModule::AddMenuOptions(SjMenu& m)
{
	SjMenu* submenu = new SjMenu(0);
		submenu->AppendRadioItem(IDC_BG_DEFAULT_IMAGES, _("Default"));
		submenu->Check(IDC_BG_DEFAULT_IMAGES, (m_bgType == SJ_KARAOKE_BG_DEFAULT_IMAGES));

		submenu->AppendRadioItem(IDC_BG_BLACK, _("Black"));
		submenu->Check(IDC_BG_BLACK, (m_bgType == SJ_KARAOKE_BG_BLACK));

		if( !m_bgUserDefDir.IsEmpty() )
		{
			submenu->AppendRadioItem(IDC_BG_USERDEF_DIR_USE, SjTools::ShortenUrl(m_bgUserDefDir));
			submenu->Check(IDC_BG_USERDEF_DIR_USE, (m_bgType == SJ_KARAOKE_BG_USERDEF_DIR));
		}

		submenu->Append(IDC_BG_USERDEF_DIR_CHANGE, _("Select..."));
	m.Append(IDC_BG_SUBMENU, _("Background"), submenu);

	m.AppendCheckItem(IDC_BG_USEBGJPG, wxString::Format(_("Use %s-files"), wxT("*.bg.jpg")));
	m.Check(IDC_BG_USEBGJPG, (m_karFlags&SJ_KAR_USEBGJPG)!=0);

	m.AppendCheckItem(IDC_BG_KEEPASPECT, _("Fit to screen"));
	m.Check(IDC_BG_KEEPASPECT, (m_karFlags&SJ_KAR_KEEPASPECT)==0);

	m.AppendCheckItem(IDC_BG_SMOOTH, _("Smooth"));
	m.Check(IDC_BG_SMOOTH, (m_karFlags&SJ_KAR_SMOOTH)!=0);

	m.AppendCheckItem(IDC_BG_GRAYSCALE, _("Grayscale"));
	m.Check(IDC_BG_GRAYSCALE, (m_karFlags&SJ_KAR_GRAYSCALE)!=0);
}