librarypage.cpp

Last change: 2008-02-03 This is the source code of KCeasy。

}

void __fastcall TLibraryForm::FileTreeHeaderClick(TVTHeader *Sender,
      TColumnIndex Column, TMouseButton Button, TShiftState Shift, int X,
      int Y)
{
    if(Button != mbLeft)
        return;
    if(Sender->SortColumn != Column) {
        Sender->SortColumn = Column;
        Sender->SortDirection = sdAscending;
    } else {
        Sender->SortDirection = (Sender->SortDirection == sdAscending) ? sdDescending : sdAscending;
    }
}

void __fastcall TLibraryForm::FileTreeHeaderDragged(TVTHeader *Sender,
      TColumnIndex Column, int OldPosition)
{
    // make sure the tree is always in the first column
    Sender->MainColumn = Sender->Columns->GetFirstVisibleColumn();
}

void __fastcall TLibraryForm::FileTreeHeaderPopupPopup(TObject *Sender)
{
    TMenuItem* Items = ((TVTHeaderPopupMenu*)Sender)->Items;
    // disable hiding of column which contains the tree
    for(int i=0;i<Items->Count;i++) {
        if(Items->Items[i]->Tag == FileTree->Header->MainColumn) {
            Items->Items[i]->Enabled = false;
            break;
        }
    }
}

void __fastcall TLibraryForm::FileTreeFocusChanged(TBaseVirtualTree *Sender,
          PVirtualNode Node, TColumnIndex Column)
{
    if(!Node) {
        FilePlayBtn->Enabled = false;
        FileShowDetails(NULL);
    } else {
        FilePlayBtn->Enabled = true;
        FileShowDetails(((TFileNodeData*)FileTree->GetNodeData(Node))->File);
    }
}

void __fastcall TLibraryForm::FileTreeChange(TBaseVirtualTree *Sender,
      PVirtualNode Node)
{
    FileDeleteBtn->Enabled = (FileTree->SelectedCount > 0);
}
//---------------------------------------------------------------------------

string __fastcall TLibraryForm::GetFileTreeColumnKey(TFolderNodeData::TFolderType Type)
{
    string Key = "tree_columns/library_";
    switch(Type) {
    case TFolderNodeData::Audio:           Key += "audio"; break;
    case TFolderNodeData::Video:           Key += "video"; break;
    case TFolderNodeData::Images:          Key += "images"; break;
    case TFolderNodeData::Documents:       Key += "documents"; break;
    case TFolderNodeData::Software:        Key += "software"; break;
    case TFolderNodeData::Torrents:        Key += "torrents"; break;
    case TFolderNodeData::Unknown:         Key += "unknown"; break;
    case TFolderNodeData::RecentDownloads: Key += "recent"; break;
    case TFolderNodeData::All:
    case TFolderNodeData::Shares:
    case TFolderNodeData::Collections:
    default:                               Key += "all"; break;
    }

    return Key;
}

void __fastcall TLibraryForm::SaveFileTreeColumns()
{
    if(!FolderTree->FocusedNode)
        return;
    TFolderNodeData* NodeData = (TFolderNodeData*)FolderTree->GetNodeData(FolderTree->FocusedNode);
    // save column positions specific for this folder
    Config->SetValue(GetFileTreeColumnKey(NodeData->Type),VTGetColumnSettings(FileTree));
}

void __fastcall TLibraryForm::FileTreeHeaderMouseUp(TVTHeader *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
    // the user most likely changed something in the header, save it now
    SaveFileTreeColumns();
}

void __fastcall TLibraryForm::FileTreeHeaderPopupColumnChange(
      const TBaseVirtualTree *Sender, const TColumnIndex Column,
      bool Visible)
{
    // save new visibility state
    SaveFileTreeColumns();
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeEditing(TBaseVirtualTree *Sender,
      PVirtualNode Node, TColumnIndex Column, bool &Allowed)
{
    TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(Node))->File;

    // only allow editing if path is accessible
    if (Column != 0 || !PathMapper->PathUsable(File->FileDir))
        Allowed = false;
}

