Пример #1
0
BOOL LocalPictureManager::Init(LPCTSTR storagePath)
{	
	if (m_pCIIP == NULL)
	{
		TRACEST(_T("LocalPictureManager::Init"));
		PrgAPI* pAPI = PRGAPI();
		InfoProviderFactory* pIPF = pAPI->GetInfoProviderFactory();
		ASSERT(storagePath != NULL);
		m_pCIIP = new CachedImageInfoProvider;
		pIPF->RegisterInfoProvider(m_pCIIP, FALSE);
		m_pDIIP = new DirImageInfoProvider;
		m_pDIIP->SetSQLManager(pAPI->GetSQLManager());
		pIPF->RegisterInfoProvider(m_pDIIP, FALSE);



		m_defGlobal.LoadResourceID(IDR_PNG_ARTIST, _T("png"));
		m_defGlobal.SetBkColor(RGB(0,0,0), 0);
		m_defGlobal.GetDrawParams().zoomLockMode = GdiPlusPicDrawer::ZLM_FillArea;
		m_defAlbum.LoadResourceID(IDR_ALBUM, _T("jpg"));
		m_defAlbum.SetBkColor(RGB(0,0,0), 0);
		m_defAlbum.GetDrawParams().zoomLockMode = GdiPlusPicDrawer::ZLM_FillArea;
	}
	m_pCIIP->SetStoragePath(storagePath);

	m_pThumbnailCache = new GdiPlusBitmapCache(64, 64, 80);
	//m_pThumbnailCache = new GdiPlusBitmapCache(96, 96, 50);
	//m_pThumbnailCache = new GdiPlusBitmapCache(128, 128, 100);


	return TRUE;
}
Пример #2
0
ITSMenu& PlayListPane::GetInternalMenu(MenusEnum mnu)
{
	TRACEST(_T("PlayListPane::GetMenu."), mnu);
	ASSERT(mnu < M_Last);
	PrgAPI* pAPI = PRGAPI();
	if (m_pMenu[mnu] == NULL)
		m_pMenu[mnu] = pAPI->CreatePopupMenu();
	ITSMenu& curMenu = *m_pMenu[mnu];
	if (curMenu.GetInternalHandler() != NULL)
		return curMenu;
	curMenu.Create();
	switch (mnu)
	{
	case M_Main:
		{
			MenuManager* pMM = pAPI->GetMenuManager();
			curMenu.AppendMenu(ITSMenu::MIT_Menu, 
				(INT)pMM->GetMenu(MenuManager::MNU_PlayListModes).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_MODE));
			
			curMenu.AppendMenu(ITSMenu::MIT_Menu, 
				(INT)pMM->GetMenu(MenuManager::MNU_PlayListSerialization).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_PLAYLIST));

			curMenu.AppendMenu(ITSMenu::MIT_Separator, NULL, NULL);
			curMenu.AppendMenu(ITSMenu::MIT_String, MI_ShowNumbers, (LPTSTR)pAPI->GetString(IDS_SHOWNUMBERS));
		}
		break;
	default:
		ASSERT(0);
	}
	return curMenu;
}
Пример #3
0
BOOL LocalPictureManager::AddAlbumPicture(const FullAlbumRecord& rec, LPCTSTR imagePath)
{
	TRACEST(_T("LocalPictureManager::AddAlbumPicture"));
	ASSERT(rec.IsValid() && imagePath != NULL);
	ASSERT(m_pCIIP != NULL);
	if (m_pCIIP == NULL || !rec.IsValid() || imagePath == NULL)	return FALSE;

	IInfoProvider::Request req(IInfoProvider::SRV_AlbumImage);
	req.artist = rec.artist.name.c_str();
	req.album = rec.album.name.c_str();

	if (m_pCIIP->OpenRequest(req))
	{
		IInfoProvider::Result res;
		res.main = imagePath;
		res.additionalInfo = _T("");
		res.service = IInfoProvider::SRV_AlbumImage;
		if (m_pCIIP->AddResult(res))
		{
			if (GetMainAlbumPicture(rec) == NULL)
				ResetAlbumCache(rec);
			return TRUE;
		}
	}
	return FALSE;
}
Пример #4
0
ITSMenu& TrackListCtrl::GetInternalMenu(MenusEnum mnu)
{
	TRACEST(_T("TrackListCtrl::GetInternalMenu."), mnu);
	ASSERT(mnu < M_Last);
	PrgAPI* pAPI = PRGAPI();
	MenuManager* pMM = pAPI->GetMenuManager();
	if (m_pMenu[mnu] == NULL)
		m_pMenu[mnu] = pAPI->CreatePopupMenu();
	ITSMenu& curMenu = *m_pMenu[mnu];
	if (curMenu.GetInternalHandler() != NULL)
		return curMenu;
	curMenu.Create();
	switch (mnu)
	{
	case M_Main:
		//================= CONTEXT MENU TEMPLATE
		TCHAR bf[1000];
		_sntprintf(bf, 1000, _T("%s\t%s"), pAPI->GetString(IDS_PLAY), pAPI->GetString(IDS_KEYENTER));
		curMenu.AppendMenu(ITSMenu::MIT_String, MI_Play, bf, pAPI->GetIcon(ICO_Play16));
		_sntprintf(bf, 1000, _T("%s\t%s + %s"), pAPI->GetString(IDS_ENQUEUE), pAPI->GetString(IDS_KEYSHIFT), pAPI->GetString(IDS_KEYENTER));
		curMenu.AppendMenu(ITSMenu::MIT_String, MI_Enqueue, bf, pAPI->GetIcon(ICO_Add16));
		_sntprintf(bf, 1000, _T("%s\t%s + %s"), pAPI->GetString(IDS_INSERTAFTER), pAPI->GetString(IDS_KEYCTRL), pAPI->GetString(IDS_KEYENTER));
		curMenu.AppendMenu(ITSMenu::MIT_String, MI_InsertAfter, bf);
		curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
		_sntprintf(bf, 1000, _T("%s\t%s"), pAPI->GetString(IDS_LOCATEALBUM), pAPI->GetString(IDS_KEYHOME));
		curMenu.AppendMenu(ITSMenu::MIT_String, MI_LocateAlbum, bf, pAPI->GetIcon(ICO_Album16));
		break;
	default:
		ASSERT(0);
	}
	return curMenu;
}
Пример #5
0
INT InfoProviderFactory::LoadPlugins(LPCTSTR pluginsPath)
{
	TRACEST(_T("InfoProviderFactory::LoadPlugins"));
	ASSERT(pluginsPath != NULL);
	ASSERT(pluginsPath[_tcslen(pluginsPath) - 1] == '\\');
	INT count = 0;
	TCHAR spec[_MAX_PATH];
	_sntprintf(spec, _MAX_PATH, _T("%s*.dll"), pluginsPath);
	WIN32_FIND_DATA data;
	HANDLE h=FindFirstFile(spec,&data);
	if (h!=INVALID_HANDLE_VALUE) 
	{
		do 
		{
			TCHAR fname[_MAX_PATH];
			_sntprintf(fname, _MAX_PATH, _T("%s%s"), pluginsPath, data.cFileName);
			std::vector<ExternalInfoProvider*> ips = ExternalInfoProvider::Create(fname);
			for (size_t i = 0; i < ips.size(); i++)
			{
				IInfoProvider* pIP = ips[i];
				count++;
				pIP->SetInternetHandle(m_hNet);
				if (!RegisterInfoProvider(pIP, TRUE))
					delete pIP;
			}
		} 
		while (FindNextFile(h,&data));
		FindClose(h);
	}
	return count;
}
Пример #6
0
void InfoProviderFactory::SaveSettings()
{
	TRACEST(_T("InfoProviderFactory::SaveSettings."));
	if (m_pAppSettings != NULL)
	{
		INT idx = 0;
		IInfoProvider* ip = GetItemByIndex(idx);
		while (ip != NULL)
		{
			LPCTSTR ipName = ip->GetModuleInfo(IInfoProvider::IPI_Name);
			IConfigurable::SettingInfo setting;
			INT setIdx = 0;
			while (ip->GetSettingInfo(setIdx, setting))
			{
				if (setting.type == IConfigurable::COVT_LPCTSTR)
					m_pAppSettings->Write(ipName, setting.name, ip->GetLPCTSTRSetting(setIdx));
				else
					m_pAppSettings->Write(ipName, setting.name, ip->GetIntSetting(setIdx));
				setIdx++;
			}
			idx++;
			ip = GetItemByIndex(idx);
		}

	}
}
Пример #7
0
BOOL MenuManager::HandleGeneralCommands(MenuCommandsEnum cmd)
{
	TRACEST(_T("MenuManager::HandleGeneralCommands"), cmd);
	PrgAPI* pAPI = PRGAPI();
	ActionManager* pAM = pAPI->GetActionManager();
	switch (cmd)
	{
	case MENU_Exit:
		AfxGetMainWnd()->PostMessage(WM_QUIT);
		break;
	case MENU_ShowMainWindow:
		pAM->ShowMainWindow();
		break;
	case MENU_ShowMiniPlayer:
		pAPI->GetMiniPlayerDlg(TRUE)->ShowWindow(TRUE);
		break;
	case MENU_HideMiniPlayer:
		{
			CMiniPlayerDlg* pMPDlg = pAPI->GetMiniPlayerDlg(FALSE);
			if (pMPDlg)
				pMPDlg->ShowWindow(SW_HIDE);
		}
		break;
	//case MENU_ToggleMiniPlayer:
	//	pAPI->GetActionManager()->ShowMiniPlayer(!pAPI->GetActionManager()->IsMiniPlayerVisible());
	//	break;
	case MENU_ShowAboutDlg:
		pAM->ShowAboutDlg(AfxGetMainWnd());
		break;
	case MENU_ShowHistoryDlg:
		pAM->ShowHistoryDlg(AfxGetMainWnd());
		break;
	case MENU_ShowGamesDlg:
		pAM->ShowGamesDlg(AfxGetMainWnd());
		break;
	case MENU_ShowAdvancedSearch:
		pAPI->GetAdvancedSearchDlg()->ShowWindow(SW_SHOW);
		break;
	case MENU_ShowOptionsDlg:
		pAM->ShowOptionsDlg(AfxGetMainWnd());
		break;
	case MENU_ShowCollectionsDlg:
		pAM->ShowCollectionsDlg(AfxGetMainWnd());
		break;
	case MENU_UpdateLocalCollections:
		pAPI->GetCollectionManager()->RefreshLocalCollections(TRUE, FALSE, TRUE);
		break;
	case MENU_ShowSkinsDialog:
		pAM->ShowSkinsDlg(AfxGetMainWnd());
		break;
	case MENU_ShowLanguagesDialog:
		pAM->ShowLanguagesDlg(AfxGetMainWnd());
		break;
	default:
		return FALSE;
	}
	return TRUE;

}
Пример #8
0
BOOL CTeenSpiritDlg::OnInitDialog()
{
	TRACEST(_T("CTeenSpiritDlg::OnInitDialog"));
	CDialog::OnInitDialog();

	PrgAPI* pAPI = PRGAPI();
	ShortcutManager* pSM = pAPI->GetShortcutManager();
	pSM->Init(m_hWnd);

	AppSettings* appSettings = PRGAPI()->GetAppSettings();
	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		pSysMenu->AppendMenu(MF_STRING, IDM_SHOWMINIPLAYER, pAPI->GetString(IDS_SHOWMINIPLAYER));
		pSysMenu->AppendMenu(MF_SEPARATOR);
		pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, pAPI->GetString(IDS_ABOUT));
	}
	TCHAR title[100];
	FileVersion fv;
	GetFileVersion(fv);
	_sntprintf(title, 100, _T("%s %d.%di"), CTeenSpiritApp::sAppTitle, fv.Major, fv.Minor);
