options.cpp

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

		gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "8080");
		force_rtsp = 1;
		break;
	case 2:
		gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "80");
		force_rtsp = 1;
		break;
	case 1:
		gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "7070");
		break;
	default:
		gf_cfg_set_key(gpac->m_user.config, "Streaming", "DefaultPort", "554");
		break;
	}

	if (force_rtsp) {
		gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTPoverRTSP", "yes");
	} else {
		gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTPoverRTSP", m_UseRTSP.GetCheck() ? "yes" : "no");
		if (!m_UseRTSP.GetCheck()) gf_cfg_set_key(gpac->m_user.config, "Streaming", "ReorderSize", m_Reorder.GetCheck() ? "30" : "0");
	}

	char str[50];

	m_Timeout.GetWindowText(str, 50);
	gf_cfg_set_key(gpac->m_user.config, "Streaming", "RTSPTimeout", str);

	m_Buffer.GetWindowText(str, 50);
	gf_cfg_set_key(gpac->m_user.config, "Network", "BufferLength", str);
	if (m_Rebuffer.GetCheck()) {
		m_RebufferLen.GetWindowText(str, 50);
		gf_cfg_set_key(gpac->m_user.config, "Network", "RebufferLength", str);
	} else {
		gf_cfg_set_key(gpac->m_user.config, "Network", "RebufferLength", "0");
	}
}




COptMCache::COptMCache(CWnd* pParent /*=NULL*/)
	: CDialog(COptMCache::IDD, pParent)
{
	//{{AFX_DATA_INIT(COptMCache)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}


void COptMCache::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptMCache)
	DDX_Control(pDX, IDC_BASEPRES, m_BaseName);
	DDX_Control(pDX, IDC_MCACHE_USENAME, m_UseBase);
	DDX_Control(pDX, IDC_MCACHE_OVERWRITE, m_Overwrite);
	DDX_Control(pDX, IDC_BROWSE_MCACHE, m_RecDir);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(COptMCache, CDialog)
	//{{AFX_MSG_MAP(COptMCache)
	ON_BN_CLICKED(IDC_BROWSE_MCACHE, OnBrowseMcache)
	ON_BN_CLICKED(IDC_MCACHE_USENAME, OnMcacheUsename)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COptMCache message handlers

void COptMCache::OnBrowseMcache() 
{
	BROWSEINFO brw;
	LPMALLOC pMalloc;
	LPITEMIDLIST ret;
	char dir[MAX_PATH];

	if (NOERROR == ::SHGetMalloc(&pMalloc) ) {

		m_RecDir.GetWindowText(szCacheDir, MAX_PATH);

		memset(&brw, 0, sizeof(BROWSEINFO));
		brw.hwndOwner = this->GetSafeHwnd();
		brw.pszDisplayName = dir;
		brw.lpszTitle = "Select HTTP Cache Directory...";
		brw.ulFlags = 0L;
		brw.lpfn = LocCbck;

		ret = SHBrowseForFolder(&brw);
		if (ret != NULL) {
			if (::SHGetPathFromIDList(ret, dir)) {
				m_RecDir.SetWindowText(dir);
			}
			pMalloc->Free(ret);
		}
		pMalloc->Release();
	}
}

BOOL COptMCache::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	WinGPAC *gpac = GetApp();
	const char *sOpt;
	
	sOpt = gf_cfg_get_key(gpac->m_user.config, "StreamingCache", "RecordDirectory");
	if (!sOpt) sOpt = gf_cfg_get_key(gpac->m_user.config, "General", "CacheDirectory");
	if (sOpt) m_RecDir.SetWindowText(sOpt);

	sOpt = gf_cfg_get_key(gpac->m_user.config, "StreamingCache", "KeepExistingFiles");
	m_Overwrite.SetCheck((sOpt && !stricmp(sOpt, "yes")) ? 0 : 1);

	sOpt = gf_cfg_get_key(gpac->m_user.config, "StreamingCache", "BaseFileName");
	if (sOpt) {
		m_UseBase.SetCheck(1);
		m_BaseName.EnableWindow(TRUE);
		m_BaseName.SetWindowText(sOpt);
	} else {
		m_UseBase.SetCheck(0);
		m_BaseName.EnableWindow(FALSE);
		m_BaseName.SetWindowText("uses service URL");
	}
	return TRUE;
}