void __fastcall TLibraryForm::FileTreeNewText(TBaseVirtualTree *Sender,
      PVirtualNode Node, TColumnIndex Column, WideString NewText)
{
    TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(Node))->File;
    string NewFileName = AnsiString(NewText).c_str();
    string OldPath = File->FileDir + "/" + File->FileName;
    string NewPath = File->FileDir + "/" + NewFileName;

    if (Column != 0 || NewFileName.empty())
        return;

    // try to rename file
    if (PathMapper->PathUsable(OldPath) &&
        PathMapper->PathUsable(NewPath) &&
        MoveFile(PathMapper->Map(OldPath).c_str(),PathMapper->Map(NewPath).c_str()))
    {
        // tell engine the share was renamed
        Engine->GetShares()->RenameFile(File, NewFileName);
    } else {
        // TRANSLATOR: Message box when renaming file in library failed.
        MessageDlg(AnsiString::Format(_("Couldn't rename file \'%s\'."),
                   ARRAYOFCONST((File->FileName.c_str()))),
                   mtError,TMsgDlgButtons() << mbOK,0);
        // we didn't change the share so the tree will update itself to the
        // previous caption after editing.
    }
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeGetUserClipboardFormats(
      TBaseVirtualTree *Sender, TFormatEtcArray &Formats)
{
    TFormatEtc FormatEtc;

    FormatEtc.cfFormat = CF_HDROP;
    FormatEtc.ptd = NULL;
    FormatEtc.dwAspect =  DVASPECT_CONTENT;
    FormatEtc.lindex = -1;
    FormatEtc.tymed = TYMED_HGLOBAL;

    Formats.Length++;
    Formats[Formats.Length-1] = FormatEtc;
}

