transferpage.cpp

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

    if(!Upload->GetMetaData().Empty()) {
        HintText += WideString("\n--");
        for(TMetaData::Iterator itr=Upload->GetMetaData().Begin();itr!=Upload->GetMetaData().End();++itr)
            HintText += WideString("\n") + (*itr).Name.c_str() + ": " + (*itr).Value.c_str();
    }
}
//---------------------------------------------------------------------------

void __fastcall TTransferForm::UploadTreeCompareNodes(
      TBaseVirtualTree *Sender, PVirtualNode Node1, PVirtualNode Node2,
      TColumnIndex Column, int &Result)
{
    TUploadNodeData* NodeData1 = (TUploadNodeData*)Sender->GetNodeData(Node1);
    TUploadNodeData* NodeData2 = (TUploadNodeData*)Sender->GetNodeData(Node2);
    TUpload* Upload1 = NodeData1->Upload;
    TUpload* Upload2 = NodeData2->Upload;

    if(!Upload1 || !Upload2)
        return;

    switch(Column) {
    case 0: Result = strcmpi(Upload1->GetFileName().c_str(),Upload2->GetFileName().c_str()); break;
    case 1: Result = strcmpi(Upload1->GetSource()->GetUser()->GetSmartName().c_str(),Upload2->GetSource()->GetUser()->GetSmartName().c_str()); break;
    case 2: Result = strcmpi(Upload1->GetNetwork().c_str(),Upload2->GetNetwork().c_str()); break;
    case 3: {
        double a = ((double)Upload1->GetTransmitted()) / Upload1->GetFileSize();
        double b = ((double)Upload2->GetTransmitted()) / Upload2->GetFileSize();
        Result = (a < b) ? -1 : (a > b);
        break;
    }
    case 4: Result = (Upload1->GetState() < Upload2->GetState()) ? -1 : (Upload1->GetState() > Upload2->GetState()); break;
    case 5: Result = (Upload1->GetSource()->Size < Upload2->GetSource()->Size) ? -1 : (Upload1->GetSource()->Size > Upload2->GetSource()->Size); break;
    case 6: Result = (Upload1->GetThroughput() < Upload2->GetThroughput()) ? -1 : (Upload1->GetThroughput() > Upload2->GetThroughput()); break;
    case 7: Result = (Upload1->GetTimeLeft() < Upload2->GetTimeLeft()) ? -1 : (Upload1->GetTimeLeft() > Upload2->GetTimeLeft()); break;
    case 8: Result = strcmpi(Upload1->GetMetaData().Get("title").c_str(),Upload2->GetMetaData().Get("title").c_str()); break;
    case 9: Result = strcmpi(Upload1->GetMetaData().Get("artist").c_str(),Upload2->GetMetaData().Get("artist").c_str()); break;
    default: Result = 0;
    }
}

void __fastcall TTransferForm::UploadTreeHeaderClick(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 TTransferForm::UploadTreeAfterCellPaint(
      TBaseVirtualTree *Sender, TCanvas *TargetCanvas, PVirtualNode Node,
      TColumnIndex Column, TRect &CellRect)
{
    if(Column != 3) // progress column
        return;
    TUpload* Upload = ((TUploadNodeData*)Sender->GetNodeData(Node))->Upload;

    if(Upload->GetState() != TUpload::Uploading)
        return;

    TRect Rect(CellRect);
    // erase background
    Rect.Left += 1; Rect.Top += 2; Rect.Right -= 2; Rect.Bottom -= 2;
    TargetCanvas->Brush->Color = clWindow;
    TargetCanvas->FillRect(Rect);
    // draw box
    TargetCanvas->Brush->Color = TColor(0x00000000);
    TargetCanvas->FrameRect(Rect);
    // draw bar
    Rect.Left += 2; Rect.Top += 2; Rect.Right -= 2; Rect.Bottom -= 2;
    Rect.Right = Rect.Left + ((double)Upload->GetSource()->Transmitted) / Upload->GetSource()->Size * Rect.Width();
    TargetCanvas->Brush->Color = TColor(0x00FF0000);
    TargetCanvas->FillRect(Rect);
}

void __fastcall TTransferForm::UploadTreeScroll(TBaseVirtualTree *Sender,
      int DeltaX, int DeltaY)
{
    // workaround for paint problem with focused nodes on scrolling
/*
    if(Sender->FocusedNode && DeltaX != 0)
        Sender->InvalidateNode(Sender->FocusedNode);
*/
}

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

void __fastcall TTransferForm::UploadHeaderPopupPopup(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 == UploadTree->Header->MainColumn) {
            Items->Items[i]->Enabled = false;
            break;
        }
    }
}

void __fastcall TTransferForm::UploadTreeKeyPress(TObject *Sender,
      char &Key)
{
    if(Key == 13)
        PlayUploadMnuClick(NULL);
}