void COptMCache::OnMcacheUsename() 
{
	if (m_UseBase.GetCheck()) {
		m_BaseName.EnableWindow(TRUE);
		m_BaseName.SetWindowText("record");
	} else {
		m_BaseName.EnableWindow(FALSE);
		m_BaseName.SetWindowText("uses service URL");
	}
}

void COptMCache::SaveOptions()
{
	WinGPAC *gpac = GetApp();

	gf_cfg_set_key(gpac->m_user.config, "StreamingCache", "KeepExistingFiles", m_Overwrite.GetCheck() ? "no" : "yes");
	if (m_UseBase.GetCheck()) {
		m_BaseName.GetWindowText(szCacheDir, MAX_PATH);
		gf_cfg_set_key(gpac->m_user.config, "StreamingCache", "BaseFileName", szCacheDir);
	} else {
		gf_cfg_set_key(gpac->m_user.config, "StreamingCache", "BaseFileName", NULL);
	}
	m_RecDir.GetWindowText(szCacheDir, MAX_PATH);
	gf_cfg_set_key(gpac->m_user.config, "StreamingCache", "RecordDirectory", szCacheDir);
}


OptFiles::OptFiles(CWnd* pParent /*=NULL*/)
	: CDialog(OptFiles::IDD, pParent)
{
	//{{AFX_DATA_INIT(OptFiles)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}


void OptFiles::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(OptFiles)
	DDX_Control(pDX, IDC_ASSOCIATE, m_DoAssociate);
	DDX_Control(pDX, IDC_FILES_PLUG, m_PlugName);
	DDX_Control(pDX, IDC_FILES_MIMES, m_mimes);
	DDX_Control(pDX, IDC_FILES_EXT, m_extensions);
	DDX_Control(pDX, IDC_FILELIST, m_FileDescs);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(OptFiles, CDialog)
	//{{AFX_MSG_MAP(OptFiles)
	ON_CBN_SELCHANGE(IDC_FILELIST, OnSelchangeFilelist)
	ON_BN_CLICKED(IDC_ASSOCIATE, OnAssociate)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// OptFiles message handlers

BOOL OptFiles::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
	WinGPAC *gpac = GetApp();
	u32 count, i;

	while (m_FileDescs.GetCount()) m_FileDescs.DeleteString(0);
	count = gf_cfg_get_key_count(gpac->m_user.config, "MimeTypes");
	for (i=0; i<count; i++) {
		char *sMime, *sKey, sDesc[200];
		const char *sOpt;
		sMime = (char *) gf_cfg_get_key_name(gpac->m_user.config, "MimeTypes", i);
		if (!sMime) continue;
		sOpt = gf_cfg_get_key(gpac->m_user.config, "MimeTypes", sMime);
		if (!sOpt) continue;
		sKey = strstr(sOpt, "\" \"");
		if (!sKey) continue;
		strcpy(sDesc, sKey+3);
		sKey = strchr(sDesc, '\"');
		if (!sKey) continue;
		sKey[0] = 0;
		m_FileDescs.AddString(sDesc);
	}
	m_FileDescs.SetCurSel(0);
	SetSelection(0);
	return TRUE;
}

void OptFiles::OnSelchangeFilelist() 
{
	SetSelection(m_FileDescs.GetCurSel());
}