void __fastcall TLibraryForm::FileTreeRenderOLEData(
      TBaseVirtualTree *Sender, const tagFORMATETC &FormatEtcIn,
      tagSTGMEDIUM &Medium, bool ForClipboard, HRESULT &Result)
{
    Result = E_FAIL;

    if(Sender != FileTree || FormatEtcIn.cfFormat != CF_HDROP)
        return;

    // collect selected/copied file names
    string FilesStr;
    int Files = 0;
    TVirtualNode* Node = ForClipboard ? FileTree->GetFirstCutCopy() : FileTree->GetFirstSelected();

    while(Node) {
        TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(Node))->File;
        string Path = File->FileDir + "/" + File->FileName;
        if(PathMapper->PathUsable(Path)) {
            FilesStr += PathMapper->Map(Path);
            FilesStr.append(1,'\0');
            Files++;
        }
        Node = ForClipboard ? FileTree->GetNextCutCopy(Node) : FileTree->GetNextSelected(Node);
    }
    FilesStr.append(1,'\0');

    if(Files == 0)
        return;

    // copy filenames to medium
    TStgMedium StgMedium;
    StgMedium.tymed = TYMED_HGLOBAL;
    StgMedium.pUnkForRelease = NULL;

    if((StgMedium.hGlobal = GlobalAlloc(GMEM_SHARE,FilesStr.size() + sizeof(TDropFiles))) == NULL)
        return;

    TDropFiles* DropFiles;
    if((DropFiles = (TDropFiles*)GlobalLock(StgMedium.hGlobal)) == NULL) {
        GlobalFree(StgMedium.hGlobal);
        return;
    }

    DropFiles->pFiles = sizeof(TDropFiles);
    DropFiles->pt.x = DropFiles->pt.y = 0;
    DropFiles->fNC = FALSE;
    DropFiles->fWide = FALSE;
    CopyMemory(((char*)DropFiles)+sizeof(TDropFiles),FilesStr.data(),FilesStr.size());
    GlobalUnlock(StgMedium.hGlobal);

    Medium = StgMedium;
    Result = S_OK;
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeKeyAction(TBaseVirtualTree *Sender,
      WORD &CharCode, TShiftState &Shift, bool &DoDefault)
{
    if(Shift.Contains(ssCtrl) && CharCode == 'C') {
        CopyFileMnuClick(NULL);
        DoDefault = false;
    }

    if(!Shift.Empty())
        return;

    switch (CharCode) {
    case VK_RETURN:
        PlayFileMnuClick(NULL);
        DoDefault = false;
        break;
    case VK_DELETE:
        DeleteFileMnuClick(NULL);
        DoDefault = false;
        break;
    case VK_F5:
        ResyncSharesMnuClick(NULL);
        DoDefault = false;
        break;
    }
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeGetPopupMenu(
      TBaseVirtualTree *Sender, PVirtualNode Node, TColumnIndex Column,
      const TPoint &P, bool &AskParent, TPopupMenu *&PopupMenu)
{
    ResyncSharesMnu->Enabled = true;
    HideSharesMnu->Enabled = true;
    HideSharesMnu->Checked = Engine->GetShares()->IsHidden();

    PlayFileMnu->Enabled = false;
    PlayFileMnu->Visible = true;
    LaunchTorrentMnu->Enabled = false;
    LaunchTorrentMnu->Visible = false;
    GoogleLyricsMnu->Enabled = false;
    GoogleLyricsMnu->Visible = false;
    FindOnYouTubeMnu->Enabled = false;
    FindOnYouTubeMnu->Visible = false;
    PlayFileMnu->Default = true;

    CopyFileMnu->Enabled = false;
    DeleteFileMnu->Enabled = false;
    RenameFileMnu->Enabled = false;
    ExploreFileMnu->Enabled = false;
    OpenFileExternallyMnu->Enabled = false;

    if(Node) {
        TFileNodeData* NodeData = (TFileNodeData*)FileTree->GetNodeData(Node);
        bool PathUsable = PathMapper->PathUsable(NodeData->File->FileDir);

        if(NodeData->File->FileType == FTTorrent) {
            PlayFileMnu->Visible = false;
            LaunchTorrentMnu->Visible = true;
            LaunchTorrentMnu->Default = true;
        }

        if(NodeData->File->FileType == FTAudio) {
            GoogleLyricsMnu->Enabled = true;
            GoogleLyricsMnu->Visible = true;
            FindOnYouTubeMnu->Enabled = true;
            FindOnYouTubeMnu->Visible = true;
        }

        PlayFileMnu->Enabled = PathUsable &&
                               (NodeData->File->FileType == FTAudio || NodeData->File->FileType == FTVideo);

        LaunchTorrentMnu->Enabled = PathUsable && NodeData->File->FileType == FTTorrent;

        CopyFileMnu->Enabled = PathUsable;
        DeleteFileMnu->Enabled = PathUsable;
        RenameFileMnu->Enabled = PathUsable;
        ExploreFileMnu->Enabled = PathUsable;
        OpenFileExternallyMnu->Enabled = PathUsable;
    }

    PopupMenu = FilePopup;
}

// this also gets called on double click in the FileTree window and when
// clicking on FilePlayBtn
void __fastcall TLibraryForm::PlayFileMnuClick(TObject *Sender)
{
    if(!FileTree->FocusedNode)
        return;

    TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(FileTree->FocusedNode))->File;

    if(File->FileType != FTAudio && File->FileType != FTVideo)
        return;

    if(Config->GetValueInt("player/always_use_external")) {
        OpenFileExternallyMnuClick(Sender);
        return;
    }

    string Path = File->FileDir + "/" + File->FileName;

    if(!PathMapper->PathUsable(Path))
        return;

    PlayerForm->PlayFile(PathMapper->Map(Path));

    if(File->FileType == FTVideo)
        MainForm->SetVisiblePage(PlayerForm);
}

void __fastcall TLibraryForm::LaunchTorrentMnuClick(TObject *Sender)
{
    if(!FileTree->FocusedNode)
        return;

    TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(FileTree->FocusedNode))->File;
    string Path = File->FileDir + "/" + File->FileName;

    if(File->FileType != FTTorrent)
            return;

    if(!PathMapper->PathUsable(Path))
        return;
    Path = PathMapper->Map(Path);

    if(TFileLauncher::IsFileTooDangerous(Path) || TFileLauncher::IsFileDangerous(Path))
        return;