void __fastcall TTransferForm::UploadTreeDblClick(TObject *Sender)
{
    PlayUploadMnuClick(NULL);
}
//---------------------------------------------------------------------------

void __fastcall TTransferForm::UploadActionBtnClick(TObject *Sender)
{
    TPoint Pt = TPoint(UploadActionBtn->Left + UploadActionBtn->Width,
                       UploadActionBtn->Top + UploadActionBtn->Height);
    Pt = UploadActionBtn->Parent->ClientToScreen(Pt);
    UpdateUploadPopup(UploadTree->FocusedNode);
    UploadPopup->Alignment = paRight;
    UploadPopup->Popup(Pt.x,Pt.y);
}

void __fastcall TTransferForm::UploadTreeGetPopupMenu(
      TBaseVirtualTree *Sender, PVirtualNode Node, TColumnIndex Column,
      const TPoint &P, bool &AskParent, TPopupMenu *&PopupMenu)
{
    UploadPopup->Alignment = paLeft;
    UpdateUploadPopup(Node);
    PopupMenu = UploadPopup;
}

void __fastcall TTransferForm::UpdateUploadPopup (TVirtualNode* Node)
{
    // general
    ClearUploadsMnu->Enabled = false;
    CancelAllUploadsMnu->Enabled = false;
    Engine->LockUploads();
    TEngine::TUploadIterator itr = Engine->GetUploadsBegin();
    for(;itr != Engine->GetUploadsEnd();++itr) {
        CancelAllUploadsMnu->Enabled = CancelAllUploadsMnu->Enabled ||
                                       (*itr)->GetState() == TUpload::Uploading ||
                                       (*itr)->GetState() == TUpload::Queued;
        ClearUploadsMnu->Enabled = ClearUploadsMnu->Enabled ||
                                   (*itr)->GetState() == TUpload::Completed ||
                                   (*itr)->GetState() == TUpload::Cancelled;
    }
    Engine->ReleaseUploads();
    // node specific
    PlayUploadMnu->Visible = true;
    PlayUploadMnu->Enabled = false;
    PlayUploadMnu->Default = true;
    LaunchTorrentUploadMnu->Visible = false;
    LaunchTorrentUploadMnu->Enabled = false;
    OpenExternallyUploadMnu->Visible = true;
    OpenExternallyUploadMnu->Enabled = false;

    CancelUploadMnu->Enabled = false;
    FindMoreFromUserUploadMnu->Enabled = false;

    if(Node) {
        TUpload* Upload = ((TUploadNodeData*)UploadTree->GetNodeData(Node))->Upload;
        bool PathUsable = PathMapper->PathUsable(Upload->GetPath());

        if(Upload->GetFileType() == FTTorrent) {
                PlayUploadMnu->Visible = false;
                OpenExternallyUploadMnu->Visible = false;
                LaunchTorrentUploadMnu->Visible = true;
                LaunchTorrentUploadMnu->Default = true;
        }

        PlayUploadMnu->Enabled = PathUsable &&
                                 (Upload->GetFileType() == FTAudio || Upload->GetFileType() == FTVideo);

        LaunchTorrentUploadMnu->Enabled = PathUsable && Upload->GetFileType() == FTTorrent;

        OpenExternallyUploadMnu->Enabled = PathUsable;
        FindMoreFromUserUploadMnu->Enabled = true;
    }

    for(Node = UploadTree->GetFirstSelected();Node;Node = UploadTree->GetNextSelected(Node)) {
        TUpload* Upload = ((TUploadNodeData*)UploadTree->GetNodeData(Node))->Upload;
        CancelUploadMnu->Enabled = CancelUploadMnu->Enabled ||
                                   Upload->GetState() == TUpload::Uploading ||
                                   Upload->GetState() == TUpload::Queued;
    }
}
//---------------------------------------------------------------------------

void __fastcall TTransferForm::PlayUploadMnuClick(TObject *Sender)
{
    if(!UploadTree->FocusedNode)
        return;
    TUpload* Upload = ((TUploadNodeData*)UploadTree->GetNodeData(UploadTree->FocusedNode))->Upload;

    if(Upload->GetFileType() != FTAudio && Upload->GetFileType() != FTVideo)
        return;

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

    if(!PathMapper->PathUsable(Upload->GetPath()))
        return;

    if(!PlayerForm->PlayFile(PathMapper->Map(Upload->GetPath())))
        return;

    // switch page if video
    if(Upload->GetFileType() == FTVideo)
        MainForm->SetVisiblePage(PlayerForm);
}