void OptFiles::SetSelection(u32 sel)
{
	WinGPAC *gpac = GetApp();
	char *sMime, *sKey, sDesc[200], sText[200];
	sMime = (char *) gf_cfg_get_key_name(gpac->m_user.config, "MimeTypes", sel);
	sprintf(sText, "Mime Type: %s", sMime);
	m_mimes.SetWindowText(sText);
	strcpy(cur_mime, sMime);
	sMime = (char *) gf_cfg_get_key(gpac->m_user.config, "MimeTypes", sMime);
	strcpy(sDesc, sMime+1);
	sKey = strchr(sDesc, '\"');
	sKey[0] = 0;
	sprintf(sText, "Extensions: %s", sDesc);
	strcpy(cur_ext, sDesc);
	m_extensions.SetWindowText(sText);
	sKey = strrchr(sMime, '\"');
	sprintf(sText, "Module: %s", sKey+2);
	m_PlugName.SetWindowText(sText);

	Bool has_asso, need_asso, go = 1;
	sKey = cur_ext;
	need_asso = has_asso = 0;

	HKEY hKey;
	DWORD dwSize;
	while (go) {
		Bool ok;
		char szExt[50], szReg[60], c;
		char *tmp = strchr(sKey, ' ');
		if (!tmp) { go = 0;}
		else { c = tmp[0]; tmp[0] = 0; }
		sprintf(szExt, ".%s", sKey);
		sprintf(szReg, "GPAC\\%s", sKey);
		if (tmp) { tmp[0] = c; tmp += 1; }

		if (RegOpenKeyEx(HKEY_CLASSES_ROOT, szExt, 0, KEY_READ, &hKey ) == ERROR_SUCCESS) {
			dwSize = 200;
			ok = 1;
			if (RegQueryValueEx(hKey, "", NULL, NULL,(unsigned char*) sDesc, &dwSize) != ERROR_SUCCESS) ok = 0;
			RegCloseKey(hKey);
			if (ok && !stricmp((char *)sDesc, szReg)) has_asso = 1;
			else need_asso = 1;
		} else need_asso = 1;
		sKey = tmp;

	}
	m_DoAssociate.SetCheck(has_asso);
	if (need_asso && has_asso)
		OnAssociate();
}


