bool
xplayerCone::GetPropertyByIndex (int aIndex,
NPVariant *_result)
{
XPLAYER_LOG_GETTER (aIndex, xplayerCone);
switch (Properties (aIndex)) {
case eAudio:
return ObjectVariant (_result, Plugin()->GetNPObject (xplayerPlugin::eConeAudio));
case eInput:
return ObjectVariant (_result, Plugin()->GetNPObject (xplayerPlugin::eConeInput));
case ePlaylist:
return ObjectVariant (_result, Plugin()->GetNPObject (xplayerPlugin::eConePlaylist));
case eVideo:
return ObjectVariant (_result, Plugin()->GetNPObject (xplayerPlugin::eConeVideo));
case eVersionInfo:
return StringVariant (_result, XPLAYER_CONE_VERSION);
case eIterator:
case eLog:
case eMessages:
XPLAYER_WARN_GETTER_UNIMPLEMENTED (aIndex, _result);
return NullVariant (_result);
}
return false;
}
void WINAPI ExitFARW3(void*)
{
CPluginBase::ShutdownPluginStep(L"ExitFARW3");
Plugin()->ExitFarCommon();
Plugin()->ExitFar();
CPluginBase::ShutdownPluginStep(L"ExitFARW3 - done");
}
void WINAPI SetStartupInfoW(void *aInfo)
{
#if 0
HMODULE h = LoadLibrary (L"Kernel32.dll");
FreeLibrary(h);
#endif
Plugin()->SetStartupInfoPtr(aInfo);
Plugin()->CommonPluginStartup();
}
void WINAPI SetStartupInfo(void *aInfo)
{
if (gFarVersion.dwVerMajor != 1)
{
gFarVersion.dwVerMajor = 1;
gFarVersion.dwVerMinor = 75;
}
Plugin()->SetStartupInfoPtr(aInfo);
Plugin()->CommonPluginStartup();
}
bool
xplayerConeVideo::SetPropertyByIndex (int aIndex,
const NPVariant *aValue)
{
XPLAYER_LOG_SETTER (aIndex, xplayerConeVideo);
switch (Properties (aIndex)) {
case eFullscreen: {
bool fullscreen;
if (!GetBoolFromArguments (aValue, 1, 0, fullscreen))
return false;
Plugin()->SetFullscreen (fullscreen);
return true;
}
case eAspectRatio:
case eSubtitle:
case eTeletext:
XPLAYER_WARN_SETTER_UNIMPLEMENTED (aIndex, _result);
return true;
case eHeight:
case eWidth:
return ThrowPropertyNotWritable ();
}
return false;
}
void cPlug::OnLoad()
{
if(IsScript()) {
if(!FindDestPlugin()) {
mLastError = _("Plugin not found.");
SaveMe();
return;
}
}
if(mLoadOnStartup) {
mReloadNext = false;
mUnloadNext = false;
Plugin();
}
if(mReloadNext) {
mReloadNext = false;
mUnloadNext = false;
Replug();
}
if(mUnloadNext) {
mUnloadNext = false;
Plugout();
SaveMe();
}
}
bool
xplayerGMPControls::GetPropertyByIndex (int aIndex,
NPVariant *_result)
{
XPLAYER_LOG_SETTER (aIndex, xplayerGMPControls);
switch (Properties (aIndex)) {
case eCurrentPosition:
/* attribute double currentPosition; */
return DoubleVariant (_result, double (Plugin()->GetTime()) / 1000.0);
case eCurrentItem:
/* attribute xplayerIGMPMedia currentItem; */
case eCurrentPositionTimecode:
/* attribute ACString currentPositionTimecode; */
case eCurrentPositionString:
/* readonly attribute ACString currentPositionString; */
XPLAYER_WARN_GETTER_UNIMPLEMENTED (aIndex, xplayerGMPControls);
return StringVariant (_result, "");
case eAudioLanguageCount:
/* readonly attribute long audioLanguageCount; */
case eCurrentAudioLanguage:
/* attribute long currentAudioLanguage; */
case eCurrentAudioLanguageIndex:
/* attribute long currentAudioLanguageIndex; */
case eCurrentMarker:
/* attribute long currentMarker; */
XPLAYER_WARN_GETTER_UNIMPLEMENTED (aIndex, xplayerGMPControls);
return Int32Variant (_result, 0);
}
return false;
}
bool
totemConePlaylist::GetPropertyByIndex (int aIndex,
NPVariant *_result)
{
TOTEM_LOG_GETTER (aIndex, totemConePlaylist);
switch (Properties (aIndex)) {
case eItems:
return ObjectVariant (_result, Plugin()->GetNPObject (totemPlugin::eConePlaylistItems));
case eIsPlaying:
return BoolVariant (_result, Plugin()->State() == TOTEM_STATE_PLAYING);
}
return false;
}
llvm::Expected<std::unique_ptr<ToolExecutor>>
createExecutorFromCommandLineArgsImpl(int &argc, const char **argv,
llvm::cl::OptionCategory &Category,
const char *Overview) {
auto OptionsParser =
CommonOptionsParser::create(argc, argv, Category, llvm::cl::ZeroOrMore,
/*Overview=*/Overview);
if (!OptionsParser)
return OptionsParser.takeError();
for (auto I = ToolExecutorPluginRegistry::begin(),
E = ToolExecutorPluginRegistry::end();
I != E; ++I) {
if (I->getName() != ExecutorName) {
continue;
}
std::unique_ptr<ToolExecutorPlugin> Plugin(I->instantiate());
llvm::Expected<std::unique_ptr<ToolExecutor>> Executor =
Plugin->create(*OptionsParser);
if (!Executor) {
return llvm::make_error<llvm::StringError>(
llvm::Twine("Failed to create '") + I->getName() +
"': " + llvm::toString(Executor.takeError()) + "\n",
llvm::inconvertibleErrorCode());
}
return std::move(*Executor);
}
return llvm::make_error<llvm::StringError>(
llvm::Twine("Executor \"") + ExecutorName + "\" is not registered.",
llvm::inconvertibleErrorCode());
}
PluginInfoStore::Plugin PluginInfoStore::findPlugin(String& mimeType, const KURL& url)
{
loadPluginsIfNecessary();
// First, check if we can get the plug-in based on its MIME type.
if (!mimeType.isNull()) {
Plugin plugin = findPluginForMIMEType(mimeType);
if (!plugin.path.isNull())
return plugin;
}
// Next, check if any plug-ins claim to support the URL extension.
String extension = pathExtension(url).lower();
if (!extension.isNull() && mimeType.isEmpty()) {
Plugin plugin = findPluginForExtension(extension, mimeType);
if (!plugin.path.isNull())
return plugin;
// Finally, try to get the MIME type from the extension in a platform specific manner and use that.
String extensionMimeType = getMIMETypeForExtension(extension);
if (!extensionMimeType.isNull()) {
Plugin plugin = findPluginForMIMEType(extensionMimeType);
if (!plugin.path.isNull()) {
mimeType = extensionMimeType;
return plugin;
}
}
}
return Plugin();
}
// watch non-modified -> modified editor status change
int WINAPI ProcessEditorInput(const INPUT_RECORD *Rec)
{
// Даже если мы не под эмулятором - просто запомним текущее состояние
//if (!ghConEmuWndDC) return 0; // Если мы не под эмулятором - ничего
Plugin()->ProcessEditorInputInternal(*Rec);
return 0;
}
void CPluginBackground::CheckPanelFolders(int anForceSetPlace /*= 0*/)
{
Plugin()->FillUpdateBackground(&m_Default);
// Заполнить текущее "место"
if (anForceSetPlace != 0)
m_Default.Place = (PaintBackgroundPlaces)anForceSetPlace;
else if (!gpTabs)
m_Default.Place = pbp_Panels;
else if (gnCurrentWindowType == WTYPE_EDITOR)
m_Default.Place = pbp_Editor;
else if (gnCurrentWindowType == WTYPE_VIEWER)
m_Default.Place = pbp_Viewer;
else if (m_Default.LeftPanel.bVisible || m_Default.RightPanel.bVisible)
{
_ASSERTE(gnCurrentWindowType == WTYPE_PANELS);
m_Default.Place = pbp_Panels;
}
if (IsParmChanged(&m_Default, &m_Last))
{
mn_ReqActions |= ra_UpdateBackground;
}
WARNING("Нужно бы перечитать его, при изменении данных в ConEmu!");
if (mb_ThNeedLoad && ghConEmuWndDC)
{
LoadThSet(TRUE/*мы уже в главной нити*/);
}
}
// export
// Возвращает TRUE в случае успешного выполнения
// (удалось активировать главную нить и выполнить в ней функцию CallBack)
// FALSE - в случае ошибки.
int WINAPI SyncExecute(HMODULE ahModule, SyncExecuteCallback_t CallBack, LONG_PTR lParam)
{
BOOL bResult = FALSE;
SyncExecuteArg args = {CMD__EXTERNAL_CALLBACK, ahModule, CallBack, lParam};
bResult = Plugin()->ProcessCommand(CMD__EXTERNAL_CALLBACK, TRUE/*bReqMainThread*/, &args);
return bResult;
}
PluginInfoStore::Plugin PluginInfoStore::infoForPluginWithPath(const String& pluginPath)
{
for (size_t i = 0; i < m_plugins.size(); ++i) {
if (m_plugins[i].path == pluginPath)
return m_plugins[i];
}
ASSERT_NOT_REACHED();
return Plugin();
}
// Эта функция используется только в ANSI
void WINAPI GetPluginInfo(void *piv)
{
if (gFarVersion.dwVerMajor != 1)
{
gFarVersion.dwVerMajor = 1;
gFarVersion.dwVerMinor = 75;
}
Plugin()->GetPluginInfoPtr(piv);
}
bool
idolConeAudio::GetPropertyByIndex (int aIndex,
NPVariant *_result)
{
IDOL_LOG_GETTER (aIndex, idolConeAudio);
switch (Properties (aIndex)) {
case eMute:
return BoolVariant (_result, Plugin()->IsMute());
case eVolume:
return Int32Variant (_result, Plugin()->Volume() * 200.0);
case eChannel:
case eTrack:
IDOL_WARN_GETTER_UNIMPLEMENTED (aIndex, _result);
return VoidVariant (_result);
}
return false;
}
bool
idolConeAudio::SetPropertyByIndex (int aIndex,
const NPVariant *aValue)
{
IDOL_LOG_SETTER (aIndex, idolConeAudio);
switch (Properties (aIndex)) {
case eVolume: {
int32_t volume;
if (!GetInt32FromArguments (aValue, 1, 0, volume))
return false;
Plugin()->SetVolume ((double) CLAMP (volume, 0, 200) / 200.0);
return true;
}
case eMute: {
if (!GetBoolFromArguments (aValue, 1, 0, mMute))
return false;
if (mMute) {
mSavedVolume = Plugin()->Volume();
Plugin()->SetVolume (0.0);
} else {
Plugin()->SetVolume (mSavedVolume);
}
return true;
}
case eChannel:
case eTrack:
IDOL_WARN_SETTER_UNIMPLEMENTED (aIndex, _result);
return true;
}
return false;
}
PluginInfoStore::Plugin PluginInfoStore::findPluginForMIMEType(const String& mimeType)
{
ASSERT(!mimeType.isNull());
for (size_t i = 0; i < m_plugins.size(); ++i) {
const Plugin& plugin = m_plugins[i];
for (size_t j = 0; j < plugin.info.mimes.size(); ++j) {
const MimeClassInfo& mimeClassInfo = plugin.info.mimes[j];
if (mimeClassInfo.type == mimeType)
return plugin;
}
}
return Plugin();
}
bool
totemConePlaylistItems::InvokeByIndex (int aIndex,
const NPVariant *argv,
uint32_t argc,
NPVariant *_result)
{
TOTEM_LOG_INVOKE (aIndex, totemConePlaylistItems);
switch (Methods (aIndex)) {
case eClear:
Plugin()->ClearPlaylist ();
return VoidVariant (_result);
}
return false;
}
CompilationDatabase *
CompilationDatabase::loadFromDirectory(StringRef BuildDirectory,
std::string &ErrorMessage) {
std::stringstream ErrorStream;
for (CompilationDatabasePluginRegistry::iterator
It = CompilationDatabasePluginRegistry::begin(),
Ie = CompilationDatabasePluginRegistry::end();
It != Ie; ++It) {
std::string DatabaseErrorMessage;
std::unique_ptr<CompilationDatabasePlugin> Plugin(It->instantiate());
if (CompilationDatabase *DB =
Plugin->loadFromDirectory(BuildDirectory, DatabaseErrorMessage))
return DB;
else
ErrorStream << It->getName() << ": " << DatabaseErrorMessage << "\n";
}
ErrorMessage = ErrorStream.str();
return NULL;
}
bool
xplayerConeVideo::GetPropertyByIndex (int aIndex,
NPVariant *_result)
{
XPLAYER_LOG_GETTER (aIndex, xplayerConeVideo);
switch (Properties (aIndex)) {
case eFullscreen:
return BoolVariant (_result, Plugin()->IsFullscreen());
case eAspectRatio:
case eHeight:
case eSubtitle:
case eTeletext:
case eWidth:
XPLAYER_WARN_GETTER_UNIMPLEMENTED (aIndex, _result);
return VoidVariant (_result);
}
return false;
}
PluginInfoStore::Plugin PluginInfoStore::findPluginForExtension(const String& extension, String& mimeType)
{
ASSERT(!extension.isNull());
for (size_t i = 0; i < m_plugins.size(); ++i) {
const Plugin& plugin = m_plugins[i];
for (size_t j = 0; j < plugin.info.mimes.size(); ++j) {
const MimeClassInfo& mimeClassInfo = plugin.info.mimes[j];
const Vector<String>& extensions = mimeClassInfo.extensions;
if (find(extensions.begin(), extensions.end(), extension) != extensions.end()) {
// We found a supported extension, set the correct MIME type.
mimeType = mimeClassInfo.type;
return plugin;
}
}
}
return Plugin();
}
bool
xplayerConeVideo::InvokeByIndex (int aIndex,
const NPVariant *argv,
uint32_t argc,
NPVariant *_result)
{
XPLAYER_LOG_INVOKE (aIndex, xplayerConeVideo);
switch (Methods (aIndex)) {
case eToggleFullscreen: {
/* FIXMEchpe this sucks */
NPVariant fullscreen;
BOOLEAN_TO_NPVARIANT (!Plugin()->IsFullscreen(), fullscreen);
return SetPropertyByIndex (eFullscreen, &fullscreen);
}
case eToggleTeletext:
XPLAYER_WARN_INVOKE_UNIMPLEMENTED (aIndex, xplayerConeVideo);
return VoidVariant (_result);
}
return false;
}
BOOL WINAPI PlugServerCommand(LPVOID pInst, CESERVER_REQ* pIn, CESERVER_REQ* &ppReply, DWORD &pcbReplySize, DWORD &pcbMaxReplySize, LPARAM lParam)
{
BOOL lbRc = FALSE;
BOOL fSuccess = FALSE;
MSectionThread SCT(csTabs);
if (pIn->hdr.cbSize < sizeof(CESERVER_REQ_HDR) || /*in.nSize < cbRead ||*/ pIn->hdr.nVersion != CESERVER_REQ_VER)
{
gpPlugServer->BreakConnection(pInst);
return FALSE;
}
UINT nDataSize = pIn->hdr.cbSize - sizeof(CESERVER_REQ_HDR);
// Все данные из пайпа получены, обрабатываем команду и возвращаем (если нужно) результат
switch (pIn->hdr.nCmd)
{
case CMD_LANGCHANGE:
{
_ASSERTE(nDataSize>=4); //-V112
// LayoutName: "00000409", "00010409", ...
// А HKL от него отличается, так что передаем DWORD
// HKL в x64 выглядит как: "0x0000000000020409", "0xFFFFFFFFF0010409"
DWORD hkl = pIn->dwData[0];
DWORD dwLastError = 0;
HKL hkl1 = NULL, hkl2 = NULL;
if (hkl)
{
WCHAR szLoc[10];
_wsprintf(szLoc, SKIPLEN(countof(szLoc)) L"%08x", hkl);
hkl1 = LoadKeyboardLayout(szLoc, KLF_ACTIVATE|KLF_REORDER|KLF_SUBSTITUTE_OK|KLF_SETFORPROCESS);
hkl2 = ActivateKeyboardLayout(hkl1, KLF_SETFORPROCESS|KLF_REORDER);
if (!hkl2)
dwLastError = GetLastError();
else
fSuccess = TRUE;
}
pcbReplySize = sizeof(CESERVER_REQ_HDR) + sizeof(DWORD)*2;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = fSuccess;
ppReply->dwData[1] = fSuccess ? ((DWORD)(LONG)(LONG_PTR)hkl2) : dwLastError;
}
break;
} // CMD_LANGCHANGE
#if 0
case CMD_DEFFONT:
{
// исключение - асинхронный, результат не требуется
SetConsoleFontSizeTo(FarHwnd, 4, 6);
MoveWindow(FarHwnd, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), 1); // чтобы убрать возможные полосы прокрутки...
break;
}
CMD_DEFFONT
#endif
case CMD_REQTABS:
case CMD_SETWINDOW:
{
MSectionLock SC;
SC.Lock(csTabs, FALSE, 1000);
DWORD nSetWindowWait = (DWORD)-1;
if (pIn->hdr.nCmd == CMD_SETWINDOW)
{
ResetEvent(ghSetWndSendTabsEvent);
// Для FAR2 - сброс QSearch выполняется в том же макро, в котором актирируется окно
if (gFarVersion.dwVerMajor == 1 && pIn->dwData[1])
{
// А вот для FAR1 - нужно шаманить
Plugin()->ProcessCommand(CMD_CLOSEQSEARCH, TRUE/*bReqMainThread*/, pIn->dwData/*хоть и не нужно?*/);
}
// Пересылается 2 DWORD
BOOL bCmdRc = Plugin()->ProcessCommand(pIn->hdr.nCmd, TRUE/*bReqMainThread*/, pIn->dwData);
DEBUGSTRCMD(L"Plugin: PlugServerThreadCommand: CMD_SETWINDOW waiting...\n");
WARNING("Почему для FAR1 не ждем? Есть возможность заблокироваться в 1.7 или что?");
if ((gFarVersion.dwVerMajor >= 2) && bCmdRc)
{
DWORD nTimeout = 2000;
#ifdef _DEBUG
if (IsDebuggerPresent()) nTimeout = 120000;
#endif
nSetWindowWait = WaitForSingleObject(ghSetWndSendTabsEvent, nTimeout);
}
if (nSetWindowWait == WAIT_TIMEOUT)
{
gbForceSendTabs = TRUE;
DEBUGSTRCMD(L"Plugin: PlugServerThreadCommand: CMD_SETWINDOW timeout !!!\n");
}
else
{
DEBUGSTRCMD(L"Plugin: PlugServerThreadCommand: CMD_SETWINDOW finished\n");
}
}
if (gpTabs && (nSetWindowWait != WAIT_TIMEOUT))
{
//fSuccess = WriteFile(hPipe, gpTabs, gpTabs->hdr.cbSize, &cbWritten, NULL);
pcbReplySize = gpTabs->hdr.cbSize;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
memmove(ppReply->Data, gpTabs->Data, pcbReplySize - sizeof(ppReply->hdr));
lbRc = TRUE;
}
}
SC.Unlock();
break;
} // CMD_REQTABS, CMD_SETWINDOW
case CMD_FARSETCHANGED:
{
// Установить переменные окружения
// Плагин это получает в ответ на CECMD_RESOURCES, посланное в GUI при загрузке плагина
_ASSERTE(nDataSize>=8);
FAR_REQ_FARSETCHANGED *pFarSet = (FAR_REQ_FARSETCHANGED*)pIn->Data;
cmd_FarSetChanged(pFarSet);
pcbReplySize = sizeof(CESERVER_REQ_HDR) + sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = TRUE;
}
//_ASSERTE(nDataSize<sizeof(gsMonitorEnvVar));
//gbMonitorEnvVar = false;
//// Плагин FarCall "нарушает" COMSPEC (копирует содержимое запускаемого процесса)
//bool lbOk = false;
//if (nDataSize<sizeof(gsMonitorEnvVar))
//{
// memcpy(gsMonitorEnvVar, pszName, nDataSize);
// lbOk = true;
//}
//UpdateEnvVar(pszName);
////while (*pszName && *pszValue) {
//// const wchar_t* pszChanged = pszValue;
//// // Для ConEmuOutput == AUTO выбирается по версии ФАРа
//// if (!lstrcmpi(pszName, L"ConEmuOutput") && !lstrcmp(pszChanged, L"AUTO")) {
//// if (gFarVersion.dwVerMajor==1)
//// pszChanged = L"ANSI";
//// else
//// pszChanged = L"UNICODE";
//// }
//// // Если в pszValue пустая строка - удаление переменной
//// SetEnvironmentVariableW(pszName, (*pszChanged != 0) ? pszChanged : NULL);
//// //
//// pszName = pszValue + lstrlenW(pszValue) + 1;
//// if (*pszName == 0) break;
//// pszValue = pszName + lstrlenW(pszName) + 1;
////}
//gbMonitorEnvVar = lbOk;
break;
} // CMD_FARSETCHANGED
case CMD_DRAGFROM:
{
#ifdef _DEBUG
BOOL *pbClickNeed = (BOOL*)pIn->Data;
COORD *crMouse = (COORD *)(pbClickNeed+1);
#endif
Plugin()->ProcessCommand(CMD_LEFTCLKSYNC, TRUE/*bReqMainThread*/, pIn->Data);
CESERVER_REQ* pCmdRet = NULL;
Plugin()->ProcessCommand(pIn->hdr.nCmd, TRUE/*bReqMainThread*/, pIn->Data, &pCmdRet);
if (pCmdRet)
{
//fSuccess = WriteFile(hPipe, pCmdRet, pCmdRet->hdr.cbSize, &cbWritten, NULL);
pcbReplySize = pCmdRet->hdr.cbSize;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
memmove(ppReply->Data, pCmdRet->Data, pCmdRet->hdr.cbSize - sizeof(ppReply->hdr));
}
Free(pCmdRet);
}
break;
} // CMD_DRAGFROM
case CMD_EMENU:
{
COORD *crMouse = (COORD *)pIn->Data;
#ifdef _DEBUG
const wchar_t *pszUserMacro = (wchar_t*)(crMouse+1);
#endif
DWORD ClickArg[2] = {(DWORD)TRUE, (DWORD)MAKELONG(crMouse->X, crMouse->Y)};
// Выделить файл под курсором
DEBUGSTRMENU(L"\n*** ServerThreadCommand->ProcessCommand(CMD_LEFTCLKSYNC) begin\n");
BOOL lb1 = Plugin()->ProcessCommand(CMD_LEFTCLKSYNC, TRUE/*bReqMainThread*/, ClickArg/*pIn->Data*/);
DEBUGSTRMENU(L"\n*** ServerThreadCommand->ProcessCommand(CMD_LEFTCLKSYNC) done\n");
// А теперь, собственно вызовем меню
DEBUGSTRMENU(L"\n*** ServerThreadCommand->ProcessCommand(CMD_EMENU) begin\n");
BOOL lb2 = Plugin()->ProcessCommand(pIn->hdr.nCmd, TRUE/*bReqMainThread*/, pIn->Data);
DEBUGSTRMENU(L"\n*** ServerThreadCommand->ProcessCommand(CMD_EMENU) done\n");
pcbReplySize = sizeof(CESERVER_REQ_HDR) + sizeof(DWORD)*2;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = lb1;
ppReply->dwData[1] = lb1;
}
break;
} // CMD_EMENU
case CMD_ACTIVEWNDTYPE:
{
int nWindowType = -1;
//CESERVER_REQ Out;
//ExecutePrepareCmd(&Out, CMD_ACTIVEWNDTYPE, sizeof(CESERVER_REQ_HDR)+sizeof(DWORD));
if (gFarVersion.dwVerMajor>=2)
nWindowType = Plugin()->GetActiveWindowType();
//fSuccess = WriteFile(hPipe, &Out, Out.hdr.cbSize, &cbWritten, NULL);
pcbReplySize = sizeof(CESERVER_REQ_HDR) + sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = nDataSize;
}
break;
} // CMD_ACTIVEWNDTYPE
case CECMD_ATTACH2GUI:
{
BOOL bAttached = Plugin()->Attach2Gui();
pcbReplySize = sizeof(CESERVER_REQ_HDR) + sizeof(DWORD);
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
ppReply->dwData[0] = bAttached;
}
break;
} // CECMD_ATTACH2GUI
default:
{
CESERVER_REQ* pCmdRet = NULL;
BOOL lbCmd = Plugin()->ProcessCommand(pIn->hdr.nCmd, TRUE/*bReqMainThread*/, pIn->Data, &pCmdRet);
if (pCmdRet)
{
//fSuccess = WriteFile(hPipe, pCmdRet, pCmdRet->hdr.cbSize, &cbWritten, NULL);
pcbReplySize = pCmdRet->hdr.cbSize;
if (ExecuteNewCmd(ppReply, pcbMaxReplySize, pIn->hdr.nCmd, pcbReplySize))
{
lbRc = TRUE;
memmove(ppReply->Data, pCmdRet->Data, pCmdRet->hdr.cbSize - sizeof(ppReply->hdr));
}
Free(pCmdRet);
}
} // default
} // switch (pIn->hdr.nCmd)
return lbRc;
}
TInt CExclusiveAccessPluginConn::DoControl(CFsPluginConnRequest& aRequest)
{
return ((CExclusiveAccessPlugin*)Plugin())->FsPluginDoControlL(aRequest);
}
int CPluginW2800::ProcessSynchroEventPtr(void* p)
{
const ProcessSynchroEventInfo* Info = (const ProcessSynchroEventInfo*)p;
return Plugin()->ProcessSynchroEvent(Info->Event, Info->Param);
}
bool XML_PluginParser::Start() {
Data = Plugin();
Data.directory = current_plugin_directory;
Data.enabled = true;
return true;
}
// Вызывается ТОЛЬКО в главной нити!
void CPluginBackground::UpdateBackground()
{
if (!mn_BgPluginsCount)
return;
if (!ghConEmuWndDC || !IsWindow(ghConEmuWndDC))
return;
if (mb_ThNeedLoad)
{
LoadThSet(TRUE/*Мы уже в главной нити*/);
}
//RECT rcClient; GetClientRect(ghConEmuWndDC, &rcClient);
struct PaintBackgroundArg Arg = m_Default;
Arg.cbSize = sizeof(struct PaintBackgroundArg);
//m_Default.dcSizeX = Arg.dcSizeX = rcClient.right+1;
//m_Default.dcSizeY = Arg.dcSizeY = rcClient.bottom+1;
m_Default.dcSizeX = Arg.dcSizeX = (m_Default.rcConWorkspace.right-m_Default.rcConWorkspace.left+1)*m_Default.MainFont.nFontCellWidth;
m_Default.dcSizeY = Arg.dcSizeY = (m_Default.rcConWorkspace.bottom-m_Default.rcConWorkspace.top+1)*m_Default.MainFont.nFontHeight;
// **********************************************************************************
// запомнить данные из m_Default в m_Last, но т.к. там есть указатели - move не катит
// **********************************************************************************
//memmove(&m_Last, &m_Default, sizeof(m_Last));
m_Last.MainFont = m_Default.MainFont;
memmove(m_Last.crPalette, m_Default.crPalette, sizeof(m_Last.crPalette));
m_Last.dcSizeX = m_Default.dcSizeX;
m_Last.dcSizeY = m_Default.dcSizeY;
m_Last.rcDcLeft = m_Default.rcDcLeft;
m_Last.rcDcRight = m_Default.rcDcRight;
m_Last.rcConWorkspace = m_Default.rcConWorkspace;
m_Last.conCursor = m_Default.conCursor;
m_Last.FarInterfaceSettings.Raw = m_Default.FarInterfaceSettings.Raw;
m_Last.FarPanelSettings.Raw = m_Default.FarPanelSettings.Raw;
memmove(m_Last.nFarColors, m_Default.nFarColors, sizeof(m_Last.nFarColors));
m_Last.bPanelsAllowed = m_Default.bPanelsAllowed;
// struct tag_BkPanelInfo
m_Last.LeftPanel.bVisible = m_Default.LeftPanel.bVisible;
m_Last.LeftPanel.bFocused = m_Default.LeftPanel.bFocused;
m_Last.LeftPanel.bPlugin = m_Default.LeftPanel.bPlugin;
m_Last.LeftPanel.rcPanelRect = m_Default.LeftPanel.rcPanelRect;
m_Last.RightPanel.bVisible = m_Default.RightPanel.bVisible;
m_Last.RightPanel.bFocused = m_Default.RightPanel.bFocused;
m_Last.RightPanel.bPlugin = m_Default.RightPanel.bPlugin;
m_Last.RightPanel.rcPanelRect = m_Default.RightPanel.rcPanelRect;
// строки
lstrcpyW(m_Last.LeftPanel.szCurDir, m_Default.LeftPanel.szCurDir);
lstrcpyW(m_Last.LeftPanel.szFormat, m_Default.LeftPanel.szFormat);
lstrcpyW(m_Last.LeftPanel.szHostFile, m_Default.LeftPanel.szHostFile);
lstrcpyW(m_Last.RightPanel.szCurDir, m_Default.RightPanel.szCurDir);
lstrcpyW(m_Last.RightPanel.szFormat, m_Default.RightPanel.szFormat);
lstrcpyW(m_Last.RightPanel.szHostFile, m_Default.RightPanel.szHostFile);
// **********************************************************************************
if (m_Default.dcSizeX < 1 || m_Default.dcSizeY < 1)
{
_ASSERTE(m_Default.dcSizeX >= 1 && m_Default.dcSizeY >= 1);
return;
}
SetDcPanelRect(&Arg.rcDcLeft, &Arg.LeftPanel, &Arg);
SetDcPanelRect(&Arg.rcDcRight, &Arg.RightPanel, &Arg);
// gpTabs отстает от реальности.
Arg.Place = m_Default.Place;
//if (!gpTabs)
// Arg.Place = pbp_Panels;
//else if (gnCurrentWindowType == WTYPE_EDITOR)
// Arg.Place = pbp_Editor;
//else if (gnCurrentWindowType == WTYPE_VIEWER)
// Arg.Place = pbp_Viewer;
//else if (Arg.LeftPanel.bVisible || Arg.RightPanel.bVisible)
//{
// _ASSERTE(gnCurrentWindowType == WTYPE_PANELS);
// Arg.Place = pbp_Panels;
//}
BITMAPINFOHEADER bi = {sizeof(BITMAPINFOHEADER)};
bi.biWidth = Arg.dcSizeX;
bi.biHeight = Arg.dcSizeY;
bi.biPlanes = 1;
bi.biBitCount = 32; //-V112
bi.biCompression = BI_RGB;
//_ASSERTE(Arg.LeftPanel.bVisible || Arg.RightPanel.bVisible);
HDC hScreen = GetDC(NULL);
RECT rcMeta = {0,0, Arg.dcSizeX, Arg.dcSizeY}; // (in pixels)
int iWidthMM = GetDeviceCaps(hScreen, HORZSIZE); if (iWidthMM <= 0) { _ASSERTE(iWidthMM>0); iWidthMM = 1024; }
int iHeightMM = GetDeviceCaps(hScreen, VERTSIZE); if (iHeightMM <= 0) { _ASSERTE(iHeightMM>0); iHeightMM = 768; }
int iWidthPels = GetDeviceCaps(hScreen, HORZRES); if (iWidthPels <= 0) { _ASSERTE(iWidthPels>0); iWidthPels = 0; }
int iHeightPels = GetDeviceCaps(hScreen, VERTRES); if (iHeightPels <= 0) { _ASSERTE(iHeightPels>0); iHeightPels = 0; }
RECT rcMetaMM = {0,0, (rcMeta.right * iWidthMM * 100)/iWidthPels, (rcMeta.bottom * iHeightMM * 100)/iHeightPels}; // (in .01-millimeter units)
HDC hdc = NULL;
HENHMETAFILE hEmf = NULL;
COLORREF* pBits = NULL;
HBITMAP hDib = NULL, hOld = NULL;
#ifdef CREATE_EMF_TEMP_FILES
wchar_t szEmfFile[MAX_PATH] = {};
#endif
wchar_t *pszEmfFile = NULL;
if (SETBACKGROUND_USE_EMF==1)
{
#ifdef CREATE_EMF_TEMP_FILES
GetTempPath(MAX_PATH-32, szEmfFile);
int nLen = lstrlen(szEmfFile);
if (*szEmfFile && szEmfFile[nLen-1] != L'\\')
{
szEmfFile[nLen++] = L'\\';
szEmfFile[nLen] = 0;
}
_wsprintf(szEmfFile+nLen, SKIPLEN(31) L"CeBack%u.emf", GetCurrentProcessId());
pszEmfFile = szEmfFile;
#endif
hdc = CreateEnhMetaFile(hScreen, pszEmfFile, &rcMetaMM, L"ConEmu\0Far Background\0\0");
if (!hdc)
{
_ASSERTE(hdc!=NULL);
return;
}
}
else
{
hdc = CreateCompatibleDC(hScreen);
if (!hdc)
{
_ASSERTE(hdc!=NULL);
return;
}
_ASSERTE(pBits = NULL);
hDib = CreateDIBSection(hScreen, (BITMAPINFO*)&bi, DIB_RGB_COLORS, (void**)&pBits, NULL, 0);
}
ReleaseDC(NULL, hScreen); hScreen = NULL;
Arg.hdc = hdc;
if (SETBACKGROUND_USE_EMF==1)
{
HBRUSH hFillBr = CreateSolidBrush (
#ifdef _DEBUG
RGB(128,128,0)
#else
RGB(0,0,0)
#endif
);
FillRect(hdc, &rcMeta, hFillBr);
DeleteObject(hFillBr);
}
else
{
if (!hDib || !pBits)
{
_ASSERTE(hDib && pBits);
if (hDib)
DeleteObject(hDib);
if (hdc)
DeleteDC(hdc);
return;
}
hOld = (HBITMAP)SelectObject(hdc, hDib);
// Залить черным - по умолчанию
#ifdef _DEBUG
memset(pBits, 128, bi.biWidth*bi.biHeight*4); //-V112
#else
memset(pBits, 0, bi.biWidth*bi.biHeight*4);
#endif
}
// Painting!
int nProcessed = 0;
MSectionLock SC; SC.Lock(csBgPlugins, TRUE);
DWORD nFromLevel = 0, nNextLevel, nSuggested;
DWORD dwDrawnPlaces = Arg.Place;
while(true)
{
nNextLevel = nFromLevel;
struct RegisterBackgroundArg *p = mp_BgPlugins;
for(int i = 0; i < mn_BgPluginsCount; i++, p++)
{
if (p->Cmd != rbc_Register ||
!(p->dwPlaces & Arg.Place) ||
!(p->PaintConEmuBackground))
continue; // пустая, неактивная в данном контексте, или некорректная ячейка
// Слои
nSuggested = p->dwSuggestedLevel;
if (nSuggested < nFromLevel)
{
continue; // Этот слой уже обработан
}
else if (nSuggested > nFromLevel)
{
// Этот слой нужно будет обработать в следующий раз
if ((nNextLevel == nFromLevel) || (nSuggested < nNextLevel))
nNextLevel = nSuggested;
continue;
}
// На уровне 0 (заливающий фон) должен быть только один плагин
Arg.dwLevel = (nProcessed == 0) ? 0 : (nFromLevel == 0 && nProcessed) ? 1 : nFromLevel;
Arg.lParam = mp_BgPlugins[i].lParam;
Arg.dwDrawnPlaces = 0;
//mp_BgPlugins[i].PaintConEmuBackground(&Arg);
UpdateBackground_Exec(mp_BgPlugins+i, &Arg);
// Что плагин покрасил (панели/редактор/вьювер считаются покрашенными по умолчанию)
dwDrawnPlaces |= Arg.dwDrawnPlaces;
//
nProcessed++;
}
if (nNextLevel == nFromLevel)
break; // больше слоев нет
nFromLevel = nNextLevel;
}
SC.Unlock();
// Sending background to GUI!
if (nProcessed < 1)
{
// Ситуация возникает при старте ConEmu, когда панелей "еще нет"
//_ASSERTE(nProcessed >= 1);
if (mb_BgWasSent)
{
mb_BgWasSent = FALSE;
CESERVER_REQ *pIn = ExecuteNewCmd(CECMD_SETBACKGROUND, sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SETBACKGROUND));
if (pIn)
{
pIn->Background.nType = 1;
pIn->Background.bEnabled = FALSE;
pIn->Background.dwDrawnPlaces = 0;
CESERVER_REQ *pOut = ExecuteGuiCmd(FarHwnd, pIn, FarHwnd);
if (pOut)
{
ExecuteFreeResult(pOut);
}
ExecuteFreeResult(pIn);
}
}
}
else // есть "отработавшие" плагины, обновить Background!
{
GdiFlush();
DWORD nBitSize = 0, nBitsError = 0;
if (SETBACKGROUND_USE_EMF==1)
{
hEmf = CloseEnhMetaFile(hdc);
hdc = NULL;
nBitSize = GetEnhMetaFileBits(hEmf, 0, NULL);
if (nBitSize == 0)
{
dwDrawnPlaces = 0;
nBitsError = GetLastError();
_ASSERTE(nBitSize!=0);
if (hEmf)
{
// В случае ошибки - сразу удаляем
DeleteEnhMetaFile(hEmf);
hEmf = NULL;
}
}
}
else
{
nBitSize = bi.biWidth*bi.biHeight*sizeof(COLORREF);
}
DWORD nWholeSize = sizeof(CESERVER_REQ_HDR)+sizeof(CESERVER_REQ_SETBACKGROUND)+nBitSize; //-V103 //-V119
CESERVER_REQ *pIn = ExecuteNewCmd(CECMD_SETBACKGROUND, nWholeSize);
if (!pIn)
{
_ASSERTE(pIn);
}
else
{
pIn->Background.nType = 1;
pIn->Background.bEnabled = TRUE;
pIn->Background.dwDrawnPlaces = dwDrawnPlaces;
if (SETBACKGROUND_USE_EMF==1)
pIn->Background.bmp.bfType = 0x4645/*EF*/;
else
pIn->Background.bmp.bfType = 0x4D42/*BM*/;
pIn->Background.bmp.bfSize = nBitSize+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER); //-V119
pIn->Background.bmp.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER); //-V119
pIn->Background.bi = bi;
if (SETBACKGROUND_USE_EMF==1)
{
LPBYTE pBits = ((LPBYTE)&pIn->Background)+sizeof(pIn->Background);
DWORD nBitsRc = (nBitSize && hEmf) ? GetEnhMetaFileBits(hEmf, nBitSize, pBits) : 0;
_ASSERTE(nBitsRc == nBitSize);
if (!nBitsRc)
{
_ASSERTE(nBitsRc!=NULL);
// Отключить нафиг
ExecutePrepareCmd(&pIn->hdr, CECMD_SETBACKGROUND, nWholeSize-nBitSize);
pIn->Background.nType = 1;
pIn->Background.bEnabled = FALSE;
pIn->Background.dwDrawnPlaces = 0;
}
}
else
{
memmove(((LPBYTE)&pIn->Background)+sizeof(pIn->Background), pBits, bi.biWidth*bi.biHeight*sizeof(COLORREF));
}
CESERVER_REQ *pOut = ExecuteGuiCmd(FarHwnd, pIn, FarHwnd);
// Вызывается ТОЛЬКО в главной нити
_ASSERTE(GetCurrentThreadId() == gnMainThreadId);
if (pOut)
{
mb_BgWasSent = TRUE;
// Сбросим флажок "Ошибка уже была показана"
if (pOut->BackgroundRet.nResult == esbr_OK)
{
mb_BgErrorShown = FALSE;
}
// Показать ошибку, если есть
else if ((pOut->BackgroundRet.nResult > esbr_OK) && (pOut->BackgroundRet.nResult <= esbr_LastErrorNo)
&& (pOut->BackgroundRet.nResult != esbr_ConEmuInShutdown)
&& !mb_BgErrorShown)
{
mb_BgErrorShown = TRUE;
Plugin()->ShowMessage(CEBkError_ExecFailed+pOut->BackgroundRet.nResult, 0);
}
ExecuteFreeResult(pOut);
}
else if (!mb_BgErrorShown)
{
mb_BgErrorShown = TRUE;
Plugin()->ShowMessage(CEBkError_ExecFailed, 0);
}
ExecuteFreeResult(pIn);
}
}
if (SETBACKGROUND_USE_EMF == 0)
{
if (hdc && hOld)
SelectObject(hdc, hOld);
if (hDib)
DeleteObject(hDib);
if (hdc)
DeleteDC(hdc);
}
else
{
if (hdc)
{
hEmf = CloseEnhMetaFile(hdc);
hdc = NULL;
}
if (hEmf)
{
DeleteEnhMetaFile(hEmf);
hEmf = NULL;
}
}
}
void BlueVexWrapper::InitPlugin(RedVexInfo* Funcs)
{
_managedPlugin = gcnew Plugin();
_managedPlugin->InitPlugin(System::IntPtr(Funcs));
}
int CPluginBackground::RegisterSubplugin(RegisterBackgroundArg *pbk)
{
if (!pbk)
{
_ASSERTE(pbk != NULL);
return esbr_InvalidArg;
}
if (!gbBgPluginsAllowed)
{
_ASSERTE(gbBgPluginsAllowed == TRUE);
return esbr_PluginForbidden;
}
if (pbk->cbSize != sizeof(*pbk))
{
_ASSERTE(pbk->cbSize == sizeof(*pbk));
return esbr_InvalidArgSize;
}
if (pbk->Cmd == rbc_Register)
{
BOOL lbCheckCallback = CheckCallbackPtr(pbk->hPlugin, 1, (FARPROC*)&pbk->PaintConEmuBackground, TRUE, FALSE, FALSE);
if (!lbCheckCallback)
{
_ASSERTE(lbCheckCallback==TRUE);
return esbr_InvalidArgProc;
}
}
MSectionLock SC; SC.Lock(csBgPlugins, TRUE);
// Выделение памяти под плагины
if (mp_BgPlugins == NULL || (mn_BgPluginsCount == mn_BgPluginsMax))
ReallocItems(16);
// go
//BOOL lbNeedResort = FALSE;
if (pbk->Cmd == rbc_Register)
{
// Память уже выделена
int nFound = -1, nFirstEmpty = -1;
for(int i = 0; i < mn_BgPluginsCount; i++)
{
if (mp_BgPlugins[i].Cmd == rbc_Register &&
mp_BgPlugins[i].hPlugin == pbk->hPlugin &&
mp_BgPlugins[i].PaintConEmuBackground == pbk->PaintConEmuBackground &&
mp_BgPlugins[i].lParam == pbk->lParam)
{
nFound = i; break;
}
if (nFirstEmpty == -1 && 0 == (int)mp_BgPlugins[i].Cmd)
nFirstEmpty = i;
}
if (nFound == -1)
{
if (nFirstEmpty >= 0)
nFound = nFirstEmpty;
else
nFound = mn_BgPluginsCount++;
//lbNeedResort = (mn_BgPluginsCount>1);
}
mp_BgPlugins[nFound] = *pbk;
}
else if (pbk->Cmd == rbc_Unregister)
{
for(int i = 0; i < mn_BgPluginsCount; i++)
{
if (mp_BgPlugins[i].Cmd == rbc_Register &&
mp_BgPlugins[i].hPlugin == pbk->hPlugin &&
((pbk->PaintConEmuBackground == NULL) ||
(mp_BgPlugins[i].PaintConEmuBackground == pbk->PaintConEmuBackground
&& mp_BgPlugins[i].lParam == pbk->lParam)))
{
memset(mp_BgPlugins+i, 0, sizeof(*mp_BgPlugins));
//lbNeedResort = TRUE;
}
}
WARNING("Если количество зарегистрированных плагинов уменьшилось до 0");
// Послать в GUI CECMD_SETBACKGROUND{bEnabled = FALSE}
// Проверить, чтобы не было противного мелькания при закрытии FAR
}
else if (pbk->Cmd == rbc_Redraw)
{
// просто выставить gbNeedBgActivate
}
////TODO: Сортировка
//if (lbNeedResort)
//{
// WARNING("Сортировка зарегистрированных плагинов - CPluginBackground::RegisterBackground");
//}
SC.Unlock();
// Когда активируется MainThread - обновить background
mn_ReqActions |= ra_UpdateBackground;
gbNeedBgActivate = TRUE;
// В фар2 сразу дернем Synchro
if (IS_SYNCHRO_ALLOWED)
{
Plugin()->ExecuteSynchro();
}
return esbr_OK;
}
