void CCommandObj::InitializationConfig(LPCWSTR lpConfigFileFullPath)
{
Out(Dbg,_T("Initialization Config Starting."));
m_ConfigCommon.usResourceServerPort = GetPrivateProfileIntW(L"System",L"ResourceServerPort",DEFAULT_CONFIG_SERVER_RESOURCE_PORT,lpConfigFileFullPath);
m_ConfigCommon.usCommandServerPort = GetPrivateProfileIntW(L"System",L"CommandServerPort",DEFAULT_CONFIG_SERVER_COMMAND_PORT,lpConfigFileFullPath);
m_ConfigCommon.dwRetrySleep = GetPrivateProfileIntW(L"Retry",L"RetrySleep",DEFAULT_CONFIG_RETRY_SLEEP,lpConfigFileFullPath);
m_ConfigCommon.dwRetryCount = GetPrivateProfileIntW(L"Retry",L"RetryCount",DEFAULT_CONFIG_RETRY_COUNT,lpConfigFileFullPath);
GetPrivateProfileStringW(L"System",L"ServerAddress",DEFAULT_CONFIG_SERVER_ADDRESS,m_ConfigCommon.szServerAddress,MAX_ADDRESS_STRING_LEN,lpConfigFileFullPath);
Runend(true,_T("Initialization Config Stoping."));
}
plExportDlgImp::plExportDlgImp() : fDlg(NULL), fPreshade(true), fPhysicalsOnly(false), fLightMap(true), fLastExportTime(0), fExporting(false), fAutoExporting(false)
{
plFileName path = plMaxConfig::GetPluginIni();
fXPos = GetPrivateProfileIntW(L"Export", L"X", 0, path.AsString().ToWchar());
fYPos = GetPrivateProfileIntW(L"Export", L"Y", 30, path.AsString().ToWchar());
wchar_t buffer[MAX_PATH];
GetPrivateProfileStringW(L"Export", L"Dir", L"", buffer, sizeof(buffer),
path.AsString().ToWchar());
fExportSourceDir = plString::FromWchar(buffer);
memset(fExportPage, 0, sizeof(fExportPage));
}
BOOL config_load_w(HMODULE module,CONFIG_BINDING_W* binding){
wchar_t path[MAX_PATH];
GetModuleFileNameW(module,path,MAX_PATH);
for(int i=wcslen(path)-1;i>=0;i--){
if(path[i]==L'\\'){
path[i]=L'\0';
break;
}
}
wcscat(path,L"\\config.ini");
PCONFIG_BINDING_W b;
int i=0;
wchar_t buffer[32767];
int l;
while((b=binding+(i++))->section){
switch(b->type){
case CONFIG_TYPE_STRING:
l = GetPrivateProfileStringW(b->section,b->key,b->def.asString,buffer,32767,path);
if(buffer[0]==0&&b->def.asString==NULL){
*(b->val.asString)=NULL;
}else{
*(b->val.asString)=(wchar_t*)malloc(sizeof(wchar_t)*(wcslen(buffer)+1));
wcscpy(*(b->val.asString),buffer);
}
break;
case CONFIG_TYPE_INT:
*(b->val.asInt) = GetPrivateProfileIntW(b->section,b->key,b->def.asInt,path);
break;
}
}
return TRUE;
}
BOOL IsHookStartEnabled()
{
BOOL Enabled;
ULONG_PTR Length;
PWSTR Buffer;
PLDR_MODULE Module;
static WCHAR Config[] = L"config.ini";
Module = FindLdrModuleByHandle(&__ImageBase);
if (Module == NULL)
return FALSE;
Length = Module->FullDllName.Length + sizeof(Config);
Buffer = (PWSTR)malloc(Length);
if (Buffer == NULL)
return FALSE;
CopyMemory(Buffer, Module->FullDllName.Buffer, Module->FullDllName.Length);
Buffer[Module->FullDllName.Length / sizeof(WCHAR)] = 0;
CopyMemory(PathFindFileNameW(Buffer), Config, sizeof(Config));
Enabled = GetPrivateProfileIntW(L"HOOKSTART", L"BOpen", FALSE, Buffer);
free(Buffer);
return Enabled;
}
int read_appint(LPCWSTR cat,LPCWSTR name)
{
int res = -1;
if ( profile_path[1] != L':' )
{
if (!ini_ready(profile_path,MAX_PATH))
{
return res;
}
}
res = GetPrivateProfileIntW(cat, name, -1, profile_path);
return res;
}
static void loadGeneralParams(LPCWSTR path) {
GeneralParams.HookTarget = (HookTargetEnum)GetPrivateProfileIntW(
L"General",
L"HookTarget",
(int)GeneralParams.HookTarget,
path);
GeneralParams.ForceNoHinting = 0 != GetPrivateProfileIntW(
L"General",
L"ForceNoHinting",
(int)GeneralParams.ForceNoHinting,
path);
wchar_t exePath[_MAX_PATH];
GetModuleFileNameW(NULL, exePath, _MAX_PATH);
wchar_t* exeName = PathFindFileNameW(exePath);
CharLower(exeName);
switch (GeneralParams.HookTarget) {
case HookTargetEnum::All:
GeneralParams.isHookTarget = true;
break;
case HookTargetEnum::ExcludeMode: {
std::set<std::wstring, std::less<>> set;
loadExeName(set, L"Exclude", path);
GeneralParams.isHookTarget = set.count(exeName) == 0;
break;
}
case HookTargetEnum::IncludeMode: {
std::set<std::wstring, std::less<>> set;
loadExeName(set, L"Include", path);
GeneralParams.isHookTarget = set.count(exeName) > 0;
break;
}
case HookTargetEnum::None:
GeneralParams.isHookTarget = false;
break;
}
}
BOOL ATEIniFile::ReadKey(const ATEStr& szSection, const ATEStr& szKey, INIKey& key)
{
if(szSection.IsEmpty()) { return FALSE; }
if(szKey.IsEmpty()) { return FALSE; }
switch(key.type)
{
case KEY_DWORD:
{
INT32 nRet = GetPrivateProfileIntW(szSection.GetHead(),
szKey.GetHead(),
INIKey::INVALID_DWORD,
m_szFilePath.GetHead());
if (INIKey::INVALID_DWORD == nRet) { return FALSE; }
key.val.dwVal = nRet;
return TRUE;
}
break;
case KEY_STRING:
{
//function have bugs for only one entry.
GetPrivateProfileStringW(szSection.GetHead(),
szKey.GetHead(),
NULL,
key.val.szVal,
INIKey::MAX_KEY_SIZE,
m_szFilePath.GetHead());
if (0 == key.val.szVal[0]) { return FALSE; }
return TRUE;
}
break;
case KEY_STRUCT:
{
BOOL bRet = GetPrivateProfileStructW(szSection.GetHead(),
szKey.GetHead(),
&(key.val.binVal[0]),
INIKey::MAX_KEY_SIZE,
m_szFilePath.GetHead());
if (!bRet) { return FALSE; }
return TRUE;
}
break;
default:
return FALSE;
break;
}
return FALSE;
}
int CMGTOOls::GetConfig_Int( LPCTSTR lpAppName, LPCTSTR lpKeyName, INT nDefault, LPCTSTR lpFileName )
{
if(_tcslen(lpFileName) <1)
return nDefault;
if(!m_bRelative)
{
#ifdef _UNICODE
return GetPrivateProfileIntW(lpAppName,lpKeyName,nDefault,lpFileName);
#else
return GetPrivateProfileIntA(lpAppName,lpKeyName,nDefault,lpFileName);
#endif
}
return ReadConfigParamValue(lpAppName,lpKeyName,nDefault,split_Config_FileName(lpFileName));
return 0;
}
static void loadRenderingParams(RenderingParams& params, LPCWSTR section, LPCWSTR path) {
params.Gamma = GetPrivateProfileIntW(
section,
L"Gamma",
(int)(params.Gamma * 1000),
path) / 1000.0f;
params.EnhancedContrast = GetPrivateProfileIntW(
section,
L"EnhancedContrast",
(int)(params.EnhancedContrast * 100),
path) / 100.0f;
params.ClearTypeLevel = GetPrivateProfileIntW(
section,
L"ClearTypeLevel",
(int)(params.ClearTypeLevel * 100),
path) / 100.0f;
params.PixelGeometry = (DWRITE_PIXEL_GEOMETRY)GetPrivateProfileIntW(
section,
L"PixelGeometry",
params.PixelGeometry,
path);
params.RenderingMode = (DWRITE_RENDERING_MODE)GetPrivateProfileIntW(
section,
L"RenderingMode",
params.RenderingMode,
path);
params.GrayscaleEnhancedContrast = GetPrivateProfileIntW(
section,
L"GrayscaleEnhancedContrast",
(int)(params.GrayscaleEnhancedContrast * 100),
path) / 100.0f;
params.GridFitMode = (DWRITE_GRID_FIT_MODE)GetPrivateProfileIntW(
section,
L"GridFitMode",
params.GridFitMode,
path);
params.RenderingMode1 = (DWRITE_RENDERING_MODE1)GetPrivateProfileIntW(
section,
L"RenderingMode1",
params.RenderingMode1,
path);
}
CWriteMain::CWriteMain(void)
{
this->file = NULL;
this->writeBuff = NULL;
this->writeBuffSize = 0;
this->writeBuffPos = 0;
WCHAR dllPath[512] = L"";
GetModuleFileName(g_instance, dllPath, 512);
wstring iniPath = dllPath;
iniPath += L".ini";
this->writeBuffSize = (DWORD)GetPrivateProfileIntW(L"SET", L"Size", 770048, iniPath.c_str());
SAFE_DELETE_ARRAY(this->writeBuff);
if( this->writeBuffSize > 0 ){
this->writeBuff = new BYTE[this->writeBuffSize];
}
this->writeBuffPos = 0;
}
void plCreateMenu()
{
#if MAX_VERSION_MAJOR <= 11
AddPlasmaExportMenu();
#endif
IMenuManager* pMenuMan = GetCOREInterface()->GetMenuManager();
bool newlyRegistered = pMenuMan->RegisterMenuBarContext(kMyMenuContextId, kMenuName);
// Is the Max menu version the most recent?
bool wrongVersion = GetPrivateProfileIntW(L"Menu", L"Version", 0, plMaxConfig::GetPluginIni().WideString().data()) < kMenuVersion;
if (wrongVersion)
{
// Delete the old version of the menu
IMenu *oldMenu = pMenuMan->FindMenu(kMenuName);
if (oldMenu)
pMenuMan->UnRegisterMenu(oldMenu);
// Update the menu version
wchar_t buf[12];
snwprintf(buf, arrsize(buf), L"%d", kMenuVersion);
WritePrivateProfileStringW(L"Menu", L"Version", buf, plMaxConfig::GetPluginIni().WideString().data());
}
if (wrongVersion || newlyRegistered)
{
IMenu *pMainMenu = pMenuMan->GetMainMenuBar();
if (!pMainMenu)
{
hsAssert(0, "Main menu not found");
return;
}
// Get our action table
ActionTable* pActionTable = GetCOREInterface()->GetActionManager()->FindTable(kActionId);
if (!pActionTable)
{
hsAssert(0, "Action table not found");
return;
}
// Create the Plasma menu
IMenu* pPlasmaMenu = GetIMenu();
pPlasmaMenu->SetTitle(kMenuName);
// Register the new menu with the system
pMenuMan->RegisterMenu(pPlasmaMenu, 0);
/////////////////////////////////////////////////
// Add the menu items
//
IMenuItem* pMenuItem;
#if MAX_VERSION_MAJOR >= 12
// Add the export action to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionExport));
pPlasmaMenu->AddItem(pMenuItem);
#endif
// Add the save selected action to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionSaveSel));
pPlasmaMenu->AddItem(pMenuItem);
// Add the merge action to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionMerge));
pPlasmaMenu->AddItem(pMenuItem);
// Add the component copy action to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionCompCopy));
pPlasmaMenu->AddItem(pMenuItem);
// Add a separator
pMenuItem = GetIMenuItem();
pMenuItem->ActAsSeparator();
pPlasmaMenu->AddItem(pMenuItem);
// Add the component manager to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionComponent));
pPlasmaMenu->AddItem(pMenuItem);
// Add the resource collector to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionResCollect));
pPlasmaMenu->AddItem(pMenuItem);
// Add the texture search to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionTexSearch));
pPlasmaMenu->AddItem(pMenuItem);
// Add the age description to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionAgeDesc));
pPlasmaMenu->AddItem(pMenuItem);
// Add a separator
pMenuItem = GetIMenuItem();
pMenuItem->ActAsSeparator();
pPlasmaMenu->AddItem(pMenuItem);
// Add the Lock Selected to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionLock));
pPlasmaMenu->AddItem(pMenuItem);
// Add the Unlock Selected to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionUnlock));
pPlasmaMenu->AddItem(pMenuItem);
// Add the Reset Selected to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionReset));
pPlasmaMenu->AddItem(pMenuItem);
// Add the SelectNonRenderables to the menu
pMenuItem = GetIMenuItem();
pMenuItem->SetActionItem(pActionTable->GetAction(kActionSelectNonRenderables));
pPlasmaMenu->AddItem(pMenuItem);
// Create a new menu item to hold the sub-menu
IMenuItem* pSubMenuItem1 = GetIMenuItem(); //menu in menu bar...
pSubMenuItem1->SetSubMenu(pPlasmaMenu);
pMainMenu->AddItem(pSubMenuItem1);
pMenuMan->UpdateMenuBar();
// Save the dang menu, in case Max crashes
const char *uiDir = GetCOREInterface()->GetDir(APP_UI_DIR);
char path[MAX_PATH];
sprintf(path, "%s\\%s", uiDir, "MaxMenus.mnu");
pMenuMan->SaveMenuFile(path);
}
}
int
PkyIniFileWrap::GetInt( const wchar_t* pszSect, const wchar_t* pszKey, int defaultVal )
{
return GetPrivateProfileIntW( pszSect, pszKey, defaultVal, m_strFileName.c_str() );
}
void loadIniFile()
{
FILE *IntFile=NULL;
//IntFile=fopen(".\\gameset.ini","r");
IntFile=_wfopen(IniFileName,L"r");
if (IntFile)
{
fclose(IntFile);
}
else
{
WritePrivateProfileStringW(L"GameSet",L"winW",L"800",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"winH",L"600",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"bits",L"32",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"depth",L"24",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"isFullScreem",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"SYNC",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"LOW",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"AA",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"AF",L"1",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"FPS",L"60",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"Light",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"Water",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"Bloom",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"SSAO",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"Shadow",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"MoveBlur",L"0",IniFileName);
WritePrivateProfileStringW(L"GameSet",L"Cloud",L"0",IniFileName);
WritePrivateProfileStringW(L"SoundSet",L"BGM",L"100",IniFileName);
WritePrivateProfileStringW(L"SoundSet",L"Effect",L"100",IniFileName);
WritePrivateProfileStringW(L"SoundSet",L"Voice",L"100",IniFileName);
WritePrivateProfileStringW(L"other",L"TouchMoveOverride",L"1",IniFileName);
WritePrivateProfileStringW(L"other",L"TouchZoomOverride",L"1",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_UP",L"32",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_DOWN",L"22",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_LEFT",L"12",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_RIGHT",L"2",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_MAIN_WEAPON",L"11",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_SUB_WEAPON",L"1",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_LOCK",L"31",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_MAP",L"21",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_SPEED_UP",L"41",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_SPEED_DOWN",L"51",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_L",L"61",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_R",L"71",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_VIEW_UP",L"52",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_VIEW_DOWN",L"42",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_VIEW_LEFT",L"112",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_VIEW_RIGHT",L"102",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_VIEW_RESET",L"111",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_SELECT",L"81",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_START",L"91",IniFileName);
WritePrivateProfileStringW(L"JoyStictSet",L"JOY_KEY_NO_USE",L"101",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_UP",L"119",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_DOWN",L"115",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_LEFT",L"97",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_RIGHT",L"100",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_MAIN_WEAPON",L"102",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_SUB_WEAPON",L"101",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_LOCK",L"113",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_MAP",L"116",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_SPEED_UP",L"38",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_SPEED_DOWN",L"40",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_L",L"37",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_R",L"39",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_VIEW_UP",L"56",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_VIEW_DOWN",L"50",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_VIEW_LEFT",L"52",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_VIEW_RIGHT",L"54",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_VIEW_RESET",L"53",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_SELECT",L"118",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_START",L"98",IniFileName);
WritePrivateProfileStringW(L"KeyBoardSet",L"JOY_KEY_NO_USE",L"96",IniFileName);
}
GameSet.winW=GetPrivateProfileIntW(L"GameSet",L"winW",800,IniFileName);GameSet.winW=GameSet.winW-GameSet.winW%4;
GameSet.winH=GetPrivateProfileIntW(L"GameSet",L"winH",600,IniFileName);GameSet.winH=GameSet.winH-GameSet.winH%4;
GameSet.bits=GetPrivateProfileIntW(L"GameSet",L"bits",32,IniFileName);
GameSet.depth=GetPrivateProfileIntW(L"GameSet",L"depth",24,IniFileName);
if(GetPrivateProfileIntW(L"GameSet",L"isFullScreem",0,IniFileName)>0)
GameSet.isFullScreem=true;
else
GameSet.isFullScreem=false;
if(GetPrivateProfileIntW(L"GameSet",L"SYNC",0,IniFileName)>0)
GameSet.SYNC=true;
else
GameSet.SYNC=false;
if(GetPrivateProfileIntW(L"GameSet",L"LOW",0,IniFileName)>0)
GameSet.LOW=true;
else
GameSet.LOW=false;
GameSet.AA=GetPrivateProfileIntW(L"GameSet",L"AA",0,IniFileName);
GameSet.AF=float(GetPrivateProfileIntW(L"GameSet",L"AF",1,IniFileName));
GameSet.FPS=GetPrivateProfileIntW(L"GameSet",L"FPS",60,IniFileName);
GameSet.Light=GetPrivateProfileIntW(L"GameSet",L"Light",0,IniFileName);
GameSet.Water=GetPrivateProfileIntW(L"GameSet",L"Water",0,IniFileName);
GameSet.Bloom=GetPrivateProfileIntW(L"GameSet",L"Bloom",0,IniFileName);
GameSet.SSAO=GetPrivateProfileIntW(L"GameSet",L"SSAO",0,IniFileName);
GameSet.Shadow=GetPrivateProfileIntW(L"GameSet",L"Shadow",0,IniFileName);
GameSet.MoveBlur=GetPrivateProfileIntW(L"GameSet",L"MoveBlur",0,IniFileName);
GameSet.Cloud=GetPrivateProfileIntW(L"GameSet",L"Cloud",0,IniFileName);
//GameSet.TouchMoveOverride=(float)GetPrivateProfileIntW(L"other",L"TouchMoveOverride",1,IniFileName);
//GameSet.TouchZoomOverride=(float)GetPrivateProfileIntW(L"other",L"TouchZoomOverride",1,IniFileName);
GameSet.TouchMoveOverride=GetIniFloat2(L"other",L"TouchMoveOverride",IniFileName,L"1.0f");
GameSet.TouchZoomOverride=GetIniFloat2(L"other",L"TouchZoomOverride",IniFileName,L"1.0f");
GameSet.TouchPosFixX=GetIniFloat2(L"other",L"TouchPosFixX",IniFileName,L"0.0");
GameSet.TouchPosFixY=GetIniFloat2(L"other",L"TouchPosFixY",IniFileName,L"0.0");
GameSet.TouchPosFixRange=GetIniFloat2(L"other",L"TouchPosFixRange",IniFileName,L"20.0");
SoundSet.BGM=GetPrivateProfileIntW(L"SoundSet",L"BGM",100,IniFileName);
SoundSet.Effect=GetPrivateProfileIntW(L"SoundSet",L"Effect",100,IniFileName);
SoundSet.Voice=GetPrivateProfileIntW(L"SoundSet",L"Voice",100,IniFileName);
JoyStictSet.KeySet[JOY_KEY_UP] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_UP", 32,IniFileName);
JoyStictSet.KeySet[JOY_KEY_DOWN] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_DOWN", 22,IniFileName);
JoyStictSet.KeySet[JOY_KEY_LEFT] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_LEFT", 12,IniFileName);
JoyStictSet.KeySet[JOY_KEY_RIGHT] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_RIGHT", 2,IniFileName);
JoyStictSet.KeySet[JOY_KEY_MAIN_WEAPON] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_MAIN_WEAPON", 11,IniFileName);
JoyStictSet.KeySet[JOY_KEY_SUB_WEAPON] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_SUB_WEAPON", 1,IniFileName);
JoyStictSet.KeySet[JOY_KEY_LOCK] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_LOCK", 31,IniFileName);
JoyStictSet.KeySet[JOY_KEY_MAP] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_MAP", 21,IniFileName);
JoyStictSet.KeySet[JOY_KEY_SPEED_UP] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_SPEED_UP", 41,IniFileName);
JoyStictSet.KeySet[JOY_KEY_SPEED_DOWN] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_SPEED_DOWN", 51,IniFileName);
JoyStictSet.KeySet[JOY_KEY_L] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_L", 61,IniFileName);
JoyStictSet.KeySet[JOY_KEY_R] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_R", 71,IniFileName);
JoyStictSet.KeySet[JOY_KEY_VIEW_UP] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_VIEW_UP", 52,IniFileName);
JoyStictSet.KeySet[JOY_KEY_VIEW_DOWN] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_VIEW_DOWN", 42,IniFileName);
JoyStictSet.KeySet[JOY_KEY_VIEW_LEFT] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_VIEW_LEFT", 112,IniFileName);
JoyStictSet.KeySet[JOY_KEY_VIEW_RIGHT] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_VIEW_RIGHT", 102,IniFileName);
JoyStictSet.KeySet[JOY_KEY_VIEW_RESET] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_VIEW_RESET", 111,IniFileName);
JoyStictSet.KeySet[JOY_KEY_SELECT] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_SELECT", 81,IniFileName);
JoyStictSet.KeySet[JOY_KEY_START] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_START", 91,IniFileName);
JoyStictSet.KeySet[JOY_KEY_NO_USE] =GetPrivateProfileIntW(L"JoyStictSet",L"JOY_KEY_NO_USE", 101,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_UP] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_UP", 119,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_DOWN] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_DOWN", 115,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_LEFT] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_LEFT", 97,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_RIGHT] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_RIGHT", 100,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_MAIN_WEAPON] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_MAIN_WEAPON", 102,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_SUB_WEAPON] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_SUB_WEAPON", 101,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_LOCK] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_LOCK", 113,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_MAP] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_MAP", 116,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_SPEED_UP] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_SPEED_UP", 38,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_SPEED_DOWN] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_SPEED_DOWN", 40,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_L] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_L", 37,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_R] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_R", 39,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_VIEW_UP] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_VIEW_UP", 56,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_VIEW_DOWN] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_VIEW_DOWN", 50,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_VIEW_LEFT] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_VIEW_LEFT", 52,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_VIEW_RIGHT] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_VIEW_RIGHT", 54,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_VIEW_RESET] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_VIEW_RESET", 53,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_SELECT] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_SELECT", 118,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_START] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_START", 98,IniFileName);
KeyBoardSet.KeySet[JOY_KEY_NO_USE] =GetPrivateProfileIntW(L"KeyBoardSet",L"JOY_KEY_NO_USE", 96,IniFileName);
}
BOOL DXContext::Internal_Init(DXCONTEXT_PARAMS *pParams, BOOL bFirstInit)
{
memcpy(&m_current_mode, pParams, sizeof(DXCONTEXT_PARAMS));
memset(&myWindowState,0,sizeof(myWindowState));
// various checks
if (m_current_mode.screenmode != WINDOWED)
m_current_mode.m_skin = 0;
// 1. destroy old window
if (m_hwnd)
{
m_ignore_wm_destroy = 1;
DestroyWindow(m_hwnd);
m_ignore_wm_destroy = 0;
m_hwnd = NULL;
}
// 2. CHECK TO MAKE SURE DIRECTX/DDRAW IS INSTALLED
if (bFirstInit)
{
// Test for DirectX 9 + start it
// note: if you don't call LoadLibrary here, and you're on a system
// where DX9 is missing, Direct3DCreate8() might crash; so call it.
int d3d9_already_loaded = (GetModuleHandle("d3d9.dll") != NULL) ? 1 : 0;
if (!d3d9_already_loaded)
m_hmod_d3d9 = LoadLibrary("d3d9.dll");
if ((!d3d9_already_loaded && !m_hmod_d3d9) ||
!(m_lpD3D = Direct3DCreate9(D3D_SDK_VERSION))
)
{
MissingDirectX(NULL);
m_lastErr = DXC_ERR_CREATE3D;
return FALSE;
}
if (!m_hmod_d3dx9)
m_hmod_d3dx9 = FindD3DX9(m_hwnd_winamp);
if ((!m_hmod_d3dx9))
{
MissingDirectX(NULL);
m_lastErr = DXC_ERR_CREATE3D;
return FALSE;
}
}
// 3. get the smallest single rectangle that encloses ALL the monitors on the desktop:
SetRect(&m_all_monitors_rect, 0, 0, 0, 0);
EnumDisplayMonitors(NULL, NULL, MyMonitorEnumProc, (LPARAM)&m_all_monitors_rect);
// 4. some DirectX- / DDraw-specific stuff. Also determine hPluginMonitor.
HMONITOR hPluginMonitor = NULL;
{
D3DADAPTER_IDENTIFIER9 temp;
// find the ordinal # of the adapter whose GUID matches what the user picked from the config panel,
// and whose DeviceName matches as well.
// if no match found, use D3DADAPTER_DEFAULT.
m_ordinal_adapter = D3DADAPTER_DEFAULT;
int nAdapters = m_lpD3D->GetAdapterCount();
{
for (int i=0; i<nAdapters; i++)
{
if ((m_lpD3D->GetAdapterIdentifier(i, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &temp) == D3D_OK) &&
(memcmp(&temp.DeviceIdentifier, &m_current_mode.adapter_guid, sizeof(GUID))==0) &&
!strcmp(temp.DeviceName, m_current_mode.adapter_devicename)
)
{
m_ordinal_adapter = i;
break;
}
}
}
if (m_lpD3D->GetAdapterIdentifier(m_ordinal_adapter, /*D3DENUM_NO_WHQL_LEVEL*/ 0, &temp) == D3D_OK)
{
StringCbCopy(m_szDriver, sizeof(m_szDriver), temp.Driver);
StringCbCopy(m_szDesc, sizeof(m_szDesc), temp.Description);
}
int caps_ok = 0;
int caps_tries = 0;
int changed_fs_disp_mode;
// try to get the device caps for the adapter selected from the config panel.
// if GetDeviceCaps() fails, it's probably because the adapter has been
// removed from the system (or disabled), so we try again with other adapter(s).
do
{
changed_fs_disp_mode = 0;
SetRect(&m_monitor_rect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
// get bounding rect of the monitor attached to the adapter (to assist w/window positioning)
// note: in vert/horz span setups (psuedo-multimon),
// this will be 2048x768 or 1024x1536 or something like that.
hPluginMonitor = m_lpD3D->GetAdapterMonitor(m_ordinal_adapter);
/*if (hPluginMonitor)
{
MONITORINFO mi;
mi.cbSize = sizeof(mi);
if (GetMonitorInfo(hPluginMonitor, &mi))
{
memcpy(&m_monitor_rect, &mi.rcMonitor, sizeof(RECT));
memcpy(&m_monitor_work_rect, &mi.rcWork, sizeof(RECT));
}
}*/
if (bFirstInit)
{
for (int i=0; i<min(nAdapters, MAX_DXC_ADAPTERS); i++)
{
// if this is the first call to Init, get the display mode's original color format,
// before we go changing it:
D3DDISPLAYMODE d3ddm;
if (FAILED(m_lpD3D->GetAdapterDisplayMode(i, &d3ddm)))
{
d3ddm.Format = D3DFMT_UNKNOWN;
}
m_orig_windowed_mode_format[i] = d3ddm.Format;
}
}
// figure out pixel (color) format for back buffer: (m_current_mode.display_mode.Format)
if (m_current_mode.screenmode!=FULLSCREEN && m_ordinal_adapter < MAX_DXC_ADAPTERS)
m_current_mode.display_mode.Format = m_orig_windowed_mode_format[m_ordinal_adapter];
// else
// for fullscreen, use what they gave us
if (m_current_mode.display_mode.Format == D3DFMT_UNKNOWN ||
!TestFormat(m_ordinal_adapter, m_current_mode.display_mode.Format))
{
// if they try to run the plugin without ever running the config panel
// first (& pressing OK), then the fullscreen pixelformat hasn't been
// chosen... so we try all the possilibities until one works:
if (TestFormat(m_ordinal_adapter,D3DFMT_A8R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_A8R8G8B8;
else if (TestFormat(m_ordinal_adapter,D3DFMT_X8R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_X8R8G8B8;
else if (TestFormat(m_ordinal_adapter,D3DFMT_R8G8B8)) m_current_mode.display_mode.Format = D3DFMT_R8G8B8 ;
else if (TestFormat(m_ordinal_adapter,D3DFMT_R5G6B5)) m_current_mode.display_mode.Format = D3DFMT_R5G6B5 ;
else if (TestFormat(m_ordinal_adapter,D3DFMT_X1R5G5B5)) m_current_mode.display_mode.Format = D3DFMT_X1R5G5B5;
else if (TestFormat(m_ordinal_adapter,D3DFMT_A1R5G5B5)) m_current_mode.display_mode.Format = D3DFMT_A1R5G5B5;
else if (TestFormat(m_ordinal_adapter,D3DFMT_A4R4G4B4)) m_current_mode.display_mode.Format = D3DFMT_A4R4G4B4;
else if (TestFormat(m_ordinal_adapter,D3DFMT_X4R4G4B4)) m_current_mode.display_mode.Format = D3DFMT_X4R4G4B4;
}
if (m_current_mode.display_mode.Format==D3DFMT_UNKNOWN)
{
wchar_t title[64];
m_lastErr = DXC_ERR_FORMAT;
MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_DIRECTX_INIT_FAILED),
WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
return FALSE;
}
if (m_current_mode.screenmode == FULLSCREEN)
changed_fs_disp_mode = CheckAndCorrectFullscreenDispMode(m_ordinal_adapter, &m_current_mode.display_mode);
// figure out pixel format of the z-buffer: (m_zFormat)
m_zFormat = D3DFMT_UNKNOWN;
/*
if (TestDepth(m_ordinal_adapter,D3DFMT_D32 )) m_zFormat=D3DFMT_D32;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D24S8 )) m_zFormat=D3DFMT_D24S8;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D24X4S4 )) m_zFormat=D3DFMT_D24X4S4;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D24X8 )) m_zFormat=D3DFMT_D24X8;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D16 )) m_zFormat=D3DFMT_D16;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D15S1 )) m_zFormat=D3DFMT_D15S1;
else if (TestDepth(m_ordinal_adapter,D3DFMT_D16_LOCKABLE)) m_zFormat=D3DFMT_D16_LOCKABLE;
*/
// get device caps:
memset(&m_caps, 0, sizeof(m_caps));
if (FAILED(m_lpD3D->GetDeviceCaps(m_ordinal_adapter, D3DDEVTYPE_HAL, &m_caps)))
{
// that adapter was found in the system, but it might be disabled
// (i.e. 'extend my Windows desktop onto this monitor') is unchecked)
// so, try other adapters (try all sequentially).
if (caps_tries < nAdapters)
{
// try again, this time using the default adapter:
m_ordinal_adapter = caps_tries;
caps_tries++;
}
else
{
wchar_t title[64];
m_lastErr = DXC_ERR_CAPSFAIL;
MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_DXC_ERR_CAPSFAIL),
WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
return FALSE;
}
}
else
{
caps_ok = 1;
}
}
while (!caps_ok);
if (changed_fs_disp_mode)
{
wchar_t title[64];
MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_FS_DISPLAY_MODE_SELECTED_IS_INVALID),
WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_WARNING, title, 64),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
}
switch (m_current_mode.display_mode.Format)
{
case D3DFMT_R8G8B8 : m_bpp = 32; break;
case D3DFMT_A8R8G8B8: m_bpp = 32; break;
case D3DFMT_X8R8G8B8: m_bpp = 32; break;
case D3DFMT_R5G6B5 : m_bpp = 16; break;
case D3DFMT_X1R5G5B5: m_bpp = 16; break;
case D3DFMT_A1R5G5B5: m_bpp = 16; break;
case D3DFMT_A8R3G3B2: m_bpp = 16; break;
case D3DFMT_A4R4G4B4: m_bpp = 16; break;
case D3DFMT_X4R4G4B4: m_bpp = 16; break;
case D3DFMT_R3G3B2 : m_bpp = 8; break; // misleading? implies a palette...
}
}
// 5. set m_monitor_rect and m_monitor_work_rect.
if (hPluginMonitor)
{
MONITORINFO mi;
mi.cbSize = sizeof(mi);
if (GetMonitorInfo(hPluginMonitor, &mi))
{
m_monitor_rect = mi.rcMonitor;
m_monitor_rect_orig = mi.rcMonitor;
m_monitor_work_rect = mi.rcWork;
m_monitor_work_rect_orig = mi.rcWork;
}
}
// 6. embedded window stuff [where the plugin window is integrated w/winamp]
if (m_current_mode.m_skin)
{
// set up the window's position on screen
// note that we'd prefer to set the CLIENT size we want, but we can't, so we'll just do
// this here, and later, adjust the client rect size to what's left...
int size = GetWindowedModeAutoSize(0); // note: requires 'm_monitor_rect' has been set!
myWindowState.r.left = GetPrivateProfileIntW(L"settings",L"avs_wx",64,m_szIniFile);
myWindowState.r.top = GetPrivateProfileIntW(L"settings",L"avs_wy",64,m_szIniFile);
myWindowState.r.right = myWindowState.r.left + GetPrivateProfileIntW(L"settings",L"avs_ww",size+24,m_szIniFile);
myWindowState.r.bottom = myWindowState.r.top + GetPrivateProfileIntW(L"settings",L"avs_wh",size+40,m_szIniFile);
// only works on winamp 2.90+!
int success = 0;
if (GetWinampVersion(mod1.hwndParent) >= 0x2900)
{
SET_EMBED_GUID((&myWindowState), avs_guid);
myWindowState.flags |= EMBED_FLAGS_NOTRANSPARENCY;
HWND (*e)(embedWindowState *v);
*(void**)&e = (void *)SendMessage(mod1.hwndParent,WM_WA_IPC,(LPARAM)0,IPC_GET_EMBEDIF);
if (e)
{
m_current_mode.parent_window = e(&myWindowState);
if (m_current_mode.parent_window)
{
SetWindowText(m_current_mode.parent_window, m_szWindowCaption);
success = 1;
}
}
}
if (!success)
m_current_mode.m_skin = 0;
}
// remember the client rect that was originally desired...
RECT windowed_mode_desired_client_rect;
windowed_mode_desired_client_rect.top = GetPrivateProfileIntW(L"settings",L"nMainWndTop",-1,m_szIniFile);
windowed_mode_desired_client_rect.left = GetPrivateProfileIntW(L"settings",L"nMainWndLeft",-1,m_szIniFile);
windowed_mode_desired_client_rect.right = GetPrivateProfileIntW(L"settings",L"nMainWndRight",-1,m_szIniFile);
windowed_mode_desired_client_rect.bottom = GetPrivateProfileIntW(L"settings",L"nMainWndBottom",-1,m_szIniFile);
// ...and in case windowed mode init fails severely,
// set it up to try next time for a simple 256x256 window.
WriteSafeWindowPos();
// 7. create the window, if not already created
if (!m_hwnd)
{
m_hwnd = CreateWindowEx(
MY_EXT_WINDOW_STYLE, // extended style
MAKEINTATOM(m_classAtom), // class
m_szWindowCaption, // caption
MY_WINDOW_STYLE, // style
0, // left
0, // top
256, // temporary width
256, // temporary height
m_current_mode.parent_window, // parent window
NULL, // menu
m_hInstance, // instance
(LPVOID)m_uWindowLong
); // parms
if (!m_hwnd)
{
wchar_t title[64];
m_lastErr = DXC_ERR_CREATEWIN;
MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_CREATEWINDOW_FAILED),
WASABI_API_LNGSTRINGW_BUF(IDS_MILKDROP_ERROR, title, 64),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
return FALSE;
}
SendMessage(m_hwnd_winamp, WM_WA_IPC, (WPARAM)m_hwnd, IPC_SETVISWND);
if (m_current_mode.m_skin)
{
if (GetWinampVersion(mod1.hwndParent) < 0x5051)
ShowWindow(m_current_mode.parent_window,SW_SHOWNA); // showing the parent wnd will make it size the child, too
else
SendMessage(m_current_mode.parent_window, WM_USER+102, 0, 0); // benski> major hack alert. winamp's embedwnd will call ShowWindow in response. SendMessage moves us over to the main thread (we're currently sitting on the viz thread)
}
}
// 8. minimize winamp before creating devices & such, so there aren't
// any confusing window-focus issues
MinimizeWinamp(hPluginMonitor);
// 9. loop to try and create the window.
// if in windowed mode and not enough vidmem, it will try again w/smaller window
// (repeatedly, until window client size would be < 64)
int iteration = 0;
int device_ok = 0;
do
{
// set the window position
if (m_current_mode.screenmode==DESKTOP ||
m_current_mode.screenmode==FAKE_FULLSCREEN)
{
int x = m_monitor_rect.right - m_monitor_rect.left;
int y = m_monitor_rect.bottom - m_monitor_rect.top;
if (x >= y*2)
{
// (pseudo-multimon modes like 2048x768)
int mid = (m_monitor_rect.left + m_monitor_rect.right)/2;
if (m_current_mode.m_dualhead_horz==1) // show on left side
m_monitor_rect.right = mid;
else if (m_current_mode.m_dualhead_horz==2) // show on right side
m_monitor_rect.left = mid;
}
else if (y > x*4/3)
{
// (pseudo-multimon modes like 1024x1536)
int mid = (m_monitor_rect.top + m_monitor_rect.bottom)/2;
if (m_current_mode.m_dualhead_vert==1) // show on top half
m_monitor_rect.bottom = mid;
else if (m_current_mode.m_dualhead_vert==2) // show on bottom half
m_monitor_rect.top = mid;
}
// recompute width & height (into x,y):
x = m_monitor_rect.right - m_monitor_rect.left;
y = m_monitor_rect.bottom - m_monitor_rect.top;
m_client_width = x;
m_client_height = y;
m_window_width = x;
m_window_height = y;
if (m_current_mode.screenmode == DESKTOP)
{
// note: we initially hide the window, and then
// only display it once the desktop is all nice & ready.
// see CPluginShell::DrawAndDisplay().
RECT r = m_monitor_rect;
// if possible, shrink the desktop window so it doesn't cover the taskbar.
HWND hTaskbar = FindWindow("Shell_TrayWnd", "");
if (hTaskbar)
{
RECT taskbar;
GetWindowRect(hTaskbar, &taskbar);
int tbw = taskbar.right - taskbar.left;
int tbh = taskbar.bottom-taskbar.top;
if (taskbar.bottom == m_monitor_rect.bottom &&
taskbar.left == m_monitor_rect.left &&
taskbar.right == m_monitor_rect.right)
{
r.bottom -= tbh;
}
else if (taskbar.top == m_monitor_rect.top &&
taskbar.left == m_monitor_rect.left &&
taskbar.right == m_monitor_rect.right)
{
r.top += tbh;
}
else if (taskbar.left == m_monitor_rect.left &&
taskbar.top == m_monitor_rect.top &&
taskbar.bottom == m_monitor_rect.bottom)
{
r.left += tbw;
}
else if (taskbar.right == m_monitor_rect.right &&
taskbar.top == m_monitor_rect.top &&
taskbar.bottom == m_monitor_rect.bottom)
{
r.right -= tbw;
}
m_client_width = r.right - r.left;
m_client_height = r.bottom - r.top;
m_REAL_client_width = m_client_width;
m_REAL_client_height = m_client_height;
m_window_width = m_client_width;
m_window_height = m_client_height;
//...ok, but text is squished - some w/h is not right...
}
SetWindowPos(m_hwnd,HWND_BOTTOM,r.left,r.top,r.right-r.left,r.bottom-r.top,SWP_HIDEWINDOW);
}
else // FAKE_FULLSCREEN
{
if (memcmp(&m_all_monitors_rect, &m_monitor_rect, sizeof(RECT))==0)
{
// there's only one display, and it's entirely covered
// by the plugin -> PUT THE PLUGIN ABOVE THE TASKBAR
// -> normally, if the user clicked another window,
// it would pop the taskbar to the top; but we don't
// have to worry about that here, since we're taking
// up the whole screen.
// -> don't worry about making the text, etc. avoid
// the taskbar in this case (see DrawAndDisplay())
// -> DO worry about hiding the mouse cursor in this case
// (see WM_SETCURSOR handler)
m_fake_fs_covers_all = 1;
//SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
}
else
{
// there is space to work outside of the plugin window.
// -> here we pretty much have to let the taskbar stay on
// top, because it really likes to be there; i.e.,
// if you click any other window, it automatically
// pops up again.
// -> therefore, TRY TO KEEP THE WINDOW ON BOTTOM
// (below the taskbar). (see PushWindowToBack)
// -> don't worry about hiding the mouse cursor in this case
// (see WM_SETCURSOR handler)
// -> DO worry about making the text, etc. avoid
// the taskbar in this case (see DrawAndDisplay())
// (note that if taskbar is in the way, they can move it,
// since there are other monitors available)
m_fake_fs_covers_all = 0;
//SetWindowPos(m_hwnd,HWND_TOP,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
}
SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
}
}
else if (m_current_mode.screenmode == FULLSCREEN)
{
int x = m_current_mode.display_mode.Width ;
int y = m_current_mode.display_mode.Height;
int cx = m_monitor_rect.right - m_monitor_rect.left;
int cy = m_monitor_rect.bottom - m_monitor_rect.top;
// test #1
if (x >= y*2 || y > x*4/3) // tackle problem of vert/horz spans
{
wchar_t title[64];
int ret = MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_TRYING_TO_ENTER_FS_MODE_WITH_MULTIPLE_DISPLAYS),
WASABI_API_LNGSTRINGW_BUF(IDS_TIP, title, 64),
MB_OKCANCEL|MB_SETFOREGROUND|MB_TOPMOST);
if (ret==IDCANCEL)
{
m_lastErr = DXC_ERR_USER_CANCELED;
return FALSE;
}
}
// test #2
if ((cx >= cy*2 && x < y*2) || (cy > cx*4/3 && y <= x*4/3))
{
wchar_t title[64];
int ret = MessageBoxW(m_hwnd, WASABI_API_LNGSTRINGW(IDS_TRYING_TO_ENTER_FS_MODE_WITH_MULTIPLE_DISPLAYS_2),
WASABI_API_LNGSTRINGW_BUF(IDS_TIP, title, 64),
MB_OKCANCEL|MB_SETFOREGROUND|MB_TOPMOST);
if (ret==IDCANCEL)
{
m_lastErr = DXC_ERR_USER_CANCELED;
return FALSE;
}
}
m_client_width = x;
m_client_height = y;
m_window_width = x;
m_window_height = y;
SetWindowPos(m_hwnd,HWND_TOPMOST,m_monitor_rect.left,m_monitor_rect.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
}
else // WINDOWED
{
RECT margin;
if (m_current_mode.m_skin)
{
RECT r1, r2;
GetWindowRect(m_current_mode.parent_window, &r1);
GetWindowRect(m_hwnd , &r2);
margin.left = r2.left - r1.left;
margin.right = r1.right - r2.right;
margin.top = r2.top - r1.top;
margin.bottom= r1.bottom - r2.bottom;
}
else
{
RECT r1;
SetRect(&r1, 0, 0, 256, 256);
AdjustWindowRect(&r1, MY_WINDOW_STYLE, 0);
margin.left = 0 - r1.left;
margin.right = r1.right - 256;
margin.top = 0 - r1.top;
margin.bottom= r1.bottom - 256;
}
int autosize = 1;
RECT r = windowed_mode_desired_client_rect;
if (iteration==0 && r.top != -1 && r.left != -1 && r.bottom != -1 && r.right != -1)
{
// use prev. window coordinates:
m_REAL_client_width = r.right - r.left;
m_REAL_client_height = r.bottom - r.top;
GetSnappedClientSize();
if (m_current_mode.m_skin) // check this here in case they got a non-aligned size by resizing when "integrated with winamp" was unchecked, then checked it & ran the plugin...
{
// STRANGE ALIGNMENTS FOR THE WINDOW FRAME: (required by winamp 2):
// the window frame's width must be divisible by 25, and height by 29.
if (GetWinampVersion(mod1.hwndParent) < 0x4000) // ... winamp 5 doesn't have this prob. (test vs. 0x4000 because winamp5 betas have version tags like 0x4987)
{
m_REAL_client_width = ((m_client_width + margin.left + margin.right)/25)*25 - margin.left - margin.right;
m_REAL_client_height = ((m_client_height + margin.top + margin.bottom)/29)*29 - margin.top - margin.bottom;
GetSnappedClientSize();
}
}
// transform screen-space CLIENT rect into screen-space WINDOW rect
r.top = windowed_mode_desired_client_rect.top - margin.top;
r.left = windowed_mode_desired_client_rect.left - margin.left;
r.right = r.left + margin.left + m_REAL_client_width + margin.right;
r.bottom = r.top + margin.top + m_REAL_client_height + margin.bottom;
// make sure the window is entirely visible on the selected monitor;
// otherwise, autosize/place it.
// (note that this test is only appled 1) at startup, and 2) after a resize/max/restore.
// this test is not applied when merely moving the window.)
if (r.top >= m_monitor_work_rect.top &&
r.left >= m_monitor_work_rect.left &&
r.right <= m_monitor_work_rect.right &&
r.bottom <= m_monitor_work_rect.bottom)
{
if (m_current_mode.m_skin)
{
m_window_width = m_REAL_client_width ; // m_window_width/height are for OUR borderless window, not the embedwnd parent frame.
m_window_height = m_REAL_client_height;
SetWindowPos(m_current_mode.parent_window,HWND_NOTOPMOST, r.left, r.top, r.right-r.left, r.bottom-r.top, /*SWP_SHOWWINDOW|*//*SWP_ASYNCWINDOWPOS*/0);
SetWindowPos(m_hwnd ,HWND_NOTOPMOST, windowed_mode_desired_client_rect.left,
windowed_mode_desired_client_rect.top,
m_REAL_client_width,
m_REAL_client_height,
SWP_SHOWWINDOW);
}
else
{
m_window_width = r.right - r.left;
m_window_height = r.bottom - r.top;
SetWindowPos(m_hwnd,HWND_NOTOPMOST,r.left,r.top,m_window_width,m_window_height,SWP_SHOWWINDOW);
}
autosize = 0;
}
}
if (autosize)
{
int size = GetWindowedModeAutoSize(iteration); // note: requires 'm_monitor_rect' has been set!
m_REAL_client_width = size;
m_REAL_client_height = size;
GetSnappedClientSize();
if (m_current_mode.m_skin)
{
// STRANGE ALIGNMENTS FOR THE WINDOW FRAME: (required by winamp 2):
// the window frame's width must be divisible by 25, and height by 29.
if (GetWinampVersion(mod1.hwndParent) < 0x4000) // ... winamp 5 doesn't have this prob. (test vs. 0x4000 because winamp5 betas have version tags like 0x4987)
{
m_REAL_client_width = ((m_client_width + margin.left + margin.right)/25)*25 - margin.left - margin.right;
m_REAL_client_height = ((m_client_height + margin.top + margin.bottom)/29)*29 - margin.top - margin.bottom;
GetSnappedClientSize();
}
m_window_width = m_client_width ; // m_window_width/height are for OUR [borderless] window, not the parent window (which is the embedwnd frame).
m_window_height = m_client_height;
SetWindowPos(m_current_mode.parent_window,HWND_NOTOPMOST, m_monitor_work_rect.left+32, m_monitor_work_rect.top+32, m_client_width + margin.left + margin.right, m_client_height + margin.top + margin.bottom, /*SWP_SHOWWINDOW|*//*SWP_ASYNCWINDOWPOS*/0);
SetWindowPos(m_hwnd ,HWND_NOTOPMOST, m_monitor_work_rect.left+32 + margin.left, m_monitor_work_rect.top+32 + margin.top, m_client_width, m_client_height, SWP_SHOWWINDOW);
}
else
{
SetRect(&r, 0, 0, size, size);
AdjustWindowRect(&r, MY_WINDOW_STYLE, 0);
m_window_width = r.right - r.left;
m_window_height = r.bottom - r.top;
SetWindowPos(m_hwnd,HWND_NOTOPMOST, m_monitor_work_rect.left+32, m_monitor_work_rect.top+32, m_window_width, m_window_height, SWP_SHOWWINDOW);
}
}
}
m_frame_delay = 1; // set this to 2 if you use triple buffering!
{
m_current_mode.display_mode.Width = m_client_width;
m_current_mode.display_mode.Height = m_client_height;
// set up m_d3dpp (presentation parameters):
ZeroMemory(&m_d3dpp,sizeof(m_d3dpp));
m_d3dpp.Windowed = (m_current_mode.screenmode==FULLSCREEN) ? 0 : 1;
m_d3dpp.BackBufferFormat = m_current_mode.display_mode.Format;
m_d3dpp.BackBufferWidth = m_client_width;
m_d3dpp.BackBufferHeight = m_client_height;
m_d3dpp.BackBufferCount = m_current_mode.nbackbuf;
if (m_current_mode.screenmode==FULLSCREEN)
m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;//D3DSWAPEFFECT_FLIP;
else // windowed or fake FS
m_d3dpp.SwapEffect = (m_current_mode.allow_page_tearing) ? D3DSWAPEFFECT_DISCARD : D3DSWAPEFFECT_COPY;//D3DSWAPEFFECT_DISCARD;//D3DSWAPEFFECT_FLIP;
// note: multisampling is only allowed if swapeffect is DISCARD!
m_d3dpp.MultiSampleType = (m_d3dpp.SwapEffect==D3DSWAPEFFECT_DISCARD) ? m_current_mode.multisamp : D3DMULTISAMPLE_NONE;
//m_d3dpp.hDeviceWindow = m_hwnd;
if (m_current_mode.screenmode==FULLSCREEN)
{
m_d3dpp.FullScreen_RefreshRateInHz = m_current_mode.display_mode.RefreshRate;//D3DPRESENT_RATE_DEFAULT;
m_d3dpp.PresentationInterval = m_current_mode.allow_page_tearing ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;//D3DPRESENT_INTERVAL_IMMEDIATE;//D3DPRESENT_INTERVAL_ONE;
}
if (m_zFormat != D3DFMT_UNKNOWN)
{
m_d3dpp.EnableAutoDepthStencil=TRUE;
m_d3dpp.AutoDepthStencilFormat=m_zFormat;
}
// finally, create the device:
HRESULT hRes;
if (FAILED(hRes = m_lpD3D->CreateDevice(
m_ordinal_adapter,
D3DDEVTYPE_HAL,
m_hwnd,
(m_caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) ? D3DCREATE_MIXED_VERTEXPROCESSING : D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&m_d3dpp,
&m_lpDevice)))
{
int code = LOWORD(hRes);
wchar_t str[1024];
if (code==2156) //D3DERR_NOTAVAILABLE
{
m_lastErr = DXC_ERR_CREATEDEV_NOT_AVAIL;
wchar_t str[2048];
WASABI_API_LNGSTRINGW_BUF(IDS_UNABLE_TO_CREATE_DIRECTX_DEVICE, str, 2048);
if (m_current_mode.screenmode == FULLSCREEN)
StringCbCatW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_OLDER_DISPLAY_ADAPTER_CATENATION));
else
StringCbCatW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_OLDER_DISPLAY_ADAPTER_CATENATION_2));
MessageBoxW(m_hwnd,str,
WASABI_API_LNGSTRINGW(IDS_MILKDROP_ERROR),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
return FALSE;
}
else if (m_current_mode.screenmode==WINDOWED && m_client_width>64)
{
// DO NOTHING; try again w/smaller window
}
else if (m_current_mode.screenmode != WINDOWED || m_client_width <= 64)
{
// usually, code==2154 here, which is D3DERR_OUTOFVIDEOMEMORY
m_lastErr = DXC_ERR_CREATEDEV_PROBABLY_OUTOFVIDEOMEMORY;
StringCbPrintfW(str, sizeof(str), WASABI_API_LNGSTRINGW(IDS_DIRECTX_INIT_FAILED_X), LOWORD(hRes));
// NOTE: *A 'SUGGESTION' SCREEN SHOULD APPEAR NEXT, PROVIDED BY THE CALLER*
MessageBoxW(m_hwnd, str,
WASABI_API_LNGSTRINGW(IDS_MILKDROP_ERROR),
MB_OK|MB_SETFOREGROUND|MB_TOPMOST);
return FALSE;
}
}
else
{
device_ok = 1;
}
}
iteration++;
}
while (!device_ok);
// set initial viewport
SetViewport();
// for desktop mode, push window to back again:
if (m_current_mode.screenmode==DESKTOP)
SetWindowPos(m_hwnd,HWND_BOTTOM,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
if (m_current_mode.m_skin)
{
if (GetWinampVersion(mod1.hwndParent) < 0x5051)
SetFocus(m_current_mode.parent_window);
else
PostMessage(m_current_mode.parent_window, WM_USER+103, 0, 0);
//SetActiveWindow(m_current_mode.parent_window);
//SetForegroundWindow(m_current_mode.parent_window);
}
/*if (m_current_mode.screenmode == WINDOWED)
SaveWindow();*/
// return success
m_ready = TRUE;
// benski> a little hack to get the window size correct. it seems to work
if (m_current_mode.screenmode==WINDOWED)
PostMessage(m_hwnd, WM_USER+555, 0, 0);
return TRUE;
}