void __fastcall TTransferForm::LaunchTorrentUploadMnuClick(
      TObject *Sender)
{
    if(!UploadTree->FocusedNode)
        return;
    TUpload* Upload = ((TUploadNodeData*)UploadTree->GetNodeData(UploadTree->FocusedNode))->Upload;

    if(Upload->GetFileType() != FTTorrent)
        return;

    if(!PathMapper->PathUsable(Upload->GetPath()))
        return;

    string Path = PathMapper->Map(Upload->GetPath());

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

    if(!TFileLauncher::LaunchFile(Path))
        TFileLauncher::ShowTorrentLaunchFailedMsg(Path);
}

void __fastcall TTransferForm::OpenExternallyUploadMnuClick(
      TObject *Sender)
{
    if(!UploadTree->FocusedNode)
        return;
    TUpload* Upload = ((TUploadNodeData*)UploadTree->GetNodeData(UploadTree->FocusedNode))->Upload;

    if(!PathMapper->PathUsable(Upload->GetPath()))
        return;

    string Path = PathMapper->Map(Upload->GetPath());

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

    if(TFileLauncher::IsFileDangerous(Path)) {
        if(!TFileLauncher::UserWantsToLaunch(Path))
            return;
    }

    if(!TFileLauncher::LaunchFile(Path))
        TFileLauncher::ShowLaunchFailedMsg(Path);
}

void __fastcall TTransferForm::CancelUploadMnuClick(TObject *Sender)
{
    list<TUpload*> Uploads;
    AnsiString FilesStr;

    // collect list of uploads to cancel
    for(TVirtualNode* Node = UploadTree->GetFirstSelected();Node;Node = UploadTree->GetNextSelected(Node)) {
        TUploadNodeData* NodeData = (TUploadNodeData*)UploadTree->GetNodeData(Node);
        if(find(Uploads.begin(), Uploads.end(), NodeData->Upload) == Uploads.end()) {
            Uploads.push_front(NodeData->Upload);
            FilesStr += AnsiString(NodeData->Upload->GetFileName().c_str()) + "\n";
        }
    }

    if(Uploads.empty())
        return;

    // TRANSLATOR: Message box confirming cancellation of upload.
    if(MessageDlg(_("Are you sure you want to cancel the following uploads?\n\n") + FilesStr,
                  mtConfirmation,TMsgDlgButtons() <<mbYes << mbNo,0) != mrYes) {
        return;
    }

    // do it
    for (list<TUpload*>::iterator itr = Uploads.begin(); itr != Uploads.end(); ++itr) {
        (*itr)->Cancel();
        // immdetiately remove upload
        Engine->RemoveUpload(*itr);
    }
}

void __fastcall TTransferForm::CancelAllUploadsMnuClick(TObject *Sender)
{
    // TRANSLATOR: Message box confirming cancellation of all uploads.
    if(MessageDlg(_("Are you sure you want to cancel ALL uploads?"),mtConfirmation,TMsgDlgButtons() <<mbYes << mbNo,0) != mrYes)
        return;
    Engine->LockUploads();
    TEngine::TUploadIterator itr = Engine->GetUploadsBegin();
    for(;itr != Engine->GetUploadsEnd();++itr)
        (*itr)->Cancel();
    Engine->ReleaseUploads();
}

void __fastcall TTransferForm::ClearUploadsMnuClick(TObject *Sender)
{
    Engine->LockUploads();
    TEngine::TUploadIterator itr = Engine->GetUploadsBegin();
    while(itr != Engine->GetUploadsEnd()) {
        if((*itr)->GetState() == TUpload::Completed || (*itr)->GetState() == TUpload::Cancelled) {
            Engine->RemoveUpload((*itr));
            itr = Engine->GetUploadsBegin(); // itr is invalid after remove
        } else
            ++itr;
    }
    Engine->ReleaseUploads();
}

void __fastcall TTransferForm::FindMoreFromUserUploadMnuClick(
      TObject *Sender)
{
    if(!UploadTree->FocusedNode)
        return;
    TUploadNodeData* NodeData = (TUploadNodeData*)UploadTree->GetNodeData(UploadTree->FocusedNode);

    SearchForm->RunSearch(NodeData->Upload->GetSource()->GetUser()->GetId().c_str(), SRUser);
    MainForm->SetVisiblePage(SearchForm);
}

//---------------------------------------------------------------------------
// utils
//---------------------------------------------------------------------------

void __fastcall TTransferForm::SanitizeMenuItems(TMenuItem* Item)
{
    bool Enabled = false;

    // if all submenus are disabled disable the parent too
    for(int i=0; i < Item->Count; i++) {
        if(Item->Items[i]->Count)
            SanitizeMenuItems(Item->Items[i]); // recurse

        Enabled = Enabled || Item->Items[i]->Enabled;
    }

    Item->Enabled = Enabled;
}
//---------------------------------------------------------------------------