bool GetVHDName(const string& DeviceName, string &strVolumePath)
{
bool Result=false;
File Device;
if(Device.Open(DeviceName, FILE_READ_ATTRIBUTES,FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, nullptr, OPEN_EXISTING))
{
ULONG Size = 1024;
PSTORAGE_DEPENDENCY_INFO StorageDependencyInfo = static_cast<PSTORAGE_DEPENDENCY_INFO>(xf_malloc(Size));
if(StorageDependencyInfo)
{
StorageDependencyInfo->Version = STORAGE_DEPENDENCY_INFO_VERSION_2;
DWORD Used = 0;
Result = Device.GetStorageDependencyInformation(GET_STORAGE_DEPENDENCY_FLAG_HOST_VOLUMES, Size, StorageDependencyInfo, &Used);
if(!Result && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
StorageDependencyInfo = static_cast<PSTORAGE_DEPENDENCY_INFO>(xf_realloc(StorageDependencyInfo, Used));
if(StorageDependencyInfo)
{
Result = Device.GetStorageDependencyInformation(GET_STORAGE_DEPENDENCY_FLAG_HOST_VOLUMES, Used, StorageDependencyInfo, &Used);
}
}
if(Result)
{
if(StorageDependencyInfo->NumberEntries)
{
strVolumePath = StorageDependencyInfo->Version2Entries[0].HostVolumeName;
strVolumePath += StorageDependencyInfo->Version2Entries[0].DependentVolumeRelativePath;
// trick: ConvertNameToReal also converts \\?\{GUID} to drive letter, if possible.
ConvertNameToReal(strVolumePath, strVolumePath);
}
}
}
}
return Result;
}
void Manager::ExecuteCommit()
{
_MANAGER(CleverSysLog clv(L"Manager::ExecuteCommit()"));
_MANAGER(SysLog(L"ExecutedFrame=%p",ExecutedFrame));
if (!ExecutedFrame)
{
return;
}
if (ModalStackCount == ModalStackSize)
{
ModalStack = (Frame **) xf_realloc(ModalStack, ++ModalStackSize * sizeof(Frame *));
}
ModalStack [ModalStackCount++] = ExecutedFrame;
ActivatedFrame=ExecutedFrame;
}
bool DizList::AddRecord(const string& DizText)
{
DizRecord** NewDizData = DizData;
if (!(DizCount & 15))
NewDizData=(DizRecord **)xf_realloc(DizData,(DizCount+16+1)*sizeof(DizRecord *));
if (!NewDizData)
return false;
DizData=NewDizData;
DizData[DizCount] = new DizRecord;
DizData[DizCount]->DizText = DizText;
DizData[DizCount]->NameStart=0;
DizData[DizCount]->NameLength=0;
const wchar_t* DizTextPtr = DizText;
if (*DizTextPtr == L'\"')
{
DizTextPtr++;
DizData[DizCount]->NameStart++;
while (*DizTextPtr && *DizTextPtr!=L'\"')
{
DizTextPtr++;
DizData[DizCount]->NameLength++;
}
}
else
{
while (!IsSpaceOrEos(*DizTextPtr))
{
DizTextPtr++;
DizData[DizCount]->NameLength++;
}
}
DizData[DizCount]->Deleted=false;
NeedRebuild=true;
Modified=true;
DizCount++;
return true;
}
bool AddAutomation(int id,
FARDIALOGITEMFLAGS UncheckedSet,FARDIALOGITEMFLAGS UncheckedSkip,
FARDIALOGITEMFLAGS CheckedSet,FARDIALOGITEMFLAGS CheckedSkip,
FARDIALOGITEMFLAGS Checked3Set,FARDIALOGITEMFLAGS Checked3Skip)
{
DialogItemAutomation *Auto;
if ((Auto=(DialogItemAutomation*)xf_realloc(AutoPtr,sizeof(DialogItemAutomation)*(AutoCount+1))) )
{
AutoPtr=Auto;
Auto=AutoPtr+AutoCount;
Auto->ID=id;
Auto->Flags[0][0]=UncheckedSet;
Auto->Flags[0][1]=UncheckedSkip;
Auto->Flags[1][0]=CheckedSet;
Auto->Flags[1][1]=CheckedSkip;
Auto->Flags[2][0]=Checked3Set;
Auto->Flags[2][1]=Checked3Skip;
AutoCount++;
return true;
}
return false;
}
bool GetVHDName(const wchar_t *DeviceName, string &strVolumePath)
{
bool Result=false;
if(ifn.pfnGetStorageDependencyInformation)
{
File Device;
if(Device.Open(DeviceName, FILE_READ_ATTRIBUTES,FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, nullptr, OPEN_EXISTING))
{
ULONG Size = 1024;
PSTORAGE_DEPENDENCY_INFO StorageDependencyInfo = reinterpret_cast<PSTORAGE_DEPENDENCY_INFO>(xf_malloc(Size));
if(StorageDependencyInfo)
{
StorageDependencyInfo->Version = STORAGE_DEPENDENCY_INFO_VERSION_2;
DWORD Used = 0;
if(!Device.GetStorageDependencyInformation(GET_STORAGE_DEPENDENCY_FLAG_HOST_VOLUMES, Size, StorageDependencyInfo, &Used) && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
StorageDependencyInfo = reinterpret_cast<PSTORAGE_DEPENDENCY_INFO>(xf_realloc(StorageDependencyInfo, Used));
if(StorageDependencyInfo)
{
Device.GetStorageDependencyInformation(GET_STORAGE_DEPENDENCY_FLAG_HOST_VOLUMES, Used, StorageDependencyInfo, &Used);
}
}
if(GetLastError() == ERROR_SUCCESS)
{
Result = true;
if(StorageDependencyInfo->NumberEntries)
{
strVolumePath = StorageDependencyInfo->Version2Entries[0].HostVolumeName;
strVolumePath += StorageDependencyInfo->Version2Entries[0].DependentVolumeRelativePath;
}
}
}
}
}
return Result;
}
void Manager::InsertCommit()
{
_MANAGER(CleverSysLog clv(L"Manager::InsertCommit()"));
_MANAGER(SysLog(L"InsertedFrame=%p",InsertedFrame));
if (InsertedFrame)
{
if (FrameListSize <= FrameCount)
{
FrameList=(Frame **)xf_realloc(FrameList,sizeof(*FrameList)*(FrameCount+1));
FrameListSize++;
}
InsertedFrame->FrameToBack=CurrentFrame;
FrameList[FrameCount]=InsertedFrame;
if (!ActivatedFrame)
{
ActivatedFrame=InsertedFrame;
}
FrameCount++;
}
}
int GetFileString::GetUnicodeString(LPWSTR* DestStr, int& Length, bool bBigEndian)
{
int CurLength = 0;
int ExitCode = 1;
EolType Eol = FEOL_NONE;
int x = 0;
LPWSTR ReadBufPtr = ReadPos < ReadSize ? wReadBuf + ReadPos / sizeof(wchar_t) : nullptr;
// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
// В этом случаем считаем \r\r двумя MAC окончаниями строк.
if (bCrCr)
{
*wStr = L'\r';
CurLength = 1;
bCrCr = false;
}
else
{
for(;;)
{
if (ReadPos >= ReadSize)
{
if (!(SrcFile.Read(wReadBuf, ReadBufCount*sizeof(wchar_t), ReadSize) && ReadSize))
{
if (!CurLength)
{
ExitCode = 0;
}
break;
}
if (bBigEndian)
{
_swab(reinterpret_cast<char*>(wReadBuf), reinterpret_cast<char*>(wReadBuf), ReadSize);
}
ReadPos = 0;
ReadBufPtr = wReadBuf;
}
if (Eol == FEOL_NONE)
{
// UNIX
if (*ReadBufPtr == L'\n')
{
Eol = FEOL_UNIX;
}
// MAC / Windows? / Notepad?
else if (*ReadBufPtr == L'\r')
{
Eol = FEOL_MAC;
}
}
else if (Eol == FEOL_MAC)
{
// Windows
if (*ReadBufPtr == L'\n')
{
Eol = FEOL_WINDOWS;
}
// Notepad?
else if (*ReadBufPtr == L'\r')
{
Eol = FEOL_MAC2;
}
else
{
break;
}
}
else if (Eol == FEOL_WINDOWS || Eol == FEOL_UNIX)
{
break;
}
else if (Eol == FEOL_MAC2)
{
// Notepad
if (*ReadBufPtr == L'\n')
{
Eol = FEOL_NOTEPAD;
}
else
{
// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
CurLength--;
bCrCr = true;
break;
}
}
else
{
break;
}
ReadPos += sizeof(wchar_t);
if (CurLength >= m_nwStrLength - 1)
{
LPWSTR NewStr = static_cast<LPWSTR>(xf_realloc(wStr, (m_nwStrLength + (DELTA << x)) * sizeof(wchar_t)));
if (!NewStr)
{
return -1;
}
wStr = NewStr;
m_nwStrLength += DELTA << x;
x++;
}
wStr[CurLength++] = *ReadBufPtr;
ReadBufPtr++;
}
}
wStr[CurLength] = 0;
*DestStr = wStr;
Length = CurLength;
return ExitCode;
}
int GetFileString::GetAnsiString(LPSTR* DestStr, int& Length)
{
int CurLength = 0;
int ExitCode = 1;
EolType Eol = FEOL_NONE;
int x = 0;
LPSTR ReadBufPtr = ReadPos < ReadSize ? ReadBuf + ReadPos : nullptr;
// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
// В этом случаем считаем \r\r двумя MAC окончаниями строк.
if (bCrCr)
{
*Str = '\r';
CurLength = 1;
bCrCr = false;
}
else
{
for(;;)
{
if (ReadPos >= ReadSize)
{
if (!(SrcFile.Read(ReadBuf, ReadBufCount, ReadSize) && ReadSize))
{
if (!CurLength)
{
ExitCode=0;
}
break;
}
ReadPos = 0;
ReadBufPtr = ReadBuf;
}
if (Eol == FEOL_NONE)
{
// UNIX
if (*ReadBufPtr == '\n')
{
Eol = FEOL_UNIX;
}
// MAC / Windows? / Notepad?
else if (*ReadBufPtr == '\r')
{
Eol = FEOL_MAC;
}
}
else if (Eol == FEOL_MAC)
{
// Windows
if (*ReadBufPtr == '\n')
{
Eol = FEOL_WINDOWS;
}
// Notepad?
else if (*ReadBufPtr == '\r')
{
Eol = FEOL_MAC2;
}
else
{
break;
}
}
else if (Eol == FEOL_WINDOWS || Eol == FEOL_UNIX)
{
break;
}
else if (Eol == FEOL_MAC2)
{
// Notepad
if (*ReadBufPtr == '\n')
{
Eol = FEOL_NOTEPAD;
}
else
{
// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
CurLength--;
bCrCr = true;
break;
}
}
else
{
break;
}
ReadPos++;
if (CurLength >= m_nStrLength - 1)
{
LPSTR NewStr = static_cast<LPSTR>(xf_realloc(Str, m_nStrLength + (DELTA << x)));
if (!NewStr)
{
return -1;
}
Str = NewStr;
m_nStrLength += DELTA << x;
x++;
}
Str[CurLength++] = *ReadBufPtr;
ReadBufPtr++;
}
}
Str[CurLength] = 0;
*DestStr = Str;
Length = CurLength;
return ExitCode;
}
int OldGetFileString::GetUnicodeString(wchar_t **DestStr, int &Length, bool bBigEndian)
{
int CurLength = 0;
int ExitCode = 1;
EolType Eol = FEOL_NONE;
int x = 0;
wchar_t *ReadBufPtr = ReadPos < ReadSize ? wReadBuf + ReadPos / sizeof(wchar_t) : nullptr;
// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
// В этом случаем считаем \r\r двумя MAC окончаниями строк.
if (bCrCr)
{
*wStr = L'\r';
CurLength = 1;
bCrCr = false;
}
else
{
while (1)
{
if (ReadPos >= ReadSize)
{
if (!(ReadSize = (int)fread(wReadBuf, sizeof(wchar_t), ReadBufCount, SrcFile)))
{
if (!CurLength)
ExitCode=0;
break;
}
ReadSize *= sizeof(wchar_t);
if (bBigEndian)
_swab(reinterpret_cast<char*>(wReadBuf), reinterpret_cast<char*>(wReadBuf), ReadSize);
ReadPos = 0;
ReadBufPtr = wReadBuf;
}
if (Eol == FEOL_NONE)
{
// UNIX
if (*ReadBufPtr == L'\n')
Eol = FEOL_UNIX;
// MAC / Windows? / Notepad?
else if (*ReadBufPtr == L'\r')
Eol = FEOL_MAC;
}
else if (Eol == FEOL_MAC)
{
// Windows
if (*ReadBufPtr == L'\n')
Eol = FEOL_WINDOWS;
// Notepad?
else if (*ReadBufPtr == L'\r')
Eol = FEOL_MAC2;
else
break;
}
else if (Eol == FEOL_WINDOWS || Eol == FEOL_UNIX)
break;
else if (Eol == FEOL_MAC2)
{
// Notepad
if (*ReadBufPtr == L'\n')
Eol = FEOL_NOTEPAD;
else
{
// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
--CurLength;
bCrCr = true;
break;
}
}
else
break;
ReadPos += sizeof(wchar_t);
if (CurLength >= m_nwStrLength - 1)
{
wchar_t *NewStr = (wchar_t *)xf_realloc(wStr, (m_nwStrLength + (DELTA << x)) * sizeof(wchar_t));
if (!NewStr)
return (-1);
wStr = NewStr;
m_nwStrLength += DELTA << x;
x++;
}
wStr[CurLength++] = *ReadBufPtr;
ReadBufPtr++;
}
}
wStr[CurLength] = 0;
*DestStr = wStr;
Length = CurLength;
return (ExitCode);
}
int OldGetFileString::GetAnsiString(char **DestStr, int &Length)
{
int CurLength = 0;
int ExitCode = 1;
EolType Eol = FEOL_NONE;
int x = 0;
char *ReadBufPtr = ReadPos < ReadSize ? ReadBuf + ReadPos : nullptr;
// Обработка ситуации, когда у нас пришёл двойной \r\r, а потом не было \n.
// В этом случаем считаем \r\r двумя MAC окончаниями строк.
if (bCrCr)
{
*Str = '\r';
CurLength = 1;
bCrCr = false;
}
else
{
while (1)
{
if (ReadPos >= ReadSize)
{
if (!(ReadSize = (int)fread(ReadBuf, 1, ReadBufCount, SrcFile)))
{
if (!CurLength)
ExitCode=0;
break;
}
ReadPos = 0;
ReadBufPtr = ReadBuf;
}
if (Eol == FEOL_NONE)
{
// UNIX
if (*ReadBufPtr == '\n')
Eol = FEOL_UNIX;
// MAC / Windows? / Notepad?
else if (*ReadBufPtr == '\r')
Eol = FEOL_MAC;
}
else if (Eol == FEOL_MAC)
{
// Windows
if (*ReadBufPtr == '\n')
Eol = FEOL_WINDOWS;
// Notepad?
else if (*ReadBufPtr == '\r')
Eol = FEOL_MAC2;
else
break;
}
else if (Eol == FEOL_WINDOWS || Eol == FEOL_UNIX)
break;
else if (Eol == FEOL_MAC2)
{
// Notepad
if (*ReadBufPtr == '\n')
Eol = FEOL_NOTEPAD;
else
{
// Пришёл \r\r, а \n не пришёл, поэтому считаем \r\r двумя MAC окончаниями строк
--CurLength;
bCrCr = true;
break;
}
}
else
break;
ReadPos++;
if (CurLength >= m_nStrLength - 1)
{
char *NewStr = (char *)xf_realloc(Str, m_nStrLength + (DELTA << x));
if (!NewStr)
return (-1);
Str = NewStr;
m_nStrLength += DELTA << x;
x++;
}
Str[CurLength++] = *ReadBufPtr;
ReadBufPtr++;
}
}
Str[CurLength] = 0;
*DestStr = Str;
Length = CurLength;
return (ExitCode);
}
void FileList::ReadFileNames(int KeepSelection, int IgnoreVisible, int DrawMessage)
{
TPreRedrawFuncGuard preRedrawFuncGuard(PR_ReadFileNamesMsg);
TaskBar TB(false);
strOriginalCurDir=strCurDir;
if (!IsVisible() && !IgnoreVisible)
{
UpdateRequired=TRUE;
UpdateRequiredMode=KeepSelection;
return;
}
UpdateRequired=FALSE;
AccessTimeUpdateRequired=FALSE;
DizRead=FALSE;
FAR_FIND_DATA_EX fdata;
FileListItem *CurPtr=0,**OldData=0;
string strCurName, strNextCurName;
int OldFileCount=0;
StopFSWatcher();
if (this!=CtrlObject->Cp()->LeftPanel && this!=CtrlObject->Cp()->RightPanel)
return;
string strSaveDir;
apiGetCurrentDirectory(strSaveDir);
{
string strOldCurDir = strCurDir;
if (!SetCurPath())
{
FlushInputBuffer(); // Очистим буффер ввода, т.к. мы уже можем быть в другом месте...
if (!StrCmp(strCurDir, strOldCurDir)) //?? i??
{
GetPathRoot(strOldCurDir,strOldCurDir);
if (!apiIsDiskInDrive(strOldCurDir))
IfGoHome(strOldCurDir.At(0));
/* При смене каталога путь не изменился */
}
return;
}
}
SortGroupsRead=FALSE;
if (GetFocus())
CtrlObject->CmdLine->SetCurDir(strCurDir);
LastCurFile=-1;
Panel *AnotherPanel=CtrlObject->Cp()->GetAnotherPanel(this);
AnotherPanel->QViewDelTempName();
size_t PrevSelFileCount=SelFileCount;
SelFileCount=0;
SelFileSize=0;
TotalFileCount=0;
TotalFileSize=0;
CacheSelIndex=-1;
CacheSelClearIndex=-1;
if (Opt.ShowPanelFree)
{
unsigned __int64 TotalSize,TotalFree;
if (!apiGetDiskSize(strCurDir,&TotalSize,&TotalFree,&FreeDiskSize))
FreeDiskSize=0;
}
if (FileCount>0)
{
strCurName = ListData[CurFile]->strName;
if (ListData[CurFile]->Selected)
{
for (int i=CurFile+1; i < FileCount; i++)
{
CurPtr = ListData[i];
if (!CurPtr->Selected)
{
strNextCurName = CurPtr->strName;
break;
}
}
}
}
if (KeepSelection || PrevSelFileCount>0)
{
OldData=ListData;
OldFileCount=FileCount;
}
else
DeleteListData(ListData,FileCount);
ListData=nullptr;
int ReadOwners=IsColumnDisplayed(OWNER_COLUMN);
int ReadNumLinks=IsColumnDisplayed(NUMLINK_COLUMN);
int ReadNumStreams=IsColumnDisplayed(NUMSTREAMS_COLUMN);
int ReadStreamsSize=IsColumnDisplayed(STREAMSSIZE_COLUMN);
string strComputerName;
if (ReadOwners)
{
CurPath2ComputerName(strCurDir, strComputerName);
// сбросим кэш SID`ов
SIDCacheFlush();
}
SetLastError(ERROR_SUCCESS);
int AllocatedCount=0;
FileListItem *NewPtr;
// сформируем заголовок вне цикла
wchar_t Title[2048];
int TitleLength=Min((int)X2-X1-1,(int)(ARRAYSIZE(Title))-1);
//wmemset(Title,0x0CD,TitleLength); //BUGBUG
//Title[TitleLength]=0;
MakeSeparator(TitleLength, Title, 9, nullptr);
BOOL IsShowTitle=FALSE;
BOOL NeedHighlight=Opt.Highlight && PanelMode != PLUGIN_PANEL;
if (!Filter)
Filter=new FileFilter(this,FFT_PANEL);
//Рефреш текущему времени для фильтра перед началом операции
Filter->UpdateCurrentTime();
CtrlObject->HiFiles->UpdateCurrentTime();
bool bCurDirRoot = false;
ParsePath(strCurDir, nullptr, &bCurDirRoot);
PATH_TYPE Type = ParsePath(strCurDir, nullptr, &bCurDirRoot);
bool NetRoot = bCurDirRoot && (Type == PATH_REMOTE || Type == PATH_REMOTEUNC);
FileCount = 0;
string strFind = strCurDir;
AddEndSlash(strFind);
strFind+=L'*';
::FindFile Find(strFind, true);
DWORD FindErrorCode = ERROR_SUCCESS;
bool UseFilter=Filter->IsEnabledOnPanel();
bool ReadCustomData=IsColumnDisplayed(CUSTOM_COLUMN0)!=0;
DWORD StartTime = GetTickCount();
while (Find.Get(fdata))
{
FindErrorCode = GetLastError();
if ((Opt.ShowHidden || !(fdata.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM))) && (!UseFilter || Filter->FileInFilter(fdata, nullptr, &fdata.strFileName)))
{
if (FileCount>=AllocatedCount)
{
AllocatedCount+=4096;
FileListItem **pTemp;
if (!(pTemp=(FileListItem **)xf_realloc(ListData,AllocatedCount*sizeof(*ListData))))
break;
ListData=pTemp;
}
ListData[FileCount] = new FileListItem;
ListData[FileCount]->Clear();
NewPtr=ListData[FileCount];
NewPtr->FileAttr = fdata.dwFileAttributes;
NewPtr->CreationTime = fdata.ftCreationTime;
NewPtr->AccessTime = fdata.ftLastAccessTime;
NewPtr->WriteTime = fdata.ftLastWriteTime;
NewPtr->ChangeTime = fdata.ftChangeTime;
NewPtr->FileSize = fdata.nFileSize;
NewPtr->AllocationSize = fdata.nAllocationSize;
NewPtr->strName = fdata.strFileName;
NewPtr->strShortName = fdata.strAlternateFileName;
NewPtr->Position=FileCount++;
NewPtr->NumberOfLinks=1;
if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
{
NewPtr->ReparseTag=fdata.dwReserved0; //MSDN
}
if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
{
TotalFileSize += NewPtr->FileSize;
if (ReadNumLinks)
NewPtr->NumberOfLinks=GetNumberOfLinks(fdata.strFileName);
}
else
{
NewPtr->AllocationSize = 0;
}
NewPtr->SortGroup=DEFAULT_SORT_GROUP;
if (ReadOwners)
{
string strOwner;
GetFileOwner(strComputerName, NewPtr->strName,strOwner);
NewPtr->strOwner = strOwner;
}
NewPtr->NumberOfStreams=NewPtr->FileAttr&FILE_ATTRIBUTE_DIRECTORY?0:1;
NewPtr->StreamsSize=NewPtr->FileSize;
if (ReadNumStreams||ReadStreamsSize)
{
EnumStreams(TestParentFolderName(fdata.strFileName)?strCurDir:fdata.strFileName,NewPtr->StreamsSize,NewPtr->NumberOfStreams);
}
if (ReadCustomData)
CtrlObject->Plugins->GetCustomData(NewPtr);
if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
TotalFileCount++;
//memcpy(ListData+FileCount,&NewPtr,sizeof(NewPtr));
// FileCount++;
DWORD CurTime = GetTickCount();
if (CurTime - StartTime > RedrawTimeout)
{
StartTime = CurTime;
if (IsVisible())
{
if (!IsShowTitle)
{
if (!DrawMessage)
{
Text(X1+1,Y1,ColorIndexToColor(COL_PANELBOX),Title);
IsShowTitle=TRUE;
SetColor(Focus ? COL_PANELSELECTEDTITLE:COL_PANELTITLE);
}
}
LangString strReadMsg(MReadingFiles);
strReadMsg << FileCount;
if (DrawMessage)
{
ReadFileNamesMsg(strReadMsg);
}
else
{
TruncStr(strReadMsg,TitleLength-2);
int MsgLength=(int)strReadMsg.GetLength();
GotoXY(X1+1+(TitleLength-MsgLength-1)/2,Y1);
FS<<L" "<<strReadMsg<<L" ";
}
}
if (CheckForEsc())
{
break;
}
}
}
}
if (!(FindErrorCode==ERROR_SUCCESS || FindErrorCode==ERROR_NO_MORE_FILES || FindErrorCode==ERROR_FILE_NOT_FOUND))
Message(MSG_WARNING|MSG_ERRORTYPE,1,MSG(MError),MSG(MReadFolderError),MSG(MOk));
if ((Opt.ShowDotsInRoot || !bCurDirRoot) || (NetRoot && CtrlObject->Plugins->FindPlugin(Opt.KnownIDs.Network))) // NetWork Plugin
{
if (FileCount>=AllocatedCount)
{
FileListItem **pTemp;
if ((pTemp=(FileListItem **)xf_realloc(ListData,(FileCount+1)*sizeof(*ListData))))
ListData=pTemp;
}
if (ListData)
{
ListData[FileCount] = new FileListItem;
string TwoDotsOwner;
if (ReadOwners)
{
GetFileOwner(strComputerName,strCurDir,TwoDotsOwner);
}
FILETIME TwoDotsTimes[4]={};
if(apiGetFindDataEx(strCurDir,fdata))
{
TwoDotsTimes[0]=fdata.ftCreationTime;
TwoDotsTimes[1]=fdata.ftLastAccessTime;
TwoDotsTimes[2]=fdata.ftLastWriteTime;
TwoDotsTimes[3]=fdata.ftChangeTime;
}
AddParentPoint(ListData[FileCount],FileCount,TwoDotsTimes,TwoDotsOwner);
FileCount++;
}
}
if (IsColumnDisplayed(DIZ_COLUMN))
ReadDiz();
if (NeedHighlight)
{
CtrlObject->HiFiles->GetHiColor(ListData, FileCount);
}
if (AnotherPanel->GetMode()==PLUGIN_PANEL)
{
HANDLE hAnotherPlugin=AnotherPanel->GetPluginHandle();
PluginPanelItem *PanelData=nullptr;
string strPath;
size_t PanelCount=0;
strPath = strCurDir;
AddEndSlash(strPath);
if (CtrlObject->Plugins->GetVirtualFindData(hAnotherPlugin,&PanelData,&PanelCount,strPath))
{
FileListItem **pTemp;
if ((pTemp=(FileListItem **)xf_realloc(ListData,(FileCount+PanelCount)*sizeof(*ListData))))
{
ListData=pTemp;
for (size_t i=0; i < PanelCount; i++)
{
CurPtr = ListData[FileCount+i];
PluginPanelItem &pfdata=PanelData[i];
PluginToFileListItem(&PanelData[i],CurPtr);
CurPtr->Position=FileCount;
TotalFileSize += pfdata.FileSize;
CurPtr->PrevSelected=CurPtr->Selected=0;
CurPtr->ShowFolderSize=0;
CurPtr->SortGroup=CtrlObject->HiFiles->GetGroup(CurPtr);
if (!TestParentFolderName(pfdata.FileName) && !(CurPtr->FileAttr & FILE_ATTRIBUTE_DIRECTORY))
TotalFileCount++;
}
// цветовую боевую раскраску в самом конце, за один раз
CtrlObject->HiFiles->GetHiColor(&ListData[FileCount],PanelCount);
FileCount+=static_cast<int>(PanelCount);
}
CtrlObject->Plugins->FreeVirtualFindData(hAnotherPlugin,PanelData,PanelCount);
}
}
InitFSWatcher(false);
CorrectPosition();
if (KeepSelection || PrevSelFileCount>0)
{
MoveSelection(ListData,FileCount,OldData,OldFileCount);
DeleteListData(OldData,OldFileCount);
}
if (SortGroups)
ReadSortGroups(false);
if (!KeepSelection && PrevSelFileCount>0)
{
SaveSelection();
ClearSelection();
}
SortFileList(FALSE);
if (CurFile>=FileCount || StrCmpI(ListData[CurFile]->strName,strCurName))
if (!GoToFile(strCurName) && !strNextCurName.IsEmpty())
GoToFile(strNextCurName);
/* $ 13.02.2002 DJ
SetTitle() - только если мы текущий фрейм!
*/
if (CtrlObject->Cp() == FrameManager->GetCurrentFrame())
SetTitle();
FarChDir(strSaveDir); //???
}
void Grabber::CopyGrabbedArea(int Append, int VerticalBlock)
{
if (GArea.X1 < 0)
return;
int X1,Y1,X2,Y2;
X1=Min(GArea.X1,GArea.X2);
X2=Max(GArea.X1,GArea.X2);
Y1=Min(GArea.Y1,GArea.Y2);
Y2=Max(GArea.Y1,GArea.Y2);
int GWidth=X2-X1+1,GHeight=Y2-Y1+1;
int BufSize=(GWidth+3)*GHeight;
FAR_CHAR_INFO* CharBuf=new FAR_CHAR_INFO[BufSize], *PtrCharBuf;
wchar_t *CopyBuf=(wchar_t *)xf_malloc(BufSize*sizeof(wchar_t)), *PtrCopyBuf;
WORD Chr;
GetText(X1,Y1,X2,Y2,CharBuf,BufSize*sizeof(FAR_CHAR_INFO));
*CopyBuf=0;
PtrCharBuf=CharBuf;
PtrCopyBuf=CopyBuf;
for (int I=0; I<GHeight; I++)
{
if (I>0)
{
*PtrCopyBuf++=L'\r';
*PtrCopyBuf++=L'\n';
*PtrCopyBuf=0;
}
for (int J=0; J<GWidth; J++, ++PtrCharBuf)
{
WORD Chr2 = PtrCharBuf->Char;
Chr=PtrCharBuf->Char;
if (Opt.CleanAscii)
{
switch (Chr2)
{
case L'.': Chr=L'.'; break;
case 0x07: Chr=L'*'; break;
case 0x10: Chr=L'>'; break;
case 0x11: Chr=L'<'; break;
case 0x18:
case 0x19: Chr=L'|'; break;
case 0x1E:
case 0x1F: Chr=L'X'; break;
case 0xFF: Chr=L' '; break;
default:
if (Chr2 < 0x20)
Chr=L'.';
else if (Chr2 < 0x100)
Chr=Chr2;
break;
}
}
if (Opt.NoGraphics && Chr2 >=0xB3 && Chr2 <= 0xDA)
{
switch (Chr2)
{
case 0xB3:
case 0xBA: Chr=L'|'; break;
case 0xC4: Chr=L'-'; break;
case 0xCD: Chr=L'='; break;
default: Chr=L'+'; break;
}
}
*PtrCopyBuf++=Chr;
*PtrCopyBuf=0;
}
for (int K=StrLength(CopyBuf)-1; K>=0 && CopyBuf[K]==L' '; K--)
CopyBuf[K]=0;
PtrCopyBuf=CopyBuf+StrLength(CopyBuf);
}
Clipboard clip;
if (clip.Open())
{
if (Append)
{
wchar_t *AppendBuf=clip.Paste();
if (AppendBuf)
{
int add=0;
size_t DataSize=StrLength(AppendBuf);
if (AppendBuf[DataSize-1]!=L'\n')
{
add=2;
}
AppendBuf=(wchar_t *)xf_realloc(AppendBuf,(DataSize+BufSize+add)*sizeof(wchar_t));
wmemcpy(AppendBuf+DataSize+add,CopyBuf,BufSize);
if (add)
wmemcpy(AppendBuf+DataSize,L"\r\n",2);
xf_free(CopyBuf);
CopyBuf=AppendBuf;
}
}
if (VerticalBlock)
clip.CopyFormat(FAR_VerticalBlock_Unicode,CopyBuf);
else
clip.Copy(CopyBuf);
clip.Close();
}
if (CopyBuf)
xf_free(CopyBuf);
delete[] CharBuf;
}
//- AN ----------------------------------------------
// Компиляция строки BufPtr в байткод CurMacroBuffer
//- AN ----------------------------------------------
int __parseMacroString(DWORD *&CurMacroBuffer, int &CurMacroBufferSize, const wchar_t *BufPtr)
{
_KEYMACRO(CleverSysLog Clev(L"parseMacroString"));
//_KEYMACRO(SysLog(L"BufPtr[%p]='%s'", BufPtr,BufPtr));
_macro_nErr = 0;
_macro_nLine= 0;
_macro_nPos = 0;
pSrcString = emptyString;
inloop = 0;
/*pSrcString = */oSrcString = sSrcString = emptyString;
if (!BufPtr || !*BufPtr)
{
keyMacroParseError(err_ZeroLengthMacro);
return FALSE;
}
bool useUDL=true;
const wchar_t *NewBufPtr;
UserDefinedList MacroSrcList(ULF_NOTRIM|ULF_NOUNQUOTE, L"\r\n");
if(!MacroSrcList.Set(BufPtr))
useUDL=false; // все в одну строку
//{
// _SVS(SysLog(L"MacroSrcList.GetTotal()=%d",MacroSrcList.GetTotal()));
// while((NewBufPtr=MacroSrcList.GetNext()) )
// _SVS(SysLog(L"[%s]",NewBufPtr));
// MacroSrcList.Reset();
//}
size_t SizeCurKeyText = (StrLength(BufPtr)*2)*sizeof(wchar_t);
string strCurrKeyText;
//- AN ----------------------------------------------
// Буфер под парсинг выражений
//- AN ----------------------------------------------
DWORD *dwExprBuff = (DWORD*)xf_malloc(SizeCurKeyText*sizeof(DWORD));
if (!dwExprBuff)
return FALSE;
TExec exec;
wchar_t varName[256];
DWORD KeyCode, *CurMacro_Buffer = nullptr;
if(useUDL)
BufPtr=MacroSrcList.GetNext();
pSrcString=BufPtr;
for (;;)
{
int Size = 1;
int SizeVarName = 0;
const wchar_t *oldBufPtr = BufPtr;
if (!(BufPtr = __GetNextWord(BufPtr, strCurrKeyText, _macro_nLine)))
{
if(!useUDL)
break;
NewBufPtr=MacroSrcList.GetNext();
if(!NewBufPtr)
break;
_macro_nLine++;
pSrcString=BufPtr=NewBufPtr;
continue;
}
_SVS(SysLog(L"_macro_nLine = [%d]",_macro_nLine));
_SVS(SysLog(L"BufPtr = [%s]",BufPtr));
_SVS(SysLog(L"pSrcString = [%s]",pSrcString));
_SVS(SysLog(L"strCurrKeyText = [%s]",strCurrKeyText.CPtr()));
//- AN ----------------------------------------------
// Проверка на строковый литерал
// Сделаем $Text опциональным
//- AN ----------------------------------------------
if (strCurrKeyText.At(0) == L'\"' && strCurrKeyText.At(1))
{
KeyCode = MCODE_OP_PLAINTEXT;
BufPtr = oldBufPtr;
}
else if ((KeyCode = KeyNameMacroToKey(strCurrKeyText)) == (DWORD)-1 && (KeyCode = KeyNameToKey(strCurrKeyText)) == (DWORD)-1)
{
int ProcError=0;
if (strCurrKeyText.At(0) == L'%' &&
(
(IsAlphaNum(strCurrKeyText.At(1)) || strCurrKeyText.At(1) == L'_') ||
(
strCurrKeyText.At(1) == L'%' &&
(IsAlphaNum(strCurrKeyText.At(2)) || strCurrKeyText.At(2)==L'_')
)
)
)
{
BufPtr = oldBufPtr;
while (*BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)))
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
ClearArray(varName);
KeyCode = MCODE_OP_SAVE;
wchar_t* p = varName;
const wchar_t* s = strCurrKeyText.CPtr()+1;
if (*s == L'%')
*p++ = *s++;
wchar_t ch;
*p++ = *s++;
while ((iswalnum(ch = *s++) || (ch == L'_')))
*p++ = ch;
*p = 0;
size_t Length = (StrLength(varName)+1)*sizeof(wchar_t);
// строка должна быть выровнена на 4
SizeVarName = static_cast<int>(Length/sizeof(DWORD));
if (Length == sizeof(wchar_t) || (Length % sizeof(DWORD)) ) // дополнение до sizeof(DWORD) нулями.
SizeVarName++;
_SVS(SysLog(L"BufPtr=%s",BufPtr));
BufPtr += Length/sizeof(wchar_t);
_SVS(SysLog(L"BufPtr=%s",BufPtr));
Size += parseExpr(BufPtr, dwExprBuff, L'=', L';');
if (_macro_nErr)
{
ProcError++;
}
}
else
{
// проверим вариант, когда вызвали функцию, но результат не присвоили,
// например, вызвали MsgBox(), но результат неважен
// тогда SizeVarName=1 и varName=""
wchar_t *lpwszCurrKeyText = strCurrKeyText.GetBuffer();
wchar_t *Brack=(wchar_t *)wcspbrk(lpwszCurrKeyText,L"( "), Chr=0;
if (Brack)
{
Chr=*Brack;
*Brack=0;
}
if (funcLook(lpwszCurrKeyText) != MCODE_F_NOFUNC)
{
if (Brack) *Brack=Chr;
BufPtr = oldBufPtr;
while (*BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)))
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
Size += parseExpr(BufPtr, dwExprBuff, 0, 0);
/*
// этого пока ненадо, считаем, что ';' идет сразу за функцией, иначе это отдельный символ ';', который нужно поместить в поток
while ( *BufPtr && (IsSpace(*BufPtr) || IsEol(*BufPtr)) )
{
if (IsEol(*BufPtr))
{
_macro_nLine++;//TODO!!!
}
BufPtr++;
}
*/
if (*BufPtr == L';')
BufPtr++; // здесь Size не увеличиваем, т.к. мы прокидываем символ ';'
//Size--; //???
if (_macro_nErr)
{
ProcError++;
}
else
{
KeyCode=MCODE_OP_SAVE;
SizeVarName=1;
ClearArray(varName);
}
}
else
{
if (Brack) *Brack=Chr;
ProcError++;
}
strCurrKeyText.ReleaseBuffer();
}
if (ProcError)
{
if (!_macro_nErr)
//keyMacroParseError(err_Unrecognized_keyword, strCurrKeyText, strCurrKeyText,strCurrKeyText);
keyMacroParseError(err_Unrecognized_keyword, oldBufPtr, pSrcString, strCurrKeyText);
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
}
else if (!(strCurrKeyText.At(0) == L'$' && strCurrKeyText.At(1)))
{
Size=3;
KeyCode=MCODE_OP_KEYS;
}
switch (KeyCode)
{
// $Text
// -------------------------------------
// MCODE_OP_PLAINTEXT
// <expr>
case MCODE_OP_PLAINTEXT:
{
Size += parseExpr(BufPtr, dwExprBuff, 0, 0);
break;
}
// $If (expr) ... $End
// -------------------------------------
// <expr>
// MCODE_OP_JZ p1=*+0
// addr1 ------------+
// ... |
// MCODE_OP_JMP |
// +--------- addr2 |
// | ... <-----------+
// +--------> MCODE_OP_END
// или
// <expr>
// MCODE_OP_JZ p1=*+0
// addr1 ------------+
// ... |
// MCODE_OP_END <-----------+
case MCODE_OP_IF:
{
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmThen, CurMacroBufferSize+Size))
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size++;
break;
}
case MCODE_OP_ELSE:
{
Size++;
break;
}
// $Rep (expr) ... $End
// -------------------------------------
// <expr>
// MCODE_OP_SAVEREPCOUNT 1
// +--------> MCODE_OP_REP p1=*
// | <counter> 3
// | <counter> 4
// | MCODE_OP_JZ 5 p2=*+2
// | addr1 ------------+
// | ... |
// | MCODE_OP_JMP |
// +--------- addr2 |
// MCODE_OP_END <-----------+
case MCODE_OP_REP:
{
inloop++;
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmRep, CurMacroBufferSize+Size, CurMacroBufferSize+Size+4)) //??? 3
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size += 5; // естественно, размер будет больше = 4
break;
}
// $While (expr) ... $End
// -------------------------------------
// +--------> <expr>
// | MCODE_OP_JZ CurMacroBufferSize + Size - 2
// | addr1 ------------+ CurMacroBufferSize + Size - 1
// | ... | ...
// | MCODE_OP_JMP | CurMacroBufferSize + Size - 3
// +--------- addr2 | CurMacroBufferSize + Size - 2
// MCODE_OP_END <-----------+ CurMacroBufferSize + Size - 1
// CurMacroBufferSize + Size
case MCODE_OP_WHILE:
{
inloop++;
Size += parseExpr(BufPtr, dwExprBuff, L'(', L')');
if (!exec.add(emmWhile, CurMacroBufferSize, CurMacroBufferSize+Size))
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
Size++;
break;
}
// $continue
// -------------------------------------
// ^ MCODE_OP_CONTINUE
// | MCODE_OP_JMP
// +--------- addr
case MCODE_OP_CONTINUE:
{
Size++; // Место под адрес
break;
}
// $break
// -------------------------------------
// MCODE_OP_BREAK
// MCODE_OP_JMP
// addr -->
case MCODE_OP_BREAK:
{
Size++; // Место под адрес
break;
}
case MCODE_OP_END:
{
switch (exec().state)
{
case emmRep:
case emmWhile:
Size += 2; // Место под дополнительный JMP
break;
default:
break;
}
break;
}
}
if (_macro_nErr)
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
if (!BufPtr) // ???
break;
// код найден, добавим этот код в буфер последовательности.
CurMacro_Buffer = (DWORD *)xf_realloc(CurMacro_Buffer,sizeof(*CurMacro_Buffer)*(CurMacroBufferSize+Size+SizeVarName));
if (!CurMacro_Buffer)
{
CurMacroBuffer = nullptr;
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
switch (KeyCode)
{
case MCODE_OP_PLAINTEXT:
{
_SVS(SysLog(L"[%d] Size=%u",__LINE__,Size));
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
}
case MCODE_OP_SAVE:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
memcpy(CurMacro_Buffer+CurMacroBufferSize+Size, varName, SizeVarName*sizeof(DWORD));
break;
}
case MCODE_OP_IF:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_REP:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-6] = MCODE_OP_SAVEREPCOUNT;
CurMacro_Buffer[CurMacroBufferSize+Size-5] = KeyCode;
CurMacro_Buffer[CurMacroBufferSize+Size-4] = 0; // Initilize 0
CurMacro_Buffer[CurMacroBufferSize+Size-3] = 0;
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_WHILE:
{
memcpy(CurMacro_Buffer+CurMacroBufferSize, dwExprBuff, Size*sizeof(DWORD));
CurMacro_Buffer[CurMacroBufferSize+Size-2] = MCODE_OP_JZ;
break;
}
case MCODE_OP_ELSE:
{
if (exec().state == emmThen)
{
exec().state = emmElse;
CurMacro_Buffer[exec().pos1] = CurMacroBufferSize+2;
exec().pos1 = CurMacroBufferSize;
CurMacro_Buffer[CurMacroBufferSize] = 0;
}
else // тут $else и не предвиделось :-/
{
keyMacroParseError(err_Not_expected_ELSE, BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
break;
}
case MCODE_OP_BREAK:
case MCODE_OP_CONTINUE:
{
TExecItem *ei=nullptr;
if (!inloop || (KeyCode==MCODE_OP_CONTINUE && exec.findnearloop(&ei) == -1))
{
keyMacroParseError(KeyCode==MCODE_OP_CONTINUE?err_Continue_Outside_The_Loop:err_Break_Outside_The_Loop, oldBufPtr, pSrcString);//BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
CurMacro_Buffer[CurMacroBufferSize+Size-2] = KeyCode==MCODE_OP_CONTINUE?MCODE_OP_JMP:MCODE_OP_BREAK;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode==MCODE_OP_CONTINUE?ei->pos1:0;
break;
}
case MCODE_OP_END:
{
switch (exec().state)
{
case emmMain:
// тут $end и не предвиделось :-/
keyMacroParseError(err_Not_expected_END, BufPtr, pSrcString); // strCurrKeyText
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
case emmThen:
CurMacro_Buffer[exec().pos1-1] = MCODE_OP_JZ;
CurMacro_Buffer[exec().pos1+0] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
case emmElse:
CurMacro_Buffer[exec().pos1-0] = MCODE_OP_JMP;
CurMacro_Buffer[exec().pos1+1] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
break;
case emmRep:
case emmWhile:
inloop--;
CurMacro_Buffer[exec().pos2] = CurMacroBufferSize+Size-1;
CurMacro_Buffer[CurMacroBufferSize+Size-3] = MCODE_OP_JMP;
CurMacro_Buffer[CurMacroBufferSize+Size-2] = exec().pos1;
CurMacro_Buffer[CurMacroBufferSize+Size-1] = KeyCode;
CorrectBreakCode(CurMacro_Buffer,CurMacro_Buffer+exec().pos1,CurMacro_Buffer+(CurMacroBufferSize+Size-1));
break;
}
if (!exec.del()) // Вообще-то этого быть не должно, но подстрахуемся
{
if (CurMacro_Buffer )
{
xf_free(CurMacro_Buffer);
CurMacroBuffer = nullptr;
}
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
break;
}
case MCODE_OP_KEYS:
{
CurMacro_Buffer[CurMacroBufferSize+Size-3]=MCODE_OP_KEYS;
CurMacro_Buffer[CurMacroBufferSize+Size-2]=KeyNameToKey(strCurrKeyText);
CurMacro_Buffer[CurMacroBufferSize+Size-1]=MCODE_OP_ENDKEYS;
break;
}
default:
CurMacro_Buffer[CurMacroBufferSize]=KeyCode;
} // end switch(KeyCode)
CurMacroBufferSize += Size+SizeVarName;
} // END for (;;)
if (CurMacroBufferSize == 1)
{
CurMacro_Buffer = (DWORD *)xf_realloc(CurMacro_Buffer,sizeof(*CurMacro_Buffer)*(CurMacroBufferSize+1));
if (!CurMacro_Buffer)
{
CurMacroBuffer = nullptr;
CurMacroBufferSize = 0;
xf_free(dwExprBuff);
return FALSE;
}
CurMacro_Buffer[CurMacroBufferSize]=MCODE_OP_NOP;
CurMacroBufferSize++;
}
#ifdef _DEBUG
#ifdef SYSLOG_KEYMACRO
SysLogDump(L"Macro Buffer",0,(LPBYTE)CurMacro_Buffer,CurMacroBufferSize*sizeof(DWORD),nullptr);
SysLog(L"<ByteCode>{");
if (CurMacro_Buffer)
{
int ii;
for (ii = 0 ; ii < CurMacroBufferSize ; ii++)
printKeyValue(CurMacro_Buffer, ii);
}
else
SysLog(L"??? is nullptr");
SysLog(L"}</ByteCode>");
#endif
#endif
if (CurMacroBufferSize > 1)
CurMacroBuffer = CurMacro_Buffer;
else if (CurMacro_Buffer)
{
CurMacroBuffer = reinterpret_cast<DWORD*>((intptr_t)(*CurMacro_Buffer));
xf_free(CurMacro_Buffer);
}
xf_free(dwExprBuff);
if (exec().state != emmMain)
{
keyMacroParseError(err_Unexpected_EOS, strCurrKeyText, strCurrKeyText);
return FALSE;
}
if (_macro_nErr)
{
return FALSE;
}
return TRUE;
}
bool History::SaveHistory()
{
if (!*EnableSave)
return true;
if (!HistoryList.Count())
{
DeleteRegKey(strRegKey);
return true;
}
//for dialogs, locked items should show first (be last in the list)
if (TypeHistory == HISTORYTYPE_DIALOG)
{
for (const HistoryRecord *HistoryItem=HistoryList.First(), *LastItem=HistoryList.Last(); HistoryItem; )
{
const HistoryRecord *tmp = HistoryItem;
HistoryItem=HistoryList.Next(HistoryItem);
if (tmp->Lock)
HistoryList.MoveAfter(HistoryList.Last(), tmp);
if (tmp == LastItem)
break;
}
}
wchar_t *TypesBuffer=nullptr;
if (SaveType)
{
TypesBuffer=(wchar_t *)xf_malloc((HistoryList.Count()+1)*sizeof(wchar_t));
if (!TypesBuffer)
return false;
}
wchar_t *LocksBuffer=nullptr;
if (!(LocksBuffer=(wchar_t *)xf_malloc((HistoryList.Count()+1)*sizeof(wchar_t))))
{
if (TypesBuffer)
xf_free(TypesBuffer);
return false;
}
FILETIME *TimesBuffer=nullptr;
if (!(TimesBuffer=(FILETIME *)xf_malloc((HistoryList.Count()+1)*sizeof(FILETIME))))
{
if (LocksBuffer)
xf_free(LocksBuffer);
if (TypesBuffer)
xf_free(TypesBuffer);
return false;
}
memset(TimesBuffer,0,(HistoryList.Count()+1)*sizeof(FILETIME));
wmemset(LocksBuffer,0,HistoryList.Count()+1);
if (SaveType)
wmemset(TypesBuffer,0,HistoryList.Count()+1);
bool ret = false;
HKEY hKey = nullptr;
wchar_t *BufferLines=nullptr, *PtrBuffer;
size_t SizeLines=0, SizeTypes=0, SizeLocks=0, SizeTimes=0;
int Position = -1;
size_t i=HistoryList.Count()-1;
for (const HistoryRecord *HistoryItem=HistoryList.Last(); HistoryItem ; HistoryItem=HistoryList.Prev(HistoryItem))
{
if (!(PtrBuffer=(wchar_t*)xf_realloc(BufferLines,(SizeLines+HistoryItem->strName.GetLength()+2)*sizeof(wchar_t))))
{
ret = false;
goto end;
}
BufferLines=PtrBuffer;
xwcsncpy(BufferLines+SizeLines,HistoryItem->strName,HistoryItem->strName.GetLength()+1);
SizeLines+=HistoryItem->strName.GetLength()+1;
if (SaveType)
TypesBuffer[SizeTypes++]=HistoryItem->Type+L'0';
LocksBuffer[SizeLocks++]=HistoryItem->Lock+L'0';
TimesBuffer[SizeTimes].dwLowDateTime=HistoryItem->Timestamp.dwLowDateTime;
TimesBuffer[SizeTimes].dwHighDateTime=HistoryItem->Timestamp.dwHighDateTime;
SizeTimes++;
if (HistoryItem == CurrentItem)
Position = static_cast<int>(i);
i--;
}
hKey=CreateRegKey(strRegKey);
if (hKey)
{
RegSetValueEx(hKey,L"Lines",0,REG_MULTI_SZ,(unsigned char *)BufferLines,static_cast<DWORD>(SizeLines*sizeof(wchar_t)));
if (SaveType)
RegSetValueEx(hKey,L"Types",0,REG_SZ,(unsigned char *)TypesBuffer,static_cast<DWORD>((SizeTypes+1)*sizeof(wchar_t)));
RegSetValueEx(hKey,L"Locks",0,REG_SZ,(unsigned char *)LocksBuffer,static_cast<DWORD>((SizeLocks+1)*sizeof(wchar_t)));
RegSetValueEx(hKey,L"Times",0,REG_BINARY,(unsigned char *)TimesBuffer,(DWORD)SizeTimes*sizeof(FILETIME));
RegSetValueEx(hKey,L"Position",0,REG_DWORD,(BYTE *)&Position,sizeof(Position));
RegCloseKey(hKey);
ret = true;
}
end:
if (BufferLines)
xf_free(BufferLines);
if (TypesBuffer)
xf_free(TypesBuffer);
if (LocksBuffer)
xf_free(LocksBuffer);
if (TimesBuffer)
xf_free(TimesBuffer);
return ret;
}
