HRESULT SetCurrentUserPermissions()
{
HRESULT hr = E_FAIL;
WCHAR wzLocalGACPath[MAX_PATH];
LPWSTR pwzFileName;
DWORD dwAttr;
// Executed on PROCESS_ATTACH - no need to lock here
if (FAILED(GetCacheLocationFromReg()))
{
if (!PAL_GetMachineConfigurationDirectory(g_szWindowsDir, NUMBER_OF(g_szWindowsDir)))
{
hr = FusionpHresultFromLastError();
goto Exit;
}
g_cchWindowsDir = lstrlen(g_szWindowsDir);
}
// Override registry setting if there is an "fusion.localgac" file
// under the path where fusion.dll is found
lstrcpyW(wzLocalGACPath, g_FusionDllPath);
pwzFileName = PathFindFileName(wzLocalGACPath);
ASSERT(pwzFileName);
*pwzFileName = '\0';
wnsprintfW(wzLocalGACPath, MAX_PATH, L"%s%s", wzLocalGACPath, FUSION_LOCAL_GAC_FILE);
dwAttr = GetFileAttributes(wzLocalGACPath);
if (dwAttr != (DWORD) -1 && !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) {
*(pwzFileName - 1) = '\0';
lstrcpyW(g_szWindowsDir, wzLocalGACPath);
g_cchWindowsDir = lstrlenW(g_szWindowsDir);
}
// Woah, the windows dir is longer than MAX_PATH??
ASSERT((g_cchWindowsDir + TEMP_RANDOM_DIR_LENGTH) < NUMBER_OF(g_szWindowsDir));
if (g_cchWindowsDir == 0)
{
hr = FusionpHresultFromLastError();
goto Exit;
}
// SetGACDir();
// SetZapDir();
Exit:
return hr;
}
static void
debug_printf(LPCTSTR format, ...)
{
va_list va;
TCHAR buf[80*25];
va_start(va, format);
_vsntprintf(buf, NUMBER_OF(buf), format, va);
buf[NUMBER_OF(buf) - 1] = T('\0');
va_end(va);
SendMessage(g_DebugWindow, EM_REPLACESEL, 0, (LPARAM)buf);
SendMessage(g_DebugWindow, EM_REPLACESEL, 0, (LPARAM)T("\r\n"));
}
/// get class name and title name
static void getClassNameTitleName(HWND i_hwnd, bool i_isInMenu,
tstringi *o_className,
tstring *o_titleName)
{
tstringi &className = *o_className;
tstring &titleName = *o_titleName;
bool isTheFirstTime = true;
if (i_isInMenu) {
className = titleName = _T("MENU");
isTheFirstTime = false;
}
while (true) {
_TCHAR buf[MAX(GANA_MAX_PATH, GANA_MAX_ATOM_LENGTH)];
// get class name
if (i_hwnd)
GetClassName(i_hwnd, buf, NUMBER_OF(buf));
else
GetModuleFileName(GetModuleHandle(NULL), buf, NUMBER_OF(buf));
buf[NUMBER_OF(buf) - 1] = _T('\0');
if (isTheFirstTime)
className = buf;
else
className = tstringi(buf) + _T(":") + className;
// get title name
if (i_hwnd) {
GetWindowText(i_hwnd, buf, NUMBER_OF(buf));
buf[NUMBER_OF(buf) - 1] = _T('\0');
for (_TCHAR *b = buf; *b; ++ b)
if (_istlead(*b) && b[1])
b ++;
else if (_istcntrl(*b))
*b = _T('?');
}
if (isTheFirstTime)
titleName = buf;
else
titleName = tstring(buf) + _T(":") + titleName;
// next loop or exit
if (!i_hwnd)
break;
i_hwnd = GetParent(i_hwnd);
isTheFirstTime = false;
}
}
/// &Recenter
static void funcRecenter(HWND i_hwnd)
{
_TCHAR buf[MAX(GANA_MAX_PATH, GANA_MAX_ATOM_LENGTH)];
GetClassName(i_hwnd, buf, NUMBER_OF(buf));
bool isEdit;
if (_tcsicmp(buf, _T("Edit")) == 0)
isEdit = true;
else if (_tcsnicmp(buf, _T("RichEdit"), 8) == 0)
isEdit = false;
else
return; // this function only works for Edit control
#ifdef MAYU64
LONG_PTR style = GetWindowLongPtr(i_hwnd, GWL_STYLE);
#else
LONG style = GetWindowLong(i_hwnd, GWL_STYLE);
#endif
if (!(style & ES_MULTILINE))
return; // this function only works for multi line Edit control
RECT rc;
GetClientRect(i_hwnd, &rc);
POINTL p = { (rc.right + rc.left) / 2, (rc.top + rc.bottom) / 2 };
int line;
if (isEdit) {
line = SendMessage(i_hwnd, EM_CHARFROMPOS, 0, MAKELPARAM(p.x, p.y));
line = HIWORD(line);
} else {
int ci = SendMessage(i_hwnd, EM_CHARFROMPOS, 0, (LPARAM)&p);
line = SendMessage(i_hwnd, EM_EXLINEFROMCHAR, 0, ci);
}
int caretLine = SendMessage(i_hwnd, EM_LINEFROMCHAR, -1, 0);
SendMessage(i_hwnd, EM_LINESCROLL, 0, caretLine - line);
}
/// notify log
static void notifyLog(_TCHAR *i_msg)
{
NotifyLog nl;
nl.m_type = Notify::Type_log;
tcslcpy(nl.m_msg, i_msg, NUMBER_OF(nl.m_msg));
notify(&nl, sizeof(nl));
}
/// notify WM_Targetted
static void notifyName(HWND i_hwnd, Notify::Type i_type = Notify::Type_name)
{
tstringi className;
tstring titleName;
getClassNameTitleName(i_hwnd, g.m_isInMenu, &className, &titleName);
NotifySetFocus *nfc = new NotifySetFocus;
nfc->m_type = i_type;
nfc->m_threadId = GetCurrentThreadId();
nfc->m_hwnd = reinterpret_cast<DWORD>(i_hwnd);
tcslcpy(nfc->m_className, className.c_str(), NUMBER_OF(nfc->m_className));
tcslcpy(nfc->m_titleName, titleName.c_str(), NUMBER_OF(nfc->m_titleName));
notify(nfc, sizeof(*nfc));
delete nfc;
}
// get filename from registry
bool SettingLoader::getFilenameFromRegistry(tstringi *o_path) const
{
// get from registry
Registry reg(MAYU_REGISTRY_ROOT);
int index;
reg.read(_T(".mayuIndex"), &index, 0);
char buf[100];
snprintf(buf, NUMBER_OF(buf), _T(".mayu%d"), index);
if (!reg.read(buf, o_path))
return false;
// parse registry entry
Regexp getFilename(_T("^[^;]*;([^;]*);(.*)$"));
if (!getFilename.doesMatch(*o_path))
return false;
tstringi path = getFilename[1];
tstringi options = getFilename[2];
if (!(0 < path.size() && isReadable(path)))
return false;
*o_path = path;
// set symbols
Regexp symbol(_T("-D([^;]*)"));
while (symbol.doesMatch(options)) {
m_setting->symbols.insert(symbol[1]);
options = options.substr(symbol.subBegin(1));
}
return true;
}
void tooltip_update (NMTTDISPINFO* di, control* c)
{
if ((c == NULL) || (!tooltip_enabled))
return;
if (di->hdr.hwndFrom == tooltip_window) {
if (di->hdr.code == TTN_GETDISPINFO) {
char buf[225];
window* w = c->windowptr;
sprintf(buf,"%s:%s [%d,%d] @ (%d,%d)",c->moduleptr->name,c->controlname, w->width, w->height, w->x, w->y);
strncpy( di->szText, buf,
NUMBER_OF(di->szText) );
di->szText[NUMBER_OF(di->szText) - 1] = '\0';
}
}
}
// get mayu filename
static bool getFilenameFromRegistry(
tstringi *o_name, tstringi *o_filename, Setting::Symbols *o_symbols)
{
Registry reg(MAYU_REGISTRY_ROOT);
int index;
reg.read(_T(".mayuIndex"), &index, 0);
_TCHAR buf[100];
_sntprintf(buf, NUMBER_OF(buf), _T(".mayu%d"), index);
tstringi entry;
if (!reg.read(buf, &entry))
return false;
tregex getFilename(_T("^([^;]*);([^;]*);(.*)$"));
tsmatch getFilenameResult;
if (!boost::regex_match(entry, getFilenameResult, getFilename))
return false;
if (o_name)
*o_name = getFilenameResult.str(1);
if (o_filename)
*o_filename = getFilenameResult.str(2);
if (o_symbols) {
tstringi symbols = getFilenameResult.str(3);
tregex symbol(_T("-D([^;]*)(.*)$"));
tsmatch symbolResult;
while (boost::regex_search(symbols, symbolResult, symbol)) {
o_symbols->insert(symbolResult.str(1));
symbols = symbolResult.str(2);
}
}
return true;
}
PCWSTR
GetSpaces(
size_t Count
)
{
static const WCHAR Spaces[] = {
L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',
L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',
L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',
L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',L' ',
0
};
C_ASSERT(NUMBER_OF(Spaces) == 65);
if (Count > (NUMBER_OF(Spaces) - 1))
Count = (NUMBER_OF(Spaces) - 1);
return (Spaces + NUMBER_OF(Spaces) - 1 - Count);
}
// get compiler version string
tstring getCompilerVersionString()
{
TCHAR buf[200];
_sntprintf(buf, NUMBER_OF(buf),
_T("GCC") // TODO:
);
return tstring(buf);
}
// load resource string
tstring loadString(UINT i_id)
{
_TCHAR buf[1024];
if (LoadString(g_hInst, i_id, buf, NUMBER_OF(buf)))
return tstring(buf);
else
return _T("");
}
// get compiler version string
tstring getCompilerVersionString()
{
TCHAR buf[200];
_sntprintf(buf, NUMBER_OF(buf),
_T("Microsoft (R) 32-bit C/C++ Optimizing Compiler Version %d.%02d"),
_MSC_VER / 100,
_MSC_VER % 100);
return tstring(buf);
}
// get compiler version string
tstring getCompilerVersionString()
{
TCHAR buf[100];
_sntprintf(buf, NUMBER_OF(buf), _T("Borland C++ %d.%d.%d"),
__BORLANDC__ / 0x100,
__BORLANDC__ / 0x10 % 0x10,
__BORLANDC__ % 0x10);
return tstring(buf);
}
BOOL
CALLBACK
EnumLangProc(
HMODULE Module,
PCWSTR Type,
PCWSTR Name,
WORD Language,
LONG Param
)
{
WCHAR TypeBuffer[20];
WCHAR NameBuffer[20];
wprintf(
L"module:%p type:%ls name:%ls lang:%x\n",
Module,
IdToString(Type, TypeBuffer, NUMBER_OF(TypeBuffer)),
IdToString(Name, NameBuffer, NUMBER_OF(NameBuffer)),
Language);
return TRUE;
}
static void WriteToLog(const char *data)
{
char buf[1024];
DWORD count;
WideCharToMultiByte(CP_THREAD_ACP, 0, g.m_moduleName, -1, buf, NUMBER_OF(buf), NULL, NULL);
strcat(buf, ": ");
strcat(buf, data);
SetFilePointer(g.m_logFile, 0, NULL, FILE_END);
WriteFile(g.m_logFile, buf, strlen(buf), &count, NULL);
FlushFileBuffers(g.m_logFile);
}
static
bool F_Parse_INI_and_Load_Packages( PCHARS szProjFilePath )
{
AssertPtr( szProjFilePath );
// Parse .INI file and load resource packages.
ANSICHAR iniFilePath[ FS_MAX_PATH ];
VRET_FALSE_IF_NOT( F_Compose_File_Path( szProjFilePath, iniFilePath, NUMBER_OF(iniFilePath) ) );
FileReader iniFileReader( iniFilePath, FileRead_NoErrors );
if( !iniFileReader.IsOpen() ) {
mxWarnf("Failed to load config file '%s'\n",iniFilePath);
return false;
}
// 1 KiB
enum { MAX_INI_SIZE = 1*mxKIBIBYTE};
const UINT fileSize = iniFileReader.GetSize();
if( fileSize > MAX_INI_SIZE )
{
mxWarnf("Config file '%s' is too big\n",iniFilePath);
return false;
}
ANSICHAR buffer[ MAX_INI_SIZE ];
MemZero( buffer, sizeof buffer );
iniFileReader.Read( buffer, fileSize );
idLexer lexer( buffer, fileSize, iniFilePath, LEXFL_ALLOWPATHNAMES|LEXFL_NOSTRINGCONCAT );
idToken token;
while( lexer.ReadToken( &token ) )
{
if( token == "[" ) {
lexer.ExpectAnyToken( &token );
lexer.ExpectTokenString("]");
continue;
}
if( token.type == TT_STRING ) {
UNDONE;
//F_MountExistingPackage( token.ToChars() );
continue;
} else {
lexer.Error("Expected a string, but got '%s'\n",token.ToChars());
}
return false;
}//while (ReadToken)
return true;
}
/// stream output
tostream &operator<<(tostream &i_ost, Modifier::Type i_type)
{
const _TCHAR *modNames[] = {
_T("Shift"),
_T("Alt"),
_T("Control"),
_T("Windows"),
_T("Up"),
_T("Down"),
_T("Repeat"),
_T("ImeLock"),
_T("ImeComp"),
_T("NumLock"),
_T("CapsLock"),
_T("ScrollLock"),
_T("KanaLock"),
_T("Maximized"),
_T("Minimized"),
_T("MdiMaximized"),
_T("MdiMinimized"),
_T("Touchpad"),
_T("TouchpadSticky"),
_T("Mod0"),
_T("Mod1"),
_T("Mod2"),
_T("Mod3"),
_T("Mod4"),
_T("Mod5"),
_T("Mod6"),
_T("Mod7"),
_T("Mod8"),
_T("Mod9"),
_T("Lock0"),
_T("Lock1"),
_T("Lock2"),
_T("Lock3"),
_T("Lock4"),
_T("Lock5"),
_T("Lock6"),
_T("Lock7"),
_T("Lock8"),
_T("Lock9"),
};
int i = static_cast<int>(i_type);
if (0 <= i && i < NUMBER_OF(modNames))
i_ost << modNames[i];
return i_ost;
}
// stream output
tostream &operator<<(tostream &i_ost, const Modifier &i_m)
{
struct Mods {
Modifier::Type m_mt;
const _TCHAR *m_symbol;
};
const static Mods mods[] = {
{ Modifier::Type_Up, _T("U-") }, { Modifier::Type_Down, _T("D-") },
{ Modifier::Type_Shift, _T("S-") }, { Modifier::Type_Alt, _T("A-") },
{ Modifier::Type_Control, _T("C-") }, { Modifier::Type_Windows, _T("W-") },
{ Modifier::Type_Repeat, _T("R-") },
{ Modifier::Type_ImeLock, _T("IL-") },
{ Modifier::Type_ImeComp, _T("IC-") },
{ Modifier::Type_ImeComp, _T("I-") },
{ Modifier::Type_NumLock, _T("NL-") },
{ Modifier::Type_CapsLock, _T("CL-") },
{ Modifier::Type_ScrollLock, _T("SL-") },
{ Modifier::Type_KanaLock, _T("KL-") },
{ Modifier::Type_Maximized, _T("MAX-") },
{ Modifier::Type_Minimized, _T("MIN-") },
{ Modifier::Type_MdiMaximized, _T("MMAX-") },
{ Modifier::Type_MdiMinimized, _T("MMIN-") },
{ Modifier::Type_Touchpad, _T("T-") },
{ Modifier::Type_TouchpadSticky, _T("TS-") },
{ Modifier::Type_Mod0, _T("M0-") }, { Modifier::Type_Mod1, _T("M1-") },
{ Modifier::Type_Mod2, _T("M2-") }, { Modifier::Type_Mod3, _T("M3-") },
{ Modifier::Type_Mod4, _T("M4-") }, { Modifier::Type_Mod5, _T("M5-") },
{ Modifier::Type_Mod6, _T("M6-") }, { Modifier::Type_Mod7, _T("M7-") },
{ Modifier::Type_Mod8, _T("M8-") }, { Modifier::Type_Mod9, _T("M9-") },
{ Modifier::Type_Lock0, _T("L0-") }, { Modifier::Type_Lock1, _T("L1-") },
{ Modifier::Type_Lock2, _T("L2-") }, { Modifier::Type_Lock3, _T("L3-") },
{ Modifier::Type_Lock4, _T("L4-") }, { Modifier::Type_Lock5, _T("L5-") },
{ Modifier::Type_Lock6, _T("L6-") }, { Modifier::Type_Lock7, _T("L7-") },
{ Modifier::Type_Lock8, _T("L8-") }, { Modifier::Type_Lock9, _T("L9-") },
};
for (size_t i = 0; i < NUMBER_OF(mods); ++ i)
if (!i_m.isDontcare(mods[i].m_mt) && i_m.isPressed(mods[i].m_mt))
i_ost << mods[i].m_symbol;
#if 0
else if (!i_m.isDontcare(mods[i].m_mt) && i_m.isPressed(mods[i].m_mt))
i_ost << _T("~") << mods[i].m_symbol;
else
i_ost << _T("*") << mods[i].m_symbol;
#endif
return i_ost;
}
// get home directory path
void getHomeDirectories(HomeDirectories *o_pathes)
{
tstringi filename;
#ifndef USE_INI
if (getFilenameFromRegistry(NULL, &filename, NULL) &&
!filename.empty()) {
tregex getPath(_T("^(.*[/\\\\])[^/\\\\]*$"));
tsmatch getPathResult;
if (boost::regex_match(filename, getPathResult, getPath))
o_pathes->push_back(getPathResult.str(1));
}
const _TCHAR *home = _tgetenv(_T("HOME"));
if (home)
o_pathes->push_back(home);
const _TCHAR *homedrive = _tgetenv(_T("HOMEDRIVE"));
const _TCHAR *homepath = _tgetenv(_T("HOMEPATH"));
if (homedrive && homepath)
o_pathes->push_back(tstringi(homedrive) + homepath);
const _TCHAR *userprofile = _tgetenv(_T("USERPROFILE"));
if (userprofile)
o_pathes->push_back(userprofile);
_TCHAR buf[GANA_MAX_PATH];
DWORD len = GetCurrentDirectory(NUMBER_OF(buf), buf);
if (0 < len && len < NUMBER_OF(buf))
o_pathes->push_back(buf);
#else //USE_INI
_TCHAR buf[GANA_MAX_PATH];
#endif //USE_INI
if (GetModuleFileName(GetModuleHandle(NULL), buf, NUMBER_OF(buf)))
o_pathes->push_back(pathRemoveFileSpec(buf));
}
bool F_Compose_File_Path(PCHARS szProjFilePath, PCHARS fileExtensionWithDot,
ANSICHAR (&destBuf)[BUF_SIZE])
{
AssertPtr( szProjFilePath );
AssertPtr( destBuf );
StaticAssert( BUF_SIZE > 0 );
// pure name (e.g. "MyProject")
ANSICHAR projName[ 128 ];
V_FileBase( szProjFilePath, projName, NUMBER_OF(projName) );
// path relative to exe (e.g. "Projects/MyProject/")
ANSICHAR projFilePath[ FS_MAX_PATH ];
VRET_FALSE_IF_NOT( V_ExtractFilePath( szProjFilePath, projFilePath, NUMBER_OF(projFilePath) ) );
// path to .INI file relative to exe (e.g. "Projects/MyProject/MyProject.INI")
ANSICHAR outFilePath[ FS_MAX_PATH ];
V_ComposeFileName( projFilePath, projName, outFilePath, NUMBER_OF(outFilePath) );
V_SetExtension( outFilePath, fileExtensionWithDot, NUMBER_OF(outFilePath) );
mxStrCpyNAnsi( destBuf, outFilePath, NUMBER_OF(destBuf) );
return true;
}
static TSTaskInfo*
TSTaskInfo_New(HWND hwnd, ULONG_PTR extra[], int extra_count)
{
TSTaskInfo* self;
self = malloc(sizeof(*self) + sizeof(extra[0]) * (extra_count-1));
if (self == NULL)
return NULL;
self->window = hwnd;
GetWindowText(hwnd, self->title, NUMBER_OF(self->title));
if ((extra != NULL) && (0 < extra_count))
memcpy(self->extra, extra, sizeof(extra[0]) * extra_count);
return self;
}
bool initialize(bool i_isYamy)
{
#ifndef NDEBUG
_TCHAR path[GANA_MAX_PATH];
GetModuleFileName(NULL, path, GANA_MAX_PATH);
_tsplitpath_s(path, NULL, 0, NULL, 0, g.m_moduleName, GANA_MAX_PATH, NULL, 0);
if (_tcsnicmp(g.m_moduleName, _T("Dbgview"), sizeof(_T("Dbgview"))/sizeof(_TCHAR)) != 0 &&
_tcsnicmp(g.m_moduleName, _T("windbg"), sizeof(_T("windbg"))/sizeof(_TCHAR)) != 0) {
g.m_isLogging = true;
}
#endif // !NDEBUG
#ifdef HOOK_LOG_TO_FILE
_TCHAR logFileName[GANA_MAX_PATH];
GetEnvironmentVariable(_T("USERPROFILE"), logFileName, NUMBER_OF(logFileName));
_tcsncat(logFileName, _T("\\AppData\\LocalLow\\yamydll.txt"), _tcslen(_T("\\AppData\\LocalLow\\yamydll.log")));
g.m_logFile = CreateFile(logFileName, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
#endif // HOOK_LOG_TO_FILE
WriteToLog("try to open mailslot\r\n");
g.m_hMailslot =
CreateFile(NOTIFY_MAILSLOT_NAME, GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
(SECURITY_ATTRIBUTES *)NULL, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, (HANDLE)NULL);
if (g.m_hMailslot == INVALID_HANDLE_VALUE) {
HOOK_RPT2("MAYU: %S create mailslot failed(0x%08x)\r\n", g.m_moduleName, GetLastError());
WriteToLog("open mailslot NG\r\n");
} else {
HOOK_RPT1("MAYU: %S create mailslot successed\r\n", g.m_moduleName);
WriteToLog("open mailslot OK\r\n");
}
if (!mapHookData(i_isYamy))
return false;
_tsetlocale(LC_ALL, _T(""));
g.m_WM_MAYU_MESSAGE =
RegisterWindowMessage(addSessionId(WM_MAYU_MESSAGE_NAME).c_str());
g.m_hwndTaskTray = g_hookData->m_hwndTaskTray;
if (!i_isYamy) {
NotifyThreadAttach ntd;
ntd.m_type = Notify::Type_threadAttach;
ntd.m_threadId = GetCurrentThreadId();
notify(&ntd, sizeof(ntd));
}
g.m_isInitialized = true;
return true;
}
/*
--------------------------------------------------------------
BuildOptionsList
--------------------------------------------------------------
*/
void DevBuildOptionsList::ToChars( ANSICHAR *buffer, UINT maxChars )
{
buffer[0] = nil;
const UINT num = this->Num();
for( UINT i=0; i < num; i++ )
{
ANSICHAR temp[64];
mxSPrintfAnsi(
temp, NUMBER_OF(temp), "%s%s",
(*this)[i], (i != num-1) ? ", " : ""
);
mxStrCatAnsi( buffer, temp );
}
}
Modifier::Modifier()
: m_modifiers(0),
m_dontcares(0)
{
ASSERT(Type_end <= (sizeof(MODIFIERS) * 8));
static const Type defaultDontCare[] = {
Type_Up, Type_Down, Type_Repeat,
Type_ImeLock, Type_ImeComp, Type_NumLock, Type_CapsLock, Type_ScrollLock,
Type_KanaLock,
Type_Maximized, Type_Minimized, Type_MdiMaximized, Type_MdiMinimized,
Type_Touchpad, Type_TouchpadSticky,
Type_Lock0, Type_Lock1, Type_Lock2, Type_Lock3, Type_Lock4,
Type_Lock5, Type_Lock6, Type_Lock7, Type_Lock8, Type_Lock9,
};
for (size_t i = 0; i < NUMBER_OF(defaultDontCare); ++ i)
dontcare(defaultDontCare[i]);
}
int main(int argc, char* argv[], char* envp[])
{
int i;
const char *name;
printf("Enum Days elements:\n");
for (i = 0; i < 7; i++)
{
name = ENUM_NAME_AT(Days, i);
if (name)
printf("\t%d) %-10s\n", i, name);
}
printf("\nEnum Number elements:\n");
for (i = 0; i < 11; i++)
{
int pos = ENUM_POS(Numbers, Numbers(i));
if (pos >= 0) {
name = ENUM_NAME(Numbers, Numbers(i));
printf("\t%-10s:\t%d\n", name, i);
} else {
printf(" %d is not a valid item of Enum Numbers\n", i);
}
}
printf("\nEnum Fruits elements:\n");
Fruits value;
for (i = 0; i < NUMBER_OF(Fruits); i++)
{
value = ENUM_VALUE_AT(Fruits, i);
name = ENUM_NAME_AT(Fruits, i);
// printf("\t%d) %-10s:\t%d\n", i, name, value);
name = ENUM_NAME(Fruits, value);
if (name)
{
value = ENUM_VALUE(Fruits, name);
if (value != INVALID_ENUM_ITEM(Fruits))
printf("\t%-10s:\t%d\n", name, value);
}
}
return 0;
}
/*
* getType:
*
* Returns a format/sub-format information. Taken from mp4.h/mp4info.
*/
static void getType(MP4FileHandle file, MP4TrackId trackId, const char **format, const char **subformat )
{
unsigned i;
const char *media_data_name = MP4GetTrackMediaDataName(file, trackId);
*format = _("Audio");
*subformat = _("Unknown");
if (media_data_name == NULL)
{
;
} else if (strcasecmp(media_data_name, "samr") == 0)
{
*subformat = "AMR";
} else if (strcasecmp(media_data_name, "sawb") == 0)
{
*subformat = "AMR-WB";
} else if (strcasecmp(media_data_name, "mp4a") == 0)
{
u_int8_t type = MP4GetTrackEsdsObjectTypeId(file, trackId);
if( type == MP4_MPEG4_AUDIO_TYPE )
{
u_int8_t* pAacConfig = NULL;
u_int32_t aacConfigLength;
MP4GetTrackESConfiguration(file, trackId, &pAacConfig, &aacConfigLength);
if (pAacConfig != NULL)
{
type = aacConfigLength >= 2 ? ((pAacConfig[0] >> 3) & 0x1f) : 0;
free(pAacConfig);
for (i = 0; i < NUMBER_OF(MP4AudioProfileToName); i++)
{
if (type == MP4AudioProfileToName[i].profile)
{
*format = MP4AudioProfileToName[i].format;
*subformat = MP4AudioProfileToName[i].subformat;
return;
}
}
}
static void __cdecl
ThreadDebug__LogEntry(const char* function, void* c, void* m, void* t)
{
if (function != LockMutex && function != UnlockMutex)
{
const unsigned Skip = 0; /* tuned for the scenario to debug */
unsigned Counter = (unsigned)InterlockedIncrement(&ThreadDebug__LogCounter) - 1;
if (Counter > Skip)
{
ThreadDebug__LogEntry_t* entry = &ThreadDebug__Log[(Counter - Skip) % NUMBER_OF(ThreadDebug__Log)];
entry->tm = (unsigned)ReadTimeStampCounter();
entry->tid = GetCurrentThreadId();
entry->f = function;
entry->c = c;
entry->m = m;
entry->t = t;
}
}
}
// WM_COMMAND
BOOL wmCommand(int /* i_notifyCode */, int i_id, HWND /* i_hwndControl */)
{
switch (i_id)
{
case IDOK:
{
wchar_t buf[1024];
GetWindowTextW(GetDlgItem(m_hwnd, IDC_PASSPHRASE), buf, NUMBER_OF(buf));
m_passPhrase = buf;
EndDialog(m_hwnd, 1);
return TRUE;
}
case IDCANCEL:
{
EndDialog(m_hwnd, 0);
return TRUE;
}
}
return FALSE;
}
TS_DefaultSieveProcedure(HWND hwnd, TSTaskList* tasklist)
{
HWND root_owner;
DWORD style;
DWORD exstyle;
int i;
ULONG_PTR extra[1];
hwnd = GetLastActivePopup(hwnd);
style = GetWindowLongPtr(hwnd, GWL_STYLE);
if (!(style & WS_VISIBLE) || (style & WS_DISABLED))
return TRUE;
exstyle = GetWindowLongPtr(hwnd, GWL_EXSTYLE);
if (!( (!(exstyle & WS_EX_TOOLWINDOW))
|| (exstyle & WS_EX_APPWINDOW) ))
{
return TRUE;
}
root_owner = get_root_owner(hwnd);
for (i = 0; i < tasklist->count; i++) {
if (root_owner == (HWND)(tasklist->list[i]->extra[0])) {
tasklist->list[i]->window = hwnd;
GetWindowText( hwnd,
tasklist->list[i]->title,
NUMBER_OF(tasklist->list[i]->title) );
tasklist->list[i]->extra[0] = (ULONG_PTR)root_owner;
return TRUE;
}
}
extra[0] = (ULONG_PTR)root_owner;
return TSTaskList_Append(tasklist, hwnd, extra, 1);
}
