static void locinfo_cleanup(LocInfo *l)
{
ZeroStruct(l);
}
//
// IDataObject::SetData
//
HRESULT __stdcall CDataObject::SetData(FORMATETC *pFormatEtc, STGMEDIUM *pMedium, BOOL fRelease)
{
_ASSERTE(pMedium && pMedium->pUnkForRelease==NULL);
#ifdef _DEBUG
LPCWSTR pszName = GetFormatName(pFormatEtc->cfFormat, true);
DWORD nData = (DWORD)-1;
if (lstrcmp(pszName, L"IsShowingLayered")==0
|| lstrcmp(pszName, L"IsShowingText")==0
|| lstrcmp(pszName, L"DragContext")==0
|| lstrcmp(pszName, L"UsingDefaultDragImage")==0
|| lstrcmp(pszName, L"DragSourceHelperFlags")==0
|| lstrcmp(pszName, L"DragWindow")==0
|| lstrcmp(pszName, L"DisableDragText")==0
)
{
LPDWORD pdw = (LPDWORD)GlobalLock(pMedium->hGlobal);
if (pdw)
{
nData = *pdw;
}
GlobalUnlock(pMedium->hGlobal);
}
wchar_t szDbg[255];
_wsprintf(szDbg, SKIPLEN(countof(szDbg)) L"CDataObject::SetData {cfFormat=%s, lindex=%i, tymed=x%02X(%u)}, {tymed=x%02X}",
GetFormatName(pFormatEtc->cfFormat), pFormatEtc->lindex, pFormatEtc->tymed, pFormatEtc->tymed, pMedium->tymed);
if (nData != (DWORD)-1)
{
int nLen = lstrlen(szDbg);
_wsprintf(szDbg+nLen, SKIPLEN(countof(szDbg)-nLen) L", Data=x%02X(%u)", nData, nData);
}
wcscat_c(szDbg, L"\n");
DEBUGSTRDATA(szDbg);
#endif
DEBUGTEST(bool bNew = false);
LONG nIndex = LookupFormatEtc(pFormatEtc);
if (nIndex >= 0)
{
if ((pMedium != &(m_Data[nIndex].StgMedium)) && (pMedium->hGlobal != &(m_Data[nIndex].StgMedium)))
{
if (m_Data[nIndex].fRelease)
{
ReleaseStgMedium(&m_Data[nIndex].StgMedium);
}
else
{
ZeroStruct(m_Data[nIndex].StgMedium);
}
}
else
{
Assert((pMedium != &(m_Data[nIndex].StgMedium)) && (pMedium->hGlobal != &(m_Data[nIndex].StgMedium)));
}
}
else // if (nIndex < 0)
{
DEBUGTEST(bNew = true);
_ASSERTE(nIndex < 0);
DragData newItem = {};
newItem.FormatEtc = *pFormatEtc;
nIndex = m_Data.push_back(newItem);
}
m_Data[nIndex].fUsed = TRUE;
m_Data[nIndex].fRelease = fRelease;
m_Data[nIndex].StgMedium = *pMedium;
return S_OK;
}
bool CConEmuInside::GetInsideRect(RECT* prWnd)
{
RECT rcWnd = {};
if (m_InsideIntegration == ii_None)
{
_ASSERTE(m_InsideIntegration != ii_None);
return false;
}
RECT rcParent = {}, rcRelative = {};
GetClientRect(mh_InsideParentWND, &rcParent);
if (m_InsideIntegration == ii_Simple)
{
mrc_InsideParent = rcParent;
ZeroStruct(mrc_InsideParentRel);
rcWnd = rcParent;
}
else
{
RECT rcChild = {};
GetWindowRect(mh_InsideParentRel, &rcChild);
MapWindowPoints(NULL, mh_InsideParentWND, (LPPOINT)&rcChild, 2);
mrc_InsideParent = rcParent;
mrc_InsideParentRel = rcChild;
IntersectRect(&rcRelative, &rcParent, &rcChild);
// WinXP & Win2k3
if (gnOsVer < 0x600)
{
rcWnd = rcRelative;
}
// Windows 7
else if ((rcParent.bottom - rcRelative.bottom) >= 100)
{
// Предпочтительно
// Далее - ветвимся по OS
if (gnOsVer < 0x600)
{
rcWnd = MakeRect(rcRelative.left, rcRelative.bottom + 4, rcParent.right, rcParent.bottom);
}
else
{
rcWnd = MakeRect(rcParent.left, rcRelative.bottom + 4, rcParent.right, rcParent.bottom);
}
}
else if ((rcParent.right - rcRelative.right) >= 200)
{
rcWnd = MakeRect(rcRelative.right + 4, rcRelative.top, rcParent.right, rcRelative.bottom);
}
else
{
TODO("Другие системы и проверки на валидность");
rcWnd = MakeRect(rcParent.left, rcParent.bottom - 100, rcParent.right, rcParent.bottom);
}
}
if (prWnd)
*prWnd = rcWnd;
return true;
}
LibxmlXmlException::LibxmlXmlException(xmlError *err)
: base(MAKE_HRESULT(SEVERITY_ERROR, FACILITY_LIBXML, err->code), err->message)
{
ZeroStruct(m_xmlError);
XmlCheck(xmlCopyError(err, &m_xmlError));
}
LibxmlXmlException::LibxmlXmlException(const LibxmlXmlException& e) {
ZeroStruct(m_xmlError);
XmlCheck(xmlCopyError(const_cast<xmlError*>(&e.m_xmlError), &m_xmlError));
}
bool CPluginW2800::UpdateConEmuTabsApi(int windowCount)
{
if (!InfoW2800 || !InfoW2800->AdvControl || gbIgnoreUpdateTabs)
return false;
bool lbCh = false, lbDummy = false;
WindowInfo WInfo = {sizeof(WindowInfo)};
wchar_t szWNameBuffer[CONEMUTABMAX];
int tabCount = 0;
bool lbActiveFound = false;
_ASSERTE(GetCurrentThreadId() == gnMainThreadId);
WindowInfo WActive = {sizeof(WActive)};
WActive.Pos = -1;
bool bActiveInfo = InfoW2800->AdvControl(&guid_ConEmu, ACTL_GETWINDOWINFO, 0, &WActive)!=0;
// Если фар запущен с ключом "/e" (как standalone редактор) - будет ассерт при первой попытке
// считать информацию об окне (редактор еще не создан?, а панелей вообще нет)
_ASSERTE(bActiveInfo && (WActive.Flags & WIF_CURRENT));
static WindowInfo WLastActive;
if (!pwList)
pwList = new MArray<WindowInfo>();
// Another weird Far API breaking change. How more?..
MArray<WindowInfo> wCurrent;
// Load window list
for (int i = 0; i < windowCount; i++)
{
ZeroStruct(WInfo);
WInfo.StructSize = sizeof(WInfo);
WInfo.Pos = i;
if (!InfoW2800->AdvControl(&guid_ConEmu, ACTL_GETWINDOWINFO, 0, &WInfo))
continue;
if (WInfo.Type != WTYPE_EDITOR && WInfo.Type != WTYPE_VIEWER && WInfo.Type != WTYPE_PANELS)
continue;
if (WInfo.Type == WTYPE_PANELS)
{
if ((wCurrent.size() > 0) && (wCurrent[0].Type == WTYPE_PANELS))
wCurrent[0] = WInfo;
else
wCurrent.insert(0, WInfo);
}
else
{
wCurrent.push_back(WInfo);
}
}
// Clear closed windows
for (INT_PTR i = 0; i < pwList->size();)
{
const WindowInfo& L = (*pwList)[i];
INT_PTR iFound = WExists(L, wCurrent);
if (iFound < 0)
pwList->erase(i);
else
i++;
}
// Add new windows
for (INT_PTR i = 0; i < wCurrent.size(); i++)
{
const WindowInfo& C = wCurrent[i];
INT_PTR iFound = WExists(C, *pwList);
if (iFound >= 0)
{
(*pwList)[iFound] = C;
}
else
{
if (C.Type == WTYPE_PANELS)
{
if ((pwList->size() > 0) && ((*pwList)[0].Type == WTYPE_PANELS))
(*pwList)[0] = C;
else
pwList->insert(0, C);
}
else
{
pwList->push_back(C);
}
}
}
// And check the count
windowCount = pwList->size();
// Проверить, есть ли активный редактор/вьювер/панель
if (bActiveInfo && (WActive.Type == WTYPE_EDITOR || WActive.Type == WTYPE_VIEWER || WActive.Type == WTYPE_PANELS))
{
if (!(WActive.Flags & WIF_MODAL))
WLastActive = WActive;
}
else
{
int nTabs = 0, nModalTabs = 0;
bool bFound = false;
WindowInfo WModal, WFirst;
// Поскольку в табах диалоги не отображаются - надо подменить "активное" окно
// т.е. предпочитаем тот таб, который был активен ранее
for (int i = 0; i < windowCount; i++)
{
WInfo = (*pwList)[i];
_ASSERTE(WInfo.Type == WTYPE_EDITOR || WInfo.Type == WTYPE_VIEWER || WInfo.Type == WTYPE_PANELS);
if (!nTabs)
WFirst = WInfo;
nTabs++;
if (WInfo.Flags & WIF_MODAL)
{
nModalTabs++;
WModal = WInfo;
}
if (WLastActive.StructSize && (WInfo.Type == WLastActive.Type) && (WInfo.Id == WLastActive.Id))
{
bActiveInfo = bFound = true;
WActive = WInfo;
}
}
if (!bFound)
{
if (nModalTabs)
{
bActiveInfo = true;
WActive = WModal;
}
else if (nTabs)
{
bActiveInfo = true;
WActive = WFirst;
}
}
}
for (int i = 0; i < windowCount; i++)
{
WInfo = (*pwList)[i];
if (WInfo.Type == WTYPE_EDITOR || WInfo.Type == WTYPE_VIEWER || WInfo.Type == WTYPE_PANELS)
{
WInfo.Name = szWNameBuffer;
WInfo.NameSize = CONEMUTABMAX;
InfoW2800->AdvControl(&guid_ConEmu, ACTL_GETWINDOWINFO, 0, &WInfo);
WARNING("Для получения имени нужно пользовать ECTL_GETFILENAME");
//// Проверить, чего там...
//_ASSERTE((WInfo.Flags & WIF_MODAL) == 0);
if (WInfo.Type == WTYPE_EDITOR || WInfo.Type == WTYPE_VIEWER || WInfo.Type == WTYPE_PANELS)
{
if ((WInfo.Flags & WIF_CURRENT))
{
lbActiveFound = true;
}
else if (bActiveInfo && (WInfo.Type == WActive.Type) && (WInfo.Id == WActive.Id))
{
WInfo.Flags |= WIF_CURRENT;
lbActiveFound = true;
}
TODO("Определение ИД редактора/вьювера");
lbCh |= AddTab(tabCount, WInfo.Pos, false/*losingFocus*/, false/*editorSave*/,
WInfo.Type, WInfo.Name, /*editorSave ? ei.FileName :*/ NULL,
(WInfo.Flags & WIF_CURRENT), (WInfo.Flags & WIF_MODIFIED), (WInfo.Flags & WIF_MODAL),
WInfo.Id);
}
}
}
bool bHasPanels = this->CheckPanelExist();
if (!lbActiveFound)
{
// Порядок инициализации поменялся, при запуске "far /e ..." редактора сначала вообще "нет".
_ASSERTE((!bHasPanels && windowCount==0 && bActiveInfo && WActive.Type == WTYPE_DESKTOP) && "Active window must be detected already!");
if (tabCount == 0)
{
// Добавить в табы хоть что-то
lbCh |= AddTab(tabCount, 0, false/*losingFocus*/, false/*editorSave*/,
WTYPE_PANELS, L"far", /*editorSave ? ei.FileName :*/ NULL,
1/*Current*/, 0/*Modified*/, 1/*Modal*/, 0);
}
if (tabCount > 0)
{
gpTabs->Tabs.CurrentType = gnCurrentWindowType = gpTabs->Tabs.tabs[tabCount-1].Type;
}
else
{
_ASSERTE(tabCount>0);
}
}
// 101224 - сразу запомнить количество!
gpTabs->Tabs.nTabCount = tabCount;
return lbCh;
}
int DeletePath(LPCTSTR pszPathIn,
LPCTSTR pszPattern,
DWORD fdwTraverse,
DWORD fdwSecurity,
DWORD fdwVerbose,
BPRINT_BUFFER & bp)
{
DWORD fdwFlags = fdwTraverse & (TDT_INPUTMASK & ~TDT_USERMASK);
if (fdwVerbose & DP_V_VERBOSE)
fdwFlags |= TDT_USER_F_VERBOSE;
if (fdwVerbose & DP_V_DIAGNOSTIC)
fdwFlags |= TDT_DIAGNOSTIC;
bool fQuiet = (fdwVerbose & DP_V_QUIET) != 0;
DeletePathData lad;
ZeroStruct(&lad);
lad.pbp = &bp;
if (fdwSecurity & DP_S_NODELETE)
lad.fNoDelete = true;
fdwFlags |= TDT_DIRLAST; // So we get directory callbacks after children have been deleted.
// if the path isn't too long, convert to canonical form. for long paths
// they has better provide canonical form to begin with.
//
TCHAR szCanonPath[MAX_PATH+1];
LPCTSTR pszPath = pszPathIn;
if (lstrlen(pszPathIn) < MAX_PATH &&
PathCanonicalize(szCanonPath, pszPathIn))
{
pszPath = szCanonPath;
}
// the unicode versions of the windows file api's can handle very long
// path names if they are canonical and if they are preceeded by \\?\.
// if we are build unicode, take advantage of that capability.
#ifdef UNICODE
static const TCHAR szPre[]= TEXT("\\\\?\\");
TCHAR szFullPath[MAX_PATH + NUMCHARS(szPre)];
TCHAR * pszFullPath = szFullPath;
TCHAR * pszFilePart = NULL;
lstrcpy(szFullPath, szPre);
UINT cchFullPath = GetFullPathName(pszPath, MAX_PATH, szFullPath + NUMCHARS(szPre)-1, &pszFilePart);
if (cchFullPath >= NUMCHARS(szFullPath)-1)
{
pszFullPath = (TCHAR *)LocalAlloc(LPTR, (cchFullPath + NUMCHARS(szPre) + 2) * sizeof(TCHAR));
if (pszFullPath)
{
lstrcpy(pszFullPath, szPre);
if (GetFullPathName(pszPath, cchFullPath+2, pszFullPath + NUMCHARS(szPre)-1, &pszFilePart) <= cchFullPath+2)
pszPath = pszFullPath;
}
}
else
pszPath = szFullPath;
#endif
int err = 0;
DWORD fdwFileAttributes = GetFileAttributes(pszPath);
if (INVALID_FILE_ATTRIBUTES == fdwFileAttributes)
{
fdwFileAttributes = 0;
err = GetLastError();
ReportError(err, "Could not get attributes for ", pszPath);
return err;
}
const bool fIsDir = (fdwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
if (fdwFlags & TDT_DIAGNOSTIC)
bprintfl(bp, TEXT("Delete %s 0x%04X %s\\%s"), fIsDir ? TEXT("Directory") : TEXT("File"), fdwFlags, pszPath, pszPattern);
if (fIsDir)
{
if (fdwTraverse & TDT_SUBDIRS)
{
if ( ! pszPattern || ! pszPattern[0])
err = TraverseDirectoryTree(pszPath, TEXT("*"), fdwFlags, DeletePathCallback, &lad, 0);
else
err = TraverseDirectoryTree(pszPath, pszPattern, fdwFlags, DeletePathCallback, &lad, 0);
}
if ( ! err || (fdwFlags & TDT_CONTINUE))
{
bprint_EndLine(bp);
if ( ! (fdwTraverse & TDT_NODIRS) && (!pszPattern || !pszPattern[0]))
{
if ( ! fQuiet)
{
bprint(bp, lad.fNoDelete ? TEXT("NoRemove ") : TEXT("Removing "));
bprint(bp, pszPath);
}
if ( ! lad.fNoDelete && ! RemoveDirectory(pszPath))
{
bprint_EndLine(bp);
err = GetLastError();
ReportError(err, "RemoveDirectory", pszPath);
if ( ! (fdwFlags & TDT_CONTINUE))
if ( ! fQuiet) bprintl(bp, "Aborting.");
}
}
}
}
else // initial path is a file, not a directory.
{
if (fdwTraverse & TDT_SUBDIRS)
{
if ( ! pszPattern || ! pszPattern[0])
{
err = TraverseDirectoryTree(pszPath, TEXT("*"), fdwFlags, DeletePathCallback, &lad, 0);
}
else
{
//#pragma REMIND("TJ: add code to split the file from the path and recurse on the filename.")
}
}
if (fdwTraverse & TDT_NOFILES)
{
// Nothing to do.
}
else if ( ! pszPattern || ! pszPattern[0])
{
if ( ! fQuiet)
{
bprint(bp, lad.fNoDelete ? TEXT("NoDelete ") : TEXT("Deleting "));
bprint(bp, pszPath);
}
if ( ! lad.fNoDelete && ! DeleteFile(pszPath))
{
bprint_EndLine(bp);
err = GetLastError();
ReportError(err, "DeleteFile", pszPath);
if ( ! (fdwFlags & TDT_CONTINUE))
if ( ! fQuiet) bprintl(bp, "Aborting.");
}
}
}
bprint_EndLine(bp);
return err;
}
//// Эта функция пайп не закрывает!
//void CGuiServer::GuiServerThreadCommand(HANDLE hPipe)
BOOL CGuiServer::GuiServerCommand(LPVOID pInst, CESERVER_REQ* pIn, CESERVER_REQ* &ppReply, DWORD &pcbReplySize, DWORD &pcbMaxReplySize, LPARAM lParam)
{
BOOL lbRc = FALSE;
CGuiServer* pGSrv = (CGuiServer*)lParam;
if (!pGSrv)
{
_ASSERTE(((CGuiServer*)lParam)!=NULL);
pGSrv = &gpConEmu->m_GuiServer;
}
if (pIn->hdr.bAsync)
pGSrv->mp_GuiServer->BreakConnection(pInst);
gpSetCls->debugLogCommand(pIn, TRUE, timeGetTime(), 0, pGSrv ? pGSrv->ms_ServerPipe : NULL);
#ifdef _DEBUG
UINT nDataSize = pIn->hdr.cbSize - sizeof(CESERVER_REQ_HDR);
#endif
// Все данные из пайпа получены, обрабатываем команду и возвращаем (если нужно) результат
#ifdef ALLOW_WINE_MSG
if (gbIsWine)
{
wchar_t szMsg[128];
msprintf(szMsg, countof(szMsg), L"CGuiServer::GuiServerCommand.\nGUI TID=%u\nSrcPID=%u, SrcTID=%u, Cmd=%u",
GetCurrentThreadId(), pIn->hdr.nSrcPID, pIn->hdr.nSrcThreadId, pIn->hdr.nCmd);
MessageBox(szMsg, MB_ICONINFORMATION);
}
#endif
switch (pIn->hdr.nCmd)
{
case CECMD_NEWCMD:
{
// Приходит из другой копии ConEmu.exe, когда она запущена с ключом /single, /showhide, /showhideTSA
DEBUGSTR(L"GUI recieved CECMD_NEWCMD\n");
if (gpSetCls->isAdvLogging)
{
size_t cchAll = 120 + _tcslen(pIn->NewCmd.szConEmu) + _tcslen(pIn->NewCmd.szCurDir) + _tcslen(pIn->NewCmd.szCommand);
wchar_t* pszInfo = (wchar_t*)malloc(cchAll*sizeof(*pszInfo));
if (pszInfo)
{
_wsprintf(pszInfo, SKIPLEN(cchAll) L"CECMD_NEWCMD: Wnd=x%08X, Act=%u, ConEmu=%s, Dir=%s, Cmd=%s",
(DWORD)(DWORD_PTR)pIn->NewCmd.hFromConWnd, pIn->NewCmd.ShowHide,
pIn->NewCmd.szConEmu, pIn->NewCmd.szCurDir, pIn->NewCmd.szCommand);
gpConEmu->LogString(pszInfo);
free(pszInfo);
}
}
BOOL bAccepted = FALSE;
if (pIn->NewCmd.szConEmu[0])
{
bAccepted = (lstrcmpi(gpConEmu->ms_ConEmuExeDir, pIn->NewCmd.szConEmu) == 0);
}
else
{
bAccepted = TRUE;
}
if (bAccepted)
{
bool bCreateTab = (pIn->NewCmd.ShowHide == sih_None || pIn->NewCmd.ShowHide == sih_StartDetached);
gpConEmu->OnMinimizeRestore(bCreateTab ? sih_SetForeground : pIn->NewCmd.ShowHide);
// Может быть пусто
if (bCreateTab && pIn->NewCmd.szCommand[0])
{
RConStartArgs *pArgs = new RConStartArgs;
pArgs->bDetached = (pIn->NewCmd.ShowHide == sih_StartDetached);
pArgs->pszSpecialCmd = lstrdup(pIn->NewCmd.szCommand);
if (pIn->NewCmd.szCurDir[0] == 0)
{
_ASSERTE(pIn->NewCmd.szCurDir[0] != 0);
}
else
{
pArgs->pszStartupDir = lstrdup(pIn->NewCmd.szCurDir);
}
if (gpSet->isMulti || CVConGroup::isDetached())
{
gpConEmu->PostCreateCon(pArgs);
}
else
{
// Если хотят в одном окне - только одну консоль
gpConEmu->CreateWnd(pArgs);
SafeDelete(pArgs);
}
}
else
{
_ASSERTE(pIn->NewCmd.ShowHide==sih_ShowMinimize || pIn->NewCmd.ShowHide==sih_ShowHideTSA || pIn->NewCmd.ShowHide==sih_Show);
}
}
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(BYTE);
lbRc = ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize);
if (lbRc)
{
ppReply->Data[0] = bAccepted;
}
break;
} //CECMD_NEWCMD
case CECMD_TABSCMD:
{
// 0: спрятать/показать табы, 1: перейти на следующую, 2: перейти на предыдущую, 3: commit switch
DEBUGSTR(L"GUI recieved CECMD_TABSCMD\n");
_ASSERTE(nDataSize>=1);
DWORD nTabCmd = pIn->Data[0];
gpConEmu->TabCommand((ConEmuTabCommand)nTabCmd);
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(BYTE);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->Data[0] = TRUE;
}
break;
} // CECMD_TABSCMD
#if 0
case CECMD_GETALLTABS:
{
int nConCount = gpConEmu->GetConCount();
int nActiveCon = gpConEmu->ActiveConNum();
size_t cchMax = nConCount*16;
size_t cchCount = 0;
CVirtualConsole* pVCon;
CESERVER_REQ_GETALLTABS::TabInfo* pTabs = (CESERVER_REQ_GETALLTABS::TabInfo*)calloc(cchMax, sizeof(*pTabs));
for (int V = 0; (pVCon = gpConEmu->GetVCon(V)) != NULL; V++)
{
if (!pTabs)
{
_ASSERTE(pTabs!=NULL);
break;
}
CRealConsole* pRCon = pVCon->RCon();
if (!pRCon)
continue;
ConEmuTab tab;
wchar_t szModified[4];
for (int T = 0; pRCon->GetTab(T, &tab); T++)
{
if (cchCount >= cchMax)
{
pTabs = (CESERVER_REQ_GETALLTABS::TabInfo*)realloc(pTabs, (cchMax+32)*sizeof(*pTabs));
if (!pTabs)
{
_ASSERTE(pTabs!=NULL);
break;
}
cchMax += 32;
_ASSERTE(cchCount<cchMax);
}
pTabs[cchCount].ActiveConsole == (V == nActiveCon);
pTabs[cchCount].ActiveTab == (tab.Current != 0);
pTabs[cchCount].Disabled = ((tab.Type & fwt_Disabled) == fwt_Disabled);
pTabs[cchCount].ConsoleIdx = V;
pTabs[cchCount].TabIdx = T;
// Text
wcscpy_c(szModified, tab.Modified ? L" * " : L" ");
if (V == nActiveCon)
{
if (T < 9)
_wsprintf(pTabs[cchCount].Title, SKIPLEN(countof(pTabs[cchCount].Title)) L"[%i/&%i]%s", V+1, T+1, szModified);
else if (T == 9)
_wsprintf(pTabs[cchCount].Title, SKIPLEN(countof(pTabs[cchCount].Title)) L"[%i/1&0]%s", V+1, szModified);
else
_wsprintf(pTabs[cchCount].Title, SKIPLEN(countof(pTabs[cchCount].Title)) L"[%i/%i]%s", V+1, T+1, szModified);
}
else
{
_wsprintf(pTabs[cchCount].Title, SKIPLEN(countof(pTabs[cchCount].Title)) L"[%i/%i]%s", V+1, T+1, szModified);
}
cchCount++;
}
}
if (cchCount && pTabs)
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_GETALLTABS)+((cchCount-1)*sizeof(CESERVER_REQ_GETALLTABS::TabInfo));
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->GetAllTabs.Count = cchCount;
memmove(ppReply->GetAllTabs.Tabs, pTabs, cchCount*sizeof(*pTabs));
}
}
SafeFree(pTabs);
break;
} // CECMD_GETALLTABS
case CECMD_ACTIVATETAB:
{
BOOL lbTabOk = FALSE;
CVirtualConsole *pVCon = gpConEmu->GetVCon(pIn->dwData[0]);
if (pVCon && pVCon->RCon())
{
lbTabOk = pVCon->RCon()->ActivateFarWindow(pIn->dwData[1]);
}
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = lbTabOk;
}
break;
} // CECMD_ACTIVATETAB
#endif
case CECMD_ATTACH2GUI:
{
// Получен запрос на Attach из сервера
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_STARTSTOPRET);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
//CESERVER_REQ* pOut = ExecuteNewCmd(CECMD_ATTACH2GUI, sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_STARTSTOPRET));
gpConEmu->AttachRequested(pIn->StartStop.hWnd, &(pIn->StartStop), &(ppReply->StartStopRet));
_ASSERTE((ppReply->StartStopRet.nBufferHeight == 0) || ((int)ppReply->StartStopRet.nBufferHeight > pIn->StartStop.sbi.dwSize.X));
lbRc = TRUE;
//ExecuteFreeResult(pOut);
break;
} // CECMD_ATTACH2GUI
case CECMD_SRVSTARTSTOP:
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_STARTSTOPRET);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
if (pIn->SrvStartStop.Started == srv_Started)
{
// Запущен процесс сервера
HWND hConWnd = (HWND)pIn->dwData[1];
_ASSERTE(hConWnd && IsWindow(hConWnd));
DWORD nStartTick = timeGetTime();
//LRESULT l = 0;
//DWORD_PTR dwRc = 0;
//2010-05-21 Поскольку это критично - лучше ждать до упора, хотя может быть DeadLock?
//l = SendMessageTimeout(ghWnd, gpConEmu->mn_MsgSrvStarted, (WPARAM)hConWnd, pIn->hdr.nSrcPID,
// SMTO_BLOCK, 5000, &dwRc);
//111002 - вернуть должен HWND окна отрисовки (дочернее окно ConEmu)
MsgSrvStartedArg arg = {hConWnd, pIn->hdr.nSrcPID, pIn->SrvStartStop.dwKeybLayout, nStartTick};
SendMessage(ghWnd, gpConEmu->mn_MsgSrvStarted, 0, (LPARAM)&arg);
HWND hWndDC = arg.hWndDc;
HWND hWndBack = arg.hWndBack;
_ASSERTE(hWndDC!=NULL);
#ifdef _DEBUG
DWORD dwErr = GetLastError(), nEndTick = timeGetTime(), nDelta = nEndTick - nStartTick;
if (hWndDC && nDelta >= EXECUTE_CMD_WARN_TIMEOUT)
{
if (!IsDebuggerPresent())
{
//_ASSERTE(nDelta <= EXECUTE_CMD_WARN_TIMEOUT || (pIn->hdr.nCmd == CECMD_CMDSTARTSTOP && nDelta <= EXECUTE_CMD_WARN_TIMEOUT2));
_ASSERTEX(nDelta <= EXECUTE_CMD_WARN_TIMEOUT);
}
}
#endif
//pIn->dwData[0] = (DWORD)ghWnd; //-V205
//pIn->dwData[1] = (DWORD)dwRc; //-V205
//pIn->dwData[0] = (l == 0) ? 0 : 1;
ppReply->StartStopRet.hWnd = ghWnd;
ppReply->StartStopRet.hWndDc = hWndDC;
ppReply->StartStopRet.hWndBack = hWndBack;
ppReply->StartStopRet.dwPID = GetCurrentProcessId();
}
else if (pIn->SrvStartStop.Started == srv_Stopped)
{
// Процесс сервера завершается
CRealConsole* pRCon = NULL;
CVConGuard VCon;
for (size_t i = 0;; i++)
{
if (!CVConGroup::GetVCon(i, &VCon))
break;
pRCon = VCon->RCon();
if (pRCon && (pRCon->GetServerPID(true) == pIn->hdr.nSrcPID || pRCon->GetServerPID(false) == pIn->hdr.nSrcPID))
{
break;
}
pRCon = NULL;
}
if (pRCon)
pRCon->OnServerClosing(pIn->hdr.nSrcPID);
//pIn->dwData[0] = 1;
}
else
{
_ASSERTE((pIn->dwData[0] == 1) || (pIn->dwData[0] == 101));
}
lbRc = TRUE;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// pOut, // buffer to write from
// pOut->hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
//ExecuteFreeResult(pOut);
break;
} // CECMD_SRVSTARTSTOP
case CECMD_ASSERT:
{
DWORD nBtn = MessageBox(NULL, pIn->AssertInfo.szDebugInfo, pIn->AssertInfo.szTitle, pIn->AssertInfo.nBtns);
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = nBtn;
}
//ExecutePrepareCmd(&pIn->hdr, CECMD_ASSERT, sizeof(CESERVER_REQ_HDR) + sizeof(DWORD));
//pIn->dwData[0] = nBtn;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// pIn, // buffer to write from
// pIn->hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
break;
} // CECMD_ASSERT
case CECMD_ATTACHGUIAPP:
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_ATTACHGUIAPP);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
ppReply->AttachGuiApp = pIn->AttachGuiApp;
//CESERVER_REQ Out;
//ExecutePrepareCmd(&Out.hdr, CECMD_ATTACHGUIAPP, sizeof(CESERVER_REQ_HDR)+sizeof(Out.AttachGuiApp));
//Out.AttachGuiApp = pIn->AttachGuiApp;
#ifdef SHOW_GUIATTACH_START
if (pIn->AttachGuiApp.hWindow == NULL)
{
wchar_t szDbg[1024];
_wsprintf(szDbg, SKIPLEN(countof(szDbg)) L"AttachGuiApp requested from:\n%s\nPID=%u", pIn->AttachGuiApp.sAppFileName, pIn->AttachGuiApp.nPID);
//MBoxA(szDbg);
MessageBox(NULL, szDbg, L"ConEmu", MB_SYSTEMMODAL);
}
#endif
// Уведомить ожидающую вкладку
CRealConsole* pRCon = gpConEmu->AttachRequestedGui(pIn->AttachGuiApp.sAppFileName, pIn->AttachGuiApp.nPID);
if (pRCon)
{
CVConGuard VCon(pRCon->VCon());
RECT rcPrev = ppReply->AttachGuiApp.rcWindow;
HWND hBack = pRCon->VCon()->GetBack();
//// Размер должен быть независим от возможности наличия прокрутки в VCon
//GetWindowRect(hBack, &ppReply->AttachGuiApp.rcWindow);
//ppReply->AttachGuiApp.rcWindow.right -= ppReply->AttachGuiApp.rcWindow.left;
//ppReply->AttachGuiApp.rcWindow.bottom -= ppReply->AttachGuiApp.rcWindow.top;
//ppReply->AttachGuiApp.rcWindow.left = ppReply->AttachGuiApp.rcWindow.top = 0;
////MapWindowPoints(NULL, hBack, (LPPOINT)&ppReply->AttachGuiApp.rcWindow, 2);
//pRCon->CorrectGuiChildRect(ppReply->AttachGuiApp.nStyle, ppReply->AttachGuiApp.nStyleEx, ppReply->AttachGuiApp.rcWindow);
// Уведомить RCon и ConEmuC, что гуй подцепился
// Вызывается два раза. Первый (при запуске exe) ahGuiWnd==NULL, второй - после фактического создания окна
pRCon->SetGuiMode(pIn->AttachGuiApp.nFlags, pIn->AttachGuiApp.hAppWindow, pIn->AttachGuiApp.Styles.nStyle, pIn->AttachGuiApp.Styles.nStyleEx, pIn->AttachGuiApp.sAppFileName, pIn->AttachGuiApp.nPID, rcPrev);
ppReply->AttachGuiApp.nFlags = agaf_Success | (pRCon->isActive(false) ? 0 : agaf_Inactive);
ppReply->AttachGuiApp.nPID = pRCon->GetServerPID();
ppReply->AttachGuiApp.hConEmuDc = pRCon->GetView();
ppReply->AttachGuiApp.hConEmuBack = hBack;
ppReply->AttachGuiApp.hConEmuWnd = ghWnd;
ppReply->AttachGuiApp.hAppWindow = pIn->AttachGuiApp.hAppWindow;
ppReply->AttachGuiApp.hSrvConWnd = pRCon->ConWnd();
ppReply->AttachGuiApp.hkl = (DWORD)(LONG)(LONG_PTR)GetKeyboardLayout(gpConEmu->mn_MainThreadId);
ZeroStruct(ppReply->AttachGuiApp.Styles.Shifts);
CRealConsole::CorrectGuiChildRect(pIn->AttachGuiApp.Styles.nStyle, pIn->AttachGuiApp.Styles.nStyleEx, ppReply->AttachGuiApp.Styles.Shifts);
}
else
{
ppReply->AttachGuiApp.nFlags = agaf_Fail;
}
lbRc = TRUE;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// &Out, // buffer to write from
// Out.hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
break;
} // CECMD_ATTACHGUIAPP
case CECMD_GUICLIENTSHIFT:
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(GuiStylesAndShifts);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
ppReply->GuiAppShifts = pIn->GuiAppShifts;
ZeroStruct(ppReply->GuiAppShifts.Shifts);
CRealConsole::CorrectGuiChildRect(pIn->GuiAppShifts.nStyle, pIn->GuiAppShifts.nStyleEx, ppReply->GuiAppShifts.Shifts);
lbRc = TRUE;
break;
} // CECMD_GUICLIENTSHIFT
}
//// Освободить память
//if (pIn && (LPVOID)pIn != (LPVOID)&in)
//{
// free(pIn); pIn = NULL;
//}
wrap:
return lbRc;
}
ULong QLIECompress(LPVoid lpInput, Int32 InputSize, LPVoid lpOutput, Int32 OutputSize)
{
Bool bEnd;
PByte pbBuffer, pbOutEnd;
UInt32 LastByte, CurrentByte;
SPackEntryCompressedData *pData;
SQLIECompressInfo Info;
pData = (SPackEntryCompressedData *)lpOutput;
if (pData == NULL)
return InputSize + sizeof(*pData) - sizeof(pData->Data) + 256;
else if (OutputSize < InputSize + sizeof(*pData) - sizeof(pData->Data) + 256)
return 0;
ZeroStruct(&Info);
pData->Magic = QLIE_COMP_MAGIC;
pData->Flag = FLAG_ENTRY_16BIT_LENGTH;
pData->DecompressSize = InputSize;
pbBuffer = pData->Data;
Info.pbBuffer = (PByte)lpInput;
Info.pbEnd = Info.pbBuffer + InputSize;
pbOutEnd = (PByte)lpOutput + OutputSize;
bEnd = False;
while (!bEnd)
{
Long Index, val;
ULong InsertIndex;
bEnd = InitDict(&Info);
Index = 0x100;
while (Index-- > 0)
{
do
{
if (Info.dict_6200[Index] == Index && Info.dict_6100[Index] == 0)
break;
} while (--Index >= 0);
if (Index < 0)
break;
PByte dict_6000 = Info.dict_6000;
PByte dict_4000 = Info.dict_4000;
PByte dict_2000 = Info.dict_2000;
val = 2;
for (ULong i = 0x2000; i; --i)
{
if (*dict_6000 > val)
{
val = *dict_6000;
CurrentByte = *dict_2000;
LastByte = *dict_4000;
}
dict_6000++;
dict_2000++;
dict_4000++;
}
if (val < 3)
break;
Int i, j, k;
for (i = 0, k = 0, j = Info.DictLength - 1; i < j; ++i, ++k)
{
if (Info.dict_820C[i - 1] != CurrentByte || Info.dict_820C[i] != LastByte)
{
Info.dict_820C[k - 1] = Info.dict_820C[i - 1];
continue;
}
if (i > 0)
{
InsertIndex = AddNode(&Info, Info.dict_820C[k - 2], CurrentByte);
if (Info.dict_6000[InsertIndex] > 1)
--Info.dict_6000[InsertIndex];
InsertIndex = AddNode(&Info, Info.dict_820C[k - 2], Index);
if (Info.dict_6000[InsertIndex] != 0xFF)
++Info.dict_6000[InsertIndex];
}
if (i < j - 1)
{
InsertIndex = AddNode(&Info, LastByte, Info.dict_820C[i + 1]);
if (Info.dict_6000[InsertIndex] > 1)
--Info.dict_6000[InsertIndex];
InsertIndex = AddNode(&Info, Index, Info.dict_820C[i + 1]);
if (Info.dict_6000[InsertIndex] != 0xFF)
++Info.dict_6000[InsertIndex];
}
Info.dict_820C[k - 1] = Index;
++i;
--Info.DictLength;
}
Info.dict_820C[k - 1] = Info.dict_820C[i - 1];
Info.dict_6200[Index] = CurrentByte;
Info.dict_6100[Index] = LastByte;
InsertIndex = AddNode(&Info, CurrentByte, LastByte);
Info.dict_6000[InsertIndex] = 1;
}
pbBuffer = WriteBlock(&Info, pbBuffer, pbOutEnd);
if (pbBuffer == NULL)
return 0;
}
return pbBuffer - (PByte)pData;
}
//// Эта функция пайп не закрывает!
//void CGuiServer::GuiServerThreadCommand(HANDLE hPipe)
BOOL CGuiServer::GuiServerCommand(LPVOID pInst, CESERVER_REQ* pIn, CESERVER_REQ* &ppReply, DWORD &pcbReplySize, DWORD &pcbMaxReplySize, LPARAM lParam)
{
BOOL lbRc = FALSE;
CGuiServer* pGSrv = (CGuiServer*)lParam;
if (!pGSrv)
{
_ASSERTE(((CGuiServer*)lParam)!=NULL);
pGSrv = &gpConEmu->m_GuiServer;
}
if (pIn->hdr.bAsync)
pGSrv->mp_GuiServer->BreakConnection(pInst);
gpSetCls->debugLogCommand(pIn, TRUE, timeGetTime(), 0, pGSrv ? pGSrv->ms_ServerPipe : NULL);
#ifdef _DEBUG
UINT nDataSize = pIn->hdr.cbSize - sizeof(CESERVER_REQ_HDR);
#endif
// Все данные из пайпа получены, обрабатываем команду и возвращаем (если нужно) результат
#ifdef ALLOW_WINE_MSG
if (gbIsWine)
{
wchar_t szMsg[128];
msprintf(szMsg, countof(szMsg), L"CGuiServer::GuiServerCommand.\nGUI TID=%u\nSrcPID=%u, SrcTID=%u, Cmd=%u",
GetCurrentThreadId(), pIn->hdr.nSrcPID, pIn->hdr.nSrcThreadId, pIn->hdr.nCmd);
MessageBox(szMsg, MB_ICONINFORMATION);
}
#endif
switch (pIn->hdr.nCmd)
{
case CECMD_NEWCMD:
{
// Приходит из другой копии ConEmu.exe, когда она запущена с ключом /single, /showhide, /showhideTSA
DEBUGSTRCMD(L"GUI recieved CECMD_NEWCMD\n");
LPCWSTR pszCommand = pIn->NewCmd.GetCommand();
_ASSERTE(pszCommand!=NULL && "Must be at least empty string but NOT NULL");
if (pIn->NewCmd.isAdvLogging && !gpSetCls->isAdvLogging)
{
gpSetCls->isAdvLogging = pIn->NewCmd.isAdvLogging;
gpConEmu->CreateLog();
}
if (gpSetCls->isAdvLogging && (pIn->NewCmd.isAdvLogging > gpSetCls->isAdvLogging))
{
wchar_t szLogLevel[80];
_wsprintf(szLogLevel, SKIPLEN(countof(szLogLevel)) L"Changing log level! Old=%u, New=%u", (UINT)gpSetCls->isAdvLogging, (UINT)pIn->NewCmd.isAdvLogging);
gpConEmu->LogString(szLogLevel);
gpSetCls->isAdvLogging = pIn->NewCmd.isAdvLogging;
}
if (gpSetCls->isAdvLogging)
{
size_t cchAll = 120 + _tcslen(pIn->NewCmd.szConEmu) + _tcslen(pIn->NewCmd.szCurDir) + _tcslen(pszCommand);
wchar_t* pszInfo = (wchar_t*)malloc(cchAll*sizeof(*pszInfo));
if (pszInfo)
{
_wsprintf(pszInfo, SKIPLEN(cchAll) L"CECMD_NEWCMD: Wnd=x%08X, Act=%u, ConEmu=%s, Dir=%s, Cmd=%s",
(DWORD)(DWORD_PTR)pIn->NewCmd.hFromConWnd, pIn->NewCmd.ShowHide,
pIn->NewCmd.szConEmu, pIn->NewCmd.szCurDir, pszCommand);
gpConEmu->LogString(pszInfo);
free(pszInfo);
}
}
BOOL bAccepted = FALSE;
if (pIn->NewCmd.szConEmu[0])
{
bAccepted = (lstrcmpi(gpConEmu->ms_ConEmuExeDir, pIn->NewCmd.szConEmu) == 0);
}
else
{
bAccepted = TRUE;
}
if (bAccepted)
{
bool bCreateTab = (pIn->NewCmd.ShowHide == sih_None || pIn->NewCmd.ShowHide == sih_StartDetached)
// Issue 1275: When minimized into TSA (on all VCon are closed) we need to restore and run new tab
|| (pszCommand[0] && !CVConGroup::isVConExists(0));
RConStartArgs rTest;
if (pszCommand[0])
{
rTest.pszSpecialCmd = lstrdup(pszCommand);
rTest.ProcessNewConArg();
}
bool bSkipActivation = false;
// Может быть пусто
if (bCreateTab && pszCommand[0])
{
RConStartArgs *pArgs = new RConStartArgs;
// New tab must be started with same credentials that calling tab if others was not specified
{
if (!rTest.HasInheritedArgs())
{
CVConGuard VCon;
if ((pIn->NewCmd.hFromConWnd || pIn->NewCmd.hFromDcWnd)
&& CVConGroup::GetVConByHWND(pIn->NewCmd.hFromConWnd, pIn->NewCmd.hFromDcWnd, &VCon))
{
const RConStartArgs& r = VCon->RCon()->GetArgs();
if (r.HasInheritedArgs())
{
pArgs->AssignInheritedArgs(&r);
}
}
}
}
pArgs->Detached = (pIn->NewCmd.ShowHide == sih_StartDetached) ? crb_On : crb_Off;
pArgs->pszSpecialCmd = lstrdup(pszCommand);
if (pIn->NewCmd.szCurDir[0] == 0)
{
_ASSERTE(pIn->NewCmd.szCurDir[0] != 0);
}
else
{
pArgs->pszStartupDir = lstrdup(pIn->NewCmd.szCurDir);
}
LPCWSTR pszStrings = pIn->NewCmd.GetEnvStrings();
if (pszStrings && pIn->NewCmd.cchEnvStrings)
{
size_t cbBytes = pIn->NewCmd.cchEnvStrings*sizeof(*pArgs->pszEnvStrings);
pArgs->pszEnvStrings = (wchar_t*)malloc(cbBytes);
if (pArgs->pszEnvStrings)
{
memmove(pArgs->pszEnvStrings, pszStrings, cbBytes);
pArgs->cchEnvStrings = pIn->NewCmd.cchEnvStrings;
}
}
if (gpSetCls->IsMulti() || CVConGroup::isDetached())
{
gpConEmu->PostCreateCon(pArgs);
}
else
{
// Если хотят в одном окне - только одну консоль
gpConEmu->CreateWnd(pArgs);
SafeDelete(pArgs);
// New window created? Don't activate this one.
bSkipActivation = true;
}
}
else
{
_ASSERTE(pIn->NewCmd.ShowHide==sih_ShowMinimize || pIn->NewCmd.ShowHide==sih_ShowHideTSA || pIn->NewCmd.ShowHide==sih_Show);
}
// gh#151: Do animation after starting tab creation
if (!bSkipActivation && (rTest.BackgroundTab != crb_On))
{
gpConEmu->DoMinimizeRestore(bCreateTab ? sih_SetForeground : pIn->NewCmd.ShowHide);
}
}
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(BYTE);
lbRc = ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize);
if (lbRc)
{
ppReply->Data[0] = bAccepted;
}
break;
} //CECMD_NEWCMD
case CECMD_TABSCMD:
{
// 0: спрятать/показать табы, 1: перейти на следующую, 2: перейти на предыдущую, 3: commit switch
DEBUGSTRCMD(L"GUI recieved CECMD_TABSCMD\n");
_ASSERTE(nDataSize>=1);
DWORD nTabCmd = pIn->Data[0];
gpConEmu->TabCommand((ConEmuTabCommand)nTabCmd);
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(BYTE);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->Data[0] = TRUE;
}
break;
} // CECMD_TABSCMD
case CECMD_ATTACH2GUI:
{
// Получен запрос на Attach из сервера
MCHKHEAP;
CESERVER_REQ_SRVSTARTSTOPRET Ret = {};
lbRc = CVConGroup::AttachRequested(pIn->StartStop.hWnd, &(pIn->StartStop), Ret);
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SRVSTARTSTOPRET)+(Ret.cchEnvCommands*sizeof(wchar_t));
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
SafeFree(Ret.pszCommands);
goto wrap;
}
if (lbRc)
{
_ASSERTE(sizeof(ppReply->SrvStartStopRet) == sizeof(Ret));
memmove(&ppReply->SrvStartStopRet, &Ret, sizeof(Ret));
// Environment strings (inherited from parent console)
if (Ret.cchEnvCommands && Ret.pszCommands)
{
memmove(ppReply->SrvStartStopRet.szCommands, Ret.pszCommands, Ret.cchEnvCommands*sizeof(wchar_t));
ppReply->SrvStartStopRet.cchEnvCommands = Ret.cchEnvCommands;
}
else
{
ppReply->SrvStartStopRet.cchEnvCommands = 0;
}
SafeFree(Ret.pszCommands);
_ASSERTE((ppReply->StartStopRet.nBufferHeight == 0) || ((int)ppReply->StartStopRet.nBufferHeight > (pIn->StartStop.sbi.srWindow.Bottom-pIn->StartStop.sbi.srWindow.Top)));
}
MCHKHEAP;
break;
} // CECMD_ATTACH2GUI
case CECMD_SRVSTARTSTOP:
{
MCHKHEAP;
// SRVSTART не приходит если запускается cmd под админом или из Win+G
bool lbAllocated = false;
if (pIn->SrvStartStop.Started == srv_Started)
{
// Запущен процесс сервера
HWND hConWnd = (HWND)pIn->dwData[1];
_ASSERTE(hConWnd && IsWindow(hConWnd));
DWORD nStartTick = timeGetTime();
struct MsgSrvStartedArg
{
HWND hConWnd;
DWORD nSrcPID;
DWORD dwKeybLayout;
DWORD timeStart;
DWORD timeRecv;
DWORD timeFin;
CESERVER_REQ_SRVSTARTSTOPRET Ret;
//111002 - вернуть должен HWND окна отрисовки (дочернее окно ConEmu)
static LRESULT OnSrvStarted(LPARAM lParam)
{
MsgSrvStartedArg *pArg = (MsgSrvStartedArg*)lParam;
HWND hWndDC = NULL;
DWORD nServerPID = pArg->nSrcPID;
HWND hWndCon = pArg->hConWnd;
DWORD dwKeybLayout = pArg->dwKeybLayout;
pArg->timeRecv = timeGetTime();
DWORD t1, t2; int iFound = -1;
hWndDC = CVConGroup::DoSrvCreated(nServerPID, hWndCon, dwKeybLayout, t1, t2, iFound, pArg->Ret);
UNREFERENCED_PARAMETER(dwKeybLayout);
UNREFERENCED_PARAMETER(hWndCon);
pArg->timeFin = timeGetTime();
if (hWndDC == NULL)
{
_ASSERTE(hWndDC!=NULL);
}
else
{
#ifdef _DEBUG
DWORD nRecvDur = pArg->timeRecv - pArg->timeStart;
DWORD nProcDur = pArg->timeFin - pArg->timeRecv;
#define MSGSTARTED_TIMEOUT 10000
if ((nRecvDur > MSGSTARTED_TIMEOUT) || (nProcDur > MSGSTARTED_TIMEOUT))
{
_ASSERTE((nRecvDur <= MSGSTARTED_TIMEOUT) && (nProcDur <= MSGSTARTED_TIMEOUT));
}
#endif
}
return (LRESULT)hWndDC;
};
} arg = {hConWnd, pIn->hdr.nSrcPID, pIn->SrvStartStop.dwKeybLayout, nStartTick};
gpConEmu->CallMainThread(true, arg.OnSrvStarted, (LPARAM)&arg);
HWND hWndDC = arg.Ret.Info.hWndDc;
HWND hWndBack = arg.Ret.Info.hWndBack;
_ASSERTE(hWndDC!=NULL);
#ifdef _DEBUG
DWORD dwErr = GetLastError(), nEndTick = timeGetTime(), nDelta = nEndTick - nStartTick;
if (hWndDC && nDelta >= EXECUTE_CMD_WARN_TIMEOUT)
{
if (!IsDebuggerPresent())
{
//_ASSERTE(nDelta <= EXECUTE_CMD_WARN_TIMEOUT || (pIn->hdr.nCmd == CECMD_CMDSTARTSTOP && nDelta <= EXECUTE_CMD_WARN_TIMEOUT2));
_ASSERTEX(nDelta <= EXECUTE_CMD_WARN_TIMEOUT);
}
}
#endif
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SRVSTARTSTOPRET)+(arg.Ret.cchEnvCommands*sizeof(wchar_t));
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
SafeFree(arg.Ret.pszCommands);
goto wrap;
}
lbAllocated = true;
_ASSERTE(sizeof(ppReply->SrvStartStopRet) == sizeof(arg.Ret));
memmove(&ppReply->SrvStartStopRet, &arg.Ret, sizeof(arg.Ret));
// Environment strings (inherited from parent console)
if (arg.Ret.cchEnvCommands && arg.Ret.pszCommands)
{
memmove(ppReply->SrvStartStopRet.szCommands, arg.Ret.pszCommands, arg.Ret.cchEnvCommands*sizeof(wchar_t));
ppReply->SrvStartStopRet.cchEnvCommands = arg.Ret.cchEnvCommands;
}
else
{
ppReply->SrvStartStopRet.cchEnvCommands = 0;
}
SafeFree(arg.Ret.pszCommands);
}
else if (pIn->SrvStartStop.Started == srv_Stopped)
{
// Процесс сервера завершается
CRealConsole* pRCon = NULL;
CVConGuard VCon;
for (size_t i = 0;; i++)
{
if (!CVConGroup::GetVCon(i, &VCon))
break;
pRCon = VCon->RCon();
if (pRCon && (pRCon->GetServerPID(true) == pIn->hdr.nSrcPID || pRCon->GetServerPID(false) == pIn->hdr.nSrcPID))
{
break;
}
pRCon = NULL;
}
gpConEmu->mn_ShellExitCode = pIn->SrvStartStop.nShellExitCode;
if (pRCon)
pRCon->OnServerClosing(pIn->hdr.nSrcPID, &pIn->SrvStartStop.nShellExitCode);
//pIn->dwData[0] = 1;
}
else
{
_ASSERTE((pIn->dwData[0] == 1) || (pIn->dwData[0] == 101));
}
MCHKHEAP;
if (!lbAllocated)
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SRVSTARTSTOPRET);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
}
lbRc = TRUE;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// pOut, // buffer to write from
// pOut->hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
//ExecuteFreeResult(pOut);
break;
} // CECMD_SRVSTARTSTOP
case CECMD_ASSERT:
{
DWORD nBtn = MessageBox(NULL, pIn->AssertInfo.szDebugInfo, pIn->AssertInfo.szTitle, pIn->AssertInfo.nBtns);
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = nBtn;
}
//ExecutePrepareCmd(&pIn->hdr, CECMD_ASSERT, sizeof(CESERVER_REQ_HDR) + sizeof(DWORD));
//pIn->dwData[0] = nBtn;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// pIn, // buffer to write from
// pIn->hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
break;
} // CECMD_ASSERT
case CECMD_ATTACHGUIAPP:
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_ATTACHGUIAPP);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
ppReply->AttachGuiApp = pIn->AttachGuiApp;
//CESERVER_REQ Out;
//ExecutePrepareCmd(&Out.hdr, CECMD_ATTACHGUIAPP, sizeof(CESERVER_REQ_HDR)+sizeof(Out.AttachGuiApp));
//Out.AttachGuiApp = pIn->AttachGuiApp;
#ifdef SHOW_GUIATTACH_START
if (pIn->AttachGuiApp.hWindow == NULL)
{
wchar_t szDbg[1024];
_wsprintf(szDbg, SKIPLEN(countof(szDbg)) L"AttachGuiApp requested from:\n%s\nPID=%u", pIn->AttachGuiApp.sAppFilePathName, pIn->AttachGuiApp.nPID);
//MBoxA(szDbg);
MessageBox(NULL, szDbg, L"ConEmu", MB_SYSTEMMODAL);
}
#endif
// Уведомить ожидающую вкладку
CRealConsole* pRCon = CVConGroup::AttachRequestedGui(pIn->AttachGuiApp.nServerPID, pIn->AttachGuiApp.sAppFilePathName, pIn->AttachGuiApp.nPID);
if (pRCon)
{
CVConGuard VCon(pRCon->VCon());
RECT rcPrev = ppReply->AttachGuiApp.rcWindow;
HWND hBack = pRCon->VCon()->GetBack();
//// Размер должен быть независим от возможности наличия прокрутки в VCon
//GetWindowRect(hBack, &ppReply->AttachGuiApp.rcWindow);
//ppReply->AttachGuiApp.rcWindow.right -= ppReply->AttachGuiApp.rcWindow.left;
//ppReply->AttachGuiApp.rcWindow.bottom -= ppReply->AttachGuiApp.rcWindow.top;
//ppReply->AttachGuiApp.rcWindow.left = ppReply->AttachGuiApp.rcWindow.top = 0;
////MapWindowPoints(NULL, hBack, (LPPOINT)&ppReply->AttachGuiApp.rcWindow, 2);
//pRCon->CorrectGuiChildRect(ppReply->AttachGuiApp.nStyle, ppReply->AttachGuiApp.nStyleEx, ppReply->AttachGuiApp.rcWindow);
// Уведомить RCon и ConEmuC, что гуй подцепился
// Вызывается два раза. Первый (при запуске exe) ahGuiWnd==NULL, второй - после фактического создания окна
pRCon->SetGuiMode(pIn->AttachGuiApp.nFlags, pIn->AttachGuiApp.hAppWindow, pIn->AttachGuiApp.Styles.nStyle, pIn->AttachGuiApp.Styles.nStyleEx, pIn->AttachGuiApp.sAppFilePathName, pIn->AttachGuiApp.nPID, pIn->hdr.nBits, rcPrev);
ppReply->AttachGuiApp.nFlags = agaf_Success | (pRCon->isActive(false) ? 0 : agaf_Inactive);
ppReply->AttachGuiApp.nServerPID = pRCon->GetServerPID();
ppReply->AttachGuiApp.nPID = ppReply->AttachGuiApp.nServerPID;
ppReply->AttachGuiApp.hConEmuDc = pRCon->GetView();
ppReply->AttachGuiApp.hConEmuBack = hBack;
ppReply->AttachGuiApp.hConEmuWnd = ghWnd;
ppReply->AttachGuiApp.hAppWindow = pIn->AttachGuiApp.hAppWindow;
ppReply->AttachGuiApp.hSrvConWnd = pRCon->ConWnd();
ppReply->AttachGuiApp.hkl = (DWORD)(LONG)(LONG_PTR)GetKeyboardLayout(gpConEmu->mn_MainThreadId);
ZeroStruct(ppReply->AttachGuiApp.Styles.Shifts);
CRealConsole::CorrectGuiChildRect(pIn->AttachGuiApp.Styles.nStyle, pIn->AttachGuiApp.Styles.nStyleEx, ppReply->AttachGuiApp.Styles.Shifts, pIn->AttachGuiApp.sAppFilePathName);
}
else
{
ppReply->AttachGuiApp.nFlags = agaf_Fail;
_ASSERTE(FALSE && "No one tab is waiting for ChildGui process");
}
lbRc = TRUE;
//// Отправляем
//fSuccess = WriteFile(
// hPipe, // handle to pipe
// &Out, // buffer to write from
// Out.hdr.cbSize, // number of bytes to write
// &cbWritten, // number of bytes written
// NULL); // not overlapped I/O
break;
} // CECMD_ATTACHGUIAPP
case CECMD_GUICLIENTSHIFT:
{
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(GuiStylesAndShifts);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
goto wrap;
ppReply->GuiAppShifts = pIn->GuiAppShifts;
ZeroStruct(ppReply->GuiAppShifts.Shifts);
CRealConsole::CorrectGuiChildRect(pIn->GuiAppShifts.nStyle, pIn->GuiAppShifts.nStyleEx, ppReply->GuiAppShifts.Shifts, pIn->GuiAppShifts.szExeName);
lbRc = TRUE;
break;
} // CECMD_GUICLIENTSHIFT
case CECMD_GUIMACRO:
{
// Допустимо, если GuiMacro пытаются выполнить извне
CVConGuard VCon;
CVConGroup::GetActiveVCon(&VCon);
DWORD nFarPluginPID = VCon->RCon()->GetFarPID(true);
LPWSTR pszResult = ConEmuMacro::ExecuteMacro(pIn->GuiMacro.sMacro, VCon->RCon(), (nFarPluginPID==pIn->hdr.nSrcPID), &pIn->GuiMacro);
int nLen = pszResult ? _tcslen(pszResult) : 0;
pcbReplySize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_GUIMACRO)+nLen*sizeof(wchar_t);
if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
SafeFree(pszResult);
goto wrap;
}
if (pszResult)
{
lstrcpy(ppReply->GuiMacro.sMacro, pszResult);
ppReply->GuiMacro.nSucceeded = 1;
free(pszResult);
}
else
{
ppReply->GuiMacro.sMacro[0] = 0;
ppReply->GuiMacro.nSucceeded = 0;
}
lbRc = TRUE;
break;
} // CECMD_GUIMACRO
case CECMD_CMDSTARTSTOP:
{
CRealServer* pRSrv = NULL;
CVConGuard VCon;
DWORD nSrvPID = pIn->hdr.nSrcPID;
DWORD nMonitorTID = (pIn->DataSize() >= sizeof(pIn->StartStop)) ? pIn->StartStop.dwAID : 0;
if (CVConGroup::GetVConBySrvPID(nSrvPID, nMonitorTID, &VCon))
pRSrv = &VCon->RCon()->m_RConServer;
if (pRSrv)
{
CESERVER_REQ* pOut = pRSrv->cmdStartStop(pInst, pIn, pIn->DataSize());
if (pOut)
{
DWORD nDataSize = pOut->DataSize();
pcbReplySize = pOut->hdr.cbSize;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pOut->hdr.nCmd, pcbReplySize))
{
if (nDataSize > 0)
{
memmove(ppReply->Data, pOut->Data, nDataSize);
}
lbRc = TRUE;
}
ExecuteFreeResult(pOut);
}
}
break;
} // CECMD_CMDSTARTSTOP
//case CECMD_DEFTERMSTARTED:
//{
// if (gpConEmu->mp_DefTrm)
// gpConEmu->mp_DefTrm->OnDefTermStarted(pIn);
// pcbReplySize = sizeof(CESERVER_REQ_HDR);
// if (!ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
// goto wrap;
// lbRc = TRUE;
// break;
//} // CECMD_DEFTERMSTARTED
default:
_ASSERTE(FALSE && "Command was not handled in CGuiServer::GuiServerCommand");
}
//// Освободить память
//if (pIn && (LPVOID)pIn != (LPVOID)&in)
//{
// free(pIn); pIn = NULL;
//}
wrap:
return lbRc;
}
bool CDpiForDialog::Attach(HWND hWnd, HWND hCenterParent, CDynDialog* apDlgTemplate)
{
mh_Dlg = hWnd;
wchar_t szLog[100];
mn_TemplateFontSize = apDlgTemplate ? apDlgTemplate->GetFontPointSize() : 8;
mh_OldFont = (HFONT)SendMessage(hWnd, WM_GETFONT, 0, 0);
if ((mh_OldFont != NULL)
&& (GetObject(mh_OldFont, sizeof(mlf_InitFont), &mlf_InitFont) > 0))
{
_wsprintf(szLog, SKIPLEN(countof(szLog)) L"CDpiForDialog(x%08X) Font='%s' lfHeight=%i Points=%u", (DWORD)(DWORD_PTR)hWnd, mlf_InitFont.lfFaceName, mlf_InitFont.lfHeight, mn_TemplateFontSize);
}
else
{
ZeroStruct(mlf_InitFont);
mlf_InitFont.lfHeight = GetFontSizeForDpi(NULL, 96);
lstrcpyn(mlf_InitFont.lfFaceName, L"MS Shell Dlg", countof(mlf_InitFont.lfFaceName));
mlf_InitFont.lfWeight = 400;
mlf_InitFont.lfCharSet = DEFAULT_CHARSET;
_wsprintf(szLog, SKIPLEN(countof(szLog)) L"CDpiForDialog(x%08X) DefaultFont='%s' lfHeight=%i Points=%u", (DWORD)(DWORD_PTR)hWnd, mlf_InitFont.lfFaceName, mlf_InitFont.lfHeight, mn_TemplateFontSize);
}
LogString(szLog);
// Up to Windows 8 - OS will care of dialog scaling
// And what will happens in Windows 8.1?
// If `Per-monitor` dpi was choosed in the OS settings,
// we need to re-scale our dialog manually!
// But if one dpi was choosed for all monitors?
CDpiAware::QueryDpiForMonitor(NULL, &m_InitDpi); // Whole desktop DPI (in most cases that will be Primary monitor DPI)
m_CurDpi.SetDpi(m_InitDpi);
if (!m_Items.Initialized())
m_Items.Init(8);
bool bPerMonitor = CDpiAware::IsPerMonitorDpi();
DEBUGTEST(bPerMonitor = true);
if (bPerMonitor)
{
// When Windows 8.1 is in per-monitor mode
// and application is marked as per-monitor-dpi aware
// Windows does not resize dialogs automatically.
// Our resources are designed for standard 96 dpi.
MArray<DlgItem>* p = NULL;
if (m_Items.Get(m_CurDpi.Ydpi, &p) && p)
delete p;
p = LoadDialogItems(hWnd);
m_Items.Set(m_CurDpi.Ydpi, p);
DpiValue CurMonDpi;
CDpiAware::QueryDpi(hCenterParent ? hCenterParent : hWnd, &CurMonDpi);
// Need to resize the dialog?
if (m_CurDpi.Ydpi != CurMonDpi.Ydpi)
{
if (!SetDialogDPI(CurMonDpi))
return false;
}
}
else
{
m_CurDpi.SetDpi(m_InitDpi.Xdpi, m_InitDpi.Ydpi);
}
return true;
}
void * CreateInputWrapper(void *real)
{
LOG::logline(">> CreateInputWrapper");
// Load macros and triggers
DWORD unused;
HANDLE keyfile = CreateFileA("MGE3\\DInput.data", GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
if(keyfile != INVALID_HANDLE_VALUE)
{
BYTE version;
ReadFile(keyfile, &version, 1, &unused, NULL);
if(version == MGE_SAVE_VERSION)
{
bool DisableConsole; // no longer supported, used for file format compatibility
ReadFile(keyfile, &SkipIntro, 1, &unused, NULL);
ReadFile(keyfile, &DisableConsole, 1, &unused, NULL);
ReadFile(keyfile, &UseAltCombatWrapper, 1, &unused, NULL);
ReadFile(keyfile, &FakeKeys, sizeof(FakeKeys), &unused, NULL);
ReadFile(keyfile, &Triggers, sizeof(Triggers), &unused, NULL);
}
else
{
LOG::logline("MGE\\dinput.data appears to be out of date.\n"
"You need to run MGEXEgui at least once to update the save files.");
}
CloseHandle(keyfile);
}
else
{
LOG::logline("Could not open MGE\\dinput.data for reading.\n"
"You need to run MGEXEgui at least once to create the save files.");
}
// Initial state
GlobalHammer = true; // Used to hammer keys (alternates between up/down)
FakeBufferStart = 0;
FakeBufferEnd = 0;
FinishedFake = false; // true to shut down the console
CloseConsole = false; // true to shut the console after performing a command
ZeroStruct(RemappedKeys);
ZeroStruct(LastBytes);
ZeroStruct(FakeStates);
ZeroStruct(FakeBuffer);
for(int i = 0; i != MAXTRIGGERS; ++i)
TriggerFireTimes[i] = GetTickCount() + Triggers[i].TimeInterval;
// Initialize the array of macro function pointers
for(int i = 0; i != GRAPHICSFUNCS; ++i)
FakeFuncs[i] = stub;
FakeFuncs[GF_Screenshot] = MacroFunctions::TakeScreenshot;
FakeFuncs[GF_ToggleZoom] = MacroFunctions::ToggleZoom;
FakeFuncs[GF_IncreaseZoom] = MacroFunctions::IncreaseZoom;
FakeFuncs[GF_DecreaseZoom] = MacroFunctions::DecreaseZoom;
FakeFuncs[GF_ToggleText] = MacroFunctions::ToggleStatusText;
FakeFuncs[GF_ShowLastText] = MacroFunctions::ShowLastMessage;
FakeFuncs[GF_ToggleFps] = MacroFunctions::ToggleFpsCounter;
FakeFuncs[GF_ToggleCrosshair] = MacroFunctions::ToggleCrosshair;
FakeFuncs[GF_NextTrack] = MacroFunctions::NextTrack;
FakeFuncs[GF_DisableMusic] = MacroFunctions::DisableMusic;
FakeFuncs[GF_IncreaseFOV] = MacroFunctions::IncreaseFOV;
FakeFuncs[GF_DecreaseFOV] = MacroFunctions::DecreaseFOV;
FakeFuncs[GF_HaggleMore1] = MacroFunctions::HaggleMore1;
FakeFuncs[GF_HaggleMore10] = MacroFunctions::HaggleMore10;
FakeFuncs[GF_HaggleMore100] = MacroFunctions::HaggleMore100;
FakeFuncs[GF_HaggleMore1000] = MacroFunctions::HaggleMore1000;
FakeFuncs[GF_HaggleMore10000] = MacroFunctions::HaggleMore10000;
FakeFuncs[GF_HaggleLess1] = MacroFunctions::HaggleLess1;
FakeFuncs[GF_HaggleLess10] = MacroFunctions::HaggleLess10;
FakeFuncs[GF_HaggleLess100] = MacroFunctions::HaggleLess100;
FakeFuncs[GF_HaggleLess1000] = MacroFunctions::HaggleLess1000;
FakeFuncs[GF_HaggleLess10000] = MacroFunctions::HaggleLess10000;
FakeFuncs[GF_Shader] = MacroFunctions::ToggleShaders;
FakeFuncs[GF_ToggleDL] = MacroFunctions::ToggleDistantLand;
FakeFuncs[GF_ToggleShadows] = MacroFunctions::ToggleShadows;
FakeFuncs[GF_ToggleGrass] = MacroFunctions::ToggleGrass;
FakeFuncs[GF_ToggleMwMgeBlending] = MacroFunctions::ToggleBlending;
FakeFuncs[GF_ToggleLightingMode] = MacroFunctions::ToggleLightingMode;
FakeFuncs[GF_MoveForward3PC] = MacroFunctions::MoveForward3PCam;
FakeFuncs[GF_MoveBack3PC] = MacroFunctions::MoveBack3PCam;
FakeFuncs[GF_MoveLeft3PC] = MacroFunctions::MoveLeft3PCam;
FakeFuncs[GF_MoveRight3PC] = MacroFunctions::MoveRight3PCam;
FakeFuncs[GF_MoveDown3PC] = MacroFunctions::MoveDown3PCam;
FakeFuncs[GF_MoveUp3PC] = MacroFunctions::MoveUp3PCam;
// Force screenshots from PrintScreen
FakeKeys[0xb7].type = FKT_Graphics;
FakeKeys[0xb7].Graphics.function = GF_Screenshot;
LOG::logline("<< CreateInputWrapper");
return new MGEProxyDirectInput((IDirectInput8A*)real);
}
void VConTextPart::Done(uint anLen, uint FontWidth)
{
_ASSERTE(anLen>0 && FontWidth>0);
Length = anLen;
TotalWidth = MinWidth = 0;
// May this part be shrinked freely?
if (Flags & TRF_TextSpacing)
{
Flags |= TRF_SizeFree;
}
else if ((Flags & TRF_TextPseudograph) && isCharPseudoFree(*Chars))
{
wchar_t wc = *Chars; bool bDiffers = false;
for (uint i = 1; i < Length; i++)
{
if (Chars[i] != wc)
{
bDiffers = true; break;
}
}
if (!bDiffers)
Flags |= TRF_SizeFree;
}
// Helper - double cell characters
uint FontWidth2 = 2*FontWidth;
uint FontWidth2M = FontWidth2 * DEF_DOUBLE_MUL / DEF_DOUBLE_DIV;
uint FontWidthM = FontWidth * DEF_SINGLE_MUL / DEF_SINGLE_DIV;
const wchar_t* pch = Chars;
const CharAttr* pca = Attrs;
TextCharType* pcf = CharFlags;
uint* pcw = CharWidth;
ZeroStruct(AllWidths);
//TODO: Continuous spaces must be processed separately
if (Flags & TRF_SizeFree)
{
VConTextPartWidth& aw = AllWidths[TCF_WidthFree];
for (uint left = anLen; left--; pch++, pca++, pcf++, pcw++)
{
_ASSERTE(!(pca->Flags2 & (CharAttr2_NonSpacing|CharAttr2_Combining|CharAttr2_DoubleSpaced)));
*pcw = FontWidth; // if non-shrinked
*pcf = TCF_WidthFree;
TotalWidth += FontWidth;
aw.Count++;
aw.Width += FontWidth;
}
aw.MinWidth += FontWidth;
}
else
{
for (uint left = anLen; left--; pch++, pca++, pcf++, pcw++)
{
if (pca->Flags2 & (CharAttr2_NonSpacing|CharAttr2_Combining))
{
// zero-width
*pcw = 0;
*pcf = TCF_WidthZero;
VConTextPartWidth& aw = AllWidths[TCF_WidthZero];
aw.Count++; // Informational
}
else if (pca->Flags2 & CharAttr2_DoubleSpaced)
{
*pcw = FontWidth2;
*pcf = TCF_WidthDouble;
TotalWidth += FontWidth2;
// Even double-width space have to be same width as ‘normal’ CJK glyph
MinWidth += FontWidth2M;
VConTextPartWidth& aw = AllWidths[TCF_WidthDouble];
aw.Count++;
aw.Width += FontWidth2;
aw.MinWidth += FontWidth2M;
}
else /*if (gpSet->isMonospace
|| (gpSet->isFixFarBorders && isCharAltFont(ch))
|| (gpSet->isEnhanceGraphics && isCharProgress(ch))
)*/
{
//TODO: Caller must process fonts and set "real" character widths for proportinal fonts
*pcw = FontWidth;
*pcf = TCF_WidthNormal;
VConTextPartWidth& aw = AllWidths[TCF_WidthNormal];
aw.Count++;
aw.Width += FontWidth;
aw.MinWidth += FontWidthM;
}
}
}
TotalWidth = AllWidths[TCF_WidthFree].Width
+ AllWidths[TCF_WidthNormal].Width
+ AllWidths[TCF_WidthDouble].Width
;
MinWidth = AllWidths[TCF_WidthFree].MinWidth
+ AllWidths[TCF_WidthNormal].MinWidth
+ AllWidths[TCF_WidthDouble].MinWidth
;
}
int RemoveFileDACLs(LPCTSTR pszPath, BOOL fDiagnostic, BPRINT_BUFFER *pbp)
{
//
// make sure that we have ESE_SECURITY priviledge
//
int err = 0;
if ( ! AddLocalPrivilege(ESE_SECURITY))
{
err = GetLastError();
if (fDiagnostic)
ReportError(err, "AdjustTokenPrivileges");
}
// setup globals, this do nothing if this is not the first time
// this function was called.
//
InitStandardSids(fDiagnostic, pbp);
InitUserSid(fDiagnostic, pbp);
InitOwnerSid(fDiagnostic, pbp);
//
// Attempt to put a NULL Dacl on the file/directory
//
SECURITY_DESCRIPTOR si;
ZeroStruct(&si);
InitializeSecurityDescriptor(&si, SECURITY_DESCRIPTOR_REVISION);
#pragma warning(suppress: 6248) // Setting a SECURITY_DESCRIPTOR's DACL to NULL will result in an unprotected object
SetSecurityDescriptorDacl (&si, TRUE, NULL, FALSE);
if ( ! SetFileSecurity(pszPath, DACL_SECURITY_INFORMATION, &si))
{
err = GetLastError();
if (fDiagnostic)
ReportError (err, "SetFileSecurity(DACL)[1] ", pszPath);
}
else
{
if (fDiagnostic)
{
if (bprint_IsEmpty(*pbp))
bprintfl(*pbp, "DACLs removed from %s", pszPath);
else
bprint(*pbp, " DACLs removed");
}
return 0;
}
//
// Attempt to make take ownership of the file.
//
SetSecurityDescriptorOwner (&si, ls.OwnerSid, FALSE);
if (SetFileSecurity(pszPath, OWNER_SECURITY_INFORMATION, &si))
err = 0;
else
{
err = GetLastError();
if (fDiagnostic)
ReportError (err, "SetFileSecurity(Owner)[1] ", pszPath);
//ZeroStruct(&si);
//InitializeSecurityDescriptor(&si, SECURITY_DESCRIPTOR_REVISION);
//SetSecurityDescriptorOwner (&si, ls.OwnerSid, FALSE);
if ( ! AddLocalPrivilege(ESE_TAKE_OWNERSHIP))
{
static bool fReportedSeTakeOwner = false;
if (fDiagnostic && ! fReportedSeTakeOwner)
{
ReportError(GetLastError(), "SeTakeOwnership ", pszPath);
fReportedSeTakeOwner = true;
}
}
else if ( ! SetFileSecurity(pszPath, OWNER_SECURITY_INFORMATION, &si))
{
err = GetLastError();
if (fDiagnostic)
ReportError (err, "SetFileSecurity(Owner)[2] ", pszPath);
}
else
{
err = 0;
}
}
// if we successfully took ownership, try again to set a NULL DACL
//
if ( ! err)
{
if (fDiagnostic)
{
if (bprint_IsEmpty(*pbp))
bprintfl(*pbp, "Ownership taken of %s", pszPath);
else
bprint(*pbp, " Ownership taken");
}
if ( ! SetFileSecurity(pszPath, DACL_SECURITY_INFORMATION, &si))
{
err = GetLastError();
if (fDiagnostic)
ReportError (err, "SetFileSecurity(DACL)[2] ", pszPath);
}
else
{
if (fDiagnostic)
{
if (bprint_IsEmpty(*pbp))
bprintfl(*pbp, "DACLs removed from %s", pszPath);
else
bprintfl(*pbp, " DACLs removed", pszPath);
}
return 0;
}
}
return err;
}
// используется в GUI при загрузке настроек
void FindComspec(ConEmuComspec* pOpt, bool bCmdAlso /*= true*/)
{
if (!pOpt)
return;
pOpt->Comspec32[0] = 0;
pOpt->Comspec64[0] = 0;
// Ищем tcc.exe
if (pOpt->csType == cst_AutoTccCmd)
{
HKEY hk;
BOOL bWin64 = IsWindows64();
wchar_t szPath[MAX_PATH+1];
// If tcc.exe can be found near to ConEmu location
LPCWSTR ppszPredefined[] = {
L"%ConEmuBaseDir%\\tcc.exe",
L"%ConEmuDir%\\tcc.exe",
// Sort of PortableApps locations
L"%ConEmuDir%\\..\\tcc\\tcc.exe",
L"%ConEmuDir%\\..\\..\\tcc\\tcc.exe",
// End of predefined list
NULL};
for (INT_PTR i = 0; ppszPredefined[i]; i++)
{
DWORD nExpand = ExpandEnvironmentStrings(ppszPredefined[i], szPath, countof(szPath));
if (nExpand && (nExpand < countof(szPath)))
{
if (FileExists(szPath))
{
wcscpy_c(pOpt->Comspec32, szPath);
wcscpy_c(pOpt->Comspec64, szPath);
break;
}
}
}
// On this step - check "Take Command"!
if (!*pOpt->Comspec32 || !*pOpt->Comspec64)
{
// [HKEY_LOCAL_MACHINE\SOFTWARE\JP Software\Take Command 13.0]
// @="\"C:\\Program Files\\JPSoft\\TCMD13\\tcmd.exe\""
for (int b = 0; b <= 1; b++)
{
// b==0 - 32bit, b==1 - 64bit
if (b && !bWin64)
continue;
bool bFound = false;
DWORD nOpt = (b == 0) ? (bWin64 ? KEY_WOW64_32KEY : 0) : (bWin64 ? KEY_WOW64_64KEY : 0);
if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\JP Software", 0, KEY_READ|nOpt, &hk))
{
wchar_t szName[MAX_PATH+1]; DWORD nLen;
for (DWORD k = 0; !bFound && !RegEnumKeyEx(hk, k, szName, &(nLen = countof(szName)-1), 0,0,0,0); k++)
{
HKEY hk2;
if (!RegOpenKeyEx(hk, szName, 0, KEY_READ|nOpt, &hk2))
{
// Just in case, check "Path" too
LPCWSTR rsNames[] = {NULL, L"Path"};
for (size_t n = 0; n < countof(rsNames); n++)
{
ZeroStruct(szPath); DWORD nSize = (countof(szPath)-1)*sizeof(szPath[0]);
if (!RegQueryValueExW(hk2, rsNames[n], NULL, NULL, (LPBYTE)szPath, &nSize) && *szPath)
{
wchar_t* psz, *pszEnd;
psz = (wchar_t*)Unquote(szPath, true);
pszEnd = wcsrchr(psz, L'\\');
if (!pszEnd || lstrcmpi(pszEnd, L"\\tcmd.exe") || !FileExists(psz))
continue;
lstrcpyn(pszEnd+1, L"tcc.exe", 8);
if (FileExists(psz))
{
bFound = true;
if (b == 0)
wcscpy_c(pOpt->Comspec32, psz);
else
wcscpy_c(pOpt->Comspec64, psz);
}
}
} // for (size_t n = 0; n < countof(rsNames); n++)
RegCloseKey(hk2);
}
} // for, подключи
RegCloseKey(hk);
} // L"SOFTWARE\\JP Software"
} // for (int b = 0; b <= 1; b++)
// Если установлен TCMD - предпочтительно использовать именно его, независимо от битности
if (*pOpt->Comspec32 && !*pOpt->Comspec64)
wcscpy_c(pOpt->Comspec64, pOpt->Comspec32);
else if (*pOpt->Comspec64 && !*pOpt->Comspec32)
wcscpy_c(pOpt->Comspec32, pOpt->Comspec64);
}
// If "Take Command" not installed - try "TCC/LE"
if (!*pOpt->Comspec32 || !*pOpt->Comspec64)
{
// [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{16A21882-4138-4ADA-A390-F62DC27E4504}]
// "DisplayVersion"="13.04.60"
// "Publisher"="JP Software"
// "DisplayName"="Take Command 13.0"
// или
// "DisplayName"="TCC/LE 13.0"
// и наконец
// "InstallLocation"="C:\\Program Files\\JPSoft\\TCMD13\\"
for (int b = 0; b <= 1; b++)
{
// b==0 - 32bit, b==1 - 64bit
if (b && !bWin64)
continue;
if (((b == 0) ? *pOpt->Comspec32 : *pOpt->Comspec64))
continue; // этот уже нашелся в TCMD
bool bFound = false;
DWORD nOpt = (b == 0) ? (bWin64 ? KEY_WOW64_32KEY : 0) : (bWin64 ? KEY_WOW64_64KEY : 0);
if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", 0, KEY_READ|nOpt, &hk))
{
wchar_t szName[MAX_PATH+1]; DWORD nLen;
for (DWORD n = 0; !bFound && !RegEnumKeyEx(hk, n, szName, &(nLen = countof(szName)-1), 0,0,0,0); n++)
{
if (*szName != L'{')
continue;
HKEY hk2;
if (!RegOpenKeyEx(hk, szName, 0, KEY_READ|nOpt, &hk2))
{
ZeroStruct(szPath); DWORD nSize = (countof(szPath) - 1)*sizeof(szPath[0]);
if (!RegQueryValueExW(hk2, L"Publisher", NULL, NULL, (LPBYTE)szPath, &nSize)
&& !lstrcmpi(szPath, L"JP Software"))
{
nSize = (countof(szPath)-12)*sizeof(szPath[0]);
if (!RegQueryValueExW(hk2, L"InstallLocation", NULL, NULL, (LPBYTE)szPath, &nSize)
&& *szPath)
{
wchar_t* psz, *pszEnd;
if (szPath[0] == L'"')
{
psz = szPath + 1;
pszEnd = wcschr(psz, L'"');
if (pszEnd)
*pszEnd = 0;
}
else
{
psz = szPath;
}
if (*psz)
{
pszEnd = psz+lstrlen(psz);
if (*(pszEnd-1) != L'\\')
*(pszEnd++) = L'\\';
lstrcpyn(pszEnd, L"tcc.exe", 8);
if (FileExists(psz))
{
bFound = true;
if (b == 0)
wcscpy_c(pOpt->Comspec32, psz);
else
wcscpy_c(pOpt->Comspec64, psz);
}
}
}
}
RegCloseKey(hk2);
}
} // for, подключи
RegCloseKey(hk);
} // L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
} // for (int b = 0; b <= 1; b++)
}
// Попытаться "в лоб" из "Program Files"
if (!*pOpt->Comspec32 && !*pOpt->Comspec64)
{
const wchar_t* pszTcmd = L"C:\\Program Files\\JPSoft\\TCMD13\\tcc.exe";
const wchar_t* pszTccLe = L"C:\\Program Files\\JPSoft\\TCCLE13\\tcc.exe";
if (FileExists(pszTcmd))
wcscpy_c(pOpt->Comspec32, pszTcmd);
else if (FileExists(pszTccLe))
wcscpy_c(pOpt->Comspec32, pszTccLe);
}
if (*pOpt->Comspec32 && !*pOpt->Comspec64)
wcscpy_c(pOpt->Comspec64, pOpt->Comspec32);
else if (*pOpt->Comspec64 && !*pOpt->Comspec32)
wcscpy_c(pOpt->Comspec32, pOpt->Comspec64);
} // if (pOpt->csType == cst_AutoTccCmd)
// С поиском tcc закончили. Теперь, если pOpt->Comspec32/pOpt->Comspec64 остались не заполнены
// нужно сначала попытаться обработать переменную окружения ComSpec, а потом - просто "cmd.exe"
if (!*pOpt->Comspec32)
GetComspecFromEnvVar(pOpt->Comspec32, countof(pOpt->Comspec32), csb_x32);
if (!*pOpt->Comspec64)
GetComspecFromEnvVar(pOpt->Comspec64, countof(pOpt->Comspec64), csb_x64);
}
// Returns the index (new or existing) in the gpIconHandles
static int EditIconHintCreateHandles(HWND hEditCtrl, CToolImg** pIcon = NULL, HFONT* phFont = NULL)
{
if (pIcon)
*pIcon = NULL;
if (phFont)
*phFont = NULL;
if (!gpIconHandles)
{
_ASSERTE(gpIconHandles!=NULL && "Must be already initialized!");
return 0;
}
// Current control font
HFONT hf = (HFONT)SendMessage(hEditCtrl, WM_GETFONT, 0, 0);
LOGFONT lf = {};
RECT rcClient = {}; GetClientRect(hEditCtrl, &rcClient);
//CreateFont(nFontHeight, 0, 0, 0, FW_NORMAL, TRUE/*Italic*/, FALSE, 0,
// DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_SWISS,
// L"Tahoma");
if ((hf == NULL)
|| (GetObject(hf, sizeof(lf), &lf) <= 0))
{
ZeroStruct(lf);
lf.lfHeight = rcClient.bottom - 4;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
}
// And change other properties to our font style
lf.lfWidth = 0;
lf.lfEscapement = 0;
lf.lfOrientation = 0;
lf.lfWeight = FW_NORMAL;
lf.lfItalic = TRUE;
lf.lfUnderline = 0;
lf.lfStrikeOut = 0;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfQuality = DEFAULT_QUALITY;
lf.lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
lstrcpyn(lf.lfFaceName, L"Tahoma", countof(lf.lfFaceName));
// Check first, if there is already created handles for that resolution?
CEIconDrawHandles dh = {};
if (!gpIconHandles->Get(lf.lfHeight, &dh))
{
// Need to be created
dh.pIcon = new CToolImg();
if (dh.pIcon && !dh.pIcon->CreateSearchButton())
{
SafeDelete(dh.pIcon);
}
dh.hFont = CreateFontIndirect(&lf);
if (!dh.hFont)
{
_ASSERTE(dh.hFont!=NULL);
return 0;
}
gpIconHandles->Set(lf.lfHeight, dh);
}
if (pIcon)
*pIcon = dh.pIcon;
if (phFont)
*phFont = dh.hFont;
return lf.lfHeight;
}
bool CPluginW2800::GetPanelItemInfo(const CEPanelInfo& PnlInfo, bool bSelected, INT_PTR iIndex, WIN32_FIND_DATAW& Info, wchar_t** ppszFullPathName)
{
if (!InfoW2800 || !InfoW2800->PanelControl)
return false;
FILE_CONTROL_COMMANDS iCmd = bSelected ? FCTL_GETSELECTEDPANELITEM : FCTL_GETPANELITEM;
INT_PTR iItemsNumber = bSelected ? ((PanelInfo*)PnlInfo.panelInfo)->SelectedItemsNumber : ((PanelInfo*)PnlInfo.panelInfo)->ItemsNumber;
if ((iIndex < 0) || (iIndex >= iItemsNumber))
{
_ASSERTE(FALSE && "iItem out of bounds");
return false;
}
INT_PTR sz = PanelControlApi(PANEL_ACTIVE, iCmd, iIndex, NULL);
if (sz <= 0)
return false;
PluginPanelItem* pItem = (PluginPanelItem*)calloc(sz, 1); // размер возвращается в байтах
if (!pItem)
return false;
FarGetPluginPanelItem gppi = {sizeof(gppi), sz, pItem};
if (PanelControlApi(PANEL_ACTIVE, iCmd, iIndex, &gppi) <= 0)
{
free(pItem);
return false;
}
ZeroStruct(Info);
Info.dwFileAttributes = LODWORD(pItem->FileAttributes);
Info.ftCreationTime = pItem->CreationTime;
Info.ftLastAccessTime = pItem->LastAccessTime;
Info.ftLastWriteTime = pItem->LastWriteTime;
Info.nFileSizeLow = LODWORD(pItem->FileSize);
Info.nFileSizeHigh = HIDWORD(pItem->FileSize);
if (pItem->FileName)
{
LPCWSTR pszName = pItem->FileName;
int iLen = lstrlen(pszName);
// If full paths exceeds MAX_PATH chars - return in Info.cFileName the file name only
if (iLen >= countof(Info.cFileName))
pszName = PointToName(pItem->FileName);
lstrcpyn(Info.cFileName, pszName, countof(Info.cFileName));
if (ppszFullPathName)
*ppszFullPathName = lstrdup(pItem->FileName);
}
else if (ppszFullPathName)
{
_ASSERTE(*ppszFullPathName == NULL);
*ppszFullPathName = NULL;
}
if (pItem->AlternateFileName)
{
lstrcpyn(Info.cAlternateFileName, pItem->AlternateFileName, countof(Info.cAlternateFileName));
}
free(pItem);
return true;
}
UINT ExecuteDownloader(LPWSTR pszCommand, LPWSTR szCmdDirectory)
{
UINT iRc;
DWORD nWait;
DWORD nThreadWait = WAIT_TIMEOUT;
PipeThreadParm threadParm = {this};
ZeroStruct(m_SI); m_SI.cb = sizeof(m_SI);
ZeroStruct(m_PI);
mb_Terminating = false;
DWORD nCreateFlags = 0
//| CREATE_NO_WINDOW
| NORMAL_PRIORITY_CLASS;
m_SI.dwFlags |= STARTF_USESHOWWINDOW;
m_SI.wShowWindow = RELEASEDEBUGTEST(SW_HIDE,SW_SHOWNA);
if (!szCmdStringFormat || !*szCmdStringFormat)
{
// We need to redirect only StdError output
SECURITY_ATTRIBUTES saAttr = {sizeof(saAttr), NULL, TRUE};
if (!CreatePipe(&mh_PipeErrRead, &mh_PipeErrWrite, &saAttr, 0))
{
iRc = GetLastError();
_ASSERTE(FALSE && "CreatePipe was failed");
if (!iRc)
iRc = E_UNEXPECTED;
goto wrap;
}
// Ensure the read handle to the pipe for STDOUT is not inherited.
SetHandleInformation(mh_PipeErrRead, HANDLE_FLAG_INHERIT, 0);
mh_PipeErrThread = apiCreateThread(StdErrReaderThread, (LPVOID)&threadParm, &mn_PipeErrThreadId, "Downloader::ReaderThread");
if (mh_PipeErrThread != NULL)
{
m_SI.dwFlags |= STARTF_USESTDHANDLES;
// Let's try to change only Error pipe?
m_SI.hStdError = mh_PipeErrWrite;
}
}
// Now we can run the downloader
if (!CreateProcess(NULL, pszCommand, NULL, NULL, TRUE/*!Inherit!*/, nCreateFlags, NULL, szCmdDirectory, &m_SI, &m_PI))
{
iRc = GetLastError();
_ASSERTE(FALSE && "Create downloader process was failed");
if (!iRc)
iRc = E_UNEXPECTED;
goto wrap;
}
nWait = WaitForSingleObject(m_PI.hProcess, INFINITE);
if (GetExitCodeProcess(m_PI.hProcess, &nWait)
&& (nWait == 0)) // CERR_DOWNLOAD_SUCCEEDED is not returned for compatibility purposes
{
iRc = 0; // OK
}
else
{
_ASSERTE(nWait == 0 && "Downloader has returned an error");
iRc = nWait;
}
wrap:
// Finalize reading routine
mb_Terminating = true;
if (mh_PipeErrThread)
{
nThreadWait = WaitForSingleObject(mh_PipeErrThread, 0);
if (nThreadWait == WAIT_TIMEOUT)
{
apiCancelSynchronousIo(mh_PipeErrThread);
}
}
SafeCloseHandle(mh_PipeErrRead);
SafeCloseHandle(mh_PipeErrWrite);
if (mh_PipeErrThread)
{
if (nThreadWait == WAIT_TIMEOUT)
{
nThreadWait = WaitForSingleObject(mh_PipeErrThread, 5000);
}
if (nThreadWait == WAIT_TIMEOUT)
{
_ASSERTE(FALSE && "StdErr reading thread hangs, terminating");
apiTerminateThread(mh_PipeErrThread, 999);
}
SafeCloseHandle(mh_PipeErrThread);
}
// Exit
return iRc;
};
void IPAddress::CreateCommon() {
ZeroStruct(m_sin6);
AddressFamily = Ext::AddressFamily::InterNetwork;
}
void MGEOnProcessStart(HANDLE pipe) {
// Set variables dependent on configuration
switch (FogMode) {
case 2:
FogPixelMode = 0;
FogVertexMode = 3;
RangedFog = 1;
break;
case 1:
FogPixelMode = 0;
FogVertexMode = 3;
RangedFog = 0;
break;
default:
FogPixelMode = 3;
FogVertexMode = 0;
RangedFog = 0;
break;
}
if (!(MGEFlags & REFLECTIVE_WATER)) {
BitReset(&MGEFlags, REFLECT_NEAR_BIT);
BitReset(&MGEFlags, REFLECT_FAR_BIT);
}
if (!(MGEFlags & REFLECT_NEAR)) {
BitReset(&MGEFlags, REFLECT_FAR_BIT);
}
DL_WaterReflect = (BYTE)BitTst(&MGEFlags, REFLECTIVE_WATER_BIT) + (BYTE)BitTst(&MGEFlags, REFLECT_NEAR_BIT) + (BYTE)BitTst(&MGEFlags, REFLECT_FAR_BIT);
Rotation *= PI / 180;
ReactionSpeed = 1.0f / ReactionSpeed;
DL_DrawDist *= 8192.0f;
DL_NearStaticEnd *= 8192.0f;
DL_FarStaticEnd *= 8192.0f;
DL_VeryFarStaticEnd *= 8192.0f;
DL_AboveWaterFogStart *= 8192.0f;
DL_AboveWaterFogEnd *= 8192.0f;
DL_BelowWaterFogStart *= 8192.0f;
DL_BelowWaterFogEnd *= 8192.0f;
DL_InteriorFogStart *= 8192.0f;
DL_InteriorFogEnd *= 8192.0f;
for (int fog = 0; fog <= 9; ++fog) DL_FgOD[fog] /= 100.0f;
//zero all the structs
//ZeroStruct(Cam3Offset);
ZeroStruct(JointInfo);
//ZeroStruct(Options);
ZeroStruct(fpsString);
ZeroStruct(ShaderStruct);
ZeroStruct(RcpRes);
ZeroStruct(SinVar);
ZeroStruct(LinVar);
ZeroStruct(EyeVec);
ZeroStruct(EyePos);
ZeroStruct(SunVec);
ZeroStruct(SunCol);
ZeroStruct(AmbCol);
EyeVec.w=1;
//Set some values for some structs
fpsRect.bottom=35;
fpsRect.right=600;
fpsRect.left=5;
fpsRect.top=20;
StatusRect.bottom=50;
StatusRect.right=635;
StatusRect.left=5;
StatusRect.top=5;
fpsColor.a=255;
fpsColor.r=255;
fpsColor.b=255;
fpsColor.g=255;
fps=0;
//Setup any global variables
UsingDistantLand=false;
UseDistantStatics=true;
UseGrass=true;
RealDevice=NULL;
BackBuffer=NULL;
DepthTexture=NULL;
DepthBuffer=NULL;
StateBlock=0;
Font=NULL;
StatusStringTime=0;
//Scenecount
SceneCount=0;
HUDScene=-1;
AlphaScene=2;
SolarScene=-1;
Indoors=false;
UpdateScene=false;
LastSceneCount=0;
PixelShading=false;
StencilEnabled=false;
AlphaBlendEnabled=false;
AlphaTestEnabled=false;
SunEnabled=false;
LightsSet=false;
ShadowsDrawn=0;
NumDrawCalls=0;
WaterDrawn=false;
FogAlreadySet=false;
DlDoneHooking=false;
//fps variables (Could make an fps structure I suppose)
fpsLastTime=0;
fpsFrames=0;
fpsAdjusting=false;
//These are variables used for graphics features which cant be set by MGEgui
Zoom=false;
//FOV=4.0f;
FogRange=1.0f;
FogStart=0;
FogEnd=0;
//Rotation=(PI*Options.Rotation)/2;
D3DXMatrixRotationZ(&RotateMatrix,Rotation);
//MaxViewRange=STDMAXVIEWDISTANCE;
//MinViewRange=STDMINVIEWDISTANCE;
//MWSE stuff
//Lighting
ZeroStruct(LightIDs);
ActiveLights=0;
//STANDARD stuff
ZeroStruct(Objects);
UsedMWSEobjects=0;
ZeroStruct(HUDbits);
UsedHUDbits=0;
HUDsprite=NULL;
ZeroStruct(LoadedTextures);
LastTimer=0;
UsedMWSEShaders=0;
HookNextTexture=false;
NextTexIsWater=false;
NextHookIndex=0;
ZeroStruct(HookedTextures);
HookedShaderActive=0;
ActiveHookedShader=0;
for(int i=0;i<8;i++) SetHookedTextures[i]=255;
//Camera shake
CameraShake=false;
CameraShakeAmp=0;
CameraShakeChange=false;
CameraShakeChangeRate=0;
D3DXMatrixTranslation(&CameraShakeMatrix,0,0,0);
//fps independent stuff
FOVZooming=false;
FOVZoomRate=0;
FogZooming=false;
FogZoomRate=0;
RotSpinning=false;
RotSpinRate=0;
//Exterior lighting control
SunManual=false;
SunManColour=false;
SunManDir=false;
AmbientManual=false;
FogManual=false;
ClsManual=false;
SkyManual=false;
HUDManual=false;
ZeroStruct(SunDirection);
SunColour=D3DXCOLOR(0,0,0,0);
AmbientColour=0;
FogColour=0;
ClsColour=0;
SkyColour=0;
HUDColour=0xFFFFFFFF;
SunTexture=NULL;
//Texture spamming
TexRenderTarget=NULL;
TexCopyTo=NULL;
SufRenderTarget=NULL;
SufCopyTo=NULL;
ZeroStruct(TexDrawOrigin);
ZeroStruct(TexDrawScale);
//video stuff
LoadedVideoCount=0;
DistantLandActive=false; //phal
//Now init some stuff
//MWSE timer
TimerFrequency=0;
if(!QueryPerformanceFrequency((LARGE_INTEGER*)&TimerFrequency)) {
TimerFrequency=0;
DEBUGSTRING("Your computer has no high resolution performance counter available.\n"
"Some MGE features or plugins will not function correctly.\n");
}
MWSEpipe=pipe;
}
