LRESULT CALLBACK AttachGuiWindowCallback(int nCode, WPARAM wParam, LPARAM lParam)
{
if (nCode == HC_ACTION)
{
CWPSTRUCT* p = (CWPSTRUCT*)lParam;
if (p->message == gnAttachMsgId)
{
_ASSERTEX(wParam==1 && p->wParam==gnAttachMsgId);
AttachMsgArg* args = (AttachMsgArg*)p->lParam;
_ASSERTEX(args->MsgId==gnAttachMsgId && args->hConEmu==ghConEmuWnd && args->hProcessed==p->hwnd);
HWND hOurWindow = p->hwnd;
HMENU hMenu = user->getMenu(hOurWindow);
wchar_t szClassName[255]; user->getClassNameW(hOurWindow, szClassName, countof(szClassName));
DWORD nCurStyle = (DWORD)user->getWindowLongPtrW(hOurWindow, GWL_STYLE);
DWORD nCurStyleEx = (DWORD)user->getWindowLongPtrW(hOurWindow, GWL_EXSTYLE);
//BOOL bWasVisible = IsWindowVisible(hOurWindow);
_ASSERTEX(IsWindowVisible(hOurWindow));
OnGuiWindowAttached(hOurWindow, hMenu, NULL, szClassName, nCurStyle, nCurStyleEx, FALSE, SW_SHOW);
args->Result = gnAttachMsgId;
//if (!bWasVisible) // Надо?
// ShowWindow(hOurWindow, SW_SHOW);
}
}
return user->callNextHookEx(ghAttachMsgHook, nCode, wParam, lParam);
}
bool CDefTermHk::isDefaultTerminalAllowed(bool bDontCheckName /*= false*/)
{
_ASSERTEX((gbPrepareDefaultTerminal==false) || ((gpDefTerm!=NULL) && (this==gpDefTerm)));
if (!gbPrepareDefaultTerminal || !this)
{
_ASSERTEX(gbPrepareDefaultTerminal && this);
return false;
}
DWORD nDelta = (GetTickCount() - mn_LastCheck);
if (nDelta > SERIALIZE_CHECK_TIMEOUT)
{
ReloadSettings();
}
// Разрешен ли вообще?
if (!m_Opt.bUseDefaultTerminal)
return false;
// Известны пути?
if (!m_Opt.pszConEmuExe || !*m_Opt.pszConEmuExe || !m_Opt.pszConEmuBaseDir || !*m_Opt.pszConEmuBaseDir)
return false;
// Проверить НАШ exe-шник на наличие в m_Opt.pszzHookedApps
if (!bDontCheckName && !IsAppMonitored(ms_ExeName))
return false;
// Да
return true;
}
RECT AttachGuiClientPos(DWORD anStyle /*= 0*/, DWORD anStyleEx /*= 0*/)
{
//CheckOrigGuiClientRect();
RECT rcPos = {}; // {0,0,grcAttachGuiClientOrig.right-grcAttachGuiClientOrig.left,grcAttachGuiClientOrig.bottom-grcAttachGuiClientOrig.top};
if (ghConEmuWndBack)
{
user->getClientRect(ghConEmuWndBack, &rcPos);
// AttachGuiClientPos may be called from CheckCanCreateWindow
// and ghAttachGuiClient is NULL at this point
_ASSERTEX(ghAttachGuiClient!=NULL || (anStyle||anStyleEx));
DWORD nStyle = (anStyle || anStyleEx) ? anStyle : (DWORD)user->getWindowLongPtrW(ghAttachGuiClient, GWL_STYLE);
DWORD nStyleEx = (anStyle || anStyleEx) ? anStyleEx : (DWORD)user->getWindowLongPtrW(ghAttachGuiClient, GWL_EXSTYLE);
CorrectGuiChildRect(nStyle, nStyleEx, rcPos);
}
else
{
_ASSERTEX(ghConEmuWndBack!=NULL);
_ASSERTEX(ghAttachGuiClient!=NULL);
user->getWindowRect(ghConEmuWndBack, &rcPos);
}
return rcPos;
}
void MSection::Unlock(BOOL abExclusive)
{
DWORD dwTID = GetCurrentThreadId();
if (abExclusive)
{
//Process_Lock();
_ASSERTEX(mn_TID == dwTID && mb_Exclusive);
_ASSERTEX(mn_LockedTID[0] == dwTID);
#ifdef _DEBUG
mn_UnlockedExclusiveTID = dwTID;
#endif
mb_Exclusive = FALSE; mn_TID = 0;
mn_LockedTID[0] = 0;
if (mn_LockedCount[0] > 0)
{
mn_LockedCount[0] --; // на [0] mn_Locked не распространяется
}
else
{
_ASSERTEX(mn_LockedCount[0]>0);
}
m_cs.Leave();
//Process_Unlock();
}
else
{
ReleaseRef(dwTID);
}
}
BOOL MSectionLockSimple::Lock(MSectionSimple* apS, DWORD anTimeout/*=-1*/)
{
if (mb_Locked && (mp_S != apS))
Unlock();
mp_S = apS;
if (!mp_S)
{
_ASSERTEX(apS);
return FALSE;
}
_ASSERTEX(!mb_Locked);
_ASSERTEX(apS->IsInitialized());
bool bLocked = false;
DWORD nStartTick = GetTickCount();
DWORD nDelta = -1;
#if 0
EnterCriticalS ection(&apS->m_S);
bLocked = mb_Locked = true;
nDelta = GetTickCount() - nStartTick;
if (nDelta >= anTimeout)
{
_ASSERTEX(FALSE && "Failed to lock CriticalSection, timeout");
}
#else
while (true)
{
if (apS->TryEnter())
{
bLocked = mb_Locked = true;
#ifdef _DEBUG
mn_LockTID = GetCurrentThreadId();
mn_LockTick = GetTickCount();
#endif
break;
}
nDelta = GetTickCount() - nStartTick;
if (anTimeout != (DWORD)-1)
{
if (nDelta >= anTimeout)
{
_ASSERTEX(FALSE && "Failed to lock CriticalSection, timeout");
break;
}
}
Sleep(1);
}
#endif
return bLocked;
}
void MSection::AddRef(DWORD dwTID)
{
Process_Lock();
#ifdef _DEBUG
int dbgCurLockCount = 0;
if (mn_Locked == 0)
{
for (int d=1; d<countof(mn_LockedCount); d++)
{
_ASSERTE(mn_LockedCount[d]>=0);
dbgCurLockCount += mn_LockedCount[d];
}
if (dbgCurLockCount != 0)
{
_ASSERTEX(dbgCurLockCount==0 || mn_Locked);
}
}
#endif
mn_Locked ++; // увеличиваем счетчик nonexclusive locks
_ASSERTEX(mn_Locked>0);
ResetEvent(mh_ReleaseEvent); // На всякий случай сбросим Event
INT_PTR j = -1; // будет -2, если ++ на существующий, иначе - +1 на пустой
for (size_t i = 1; i < countof(mn_LockedTID); i++)
{
if (mn_LockedTID[i] == dwTID)
{
_ASSERTE(mn_LockedCount[i]>=0);
mn_LockedCount[i] ++;
j = -2;
break;
}
}
if (j == -1)
{
for (size_t i = 1; i < countof(mn_LockedTID); i++)
{
if (mn_LockedTID[i] == 0)
{
mn_LockedTID[i] = dwTID;
_ASSERTE(mn_LockedCount[i]>=0);
mn_LockedCount[i] ++;
j = i;
break;
}
}
}
if (j == -1) // Этого быть не должно
{
_ASSERTEX(j != -1);
}
Process_Unlock();
}
HWND CDefTermHk::AllocHiddenConsole(bool bTempForVS)
{
// функция AttachConsole есть только в WinXP и выше
AttachConsole_t _AttachConsole = GetAttachConsoleProc();
if (!_AttachConsole)
{
LogHookingStatus(L"Can't create hidden console, function does not exist");
return NULL;
}
LogHookingStatus(L"AllocHiddenConsole");
ReloadSettings();
_ASSERTEX(isDefTermEnabled() && (gbIsNetVsHost || bTempForVS));
if (!isDefTermEnabled())
{
// Disabled in settings or registry
LogHookingStatus(L"Application skipped by settings");
return NULL;
}
HANDLE hSrvProcess = NULL;
DWORD nAttachPID = bTempForVS ? 0 : gnSelfPID;
DWORD nSrvPID = StartConsoleServer(nAttachPID, true, &hSrvProcess);
if (!nSrvPID)
{
// Failed to start process?
return NULL;
}
_ASSERTEX(hSrvProcess!=NULL);
HWND hCreatedCon = NULL;
// Do while server process is alive
DWORD nStart = GetTickCount(), nMaxDelta = 30000, nDelta = 0;
DWORD nWait = WaitForSingleObject(hSrvProcess, 0);
while (nWait != WAIT_OBJECT_0)
{
if (_AttachConsole(nSrvPID))
{
hCreatedCon = GetRealConsoleWindow();
if (hCreatedCon)
break;
}
nWait = WaitForSingleObject(hSrvProcess, 150);
nDelta = (GetTickCount() - nStart);
if (nDelta > nMaxDelta)
break;
}
return hCreatedCon;
}
int MSection::ReleaseRef(DWORD dwTID)
{
Process_Lock();
_ASSERTEX(mn_Locked>0);
int nInThreadLeft = 0;
if (mn_Locked > 0)
mn_Locked --;
if (mn_Locked == 0)
{
SetEvent(mh_ReleaseEvent); // Больше nonexclusive locks не осталось
}
for (size_t i = 1; i < countof(mn_LockedTID); i++)
{
if (mn_LockedTID[i] == dwTID)
{
if (mn_LockedCount[i] > 0)
{
mn_LockedCount[i] --;
}
else
{
_ASSERTEX(mn_LockedCount[i] > 0);
}
if ((nInThreadLeft = mn_LockedCount[i]) == 0)
mn_LockedTID[i] = 0; // Иначе при динамически создаваемых нитях - 10 будут в момент использованы
break;
}
}
if (mn_Locked == 0)
{
#ifdef _DEBUG
int dbgCurLockCount = 0;
for (int d=1; d<countof(mn_LockedCount); d++)
{
_ASSERTEX(mn_LockedCount[d]>=0);
dbgCurLockCount += mn_LockedCount[d];
}
if (dbgCurLockCount != 0)
{
_ASSERTEX(dbgCurLockCount==0);
}
#endif
}
Process_Unlock();
return nInThreadLeft;
}
void OnConWndChanged(HWND ahNewConWnd)
{
//BOOL lbForceReopen = FALSE;
if (ahNewConWnd)
{
#ifdef _DEBUG
if (user)
{
wchar_t sClass[64]; user->getClassNameW(ahNewConWnd, sClass, countof(sClass));
_ASSERTEX(isConsoleClass(sClass));
}
#endif
if (ghConWnd != ahNewConWnd)
{
ghConWnd = ahNewConWnd;
//lbForceReopen = TRUE;
}
}
else
{
//lbForceReopen = TRUE;
}
GetConMap(TRUE);
}
void CTabPanelWin::ShowToolbar(bool bShow)
{
if (bShow)
{
if (!IsToolbarCreated() && (CreateToolbar() != NULL))
{
REBARBANDINFO rbBand = {80}; // не используем size, т.к. приходит "новый" размер из висты и в XP обламываемся
rbBand.fMask = RBBIM_SIZE | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_ID | RBBIM_STYLE | RBBIM_COLORS;
rbBand.fStyle = RBBS_CHILDEDGE | RBBS_FIXEDSIZE | RBBS_VARIABLEHEIGHT;
rbBand.clrBack = GetSysColor(COLOR_BTNFACE);
rbBand.clrFore = GetSysColor(COLOR_BTNTEXT);
SIZE sz = {0,0};
SendMessage(mh_Toolbar, TB_GETMAXSIZE, 0, (LPARAM)&sz);
// Set values unique to the band with the toolbar.
rbBand.wID = 2;
rbBand.hwndChild = mh_Toolbar;
rbBand.cx = rbBand.cxMinChild = rbBand.cxIdeal = mn_LastToolbarWidth = sz.cx;
rbBand.cyChild = rbBand.cyMinChild = rbBand.cyMaxChild = sz.cy + mn_ThemeHeightDiff;
// Add the band that has the toolbar.
if (!SendMessage(mh_Rebar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand))
{
DisplayLastError(_T("Can't initialize rebar (toolbar)"));
}
}
}
else
{
_ASSERTEX(bShow);
}
}
BOOL WINAPI OnSetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode)
{
//typedef BOOL (WINAPI* OnSetConsoleMode_t)(HANDLE hConsoleHandle, DWORD dwMode);
ORIGINAL_KRNL(SetConsoleMode);
BOOL lbRc = FALSE;
#if 0
if (!(dwMode & ENABLE_PROCESSED_OUTPUT))
{
_ASSERTEX((dwMode & ENABLE_PROCESSED_OUTPUT)==ENABLE_PROCESSED_OUTPUT);
}
#endif
if (gbIsVimProcess)
{
if ((dwMode & (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)) != (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT))
{
if (CEAnsi::IsOutputHandle(hConsoleHandle))
{
dwMode |= ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT;
}
else
{
dwMode |= ENABLE_WINDOW_INPUT;
}
}
}
lbRc = F(SetConsoleMode)(hConsoleHandle, dwMode);
return lbRc;
}
void MSectionLock::Unlock()
{
if (mp_S && mb_Locked)
{
#ifdef _DEBUG
DWORD nCurTID = GetCurrentThreadId();
wchar_t szDbg[80];
if (mb_Exclusive)
msprintf(szDbg, countof(szDbg), L"::Unlock(), TID=%u\n", nCurTID);
else
szDbg[0] = 0;
#endif
_ASSERTEX(mb_Exclusive || mp_S->mn_Locked>0);
mp_S->Unlock(mb_Exclusive);
mb_Locked = FALSE;
#ifdef _DEBUG
if (*szDbg)
{
DebugString(szDbg);
}
#endif
}
}
void MSection::WaitUnlocked(DWORD dwTID, DWORD anTimeout)
{
DWORD dwStartTick = GetTickCount();
int nSelfCount = 0;
for (size_t i = 1; i < countof(mn_LockedTID); i++)
{
if (mn_LockedTID[i] == dwTID)
{
_ASSERTEX(mn_LockedCount[i]>=0);
nSelfCount = mn_LockedCount[i];
break;
}
}
while(mn_Locked > nSelfCount)
{
#ifdef _DEBUG
DEBUGSTR(L"!!! Waiting for exclusive access\n");
DWORD nWait =
#endif
WaitForSingleObject(mh_ReleaseEvent, 10);
DWORD dwCurTick = GetTickCount();
DWORD dwDelta = dwCurTick - dwStartTick;
if (anTimeout != (DWORD)-1)
{
if (dwDelta > anTimeout)
{
#ifndef CSECTION_NON_RAISE
_ASSERTEX(dwDelta<=anTimeout);
#endif
break;
}
}
#ifdef _DEBUG
else if (dwDelta > 3000)
{
#ifndef CSECTION_NON_RAISE
_ASSERTEX(dwDelta <= 3000);
#endif
break;
}
#endif
}
}
bool FileExistsSearch(LPCWSTR asFilePath, CmdArg& rsFound, bool abSetPath/*= true*/, bool abRegSearch /*= true*/)
{
if (!asFilePath || !*asFilePath)
{
_ASSERTEX(asFilePath && *asFilePath);
return false;
}
if (FileExists(asFilePath))
{
return true;
}
// Развернуть переменные окружения
if (wcschr(asFilePath, L'%'))
{
bool bFound = false;
wchar_t* pszExpand = ExpandEnvStr(asFilePath);
if (pszExpand && FileExists(pszExpand))
{
// asFilePath will be invalid after .Set
rsFound.Set(pszExpand);
bFound = true;
}
SafeFree(pszExpand);
if (bFound)
{
return true;
}
}
// Search "Path"
if (FileSearchInDir(asFilePath, rsFound))
{
return true;
}
// Только если приложение не нашли "по путям" - пытаемся определить его расположение через [App Paths]
// В противном случае, в частности, может быть запущен "far" не из папки с ConEmu, а зарегистрированный
// в реестре, если на машине их несколько установлено.
#if !defined(CONEMU_MINIMAL)
// В ConEmuHk этот блок не активен, потому что может быть "только" перехват CreateProcess,
// а о его параметрах должно заботиться вызывающее (текущее) приложение
if (abRegSearch && !wcschr(asFilePath, L'\\'))
{
// Если в asFilePath НЕ указан путь - искать приложение в реестре,
// и там могут быть указаны доп. параметры (пока только добавка в %PATH%)
if (SearchAppPaths(asFilePath, rsFound, abSetPath))
{
// Нашли по реестру, возможно обновили %PATH%
return true;
}
}
#endif
return false;
}
void UnregisterLdrNotification()
{
if (gbLdrDllNotificationUsed)
{
_ASSERTEX(LdrUnregisterDllNotification!=NULL);
LdrUnregisterDllNotification(gpLdrDllNotificationCookie);
}
}
void CheckOrigGuiClientRect()
{
if (grcAttachGuiClientOrig.left==grcAttachGuiClientOrig.right && grcAttachGuiClientOrig.bottom==grcAttachGuiClientOrig.top)
{
_ASSERTEX(ghAttachGuiClient!=NULL);
user->getWindowRect(ghAttachGuiClient, &grcAttachGuiClientOrig);
}
}
BOOL GetConsoleModeCached(HANDLE hConsoleHandle, LPDWORD lpMode, BOOL bForced /*= FALSE*/)
{
BOOL lbRc = FALSE;
static DWORD s_LastCheckTick = 0;
static DWORD s_dwMode = 0;
static HANDLE s_hConHandle = NULL;
DWORD nTickDelta = 0;
const DWORD TickDeltaMax = 250;
if (hConsoleHandle == NULL)
{
// Сброс
s_hConHandle = NULL;
return FALSE;
}
if (!lpMode)
{
_ASSERTEX(lpMode!=NULL);
return FALSE;
}
if (s_hConHandle && (s_hConHandle == hConsoleHandle))
{
nTickDelta = GetTickCount() - s_LastCheckTick;
if (nTickDelta <= TickDeltaMax)
{
if (bForced)
{
#ifdef _DEBUG
lbRc = FALSE;
#endif
}
else
{
*lpMode = s_dwMode;
lbRc = TRUE;
}
}
}
if (!lbRc)
{
DWORD dwMode = 0;
lbRc = GetConsoleMode(hConsoleHandle, &dwMode);
*lpMode = dwMode;
if (lbRc)
{
s_dwMode = dwMode;
s_LastCheckTick = GetTickCount();
s_hConHandle = hConsoleHandle;
}
}
return lbRc;
}
// GetConsoleWindow хукается, поэтому, для получения реального консольного окна
// можно дергать эту экспортируемую функцию
HWND WINAPI GetRealConsoleWindow()
{
_ASSERTE(gfGetRealConsoleWindow);
HWND hConWnd = gfGetRealConsoleWindow ? gfGetRealConsoleWindow() : NULL; //GetConsoleWindow();
#ifdef _DEBUG
wchar_t sClass[64]; user->getClassNameW(hConWnd, sClass, countof(sClass));
_ASSERTEX(hConWnd==NULL || isConsoleClass(sClass));
#endif
return hConWnd;
}
bool MSection::isLockedExclusive()
{
if (!this || !mb_Exclusive)
return false;
DWORD nTID = GetCurrentThreadId();
if (mn_LockedTID[0] != nTID)
return false;
_ASSERTEX(mn_LockedCount[0] > 0);
return (mn_LockedCount[0] > 0);
}
void AttachGuiWindow(HWND hOurWindow)
{
_ASSERTEX(gbAttachGuiClient); // Уже должен был быть установлен?
gnAttachMsgId = RegisterWindowMessageW(L"ConEmu:Attach2Gui");
if (gnAttachMsgId)
{
DWORD nWndTID = GetWindowThreadProcessId(hOurWindow, NULL);
ghAttachMsgHook = SetWindowsHookExW(WH_CALLWNDPROC, AttachGuiWindowCallback, NULL, nWndTID);
// Поскольку аттач хорошо бы выполнять в той нити, в которой крутится окно - то через хук
AttachMsgArg args = {gnAttachMsgId, 0, ghConEmuWnd, hOurWindow};
LRESULT lRc = SendMessageW(hOurWindow, gnAttachMsgId, gnAttachMsgId, (LPARAM)&args);
_ASSERTEX(args.Result == gnAttachMsgId);
UNREFERENCED_PARAMETER(lRc);
UnhookWindowsHookEx(ghAttachMsgHook);
ghAttachMsgHook = NULL;
}
}
bool MSectionSimple::TryEnter()
{
_ASSERTEX(mb_Initialized);
BOOL brc = TryEnterCriticalSection(&m_S);
if (!brc)
{
mn_LastError = GetLastError();
return false;
}
return true;
}
void CDefTermHk::OnAllocConsoleFinished()
{
if (!gbPrepareDefaultTerminal || !this)
{
_ASSERTEX((gbPrepareDefaultTerminal && gpDefTerm) && "Must be called in DefTerm mode only");
return;
}
if (!ghConWnd || !IsWindow(ghConWnd))
{
LogHookingStatus(L"OnAllocConsoleFinished: ghConWnd must be initialized already!");
_ASSERTEX(FALSE && "ghConWnd must be initialized already!");
return;
}
ReloadSettings();
_ASSERTEX(isDefTermEnabled() && gbIsNetVsHost);
if (!isDefTermEnabled())
{
// Disabled in settings or registry
LogHookingStatus(L"OnAllocConsoleFinished: !isDefTermEnabled()");
return;
}
// По идее, после AllocConsole окно RealConsole всегда видимо
BOOL bConWasVisible = IsWindowVisible(ghConWnd);
_ASSERTEX(bConWasVisible);
// Чтобы минимизировать "мелькания" - сразу спрячем его
ShowWindow(ghConWnd, SW_HIDE);
LogHookingStatus(L"Console window was hidden");
if (!StartConsoleServer(gnSelfPID, false, NULL))
{
if (bConWasVisible)
ShowWindow(ghConWnd, SW_SHOW);
LogHookingStatus(L"Starting attach server failed?");
}
}
BOOL MSectionLock::Lock(MSection* apS, BOOL abExclusive/*=FALSE*/, DWORD anTimeout/*=-1*/)
{
if (!apS)
return FALSE;
if (mb_Locked && apS == mp_S && (abExclusive == mb_Exclusive || mb_Exclusive))
return TRUE; // уже заблокирован //111126 - возвращался FALSE
_ASSERTEX(!mb_Locked);
mb_Exclusive = (abExclusive!=FALSE);
mp_S = apS;
mb_Locked = mp_S->Lock(mb_Exclusive, anTimeout);
return mb_Locked;
}
MSection::MSection()
{
mn_TID = 0; mn_Locked = 0; mb_Exclusive = FALSE;
#ifdef _DEBUG
mn_UnlockedExclusiveTID = 0;
#endif
ZeroStruct(mn_LockedTID); ZeroStruct(mn_LockedCount);
m_cs.Init();
m_lock_cs.Init();
mh_ReleaseEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
_ASSERTEX(mh_ReleaseEvent!=NULL);
if (mh_ReleaseEvent) ResetEvent(mh_ReleaseEvent);
mh_ExclusiveThread = NULL;
}
BOOL MSectionLock::RelockExclusive(DWORD anTimeout/*=-1*/)
{
if (!mp_S)
{
_ASSERTEX(mp_S!=NULL);
return FALSE;
}
if (mb_Locked && mb_Exclusive)
return TRUE; // уже
// Чистый ReLock делать нельзя. Виснут другие нити, которые тоже запросили ReLock
Unlock();
mb_Exclusive = TRUE;
mb_Locked = mp_S->Lock(mb_Exclusive, anTimeout);
return mb_Locked;
}
MSectionLock::~MSectionLock()
{
_ASSERTEX((mb_Locked==FALSE || mb_Locked==TRUE) && (mb_Exclusive==FALSE || mb_Exclusive==TRUE));
if (mb_Locked)
{
DWORD nCurTID = GetCurrentThreadId();
Unlock();
#ifdef _DEBUG
wchar_t szDbg[80];
msprintf(szDbg, countof(szDbg), L"::~MSectionLock, TID=%u\n", nCurTID);
DebugString(szDbg);
#endif
UNREFERENCED_PARAMETER(nCurTID);
}
}
void MSection::ThreadTerminated(DWORD dwTID)
{
for (size_t i = 1; i < countof(mn_LockedTID); i++)
{
if (mn_LockedTID[i] == dwTID)
{
mn_LockedTID[i] = 0;
if (mn_LockedCount[i] != 0)
{
_ASSERTEX(mn_LockedCount[i] == 0);
}
break;
}
}
}
bool InitHooksKernel()
{
HLOG1("InitHooksKernel",0);
bool lbRc = false;
HookItem HooksKernel[] =
{
/* ************************ */
HOOK_ITEM_BY_NAME(OpenFileMappingW, kernel32),
HOOK_ITEM_BY_NAME(MapViewOfFile, kernel32),
HOOK_ITEM_BY_NAME(UnmapViewOfFile, kernel32),
/* ************************ */
HOOK_ITEM_BY_NAME(SetEnvironmentVariableA, kernel32),
HOOK_ITEM_BY_NAME(SetEnvironmentVariableW, kernel32),
HOOK_ITEM_BY_NAME(GetEnvironmentVariableA, kernel32),
HOOK_ITEM_BY_NAME(GetEnvironmentVariableW, kernel32),
#if 0
HOOK_ITEM_BY_NAME(GetEnvironmentStringsA, kernel32),
#endif
HOOK_ITEM_BY_NAME(GetEnvironmentStringsW, kernel32),
/* ************************ */
HOOK_ITEM_BY_NAME(GetSystemTime, kernel32),
HOOK_ITEM_BY_NAME(GetLocalTime, kernel32),
HOOK_ITEM_BY_NAME(GetSystemTimeAsFileTime, kernel32),
/* ************************ */
HOOK_ITEM_BY_NAME(Beep, kernel32),
/* ************************ */
{0}
};
if (InitHooks(HooksKernel) < 0)
goto wrap;
#if 0
// Проверка, как реагирует на дубли
HooksCommon[1].NewAddress = NULL;
_ASSERTEX(FALSE && "Testing");
InitHooks(HooksCommon);
#endif
lbRc = true;
wrap:
HLOGEND1();
return lbRc;
}
BOOL WINAPI OnSetConsoleMode(HANDLE hConsoleHandle, DWORD dwMode)
{
//typedef BOOL (WINAPI* OnSetConsoleMode_t)(HANDLE hConsoleHandle, DWORD dwMode);
ORIGINAL_KRNL(SetConsoleMode);
BOOL lbRc = FALSE;
#if 0
if (!(dwMode & ENABLE_PROCESSED_OUTPUT))
{
_ASSERTEX((dwMode & ENABLE_PROCESSED_OUTPUT)==ENABLE_PROCESSED_OUTPUT);
}
#endif
if (gbIsVimProcess)
{
if ((dwMode & (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT)) != (ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT))
{
if (HandleKeeper::IsOutputHandle(hConsoleHandle))
{
dwMode |= ENABLE_WRAP_AT_EOL_OUTPUT|ENABLE_PROCESSED_OUTPUT;
}
else
{
dwMode |= ENABLE_WINDOW_INPUT;
}
}
}
#ifdef _DEBUG
if ((gnExeFlags & (caf_Cygwin1|caf_Msys1|caf_Msys2))
&& (dwMode & ENABLE_PROCESSED_INPUT)
&& !HandleKeeper::IsOutputHandle(hConsoleHandle))
{
//_ASSERTE(!(dwMode & ENABLE_PROCESSED_INPUT));
wchar_t szLog[120];
msprintf(szLog, countof(szLog), L"\r\n\033[31;40m{PID:%u} Process is enabling ENABLE_PROCESSED_INPUT\033[m\r\n", GetCurrentProcessId());
//WriteProcessed2(szLog, lstrlen(szLog), NULL, wps_Error);
szLog[0] = 0;
}
#endif
lbRc = F(SetConsoleMode)(hConsoleHandle, dwMode);
return lbRc;
}
void CTabPanelWin::ShowToolsPane(bool bShow)
{
if (bShow)
{
_ASSERTE(isMainThread());
if (!IsToolbarCreated() && (CreateToolbar() != NULL))
{
REBARBANDINFO rbBand = {REBARBANDINFO_SIZE}; // не используем size, т.к. приходит "новый" размер из висты и в XP обламываемся
rbBand.fMask = RBBIM_SIZE | RBBIM_CHILD | RBBIM_CHILDSIZE | RBBIM_ID | RBBIM_STYLE;
rbBand.fStyle = RBBS_CHILDEDGE | RBBS_FIXEDSIZE | RBBS_VARIABLEHEIGHT;
#if 0
rbBand.fMask |= RBBIM_COLORS;
rbBand.clrFore = RGB(255,255,255);
rbBand.clrBack = RGB(0,0,255);
#endif
SIZE sz = {0,0};
SendMessage(mh_Toolbar, TB_GETMAXSIZE, 0, (LPARAM)&sz);
rbBand.wID = rbi_ToolBar;
rbBand.hwndChild = mh_Toolbar;
rbBand.cx = rbBand.cxMinChild = rbBand.cxIdeal = mn_LastToolbarWidth = sz.cx;
rbBand.cyChild = rbBand.cyMinChild = rbBand.cyMaxChild = sz.cy + mn_ThemeHeightDiff;
if (!SendMessage(mh_Rebar, RB_INSERTBAND, (WPARAM)-1, (LPARAM)&rbBand))
{
DisplayLastError(_T("Can't initialize rebar (toolbar)"));
}
}
}
else
{
_ASSERTEX(!bShow);
INT_PTR nPaneIndex = SendMessage(mh_Rebar, RB_IDTOINDEX, rbi_ToolBar, 0);
if (nPaneIndex >= 0)
{
SendMessage(mh_Rebar, RB_DELETEBAND, nPaneIndex, 0);
DestroyWindow(mh_Toolbar);
mh_Toolbar = NULL;
}
}
}