#ifdef _DEBUG
	_sntprintf(&title[_tcslen(title)], 100, _T(" [DEBUG: %d]"), fv.Build);
#endif
	SetWindowText(title);

	BCMenu::SetMenuDrawMode(1);

	SetIcon(m_hBigIcon, TRUE);			// Set big icon
	SetIcon(m_hSmallIcon, FALSE);		// Set small icon
		

	m_toolBar.Create(WS_VISIBLE | WS_CHILDWINDOW, CRect(0,0,0,0), this, 772);
	m_playerBar.SetMediaPlayer(pAPI->GetMediaPlayer());
	m_playerBar.Create(WS_VISIBLE | WS_CHILDWINDOW, CRect(0,0,0,0), this, 773);
	m_statusBar.Create(WS_VISIBLE | WS_CHILDWINDOW, CRect(0,0,0,0), this, 774);


	pAPI->SetNotificationTarget(&m_statusBar);

	m_PaneController.Init(this);

	//HotKeyManager* pHKM = pAPI->GetHotKeyManager();
	//pHKM->Init();//m_hWnd);

	SetTimer(TMR_InitialDelay, DELAY_TIMER_DELAY, NULL);
	if (pAPI->GetOption(OPT_GEN_CheckForUpdates))
		SetTimer(TMR_CheckNewVersion, CHECKNEWVERSION_TIMER_DELAY, NULL);
	SetTimer(TMR_HeartBeat, HEARTBEAT_TIMER_DELAY, NULL);
	SetTimer(TMR_AppMonitor, APPMONITOR_TIMER_DELAY, NULL);
	//SetTimer(TMR_PlayerMonitor, PLAYERMONITOR_TIMER_DELAY, NULL);
	LoadSettings();

	if (pAPI->GetOption(OPT_GEN_AutoUpdateDB) != 0)
		SetTimer(TMR_AutoUpdateDB, pAPI->GetOption(OPT_GEN_AutoUpdateDBDelay) * 1000, NULL);

	return FALSE;
}
Пример #9
0
BOOL DownloadWebPagePostA(std::string& page, HINTERNET hInternet, LPCSTR url, LPCSTR postData)
{
	TRACEST(_T("DownloadWebPagePostA"), CA2CT(url));
	BOOL bRet = FALSE;
	URL_COMPONENTSA comp;
	memset(&comp, 0, sizeof(URL_COMPONENTSA));
	comp.dwStructSize = sizeof(URL_COMPONENTSA);
	CHAR hostName[100], URI[100];
	comp.dwHostNameLength = comp.dwUrlPathLength = 100;
	comp.lpszHostName = hostName;
	comp.lpszUrlPath = URI;
	if (InternetCrackUrlA(url, 0, ICU_ESCAPE, &comp))
	{
		HINTERNET hConnection = InternetConnectA(hInternet, 
			comp.lpszHostName, 
			comp.nPort, 
			NULL, 
			NULL, 
			INTERNET_SERVICE_HTTP, 
			INTERNET_FLAG_KEEP_CONNECTION, 
			0);
		if (hConnection)
		{
			LPCSTR sAcceptTypes[] = {"*/*",NULL};
			HINTERNET hRequest=::HttpOpenRequestA(hConnection,
				"POST", // HTTP Verb
				comp.lpszUrlPath, // Object Name
				HTTP_VERSIONA, // Version
				NULL, // Reference
				sAcceptTypes, // Accept Type
				INTERNET_FLAG_NO_CACHE_WRITE | INTERNET_FLAG_FORMS_SUBMIT,
				0); // context call-back point
			if(hRequest)
			{
				static LPCSTR sHttpAccept = "Accept: */*\r\n";
				::HttpAddRequestHeadersA(hRequest, sHttpAccept, (DWORD)strlen(sHttpAccept), HTTP_ADDREQ_FLAG_ADD_IF_NEW);

				static LPCSTR szContentType = "Content-Type: application/x-www-form-urlencoded\r\n";
				if(::HttpSendRequestA(hRequest,	szContentType, (DWORD)strlen(szContentType), (LPVOID)postData, (DWORD)strlen(postData)))
					bRet = ReadInternetFile2StringA(hRequest, page);
				else
					HandleInternetError(_T("DownloadWebPagePostA. HttpSendRequestA"));
				InternetCloseHandle(hRequest);

			}
			else
				HandleInternetError(_T("DownloadWebPagePostA. HttpOpenRequestA"));
			InternetCloseHandle(hConnection);

		}
		else
			HandleInternetError(_T("DownloadWebPagePostA. InternetConnectA"));
	}
	else
		HandleInternetError(_T("DownloadWebPagePostA. InternetCrackUrlA"));
	return bRet;
}
Пример #10
0
void LocalPictureManager::LoadState(LPCTSTR stateRoot)
{
	TRACEST(_T("LocalPictureManager::LoadState"));
	ASSERT(m_pThumbnailCache != NULL);//=== You must call Init first
	if (m_pThumbnailCache != NULL)
	{
		std::tstring thumbsDB(stateRoot);
		thumbsDB += sThumbsDB;
		m_pThumbnailCache->LoadState(thumbsDB.c_str());
	}
}
Пример #11
0
void HotKeyManager::SaveSettings()
{
	TRACEST(_T("HotKeyManager::SaveSettings."));
	PrgAPI* pAPI = PRGAPI();
	AppSettings* appSettings = pAPI->GetAppSettings();
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyPlay, (INT) m_HotKeys[HK_Play - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyStop, (INT) m_HotKeys[HK_Stop - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyPrev, (INT) m_HotKeys[HK_Prev - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyNext, (INT) m_HotKeys[HK_Next - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyMiniPlayer, (INT) m_HotKeys[HK_ToggleMiniPlayer - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyTooltip, (INT) m_HotKeys[HK_Tooltip - HK_First - 1]);
	appSettings->Write(HotKeyManagerSettingsCategory, cHotkeyQuickSearch, (INT) m_HotKeys[HK_QuickSearch - HK_First - 1]);

}
Пример #12
0
BOOL CQuizRunningDlg::DisplayNextQuestion()
{
	TRACEST(_T("CQuizRunningDlg::DisplayNextQuestion"));
	PrgAPI* pAPI = PRGAPI();
	ActionManager* pAM = pAPI->GetActionManager();
	TracksFilter tf;
	tf.Duration.match = NUMM_Over;
	tf.Duration.val = 30;
	FullTrackRecordCollection col;
	if (!pAM->GetRandomTrackCollection(col, tf, 4))
		return FALSE;
	UINT trackLength = 0;
	TCHAR trackPath[MAX_PATH];
	m_correctAnswer = INT((rand() * 4) / RAND_MAX);
	FullTrackRecordSP rec;
	for (int i = 0; i < 4; i++)
	{
		TCHAR txt[1000];
		_sntprintf(txt, 1000, _T("%d. %s - %s"), i + 1, col[i]->artist.name.c_str(),col[i]->track.name.c_str());
		m_pButtons[i + BT_Answer1]->SetWindowText(txt);
		if (m_correctAnswer == i)
		{
			_tcsncpy(trackPath, col[i]->track.location.c_str(), MAX_PATH);
			trackLength = col[i]->track.duration;
		}
		m_pButtons[i + BT_Answer1]->ShowWindow(TRUE);
	}

	m_subTitle.SetWindowText(PRGAPI()->GetString(IDS_RECOGNISESONG));
	if (!m_pPlayer->Play(trackPath))
	{
		TRACE(_T("@1CQuizRunningDlg::DisplayNextQuestion. Cannot play the file '%s'\r\n"), trackPath);
		return FALSE;
	}
	m_pPlayer->Pause();
	trackLength = INT(m_pPlayer->GetMediaLength());
	if (trackLength < 20)
	{
		TRACE(_T("@1CQuizRunningDlg::DisplayNextQuestion. trackLength is %d '%s'\r\n"), trackLength, trackPath);
		return FALSE;
	}
	m_subTitle.SetColor(CLabelEx::COL_Text, RGB(200,200,200));
	UINT startSec = (trackLength - 40) * rand() / RAND_MAX + 20;//Select 20sec in the track after the first 20 sec
	m_pPlayer->SetVolume(95);
	m_pPlayer->SetMediaPos((DOUBLE) startSec);


	return TRUE;
}
Пример #13
0
void CTeenSpiritDlg::OnEndSession(BOOL bEnding)
{
	if (bEnding)
	{
		TRACEST(_T("CTeenSpiritDlg::OnEndSession"));
		PrgAPI* pAPI = PRGAPI();
		pAPI->GetAppMonitor()->StopMonitoring();
		pAPI->GetMediaPlayer()->Pause();
		SaveSettings();
		pAPI->SaveSettings();
	}
	else
		TRACE(_T("@D CTeenSpiritDlg::OnEndSession (FALSE)\r\n"));
	__super::OnEndSession(bEnding);
}
Пример #14
0
BOOL DownloadWebPageW(std::string& page, HINTERNET hInternet, LPCWSTR url)
{
	TRACEST(_T("DownloadWebPageW"), CW2CT(url));
	BOOL bDownloadSuccess = FALSE;
	if (hInternet == NULL)
		return FALSE;
	HINTERNET hFile = InternetOpenUrlW(hInternet, url, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
	if (hFile)
	{   
		bDownloadSuccess = ReadInternetFile2StringW(hFile, page);
		InternetCloseHandle(hFile);
	}
	else
		HandleInternetError(_T("DownloadWebPage. InternetOpenUrlW"));
	return bDownloadSuccess;
}
Пример #15
0
void LocalPictureManager::ResetAlbumCache(const FullAlbumRecord& rec)
{
	//=== Reset Session Cache
	TRACEST(_T("LocalPictureManager::ClearCachedAlbumPicture"));
	ASSERT(rec.IsValid());
	if (rec.IsValid())
	{
		CacheContainer::iterator it = m_albums.find(rec.album.ID);
		if (it != m_albums.end())
			m_albums.erase(it);
	}
	//=== Reset DB Cache
	SQLManager* pSM = PRGAPI()->GetSQLManager();
	pSM->DeletePicRecord(IIT_AlbumPicture, rec.album.ID);

}
Пример #16
0
BOOL DownloadToFile(LPCTSTR fileName, HINTERNET hInternet, LPCWSTR url)
{
	TRACEST(_T("DownloadToFile"), CW2CT(url));
	BOOL bDownloadSuccess = FALSE;
	if (hInternet == NULL)
		return FALSE;
	HINTERNET hFile = InternetOpenUrl(hInternet, url, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
	if (hFile)
	{   
		const int bufferSize = 8192;
		BYTE bf[bufferSize];
		unsigned long nSize = 0;
		BOOL bReadSuccess = TRUE;
		HANDLE f = CreateFile(fileName, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
		if (f != INVALID_HANDLE_VALUE)
		{
			while(bReadSuccess)
			{
				bReadSuccess = InternetReadFile(hFile, bf, bufferSize, &nSize);
				if (bReadSuccess)
				{
					if (nSize == 0)
					{
						TRACE(_T("@3 DownloadToFile. InternetReadFile Finished\r\n"));
						bDownloadSuccess = TRUE;
						break;
					}
					DWORD bWritten = 0;
					if (WriteFile(f, bf, nSize, &bWritten, NULL) == 0)
					{
						bReadSuccess = FALSE;
						TRACE(_T("@3 DownloadToFile. WriteFile Failed [%d]\r\n"), GetLastError());
					}
				}
				else
					HandleInternetError(_T("DownloadToFile. InternetReadFile"));
			}
			CloseHandle(f);
		}
		else
			TRACE(_T("@3 DownloadToFile. CreateFile Failed [%d]\r\n"), GetLastError());
		InternetCloseHandle(hFile);
	}
	else
		HandleInternetError(_T("DownloadToFile. InternetOpenUrl"));
	return bDownloadSuccess;
}
Пример #17
0
BOOL CQuizRunningDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
	TRACEST(_T("CQuizRunningDlg::OnCommand"), wParam);
	if (wParam >= START_BUTTON_ID && wParam < START_BUTTON_ID + BT_Last)
	{
		INT btnIdx = wParam - START_BUTTON_ID;
		switch (btnIdx)
		{
		case BT_Start:
			SetState(ST_DisplayingQuestionsAndWait);
			break;
		case BT_SelectPrev:
			SetCurrentGame(--m_curGameIdx);
			break;
		case BT_SelectNext:
			SetCurrentGame(++m_curGameIdx);
			break;
		case BT_Answer1:
		case BT_Answer2:
		case BT_Answer3:
		case BT_Answer4:
		case BT_AnswerNo:
			EvaluateAnswer(btnIdx - BT_Answer1);
			break;
		case BT_NewGame:
			SetState(ST_Start);
			break;
		case BT_Submit:
			{
				CHAR gameName[200];
				_snprintf(gameName, 200, "QUIZ|%d:%d:%d", m_curGame.totalTime, m_curGame.penaltyTime, m_curGame.bonusTime);
				PrgAPI* pAPI = PRGAPI();
				TSOnlineServices* pTS = pAPI->GetTSOnlineServices();
				pTS->SendGameResults(gameName, m_correctAnswers, m_poolCount, m_gameTimeStamp, TRUE);
			}
			break;
		case BT_Exit:
			EndDialog(0);
			break;
		case BT_EndGame:
			SetState(ST_GameOver);
			break;
		}
	}
	return CDialog::OnCommand(wParam, lParam);
}
Пример #18
0
void CTeenSpiritDlg::OnDestroy()
{
	TRACEST(_T("CTeenSpiritDlg::OnDestroy"));
	SaveSettings();

	PrgAPI* pAPI = PRGAPI();
	//pAPI->UnRegisterReceiver(m_playerBar);
	//pAPI->UnRegisterReceiver(*this);
	pAPI->SetNotificationTarget(NULL);//Disable Notifications
	m_TrayIcon.RemoveIcon();
	pAPI->DestroyMiniPlayerDlg();
	pAPI->DestroyQuickSearchDlg();
	pAPI->DestroyTrayToolTipDlg();
	pAPI->DestroyAdvancedSearchDlg();
	//pAPI->GetSkinManager()->UnRegisterSkinnable(m_ListCtrl);
	CDialog::OnDestroy();
}
Пример #19
0
BOOL TrackListCtrl::OnCommand(WPARAM wParam, LPARAM lParam)
{
	TRACEST(_T("TrackListCtrl::OnCommand"), wParam);
	switch (wParam)
	{
	case MI_Play:
	case MI_Enqueue:
	case MI_InsertAfter:
		if (m_menuInitiator != -1 && m_pPlayer != NULL && m_pCollection != NULL)
		{
			FullTrackRecordSP rec = (*m_pCollection)[m_menuInitiator];
			MediaPlayListItem mpli;
			mpli.artist = rec->artist.name.c_str();
			mpli.title = rec->track.name.c_str();
			mpli.rating = rec->track.rating;
			mpli.length = rec->track.duration;
			mpli.url = rec->track.location.c_str();
			switch (wParam)
			{
			case MI_Play:
				m_pPlayer->Play(mpli);
				break;
			case MI_Enqueue:
				m_pPlayer->Enqueue(mpli);
				break;
			case MI_InsertAfter:
				m_pPlayer->InsertMedia(mpli, m_pPlayer->GetPlayListPos() + 1);
				break;
			}
		}
		break;
	case MI_LocateAlbum:
		{
			if (m_menuInitiator != -1 && m_pCollection != NULL)
			{
				FullTrackRecordSP rec = (*m_pCollection)[m_menuInitiator];
				PrgAPI* pAPI = PRGAPI();
				SQLManager* pSM = pAPI->GetSQLManager();
				pAPI->GetStateManager()->GetState().locateTrackID = rec->track.ID;
				pAPI->SendMessage(SM_LocateTrackRequest);
			}
		}
		break;
	}
	return __super::OnCommand(wParam, lParam);
}
Пример #20
0
BOOL CTeenSpiritDlg::OnCommand(WPARAM wParam, LPARAM lParam)
{
	TRACEST(_T("CTeenSpiritDlg::OnCommand"), wParam);
	PrgAPI* pAPI = PRGAPI();

	switch (wParam)
	{
	case CToolbarWnd::CMD_About:
		return pAPI->GetActionManager()->ShowAboutDlg(this);
	case CToolbarWnd::CMD_Collections:
		return pAPI->GetActionManager()->ShowCollectionsDlg(this);
	case CToolbarWnd::CMD_Search:
		return pAPI->GetAdvancedSearchDlg()->ShowWindow(SW_SHOW);
	case CToolbarWnd::CMD_History:
		return pAPI->GetActionManager()->ShowHistoryDlg(this);
	case CToolbarWnd::CMD_Options:
		return pAPI->GetActionManager()->ShowOptionsDlg(this);
	case CToolbarWnd::CMD_Games:
		return pAPI->GetActionManager()->ShowGamesDlg(this);

	case CToolbarWnd::CMD_Min:
		return SendMessage(WM_SYSCOMMAND, SC_MINIMIZE, 0);
	case CToolbarWnd::CMD_Restore:
		return SendMessage(WM_SYSCOMMAND, SC_RESTORE, 0);
	case CToolbarWnd::CMD_Close:
		return SendMessage(WM_SYSCOMMAND, SC_CLOSE, 0);
		break;

	default:
		{
			if (wParam > MENU_First && wParam < MENU_Last)
			{
				MenuManager* pMM = pAPI->GetMenuManager();
				MenuCommandsEnum cmd = (MenuCommandsEnum) wParam;
				if (pMM->HandleGeneralCommands(cmd) || pMM->HandlePlayerCommands(*pAPI->GetMediaPlayer(), cmd, 0))
					return TRUE;
			}
		}
		return CDialog::OnCommand(wParam, lParam);
	}
	return TRUE;
}
Пример #21
0
void TrackListCtrl::OnContextMenu(CWnd* pWnd, CPoint point)
{
	TRACEST(_T("TrackListCtrl::OnContextMenu"));
	if (m_pPlayer == NULL)	
		return;



	CPoint htp(point);
	ScreenToClient(&htp);
	m_menuInitiator = GetItemFromPoint(htp.x, htp.y);
	if (m_menuInitiator == -1)
		return;
	if (IsItemSelected(m_menuInitiator) == FALSE)
		SetItemSelection(m_menuInitiator, TRUE);

	ITSMenu& mainMenu = GetInternalMenu(M_Main);
	mainMenu.TrackPopupMenu(point.x, point.y, pWnd->GetSafeHwnd());

}
Пример #22
0
ITSMenu& WebPane::GetInternalMenu(MenusEnum mnu)
{
	TRACEST(_T("PlayListPane::GetMenu."), mnu);
	ASSERT(mnu < M_Last);
	PrgAPI* pAPI = PRGAPI();
	if (m_pMenu[mnu] == NULL)
		m_pMenu[mnu] = pAPI->CreatePopupMenu();
	ITSMenu& curMenu = *m_pMenu[mnu];
	if (curMenu.GetInternalHandler() != NULL)
		return curMenu;
	curMenu.Create();
	switch (mnu)
	{
	case M_Main:
		{
			MenuManager* pMM = pAPI->GetMenuManager();
			curMenu.AppendMenu(ITSMenu::MIT_Menu, 
				(INT)pMM->GetMenu(MenuManager::MNU_ArtistServices).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_ARTIST));

			curMenu.AppendMenu(ITSMenu::MIT_Menu, 
				(INT)pMM->GetMenu(MenuManager::MNU_AlbumServices).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_ALBUM));

			curMenu.AppendMenu(ITSMenu::MIT_Menu, 
				(INT)pMM->GetMenu(MenuManager::MNU_TrackServices).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_TITLE));
			
			curMenu.AppendMenu(ITSMenu::MIT_Separator, NULL, NULL);
			
			curMenu.AppendMenu(ITSMenu::MIT_String, MI_SyncWithSectionChanger, (LPTSTR)pAPI->GetString(IDS_SYNCWITHSECTIONS));
			curMenu.AppendMenu(ITSMenu::MIT_String, MI_SyncWithTracksChanger, (LPTSTR)pAPI->GetString(IDS_SYNCWITHTRACKS));
			curMenu.AppendMenu(ITSMenu::MIT_String, MI_SyncWithPlayer, (LPTSTR)pAPI->GetString(IDS_SYNCWITHPLAYER));
			
			curMenu.AppendMenu(ITSMenu::MIT_Separator, NULL, NULL);
			
			curMenu.AppendMenu(ITSMenu::MIT_String, MI_UseAsWebViewer, (LPTSTR)pAPI->GetString(IDS_WEBVIEWER));
		}
		break;
	default:
		ASSERT(0);
	}
	return curMenu;
}
Пример #23
0
BOOL PlayListPane::OnButton(UINT idx)
{
	TRACEST(_T("PlayListPane::OnCommand"), idx);
	switch (idx)
	{
	case MI_ShowNumbers:
		m_PlayList.SetConfigurationOption(CPlayListListCtrl::C_ShowNumbers, 
			m_PlayList.GetConfigurationOption(CPlayListListCtrl::C_ShowNumbers) == 0 ? 1 : 0);
		break;
	default:
		{
			PrgAPI* pAPI = PRGAPI();
			MediaPlayer* pPlayer = pAPI->GetMediaPlayer();
			MenuManager* pMM = pAPI->GetMenuManager();
			MenuCommandsEnum cmd = (MenuCommandsEnum) idx;
			if (!pMM->HandlePlayerCommands(*pPlayer, cmd, pPlayer->GetPlayListPos()) || (pMM->HandleGeneralCommands(cmd)))
				return FALSE;
		}
	}
	return TRUE;;
}
Пример #24
0
void CHistTracksListCtrl::Refresh()
{
	TRACEST(_T("CHistTracksListCtrl::Refresh"));
	SetRedraw(FALSE);
	DeleteAllItems();
	SQLManager* pSM = PRGAPI()->GetSQLManager();
	m_collection.clear();
	VERIFY(pSM->GetFullHistTrackRecordCollection(m_collection,
		m_pFilter->MinTimeStatus == HistoryDlgFilter::FS_Enabled ? &m_pFilter->MinTime : NULL, 
		m_pFilter->MaxTimeStatus == HistoryDlgFilter::FS_Enabled ? &m_pFilter->MaxTime : NULL, 
		m_pFilter->ArtistStatus == HistoryDlgFilter::FS_Enabled ? m_pFilter->Artist : NULL, 
		m_pFilter->TrackStatus == HistoryDlgFilter::FS_Enabled ? m_pFilter->Track : NULL, 
		HLA_Played, 
		0));
	SortOptionCollection soc;
	soc.ApplySortOption(m_so);
	RecordCollectionSorter::SortFullHistTrackRecordCollection(m_collection, soc);

	SetItemCount(m_collection.size());
	SetRedraw(TRUE);
}
Пример #25
0
BOOL DownloadWebPageUnicode(std::wstring& page, HINTERNET hInternet, LPCWSTR url)
{
	TRACEST(_T("DownloadWebPageUnicode"), CW2CT(url));
	BOOL bDownloadSuccess = FALSE;
	if (hInternet == NULL)
		return FALSE;
	HINTERNET hFile = InternetOpenUrl(hInternet, url, NULL, 0, INTERNET_FLAG_NO_CACHE_WRITE, 0);
	if (hFile)
	{   
		page.clear();
		DWORD dwSize = 0;
		INT headerCP = 0;//Latin1
		INT pageCP = 0;//Latin1
		INT workingCP = 1252;//Latin1
		if(!HttpQueryInfo(hFile, HTTP_QUERY_RAW_HEADERS_CRLF, 0, &dwSize, 0))
		{
			if (GetLastError()==ERROR_INSUFFICIENT_BUFFER)
			{
				SetLastError(0);
				LPVOID lpOutBuffer = new CHAR[dwSize];
				if (HttpQueryInfo(hFile, HTTP_QUERY_RAW_HEADERS_CRLF, lpOutBuffer, &dwSize, 0))
				{
					//TRACE((LPCTSTR)lpOutBuffer);
					headerCP = GetWindowsCodePageW((LPCTSTR)lpOutBuffer);
				}
				delete[] lpOutBuffer;
			}		
		}

		DWORD pageSize = 0;
		DWORD pageSizeLen = sizeof(pageSize);
		if (::HttpQueryInfo(hFile, HTTP_QUERY_CONTENT_LENGTH, &pageSize, &pageSizeLen, NULL))
		{
			if (pageSize > 0)
				page.reserve(pageSize + 10);
		}
		if (page.capacity() < 1000)
			page.reserve(50000);
		const int bufferSize = 8192;
		const int bufferSizeU = 2 * bufferSize;
		CHAR bf[bufferSize + 1];
		TCHAR bfU[bufferSizeU];
		unsigned long nSize = 0;
		BOOL bReadSuccess = TRUE;
		BOOL bFirstTime = TRUE;
		while(bReadSuccess)
		{
			bReadSuccess = InternetReadFile(hFile, bf, bufferSize, &nSize);
			if (bReadSuccess)
			{
				if (nSize == 0)
				{
					//TRACE(_T("@3 DownloadWebPage. InternetReadFile Finished\r\n"));
					bDownloadSuccess = TRUE;
					break;
				}
				if (bFirstTime)
				{
					bFirstTime = FALSE;
					bf[nSize] = 0;
					pageCP = GetWindowsCodePageA(bf);
					if (headerCP != pageCP)
					{
						TRACE(_T("@3 DownloadWebPage. CodePage Differs (header:%d - page:%d)\r\n"),
							headerCP, pageCP);
					}
					if (pageCP > 0)	//===Choose the Codepage detected from page if available
						workingCP = pageCP;
					else if (headerCP > 0) //===Else select the Codepage detected from headers if available
						workingCP = headerCP;
					//===Otherwise keep the original 1252 (latin 1)
				}
				if (nSize > 0)
				{
					INT bfLen = MultiByteToWideChar(workingCP, 0, bf, nSize, 0, 0);
					if (bfLen < bufferSizeU)
					{
						MultiByteToWideChar(workingCP, 0, bf, nSize, bfU, bfLen);
						page.append(bfU, bfLen);
					}
					else
					{
						TRACE(_T("@1 DownloadWebPageUnicode. Unicode buffer not enough\r\n"));
						bReadSuccess = FALSE;
					}
				}
			}
			else
				HandleInternetError(_T("DownloadWebPageUnicode. InternetReadFile"));
		}
		InternetCloseHandle(hFile);
	}
	else
		HandleInternetError(_T("DownloadWebPageUnicode. InternetOpenUrl"));
	return bDownloadSuccess;
}
Пример #26
0
ITSMenu& MenuManager::GetMenu(MENUS mnu)
{
	TRACEST(_T("MenuManager::GetMenu."), mnu);
	ASSERT(mnu < MNU_Last);
	PrgAPI* pAPI = PRGAPI();
	if (m_pMenu[mnu] == NULL)
		m_pMenu[mnu] = pAPI->CreatePopupMenu();
	ITSMenu& curMenu = *m_pMenu[mnu];
	if (curMenu.GetInternalHandler() != NULL)
		return curMenu;
	curMenu.Create();
	switch (mnu)
	{
	case MNU_AutoContinueMode:
		for (int i = RTM_All; i < RTM_Last; i++)
		{
			curMenu.AppendMenu(ITSMenu::MIT_String, MENU_AutoContinueModeHolder + i, (LPTSTR)pAPI->GetStringForRandomMode((RandomTrackModeEnum)i));
			if (i == RTM_All)
				curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
		}
		break;
	case MNU_PlayListSerialization:
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_InsertList, (LPTSTR)pAPI->GetString(IDS_INSERTLIST));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_LoadList, (LPTSTR)pAPI->GetString(IDS_LOADLIST));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_SaveList, (LPTSTR)pAPI->GetString(IDS_SAVELIST));
		break;
	//case MNU_InsertRandomTracks:
	//	for (int i = RTM_All; i < RTM_Last; i++)
	//	{
	//		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_InsertRandomTracksHolder + i, (LPTSTR)pAPI->GetStringForRandomMode((RandomTrackModeEnum)i));
	//		if (i == RTM_All)
	//			curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
	//	}
	//	break;
	//case MNU_SearchTracks:
	//	for (int i = 0; i < TTT_Last; i++)
	//		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_SearchTracksHolder + i, (LPTSTR)pAPI->GetStringForTrackTextType((TrackTextType)i));
	//	break;
	case MNU_Tray:
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_ShowMainWindow, (LPTSTR)pAPI->GetString(IDS_SHOWMAINWINDOW));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_ShowMiniPlayer, pAPI->GetString(IDS_SHOWMINIPLAYER));
		curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
		curMenu.AppendMenu(ITSMenu::MIT_Menu, (INT)GetMenu(MenuManager::MNU_PlayerControl).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_MEDIAPLAYER));
		curMenu.AppendMenu(ITSMenu::MIT_Menu, (INT)GetMenu(MenuManager::MNU_PlayListModes).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_AUTOCONTINUEMODE));
		curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_Exit, (LPTSTR)pAPI->GetString(IDS_EXIT), pAPI->GetIcon(ICO_Close16));
		curMenu.SetDefaultItem(MENU_ShowMainWindow);
		break;
	case MNU_PlayerControl:
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_PlayControl, (LPTSTR)pAPI->GetString(IDS_PLAY), pAPI->GetIcon(ICO_Play24));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_PauseControl, (LPTSTR)pAPI->GetString(IDS_PAUSE), pAPI->GetIcon(ICO_Pause24));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_StopControl, (LPTSTR)pAPI->GetString(IDS_STOP), pAPI->GetIcon(ICO_Stop24));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_NextControl, (LPTSTR)pAPI->GetString(IDS_NEXT), pAPI->GetIcon(ICO_Next24));
		curMenu.AppendMenu(ITSMenu::MIT_String, MENU_PrevControl, (LPTSTR)pAPI->GetString(IDS_PREVIOUS), pAPI->GetIcon(ICO_Prev24));
		curMenu.SetDefaultItem(MENU_PlayControl);
		break;
	//case MNU_MiniPlayer:
	//	curMenu.AppendMenu(ITSMenu::MIT_Menu, (INT)GetMenu(MenuManager::MNU_PlayListModes).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_PLAYLIST));
	//	curMenu.AppendMenu(ITSMenu::MIT_Menu, (INT)GetMenu(MenuManager::MNU_Rating).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_RATING), pAPI->GetIcon(ICO_StarGold16));
	//	curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
	//	curMenu.AppendMenu(ITSMenu::MIT_String, MENU_ShowMainWindow, (LPTSTR)pAPI->GetString(IDS_SHOWMAINWINDOW));
	//	curMenu.AppendMenu(ITSMenu::MIT_String, MENU_HideMiniPlayer, (LPTSTR)pAPI->GetString(IDS_HIDE));
	//	curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
	//	curMenu.AppendMenu(ITSMenu::MIT_String, MENU_Exit, (LPTSTR)pAPI->GetString(IDS_EXIT));
	//	break;
	case MNU_TrackServices:
		AppendServicesMenu(curMenu, IT_Track);
		break;
	case MNU_AlbumServices:
		AppendServicesMenu(curMenu, IT_Album);
		break;
	case MNU_ArtistServices:
		AppendServicesMenu(curMenu, IT_Artist);
		break;
	case MNU_Rating:
		for (int i = 5; i >= 0 ; i--)
		{
			if (i==0)
				curMenu.AppendMenu(ITSMenu::MIT_Separator, NULL, NULL);
			curMenu.AppendMenu(ITSMenu::MIT_String, MENU_RatingHolder + i, 
				(LPTSTR) pAPI->GetStringForStars(i), pAPI->GetIconForStars(i));
		}
		break;
	case MNU_PlayListModes:
		for (int i = 0; i < MPNM_Last; i++)
			curMenu.AppendMenu(ITSMenu::MIT_String, MENU_PlayModesHolder + i, (LPTSTR)pAPI->GetStringForPlayListMode(MediaPlayerNextMode(i)));
		curMenu.AppendMenu(ITSMenu::MIT_Separator, 0, NULL);
		curMenu.AppendMenu(ITSMenu::MIT_Menu, (INT)GetMenu(MenuManager::MNU_AutoContinueMode).GetInternalHandler(), (LPTSTR)pAPI->GetString(IDS_AUTOCONTINUEMODE));
		break;
	//case MNU_StartMenu:
	//	curMenu.SetIconSize(32,32);
		//curMenu.AppendMenu(MF_STRING, MENU_ShowAdvancedSearch, (LPTSTR) pAPI->GetString(IDS_ADVSEARCH), pAPI->GetIcon(ICO_Search32));
		//curMenu.AppendMenu(MF_STRING, MENU_ShowHistoryDlg, (LPTSTR) pAPI->GetString(IDS_HISTORY), pAPI->GetIcon(ICO_History32));
		//curMenu.AppendMenu(MF_SEPARATOR, NULL, NULL);
		//curMenu.AppendMenu(MF_STRING, MENU_ShowOptionsDlg, (LPTSTR) pAPI->GetString(IDS_OPTIONS), pAPI->GetIcon(ICO_Options32));
		//curMenu.AppendMenu(MF_STRING, MENU_ShowSkinsDialog, (LPTSTR) pAPI->GetString(IDS_SKIN));
		//curMenu.AppendMenu(MF_STRING, MENU_ShowLanguagesDialog, (LPTSTR) pAPI->GetString(IDS_LANGUAGE));
		//curMenu.AppendMenu(MF_SEPARATOR, NULL, NULL);
		//curMenu.AppendMenu(MF_STRING, MENU_ShowCollectionsDlg, (LPTSTR) pAPI->GetString(IDS_COLLECTIONS), pAPI->GetIcon(ICO_Collections32));
		//curMenu.AppendMenu(MF_STRING, MENU_UpdateLocalCollections, (LPTSTR) pAPI->GetString(IDS_UPDATELOCALCOLLECTIONS));
		//curMenu.AppendMenu(MF_SEPARATOR, NULL, NULL);
		//curMenu.AppendMenu(MF_STRING, MENU_ShowGamesDlg, (LPTSTR) pAPI->GetString(IDS_GAMES), pAPI->GetIcon(ICO_Games32));
		//curMenu.AppendMenu(MF_SEPARATOR, NULL, NULL);
		//curMenu.AppendMenu(MF_STRING, MENU_ShowAboutDlg, (LPTSTR) pAPI->GetString(IDS_ABOUT), pAPI->GetIcon(ICO_About32));
		break;
	default:
		ASSERT(0);
	}
	return curMenu;
}
Пример #27
0
BOOL CHistTracksListCtrl::OnCommand(WPARAM wParam, LPARAM lParam)
{
	TRACEST(_T("CHistTracksListCtrl::OnCommand \r\n"), wParam);
	switch (wParam)
	{
	case ACMD_Play:
		ExecuteTracks(FALSE);
		break;
	case ACMD_Enqueue:
		ExecuteTracks(TRUE);
		break;
	case ACMD_OpenFolder:
		{
			POSITION pos = GetFirstSelectedItemPosition();
			if (pos)
			{
				FullTrackRecordCollection col;
				if (GetFullTrackRecordCollectionByItemID(col, GetNextSelectedItem(pos), 1) && col.size() == 1)
					PRGAPI()->GetActionManager()->OpenFolderToItem(col[0]->track.location.c_str(), col[0]->collection.type);
			}
		}
		break;
	case ACMD_History:
		{
			ASSERT(m_pHistDlg != NULL);
			POSITION pos = GetFirstSelectedItemPosition();
			if (pos != 0)
			{
				TCHAR title[100];
				TCHAR artist[100];
				int Item = GetNextSelectedItem(pos);
				GetItemText(Item, 2, title, 100);
				GetItemText(Item, 3, artist, 100);
				m_pHistDlg->SetTrackFilterText(title, artist, TRUE);
			}
		}
		break;
	case ID_EXPORTSELECTION:
	case ID_EXPORTALL:
		{
			CFileDialog fd(FALSE, _T(".xml"), NULL, OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY, 
				_T("Xml Files (*.xml)|*.xml|All Files (*.*)|*.*||"), NULL);
			if (fd.DoModal() == IDOK)
			{
				if (wParam == ID_EXPORTSELECTION)
				{
					FullHistTrackRecordCollection col;
					POSITION pos = GetFirstSelectedItemPosition();
					while (pos != NULL)
						col.push_back(m_collection[GetNextSelectedItem(pos)]);
					DataRecordsXmlSerializer::Export(fd.GetFileName(), col);
				}
				else
					DataRecordsXmlSerializer::Export(fd.GetFileName(), m_collection);
			}
		}
		break;
	default:
		ASSERT(FALSE);
	}
	return TRUE;
}
Пример #28
0
BOOL LastFMServices::SubmitTracks(LPCTSTR sessionID, LPCTSTR submissionURL)
{
	ASSERT(sessionID != NULL && submissionURL != NULL);
	if (!(sessionID != NULL && submissionURL != NULL))
		return FALSE;
	ASSERT(sessionID[0] != 0 && submissionURL[0]);
	if (!(sessionID[0] != 0 && submissionURL[0]))
		return FALSE;
	TRACEST(_T("LastFMServices::SubmitTracks"));
	std::string postData;
	const INT bfSize = 1000;
	postData.reserve(bfSize);
	CHAR bf[bfSize];
	CHAR utf8bf[bfSize];
	//s=<sessionID>
	//The Session ID string returned by the handshake request. Required
	_snprintf(bf, bfSize, "s=%s&", CT2CA(sessionID));
	postData = bf;
	{
		CSingleLock lock(&m_cs);
		std::list<LastFMSubmitTrack>::const_iterator it = m_jobs.begin();
		UINT i = 0;
		for (;it != m_jobs.end(); it++)
		{
			const LastFMSubmitTrack& track = *it;
			//a[0]=<artist>
			//The artist name. Required.
			ConvertString(track.artist.c_str(), utf8bf, bfSize);
			_snprintf(bf, bfSize, "a[%d]=%s&", i, utf8bf);
			bf[bfSize - 1] = 0;
			postData += bf;
			//t[0]=<track>
			//The track title. Required.
			ConvertString(track.track.c_str(), utf8bf, bfSize);
			_snprintf(bf, bfSize, "t[%d]=%s&", i, utf8bf);
			bf[bfSize - 1] = 0;
			postData += bf;
			//i[0]=<time>
			//The time the track started playing, in UNIX timestamp format. 
			//This must be in the UTC time zone, and is required.
			_snprintf(bf, bfSize, "i[%d]=%u&", i, track.unixTimeStamp);
			bf[bfSize - 1] = 0;
			postData += bf;
			//o[0]=<source>
			//The source of the track. Required
			_snprintf(bf, bfSize, "o[%d]=P&", i);
			postData += bf;
			//r[0]=<rating>
			//A single character denoting the rating of the track
			_snprintf(bf, bfSize, "r[%d]=&", i);
			bf[bfSize - 1] = 0;
			postData += bf;

			//l[0]=<secs>
			//The length of the track in seconds. Required when the source is P, optional otherwise.
			_snprintf(bf, bfSize, "l[%d]=%d&", i, track.length);
			bf[bfSize - 1] = 0;
			postData += bf;

			//b[0]=<album>
			//The album title, or an empty string if not known.
			ConvertString(track.album.c_str(), utf8bf, bfSize);
			_snprintf(bf, bfSize, "b[%d]=%s&", i, utf8bf);
			bf[bfSize - 1] = 0;
			postData += bf;

			//n[0]=<tracknumber>
			//The position of the track on the album, or an empty string if not known.
			_snprintf(bf, bfSize, "n[%d]=%d&", i, track.trackNo);
			bf[bfSize - 1] = 0;
			postData += bf;

			//m[0]=<mb-trackid>
			//The MusicBrainz Track ID, or an empty string if not known.
			_snprintf(bf, bfSize, "m[%d]=&", i);
			bf[bfSize - 1] = 0;
			postData += bf;
			i++;
		}
	}
	postData.erase(postData.size() - 1);

	TRACE(_T("@4 LastFMServices::SubmitTracks. postingData '%s'\n"), CA2CT(postData.c_str()));
	std::string page;
	if (DownloadWebPagePost(page, m_hNet, submissionURL, postData.c_str()))
	{
		m_errorString = page;
		if (strncmp(page.c_str(), "OK", 2) == 0)
		{
			//TRACE(_T("@4 LastFMServices::SubmitTracks. Track Succesfully submitted.\n"));
			m_error = ERR_None;
			m_state = ST_Idle;
		}
		else 
		{
			m_state = ST_Error;
			if (strncmp(page.c_str(), "BADSESSION", 10) == 0)
				m_error = ERR_BadSession;
			else 
				m_error = ERR_Failed;
			TRACE(_T("@1 LastFMServices::SubmitTracks. Track Failed (%d):'%s'.\n"), m_error, CA2CT(GetErrorString()));
			TRACE(_T("@1 ... postedData '%s'.\n"), CA2CT(postData.c_str()));
		}
	}
	else
	{
		m_state = ST_Error;
		m_error = ERR_CommunicationError;
		TRACE(_T("@4 LastFMServices::SubmitTracks. DownloadWebPage Failed\n"));
	}
	if (m_state == ST_Error)
		return FALSE;
	return TRUE;
}
Пример #29
0
UINT FileNameTagger::Read(LPCTSTR fileName, TagInfo& tagInfo)
{
	TRACEST(_T("FileNameTagger::Read"));
	return FileNameTagger::CustomRead(fileName, tagInfo, NULL);
}
Пример #30
0
BOOL MenuManager::HandlePlayerCommands(MediaPlayer& player, MenuCommandsEnum cmd, INT playlistPos)
{
	TRACEST(_T("MenuManager::HandlePlayerCommands"));
	PrgAPI* pAPI = PRGAPI();
	ActionManager* pAM = pAPI->GetActionManager();
	switch (cmd)
	{
		//=== Play Control =========================================
	case MENU_PlayControl:
		player.Start();
		break;
	case MENU_PauseControl:
		if (player.GetPlayState() == PS_Paused)
			player.Start();
		else
			player.Pause();
		break;
	case MENU_StopControl:
		player.Stop();
		break;
	case MENU_NextControl:
		player.Next();
		break;
	case MENU_PrevControl:
		player.Previous();
		break;
		//=== Playlist Serialization =========================================
	case MENU_LoadList:
		pAM->InsertPlayList(&player, -1);
		break;
	case MENU_SaveList:
		pAM->SavePlayList(&player);
		break;
	case MENU_InsertList:
		pAM->InsertPlayList(&player, playlistPos);
		break;
	default:
		//=== PlayModes =========================================
		if (cmd>= MENU_PlayModesHolder && cmd < MENU_PlayModesHolder + MPNM_Last)
			player.SetNextMode(MediaPlayerNextMode(cmd - MENU_PlayModesHolder), -1);
		else if (cmd >= MENU_AutoContinueModeHolder && cmd < MENU_AutoContinueModeHolder + RTM_Last)
		{
			player.SetNextMode(player.GetNextMode(NULL), cmd - MENU_AutoContinueModeHolder);
		}
		//=== Rating =========================================
		else if (cmd>= MENU_RatingHolder && cmd <= MENU_RatingHolder + 5)
		{
			int idx = playlistPos;
			if (idx >= 0)
			{
				SQLManager* pSM = PRGAPI()->GetSQLManager();
				MediaPlayListItem mpli;
				if (player.GetPlayListItem(mpli, idx))
				{
					FullTrackRecordSP rec;
					if (pSM->GetFullTrackRecordByLocation(rec, mpli.url))
					{
						FullTrackRecordCollection col;
						col.push_back(rec);
						ActionManager* pAM = PRGAPI()->GetActionManager();
						pAM->SetTrackRating(col, Stars2Rating((FLOAT)(cmd - MENU_RatingHolder)));
					}
				}
			}
		}

		else
			return FALSE;
	}
	return TRUE;
}