void OptFiles::OnAssociate() 
{
	char *sKey, sDesc[200];
	unsigned char szApp[MAX_PATH];
	unsigned char szIco[MAX_PATH];

	strcpy((char *) szApp, GetApp()->szAppPath);
	strcpy((char *) szIco, (const char *) szApp);
	strcat((char *) szIco, "Osmo4.ico");
	strcat((char *) szApp, "Osmo4.exe \"%L\"");

	if (m_DoAssociate.GetCheck()) {
		Bool go = 1;
		sKey = cur_ext;

		HKEY hKey;
		DWORD dwSize;
		while (go) {
			Bool ok;
			char szExt[50], szReg[60], szOld[80], szPath[1024], c;
			char *tmp = strchr(sKey, ' ');
			if (!tmp) { go = 0;}
			else { c = tmp[0]; tmp[0] = 0; }
			sprintf(szExt, ".%s", sKey);
			sprintf(szReg, "GPAC\\%s", sKey);
			if (tmp) { tmp[0] = c; tmp += 1; }

			RegOpenKeyEx(HKEY_CLASSES_ROOT, szExt, 0, 0, &hKey );
			dwSize = 200;
			ok = 1;
			if (RegQueryValueEx(hKey, "", NULL, NULL,(unsigned char*) sDesc, &dwSize) != ERROR_SUCCESS) ok = 0;
			RegCloseKey(hKey);
			strcpy(szOld, "");
			if (ok && stricmp((char *)sDesc, szReg)) strcpy(szOld, sDesc);

			strcpy(szPath, szReg); strcat(szPath, "\\DefaultIcon");
			RegCreateKeyEx(HKEY_CLASSES_ROOT, szPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
			RegSetValueEx(hKey, "", 0, REG_SZ, szIco, strlen((const char *) szIco)+1);
			RegCloseKey(hKey);

			strcpy(szPath, szReg); strcat(szPath, "\\Shell\\open\\command");
			RegCreateKeyEx(HKEY_CLASSES_ROOT, szPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
			RegSetValueEx(hKey, "", 0, REG_SZ, szApp, strlen((const char *) szApp)+1);
			RegCloseKey(hKey);

			if (strlen(szOld)) {
				strcpy(szPath, szReg); strcat(szPath, "\\Backup");
				RegCreateKeyEx(HKEY_CLASSES_ROOT, szPath, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
				RegSetValueEx(hKey, "", 0, REG_SZ, (unsigned char *) szOld, strlen((const char *) szIco)+1);
				RegCloseKey(hKey);
			}

			RegCreateKeyEx(HKEY_CLASSES_ROOT, szExt, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
			RegSetValueEx(hKey, "", 0, REG_SZ, (const unsigned char *) szReg, strlen(szReg)+1);
			RegCloseKey(hKey);

			sKey = tmp;
		}
	} else {
		Bool go = 1;
		sKey = cur_ext;

		HKEY hKey;
		DWORD dwSize;
		while (go) {
			Bool ok;
			char szExt[50], szReg[60], szPath[1024], c;
			char *tmp = strchr(sKey, ' ');
			if (!tmp) { go = 0;}
			else { c = tmp[0]; tmp[0] = 0; }
			sprintf(szExt, ".%s", sKey);
			sprintf(szReg, "GPAC\\%s", sKey);
			if (tmp) { tmp[0] = c; tmp += 1; }

			strcpy(szPath, szReg); strcat(szPath, "\\Backup");
			RegOpenKeyEx(HKEY_CLASSES_ROOT, szPath, 0, 0, &hKey );
			dwSize = 200;
			ok = 1;
			if (RegQueryValueEx(hKey, "", NULL, NULL,(unsigned char*) sDesc, &dwSize) != ERROR_SUCCESS) ok = 0;
			RegCloseKey(hKey);
			if (ok && strlen((char *)sDesc)) {
				RegCreateKeyEx(HKEY_CLASSES_ROOT, szExt, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwSize);
				RegSetValueEx(hKey, "", 0, REG_SZ, (unsigned char*) sDesc, strlen((const char *) sDesc)+1);
				RegCloseKey(hKey);
			}

			RegOpenKeyEx(HKEY_CLASSES_ROOT, szReg, 0, 0, &hKey );
			RegDeleteKey(hKey, "Backup");
			RegDeleteKey(hKey, "DefaultIcon");
			RegDeleteKey(hKey, "Shell\\open\\command");
			RegDeleteKey(hKey, "Shell\\open");
			RegDeleteKey(hKey, "Shell");
			RegCloseKey(hKey);
			RegDeleteKey(HKEY_CLASSES_ROOT, szReg);

			sKey = tmp;
		}
	}	
}

COptLogs::COptLogs(CWnd* pParent /*=NULL*/)
	: CDialog(COptLogs::IDD, pParent)
{
	//{{AFX_DATA_INIT(COptLogs)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
}


void COptLogs::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(COptLogs)
	DDX_Control(pDX, IDC_TOOL_SYNC, m_sync);
	DDX_Control(pDX, IDC_TOOL_SCRIPT, m_script);
	DDX_Control(pDX, IDC_TOOL_SCENE, m_scene);
	DDX_Control(pDX, IDC_TOOL_RTP, m_rtp);
	DDX_Control(pDX, IDC_TOOL_RENDER, m_render);
	DDX_Control(pDX, IDC_TOOL_PARSER, m_parser);
	DDX_Control(pDX, IDC_TOOL_NET, m_net);
	DDX_Control(pDX, IDC_TOOL_MMIO, m_mmio);
	DDX_Control(pDX, IDC_TOOL_MEDIA, m_media);
	DDX_Control(pDX, IDC_TOOL_CORE, m_core);
	DDX_Control(pDX, IDC_TOOL_CONTAINER, m_container);
	DDX_Control(pDX, IDC_TOOL_COMPOSE, m_compose);
	DDX_Control(pDX, IDC_TOOL_CODING, m_coding);
	DDX_Control(pDX, IDC_TOOL_CODEC, m_codec);
	DDX_Control(pDX, IDC_TOOL_AUTHOR, m_author);
	DDX_Control(pDX, IDC_LOG_LEVEL, m_Level);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(COptLogs, CDialog)
	//{{AFX_MSG_MAP(COptLogs)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// COptLogs message handlers

BOOL COptLogs::OnInitDialog() 
{
	CDialog::OnInitDialog();

	WinGPAC *gpac = GetApp();
	switch (gpac->m_log_level) {
	case GF_LOG_ERROR: m_Level.SetCurSel(1); break;
	case GF_LOG_WARNING: m_Level.SetCurSel(2); break;
	case GF_LOG_INFO: m_Level.SetCurSel(3); break;
	case GF_LOG_DEBUG: m_Level.SetCurSel(4); break;
	default: m_Level.SetCurSel(0); break;
	}

	m_sync.SetCheck(gpac->m_log_tools & GF_LOG_SYNC);
	m_script.SetCheck(gpac->m_log_tools & GF_LOG_SCRIPT);
	m_scene.SetCheck(gpac->m_log_tools & GF_LOG_SCENE);
	m_rtp.SetCheck(gpac->m_log_tools & GF_LOG_RTP);
	m_render.SetCheck(gpac->m_log_tools & GF_LOG_RENDER);
	m_parser.SetCheck(gpac->m_log_tools & GF_LOG_PARSER);
	m_net.SetCheck(gpac->m_log_tools & GF_LOG_NETWORK);
	m_mmio.SetCheck(gpac->m_log_tools & GF_LOG_MMIO);
	m_media.SetCheck(gpac->m_log_tools & GF_LOG_MEDIA);
	m_core.SetCheck(gpac->m_log_tools & GF_LOG_CORE);
	m_container.SetCheck(gpac->m_log_tools & GF_LOG_CONTAINER);
	m_compose.SetCheck(gpac->m_log_tools & GF_LOG_COMPOSE);
	m_coding.SetCheck(gpac->m_log_tools & GF_LOG_CODING);
	m_codec.SetCheck(gpac->m_log_tools & GF_LOG_CODEC);
	m_author.SetCheck(gpac->m_log_tools & GF_LOG_AUTHOR);

	return TRUE;
}

void COptLogs::SaveOptions()
{
	WinGPAC *gpac = GetApp();
	CString str = "";
	u32 flags = 0;

	switch (m_Level.GetCurSel()) {
	case 1: 
		gf_cfg_set_key(gpac->m_user.config, "General", "LogLevel", "error");
		gpac->m_log_level = GF_LOG_ERROR;
		break;
	case 2: 
		gf_cfg_set_key(gpac->m_user.config, "General", "LogLevel", "warning");
		gpac->m_log_level = GF_LOG_WARNING;
		break;
	case 3: 
		gf_cfg_set_key(gpac->m_user.config, "General", "LogLevel", "info");
		gpac->m_log_level = GF_LOG_INFO;
		break;
	case 4: 
		gf_cfg_set_key(gpac->m_user.config, "General", "LogLevel", "debug");
		gpac->m_log_level = GF_LOG_DEBUG;
		break;
	default: 
		gf_cfg_set_key(gpac->m_user.config, "General", "LogLevel", "none");
		gpac->m_log_level = 0;
		break;
	}
	gf_log_set_level(gpac->m_log_level);


	if (m_sync.GetCheck()) { flags |= GF_LOG_SYNC; str +="sync:"; }
	if (m_script.GetCheck()) { flags |= GF_LOG_SCRIPT; str +="script:"; }
	if (m_scene.GetCheck()) { flags |= GF_LOG_SCENE; str +="scene:"; }
	if (m_rtp.GetCheck()) { flags |= GF_LOG_RTP; str +="rtp:"; }
	if (m_render.GetCheck()) { flags |= GF_LOG_RENDER; str +="render:"; }
	if (m_parser.GetCheck()) { flags |= GF_LOG_PARSER; str +="parser:"; }
	if (m_net.GetCheck()) { flags |= GF_LOG_NETWORK; str +="network:"; }
	if (m_mmio.GetCheck()) { flags |= GF_LOG_MMIO; str +="mmio:"; }
	if (m_media.GetCheck()) { flags |= GF_LOG_MEDIA; str +="media:"; }
	if (m_core.GetCheck()) { flags |= GF_LOG_CORE; str +="core:"; }
	if (m_container.GetCheck()) { flags |= GF_LOG_CONTAINER; str +="container:"; }
	if (m_compose.GetCheck()) { flags |= GF_LOG_COMPOSE; str +="compose:"; }
	if (m_coding.GetCheck()) { flags |= GF_LOG_CODING; str +="coding:"; }
	if (m_codec.GetCheck()) { flags |= GF_LOG_CODEC; str +="codec:"; }
	if (m_author.GetCheck()) { flags |= GF_LOG_AUTHOR; str +="author:"; }

	gf_cfg_set_key(gpac->m_user.config, "General", "LogTools", str);
	gpac->m_log_tools = flags;
	gf_log_set_tools(gpac->m_log_tools);
}