Пользовательская оболочка

#include <vcl.h>
#pragma hdrstop
#include "main.h"
#include "windows.h"
#include "copy.h"
#include "create.h"
#include "view.h"
#include "help.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TMainForm *MainForm;
//---------------------------------------------------------------------------
__fastcall TMainForm::TMainForm(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
// настройка панели, создание колонок
void __fastcall TMainForm::SetupPanel(PANEL_INFO *p)
{
    TListColumn *lc;
 
    // определяем текущий путь
    GetCurrentDirectory(MAX_PATH, p->path);
 
    // рамер панели
    p->panel->Width = ClientWidth / 2;
    // создаем колонки
    lc = p->panel->Columns->Add();
    lc->Caption = "Имя";
    lc->Width   = p->panel->Width*0.5;
    lc = p->panel->Columns->Add();
    lc->Caption = "Размер";
    lc->Width   = p->panel->Width*0.25;
    lc = p->panel->Columns->Add();
    lc->Caption = "Дата";
    lc->Width   = p->panel->Width*0.25;
 
    // заполняем панель
    FillPanel(p);
}
//---------------------------------------------------------------------------
// при создание формы создаем две панели
void __fastcall TMainForm::FormCreate(TObject *Sender)
{
    FillDrives();
    
    PanelLeft  = new PANEL_INFO;
    PanelLeft->panel = Panel1;
    SetupPanel(PanelLeft);
    PanelRight = new PANEL_INFO;
    PanelRight->panel = Panel2;
    CurPanel = PanelRight;
    SetupPanel(PanelRight);
}
//---------------------------------------------------------------------------
// перевод времени файла в TDateTime
TDateTime __fastcall TMainForm::FileTimeToDateTime(FILETIME *ft)
{
    SYSTEMTIME st;
    FileTimeToSystemTime(ft, &st);
    return
        TDateTime(st.wYear, st.wMonth, st.wDay) +
        TDateTime(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
}
//---------------------------------------------------------------------------
// удаление связанной с элементами списка информации о файле
void __fastcall TMainForm::FreePanel(PANEL_INFO *p)
{
    FILE_INFO *info;
 
    for (int i=0; i<p->panel->Items->Count; i++)
    {
        info = (FILE_INFO*)p->panel->Items->Item[i]->Data;
        if (info)
            delete info;
    }
 
    p->panel->Items->Clear();
}
//---------------------------------------------------------------------------
// заполнение панели информацией о файлах
void __fastcall TMainForm::FillPanel(PANEL_INFO *p, AnsiString asCurrent)
{
    WIN32_FIND_DATA wfd;
    HANDLE hFind;
    FILE_INFO *info;
    char szMask[MAX_PATH];
    TListItem *item;
    AnsiString asPath, asDrive;
    int i;
 
    p->panel->Items->BeginUpdate();
 
    // очищаем панель
    FreePanel(p);
    strcpy(szMask, p->path);
    strcat(szMask, "\\*.*");
    // обновляем заголовок
    Caption = "Файловый менеджер - " + (AnsiString)p->path;
    // очищаем группу
    p->group.clear();
 
    // заполняем панель информацией о файлах
    if ((hFind = FindFirstFile(szMask, &wfd)) != INVALID_HANDLE_VALUE)
    {
        do
        {
            if (strcmp(wfd.cFileName, ".") != 0)
            {
                // заполняем структуру с информацией о файле
                // на основе WIN32_FIND_DATA
                info = new FILE_INFO;
                info->dCreate = FileTimeToDateTime(&wfd.ftCreationTime);
                info->dAccess = FileTimeToDateTime(&wfd.ftLastAccessTime);
                info->dModify = FileTimeToDateTime(&wfd.ftLastWriteTime);
                info->size    = (__int64)wfd.nFileSizeHigh << 32 + wfd.nFileSizeLow;
                info->attr    = wfd.dwFileAttributes;
 
                // добавляем элемент в панель
                item = p->panel->Items->Add();
                item->Caption = wfd.cFileName;
                item->Data    = info;
 
                // если каталог, то пишем что папка
                if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                    item->SubItems->Add("Папка");
                // иначе размер файла
                else
                    item->SubItems->Add(IntToStr(wfd.nFileSizeLow));
 
                // в третью колонку выводим время создания файла
                item->SubItems->Add(info->dCreate.DateString());
            }
        }
        while (FindNextFile(hFind, &wfd));
 
        FindClose(hFind);
    }
    p->panel->Items->EndUpdate();
 
    // устанавливаем текущий элемент списка
    // если параметр не пустой то устанавливаем его текущим
    if (!asCurrent.IsEmpty())
    {
        // идем по всем элементам
        for (int i=0; i<p->panel->Items->Count; i++)
        {
            // если имя элемента совпадает с параметом
            if ((item = p->panel->Items->Item[i])->Caption == asCurrent)
            {
                // устанавливаем элемент текущим
                p->panel->ItemIndex = i;
                p->panel->ItemFocused = p->panel->Items->Item[i];
                // если элемент не прокручен, то прокручиваем пенель
                // так, чтобы текущий элемент был по центру
                if (i >= p->panel->VisibleRowCount)
                {
                    item = p->panel->Items->Item[i - p->panel->VisibleRowCount/2];
                    p->panel->Scroll(0, item->Position.y);
                }
                break;
            }
        }
    }
    // иначе устанавливаем текущим перый элемент списка
    else
    {
        p->panel->ItemIndex = (p->panel->Items->Count)? 0 : -1;
        if (p->panel->ItemIndex != -1)
            p->panel->ItemFocused = p->panel->Items->Item[0];
    }
 
    // обновляем текущий диск
    SetCurrentDrive(p, false);
 
}
//---------------------------------------------------------------------------
// выбор пользователем файла
void __fastcall TMainForm::SelectFile(PANEL_INFO *p, AnsiString asFile, FILE_INFO *info)
{
    AnsiString asCurDir, asExt;
    PROCESS_INFORMATION pi;
    STARTUPINFO si;
 
    if (info != NULL)
    {
        // если каталог, то переходим в него
        if (info->attr & FILE_ATTRIBUTE_DIRECTORY)
        {
            if (asFile == "..")
            {
                asCurDir = (AnsiString) CurPanel->path;
                asCurDir = asCurDir.SubString(asCurDir.LastDelimiter("\\")+1, asCurDir.Length());
            }
            else
                asCurDir = "";
 
            // устанавливаем каталог текущим
            if (SetCurrentDirectory(asFile.c_str()))
            {
                GetCurrentDirectory(MAX_PATH, CurPanel->path);
                // обновляем содержимое панели
                FillPanel(CurPanel, asCurDir);
            }
        }
        // если файл, то пытаемся выполнить
        else
        {
            asExt = ExtractFileExt(asFile).UpperCase();
 
            if (asExt == ".EXE")
            {
                si.cb = sizeof(si);
                si.lpReserved    = NULL;
                si.lpDesktop     = NULL;
                si.lpTitle       = NULL;
                si.dwFlags       = STARTF_USESHOWWINDOW;
                si.wShowWindow   = SW_SHOWDEFAULT;
                si.cbReserved2   = 0;
                si.lpReserved2   = NULL;
 
                CreateProcess(NULL, asFile.c_str(),
                     NULL, NULL, FALSE,
                    NORMAL_PRIORITY_CLASS,
                    NULL, NULL, &si, &pi);
            }
            else
                ShellExecute(NULL, "OPEN", asFile.c_str(), "", "", SW_SHOW);
        }
    }
 
}
//---------------------------------------------------------------------------
// при смене панели, запоминаем текущую панель
// изменяем заголовок и устанавливаем текущий каталог
// и обновляем текущий диск
void __fastcall TMainForm::PanelEnter(TObject *Sender)
{
    if (PanelLeft && PanelRight)
        CurPanel = (PanelLeft->panel == Sender)? PanelLeft : PanelRight;
 
    if (CurPanel)
    {
        Caption = "Файловый менеджер - " + (AnsiString)CurPanel->path;
        SetCurrentDirectory(CurPanel->path);
        SetCurrentDrive(CurPanel, false);
    }
 
}
//---------------------------------------------------------------------------
// обрабатываем нажатия клавишь
void __fastcall TMainForm::PanelKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
    TListItem *Item = NULL;
 
    if (CurPanel->panel->ItemIndex != -1)
        Item = CurPanel->panel->Items->Item[CurPanel->panel->ItemIndex];
 
    // выбор файла на панели
    if (Key == VK_RETURN)
    {
        if (Item != NULL)
            SelectFile (CurPanel, Item->Caption, (FILE_INFO*)Item->Data);
    }
    // добавление файла в группу
    else if (Key == VK_INSERT)
    {
        if (Item != NULL && Item->Caption != "..")
        {
            vector<int>::iterator i;
 
            i = find(CurPanel->group.begin(), CurPanel->group.end(), Item->Index);
 
            if (i != CurPanel->group.end())
                CurPanel->group.erase(i);
            else
                CurPanel->group.push_back(Item->Index);
 
            CurPanel->panel->Perform(WM_KEYDOWN, (WPARAM)VK_DOWN, NULL);
        }
    }
}
//---------------------------------------------------------------------------
// выбор файла на панели двойным кликом
void __fastcall TMainForm::PanelDblClick(TObject *Sender)
{
    TListView *Panel = (TListView*) Sender;
    TListItem *Item;
 
    Item = Panel->Items->Item[Panel->ItemIndex];
 
    if (Item != NULL)
        SelectFile (CurPanel, Item->Caption, (FILE_INFO*)Item->Data);
}
//---------------------------------------------------------------------------
// сортировка файлов по имени, каталоги вперед
void __fastcall TMainForm::PanelCompare(TObject *Sender, TListItem *Item1,
      TListItem *Item2, int Data, int &Compare)
{
    FILE_INFO *info1, *info2;
    info1 = (FILE_INFO*)Item1->Data;
    info2 = (FILE_INFO*)Item2->Data;
 
    if ((info1->attr & FILE_ATTRIBUTE_DIRECTORY) !=
        (info2->attr & FILE_ATTRIBUTE_DIRECTORY))
    {
        if (info1->attr & FILE_ATTRIBUTE_DIRECTORY)
            Compare = -1;
        else
            Compare = 1;
    }
    else
        Compare = strcmp(Item1->Caption.c_str(), Item2->Caption.c_str());
}
//---------------------------------------------------------------------------
// отрисовка, каталоги жирным, а файлы из группы зеленым
void __fastcall TMainForm::PanelCustomDrawItem(TCustomListView *Sender,
      TListItem *Item, TCustomDrawState State, bool &DefaultDraw)
{
    FILE_INFO *info;
    PANEL_INFO *p;
 
    p = (PanelLeft->panel == Sender)? PanelLeft : PanelRight;
 
    if ((info = (FILE_INFO*)Item->Data) != NULL && p)
    {
        if (info->attr & FILE_ATTRIBUTE_DIRECTORY)
            Sender->Canvas->Font->Style = TFontStyles() << fsBold;
 
        vector<int>::iterator i;
        i = find(p->group.begin(), p->group.end(), Item->Index);
        if (i != p->group.end())
            Sender->Canvas->Font->Color = clGreen;
    }
}
//---------------------------------------------------------------------------
// определяем наличие и тип дисков в системе
void __fastcall TMainForm::FillDrives()
{
    DWORD dwDrives;
    AnsiString asDrive;
    int i;
 
    cbDrives->Items->Clear();
 
    dwDrives = GetLogicalDrives();
 
    for (i=0; i<sizeof(dwDrives)*8; i++)
    {
        if (dwDrives & (1 << i))
        {
            asDrive = ((AnsiString)(char)('A'+i)) + ": ";
 
            switch (GetDriveType(asDrive.c_str()))
            {
                case DRIVE_FIXED:
                    asDrive += "жёсткий"; break;
                case DRIVE_REMOVABLE:
                    asDrive += "сменный"; break;
                case DRIVE_REMOTE:
                    asDrive += "сетевой"; break;
                case DRIVE_CDROM:
                    asDrive += "CD-ROM"; break;
                case DRIVE_RAMDISK:
                    asDrive += "RAM"; break;
 
            }
 
            cbDrives->Items->Add( asDrive );
        }
    }
}
//---------------------------------------------------------------------------
// делаем диск из списка текущим
void __fastcall TMainForm::SetCurrentDrive(PANEL_INFO *p, bool bUpdate)
{
    AnsiString asDrive, asPath;
    TNotifyEvent neSave;
    int i;
 
    asPath  = p->path;
    asDrive = asPath.SubString(1, asPath.AnsiPos(":")).UpperCase();
 
    for (i=0; i<cbDrives->Items->Count; i++)
    {
        if (cbDrives->Items->Strings[i].SubString(1,2) == asDrive)
        {
            if (!bUpdate)
            {
                neSave = cbDrives->OnChange;
                cbDrives->OnChange = NULL;
            }
 
            cbDrives->ItemIndex = i;
 
            if (!bUpdate)
                cbDrives->OnChange = neSave;
 
            break;
        }
    }
}
//---------------------------------------------------------------------------
// при выборе диска, обновляем содержимое панелей
void __fastcall TMainForm::cbDrivesChange(TObject *Sender)
{
    AnsiString asDrive = cbDrives->Items->Strings[cbDrives->ItemIndex].SubString(1,2);
 
    if (SetCurrentDirectory(asDrive.c_str()))
        GetCurrentDirectory(MAX_PATH, CurPanel->path);
    else
        MessageBox(Handle, "Не удается назначить диск", "Ошибка", MB_OK|MB_ICONERROR);
 
    FillPanel(CurPanel);
}
//---------------------------------------------------------------------------
// при изменении размеров формы, корректируем размер панели
void __fastcall TMainForm::FormResize(TObject *Sender)
{
    PanelLeft->panel->Width = ClientWidth / 2;
}
//---------------------------------------------------------------------------
// просмотр файла
void __fastcall TMainForm::DoView()
{
    // если файл выбран
    if (CurPanel->panel->ItemIndex != -1)
    {
        TListItem *Item = CurPanel->panel->Items->Item[CurPanel->panel->ItemIndex];
        FILE_INFO *info;
 
        // если это не возврат
        if (Item->Caption != ".." && (info = (FILE_INFO*)Item->Data) != NULL)
        {
            // если не каталог
            if (!(info->attr &  FILE_ATTRIBUTE_DIRECTORY))
            {
                try
                {
                    // открываем форму и загружаем содержимое
                    frmView->Caption = "Просмотр - " + Item->Caption;
                    frmView->mText->Lines->LoadFromFile(Item->Caption);
                    frmView->Show();
                }
                catch(Exception &E)
                {
                    MessageBox(Handle, "Не могу прочитать файл", "Ошибка", MB_OK|MB_ICONERROR);
                }
            }
        }
    }
}
//---------------------------------------------------------------------------
// копирование файла или группы файлов
void __fastcall TMainForm::DoCopy()
{
    PANEL_INFO *OppPanel = (CurPanel == PanelRight)? PanelLeft : PanelRight;
 
    // если файл выбран
    if (CurPanel->panel->ItemIndex != -1)
    {
        TListItem *Item = CurPanel->panel->Items->Item[CurPanel->panel->ItemIndex];
 
        // если это не возврат
        if (Item->Caption != "..")
        {
            // настраиваем диалог копирования
            if (CurPanel->group.size() > 0)
                frmCopy->lSource->Caption = IntToStr(MainForm->CurPanel->group.size()) + " файл(ов) в";
            else
                frmCopy->lSource->Caption = Item->Caption + " в";
 
            frmCopy->eTarget->Text = OppPanel->path;
 
            // показываем диалог, если пользователь выбрал OK
            if (frmCopy->ShowModal() == mrOk)
            {
                // если есть файлы в группе, то копируем файлы из группы
                if (CurPanel->group.size() > 0)
                {
                    for (int i=0; i<CurPanel->group.size(); i++)
                    {
                        Item = CurPanel->panel->Items->Item[CurPanel->group[i]];
                        CopyFileEx((AnsiString)CurPanel->path + "\\" + Item->Caption, OppPanel->path);
                    }
                }
                // иначе копируем текущий файл
                else
                    CopyFileEx((AnsiString)MainForm->CurPanel->path + "\\" + Item->Caption, OppPanel->path);
 
                // очищаем группу
                CurPanel->group.clear();
                // обновляем содержимое панелей
                FillPanel(OppPanel, ((OppPanel->panel->ItemFocused)? OppPanel->panel->ItemFocused->Caption.c_str() : ""));
            }
        }
    }
}
//---------------------------------------------------------------------------
//создание каталога
void __fastcall TMainForm::DoCreateDir()
{
    // показываем диалог, если пользователь выбрал ОК
    if (frmCreate->ShowModal() == mrOk)
    {
        // создаем каталог
        if (CreateDirectory(frmCreate->edPath->Text.c_str(), NULL))
        {
            // обновляем панель
            FillPanel(CurPanel, frmCreate->edPath->Text);
        }
        else
            MessageBox(Handle, "Не могу создать папку", "Ошибка", MB_OK|MB_ICONERROR);
    }
}
//---------------------------------------------------------------------------
// удаление файла или группы файлов
void __fastcall TMainForm::DoDelete()
{
    AnsiString asMessage, asPrevItem;
 
    // если файл выбран
    if (CurPanel->panel->ItemIndex != -1)
    {
        TListItem *Item = CurPanel->panel->Items->Item[CurPanel->panel->ItemIndex];
 
        // если не возврат
        if (Item->Caption != "..")
        {
            if (CurPanel->group.size() > 0)
                asMessage = "Удалить " + IntToStr(CurPanel->group.size()) + " файл(ов)";
            else
                asMessage = "Удалить " + Item->Caption;
 
            // если пользователь выбрал ОК
            if (MessageBox(Handle, asMessage.c_str(), "Удаление", MB_YESNO|MB_ICONQUESTION) == IDYES)
            {
                // если есть файлы в группе, то удаляем файлы из группы
                if (CurPanel->group.size() > 0)
                {
                    for (int i=0; i<CurPanel->group.size(); i++)
                    {
                        Item = CurPanel->panel->Items->Item[CurPanel->group[i]];
                        DeleteFileEx((AnsiString)CurPanel->path + "\\" + Item->Caption);
                    }
                }
                // иначе удаляем текущий файл
                else
                    DeleteFileEx((AnsiString)CurPanel->path + "\\" + Item->Caption);
 
                // обновляем панель
                if (CurPanel->panel->ItemIndex < CurPanel->panel->Items->Count-1)
                    asPrevItem = CurPanel->panel->Items->Item[CurPanel->panel->ItemIndex+1]->Caption;
                else if (CurPanel->panel->Items->Count > 1)
                    asPrevItem = CurPanel->panel->Items->Item[CurPanel->panel->Items->Count-2]->Caption;
 
                FillPanel(CurPanel, asPrevItem);
            }
        }
    }
}
//---------------------------------------------------------------------------
// рекурсивная функция копирования файлов и папок
void __fastcall TMainForm::CopyFileEx(AnsiString asSourse, AnsiString asTarget)
{
    WIN32_FIND_DATA wfd;
    char szPath[MAX_PATH];
    AnsiString asCurDir, asNewTarget;
    HANDLE hFind;
 
    // если копируем каталог
    if (GetFileAttributes(asSourse.c_str()) &  FILE_ATTRIBUTE_DIRECTORY)
    {
        // нельзя копировать папку саму в себя
        if (asTarget.UpperCase() != asSourse.UpperCase())
        {
            // путь для создания папки
            asNewTarget = asTarget + "\\" + ExtractFileName(asSourse);
 
            // если удалось создать папку
            if (CreateDirectory(asNewTarget.c_str(), NULL))
            {
                // сохраняем текущий путь
                GetCurrentDirectory(MAX_PATH, szPath);
 
                // заходим в копируемый каталог
                if (SetCurrentDirectory(asSourse.c_str()))
                {
                    // для всех файлов каталога рекурсивно
                    // вызываем копирование (эту же функцию)
                    if ((hFind = FindFirstFile("*.*", &wfd)) != INVALID_HANDLE_VALUE)
                    {
                        do
                        {
                            if ( wfd.cFileName[0] != '.' )
                                CopyFileEx(wfd.cFileName, asNewTarget);
                        }
                        while (FindNextFile(hFind, &wfd));
 
                        FindClose(hFind);
                    }
                }
                else
                    MessageBox(Handle, "Не могу скопировать папку", "Ошибка", MB_OK|MB_ICONERROR);
 
                // восстанавливаем путь
                SetCurrentDirectory(szPath);
            }
            else
                MessageBox(Handle, "Не могу создать папку", "Ошибка", MB_OK|MB_ICONERROR);
        }
        else
            MessageBox(Handle, "Нельзя копировать папку саму в себя", "Ошибка", MB_OK|MB_ICONERROR);
    }
    // иначе копируем файл
    else
    {
        asNewTarget = asTarget + "\\" + ExtractFileName(asSourse);
 
        if (!CopyFile(asSourse.c_str(), asNewTarget.c_str(), FALSE))
            MessageBox(Handle, "Не могу скопировать файл", "Ошибка", MB_OK|MB_ICONERROR);
    }
}
//---------------------------------------------------------------------------
// рекурсивная функция удаления файлов и папок
void __fastcall TMainForm::DeleteFileEx(AnsiString asFile)
{
    char szPath[MAX_PATH];
    WIN32_FIND_DATA wfd;
    HANDLE hFind;
 
    // если удаляем каталог
    if (GetFileAttributes(asFile.c_str()) &  FILE_ATTRIBUTE_DIRECTORY)
    {
        // запомним текущий каталог
        GetCurrentDirectory(MAX_PATH, szPath);
 
        // заходим в удаляемый каталог
        if (SetCurrentDirectory(asFile.c_str()))
        {
            // удаляем все файлы каталога
            // для всех файлов каталога рекурсивно
            // вызываем DeleteFileEx (эту же функцию)
            if ((hFind = FindFirstFile("*.*", &wfd)) != INVALID_HANDLE_VALUE)
            {
                do
                {
                    if ( wfd.cFileName[0] != '.')
                    {
                        if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                            DeleteFileEx(asFile + "\\" + (AnsiString)wfd.cFileName);
                        else
                        {
                            if (!DeleteFile(wfd.cFileName))
                                MessageBox(Handle, "Ошибка удаления файла", "Ошибка", MB_OK|MB_ICONERROR);
                        }
                    }
                }
                while (FindNextFile(hFind, &wfd));
 
                FindClose(hFind);
            }
        }
        else
            MessageBox(Handle, "Не могу удалить папку", "Ошибка", MB_OK|MB_ICONERROR);
 
        // востанавливаем путь
        SetCurrentDirectory(szPath);
 
        // удаляем пустой каталог
        if (!RemoveDirectory(asFile.c_str()))
            MessageBox(Handle, "Не могу удалить папку", "Ошибка", MB_OK|MB_ICONERROR);
    }
    // иначе удаляем файл
    else
    {
        if (!DeleteFile(asFile.c_str()))
            MessageBox(Handle, "Ошибка удаления файла", "Ошибка", MB_OK|MB_ICONERROR);
    }
 
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::actionHelpExecute(TObject *Sender)
{
    frmHelp->Show();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::actionViewExecute(TObject *Sender)
{
    DoView();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::actionCopyExecute(TObject *Sender)
{
    DoCopy();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::actionCreateExecute(TObject *Sender)
{
    DoCreateDir();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::actionDeleteExecute(TObject *Sender)
{
    DoDelete();
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::mAboutClick(TObject *Sender)
{
    MessageBox(Handle, "Файловый менеджер", "О программе", MB_OK|MB_ICONINFORMATION);
}
//---------------------------------------------------------------------------
void __fastcall TMainForm::mExitClick(TObject *Sender)
{
    Close();
}
//---------------------------------------------------------------------------