diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 0000000..f0385c9 --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1,5 @@ +# These are supported funding model platforms + +github: Maximus5 +liberapay: conemu.maximus5 +custom: ['https://www.paypal.me/conemu/5'] diff --git a/Dir_b3/Dir_fmt_exe.cpp b/Dir_b3/Dir_fmt_exe.cpp new file mode 100644 index 0000000..952329a --- /dev/null +++ b/Dir_b3/Dir_fmt_exe.cpp @@ -0,0 +1,274 @@ +// Dir_fmt_exe.cpp : Defines the entry point for the console application. +// + +#include +#include +#include +#include +#include +#include +#include + +#include "plugin.hpp" +#include "fmt.hpp" + +int help(); +int fail(int nCode); +BOOL WINAPI _export OpenArchive(char *Name, int *Type); +int WINAPI _export GetArcItem(struct PluginPanelItem *Item, struct ArcItemInfo *Info); +BOOL WINAPI _export CloseArchive(struct ArcInfo *Info); +int CreateItem ( PluginPanelItem& Item ); + +enum class WorkMode +{ + ExtractNoPath, + ExtractWithPath, + Information, + ListFiles, +}; + +WorkMode work_mode; + +int main(int argc, char* argv[]) +{ + int nRc = 0; + + printf("Arg count: %i\n", argc); + for (int i = 0; i < argc; i++) { + printf("%s\n", argv[i]); + } + + if (argc <= 2) + return help(); + + const auto* mode = argv[1]; + if (strcmp(mode, "e") == 0) + { + if (argc <= 3) + return help(); + work_mode = WorkMode::ExtractNoPath; + } + else if (strcmp(mode, "x") == 0) + { + if (argc <= 3) + return help(); + work_mode = WorkMode::ExtractWithPath; + } + else if (strcmp(mode, "i") == 0) + { + work_mode = WorkMode::Information; + } + else if (strcmp(mode, "l") == 0) + { + work_mode = WorkMode::ListFiles; + } + else + { + return help(); + } + + int nType = 0; + if (!OpenArchive(argv[2], &nType)) + return fail(101); + +#ifdef _DEBUG + if (!IsDebuggerPresent()) + MessageBox(nullptr, "Wait", "Dir.Fmt", 0); +#endif + + + std::vector psNeeds; + std::unique_ptr pszList; + HANDLE hList = INVALID_HANDLE_VALUE; + while (work_mode == WorkMode::ExtractNoPath || work_mode == WorkMode::ExtractWithPath) { + hList = CreateFile(argv[3], GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, 0, 0); + if (hList == INVALID_HANDLE_VALUE) { + nRc = 102; break; + } + DWORD dwSize, dwHigh = 0; + dwSize = GetFileSize(hList, &dwHigh); + if (dwHigh != 0 || dwSize == static_cast(-1) || dwSize == 0) { + nRc = 103; break; + } + + // ReSharper disable once CppJoinDeclarationAndAssignment + pszList = std::make_unique(dwSize + 1); + if (!pszList) { + nRc = 104; break; + } + if (!ReadFile(hList, pszList.get(), dwSize, &dwSize, 0)) { + nRc = 105; break; + } + + OemToCharBuff(pszList.get(), pszList.get(), dwSize); + + TCHAR* psz = pszList.get(); + TCHAR* pszLine = nullptr; + while ((pszLine = _tcschr(psz, _T('\r')))) { + *pszLine = 0; + if (pszLine[1] == _T('\n')) pszLine += 2; else pszLine++; + psNeeds.push_back(psz); + psz = pszLine; + } + + break; + } + + if (hList != INVALID_HANDLE_VALUE) + CloseHandle(hList); + + const auto prevCp = GetConsoleOutputCP(); + + uint32_t fileCount = 0; + uint32_t dirCount = 0; + if (nRc == 0) + { + SetConsoleOutputCP(1251); + + PluginPanelItem item{}; + ArcItemInfo info{}; + + //MessageBox(nullptr, "Wait", "Dir.fmt.exe", MB_OK); + + wchar_t utfBuffer[MAX_PATH + 32]; + bool switchedToUtf8 = false; + HANDLE hStdOut = NULL; + //TCHAR szFromDir[MAX_PATH+1]; szFromDir[0]=0; + while (GETARC_SUCCESS == GetArcItem(&item, &info)) { + if (item.UserData == CP_UTF8) + { + if (!hStdOut) + { + hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); + switchedToUtf8 = true; + } + } + + if (item.UserData == CP_OEMCP) + { + OemToCharBuff(item.FindData.cFileName, item.FindData.cFileName, strlen(item.FindData.cFileName)); + } + + if (item.FindData.cFileName[0] == _T('<')) + continue; // + //if (Item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) continue; + if (strchr(item.FindData.cFileName, '\\')) { + std::ignore = 0; + } + + if (item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) + ++dirCount; + else + ++fileCount; + + if (work_mode == WorkMode::ListFiles) { + if (switchedToUtf8 && hStdOut && hStdOut != INVALID_HANDLE_VALUE && item.UserData == CP_UTF8) + { + swprintf_s(utfBuffer, L"%c '", (item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 'D' : 'F'); + MultiByteToWideChar(CP_UTF8, 0, item.FindData.cFileName, -1, utfBuffer + 3, MAX_PATH + 1); + wcscat_s(utfBuffer, L"'\n"); + DWORD written = 0; + WriteConsoleW(hStdOut, utfBuffer, wcslen(utfBuffer), &written, nullptr); + } + else + { + printf("%c '%s'\n", (item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? 'D' : 'F', + item.FindData.cFileName); + } + } + + // ReSharper disable once IdentifierTypo + for (auto* psTest : psNeeds) + { + BOOL lbOurFile = FALSE; + if (_tcsnicmp(psTest, item.FindData.cFileName, strlen(psTest)) == 0) + { + lbOurFile = TRUE; + if (item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + psTest += _tcslen(psTest); + if (*(psTest - 1) != _T('\\')) { + if (psTest[1] != _T('\n')) { + nRc = 200; + break; + } + *psTest = _T('\\'); + psTest[1] = 0; + } + } + } + + if (lbOurFile) { + nRc = CreateItem(item); + break; + } + } + } + + CloseArchive(nullptr); + } + + if (work_mode == WorkMode::Information || work_mode == WorkMode::ListFiles) + printf("Directories: %u\nFiles: %u\n", dirCount, fileCount); + + if (nRc != 0) + printf("Can't extract\nRc: %i\n", nRc); + else + printf("Rc: %i\n", nRc); + SetConsoleOutputCP(prevCp); + return nRc; +} + +int help() +{ + printf("Dir.fmt.exe {e|x} \"dir_file\" \"file_list\"\n"); + return 100; +} + +int fail(int nCode) +{ + printf("Can't extract!\nRc: %i\n", nCode); + return nCode; +} + +int CreateItem(PluginPanelItem& Item) +{ + int nRc = 0; + // ReSharper disable once CppEntityAssignedButNoRead + DWORD dwLastError = 0; + + TCHAR* pszFile = Item.FindData.cFileName; + if (work_mode == WorkMode::ExtractNoPath) { + TCHAR* pszSlash = _tcsrchr(pszFile, _T('\\')); + if (pszSlash) + pszFile = pszSlash + 1; + } + + if (Item.FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) { + printf("Creating folder: %s", pszFile); + CreateDirectory(pszFile, nullptr); + printf("\n"); + } + else { + printf("Creating file: %s", pszFile); + // ReSharper disable once CppLocalVariableMayBeConst + HANDLE hFile = CreateFile(pszFile, GENERIC_WRITE, FILE_SHARE_READ, nullptr, + CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL/*Item.FindData.dwFileAttributes*/, nullptr); + + if (hFile == INVALID_HANDLE_VALUE) { + nRc = 110; + } + else { + SetFilePointer(hFile, Item.FindData.nFileSizeLow, reinterpret_cast(&Item.FindData.nFileSizeHigh), FILE_BEGIN); + SetEndOfFile(hFile); + if (!SetFileTime(hFile, nullptr, nullptr, &Item.FindData.ftLastWriteTime)) + dwLastError = GetLastError(); + CloseHandle(hFile); + if (!SetFileAttributes(pszFile, Item.FindData.dwFileAttributes | FILE_ATTRIBUTE_HIDDEN)) + dwLastError = GetLastError(); + } + printf("\n"); + } + + std::ignore = dwLastError; + return nRc; +} diff --git a/Dir_b3/ModuleDef.h b/Dir_b3/ModuleDef.h new file mode 100644 index 0000000..0027791 --- /dev/null +++ b/Dir_b3/ModuleDef.h @@ -0,0 +1,113 @@ +#ifndef _MODULE_DEF_H_ +#define _MODULE_DEF_H_ + +#define MODULE_EXPORT __stdcall + +// Extract progress callbacks +typedef int (CALLBACK *ExtractProgressFunc)(HANDLE, __int64); + +#pragma pack(push, 1) + +struct ExtractProcessCallbacks +{ + HANDLE signalContext; + ExtractProgressFunc FileProgress; +}; + +#define ACTUAL_API_VERSION 6 +#define STORAGE_FORMAT_NAME_MAX_LEN 32 +#define STORAGE_PARAM_MAX_LEN 64 + +struct StorageGeneralInfo +{ + wchar_t Format[STORAGE_FORMAT_NAME_MAX_LEN]; + wchar_t Compression[STORAGE_PARAM_MAX_LEN]; + wchar_t Comment[STORAGE_PARAM_MAX_LEN]; + FILETIME Created; +}; + +struct StorageOpenParams +{ + size_t StructSize; + const wchar_t* FilePath; + const char* Password; + const void* Data; + size_t DataSize; +}; + +struct StorageItemInfo +{ + __int64 Size; + __int64 PackedSize; + DWORD Attributes; + FILETIME CreationTime; + FILETIME ModificationTime; + WORD NumHardlinks; + wchar_t Owner[64]; + wchar_t Path[1024]; +}; + +struct ExtractOperationParams +{ + int ItemIndex; + int Flags; + const wchar_t* DestPath; + const char* Password; + ExtractProcessCallbacks Callbacks; +}; + +typedef int (MODULE_EXPORT *OpenStorageFunc)(StorageOpenParams params, HANDLE *storage, StorageGeneralInfo *info); +typedef int (MODULE_EXPORT *PrepareFilesFunc)(HANDLE storage); +typedef void (MODULE_EXPORT *CloseStorageFunc)(HANDLE storage); +typedef int (MODULE_EXPORT *GetItemFunc)(HANDLE storage, int item_index, StorageItemInfo* item_info); +typedef int (MODULE_EXPORT *ExtractFunc)(HANDLE storage, ExtractOperationParams params); + +struct module_cbs +{ + OpenStorageFunc OpenStorage; + CloseStorageFunc CloseStorage; + GetItemFunc GetItem; + ExtractFunc ExtractItem; + PrepareFilesFunc PrepareFiles; +}; + +struct ModuleLoadParameters +{ + //IN + size_t StructSize; + const wchar_t* Settings; + //OUT + GUID ModuleId; + DWORD ModuleVersion; + DWORD ApiVersion; + module_cbs ApiFuncs; +}; + +#pragma pack(pop) + +// Function that should be exported from modules +typedef int (MODULE_EXPORT *LoadSubModuleFunc)(ModuleLoadParameters*); +typedef void (MODULE_EXPORT *UnloadSubModuleFunc)(void); + +#define MAKEMODULEVERSION(mj,mn) ((mj << 16) | mn) +#define STRBUF_SIZE(x) ( sizeof(x) / sizeof(x[0]) ) + +// Open storage return results +#define SOR_INVALID_FILE 0 +#define SOR_SUCCESS 1 +#define SOR_PASSWORD_REQUIRED 2 + +// Item retrieval result +#define GET_ITEM_ERROR 0 +#define GET_ITEM_OK 1 +#define GET_ITEM_NOMOREITEMS 2 + +// Extract result +#define SER_SUCCESS 0 +#define SER_ERROR_WRITE 1 +#define SER_ERROR_READ 2 +#define SER_ERROR_SYSTEM 3 +#define SER_USERABORT 4 +#define SER_PASSWORD_REQUIRED 5 + +#endif diff --git a/Dir_b3/_Dir.sln b/Dir_b3/_Dir.sln new file mode 100644 index 0000000..4c3cd95 --- /dev/null +++ b/Dir_b3/_Dir.sln @@ -0,0 +1,49 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.30406.217 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dir_b3", "dir_b3.vcxproj", "{CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dir_fmt_exe", "dir_fmt_exe.vcxproj", "{2C08961C-89C1-4263-AA60-820B4C82B4E3}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dir_so", "dir_so.vcxproj", "{54892E57-F71A-4E2D-8132-B717B3FD7649}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Debug|Win32.ActiveCfg = Debug|Win32 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Debug|Win32.Build.0 = Debug|Win32 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Debug|x64.ActiveCfg = Debug|x64 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Debug|x64.Build.0 = Debug|x64 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Release|Win32.ActiveCfg = Release|Win32 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Release|Win32.Build.0 = Release|Win32 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Release|x64.ActiveCfg = Release|x64 + {CE5DE198-A8B4-4BBC-BDB7-253EA2C646A1}.Release|x64.Build.0 = Release|x64 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Debug|Win32.ActiveCfg = Debug|Win32 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Debug|Win32.Build.0 = Debug|Win32 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Debug|x64.ActiveCfg = Debug|Win32 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Release|Win32.ActiveCfg = Release|Win32 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Release|Win32.Build.0 = Release|Win32 + {2C08961C-89C1-4263-AA60-820B4C82B4E3}.Release|x64.ActiveCfg = Release|Win32 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Debug|Win32.ActiveCfg = Debug|Win32 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Debug|Win32.Build.0 = Debug|Win32 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Debug|x64.ActiveCfg = Debug|x64 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Debug|x64.Build.0 = Debug|x64 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Release|Win32.ActiveCfg = Release|Win32 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Release|Win32.Build.0 = Release|Win32 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Release|x64.ActiveCfg = Release|x64 + {54892E57-F71A-4E2D-8132-B717B3FD7649}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {4FB8F4A5-80A9-44EC-BBFE-6E0C98B5069B} + EndGlobalSection +EndGlobal diff --git a/Dir_b3/dir.cpp b/Dir_b3/dir.cpp new file mode 100644 index 0000000..d9c7d8b --- /dev/null +++ b/Dir_b3/dir.cpp @@ -0,0 +1,610 @@ + +/* ************************** + This module may be used as + 1) Observer module (*.so) + 2) MultiArc module (*.fmt) + * ************************** */ + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +#include +#include +#include "plugin.hpp" +#include "fmt.hpp" +#include + +/****************************************************** + D DIST_ALX + : 356D-B9B3 + + D:\!Develop!\Dir + +15.11.2008 17:36 . +15.11.2008 17:36 .. +15.11.2008 17:39 dir010327 +15.11.2008 17:46 dirparse +15.11.2008 18:11 [2008.11.15] +15.11.2008 18:36 0 !! + 1 0 + + D:\!Develop!\Dir\dir010327 + +15.11.2008 17:39 . +15.11.2008 17:39 .. +27.03.2001 08:47 7581 dir.cpp +27.03.2001 09:03 6144 dir.fmt +29.03.2001 18:11 2600 dir.txt + 3 16325 + + : + 9 26795 + 11 396525568 + Volume in drive C is w2k3 + Volume Serial Number is F0AC-A340 + + Directory of C:\Programs\Develop\mingw32\mingw + +31.10.2008 12:30 . +31.10.2008 12:30 .. +31.10.2008 12:30 bin +04.02.2008 04:19 35821 COPYING-gcc-tdm.txt +09.08.2007 17:18 26930 COPYING.lib-gcc-tdm.txt +31.10.2008 12:30 doc +31.10.2008 13:06 include +31.10.2008 12:30 info +31.10.2008 13:06 lib +28.08.2008 16:39 libexec +31.10.2008 12:30 man +31.10.2008 12:30 mingw32 +26.05.2005 10:15 21927 pthreads-win32-README +28.08.2008 16:58 14042 README-gcc-tdm.txt + 4 File(s) 98720 bytes + +******************************************************/ + +/* +BOOL APIENTRY DllMain( HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + switch (ul_reason_for_call) + { + case DLL_PROCESS_ATTACH: + case DLL_THREAD_ATTACH: + case DLL_THREAD_DETACH: + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} +*/ + +enum { // WIN XP/2003/VISTA: + DATA_DISP = 0, + TIME_DISP = 12, + SIZE_DISP = 19, + NAME_DISP = 36, + + ID_DIR_DISP = 21, +}; + +struct DirInfo; +DirInfo* gpCur = nullptr; + +//static struct PluginStartupInfo Info; +struct DirInfo +{ + HANDLE Handle, MapHandle; + char *Data, *Pos, *Edge, Prefix[MAX_PATH-2], Descrip[80], Oem2Ansi[4096]; + int nPrefixLen; + wchar_t Utf8[4096], Wide[MAX_PATH]; + char Buf[8192]; // + size_t nStrLen, nSkipLen; + bool FormatOk; + //bool isBtanch; + enum + { + cp_NonChecked = 0, + cp_OEM = 1, + cp_ANSI = 2, + cp_UTF8 = 3, + } CP_Check; + bool isRus; + + __int64 AtoI(char *Str, int Len) + { + __int64 Ret=0; + for (; Len && *Str; Len--, Str++) + if (*Str>='0' && *Str<='9') + (Ret*=10)+=*Str-'0'; + return Ret; + }; + + bool Compare(const char *Str, const char *Mask, bool NonEng = false, int Len=-1) + { + int nCmp = (Len==-1) ? lstrlenA(Mask) : Len; + + if (CompareString(LOCALE_USER_DEFAULT, 0, Str, nCmp, Mask, nCmp)==CSTR_EQUAL) + return true; + + if (NonEng) + { + if ((CP_Check == cp_NonChecked) && (nCmp < ARRAYSIZE(Oem2Ansi))) + { + CharToOemBuff(Mask, Oem2Ansi, nCmp); + if (CompareString(LOCALE_USER_DEFAULT, 0, Str, nCmp, Oem2Ansi, nCmp)==CSTR_EQUAL) + { + CP_Check = cp_OEM; + return true; + } + } + if ((CP_Check == cp_NonChecked || CP_Check == cp_UTF8) && (nCmp < ARRAYSIZE(Oem2Ansi))) + { + int nWide = MultiByteToWideChar(CP_ACP, 0, Mask, nCmp, Utf8, ARRAYSIZE(Utf8)-1); + Utf8[nWide] = 0; + int nUtf8 = WideCharToMultiByte(CP_UTF8, 0, Utf8, nWide+1, Oem2Ansi, ARRAYSIZE(Utf8)-1, 0, 0); + //BUGBUG:??? + if (memcmp(Str, Oem2Ansi, min(nUtf8,nCmp)) == 0) + { + CP_Check = cp_UTF8; + return true; + } + } + } + + return false; + }; + + bool GetS(char *pBuf, DWORD nBufLen) + { + if (!pBuf || !nBufLen) + { + _ASSERTE(pBuf && nBufLen); + return false; + } + const char *Start=pBuf; + if (Pos >= Edge) + { + nStrLen = 0; + return false; + } + while (Pos < Edge && *Pos!='\r' && *Pos!='\n' && (--nBufLen)) //Maks " && (--BufLen)" + *pBuf++ = *Pos++; + *pBuf=0; + for (; Pos < Edge && (*Pos=='\r' || *Pos=='\n'); Pos++) + ; + nStrLen = pBuf - Start; + return true; + }; + + BOOL openArchive(int* Type) + { + //Handle=CreateFile(Name, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, + // FILE_FLAG_SEQUENTIAL_SCAN, nullptr); + if (Handle != INVALID_HANDLE_VALUE) + { + MapHandle = CreateFileMapping(Handle, nullptr, PAGE_READONLY, 0, 0, nullptr); + if (MapHandle) + { + Pos = Data = static_cast(MapViewOfFile(MapHandle, FILE_MAP_READ, 0, 0, 0)); + if (Data) + { + *Type = 0; + *Prefix = 0; nPrefixLen = 0; + *Descrip = 0; + nSkipLen = 0; + Edge = Data + GetFileSize(Handle, nullptr); + + PluginPanelItem Item{}; + ArcItemInfo Info{}; + const bool lbRc = (getArcItem(&Item, &Info) == GETARC_SUCCESS); + + nStrLen = nSkipLen = 0; + *Prefix = 0; nPrefixLen = 0; + Pos = Data; + + if (lbRc) + { + //static const char *MsgItems[]={ "", "In mode branch?"}; + //isBtanch=!Info.Message(Info.ModuleNumber, FMSG_MB_YESNO, 0, MsgItems, 2, 0); + return true; + } + } + CloseHandle(MapHandle); MapHandle = nullptr; + } + CloseHandle(Handle); + } + Handle = nullptr; + return false; + } + + int getArcItem(struct PluginPanelItem* Item, struct ArcItemInfo* Info) + { + static const char* LabelHeader[] = { " ", " Volume in" }; + static const char* SerialHeader[] = { " ", " Volume Serial" }; + static const char* DirHeader[] = { " ", " Directory of" }; + static const char* DirEndHeader[] = { " :", " Total Files" }; + static char DirID[] = ""; + static char JunID[] = ""; + //char* Buf = (char*)malloc(4096); + bool First = false; + size_t nLines = 0; + + //if (isBtanch) nSkipLen=0; + while (GetS(Buf, ARRAYSIZE(Buf) - 2)) + { + nLines++; + if (((First = Compare(Buf, LabelHeader[0], true))) || Compare(Buf, LabelHeader[1])) + { + FormatOk = true; + isRus = First; + //if (isRus && strncmp(Buf, LabelHeader[0], lstrlenA(LabelHeader[0]))) + //{ + // OemToCharBuff(Buf, Buf, lstrlenA(Buf)); + //} + if (CP_Check == cp_OEM) + { + OemToCharBuff(Buf, Buf, lstrlenA(Buf)); + CP_Check = cp_ANSI; + } + + *Prefix = 0; nPrefixLen = 0; nSkipLen = 0; + + // 26.11.2008 Maks - + //lstrcpy(Descrip, " Label:"); + Descrip[0] = 0; + // 26.11.2008 Maks - + //if (isRus?*(Buf+20)=='':*(Buf+19)=='i' ) lstrcat(Descrip, Buf+(isRus?31:21)); + char* lpszPtr = nullptr; + if (isRus ? *(Buf + 20) == '' : *(Buf + 19) == 'i') lpszPtr = Buf + (isRus ? 31 : 21); + if (!lpszPtr) continue; + while (*lpszPtr == ' ') lpszPtr++; + + // 26.11.2008 Maks - + if (!*lpszPtr) continue; + memset(Item, 0, sizeof(PluginPanelItem)); + + lstrcpy(Item->FindData.cFileName, "= (MAX_PATH - 20)) + lpszPtr[MAX_PATH - 20] = 0; + lstrcat(Item->FindData.cFileName, lpszPtr); + lstrcat(Item->FindData.cFileName, ">"); + + Item->FindData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; + Item->UserData = 0; + + SYSTEMTIME st; + GetSystemTime(&st); + FILETIME ft; + SystemTimeToFileTime(&st, &ft); + LocalFileTimeToFileTime(&ft, &Item->FindData.ftLastWriteTime); + + lstrcpy(Info->Description, lpszPtr); + return GETARC_SUCCESS; + } + if (Compare(Buf, SerialHeader[0]) || Compare(Buf, SerialHeader[1])) + { + FormatOk = true; + /* // 26.11.2008 Maks - Volume Serial - + char temp[80]; + lstrcpy(temp, Descrip); + lstrcpy(Descrip, Buf+(isRus?21:24)); + lstrcat(Descrip, temp); + */ + continue; + } + if (Compare(Buf, DirHeader[0]) || Compare(Buf, DirHeader[1])) + { + FormatOk = true; + if (!nSkipLen) + nSkipLen = nStrLen; + else + { + lstrcpyn(Prefix, Buf + nSkipLen + (Buf[nSkipLen] == '\\' ? 1 : 0), ARRAYSIZE(Prefix) - 2); + nPrefixLen = lstrlen(Prefix); + if (nPrefixLen && Prefix[nPrefixLen - 1] != '\\') + { + Prefix[nPrefixLen++] = '\\'; + Prefix[nPrefixLen] = 0; + } + } + continue; + } + + if (!FormatOk) + { + // 128 - + if (nLines > 128) + break; + else + continue; + } + + if ((nStrLen == NAME_DISP + 1 && *(Buf + NAME_DISP) == '.') || + (nStrLen == NAME_DISP + 2 && *(Buf + NAME_DISP + 1) == '.')) + continue; + if (Compare(Buf, DirEndHeader[0]) || Compare(Buf, DirEndHeader[1])) + { + nSkipLen = 0; *Prefix = 0; nPrefixLen = 0; + continue; + } + //2008-11-30 , + if (nStrLen > NAME_DISP && *Buf != ' ' && *(Buf + 1) != ' ') + { + memset(Item, 0, sizeof(PluginPanelItem)); + + //BUGBUG: LongUnicodeString + if (*Prefix) + { + lstrcpy(Item->FindData.cFileName, Prefix); + } + if (CP_Check == cp_NonChecked) + { + //TODO: , UTF8? + const int iUtf = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, Buf, -1, Utf8, ARRAYSIZE(Utf8)); + //BUGBUG: ?? OEM ? + const int iWide = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS, Buf, -1, Wide, ARRAYSIZE(Wide)); + if (iUtf > 0 && iWide > 0 && iUtf < iWide) + { + CP_Check = cp_UTF8; + } + } + + bool copied = false; + const int cchMaxLen = ARRAYSIZE(Item->FindData.cFileName) - nPrefixLen; + if (CP_Check == cp_UTF8) + { + const int iUtf = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, Buf, -1, Utf8, ARRAYSIZE(Utf8)); + if (iUtf > NAME_DISP) { + const int iWide = WideCharToMultiByte(CP_UTF8, 0, Utf8 + NAME_DISP, -1, + Item->FindData.cFileName + nPrefixLen, cchMaxLen, nullptr, nullptr); + copied = (iWide > 0 && iWide < cchMaxLen); + } + } + if (!copied) + { + lstrcpyn(Item->FindData.cFileName + nPrefixLen, Buf + NAME_DISP, cchMaxLen); + } + + switch (CP_Check) + { + case cp_ANSI: + Item->UserData = CP_ACP; break; + case cp_OEM: + Item->UserData = CP_OEMCP; break; + case cp_UTF8: + Item->UserData = CP_UTF8; break; + default: + Item->UserData = 0; + } + + if (Compare(Buf + ID_DIR_DISP, DirID) || Compare(Buf + ID_DIR_DISP, JunID)) + Item->FindData.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; + else + { + FARINT64 nFileSize; + nFileSize.i64 = AtoI(Buf + SIZE_DISP, 16); + Item->FindData.nFileSizeLow = nFileSize.Part.LowPart; + Item->FindData.nFileSizeHigh = nFileSize.Part.HighPart; + } + + SYSTEMTIME st; + st.wDayOfWeek = st.wSecond = st.wMilliseconds = 0; + st.wDay = (WORD)AtoI(Buf + DATA_DISP, 2); + st.wMonth = (WORD)AtoI(Buf + DATA_DISP + 3, 2); + st.wYear = (WORD)AtoI(Buf + DATA_DISP + 6, 4); + st.wHour = (WORD)AtoI(Buf + TIME_DISP, 2); + st.wMinute = (WORD)AtoI(Buf + TIME_DISP + 3, 2); + //st.wYear+=st.wYear<50?2000:1900; + FILETIME ft; + SystemTimeToFileTime(&st, &ft); + LocalFileTimeToFileTime(&ft, &Item->FindData.ftLastWriteTime); + + //lstrcpy(Info->Description, Descrip); -- Maks VolumeID Description + char* Temp = Pos; // DIR + if (GetS(Buf, 4095)) + if (Compare(Buf, " @")) + lstrcpyn(Info->Description, Buf + 2, 256); + else + Pos = Temp; + + return GETARC_SUCCESS; + } + } + return GETARC_EOF; + } + + BOOL closeArchive() + { + if (Data) + UnmapViewOfFile(Data); + Data = nullptr; + + if (MapHandle && (MapHandle != INVALID_HANDLE_VALUE)) + CloseHandle(MapHandle); + MapHandle = nullptr; + + if (Handle && (Handle != INVALID_HANDLE_VALUE)) + CloseHandle(Handle); + Handle = nullptr; + + DirInfo* p = this; + if (p == gpCur) + gpCur = nullptr; + free(p); + + return true; + } +}; + + + +BOOL WINAPI _export IsArchive(char* Name, const unsigned char* Data, int DataSize) +{ + _ASSERTE(gpCur != nullptr); + static const char* ID[] = { " ", " Volume in drive ", "Queued to drive " }; + BOOL lbRc = FALSE; + const char* strData = reinterpret_cast(Data); + for (const auto* id : ID) { + if (gpCur->Compare(strData, id, true, min(lstrlen(id), DataSize))) + { + lbRc = TRUE; + break; + } + + } + return lbRc; +} + +BOOL WINAPI _export OpenArchive(char* Name, int* Type) +{ + _ASSERTE(gpCur == nullptr); + gpCur = static_cast(calloc(1, sizeof(DirInfo))); + if (!gpCur) + return FALSE; + gpCur->Handle = CreateFile(Name, GENERIC_READ, FILE_SHARE_READ, nullptr, + OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, nullptr); + return gpCur->openArchive(Type); +} + +int WINAPI _export GetArcItem(struct PluginPanelItem* Item, struct ArcItemInfo* Info) +{ + if (!gpCur) + return GETARC_EOF; + return gpCur->getArcItem(Item, Info); +} + +BOOL WINAPI _export CloseArchive(struct ArcInfo* Info) +{ + if (gpCur) + { + gpCur->closeArchive(); + } + return TRUE; +} + +//?? , MultiArc, +// MultiArc :( +BOOL WINAPI _export GetFormatName(int Type, char* FormatName, char* DefaultExt) +{ + if (Type == 0) + { + lstrcpy(FormatName, "DIR"); + lstrcpy(DefaultExt, "dir"); + return true; + } + return false; +} + +BOOL WINAPI _export GetDefaultCommands(int Type, int Command, char* Dest) +{ + if (Type == 0) + { + if (Command == 0) + { + //extract () + lstrcpyA(Dest, "dir.fmt.exe x %%A %%L"); + } + else if (Command == 1) + { + //extract without path ( ) + lstrcpyA(Dest, "dir.fmt.exe e %%A %%L"); + } + else + { + *Dest = 0; + } + return true; + } + return false; +} + +#include "ModuleDef.h" + +int nLastItemIndex = -1; + +int MODULE_EXPORT OpenStorage(StorageOpenParams params, HANDLE* storage, StorageGeneralInfo* info) +{ + nLastItemIndex = -1; + gpCur = static_cast(calloc(1, sizeof(DirInfo))); + if (!gpCur) + return SOR_INVALID_FILE; + gpCur->Handle = CreateFileW(params.FilePath, GENERIC_READ, FILE_SHARE_READ, nullptr, + OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, nullptr); + int Type = 0; + if (gpCur->openArchive(&Type)) + { + *storage = static_cast(gpCur); + lstrcpyW(info->Format, L"Dir"); + lstrcpyW(info->Compression, L""); + lstrcpyW(info->Comment, L""); + return SOR_SUCCESS; + } + gpCur->closeArchive(); + return SOR_INVALID_FILE; +} + +void MODULE_EXPORT CloseStorage(HANDLE storage) +{ + DirInfo* p = static_cast(storage); + if (p) + p->closeArchive(); +} + +int MODULE_EXPORT GetStorageItem(HANDLE storage, int item_index, StorageItemInfo* item_info) +{ + int iRc = GET_ITEM_NOMOREITEMS; + _ASSERTE(item_index > nLastItemIndex); + DirInfo* p = static_cast(storage); + nLastItemIndex = item_index; + PluginPanelItem Item{}; + ArcItemInfo Info{}; + if (p->getArcItem(&Item, &Info) == GETARC_SUCCESS) + { + item_info->Attributes = Item.FindData.dwFileAttributes; + LARGE_INTEGER li; li.LowPart = Item.FindData.nFileSizeLow; li.HighPart = Item.FindData.nFileSizeHigh; + item_info->Size = li.QuadPart; + item_info->CreationTime = Item.FindData.ftLastWriteTime; + item_info->ModificationTime = Item.FindData.ftLastWriteTime; + MultiByteToWideChar((p->CP_Check == p->cp_UTF8) ? CP_UTF8 : CP_OEMCP, 0, Item.FindData.cFileName, -1, item_info->Path, ARRAYSIZE(item_info->Path)); + iRc = GET_ITEM_OK; + } + return iRc; +} + +int MODULE_EXPORT ExtractItem(HANDLE storage, ExtractOperationParams params) +{ + return SER_ERROR_SYSTEM; +} + +int MODULE_EXPORT PrepareFiles(HANDLE storage) +{ + return SER_ERROR_SYSTEM; +} + +////////////////////////////////////////////////////////////////////////// +// Exported Functions +////////////////////////////////////////////////////////////////////////// + +// {C0651C24-3DCA-441C-8A42-C73664F942CF} +static const GUID MODULE_GUID = { 0xc0651c24, 0x3dca, 0x441c, { 0x8a, 0x42, 0xc7, 0x36, 0x64, 0xf9, 0x42, 0xcf } };; + +int MODULE_EXPORT LoadSubModule(ModuleLoadParameters* LoadParams) +{ + LoadParams->ModuleId = MODULE_GUID; + LoadParams->ModuleVersion = MAKEMODULEVERSION(1, 0); + LoadParams->ApiVersion = ACTUAL_API_VERSION; + + LoadParams->ApiFuncs.OpenStorage = OpenStorage; + LoadParams->ApiFuncs.CloseStorage = CloseStorage; + LoadParams->ApiFuncs.GetItem = GetStorageItem; + LoadParams->ApiFuncs.ExtractItem = ExtractItem; + LoadParams->ApiFuncs.PrepareFiles = PrepareFiles; + + return TRUE; +} + +void MODULE_EXPORT UnloadSubModule() +{ +} diff --git a/Dir_b3/dir_b3.def b/Dir_b3/dir_b3.def new file mode 100644 index 0000000..eb0b397 --- /dev/null +++ b/Dir_b3/dir_b3.def @@ -0,0 +1,9 @@ +EXPORTS + IsArchive + OpenArchive + GetArcItem + CloseArchive + GetFormatName + GetDefaultCommands + LoadSubModule + UnloadSubModule diff --git a/Dir_b3/dir_b3.rc b/Dir_b3/dir_b3.rc new file mode 100644 index 0000000..daffc9f --- /dev/null +++ b/Dir_b3/dir_b3.rc @@ -0,0 +1,96 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource." + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// German (Germany) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_DEU) +LANGUAGE LANG_GERMAN, SUBLANG_GERMAN +#pragma code_page(1252) + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 3,0,0,7 + PRODUCTVERSION 1,71,0,0 + FILEFLAGSMASK 0x0L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "000004e4" + BEGIN + VALUE "Comments", "Current developer: ConEmu.Maximus5@gmail.com" + VALUE "FileDescription", "DIR XP/2003/Vista/7 parse for FAR Manager" + VALUE "FileVersion", "3.0 build 7" + VALUE "InternalName", "Dir" + VALUE "LegalCopyright", " Alexander Arefiev 2001, Maximus5 2012" + VALUE "OriginalFilename", "dir.so" + VALUE "ProductName", "FAR Manager" + VALUE "ProductVersion", "1.71" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0, 1252 + END +END + +#endif // German (Germany) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/Dir_b3/dir_so.vcxproj b/Dir_b3/dir_so.vcxproj new file mode 100644 index 0000000..8ba4efa --- /dev/null +++ b/Dir_b3/dir_so.vcxproj @@ -0,0 +1,208 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + 16.0 + Win32Proj + {54892e57-f71a-4e2d-8132-b717b3fd7649} + dirso + 8.1 + + + + DynamicLibrary + true + v141_xp + MultiByte + + + DynamicLibrary + false + v141_xp + true + MultiByte + + + DynamicLibrary + true + v142 + MultiByte + + + DynamicLibrary + false + v142 + true + MultiByte + + + + + + + + + + + + + + + + + + + + + true + $(Configuration)\ + dir + obj\$(Platform)\$(Configuration)\ + .so + + + false + $(Configuration)\ + dir + obj\$(Platform)\$(Configuration)\ + .so + + + true + dir64 + $(Configuration)\ + obj\$(Platform)\$(Configuration)\ + .so + + + false + dir64 + $(Configuration)\ + obj\$(Platform)\$(Configuration)\ + .so + + + + Level3 + true + WIN32;_DEBUG;DIRSO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + MultiThreadedDebug + + + + Windows + true + false + dir_b3.def + + + + + Level3 + true + true + true + WIN32;NDEBUG;DIRSO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + MultiThreaded + + + + Windows + true + true + true + false + dir_b3.def + + + + + Level3 + true + _DEBUG;DIRSO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + MultiThreadedDebug + + + + Windows + true + false + dir_b3.def + C:\Users\Maksim.Moisiuk\AppData\Local\Far Manager x64\Plugins\Observer\modules\dir64.so + + + + + Level3 + true + true + true + NDEBUG;DIRSO_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + NotUsing + + + MultiThreaded + + + + Windows + true + true + true + false + dir_b3.def + + + + + + \ No newline at end of file diff --git a/Dir_b3/dir_so.vcxproj.filters b/Dir_b3/dir_so.vcxproj.filters new file mode 100644 index 0000000..3598203 --- /dev/null +++ b/Dir_b3/dir_so.vcxproj.filters @@ -0,0 +1,53 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + + + Source Files + + + + Resource Files + + + + + Resource Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + + \ No newline at end of file diff --git a/Dir_b3/fmt.hpp b/Dir_b3/fmt.hpp new file mode 100644 index 0000000..ba5dae5 --- /dev/null +++ b/Dir_b3/fmt.hpp @@ -0,0 +1,103 @@ +#ifndef __FARFMT_HPP__ +#define __FARFMT_HPP__ +/* + FMT.HPP + + Archive Support API for FAR Manager 1.75 and MultiArc plugin + + Copyright (c) 1996-2000 Eugene Roshal + Copyrigth (c) 2000-2008 FAR group +*/ + +#if !defined(_WIN64) +#if defined(__BORLANDC__) + #pragma option -a2 +#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__) + #pragma pack(2) + #if defined(__LCC__) + #define _export __declspec(dllexport) + #endif +#else + #pragma pack(push,2) + #if _MSC_VER + #ifdef _export + #undef _export + #endif + #define _export + #endif +#endif +#endif + +enum GETARC_CODE +{ + GETARC_EOF =0, + GETARC_SUCCESS =1, + GETARC_BROKEN =2, + GETARC_UNEXPEOF =3, + GETARC_READERROR =4, +}; + +struct ArcItemInfo +{ + char HostOS[32]; + char Description[256]; + int Solid; + int Comment; + int Encrypted; + int DictSize; + int UnpVer; + int Chapter; +}; + +enum ARCINFO_FLAGS +{ + AF_AVPRESENT =0x00000001, + AF_IGNOREERRORS =0x00000002, + AF_HDRENCRYPTED =0x00000080, +}; + +struct ArcInfo +{ + int SFXSize; + int Volume; + int Comment; + int Recovery; + int Lock; + DWORD Flags; + DWORD Reserved; + int Chapters; +}; + + +#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__GNUC__) || defined(__WATCOMC__) +#ifdef __cplusplus +extern "C"{ +#endif + +DWORD WINAPI _export LoadFormatModule(const char *ModuleName); +void WINAPI _export SetFarInfo(const struct PluginStartupInfo *Info); + +BOOL WINAPI _export IsArchive(const char *Name,const unsigned char *Data,int DataSize); +DWORD WINAPI _export GetSFXPos(void); +BOOL WINAPI _export OpenArchive(const char *Name,int *TypeArc); +int WINAPI _export GetArcItem(struct PluginPanelItem *Item,struct ArcItemInfo *Info); +BOOL WINAPI _export CloseArchive(struct ArcInfo *Info); +BOOL WINAPI _export GetFormatName(int TypeArc,char *FormatName,char *DefaultExt); +BOOL WINAPI _export GetDefaultCommands(int TypeArc,int Command,char *Dest); + +#ifdef __cplusplus +}; +#endif +#endif + +#if !defined(_WIN64) +#if defined(__BORLANDC__) + #pragma option -a. +#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__) + #pragma pack() +#else + #pragma pack(pop) +#endif +#endif + +#endif /* __FARFMT_HPP__ */ diff --git a/Dir_b3/plugin.hpp b/Dir_b3/plugin.hpp new file mode 100644 index 0000000..f8cbf61 --- /dev/null +++ b/Dir_b3/plugin.hpp @@ -0,0 +1,1851 @@ +#ifndef __PLUGIN_HPP__ +#define __PLUGIN_HPP__ + +/* + plugin.hpp + + Plugin API for FAR Manager 1.75 build 2593 + + Copyright (c) 1996-2000 Eugene Roshal + Copyright (c) 2000-2009 FAR group +*/ + +#define FARMANAGERVERSION_MAJOR 1 +#define FARMANAGERVERSION_MINOR 75 +#define FARMANAGERVERSION_BUILD 2593 + +#ifndef RC_INVOKED + +#define MAKEFARVERSION(major,minor,build) ( ((major)<<8) | (minor) | ((build)<<16)) + +#define FARMANAGERVERSION MAKEFARVERSION(FARMANAGERVERSION_MAJOR,FARMANAGERVERSION_MINOR,FARMANAGERVERSION_BUILD) + +#if !defined(_INC_WINDOWS) && !defined(_WINDOWS_) + #if (defined(__GNUC__) || defined(_MSC_VER)) && !defined(_WIN64) + #if !defined(_WINCON_H) && !defined(_WINCON_) + #define _WINCON_H + #define _WINCON_ // to prevent including wincon.h + #if defined(_MSC_VER) + #pragma pack(push,2) + #else + #pragma pack(2) + #endif + #include + #if defined(_MSC_VER) + #pragma pack(pop) + #else + #pragma pack() + #endif + #undef _WINCON_ + #undef _WINCON_H + + #if defined(_MSC_VER) + #pragma pack(push,8) + #else + #pragma pack(8) + #endif + #include + #if defined(_MSC_VER) + #pragma pack(pop) + #else + #pragma pack() + #endif + #endif + #define _WINCON_ + #else + #include + #endif +#endif + +#if defined(__BORLANDC__) + #ifndef _WIN64 + #pragma option -a2 + #endif +#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__) + #ifndef _WIN64 + #pragma pack(2) + #endif + #if defined(__LCC__) + #define _export __declspec(dllexport) + #endif +#else + #ifndef _WIN64 + #pragma pack(push,2) + #endif + #if _MSC_VER + #ifdef _export + #undef _export + #endif + #define _export + #endif +#endif + +#define NM 260 + +#undef DefDlgProc + +#define FARMACRO_KEY_EVENT (KEY_EVENT|0x8000) + +// To ensure compatibility of plugin.hpp with compilers not supporting C++, +// you can #define _FAR_NO_NAMELESS_UNIONS. In this case, to access, +// for example, the Data field of the FarDialogItem structure +// you will need to use Data.Data, and the Selected field - Param.Selected +//#define _FAR_NO_NAMELESS_UNIONS + +// To ensure correct structure packing the member PluginPanelItem.FindData +// has the type FAR_FIND_DATA, not WIN32_FIND_DATA (since version 1.71 +// build 2250). The structure FAR_FIND_DATA has the same layout as +// WIN32_FIND_DATA, but since it is declared in this file, it is +// generated with correct 2-byte alignment. +// This #define is necessary to compile plugins that expect +// PluginPanelItem.FindData to be of WIN32_FIND_DATA type. +//#define _FAR_USE_WIN32_FIND_DATA + +#ifndef _WINCON_ +typedef struct _INPUT_RECORD INPUT_RECORD; +typedef struct _CHAR_INFO CHAR_INFO; +#endif + +enum FARMESSAGEFLAGS{ + FMSG_WARNING = 0x00000001, + FMSG_ERRORTYPE = 0x00000002, + FMSG_KEEPBACKGROUND = 0x00000004, + FMSG_DOWN = 0x00000008, + FMSG_LEFTALIGN = 0x00000010, + + FMSG_ALLINONE = 0x00000020, + + FMSG_MB_OK = 0x00010000, + FMSG_MB_OKCANCEL = 0x00020000, + FMSG_MB_ABORTRETRYIGNORE = 0x00030000, + FMSG_MB_YESNO = 0x00040000, + FMSG_MB_YESNOCANCEL = 0x00050000, + FMSG_MB_RETRYCANCEL = 0x00060000, +}; + +typedef int (WINAPI *FARAPIMESSAGE)( + INT_PTR PluginNumber, + DWORD Flags, + const char *HelpTopic, + const char * const *Items, + int ItemsNumber, + int ButtonsNumber +); + + +enum DialogItemTypes { + DI_TEXT, + DI_VTEXT, + DI_SINGLEBOX, + DI_DOUBLEBOX, + DI_EDIT, + DI_PSWEDIT, + DI_FIXEDIT, + DI_BUTTON, + DI_CHECKBOX, + DI_RADIOBUTTON, + DI_COMBOBOX, + DI_LISTBOX, + + DI_USERCONTROL=255, +}; + +enum FarDialogItemFlags { + DIF_COLORMASK = 0x000000ffUL, + DIF_SETCOLOR = 0x00000100UL, + DIF_BOXCOLOR = 0x00000200UL, + DIF_GROUP = 0x00000400UL, + DIF_LEFTTEXT = 0x00000800UL, + DIF_MOVESELECT = 0x00001000UL, + DIF_SHOWAMPERSAND = 0x00002000UL, + DIF_CENTERGROUP = 0x00004000UL, + DIF_NOBRACKETS = 0x00008000UL, + DIF_MANUALADDHISTORY = 0x00008000UL, + DIF_SEPARATOR = 0x00010000UL, + DIF_VAREDIT = 0x00010000UL, + DIF_SEPARATOR2 = 0x00020000UL, + DIF_EDITOR = 0x00020000UL, + DIF_LISTNOAMPERSAND = 0x00020000UL, + DIF_LISTNOBOX = 0x00040000UL, + DIF_HISTORY = 0x00040000UL, + DIF_BTNNOCLOSE = 0x00040000UL, + DIF_CENTERTEXT = 0x00040000UL, + DIF_NOTCVTUSERCONTROL = 0x00040000UL, + DIF_EDITEXPAND = 0x00080000UL, + DIF_DROPDOWNLIST = 0x00100000UL, + DIF_USELASTHISTORY = 0x00200000UL, + DIF_MASKEDIT = 0x00400000UL, + DIF_SELECTONENTRY = 0x00800000UL, + DIF_3STATE = 0x00800000UL, + DIF_LISTWRAPMODE = 0x01000000UL, + DIF_NOAUTOCOMPLETE = 0x02000000UL, + DIF_LISTAUTOHIGHLIGHT = 0x02000000UL, + DIF_LISTNOCLOSE = 0x04000000UL, + DIF_HIDDEN = 0x10000000UL, + DIF_READONLY = 0x20000000UL, + DIF_NOFOCUS = 0x40000000UL, + DIF_DISABLE = 0x80000000UL, +}; + +enum FarMessagesProc{ + DM_FIRST=0, + DM_CLOSE, + DM_ENABLE, + DM_ENABLEREDRAW, + DM_GETDLGDATA, + DM_GETDLGITEM, + DM_GETDLGRECT, + DM_GETTEXT, + DM_GETTEXTLENGTH, + DM_KEY, + DM_MOVEDIALOG, + DM_SETDLGDATA, + DM_SETDLGITEM, + DM_SETFOCUS, + DM_REDRAW, + DM_SETREDRAW=DM_REDRAW, + DM_SETTEXT, + DM_SETMAXTEXTLENGTH, + DM_SETTEXTLENGTH=DM_SETMAXTEXTLENGTH, + DM_SHOWDIALOG, + DM_GETFOCUS, + DM_GETCURSORPOS, + DM_SETCURSORPOS, + DM_GETTEXTPTR, + DM_SETTEXTPTR, + DM_SHOWITEM, + DM_ADDHISTORY, + + DM_GETCHECK, + DM_SETCHECK, + DM_SET3STATE, + + DM_LISTSORT, + DM_LISTGETITEM, + DM_LISTGETCURPOS, + DM_LISTSETCURPOS, + DM_LISTDELETE, + DM_LISTADD, + DM_LISTADDSTR, + DM_LISTUPDATE, + DM_LISTINSERT, + DM_LISTFINDSTRING, + DM_LISTINFO, + DM_LISTGETDATA, + DM_LISTSETDATA, + DM_LISTSETTITLES, + DM_LISTGETTITLES, + + DM_RESIZEDIALOG, + DM_SETITEMPOSITION, + + DM_GETDROPDOWNOPENED, + DM_SETDROPDOWNOPENED, + + DM_SETHISTORY, + + DM_GETITEMPOSITION, + DM_SETMOUSEEVENTNOTIFY, + + DM_EDITUNCHANGEDFLAG, + + DM_GETITEMDATA, + DM_SETITEMDATA, + + DM_LISTSET, + DM_LISTSETMOUSEREACTION, + + DM_GETCURSORSIZE, + DM_SETCURSORSIZE, + + DM_LISTGETDATASIZE, + + DM_GETSELECTION, + DM_SETSELECTION, + + DN_LISTHOTKEY, + + DM_GETEDITPOSITION, + DM_SETEDITPOSITION, + + DM_SETCOMBOBOXEVENT, + DM_GETCOMBOBOXEVENT, + + DN_FIRST=0x1000, + DN_BTNCLICK, + DN_CTLCOLORDIALOG, + DN_CTLCOLORDLGITEM, + DN_CTLCOLORDLGLIST, + DN_DRAWDIALOG, + DN_DRAWDLGITEM, + DN_EDITCHANGE, + DN_ENTERIDLE, + DN_GOTFOCUS, + DN_HELP, + DN_HOTKEY, + DN_INITDIALOG, + DN_KILLFOCUS, + DN_LISTCHANGE, + DN_MOUSECLICK, + DN_DRAGGED, + DN_RESIZECONSOLE, + DN_MOUSEEVENT, + DN_DRAWDIALOGDONE, + + DN_CLOSE=DM_CLOSE, + DN_KEY=DM_KEY, + + DM_USER=0x4000, + +}; + +enum FARCHECKEDSTATE { + BSTATE_UNCHECKED = 0, + BSTATE_CHECKED = 1, + BSTATE_3STATE = 2, + BSTATE_TOGGLE = 3, +}; + +enum FARLISTMOUSEREACTIONTYPE{ + LMRT_ONLYFOCUS = 0, + LMRT_ALWAYS = 1, + LMRT_NEVER = 2, +}; + +enum FARCOMBOBOXEVENTTYPE{ + CBET_KEY = 0x00000001, + CBET_MOUSE = 0x00000002, +}; + +enum LISTITEMFLAGS { + LIF_SELECTED = 0x00010000UL, + LIF_CHECKED = 0x00020000UL, + LIF_SEPARATOR = 0x00040000UL, + LIF_DISABLE = 0x00080000UL, + LIF_GRAYED = 0x00100000UL, + LIF_HIDDEN = 0x00200000UL, + LIF_DELETEUSERDATA = 0x80000000UL, +}; + +struct FarListItem +{ + DWORD Flags; + char Text[128]; + DWORD Reserved[3]; +}; + +struct FarListUpdate +{ + int Index; + struct FarListItem Item; +}; + +struct FarListInsert +{ + int Index; + struct FarListItem Item; +}; + +struct FarListGetItem +{ + int ItemIndex; + struct FarListItem Item; +}; + +struct FarListPos +{ + int SelectPos; + int TopPos; +}; + +enum FARLISTFINDFLAGS{ + LIFIND_EXACTMATCH = 0x00000001, +}; + +struct FarListFind +{ + int StartIndex; + const char *Pattern; + DWORD Flags; + DWORD Reserved; +}; + +struct FarListDelete +{ + int StartIndex; + int Count; +}; + +enum FARLISTINFOFLAGS{ + LINFO_SHOWNOBOX = 0x00000400, + LINFO_AUTOHIGHLIGHT = 0x00000800, + LINFO_REVERSEHIGHLIGHT = 0x00001000, + LINFO_WRAPMODE = 0x00008000, + LINFO_SHOWAMPERSAND = 0x00010000, +}; + +struct FarListInfo +{ + DWORD Flags; + int ItemsNumber; + int SelectPos; + int TopPos; + int MaxHeight; + int MaxLength; + DWORD Reserved[6]; +}; + +struct FarListItemData +{ + int Index; + int DataSize; + void *Data; + DWORD Reserved; +}; + +struct FarList +{ + int ItemsNumber; + struct FarListItem *Items; +}; + +struct FarListTitles +{ + int TitleLen; + char *Title; + int BottomLen; + char *Bottom; +}; + +struct FarListColors{ + DWORD Flags; + DWORD Reserved; + int ColorCount; + LPBYTE Colors; +}; + +struct FarDialogItem +{ + int Type; + int X1,Y1,X2,Y2; + int Focus; + union + { + DWORD_PTR Reserved; + int Selected; + const char *History; + const char *Mask; + struct FarList *ListItems; + int ListPos; + CHAR_INFO *VBuf; + } +#ifdef _FAR_NO_NAMELESS_UNIONS + Param +#endif + ; + DWORD Flags; + int DefaultButton; + union + { + char Data[512]; + struct + { + DWORD PtrFlags; + int PtrLength; + char *PtrData; + char PtrTail[1]; + } Ptr; + } +#ifdef _FAR_NO_NAMELESS_UNIONS + Data +#endif + ; +}; + +struct FarDialogItemData +{ + int PtrLength; + char *PtrData; +}; + +struct FarDialogEvent +{ + HANDLE hDlg; + int Msg; + int Param1; + LONG_PTR Param2; + LONG_PTR Result; +}; + +struct OpenDlgPluginData +{ + int ItemNumber; + HANDLE hDlg; +}; + +#define Dlg_RedrawDialog(Info,hDlg) Info.SendDlgMessage(hDlg,DM_REDRAW,0,0) + +#define Dlg_GetDlgData(Info,hDlg) Info.SendDlgMessage(hDlg,DM_GETDLGDATA,0,0) +#define Dlg_SetDlgData(Info,hDlg,Data) Info.SendDlgMessage(hDlg,DM_SETDLGDATA,0,(LONG_PTR)Data) + +#define Dlg_GetDlgItemData(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_GETITEMDATA,0,0) +#define Dlg_SetDlgItemData(Info,hDlg,ID,Data) Info.SendDlgMessage(hDlg,DM_SETITEMDATA,0,(LONG_PTR)Data) + +#define DlgItem_GetFocus(Info,hDlg) Info.SendDlgMessage(hDlg,DM_GETFOCUS,0,0) +#define DlgItem_SetFocus(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_SETFOCUS,ID,0) +#define DlgItem_Enable(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_ENABLE,ID,TRUE) +#define DlgItem_Disable(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_ENABLE,ID,FALSE) +#define DlgItem_IsEnable(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_ENABLE,ID,-1) +#define DlgItem_SetText(Info,hDlg,ID,Str) Info.SendDlgMessage(hDlg,DM_SETTEXTPTR,ID,(LONG_PTR)Str) + +#define DlgItem_GetCheck(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_GETCHECK,ID,0) +#define DlgItem_SetCheck(Info,hDlg,ID,State) Info.SendDlgMessage(hDlg,DM_SETCHECK,ID,State) + +#define DlgEdit_AddHistory(Info,hDlg,ID,Str) Info.SendDlgMessage(hDlg,DM_ADDHISTORY,ID,(LONG_PTR)Str) + +#define DlgList_AddString(Info,hDlg,ID,Str) Info.SendDlgMessage(hDlg,DM_LISTADDSTR,ID,(LONG_PTR)Str) +#define DlgList_GetCurPos(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_LISTGETCURPOS,ID,0) +#define DlgList_SetCurPos(Info,hDlg,ID,NewPos) {struct FarListPos LPos={NewPos,-1};Info.SendDlgMessage(hDlg,DM_LISTSETCURPOS,ID,(LONG_PTR)&LPos);} +#define DlgList_ClearList(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_LISTDELETE,ID,0) +#define DlgList_DeleteItem(Info,hDlg,ID,Index) {struct FarListDelete FLDItem={Index,1}; Info.SendDlgMessage(hDlg,DM_LISTDELETE,ID,(LONG_PTR)&FLDItem);} +#define DlgList_SortUp(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_LISTSORT,ID,0) +#define DlgList_SortDown(Info,hDlg,ID) Info.SendDlgMessage(hDlg,DM_LISTSORT,ID,1) +#define DlgList_GetItemData(Info,hDlg,ID,Index) Info.SendDlgMessage(hDlg,DM_LISTGETDATA,ID,Index) +#define DlgList_SetItemStrAsData(Info,hDlg,ID,Index,Str) {struct FarListItemData FLID{Index,0,Str,0}; Info.SendDlgMessage(hDlg,DM_LISTSETDATA,ID,(LONG_PTR)&FLID);} + +enum FARDIALOGFLAGS{ + FDLG_WARNING = 0x00000001, + FDLG_SMALLDIALOG = 0x00000002, + FDLG_NODRAWSHADOW = 0x00000004, + FDLG_NODRAWPANEL = 0x00000008, +}; + +typedef LONG_PTR (WINAPI *FARWINDOWPROC)( + HANDLE hDlg, + int Msg, + int Param1, + LONG_PTR Param2 +); + +typedef LONG_PTR (WINAPI *FARAPISENDDLGMESSAGE)( + HANDLE hDlg, + int Msg, + int Param1, + LONG_PTR Param2 +); + +typedef LONG_PTR (WINAPI *FARAPIDEFDLGPROC)( + HANDLE hDlg, + int Msg, + int Param1, + LONG_PTR Param2 +); + +typedef int (WINAPI *FARAPIDIALOG)( + INT_PTR PluginNumber, + int X1, + int Y1, + int X2, + int Y2, + const char *HelpTopic, + struct FarDialogItem *Item, + int ItemsNumber +); + +typedef int (WINAPI *FARAPIDIALOGEX)( + INT_PTR PluginNumber, + int X1, + int Y1, + int X2, + int Y2, + const char *HelpTopic, + struct FarDialogItem *Item, + int ItemsNumber, + DWORD Reserved, + DWORD Flags, + FARWINDOWPROC DlgProc, + LONG_PTR Param +); + + +struct FarMenuItem +{ + char Text[128]; + int Selected; + int Checked; + int Separator; +}; + +enum MENUITEMFLAGS { + MIF_SELECTED = 0x00010000UL, + MIF_CHECKED = 0x00020000UL, + MIF_SEPARATOR = 0x00040000UL, + MIF_DISABLE = 0x00080000UL, + MIF_GRAYED = 0x00100000UL, + MIF_HIDDEN = 0x00200000UL, + MIF_USETEXTPTR = 0x80000000UL, +}; + +struct FarMenuItemEx +{ + DWORD Flags; + union { + char Text[128]; + const char *TextPtr; + } Text; + DWORD AccelKey; + DWORD Reserved; + DWORD_PTR UserData; +}; + +enum FARMENUFLAGS{ + FMENU_SHOWAMPERSAND = 0x00000001, + FMENU_WRAPMODE = 0x00000002, + FMENU_AUTOHIGHLIGHT = 0x00000004, + FMENU_REVERSEAUTOHIGHLIGHT = 0x00000008, + FMENU_USEEXT = 0x00000020, + FMENU_CHANGECONSOLETITLE = 0x00000040, +}; + +typedef int (WINAPI *FARAPIMENU)( + INT_PTR PluginNumber, + int X, + int Y, + int MaxHeight, + DWORD Flags, + const char *Title, + const char *Bottom, + const char *HelpTopic, + const int *BreakKeys, + int *BreakCode, + const struct FarMenuItem *Item, + int ItemsNumber +); + + +enum PLUGINPANELITEMFLAGS{ + PPIF_PROCESSDESCR = 0x80000000, + PPIF_SELECTED = 0x40000000, + PPIF_USERDATA = 0x20000000, +}; + +#ifndef _FAR_USE_WIN32_FIND_DATA + +struct FAR_FIND_DATA +{ + DWORD dwFileAttributes; + FILETIME ftCreationTime; + FILETIME ftLastAccessTime; + FILETIME ftLastWriteTime; + DWORD nFileSizeHigh; + DWORD nFileSizeLow; + DWORD dwReserved0; + DWORD dwReserved1; + CHAR cFileName[MAX_PATH]; + CHAR cAlternateFileName[14]; +}; + +#endif + +struct PluginPanelItem +{ +#ifndef _FAR_USE_WIN32_FIND_DATA + struct FAR_FIND_DATA FindData; +#else + WIN32_FIND_DATA FindData; +#endif + DWORD PackSizeHigh; + DWORD PackSize; + DWORD Flags; + DWORD NumberOfLinks; + char *Description; + char *Owner; + char **CustomColumnData; + int CustomColumnNumber; + DWORD_PTR UserData; + DWORD CRC32; + DWORD_PTR Reserved[2]; +}; + +#if defined(__BORLANDC__) +#if sizeof(struct PluginPanelItem) != 366 +#if defined(STRICT) +#error Incorrect alignment: sizeof(PluginPanelItem)!=366 +#else +#pragma message Incorrect alignment: sizeof(PluginPanelItem)!=366 +#endif +#endif +#endif + +enum PANELINFOFLAGS { + PFLAGS_SHOWHIDDEN = 0x00000001, + PFLAGS_HIGHLIGHT = 0x00000002, + PFLAGS_REVERSESORTORDER = 0x00000004, + PFLAGS_USESORTGROUPS = 0x00000008, + PFLAGS_SELECTEDFIRST = 0x00000010, + PFLAGS_REALNAMES = 0x00000020, + PFLAGS_NUMERICSORT = 0x00000040, + PFLAGS_PANELLEFT = 0x00000080, +}; + +enum PANELINFOTYPE{ + PTYPE_FILEPANEL, + PTYPE_TREEPANEL, + PTYPE_QVIEWPANEL, + PTYPE_INFOPANEL +}; + +struct PanelInfo +{ + int PanelType; + int Plugin; + RECT PanelRect; + struct PluginPanelItem *PanelItems; + int ItemsNumber; + struct PluginPanelItem *SelectedItems; + int SelectedItemsNumber; + int CurrentItem; + int TopPanelItem; + int Visible; + int Focus; + int ViewMode; + char ColumnTypes[80]; + char ColumnWidths[80]; + char CurDir[NM]; + int ShortNames; + int SortMode; + DWORD Flags; + DWORD Reserved; +}; + + +struct PanelRedrawInfo +{ + int CurrentItem; + int TopPanelItem; +}; + +struct CmdLineSelect +{ + int SelStart; + int SelEnd; +}; + +enum FILE_CONTROL_COMMANDS{ + FCTL_CLOSEPLUGIN, + FCTL_GETPANELINFO, + FCTL_GETANOTHERPANELINFO, + FCTL_UPDATEPANEL, + FCTL_UPDATEANOTHERPANEL, + FCTL_REDRAWPANEL, + FCTL_REDRAWANOTHERPANEL, + FCTL_SETANOTHERPANELDIR, + FCTL_GETCMDLINE, + FCTL_SETCMDLINE, + FCTL_SETSELECTION, + FCTL_SETANOTHERSELECTION, + FCTL_SETVIEWMODE, + FCTL_SETANOTHERVIEWMODE, + FCTL_INSERTCMDLINE, + FCTL_SETUSERSCREEN, + FCTL_SETPANELDIR, + FCTL_SETCMDLINEPOS, + FCTL_GETCMDLINEPOS, + FCTL_SETSORTMODE, + FCTL_SETANOTHERSORTMODE, + FCTL_SETSORTORDER, + FCTL_SETANOTHERSORTORDER, + FCTL_GETCMDLINESELECTEDTEXT, + FCTL_SETCMDLINESELECTION, + FCTL_GETCMDLINESELECTION, + FCTL_GETPANELSHORTINFO, + FCTL_GETANOTHERPANELSHORTINFO, + FCTL_CHECKPANELSEXIST, + FCTL_SETNUMERICSORT, + FCTL_SETANOTHERNUMERICSORT, + FCTL_GETUSERSCREEN, +}; + +typedef int (WINAPI *FARAPICONTROL)( + HANDLE hPlugin, + int Command, + void *Param +); + +typedef void (WINAPI *FARAPITEXT)( + int X, + int Y, + int Color, + const char *Str +); + +typedef HANDLE (WINAPI *FARAPISAVESCREEN)(int X1, int Y1, int X2, int Y2); + +typedef void (WINAPI *FARAPIRESTORESCREEN)(HANDLE hScreen); + + +typedef int (WINAPI *FARAPIGETDIRLIST)( + const char *Dir, + struct PluginPanelItem **pPanelItem, + int *pItemsNumber +); + +typedef int (WINAPI *FARAPIGETPLUGINDIRLIST)( + INT_PTR PluginNumber, + HANDLE hPlugin, + const char *Dir, + struct PluginPanelItem **pPanelItem, + int *pItemsNumber +); + +typedef void (WINAPI *FARAPIFREEDIRLIST)(const struct PluginPanelItem *PanelItem); + +enum VIEWER_FLAGS { + VF_NONMODAL = 0x00000001, + VF_DELETEONCLOSE = 0x00000002, + VF_ENABLE_F6 = 0x00000004, + VF_DISABLEHISTORY = 0x00000008, + VF_IMMEDIATERETURN = 0x00000100, + VF_DELETEONLYFILEONCLOSE = 0x00000200, +}; + +typedef int (WINAPI *FARAPIVIEWER)( + const char *FileName, + const char *Title, + int X1, + int Y1, + int X2, + int Y2, + DWORD Flags +); + +enum EDITOR_FLAGS { + EF_NONMODAL = 0x00000001, + EF_CREATENEW = 0x00000002, + EF_ENABLE_F6 = 0x00000004, + EF_DISABLEHISTORY = 0x00000008, + EF_DELETEONCLOSE = 0x00000010, + EF_IMMEDIATERETURN = 0x00000100, + EF_DELETEONLYFILEONCLOSE = 0x00000200, +}; + +enum EDITOR_EXITCODE{ + EEC_OPEN_ERROR = 0, + EEC_MODIFIED = 1, + EEC_NOT_MODIFIED = 2, + EEC_LOADING_INTERRUPTED = 3, +}; + +typedef int (WINAPI *FARAPIEDITOR)( + const char *FileName, + const char *Title, + int X1, + int Y1, + int X2, + int Y2, + DWORD Flags, + int StartLine, + int StartChar +); + +typedef int (WINAPI *FARAPICMPNAME)( + const char *Pattern, + const char *String, + int SkipPath +); + + +enum FARCHARTABLE_COMMAND{ + FCT_DETECT=0x40000000, +}; + +struct CharTableSet +{ + unsigned char DecodeTable[256]; + unsigned char EncodeTable[256]; + unsigned char UpperTable[256]; + unsigned char LowerTable[256]; + char TableName[128]; +}; + +typedef int (WINAPI *FARAPICHARTABLE)( + int Command, + char *Buffer, + int BufferSize +); + +typedef const char* (WINAPI *FARAPIGETMSG)( + INT_PTR PluginNumber, + int MsgId +); + + +enum FarHelpFlags{ + FHELP_NOSHOWERROR = 0x80000000, + FHELP_SELFHELP = 0x00000000, + FHELP_FARHELP = 0x00000001, + FHELP_CUSTOMFILE = 0x00000002, + FHELP_CUSTOMPATH = 0x00000004, + FHELP_USECONTENTS = 0x40000000, +}; + +typedef BOOL (WINAPI *FARAPISHOWHELP)( + const char *ModuleName, + const char *Topic, + DWORD Flags +); + +enum ADVANCED_CONTROL_COMMANDS{ + ACTL_GETFARVERSION = 0, + ACTL_CONSOLEMODE = 1, + ACTL_GETSYSWORDDIV = 2, + ACTL_WAITKEY = 3, + ACTL_GETCOLOR = 4, + ACTL_GETARRAYCOLOR = 5, + ACTL_EJECTMEDIA = 6, + ACTL_KEYMACRO = 7, + ACTL_POSTKEYSEQUENCE = 8, + ACTL_GETWINDOWINFO = 9, + ACTL_GETWINDOWCOUNT = 10, + ACTL_SETCURRENTWINDOW = 11, + ACTL_COMMIT = 12, + ACTL_GETFARHWND = 13, + ACTL_GETSYSTEMSETTINGS = 14, + ACTL_GETPANELSETTINGS = 15, + ACTL_GETINTERFACESETTINGS = 16, + ACTL_GETCONFIRMATIONS = 17, + ACTL_GETDESCSETTINGS = 18, + ACTL_SETARRAYCOLOR = 19, + ACTL_GETWCHARMODE = 20, + ACTL_GETPLUGINMAXREADDATA = 21, + ACTL_GETDIALOGSETTINGS = 22, + ACTL_GETSHORTWINDOWINFO = 23, + ACTL_REDRAWALL = 27, +}; + + +enum FarSystemSettings{ + FSS_CLEARROATTRIBUTE = 0x00000001, + FSS_DELETETORECYCLEBIN = 0x00000002, + FSS_USESYSTEMCOPYROUTINE = 0x00000004, + FSS_COPYFILESOPENEDFORWRITING = 0x00000008, + FSS_CREATEFOLDERSINUPPERCASE = 0x00000010, + FSS_SAVECOMMANDSHISTORY = 0x00000020, + FSS_SAVEFOLDERSHISTORY = 0x00000040, + FSS_SAVEVIEWANDEDITHISTORY = 0x00000080, + FSS_USEWINDOWSREGISTEREDTYPES = 0x00000100, + FSS_AUTOSAVESETUP = 0x00000200, + FSS_SCANSYMLINK = 0x00000400, +}; + +enum FarPanelSettings{ + FPS_SHOWHIDDENANDSYSTEMFILES = 0x00000001, + FPS_HIGHLIGHTFILES = 0x00000002, + FPS_AUTOCHANGEFOLDER = 0x00000004, + FPS_SELECTFOLDERS = 0x00000008, + FPS_ALLOWREVERSESORTMODES = 0x00000010, + FPS_SHOWCOLUMNTITLES = 0x00000020, + FPS_SHOWSTATUSLINE = 0x00000040, + FPS_SHOWFILESTOTALINFORMATION = 0x00000080, + FPS_SHOWFREESIZE = 0x00000100, + FPS_SHOWSCROLLBAR = 0x00000200, + FPS_SHOWBACKGROUNDSCREENSNUMBER = 0x00000400, + FPS_SHOWSORTMODELETTER = 0x00000800, +}; + +enum FarDialogSettings{ + FDIS_HISTORYINDIALOGEDITCONTROLS = 0x00000001, + FDIS_PERSISTENTBLOCKSINEDITCONTROLS = 0x00000002, + FDIS_AUTOCOMPLETEININPUTLINES = 0x00000004, + FDIS_BSDELETEUNCHANGEDTEXT = 0x00000008, + FDIS_DELREMOVESBLOCKS = 0x00000010, + FDIS_MOUSECLICKOUTSIDECLOSESDIALOG = 0x00000020, +}; + +enum FarInterfaceSettings{ + FIS_CLOCKINPANELS = 0x00000001, + FIS_CLOCKINVIEWERANDEDITOR = 0x00000002, + FIS_MOUSE = 0x00000004, + FIS_SHOWKEYBAR = 0x00000008, + FIS_ALWAYSSHOWMENUBAR = 0x00000010, + FIS_USERIGHTALTASALTGR = 0x00000080, + FIS_SHOWTOTALCOPYPROGRESSINDICATOR = 0x00000100, + FIS_SHOWCOPYINGTIMEINFO = 0x00000200, + FIS_USECTRLPGUPTOCHANGEDRIVE = 0x00000800, +}; + +enum FarConfirmationsSettings{ + FCS_COPYOVERWRITE = 0x00000001, + FCS_MOVEOVERWRITE = 0x00000002, + FCS_DRAGANDDROP = 0x00000004, + FCS_DELETE = 0x00000008, + FCS_DELETENONEMPTYFOLDERS = 0x00000010, + FCS_INTERRUPTOPERATION = 0x00000020, + FCS_DISCONNECTNETWORKDRIVE = 0x00000040, + FCS_RELOADEDITEDFILE = 0x00000080, + FCS_CLEARHISTORYLIST = 0x00000100, + FCS_EXIT = 0x00000200, +}; + +enum FarDescriptionSettings { + FDS_UPDATEALWAYS = 0x00000001, + FDS_UPDATEIFDISPLAYED = 0x00000002, + FDS_SETHIDDEN = 0x00000004, + FDS_UPDATEREADONLY = 0x00000008, +}; + +#define FAR_CONSOLE_GET_MODE (-2) +#define FAR_CONSOLE_TRIGGER (-1) +#define FAR_CONSOLE_SET_WINDOWED (0) +#define FAR_CONSOLE_SET_FULLSCREEN (1) +#define FAR_CONSOLE_WINDOWED (0) +#define FAR_CONSOLE_FULLSCREEN (1) + +enum FAREJECTMEDIAFLAGS{ + EJECT_NO_MESSAGE = 0x00000001, + EJECT_LOAD_MEDIA = 0x00000002, +}; + +struct ActlEjectMedia { + DWORD Letter; + DWORD Flags; +}; + + +enum FARKEYSEQUENCEFLAGS { + KSFLAGS_DISABLEOUTPUT = 0x00000001, + KSFLAGS_NOSENDKEYSTOPLUGINS = 0x00000002, + KSFLAGS_REG_MULTI_SZ = 0x00100000, +}; + +struct KeySequence{ + DWORD Flags; + int Count; + DWORD *Sequence; +}; + +enum FARMACROCOMMAND{ + MCMD_LOADALL = 0, + MCMD_SAVEALL = 1, + MCMD_POSTMACROSTRING = 2, + MCMD_GETSTATE = 5, +}; + +enum FARMACROSTATE { + MACROSTATE_NOMACRO =0, + MACROSTATE_EXECUTING =1, + MACROSTATE_EXECUTING_COMMON =2, + MACROSTATE_RECORDING =3, + MACROSTATE_RECORDING_COMMON =4, +}; + +struct ActlKeyMacro{ + int Command; + union{ + struct { + char *SequenceText; + DWORD Flags; + } PlainText; + DWORD_PTR Reserved[3]; + } Param; +}; + +enum FARCOLORFLAGS{ + FCLR_REDRAW = 0x00000001, +}; + +struct FarSetColors{ + DWORD Flags; + int StartIndex; + int ColorCount; + LPBYTE Colors; +}; + +enum WINDOWINFO_TYPE{ + WTYPE_PANELS=1, + WTYPE_VIEWER, + WTYPE_EDITOR, + WTYPE_DIALOG, + WTYPE_VMENU, + WTYPE_HELP, +}; + +struct WindowInfo +{ + int Pos; + int Type; + int Modified; + int Current; + char TypeName[64]; + char Name[NM]; +}; + +typedef INT_PTR (WINAPI *FARAPIADVCONTROL)( + INT_PTR ModuleNumber, + int Command, + void *Param +); + + +enum VIEWER_CONTROL_COMMANDS { + VCTL_GETINFO, + VCTL_QUIT, + VCTL_REDRAW, + VCTL_SETKEYBAR, + VCTL_SETPOSITION, + VCTL_SELECT, + VCTL_SETMODE, +}; + +enum VIEWER_OPTIONS { + VOPT_SAVEFILEPOSITION=1, + VOPT_AUTODETECTTABLE=2, +}; + +enum VIEWER_SETMODE_TYPES { + VSMT_HEX, + VSMT_WRAP, + VSMT_WORDWRAP, +}; + +enum VIEWER_SETMODEFLAGS_TYPES { + VSMFL_REDRAW = 0x00000001, +}; + +struct ViewerSetMode { + int Type; + union { + int iParam; + char *cParam; + } Param; + DWORD Flags; + DWORD Reserved; +}; + +typedef union { + __int64 i64; + struct { + DWORD LowPart; + LONG HighPart; + } Part; +} FARINT64; + +struct ViewerSelect +{ + FARINT64 BlockStartPos; + int BlockLen; +}; + +enum VIEWER_SETPOS_FLAGS { + VSP_NOREDRAW = 0x0001, + VSP_PERCENT = 0x0002, + VSP_RELATIVE = 0x0004, + VSP_NORETNEWPOS = 0x0008, +}; + +struct ViewerSetPosition +{ + DWORD Flags; + FARINT64 StartPos; + int LeftPos; +}; + +struct ViewerMode{ + int UseDecodeTable; + int TableNum; + int AnsiMode; + int Unicode; + int Wrap; + int WordWrap; + int Hex; + DWORD Reserved[4]; +}; + +struct ViewerInfo +{ + int StructSize; + int ViewerID; + const char *FileName; + FARINT64 FileSize; + FARINT64 FilePos; + int WindowSizeX; + int WindowSizeY; + DWORD Options; + int TabSize; + struct ViewerMode CurMode; + int LeftPos; + DWORD Reserved3; +}; + +typedef int (WINAPI *FARAPIVIEWERCONTROL)( + int Command, + void *Param +); + +enum VIEWER_EVENTS { + VE_READ =0, + VE_CLOSE =1, + + VE_GOTFOCUS =6, + VE_KILLFOCUS =7, +}; + + +enum EDITOR_EVENTS { + EE_READ =0, + EE_SAVE =1, + EE_REDRAW =2, + EE_CLOSE =3, + + EE_GOTFOCUS =6, + EE_KILLFOCUS =7, +}; + +enum DIALOG_EVENTS { + DE_DLGPROCINIT =0, + DE_DEFDLGPROCINIT =1, + DE_DLGPROCEND =2, +}; + +#define EEREDRAW_ALL (void*)0 +#define EEREDRAW_CHANGE (void*)1 +#define EEREDRAW_LINE (void*)2 + +enum EDITOR_CONTROL_COMMANDS { + ECTL_GETSTRING, + ECTL_SETSTRING, + ECTL_INSERTSTRING, + ECTL_DELETESTRING, + ECTL_DELETECHAR, + ECTL_INSERTTEXT, + ECTL_GETINFO, + ECTL_SETPOSITION, + ECTL_SELECT, + ECTL_REDRAW, + ECTL_EDITORTOOEM, + ECTL_OEMTOEDITOR, + ECTL_TABTOREAL, + ECTL_REALTOTAB, + ECTL_EXPANDTABS, + ECTL_SETTITLE, + ECTL_READINPUT, + ECTL_PROCESSINPUT, + ECTL_ADDCOLOR, + ECTL_GETCOLOR, + ECTL_SAVEFILE, + ECTL_QUIT, + ECTL_SETKEYBAR, + ECTL_PROCESSKEY, + ECTL_SETPARAM, + ECTL_GETBOOKMARKS, + ECTL_TURNOFFMARKINGBLOCK, + ECTL_DELETEBLOCK, + ECTL_ADDSTACKBOOKMARK, + ECTL_PREVSTACKBOOKMARK, + ECTL_NEXTSTACKBOOKMARK, + ECTL_CLEARSTACKBOOKMARKS, + ECTL_DELETESTACKBOOKMARK, + ECTL_GETSTACKBOOKMARKS, +}; + +enum EDITOR_SETPARAMETER_TYPES { + ESPT_TABSIZE, + ESPT_EXPANDTABS, + ESPT_AUTOINDENT, + ESPT_CURSORBEYONDEOL, + ESPT_CHARCODEBASE, + ESPT_CHARTABLE, + ESPT_SAVEFILEPOSITION, + ESPT_LOCKMODE, + ESPT_SETWORDDIV, + ESPT_GETWORDDIV, +}; + + + +struct EditorSetParameter +{ + int Type; + union { + int iParam; + char *cParam; + DWORD Reserved1; + } Param; + DWORD Flags; + DWORD Reserved2; +}; + +struct EditorGetString +{ + int StringNumber; + const char *StringText; + const char *StringEOL; + int StringLength; + int SelStart; + int SelEnd; +}; + + +struct EditorSetString +{ + int StringNumber; + char *StringText; + char *StringEOL; + int StringLength; +}; + +enum EXPAND_TABS { + EXPAND_NOTABS, + EXPAND_ALLTABS, + EXPAND_NEWTABS +}; + + +enum EDITOR_OPTIONS { + EOPT_EXPANDALLTABS = 0x00000001, + EOPT_PERSISTENTBLOCKS = 0x00000002, + EOPT_DELREMOVESBLOCKS = 0x00000004, + EOPT_AUTOINDENT = 0x00000008, + EOPT_SAVEFILEPOSITION = 0x00000010, + EOPT_AUTODETECTTABLE = 0x00000020, + EOPT_CURSORBEYONDEOL = 0x00000040, + EOPT_EXPANDONLYNEWTABS = 0x00000080, +}; + + +enum EDITOR_BLOCK_TYPES { + BTYPE_NONE, + BTYPE_STREAM, + BTYPE_COLUMN +}; + +enum EDITOR_CURRENTSTATE { + ECSTATE_MODIFIED = 0x00000001, + ECSTATE_SAVED = 0x00000002, + ECSTATE_LOCKED = 0x00000004, +}; + + +struct EditorInfo +{ + int EditorID; + const char *FileName; + int WindowSizeX; + int WindowSizeY; + int TotalLines; + int CurLine; + int CurPos; + int CurTabPos; + int TopScreenLine; + int LeftPos; + int Overtype; + int BlockType; + int BlockStartLine; + int AnsiMode; + int TableNum; + DWORD Options; + int TabSize; + int BookMarkCount; + DWORD CurState; + DWORD Reserved[6]; +}; + +struct EditorBookMarks +{ + long *Line; + long *Cursor; + long *ScreenLine; + long *LeftPos; + DWORD Reserved[4]; +}; + +struct EditorSetPosition +{ + int CurLine; + int CurPos; + int CurTabPos; + int TopScreenLine; + int LeftPos; + int Overtype; +}; + + +struct EditorSelect +{ + int BlockType; + int BlockStartLine; + int BlockStartPos; + int BlockWidth; + int BlockHeight; +}; + + +struct EditorConvertText +{ + char *Text; + int TextLength; +}; + + +struct EditorConvertPos +{ + int StringNumber; + int SrcPos; + int DestPos; +}; + + +enum EDITORCOLORFLAGS{ + ECF_TAB1 = 0x10000, +}; + +struct EditorColor +{ + int StringNumber; + int ColorItem; + int StartPos; + int EndPos; + int Color; +}; + +struct EditorSaveFile +{ + char FileName[NM]; + char *FileEOL; +}; + +typedef int (WINAPI *FARAPIEDITORCONTROL)( + int Command, + void *Param +); + +enum INPUTBOXFLAGS{ + FIB_ENABLEEMPTY = 0x00000001, + FIB_PASSWORD = 0x00000002, + FIB_EXPANDENV = 0x00000004, + FIB_NOUSELASTHISTORY = 0x00000008, + FIB_BUTTONS = 0x00000010, + FIB_NOAMPERSAND = 0x00000020, +}; + +typedef int (WINAPI *FARAPIINPUTBOX)( + const char *Title, + const char *SubTitle, + const char *HistoryName, + const char *SrcText, + char *DestText, + int DestLength, + const char *HelpTopic, + DWORD Flags +); + +// +typedef int (WINAPIV *FARSTDSPRINTF)(char *Buffer,const char *Format,...); +typedef int (WINAPIV *FARSTDSNPRINTF)(char *Buffer,size_t Sizebuf,const char *Format,...); +typedef int (WINAPIV *FARSTDSSCANF)(const char *Buffer, const char *Format,...); +// +typedef void (WINAPI *FARSTDQSORT)(void *base, size_t nelem, size_t width, int (__cdecl *fcmp)(const void *, const void *)); +typedef void (WINAPI *FARSTDQSORTEX)(void *base, size_t nelem, size_t width, int (__cdecl *fcmp)(const void *, const void *,void *userparam),void *userparam); +typedef void *(WINAPI *FARSTDBSEARCH)(const void *key, const void *base, size_t nelem, size_t width, int (__cdecl *fcmp)(const void *, const void *)); +typedef int (WINAPI *FARSTDGETFILEOWNER)(const char *Computer,const char *Name,char *Owner); +typedef int (WINAPI *FARSTDGETNUMBEROFLINKS)(const char *Name); +typedef int (WINAPI *FARSTDATOI)(const char *s); +typedef __int64 (WINAPI *FARSTDATOI64)(const char *s); +typedef char *(WINAPI *FARSTDITOA64)(__int64 value, char *string, int radix); +typedef char *(WINAPI *FARSTDITOA)(int value, char *string, int radix); +typedef char *(WINAPI *FARSTDLTRIM)(char *Str); +typedef char *(WINAPI *FARSTDRTRIM)(char *Str); +typedef char *(WINAPI *FARSTDTRIM)(char *Str); +typedef char *(WINAPI *FARSTDTRUNCSTR)(char *Str,int MaxLength); +typedef char *(WINAPI *FARSTDTRUNCPATHSTR)(char *Str,int MaxLength); +typedef char *(WINAPI *FARSTDQUOTESPACEONLY)(char *Str); +typedef char* (WINAPI *FARSTDPOINTTONAME)(const char *Path); +typedef void (WINAPI *FARSTDGETPATHROOT)(const char *Path,char *Root); +typedef BOOL (WINAPI *FARSTDADDENDSLASH)(char *Path); +typedef int (WINAPI *FARSTDCOPYTOCLIPBOARD)(const char *Data); +typedef char *(WINAPI *FARSTDPASTEFROMCLIPBOARD)(void); +typedef int (WINAPI *FARSTDINPUTRECORDTOKEY)(const INPUT_RECORD *r); +typedef int (WINAPI *FARSTDLOCALISLOWER)(unsigned Ch); +typedef int (WINAPI *FARSTDLOCALISUPPER)(unsigned Ch); +typedef int (WINAPI *FARSTDLOCALISALPHA)(unsigned Ch); +typedef int (WINAPI *FARSTDLOCALISALPHANUM)(unsigned Ch); +typedef unsigned (WINAPI *FARSTDLOCALUPPER)(unsigned LowerChar); +typedef unsigned (WINAPI *FARSTDLOCALLOWER)(unsigned UpperChar); +typedef void (WINAPI *FARSTDLOCALUPPERBUF)(char *Buf,int Length); +typedef void (WINAPI *FARSTDLOCALLOWERBUF)(char *Buf,int Length); +typedef void (WINAPI *FARSTDLOCALSTRUPR)(char *s1); +typedef void (WINAPI *FARSTDLOCALSTRLWR)(char *s1); +typedef int (WINAPI *FARSTDLOCALSTRICMP)(const char *s1,const char *s2); +typedef int (WINAPI *FARSTDLOCALSTRNICMP)(const char *s1,const char *s2,int n); + +enum PROCESSNAME_FLAGS{ + PN_CMPNAME = 0x00000000UL, + PN_CMPNAMELIST = 0x00001000UL, + PN_GENERATENAME = 0x00002000UL, + PN_SKIPPATH = 0x00100000UL, +}; + +typedef int (WINAPI *FARSTDPROCESSNAME)(const char *param1, char *param2, DWORD flags); + +typedef void (WINAPI *FARSTDUNQUOTE)(char *Str); + +typedef DWORD (WINAPI *FARSTDEXPANDENVIRONMENTSTR)( + const char *src, + char *dst, + size_t size +); + +enum XLATMODE{ + XLAT_SWITCHKEYBLAYOUT = 0x00000001UL, + XLAT_SWITCHKEYBBEEP = 0x00000002UL, +}; + +typedef char* (WINAPI *FARSTDXLAT)(char *Line,int StartPos,int EndPos,const struct CharTableSet *TableSet,DWORD Flags); +typedef BOOL (WINAPI *FARSTDKEYTOKEYNAME)(int Key,char *KeyText,int Size); +typedef int (WINAPI *FARSTDKEYNAMETOKEY)(const char *Name); + +typedef int (WINAPI *FRSUSERFUNC)( + const WIN32_FIND_DATA *FData, + const char *FullName, + void *Param +); + +enum FRSMODE{ + FRS_RETUPDIR = 0x01, + FRS_RECUR = 0x02, + FRS_SCANSYMLINK = 0x04, +}; + +typedef void (WINAPI *FARSTDRECURSIVESEARCH)(const char *InitDir,const char *Mask,FRSUSERFUNC Func,DWORD Flags,void *Param); +typedef char* (WINAPI *FARSTDMKTEMP)(char *Dest,const char *Prefix); +typedef void (WINAPI *FARSTDDELETEBUFFER)(void *Buffer); + +enum MKLINKOP{ + FLINK_HARDLINK = 1, + FLINK_JUNCTION = 2, + FLINK_SYMLINK = FLINK_JUNCTION, + FLINK_VOLMOUNT = 3, + FLINK_SYMLINKFILE = 4, + FLINK_SYMLINKDIR = 5, + + FLINK_SHOWERRMSG = 0x10000, + FLINK_DONOTUPDATEPANEL = 0x20000, +}; +typedef int (WINAPI *FARSTDMKLINK)(const char *Src,const char *Dest,DWORD Flags); +typedef int (WINAPI *FARCONVERTNAMETOREAL)(const char *Src,char *Dest, int DestSize); +typedef int (WINAPI *FARGETREPARSEPOINTINFO)(const char *Src,char *Dest,int DestSize); + +typedef struct FarStandardFunctions +{ + int StructSize; + + FARSTDATOI atoi; + FARSTDATOI64 atoi64; + FARSTDITOA itoa; + FARSTDITOA64 itoa64; + // + FARSTDSPRINTF sprintf; + FARSTDSSCANF sscanf; + // + FARSTDQSORT qsort; + FARSTDBSEARCH bsearch; + FARSTDQSORTEX qsortex; + + // + FARSTDSNPRINTF snprintf; + // + + DWORD_PTR Reserved[8]; + + FARSTDLOCALISLOWER LIsLower; + FARSTDLOCALISUPPER LIsUpper; + FARSTDLOCALISALPHA LIsAlpha; + FARSTDLOCALISALPHANUM LIsAlphanum; + FARSTDLOCALUPPER LUpper; + FARSTDLOCALLOWER LLower; + FARSTDLOCALUPPERBUF LUpperBuf; + FARSTDLOCALLOWERBUF LLowerBuf; + FARSTDLOCALSTRUPR LStrupr; + FARSTDLOCALSTRLWR LStrlwr; + FARSTDLOCALSTRICMP LStricmp; + FARSTDLOCALSTRNICMP LStrnicmp; + + FARSTDUNQUOTE Unquote; + FARSTDEXPANDENVIRONMENTSTR ExpandEnvironmentStr; + FARSTDLTRIM LTrim; + FARSTDRTRIM RTrim; + FARSTDTRIM Trim; + FARSTDTRUNCSTR TruncStr; + FARSTDTRUNCPATHSTR TruncPathStr; + FARSTDQUOTESPACEONLY QuoteSpaceOnly; + FARSTDPOINTTONAME PointToName; + FARSTDGETPATHROOT GetPathRoot; + FARSTDADDENDSLASH AddEndSlash; + FARSTDCOPYTOCLIPBOARD CopyToClipboard; + FARSTDPASTEFROMCLIPBOARD PasteFromClipboard; + FARSTDKEYTOKEYNAME FarKeyToName; + FARSTDKEYNAMETOKEY FarNameToKey; + FARSTDINPUTRECORDTOKEY FarInputRecordToKey; + FARSTDXLAT XLat; + FARSTDGETFILEOWNER GetFileOwner; + FARSTDGETNUMBEROFLINKS GetNumberOfLinks; + FARSTDRECURSIVESEARCH FarRecursiveSearch; + FARSTDMKTEMP MkTemp; + FARSTDDELETEBUFFER DeleteBuffer; + FARSTDPROCESSNAME ProcessName; + FARSTDMKLINK MkLink; + FARCONVERTNAMETOREAL ConvertNameToReal; + FARGETREPARSEPOINTINFO GetReparsePointInfo; +} FARSTANDARDFUNCTIONS; + +struct PluginStartupInfo +{ + int StructSize; + char ModuleName[NM]; + INT_PTR ModuleNumber; + const char *RootKey; + + FARAPIMENU Menu; + FARAPIDIALOG Dialog; + FARAPIMESSAGE Message; + FARAPIGETMSG GetMsg; + FARAPICONTROL Control; + FARAPISAVESCREEN SaveScreen; + FARAPIRESTORESCREEN RestoreScreen; + FARAPIGETDIRLIST GetDirList; + FARAPIGETPLUGINDIRLIST GetPluginDirList; + FARAPIFREEDIRLIST FreeDirList; + FARAPIVIEWER Viewer; + FARAPIEDITOR Editor; + FARAPICMPNAME CmpName; + FARAPICHARTABLE CharTable; + FARAPITEXT Text; + FARAPIEDITORCONTROL EditorControl; + + FARSTANDARDFUNCTIONS *FSF; + + FARAPISHOWHELP ShowHelp; + FARAPIADVCONTROL AdvControl; + FARAPIINPUTBOX InputBox; + FARAPIDIALOGEX DialogEx; + FARAPISENDDLGMESSAGE SendDlgMessage; + FARAPIDEFDLGPROC DefDlgProc; + DWORD_PTR Reserved; + FARAPIVIEWERCONTROL ViewerControl; +}; + + +enum PLUGIN_FLAGS { + PF_PRELOAD = 0x0001, + PF_DISABLEPANELS = 0x0002, + PF_EDITOR = 0x0004, + PF_VIEWER = 0x0008, + PF_FULLCMDLINE = 0x0010, + PF_DIALOG = 0x0020, +}; + + +struct PluginInfo +{ + int StructSize; + DWORD Flags; + const char * const *DiskMenuStrings; + int *DiskMenuNumbers; + int DiskMenuStringsNumber; + const char * const *PluginMenuStrings; + int PluginMenuStringsNumber; + const char * const *PluginConfigStrings; + int PluginConfigStringsNumber; + const char *CommandPrefix; + DWORD Reserved; +}; + + +struct InfoPanelLine +{ + char Text[80]; + char Data[80]; + int Separator; +}; + +struct PanelMode +{ + char *ColumnTypes; + char *ColumnWidths; + char **ColumnTitles; + int FullScreen; + int DetailedStatus; + int AlignExtensions; + int CaseConversion; + char *StatusColumnTypes; + char *StatusColumnWidths; + DWORD Reserved[2]; +}; + + +enum OPENPLUGININFO_FLAGS { + OPIF_USEFILTER = 0x00000001, + OPIF_USESORTGROUPS = 0x00000002, + OPIF_USEHIGHLIGHTING = 0x00000004, + OPIF_ADDDOTS = 0x00000008, + OPIF_RAWSELECTION = 0x00000010, + OPIF_REALNAMES = 0x00000020, + OPIF_SHOWNAMESONLY = 0x00000040, + OPIF_SHOWRIGHTALIGNNAMES = 0x00000080, + OPIF_SHOWPRESERVECASE = 0x00000100, + OPIF_FINDFOLDERS = 0x00000200, + OPIF_COMPAREFATTIME = 0x00000400, + OPIF_EXTERNALGET = 0x00000800, + OPIF_EXTERNALPUT = 0x00001000, + OPIF_EXTERNALDELETE = 0x00002000, + OPIF_EXTERNALMKDIR = 0x00004000, + OPIF_USEATTRHIGHLIGHTING = 0x00008000, +}; + + +enum OPENPLUGININFO_SORTMODES { + SM_DEFAULT, + SM_UNSORTED, + SM_NAME, + SM_EXT, + SM_MTIME, + SM_CTIME, + SM_ATIME, + SM_SIZE, + SM_DESCR, + SM_OWNER, + SM_COMPRESSEDSIZE, + SM_NUMLINKS +}; + + +struct KeyBarTitles +{ + char *Titles[12]; + char *CtrlTitles[12]; + char *AltTitles[12]; + char *ShiftTitles[12]; + + char *CtrlShiftTitles[12]; + char *AltShiftTitles[12]; + char *CtrlAltTitles[12]; +}; + + +enum OPERATION_MODES { + OPM_SILENT =0x0001, + OPM_FIND =0x0002, + OPM_VIEW =0x0004, + OPM_EDIT =0x0008, + OPM_TOPLEVEL =0x0010, + OPM_DESCR =0x0020, + OPM_QUICKVIEW =0x0040, +}; + +#define MAXSIZE_SHORTCUTDATA 8192 + +struct OpenPluginInfo +{ + int StructSize; + DWORD Flags; + const char *HostFile; + const char *CurDir; + const char *Format; + const char *PanelTitle; + const struct InfoPanelLine *InfoLines; + int InfoLinesNumber; + const char * const *DescrFiles; + int DescrFilesNumber; + const struct PanelMode *PanelModesArray; + int PanelModesNumber; + int StartPanelMode; + int StartSortMode; + int StartSortOrder; + const struct KeyBarTitles *KeyBar; + const char *ShortcutData; + long Reserved; +}; + +enum OPENPLUGIN_OPENFROM{ + OPEN_DISKMENU = 0, + OPEN_PLUGINSMENU = 1, + OPEN_FINDLIST = 2, + OPEN_SHORTCUT = 3, + OPEN_COMMANDLINE = 4, + OPEN_EDITOR = 5, + OPEN_VIEWER = 6, + OPEN_DIALOG = 8, +}; + +enum FAR_PKF_FLAGS { + PKF_CONTROL = 0x00000001, + PKF_ALT = 0x00000002, + PKF_SHIFT = 0x00000004, + PKF_PREPROCESS = 0x00080000, // for "Key", function ProcessKey() +}; + +enum FAR_EVENTS { + FE_CHANGEVIEWMODE =0, + FE_REDRAW =1, + FE_IDLE =2, + FE_CLOSE =3, + FE_BREAK =4, + FE_COMMAND =5, + + FE_GOTFOCUS =6, + FE_KILLFOCUS =7, +}; + + +#if defined(__BORLANDC__) || defined(_MSC_VER) || defined(__GNUC__) || defined(__WATCOMC__) +#ifdef __cplusplus +extern "C"{ +#endif +// Exported Functions + +void WINAPI _export ClosePlugin(HANDLE hPlugin); +int WINAPI _export Compare(HANDLE hPlugin,const struct PluginPanelItem *Item1,const struct PluginPanelItem *Item2,unsigned int Mode); +int WINAPI _export Configure(int ItemNumber); +int WINAPI _export DeleteFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode); +void WINAPI _export ExitFAR(void); +void WINAPI _export FreeFindData(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber); +void WINAPI _export FreeVirtualFindData(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber); +int WINAPI _export GetFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,char *DestPath,int OpMode); +int WINAPI _export GetFindData(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,int OpMode); +int WINAPI _export GetMinFarVersion(void); +void WINAPI _export GetOpenPluginInfo(HANDLE hPlugin,struct OpenPluginInfo *Info); +void WINAPI _export GetPluginInfo(struct PluginInfo *Info); +int WINAPI _export GetVirtualFindData(HANDLE hPlugin,struct PluginPanelItem **pPanelItem,int *pItemsNumber,const char *Path); +int WINAPI _export MakeDirectory(HANDLE hPlugin,char *Name,int OpMode); +HANDLE WINAPI _export OpenFilePlugin(char *Name,const unsigned char *Data,int DataSize); +HANDLE WINAPI _export OpenPlugin(int OpenFrom,INT_PTR Item); +int WINAPI _export ProcessDialogEvent(int Event,void *Param); +int WINAPI _export ProcessEditorEvent(int Event,void *Param); +int WINAPI _export ProcessEditorInput(const INPUT_RECORD *Rec); +int WINAPI _export ProcessEvent(HANDLE hPlugin,int Event,void *Param); +int WINAPI _export ProcessHostFile(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int OpMode); +int WINAPI _export ProcessKey(HANDLE hPlugin,int Key,unsigned int ControlState); +int WINAPI _export ProcessViewerEvent(int Event,void *Param); +int WINAPI _export PutFiles(HANDLE hPlugin,struct PluginPanelItem *PanelItem,int ItemsNumber,int Move,int OpMode); +int WINAPI _export SetDirectory(HANDLE hPlugin,const char *Dir,int OpMode); +int WINAPI _export SetFindList(HANDLE hPlugin,const struct PluginPanelItem *PanelItem,int ItemsNumber); +void WINAPI _export SetStartupInfo(const struct PluginStartupInfo *Info); + +#ifdef __cplusplus +}; +#endif +#endif + +#ifndef _WIN64 +#if defined(__BORLANDC__) + #pragma option -a. +#elif defined(__GNUC__) || (defined(__WATCOMC__) && (__WATCOMC__ < 1100)) || defined(__LCC__) + #pragma pack() +#else + #pragma pack(pop) +#endif +#endif + +#endif /* RC_INVOKED */ + +#endif /* __PLUGIN_HPP__ */ diff --git a/Dir_b3/readme.txt b/Dir_b3/readme.txt new file mode 100644 index 0000000..d69065e --- /dev/null +++ b/Dir_b3/readme.txt @@ -0,0 +1,40 @@ + dir.fmt v 3.0 + ~~~~~~~~~~~~~ + + Плагин второго уровня к плагину Observer (или MultiArc) файл-менеджера FAR. Позволяет +представить результат работы XP/2003/Vista/7 команды DIR в виде псевдоархива. +То есть файл, сформированный командой: + +dir /a /s>file.dir + +или, для получения юникодного листинга: + +cmd /c chcp 65001 & dir /s>file.dir + +в виде папки. Мне служит для грубого сравнения каталогов на удаленных машинах и +в качестве библиотекаря моих компакт-дисков. Остальные подобные плагины +(известные мне) не подошли, т.к. требуют наличия FARа или каких-то других +программ для получения "слепка". Функции реализованы лишь в том объеме, который +мне необходим, не обрабатываются все режимы команды DIR, не учитываются +атрибуты и тд. Поэтому прилагаю исходник, кому нужно, тот запросто программу +доработает. + + +Инсталляция +~~~~~~~~~~~ + +1. Скопировать dir.so в каталог Far\Plugins\Observer\modules +2. Отредактировать файл observer.ini (добавить строки в существующие секции) + [Modules] + DIR=modules\dir.so + [Filters] + DIR=*.dir;*.info +3. Перезапустить FAR (или перезагрузить плагин Observer). + + автор: + Александр Арефьев 25.03.2001 + alarf@mail.ru + http://alarf.newmail.ru + + текущий разработчик: + ConEmu.Maximus5@gmail.com diff --git a/Dir_b3/resource.h b/Dir_b3/resource.h new file mode 100644 index 0000000..8b17bc2 --- /dev/null +++ b/Dir_b3/resource.h @@ -0,0 +1,15 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by dir_b3.rc +// + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 101 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/MBlockEditor/Release/Comment_FileTypes.farconfig b/MBlockEditor/Release/Comment_FileTypes.farconfig index 58ed70f..f010396 100644 --- a/MBlockEditor/Release/Comment_FileTypes.farconfig +++ b/MBlockEditor/Release/Comment_FileTypes.farconfig @@ -51,6 +51,12 @@ + + + + + + @@ -79,6 +85,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -117,6 +149,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/MBlockEditor/src/BlockEditor.cpp b/MBlockEditor/src/BlockEditor.cpp index 0175cbc..78c09ff 100644 --- a/MBlockEditor/src/BlockEditor.cpp +++ b/MBlockEditor/src/BlockEditor.cpp @@ -1,4 +1,4 @@ -//TODO: ShiftTab +//TODO: Глюкавит ShiftTab /* Copyright (c) 2008-2011 Maximus5 @@ -38,6 +38,8 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../../common/plugin.h" +#include +using namespace std; //FIXME: bad practice. https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice #ifdef MDEBUG //#include "/VCProject/MLib/MLibDef.h" @@ -51,24 +53,24 @@ GUID guid_BlockEditor = { /* D82D6847-0C7B-4BF4-9A31-B0B929707854 */ {0x9A, 0x31, 0xB0, 0xB9, 0x29, 0x70, 0x78, 0x54} }; -GUID guid_BlockEditorPluginMenu = { /* 186dd20d-43e9-4a39-8d4b-9e74e9c5b7a1 */ - 0x186dd20d, - 0x43e9, - 0x4a39, - {0x8d, 0x4b, 0x9e, 0x74, 0xe9, 0xc5, 0xb7, 0xa1} +GUID guid_BlockEditorPluginMenu = { /* 186dd20d-43e9-4a39-8d4b-9e74e9c5b7a1 */ + 0x186dd20d, + 0x43e9, + 0x4a39, + {0x8d, 0x4b, 0x9e, 0x74, 0xe9, 0xc5, 0xb7, 0xa1} }; GUID guid_Menu1 = { /* 965a8475-e260-472c-81f7-8d66a6c34e3b */ - 0x965a8475, - 0xe260, - 0x472c, - {0x81, 0xf7, 0x8d, 0x66, 0xa6, 0xc3, 0x4e, 0x3b} + 0x965a8475, + 0xe260, + 0x472c, + {0x81, 0xf7, 0x8d, 0x66, 0xa6, 0xc3, 0x4e, 0x3b} }; GUID guid_Menu2 = { /* 161d063a-4bf9-498d-adab-4aec1a0892cf */ - 0x161d063a, - 0x4bf9, - 0x498d, - {0xad, 0xab, 0x4a, 0xec, 0x1a, 0x08, 0x92, 0xcf} + 0x161d063a, + 0x4bf9, + 0x498d, + {0xad, 0xab, 0x4a, 0xec, 0x1a, 0x08, 0x92, 0xcf} }; #endif @@ -105,17 +107,17 @@ extern "C"{ extern "C"{ BOOL WINAPI _DllMainCRTStartup(HANDLE hModule,DWORD dwReason,LPVOID lpReserved) { - if (ghInstance==NULL) - ghInstance = (HMODULE)hModule; - return TRUE; + if (ghInstance==NULL) + ghInstance = (HMODULE)hModule; + return TRUE; }; }; #else BOOL APIENTRY DllMain(HANDLE hModule,DWORD dwReason,LPVOID lpReserved) { - if (ghInstance==NULL) - ghInstance = (HMODULE)hModule; - return TRUE; + if (ghInstance==NULL) + ghInstance = (HMODULE)hModule; + return TRUE; } #endif @@ -128,7 +130,7 @@ void WINAPI SetStartupInfoW(struct PluginStartupInfo *Info) { memset(&psi, 0, sizeof(psi)); memmove(&psi, Info, Info->StructSize); - + #ifndef _UNICODE gdwFarVersion = (DWORD)psi.AdvControl(psi.ModuleNumber, ACTL_GETFARVERSION, NULL); #endif @@ -140,19 +142,19 @@ void WINAPI SetStartupInfoW(struct PluginStartupInfo *Info) //static wchar_t szTitle[16]; _wcscpy_c(szTitle, L"ConEmu"); //static wchar_t szDescr[64]; _wcscpy_c(szTitle, L"ConEmu support for Far Manager"); //static wchar_t szAuthr[64]; _wcscpy_c(szTitle, L"ConEmu.Maximus5@gmail.com"); - + Info->StructSize = sizeof(GlobalInfo); Info->MinFarVersion = FARMANAGERVERSION; - // Build: YYMMDDX (YY - , MM - , DD - , X - 0 - ) + // Build: YYMMDDX (YY - две цифры года, MM - месяц, DD - день, X - 0 и выше-номер подсборки) Info->Version = MAKEFARVERSION(MVV_1,MVV_2,MVV_3,((MVV_1 % 100)*100000) + (MVV_2*1000) + (MVV_3*10) + (MVV_4 % 10), VS_RELEASE); - + Info->Guid = guid_BlockEditor; Info->Title = L"MBlockEditor"; Info->Description = L"Tabulate and comment in the Editor"; Info->Author = L"ConEmu.Maximus5@gmail.com"; } - + int WINAPI GetMinFarVersionW() { #define MAKEFARVERSION2(major,minor,build) ( ((major)<<8) | (minor) | ((build)<<16)) @@ -173,27 +175,27 @@ void WINAPI SetStartupInfoW(struct PluginStartupInfo *Info) void WINAPI GetPluginInfoW( struct PluginInfo *Info ) { - memset(Info, 0, sizeof(PluginInfo)); - - #if FAR_UNICODE>=1906 - Info->StructSize = sizeof(struct PluginInfo); - #endif + memset(Info, 0, sizeof(PluginInfo)); - MCHKHEAP; + #if FAR_UNICODE>=1906 + Info->StructSize = sizeof(struct PluginInfo); + #endif - static TCHAR *szMenu[1]; + MCHKHEAP; + + static TCHAR *szMenu[1]; #ifdef _UNICODE - int nLen = lstrlenA(szMsgBlockEditorPlugin)+1; - MCHKHEAP; - szMenu[0]=(WCHAR*)malloc(nLen*2); - MultiByteToWideChar(0,0,szMsgBlockEditorPlugin,nLen,szMenu[0],nLen); - MCHKHEAP; + int nLen = lstrlenA(szMsgBlockEditorPlugin)+1; + MCHKHEAP; + szMenu[0]=(WCHAR*)malloc(nLen*2); + MultiByteToWideChar(0,0,szMsgBlockEditorPlugin,nLen,szMenu[0],nLen); + MCHKHEAP; #else - szMenu[0]=szMsgBlockEditorPlugin; + szMenu[0]=szMsgBlockEditorPlugin; #endif - MCHKHEAP; + MCHKHEAP; - Info->Flags = PF_DISABLEPANELS | PF_EDITOR; + Info->Flags = PF_DISABLEPANELS | PF_EDITOR; #ifdef _UNICODE #if FAR_UNICODE>=1906 @@ -201,13 +203,13 @@ void WINAPI GetPluginInfoW( struct PluginInfo *Info ) Info->PluginMenu.Strings = szMenu; Info->PluginMenu.Count = 1; #else - Info->PluginMenuStrings = szMenu; - Info->PluginMenuStringsNumber = 1; + Info->PluginMenuStrings = szMenu; + Info->PluginMenuStringsNumber = 1; Info->Reserved = 1296198763; //'MBlk'; #endif #else - Info->PluginMenuStrings = szMenu; - Info->PluginMenuStringsNumber = 1; + Info->PluginMenuStrings = szMenu; + Info->PluginMenuStringsNumber = 1; #endif } @@ -301,19 +303,19 @@ FarSetHandle OpenKey(LPCTSTR pszSubKey) } #else - + TCHAR* pszKey = NULL; int nLen = (pszSubKey ? lstrlen(pszSubKey) : 0) + 2 + lstrlen(psi.RootKey); pszKey = (TCHAR*)calloc(nLen, sizeof(TCHAR)); - lstrcpy(pszKey, psi.RootKey); + lstrcpy(pszKey, psi.RootKey); lstrcat(pszKey, _T("\\")); lstrcat(pszKey, pszSubKey); - + if (RegOpenKeyEx(HKEY_CURRENT_USER, pszKey, 0, KEY_READ, (HKEY*)&Key.hKey) != 0) Key.hKey = NULL; - + free(pszKey); - + #endif return Key; } @@ -391,26 +393,26 @@ void SetMenuItem(FarMenuItem* pItems, int nIdx, LPCTSTR pszBegin, LPCTSTR pszEnd #else char* psz = pItems[nIdx].Text; #endif - + #define MENU_PART 4 - + if (nIdx < 9) wsprintf(psz, _T("&%i. "), nIdx+1); else if (nIdx == 9) lstrcpy(psz, _T("&0. ")); else lstrcpy(psz, _T(" ")); - + int iStart = lstrlen(psz); int i = iStart; - lstrcpyn(psz+i, pszBegin, MENU_PART+1 /*+1 .. \0*/); + lstrcpyn(psz+i, pszBegin, MENU_PART+1 /*+1 т.к. включая \0*/); i = lstrlen(psz); int iFin = iStart+MENU_PART+1; while (i < iFin) psz[i++] = _T(' '); psz[i] = 0; if (pszEnd) - lstrcpyn(psz+i, pszEnd, MENU_PART+1 /*+1 .. \0*/); + lstrcpyn(psz+i, pszEnd, MENU_PART+1 /*+1 т.к. включая \0*/); i = lstrlen(psz); iFin = iStart+MENU_PART*2+2; while (i < iFin) @@ -436,82 +438,82 @@ int X1, X2; bool lbCurLineShifted; int nInsertSlash; int nMaxStrLen; -bool lbStartChanged, lbEndChanged; // ? +bool lbStartChanged, lbEndChanged; // измнены ли первая и последняя строки выделения? bool lbMultiComment; /* end of global variables */ void FindMaxStringLen() { - for (egs.StringNumber = nStartLine; - egs.StringNumber < ei.TotalLines; - egs.StringNumber++) - { - EditCtrl(ECTL_GETSTRING,&egs); + for (egs.StringNumber = nStartLine; + egs.StringNumber < ei.TotalLines; + egs.StringNumber++) + { + EditCtrl(ECTL_GETSTRING,&egs); - MCHKHEAP; + MCHKHEAP; - if (egs.StringNumber==nStartLine) + if (egs.StringNumber==nStartLine) { - X1 = egs.SelStart; - } + X1 = egs.SelStart; + } - if (egs.SelEnd!=-1 && X2==-1) + if (egs.SelEnd!=-1 && X2==-1) { - X2 = egs.SelEnd; - Y2 = nEndLine; - } + X2 = egs.SelEnd; + Y2 = nEndLine; + } - MCHKHEAP; + MCHKHEAP; - if (egs.StringLength>nMaxStrLen) - nMaxStrLen = egs.StringLength; + if (egs.StringLength>nMaxStrLen) + nMaxStrLen = egs.StringLength; - if ((ei.BlockType != BTYPE_NONE) && (egs.SelStart==-1)) + if ((ei.BlockType != BTYPE_NONE) && (egs.SelStart==-1)) + { + break; + } + else if ((ei.BlockType == BTYPE_NONE) || + (egs.SelStart>0) || (egs.SelStart==0 && (egs.SelEnd==-1 || egs.SelEnd>egs.SelStart))) { - break; - } - else if ((ei.BlockType == BTYPE_NONE) || - (egs.SelStart>0) || (egs.SelStart==0 && (egs.SelEnd==-1 || egs.SelEnd>egs.SelStart))) - { - MCHKHEAP; - nEndLine = egs.StringNumber; - //if (nEmptyLine!=-1) nEmptyLine=-1; - if (nMode == ewmCommentBlock || nMode == ewmCommentAuto) + MCHKHEAP; + nEndLine = egs.StringNumber; + //if (nEmptyLine!=-1) nEmptyLine=-1; + if (nMode == ewmCommentBlock || nMode == ewmCommentAuto) { - int nPos = 0, nIdx=0; BOOL lbSpace=FALSE; - while ((lbSpace=(egs.StringText[nIdx]==_T(' '))) || egs.StringText[nIdx]==_T('\t')) + int nPos = 0, nIdx=0; BOOL lbSpace=FALSE; + while ((lbSpace=(egs.StringText[nIdx]==_T(' '))) || egs.StringText[nIdx]==_T('\t')) { - nIdx++; - if (lbSpace) - nPos++; - else - nPos += ei.TabSize; - } - if (nPos || (nInsertSlash==-1)) + nIdx++; + if (lbSpace) + nPos++; + else + nPos += ei.TabSize; + } + if (nPos || (nInsertSlash==-1)) { - if (nInsertSlash==-1) - nInsertSlash = nPos; - else if (nInsertSlash>nPos) - nInsertSlash = nPos; - } - } - MCHKHEAP; - - if (ei.BlockType == BTYPE_NONE) - break; - - } + if (nInsertSlash==-1) + nInsertSlash = nPos; + else if (nInsertSlash>nPos) + nInsertSlash = nPos; + } + } + MCHKHEAP; + + if (ei.BlockType == BTYPE_NONE) + break; + + } else { - //nEmptyLine = egs.StringNumber; - break; - } - } - //if (Y2==-1) - Y2 = nEndLine; - if (X2==0) Y2++; - - // X1/X2 + //nEmptyLine = egs.StringNumber; + break; + } + } + //if (Y2==-1) + Y2 = nEndLine; + if (X2==0) Y2++; + + // Скорректировать X1/X2 если они выходят ЗА пределы строки if (X1 > 0) { egs.StringNumber = Y1; @@ -539,14 +541,14 @@ BOOL PrepareCommentParams() } else if (((X1 >= 0 && X2 >= 0) && (X1 || X2))) { - // - , X2 ? + // Если есть из чего выбирать - проверить, а не захватывает ли X2 всю строку? if (!X1 && X2 && psComment && *psComment) { egs.StringNumber = Y2; if (EditCtrl(ECTL_GETSTRING,&egs) && egs.StringLength == X2) { - // - "" + // Раз захватывает всю строку целиком - выбираем "блочное" комментирование nMode = ewmCommentBlock; } } @@ -573,7 +575,7 @@ BOOL PrepareCommentParams() } } } - + if (nMode != ewmCommentStream) nMode = ewmCommentBlock; } @@ -598,15 +600,15 @@ BOOL PrepareCommentParams() { if (nCommentBeginLen<1) return FALSE; - // , ? + // Проверка, может быть настроено несколько допустимых комментариев? if (nMode == ewmCommentBlock) lbMultiComment = (psComment[nCommentBeginLen+1] != 0); else lbMultiComment = (psCommentBegin[nCommentBeginLen+1] != 0); - // , + // Дать пользователю выбрать, чем комментировать if (lbMultiComment && !lbSkipCommentMenu) { - // + // Выбирать будем и блочные и потоковые int nCount = 0; LPCTSTR psz = psComment; while (psz && *psz) @@ -622,7 +624,7 @@ BOOL PrepareCommentParams() } if (!nCount) return FALSE; - // + // Сформировать меню FarMenuItem* pItems = (FarMenuItem*)calloc(nCount, sizeof(FarMenuItem)); //#if FAR_UNICODE>=1906 //FarMenuItem pItems[] = @@ -699,12 +701,12 @@ BOOL PrepareCommentParams() free(pItems); if (nSel < 0) return FALSE; - // , + // Смотрим, что юзер выбрал if (nStreamBegin != -1 && nSel >= nStreamBegin) { nMode = ewmCommentStream; nSel -= nStreamBegin; - // + // Указатель на выбранный комментарий while ((nSel--) > 0) { if (*psCommentBegin) @@ -719,7 +721,7 @@ BOOL PrepareCommentParams() { nMode = ewmCommentBlock; nSel -= nBlockBegin; - // + // Указатель на выбранный комментарий while ((nSel--) > 0) { if (*psComment) @@ -741,158 +743,190 @@ BOOL PrepareCommentParams() BOOL DoTabRight() { - // - TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); - if (!lsText) return FALSE; - MCHKHEAP; - for (egs.StringNumber = nStartLine; - egs.StringNumber <= nEndLine; - egs.StringNumber++) - { - MCHKHEAP; - EditCtrl(ECTL_GETSTRING,&egs); - - //if (nMode == ewmTabulateRight) + // Поехали + TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); + if (!lsText) return FALSE; + MCHKHEAP; + for (egs.StringNumber = nStartLine; + egs.StringNumber <= nEndLine; + egs.StringNumber++) + { + MCHKHEAP; + EditCtrl(ECTL_GETSTRING,&egs); + + //if (nMode == ewmTabulateRight) { - MCHKHEAP; - if (*egs.StringText==0) continue; - if (lbExpandTabs) + MCHKHEAP; + if (*egs.StringText==0) continue; + if (lbExpandTabs) { - //lsText.Fill(_T(' '), ei.TabSize); - for(int i=0; inSpaces) ? (X1-nSpaces) : 0; - if (egs.StringNumber==nEndLine) - X2 = (X2>nSpaces) ? (X2-nSpaces) : 0; + egs.StringText++; nSpaces++; + } + MCHKHEAP; + if (egs.StringNumber==nStartLine) + X1 = (X1>nSpaces) ? (X1-nSpaces) : 0; + if (egs.StringNumber==nEndLine) + X2 = (X2>nSpaces) ? (X2-nSpaces) : 0; if (egs.StringNumber == ei.CurLine) lbCurLineShifted = true; - } - //lstrcpy(lsText, egs.StringText); + } + //lstrcpy(lsText, egs.StringText); - } + } - MCHKHEAP; + MCHKHEAP; ess.StringLength = lstrlen(egs.StringText); ess.StringText = (TCHAR*)egs.StringText; ess.StringNumber = egs.StringNumber; ess.StringEOL = (TCHAR*)egs.StringEOL; EditCtrl(ECTL_SETSTRING,&ess); - MCHKHEAP; - } - free(lsText); - return TRUE; + MCHKHEAP; + } + free(lsText); + return TRUE; } -void SetCommentDefaults(LPCTSTR psExt) +bool filename_match(LPCTSTR fn, LPCTSTR ref) { - if (_tcsicmp(psExt, _T(".bat"))==0 || _tcsicmp(psExt, _T(".cmd"))==0) + LPCTSTR _fn = & fn[ lstrlen(fn)-lstrlen(ref) ]; + return (_tcsicmp(_fn, ref) == 0); +} + +//match string to one from to comma separated list +bool _ext_match_to_any(LPCTSTR str, LPCTSTR clst) +{ + int slen = lstrlen(str); + int clen = lstrlen(clst); + for (int idx=0, i=0; i"); psComment = _T(""); } - else if (_tcsicmp(psExt, _T(".php"))==0) + else if ( EXT_MATCH("php") ) { psCommentBegin = _T("\0*/\0"); psComment = _T("//\0#\0"); } - else if (_tcsicmp(psExt, _T(".ps1"))==0 || _tcsicmp(psExt, _T(".psm1"))==0) + else if ( EXT_MATCH("ps1,psm1") ) { psCommentBegin = _T("<#"); psCommentEnd = _T("#>"); psComment = _T("#"); } - else if (_tcsicmp(psExt, _T(".lua"))==0 || _tcsicmp(psExt, _T(".psm1"))==0) + else if ( EXT_MATCH("lua,psm1") ) { psComment = _T("--"); } @@ -904,7 +938,7 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s FarSetHandle hk = {NULL}; TCHAR szTemp[16] = {0}; TCHAR szKey[MAX_PATH]; - //lstrcpy(szKey, psi.RootKey); + //lstrcpy(szKey, psi.RootKey); //if (lstrlen(szKey) < (MAX_PATH - 15)) //{ #if defined(_UNICODE) && FARMANAGERVERSION_BUILD>=2460 @@ -930,8 +964,8 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s } //} - LPCTSTR psExt = _tcsrchr(pszFileName, _T('.')); - if (psExt) + LPCTSTR psExt = _tcsrchr(pszFileName, _T('.')); + if (psExt) { if ((lstrlen(szKey) + 2 + lstrlen(psExt)) < MAX_PATH) { @@ -941,7 +975,7 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s lstrcat(szKey, _T("\\")); #endif lstrcat(szKey, psExt); - + hk = OpenKey(szKey); if (hk.hKey != NULL) { @@ -954,7 +988,7 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s lbSkipNonSpace = lstrcmpi(szTemp, _T("on")) != 0; } } - // "" + // Для "множественного" комментирования может быть запрещен показ меню if (QueryValue(hk, _T("CommentSkipMenu"), szTemp, ARRAYSIZE(szTemp))) { if (*szTemp) @@ -962,19 +996,19 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s lbSkipCommentMenu = lstrcmpi(szTemp, _T("on")) == 0; } } - // "" ( ) + // Настройка "блочного" комментирования (на каждой строке) if (QueryValue(hk, _T("Comment"), szComment, ARRAYSIZE(szComment))) { - // "" ( html ) - // "Comment"="" + // Чтобы можно было запретить "блочный" комментарий (для html например) + // нужно указать "Comment"="" //if (*szComment) //{ psComment = szComment; - // + // Имеет приоритет над встроенным в программу psExt = NULL; //} } - // "" ( ) + // Комментирование может быть и "потоковое" (начало и конец выделения) if (QueryValue(hk, _T("CommentBegin"), szCommentBegin, ARRAYSIZE(szCommentBegin)) && QueryValue(hk, _T("CommentEnd"), szCommentEnd, ARRAYSIZE(szCommentEnd))) { @@ -982,55 +1016,53 @@ void LoadCommentSettings(LPCTSTR pszFileName, TCHAR (&szComment)[100], TCHAR (&s { psCommentBegin = szCommentBegin; psCommentEnd = szCommentEnd; - // + // Имеет приоритет над встроенным в программу psExt = NULL; } } CloseKey(hk); } } - } + } - // NULL - - if (psExt) - SetCommentDefaults(psExt); + SetCommentDefaults(pszFileName, psExt); } BOOL DoComment() { - // - TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); - if (!lsText) return FALSE; - MCHKHEAP; - for (egs.StringNumber = nStartLine; - egs.StringNumber <= nEndLine; - egs.StringNumber++) - { - MCHKHEAP; - EditCtrl(ECTL_GETSTRING,&egs); - + // Поехали + TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); + if (!lsText) return FALSE; + MCHKHEAP; + for (egs.StringNumber = nStartLine; + egs.StringNumber <= nEndLine; + egs.StringNumber++) + { + MCHKHEAP; + EditCtrl(ECTL_GETSTRING,&egs); + //if (nMode == ewmCommentBlock || nMode == ewmCommentStream) { - MCHKHEAP; - int nPos = 0, nIdx = 0; BOOL lbSpace=FALSE; - while (lbSkipNonSpace - && ((lbSpace=(egs.StringText[nIdx]==_T(' '))) || egs.StringText[nIdx]==_T('\t'))) - { - if (nPos >= nInsertSlash) + MCHKHEAP; + int nPos = 0, nIdx = 0; BOOL lbSpace=FALSE; + while (lbSkipNonSpace + && ((lbSpace=(egs.StringText[nIdx]==_T(' '))) || egs.StringText[nIdx]==_T('\t'))) + { + if (nPos >= nInsertSlash) break; - nIdx++; - if (lbSpace) - nPos++; - else - nPos += ei.TabSize; - } - // (//) + nIdx++; + if (lbSpace) + nPos++; + else + nPos += ei.TabSize; + } + // Чтобы после комментирования курсор встал на первый символ ПОСЛЕ комментария (//) if ((ei.CurPos < nIdx) && (ei.BlockType == BTYPE_NONE) /*&& (nMode == ewmCommentBlock)*/) { ei.CurPos = nIdx; } - MCHKHEAP; + MCHKHEAP; if (nMode == ewmCommentBlock || (nMode == ewmCommentStream @@ -1042,10 +1074,10 @@ BOOL DoComment() else psCommCurr = (egs.StringNumber == nStartLine) ? psCommentBegin : psCommentEnd; - //// nIdx - + //// nIdx - пропуск пробельных символов //if (egs.StringText[nIdx]) //{ - // + // Если НЕ конец строки //lsText = egs.StringText; //lsText.Insert(nIdx,_T("//")); @@ -1053,10 +1085,10 @@ BOOL DoComment() MCHKHEAP; if (nMode == ewmCommentBlock) { - // , + // Не трогать пустые строки, если предыдущая была с отступом if (!egs.StringLength && (egs.StringNumber > nStartLine) && (nInsertSlash > 0)) continue; - // + // сначала скопировать пробельные символы if (nIdx) memcpy(lsText, egs.StringText, nIdx*sizeof(TCHAR)); MCHKHEAP; @@ -1131,7 +1163,7 @@ BOOL DoComment() else lstrcpy(lsText+n, egs.StringText); } - + } MCHKHEAP; //} @@ -1149,13 +1181,13 @@ BOOL DoComment() //} egs.StringText = lsText; - // + // Коррекция будущего выделения if (egs.StringNumber == nStartLine && nMode != ewmCommentStream) { if ((X1 > nIdx) && (X1 || Y1==Y2)) X1 += nCommentBeginLen; } - if (egs.StringNumber == nEndLine) // else - + if (egs.StringNumber == nEndLine) // БЕЗ else - может быть однострочное выделение { if (X2 || Y1==Y2) X2 += nCommentEndLen; @@ -1165,29 +1197,29 @@ BOOL DoComment() if (egs.StringNumber == ei.CurLine) lbCurLineShifted = true; } - } + } - MCHKHEAP; + MCHKHEAP; ess.StringLength = lstrlen(egs.StringText); ess.StringText = (TCHAR*)egs.StringText; ess.StringNumber = egs.StringNumber; ess.StringEOL = (TCHAR*)egs.StringEOL; EditCtrl(ECTL_SETSTRING,&ess); - MCHKHEAP; - } - free(lsText); - return TRUE; + MCHKHEAP; + } + free(lsText); + return TRUE; } BOOL DoUnComment() { - // - TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); - if (!lsText) return FALSE; + // Поехали + TCHAR* lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); + if (!lsText) return FALSE; bool lbFirstUncommented = false; - LPCTSTR pszBlockComment = psComment; // , + LPCTSTR pszBlockComment = psComment; // сохранить, для перебора - //lbMultiComment - + //lbMultiComment - Может быть настроено несколько типов комментариев if (nMode != ewmUncommentAuto) { if (nMode == ewmCommentBlock) @@ -1196,18 +1228,18 @@ BOOL DoUnComment() lbMultiComment = (psCommentBegin[lstrlen(psCommentBegin)+1] != 0); } - MCHKHEAP; - for (egs.StringNumber = nStartLine; - egs.StringNumber <= nEndLine; - egs.StringNumber++) - { - MCHKHEAP; - if (!EditCtrl(ECTL_GETSTRING,&egs)) + MCHKHEAP; + for (egs.StringNumber = nStartLine; + egs.StringNumber <= nEndLine; + egs.StringNumber++) + { + MCHKHEAP; + if (!EditCtrl(ECTL_GETSTRING,&egs)) break; MCHKHEAP; - // , , - // + // При снятии потокового комментария, если весь комментарий не был выделен, + // следующая строка может оказаться длиннее текущей if (egs.StringLength > nMaxStrLen) { nMaxStrLen = egs.StringLength; @@ -1215,11 +1247,11 @@ BOOL DoUnComment() lsText = (TCHAR*)calloc(nMaxStrLen,sizeof(TCHAR)); if (!lsText) return FALSE; } - + //if (nMode == ewmUncommentAuto || nMode == ewmUncommentBlock || nMode == ewmUncommentStream) { - // - if (*egs.StringText==0) + // Убрать комментарий + if (*egs.StringText==0) { if (egs.StringNumber == nStartLine) lbStartChanged = false; @@ -1227,9 +1259,9 @@ BOOL DoUnComment() lbEndChanged = false; continue; } - //lsText = egs.StringText; - //int nSlash = lsText.Find(_T("//")); - //if (nSlash>=0) lsText.Delete(nSlash,2); + //lsText = egs.StringText; + //int nSlash = lsText.Find(_T("//")); + //if (nSlash>=0) lsText.Delete(nSlash,2); if (nMode == ewmUncommentAuto) { @@ -1245,10 +1277,10 @@ BOOL DoUnComment() } else { - // , :( + // Нужно опеределить, какой комментарий используется в блоке :( LPCTSTR pszTest; LPCTSTR pszBegin = psCommentBegin, pszEnd = psCommentEnd; - // + // Сравнить с началом блока if (nMode == ewmUncommentAuto) { pszTest = egs.StringText; @@ -1265,7 +1297,7 @@ BOOL DoUnComment() nMode = ewmUncommentStream; break; } - // + // Следующий pszBegin += lstrlen(pszBegin)+1; if (*pszEnd) pszEnd += lstrlen(pszEnd)+1; @@ -1276,7 +1308,7 @@ BOOL DoUnComment() pszTest = egs.StringText; if (egs.StringNumber == nStartLine && X1 >= 0) pszTest += X1; - // "", + // Поскольку здесь мы ищем "назад", то пропуск пробелов будет ошибкой // -- while (*pszTest == _T(' ') || *pszTest == _T('\t')) pszTest++; pszBegin = psCommentBegin; pszEnd = psCommentEnd; while (*pszBegin && nMode != ewmUncommentStream) @@ -1297,8 +1329,8 @@ BOOL DoUnComment() } } if (nMode == ewmUncommentStream) - break; // for :( - // + break; // ибо for :( + // Следующий pszBegin += lstrlen(pszBegin)+1; if (*pszEnd) pszEnd += lstrlen(pszEnd)+1; @@ -1306,13 +1338,13 @@ BOOL DoUnComment() } if (nMode == ewmUncommentStream) { - //if (lbMultiComment) -- Auto - lbMultiComment , , + //if (lbMultiComment) -- если был Auto - то lbMultiComment не был установлен, но и не надо, тип комментарования уже выбрали //{ - // "" + // Мог изменится "активный" тип комментирования lbMultiComment = false; psCommentBegin = pszBegin; psCommentEnd = pszEnd; - // - , + // Длины - обновляются ниже, строго всегда //} } @@ -1330,7 +1362,7 @@ BOOL DoUnComment() else { nCommentBeginLen = nCommentEndLen = lstrlen(psComment); - // lbMultiComment - + // если lbMultiComment - нужно будет еще выбрать тип комментирования и обновить длины } } @@ -1357,13 +1389,13 @@ BOOL DoUnComment() pszTest++; if (_tcsncmp(pszTest, psCommentBegin, nCommentBeginLen) == 0) psComm = pszTest; - // , .. X1 + // Это по идее не нужно, т.к. X1 подкорректирован выше //else if ((pszTest - egs.StringText) >= nCommentBeginLen // && _tcsncmp(pszTest-nCommentBeginLen, psCommentBegin, nCommentBeginLen) == 0) // psComm = pszTest-nCommentBeginLen; } } - + if (!psComm) { if (nMode == ewmUncommentBlock) @@ -1382,7 +1414,7 @@ BOOL DoUnComment() psCommCurr = psComment = pszMulti; nCommentBeginLen = nCommentEndLen = lstrlen(pszMulti); break; - } + } pszMulti += lstrlen(pszMulti)+1; } } @@ -1390,8 +1422,8 @@ BOOL DoUnComment() { if (_tcsncmp(pszTest, psCommCurr, lstrlen(psCommCurr)) == 0) psComm = pszTest; - } - // , - ? + } + // Если таки не с начала строки, но есть в середине - поставить туда курсор? if (!psComm && (es.BlockType == BTYPE_NONE)) { if (lbMultiComment) @@ -1404,14 +1436,14 @@ BOOL DoUnComment() psCommCurr = psComment = pszMulti; nCommentBeginLen = nCommentEndLen = lstrlen(pszMulti); break; - } + } pszMulti += lstrlen(pszMulti)+1; } } else { psComm = _tcsstr(egs.StringText, psCommCurr); - } + } if (psComm) { EditorSetPosition esp; @@ -1422,7 +1454,7 @@ BOOL DoUnComment() esp.CurPos = (int)(psComm - egs.StringText); esp.Overtype=-1; EditCtrl(ECTL_SETPOSITION,&esp); - psComm = NULL; // , "http://www..." + psComm = NULL; // но не убирать, а то "http://www..." } } } @@ -1444,13 +1476,13 @@ BOOL DoUnComment() MCHKHEAP; if (nMode == ewmUncommentBlock) { - // + // Коррекция будущего выделения if (egs.StringNumber == nStartLine) { if ((X1 > (psComm - egs.StringText)) && (X1 || Y1==Y2)) X1 -= lstrlen(psCommCurr); } - if (egs.StringNumber == nEndLine) // else - + if (egs.StringNumber == nEndLine) // БЕЗ else - может быть однострочное выделение { if (X2 || Y1==Y2) X2 -= lstrlen(psCommCurr); @@ -1459,14 +1491,14 @@ BOOL DoUnComment() MCHKHEAP; if (psComm > egs.StringText) { - // + // Комментарий НЕ с начала строки memcpy(lsText, egs.StringText, (psComm-egs.StringText)*sizeof(TCHAR)); lstrcpy(lsText+(psComm-egs.StringText), psComm+lstrlen(psCommCurr)); egs.StringText = lsText; } else { - // - "" ( ) + // Комментарий с начала строки - просто "отбросить" кусок (передвинуть указатель) egs.StringText += lstrlen(psCommCurr); } MCHKHEAP; @@ -1495,32 +1527,32 @@ BOOL DoUnComment() psComm = egs.StringText; else psComm += nCommentBeginLen; - // + // нужно отбросить и закрывающий коментатор pszEndComm = egs.StringText + X2; if (_tcsncmp(pszEndComm, psCommentEnd, nCommentEndLen) == 0) { - // OK, + // OK, выделение НЕ включало закрывающий коментатор } else if ((pszEndComm - psComm) >= nCommentEndLen && _tcsncmp(pszEndComm-nCommentEndLen, psCommentEnd, nCommentEndLen) == 0) { - // + // выделение включало закрывающий коментатор pszEndComm -= nCommentEndLen; } else { - // + // Просто найти в строке закрывающий комментатор if (!lbFirstUncommented && psComm) { - // " " - + // Если в этой строке убирали "открывающий комментатор" - искать нужно после него pszEndComm = _tcsstr(psComm+nCommentBeginLen, psCommentEnd); } else { pszEndComm = _tcsstr(egs.StringText, psCommentEnd); } - // , , - - // + // Если выделения нет, убираем потоковый комментарий, и на этой строке закрывающего нет - + // то искать вниз до упора if (!pszEndComm && (ei.BlockType == BTYPE_NONE) && (nEndLine < ei.TotalLines)) nEndLine++; } @@ -1536,7 +1568,7 @@ BOOL DoUnComment() } else { - // ( ) + // Просто докопировать остаток (чтобы не потерять ничего) lstrcpy(lsText+n, pszNextPart); MCHKHEAP; } @@ -1547,13 +1579,13 @@ BOOL DoUnComment() MCHKHEAP; } - // + // Коррекция будущего выделения if (egs.StringNumber == nStartLine) { if ((X1 > (psComm - egs.StringText)) && (X1 || Y1==Y2)) X1 -= nCommentBeginLen; } - if (egs.StringNumber == nEndLine) // else - + if (egs.StringNumber == nEndLine) // БЕЗ else - может быть однострочное выделение { if ((X2 || Y1==Y2) && (pszEndComm && (pszEndComm - egs.StringText) < X2)) X2 -= nCommentEndLen; @@ -1571,30 +1603,30 @@ BOOL DoUnComment() lbFirstUncommented = true; } } - } + } - MCHKHEAP; + MCHKHEAP; ess.StringLength = lstrlen(egs.StringText); ess.StringText = (TCHAR*)egs.StringText; ess.StringNumber = egs.StringNumber; ess.StringEOL = (TCHAR*)egs.StringEOL; EditCtrl(ECTL_SETSTRING,&ess); - MCHKHEAP; - } - free(lsText); - return TRUE; + MCHKHEAP; + } + free(lsText); + return TRUE; } void Reselect() { if (nMode <= ewmLastInternal && es.BlockType != BTYPE_NONE) - { + { if (es.BlockType==BTYPE_STREAM) { es.BlockStartLine = min(Y2,Y1); es.BlockStartPos = (Y1 == Y2) ? (min(X1,X2)) : ((Y1 < Y2) ? X1 : X2); - // , + // небольшая коррекция, если позиции равны if(X1 == X2) es.BlockStartPos += (Y1 < Y2) ? 1: -1; @@ -1618,8 +1650,8 @@ void Reselect() else { //#ifndef _UNICODE - // FAR 1.7x build 2479 - // TAB . + // В FAR 1.7x build 2479 возникала проблема если + // TAB не заменяется проблами и идет выделение верт.блока // gdwFarVersion == 0x09af014b if (!lbExpandTabs) { @@ -1635,20 +1667,20 @@ void Reselect() es.BlockStartLine=min(Y2,Y1); es.BlockStartPos=(Y1==Y2) ? (min(X1,X2)) : (Y1 < Y2?X1:X2); - - // , + + // небольшая коррекция, если позиции равны if(X1 == X2) es.BlockStartPos+=(Y1 < Y2?1:-1); - + es.BlockHeight=max(Y1,Y2)-min(Y1,Y2)+1; - + if(Y1 < Y2) es.BlockWidth=X2-X1/*+1*/; else if(Y1 > Y2) es.BlockWidth=X1-X2+1; else if (Y1 == Y2) es.BlockWidth=max(X1,X2)-min(X1,X2); - + if(X1 == X2) { if(Y1 < Y2) @@ -1658,9 +1690,9 @@ void Reselect() } } - MCHKHEAP; - EditCtrl(ECTL_SELECT,(void*)&es); - } + MCHKHEAP; + EditCtrl(ECTL_SELECT,(void*)&es); + } } void UpdateCursorPos() @@ -1681,11 +1713,11 @@ void UpdateCursorPos() esp.CurTabPos = max(0,ei.CurTabPos-ei.TabSize); break; case ewmCommentBlock: - //WARNING: - + //WARNING: для потоковых комментариев - доработать esp.CurPos = ei.CurPos+lstrlen(psComment); break; case ewmCommentStream: - //WARNING: - + //WARNING: для потоковых комментариев - доработать //esp.CurPos = ei.CurPos+lstrlen(psCommentBegin); if ((Y1 == Y2) && (X2 == (ei.CurPos+nCommentBeginLen+nCommentEndLen))) esp.CurPos = ei.CurPos + nCommentBeginLen + nCommentEndLen; @@ -1700,7 +1732,7 @@ void UpdateCursorPos() esp.CurPos = max(0,ei.CurPos-lstrlen(psComment)); break; case ewmUncommentStream: - //WARNING: - + //WARNING: для потоковых комментариев - доработать //esp.CurPos = max(0,ei.CurPos-lstrlen(psCommentBegin)); if ((Y1 == Y2) && (ei.CurPos >= (X2+nCommentBeginLen+nCommentEndLen))) esp.CurPos = ei.CurPos - nCommentBeginLen - nCommentEndLen; @@ -1730,19 +1762,19 @@ void UpdateCursorPos() } esp.Overtype=-1; - - //TODO: + + //TODO: сдвиг курсора при обычной табуляции EditCtrl(ECTL_SETPOSITION,&esp); } } HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) { - - memset(&egs, 0, sizeof(egs)); - memset(&ei, 0, sizeof(ei)); - memset(&ess, 0, sizeof(ess)); - memset(&es, 0, sizeof(es)); + + memset(&egs, 0, sizeof(egs)); + memset(&ei, 0, sizeof(ei)); + memset(&ess, 0, sizeof(ess)); + memset(&es, 0, sizeof(es)); nMode = ewmUndefined; #if FAR_UNICODE>=3000 @@ -1752,25 +1784,25 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) es.StructSize = sizeof(es); #endif - MCHKHEAP; + MCHKHEAP; - EditCtrl(ECTL_GETINFO,&ei); - //if (ei.BlockType == BTYPE_NONE) - // return INVALID_HANDLE_VALUE; - es.BlockType = ei.BlockType; + EditCtrl(ECTL_GETINFO,&ei); + //if (ei.BlockType == BTYPE_NONE) + // return INVALID_HANDLE_VALUE; + es.BlockType = ei.BlockType; - //TODO: , Tab/ShiftTab - //ACTL_POSTKEYSEQUENCE TAB/ BS + //TODO: Если выделения нет, и хотят Tab/ShiftTab можно переслать в ФАР + //ACTL_POSTKEYSEQUENCE TAB/требуемое количество BS - MCHKHEAP; - //CStaticMenu lmMenu(_ATOT(szMsgBlockEditorPlugin)); + MCHKHEAP; + //CStaticMenu lmMenu(_ATOT(szMsgBlockEditorPlugin)); - /*lmMenu.AddMenuItem ( _T("&1 Tabulate right") ); - lmMenu.AddMenuItem ( _T("&2 Tabulate left") ); - lmMenu.AddMenuItem ( _T("&3 Comment") ); - lmMenu.AddMenuItem ( _T("&4 UnComment") );*/ - //psi.Menu( + /*lmMenu.AddMenuItem ( _T("&1 Tabulate right") ); + lmMenu.AddMenuItem ( _T("&2 Tabulate left") ); + lmMenu.AddMenuItem ( _T("&3 Comment") ); + lmMenu.AddMenuItem ( _T("&4 UnComment") );*/ + //psi.Menu( #ifdef _UNICODE #if FARMANAGERVERSION_BUILD>=2460 @@ -1842,10 +1874,10 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) return INVALID_HANDLE_VALUE; nMode++; } - MCHKHEAP; + MCHKHEAP; - if (nMode < ewmFirst || nMode > ewmLastValidCall) - return INVALID_HANDLE_VALUE; + if (nMode < ewmFirst || nMode > ewmLastValidCall) + return INVALID_HANDLE_VALUE; #ifdef _UNICODE EditorUndoRedo eur = {}; @@ -1864,15 +1896,15 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) lbSkipNonSpace = TRUE; lbSkipCommentMenu = FALSE; - psComment = _T("//"); - psCommentBegin = NULL; - psCommentEnd = NULL; + psComment = _T("//"); + psCommentBegin = NULL; + psCommentEnd = NULL; nCommentBeginLen = 0; nCommentEndLen = 0; - // 0-, .. MSZ + // Обязательно инициализируем все 0-ми, т.к. может быть MSZ TCHAR szComment[100] = {0}, szCommentBegin[100] = {0}, szCommentEnd[100] = {0}; - if ((nMode >= ewmCommentFirst && nMode <= ewmCommentLast) && pszFileName) - LoadCommentSettings(pszFileName, szComment, szCommentBegin, szCommentEnd); + if ((nMode >= ewmCommentFirst && nMode <= ewmCommentLast) && pszFileName) + LoadCommentSettings(pszFileName, szComment, szCommentBegin, szCommentEnd); #ifdef _UNICODE @@ -1883,46 +1915,46 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) #endif - if (ei.TabSize<1) ei.TabSize=1; - lbExpandTabs = (ei.Options & (EOPT_EXPANDALLTABS|EOPT_EXPANDONLYNEWTABS))!=0; + if (ei.TabSize<1) ei.TabSize=1; + lbExpandTabs = (ei.Options & (EOPT_EXPANDALLTABS|EOPT_EXPANDONLYNEWTABS))!=0; - MCHKHEAP; + MCHKHEAP; - nStartLine = (ei.BlockType == BTYPE_NONE) ? ei.CurLine : ei.BlockStartLine; - nEndLine = nStartLine; - //int nEmptyLine = -1; - Y1 = nStartLine; Y2 = -1; - X1 = 0; X2 = -1; + nStartLine = (ei.BlockType == BTYPE_NONE) ? ei.CurLine : ei.BlockStartLine; + nEndLine = nStartLine; + //int nEmptyLine = -1; + Y1 = nStartLine; Y2 = -1; + X1 = 0; X2 = -1; lbCurLineShifted = false; - nInsertSlash = -1; - nMaxStrLen = 0; - lbStartChanged = true; lbEndChanged = true; // ? + nInsertSlash = -1; + nMaxStrLen = 0; + lbStartChanged = true; lbEndChanged = true; // измнены ли первая и последняя строки выделения? lbMultiComment = false; - MCHKHEAP; + MCHKHEAP; - // , + // Пробежаться по выделению, определить максимальную длину строки FindMaxStringLen(); - MCHKHEAP; + MCHKHEAP; - if (!PrepareCommentParams()) - return INVALID_HANDLE_VALUE; + if (!PrepareCommentParams()) + return INVALID_HANDLE_VALUE; - nMaxStrLen += 10+ei.TabSize; // + nMaxStrLen += 10+ei.TabSize; // с запасом на символы комментирования if (psCommentBegin && psCommentEnd) nMaxStrLen += lstrlen(psCommentBegin) + lstrlen(psCommentEnd); if (psComment) nMaxStrLen += lstrlen(psComment); - MCHKHEAP; + MCHKHEAP; - if (ei.BlockType == BTYPE_NONE) - X1 = ei.CurPos; + if (ei.BlockType == BTYPE_NONE) + X1 = ei.CurPos; - // + // Поехали if (nMode == ewmTabulateRight) DoTabRight(); else if (nMode == ewmTabulateLeft) @@ -1931,7 +1963,7 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) DoComment(); else if (nMode == ewmUncommentAuto || nMode == ewmUncommentBlock || nMode == ewmUncommentStream) DoUnComment(); - + if (X1<0) { @@ -1953,7 +1985,7 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) else if (nMode == ewmTabulateLeft) { int nSize = lbExpandTabs ? ei.TabSize : 1; - // X1&X2 , ewmTabulateLeft + // X1&X2 корректируются выше, при обработке ewmTabulateLeft } //else if (nMode == ewmComment) //{ @@ -1970,12 +2002,12 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) // X2 = (X2>nCmtLen) ? (X2-nCmtLen) : 0; //} - MCHKHEAP; + MCHKHEAP; - // - UpdateCursorPos(); + // Подвинуть курсор + UpdateCursorPos(); - // + // Обновить выделение Reselect(); #ifdef _UNICODE @@ -1983,7 +2015,7 @@ HANDLE WINAPI OpenPluginW(int OpenFrom,INT_PTR Item) EditCtrl(ECTL_UNDOREDO,&eur); #endif - MCHKHEAP; + MCHKHEAP; - return INVALID_HANDLE_VALUE; + return INVALID_HANDLE_VALUE; } diff --git a/MBlockEditor/src/MBlockEditor.vcxproj b/MBlockEditor/src/MBlockEditor.vcxproj index ee00777..8d0706f 100644 --- a/MBlockEditor/src/MBlockEditor.vcxproj +++ b/MBlockEditor/src/MBlockEditor.vcxproj @@ -1134,6 +1134,8 @@ Level3 true ProgramDatabase + true + true _DEBUG;FAR_UNICODE=3000;%(PreprocessorDefinitions) @@ -1153,6 +1155,7 @@ MachineX64 false Windows + UseLinkTimeCodeGeneration true