librarypage.cpp

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

            return Node;
    }

    return NULL;
}

void __fastcall TLibraryForm::FolderTreeFreeNode(TBaseVirtualTree *Sender,
      PVirtualNode Node)
{
    // call TFolderNodeData destructor
    ((TFolderNodeData*)FolderTree->GetNodeData(Node))->~TFolderNodeData();
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FolderTreeGetText(TBaseVirtualTree *Sender,
      PVirtualNode Node, TColumnIndex Column, TVSTTextType TextType,
      WideString &CellText)
{
    if(TextType != ttNormal || Column != 0)
        return;
    TFolderNodeData* NodeData = (TFolderNodeData*)Sender->GetNodeData(Node);
    if(NodeData->CaptionNumber > 0)
        CellText = (NodeData->Caption + " (" + int_to_string(NodeData->CaptionNumber) + ")").c_str();
    else
        CellText = NodeData->Caption.c_str();
}

void __fastcall TLibraryForm::FolderTreeGetImageIndex(
      TBaseVirtualTree *Sender, PVirtualNode Node, TVTImageKind Kind,
      TColumnIndex Column, bool &Ghosted, int &ImageIndex)
{
    if(Column != 0)
        return;

    if(Kind == ikNormal || Kind == ikSelected)
        ImageIndex = ((TFolderNodeData*)Sender->GetNodeData(Node))->ImageIndex;
    else
        ImageIndex = -1;
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FolderTreeFocusChanging(
      TBaseVirtualTree *Sender, PVirtualNode OldNode, PVirtualNode NewNode,
      TColumnIndex OldColumn, TColumnIndex NewColumn, bool &Allowed)
{
    if(OldNode && ((TFolderNodeData*)FolderTree->GetNodeData(OldNode))->ImageIndex == OpenFolderImageIndex) {
        ((TFolderNodeData*)FolderTree->GetNodeData(OldNode))->ImageIndex = ClosedFolderImageIndex;
        FolderTree->InvalidateNode(OldNode);
    }
    if(NewNode && ((TFolderNodeData*)FolderTree->GetNodeData(NewNode))->ImageIndex == ClosedFolderImageIndex) {
        ((TFolderNodeData*)FolderTree->GetNodeData(NewNode))->ImageIndex = OpenFolderImageIndex;
        FolderTree->InvalidateNode(NewNode);
    }
    FileTree->FocusedNode = NULL;
}

void __fastcall TLibraryForm::FolderTreeChange(TBaseVirtualTree *Sender,
      PVirtualNode Node)
{
    FileTree->BeginUpdate();
    FileTree->FocusedNode = NULL;
    FileTree->ClearSelection();
    // recheck all files
    for(TVirtualNode* Node = FileTree->GetFirst(); Node; Node = FileTree->GetNextSibling(Node))
        FileTree->IsVisible[Node] = FileNodeVisible(Node);
    FileTree->EndUpdate();
    // load column positions specific for this folder
    TFolderNodeData* NodeData = (TFolderNodeData*)FolderTree->GetNodeData(Node);
    if(Node)
        VTSetColumnSettings(FileTree,Config->GetValue(GetFileTreeColumnKey(NodeData->Type)));
    else
        VTSetColumnSettings(FileTree,Config->GetValue(GetFileTreeColumnKey(TFolderNodeData::All)));
}
//---------------------------------------------------------------------------
// FileTree

bool __fastcall TLibraryForm::FileNodeVisible(TVirtualNode* Node)
{
    if(!FolderTree->FocusedNode)
        return false;
    TFolderNodeData* FolderNodeData = (TFolderNodeData*)FolderTree->GetNodeData(FolderTree->FocusedNode);
    TSharedFile* File = ((TFileNodeData*)FileTree->GetNodeData(Node))->File;

    // check if file is in this folder
    switch(FolderNodeData->Type) {
    case TFolderNodeData::Shares:
    case TFolderNodeData::Collections:
        return false;
    case TFolderNodeData::All:
        break;
    case TFolderNodeData::Audio:
    case TFolderNodeData::Video:
    case TFolderNodeData::Images:
    case TFolderNodeData::Documents:
    case TFolderNodeData::Software:
    case TFolderNodeData::Torrents:
    case TFolderNodeData::Unknown:
        if(FolderNodeData->Type != File->FileType)
            return false;
        break;
    case TFolderNodeData::RecentDownloads:
        if(!File->AddedManually)
            return false;
        break;
    }

    // apply filter
    static char Value[1024];

    if(FilterKeyCombo->ItemIndex <= 0 || FilterEdit->Text.Length() == 0)
        return true;

    string Key = FilterKeyCombo->Text.LowerCase().c_str();
    string Filter = FilterEdit->Text.LowerCase().c_str();

    // TODO: localization

    if(Key == "Everything") {
        // all keys
        // check filename
        strncpy(Value,File->FileName.c_str(),1024)[1023] = 0;
        strlwr(Value);

        if(strstr(Value,Filter.c_str()))
            return true;

        // check all meta data
        for(TMetaData::Iterator itr = File->MetaData.Begin();itr!=File->MetaData.End();++itr) {
            strncpy(Value,(*itr).Value.c_str(),1024)[1023] = 0;
            strlwr(Value);
            if(strstr(Value,Filter.c_str()))
                return true;
        }

        return false;

    } else if(Key == "size" || Key == "bitrate" || Key == "mediasize") {
        // integer cmp
        enum { gt, lt, eq } FilterCmp;
        int FilterInt;
        int ValueInt;

        // get cmp mode and integer
        if(Filter[0] == '>') {
            FilterCmp = gt;
            FilterInt = string_to_int(Filter.substr(1));
        } else if(Filter[0] == '<') {
            FilterCmp = lt;
            FilterInt = string_to_int(Filter.substr(1));
        } else {
            FilterCmp = eq;
            FilterInt = string_to_int(Filter);
        }

        // prepare integer to check
        if(Key == "size")
            ValueInt = File->FileSize / 1024 / 1024; // MB
        else if (Key == "mediasize")
            ValueInt = File->MetaData.GetInt("mediasize") / 1024 / 1024; // MB
        else if (Key == "bitrate")
            ValueInt = File->MetaData.GetInt("bitrate") / 1000; // kbps
        else
            ValueInt = 0; // cannot happen

        // do the actual compare
        switch(FilterCmp) {
            case eq: return (ValueInt == FilterInt);
            case gt: return (ValueInt >= FilterInt);
            case lt: return (ValueInt <= FilterInt);
        }
    } else {
        // substr cmp
        if(Key == "filename")
            strncpy(Value,File->FileName.c_str(),1024)[1023] = 0;
        else
            strncpy(Value,File->MetaData.Get(Key.c_str()).c_str(),1024)[1023] = 0;
        strlwr(Value);

        if(strstr(Value,Filter.c_str()))
            return true;

        return false;
    }

    return false;
}

void __fastcall TLibraryForm::FilterEditChange(TObject *Sender)
{
    FileTree->BeginUpdate();
    // recheck all files
    for(TVirtualNode* Node = FileTree->GetFirst(); Node; Node = FileTree->GetNextSibling(Node))
        FileTree->IsVisible[Node] = FileNodeVisible(Node);
    FileTree->EndUpdate();
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeGetText(TBaseVirtualTree *Sender,
      PVirtualNode Node, TColumnIndex Column, TVSTTextType TextType,
      WideString &CellText)
{
    if(TextType != ttNormal)
        return;
    TSharedFile* File = ((TFileNodeData*)Sender->GetNodeData(Node))->File;

    switch(Column) {
    case 0: // file name
        CellText = File->FileName.c_str(); break;
    case 1: // path
        CellText = File->FileDir.c_str(); break;
    case 2: // media type
        switch(File->FileType) {
        case FTAudio:       CellText = _("Audio");    break; // TRANSLATOR: Library media type
        case FTVideo:       CellText = _("Video");    break; // TRANSLATOR: Library media type
        case FTImage:       CellText = _("Image");    break; // TRANSLATOR: Library media type
        case FTDocument:    CellText = _("Document"); break; // TRANSLATOR: Library media type
        case FTSoftware:    CellText = _("Software"); break; // TRANSLATOR: Library media type
        case FTTorrent:     CellText = _("Torrent");  break; // TRANSLATOR: Library media type
        case FTUnknown:     CellText = _("Unknown");  break; // TRANSLATOR: Library media type
        }
        break;
    case 3: // file size
        CellText = FormatNumber(File->FileSize,"B",2).c_str(); break;
    case 4: // title
        CellText = File->MetaData.Get("title").c_str(); break;
    case 5: // artist
        CellText = File->MetaData.Get("artist").c_str(); break;
    case 6: // album
        CellText = File->MetaData.Get("album").c_str(); break;
    case 7: // length
        if (File->MetaData.GetInt("duration") > 0)
            CellText = FormatTime(File->MetaData.GetInt("duration")).c_str();
        break;
    case 8: // bitrate
        if (File->MetaData.GetInt("bitrate") > 0)
            CellText = FormatNumber(File->MetaData.GetInt("bitrate")/1000,"",-1).c_str();
        break;
    case 9: // resolution
        if(File->MetaData.Exists("width"))
            CellText = WideString(File->MetaData.Get("width").c_str()) + "x" + File->MetaData.Get("height").c_str();
        break;
    case 10: // track
        CellText = File->MetaData.Get("track").c_str(); break;
    case 11: // comment
        CellText = File->MetaData.Get("comment").c_str(); break;
    case 12: // media size
    {
        int MediaSize = File->MetaData.GetInt("mediasize");
        if(MediaSize > 0)
            CellText = FormatNumber(MediaSize,"B",2).c_str(); break;
    }
    case 13: // creation date
        CellText = File->MetaData.Get("creationdate").c_str(); break;
    case 14: // tracker (announce)
        CellText = File->MetaData.Get("announce").c_str(); break;
    }
}

void __fastcall TLibraryForm::FileTreeGetImageIndex(
      TBaseVirtualTree *Sender, PVirtualNode Node, TVTImageKind Kind,
      TColumnIndex Column, bool &Ghosted, int &ImageIndex)
{
    if(FileTree->Header->MainColumn != Column)
        return;

    if(Kind == ikNormal || Kind == ikSelected)
        ImageIndex = ((TFileNodeData*)Sender->GetNodeData(Node))->ImageIndex;
    else
        ImageIndex = -1;
}
//---------------------------------------------------------------------------

void __fastcall TLibraryForm::FileTreeCompareNodes(
      TBaseVirtualTree *Sender, PVirtualNode Node1, PVirtualNode Node2,
      TColumnIndex Column, int &Result)
{
    TSharedFile* File1 = ((TFileNodeData*)Sender->GetNodeData(Node1))->File;
    TSharedFile* File2 = ((TFileNodeData*)Sender->GetNodeData(Node2))->File;

    if(!File1 || !File2)
        return;

    switch(Column) {
    case 0: Result = strcmpi(File1->FileName.c_str(),File2->FileName.c_str()); break;
    case 1: Result = strcmpi(File1->FileDir.c_str(),File2->FileDir.c_str()); break;
    case 2: Result = (File1->FileType < File2->FileType) ? -1 : (File1->FileType > File2->FileType); break;
    case 3: Result = (File1->FileSize == File2->FileSize) ? 0 : (File1->FileSize < File2->FileSize) ? -1 : 1; break;
    case 4: Result = strcmpi(File1->MetaData.Get("title").c_str(),File2->MetaData.Get("title").c_str()); break;
    case 5: Result = strcmpi(File1->MetaData.Get("artist").c_str(),File2->MetaData.Get("artist").c_str()); break;
    case 6: Result = strcmpi(File1->MetaData.Get("album").c_str(),File2->MetaData.Get("album").c_str()); break;
    case 7: {
        int a = File1->MetaData.GetInt("duration");
        int b = File2->MetaData.GetInt("duration");
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 8: {
        int a = File1->MetaData.GetInt("bitrate");
        int b = File2->MetaData.GetInt("bitrate");
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 9: {
        // sort by total pixel count
        int a = File1->MetaData.GetInt("width") * File1->MetaData.GetInt("height");
        int b = File2->MetaData.GetInt("width") * File2->MetaData.GetInt("height");
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 10: {
        int a = File1->MetaData.GetInt("track");
        int b = File2->MetaData.GetInt("track");
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 11: Result = strcmpi(File1->MetaData.Get("comment").c_str(),File2->MetaData.Get("comment").c_str()); break;
    case 12: {
        int a = File1->MetaData.GetInt("mediasize");
        int b = File2->MetaData.GetInt("mediasize");
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 13: Result = strcmpi(File1->MetaData.Get("creationdate").c_str(),File2->MetaData.Get("creationdate").c_str()); break;
    case 14: Result = strcmpi(File1->MetaData.Get("announce").c_str(),File2->MetaData.Get("announce").c_str()); break;
    default: Result = 0;
    }
}

void __fastcall TLibraryForm::FileTreeIncrementalSearch(
      TBaseVirtualTree *Sender, PVirtualNode Node,
      const WideString SearchText, int &Result)
{
    if(!Node)
        return;
    TSharedFile* File = ((TFileNodeData*)Sender->GetNodeData(Node))->File;

    AnsiString SearchTerm(SearchText);
    AnsiString FileName = File->FileName.substr(0,SearchTerm.Length()).c_str();
    Result = stricmp(SearchTerm.c_str(), FileName.c_str());