src/ClientListCtrl.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 // Copyright (c) 2002 Merkur ( devs@emule-project.net / http://www.emule-project.net )
   6 //
   7 // Any parts of this program derived from the xMule, lMule or eMule project,
   8 // or contributed by third-party developers are copyrighted by their
   9 // respective authors.
  10 //
  11 // This program is free software; you can redistribute it and/or modify
  12 // it under the terms of the GNU General Public License as published by
  13 // the Free Software Foundation; either version 2 of the License, or
  14 // (at your option) any later version.
  15 //
  16 // This program is distributed in the hope that it will be useful,
  17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 // GNU General Public License for more details.
  20 //
  21 // You should have received a copy of the GNU General Public License
  22 // along with this program; if not, write to the Free Software
  23 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  24 //
  25
  26 #include "ClientListCtrl.h"
  27
  28 #include <protocol/ed2k/ClientSoftware.h>
  29 #include <common/MenuIDs.h>
  30
  31 #include "amule.h"
  32 #include "amuleDlg.h"
  33 #include "BarShader.h"          // Needed for CBarShader
  34 #include "ChatWnd.h"
  35 #include "ClientDetailDialog.h"
  36 #include "ClientList.h"
  37 #include "DataToText.h"
  38 #ifdef ENABLE_IP2COUNTRY
  39         #include "IP2Country.h" // Needed for IP2Country
  40 #endif
  41 #include "KnownFile.h"
  42 #include "Preferences.h"
  43 #include "updownclient.h"
  44 #include "UploadQueue.h"
  45
  46 #include <wx/menu.h>
  47 #include <wx/textdlg.h>
  48 #include <wx/dc.h>
  49 #include <wx/settings.h>
  50
  51 ////////////////////////////////////////////////////////////
  52 // Sorter functions.
  53
  54 int CompareVersions(const CUpDownClient* client1, const CUpDownClient* client2)
  55 {
  56         if (client1->GetClientSoft() != client2->GetClientSoft()) {
  57                 return client1->GetSoftStr().Cmp(client2->GetSoftStr());
  58         }
  59
  60         if (client1->GetVersion() != client2->GetVersion()) {
  61                 return CmpAny(client1->GetVersion(), client2->GetVersion());
  62         }
  63
  64         return client1->GetClientModString().Cmp(client2->GetClientModString());
  65 }
  66
  67
  68 ////////////////////////////////////////////////////////////
  69 // CClientListCtrl
  70
  71
  72 BEGIN_EVENT_TABLE( CClientListCtrl, CMuleListCtrl )
  73         EVT_RIGHT_DOWN(CClientListCtrl::OnRightClick)
  74         EVT_LIST_ITEM_MIDDLE_CLICK(-1, CClientListCtrl::OnMiddleClick)
  75
  76         EVT_MENU( MP_DETAIL,             CClientListCtrl::OnShowDetails )
  77         EVT_MENU( MP_ADDFRIEND,          CClientListCtrl::OnAddFriend   )
  78         EVT_MENU( MP_SHOWLIST,           CClientListCtrl::OnViewFiles   )
  79         EVT_MENU( MP_SENDMESSAGE,        CClientListCtrl::OnSendMessage )
  80         EVT_MENU( MP_UNBAN,              CClientListCtrl::OnUnbanClient )
  81         EVT_MENU_RANGE( MP_SWITCHCTRL_0, MP_SWITCHCTRL_9, CClientListCtrl::OnChangeView )
  82 END_EVENT_TABLE()
  83
  84
  85 #define m_imagelist theApp->amuledlg->m_imagelist
  86
  87
  88 /**
  89  * This struct is used to keep track of the different view-types.
  90  *
  91  * Each view has a number of attributes, namely a title and serveral functions
  92  * which are used by the CClientListCtrl class. This struct is used to store these
  93  * for easier access.
  94  *
  95  * Please note that none of the values are required, however for a fully functional
  96  * view, it is nescesarry to specificy all of them.
  97  */
  98 struct ClientListView
  99 {
 100         //! The name of the view, this is used to load and save column-preferences.
 101         wxString        m_title;
 102
 103         //! Pointer to the initialization function.
 104         void            (*m_init)(CClientListCtrl*);
 105
 106         //! Pointer to the drawing function
 107         void            (*m_draw)(CUpDownClient*, int, wxDC*, const wxRect&);
 108
 109         //! Pointer to the sorting function.
 110         MuleListCtrlCompare     m_sort;
 111
 112         //! Pointer to the function which returns the old column order.
 113         wxString        (*m_getOldColumnOrder)();
 114 };
 115
 116
 117 //! This is the list of currently usable views, in the same order as the ViewType enum.
 118 ClientListView g_listViews[] =
 119 {
 120         //! None: This view does nothing at all.
 121         {
 122                 wxEmptyString,
 123                 NULL,
 124                 NULL,
 125                 NULL,
 126                 NULL,
 127         },
 128
 129         //! Uploading: The clients currently being uploaded to.
 130         {
 131                 wxT("Uploads"),
 132                 CUploadingView::Initialize,
 133                 CUploadingView::DrawCell,
 134                 CUploadingView::SortProc,
 135                 CUploadingView::GetOldColumnOrder,
 136         },
 137
 138         //! Queued: The clients currently queued for uploading.
 139         {
 140                 wxT("Queue"),
 141                 CQueuedView::Initialize,
 142                 CQueuedView::DrawCell,
 143                 CQueuedView::SortProc,
 144                 CQueuedView::GetOldColumnOrder,
 145         },
 146
 147         //! Clients The complete list of all known clients.
 148         {
 149                 wxT("Clients"),
 150                 CClientsView::Initialize,
 151                 CClientsView::DrawCell,
 152                 CClientsView::SortProc,
 153                 CClientsView::GetOldColumnOrder,
 154         }
 155 };
 156
 157
 158
 159 CClientListCtrl::CClientListCtrl( wxWindow *parent, wxWindowID winid, const wxPoint &pos, const wxSize &size, long style, const wxValidator& validator, const wxString& name )
 160 :
 161 CMuleListCtrl( parent, winid, pos, size, style | wxLC_OWNERDRAW, validator, name )
 162 {
 163         m_viewType = vtNone;
 164
 165         m_menu = NULL;
 166
 167         m_hilightBrush  = CMuleColour(wxSYS_COLOUR_HIGHLIGHT).Blend(125).GetBrush();
 168
 169         m_hilightUnfocusBrush = CMuleColour(wxSYS_COLOUR_BTNSHADOW).Blend(125).GetBrush();
 170
 171         // We show the uploading-list initially
 172         SetListView( vtUploading );
 173 }
 174
 175
 176 CClientListCtrl::~CClientListCtrl()
 177 {
 178
 179 }
 180
 181
 182 ViewType CClientListCtrl::GetListView()
 183 {
 184         return m_viewType;
 185 }
 186
 187
 188 void CClientListCtrl::SetListView( ViewType newView )
 189 {
 190         if ( m_viewType != newView ) {
 191                 if (m_viewType != vtNone) {
 192                         SaveSettings();
 193                         ClearAll();
 194                 }
 195
 196                 m_viewType = newView;
 197
 198                 const ClientListView& view = g_listViews[ (int)newView ];
 199
 200                 // Initialize the selected view
 201                 if ( view.m_init ) {
 202                         view.m_init( this );
 203                 }
 204
 205                 SetTableName( view.m_title );
 206                 SetSortFunc( view.m_sort );
 207
 208                 if (newView != vtNone) {
 209                         LoadSettings();
 210                 }
 211         }
 212 }
 213
 214
 215 void CClientListCtrl::ToggleView()
 216 {
 217         // Disallow toggling if the list is disabled
 218         if ( m_viewType == vtNone ) {
 219                 return;
 220         }
 221
 222         unsigned int view = (int)m_viewType + 1;
 223
 224         if ( view < itemsof(g_listViews) ) {
 225                 SetListView( (ViewType)(view) );
 226         } else {
 227                 SetListView( (ViewType)(1) );
 228         }
 229 }
 230
 231
 232 /////////////////////////////////////////////////////////////////////////////////////////////
 233 void CClientListCtrl::OnRightClick(wxMouseEvent& event)
 234 {
 235         long index = CheckSelection(event);
 236
 237         if ( m_menu == NULL ) {
 238
 239                 bool banned = false;
 240                 bool validIP = false;
 241                 bool isfriend = false;
 242                 bool hasdisabledsharedfiles = false;
 243
 244                 // Check if the client is banned
 245                 if ( index > -1 ) {
 246                         CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 247
 248                         banned = client->IsBanned();
 249                         validIP = (client->GetIP() != 0);
 250                         isfriend = client->IsFriend();
 251                         hasdisabledsharedfiles = client->HasDisabledSharedFiles();
 252                 }
 253
 254                 m_menu = new wxMenu(_("Clients"));
 255                 m_menu->Append( MP_DETAIL,      _("Show &Details") );
 256                 m_menu->Append( MP_ADDFRIEND,   isfriend ? _("Remove from friends") : _("Add to Friends") );
 257                 m_menu->Append( MP_SHOWLIST,    _("View Files") );
 258                 m_menu->Append( MP_SENDMESSAGE, _("Send message") );
 259                 m_menu->Append( MP_UNBAN,       _("Unban") );
 260
 261                 m_menu->AppendSeparator();
 262
 263                 wxMenu* view = new wxMenu();
 264                 view->Append( MP_SWITCHCTRL_0 + 1, _("Show Uploads") );
 265                 view->Append( MP_SWITCHCTRL_0 + 2, _("Show Queue") );
 266                 view->Append( MP_SWITCHCTRL_0 + 3, _("Show Clients") );
 267
 268                 view->Enable( MP_SWITCHCTRL_0 + (int)m_viewType, false );
 269
 270                 m_menu->Append( 0, _("Select View"), view );
 271
 272                 m_menu->Enable( MP_DETAIL,      index > -1 );
 273                 m_menu->Enable( MP_SHOWLIST,    index > -1 );
 274
 275                 m_menu->Enable( MP_UNBAN,       banned );
 276                 m_menu->Enable( MP_SHOWLIST,    !hasdisabledsharedfiles );
 277                 m_menu->Enable( MP_ADDFRIEND,   validIP );
 278                 m_menu->Enable( MP_SENDMESSAGE, validIP );
 279
 280                 PopupMenu( m_menu, event.GetPosition() );
 281
 282                 delete m_menu;
 283
 284                 m_menu = NULL;
 285         }
 286 }
 287
 288
 289 void CClientListCtrl::OnMiddleClick(wxListEvent& event)
 290 {
 291         long index = CheckSelection(event);
 292
 293         if (index > -1) {
 294                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 295
 296                 CClientDetailDialog dialog(this, client);
 297
 298                 dialog.ShowModal();
 299         }
 300 }
 301
 302
 303 void CClientListCtrl::OnChangeView( wxCommandEvent& event )
 304 {
 305         int view = event.GetId() - MP_SWITCHCTRL_0;
 306
 307         SetListView( (ViewType)view );
 308 }
 309
 310
 311 void CClientListCtrl::OnAddFriend( wxCommandEvent& WXUNUSED(event) )
 312 {
 313         long index = GetNextItem( -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 314
 315         while ( index != -1 ) {
 316                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 317                 if (client->IsFriend()) {
 318                         theApp->amuledlg->m_chatwnd->RemoveFriend(client->GetUserHash(), client->GetIP(), client->GetUserPort());
 319                 } else {
 320                         theApp->amuledlg->m_chatwnd->AddFriend( client );
 321                 }
 322                 index = GetNextItem( index, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 323         }
 324 }
 325
 326
 327 void CClientListCtrl::OnShowDetails( wxCommandEvent& WXUNUSED(event) )
 328 {
 329         long index = GetNextItem( -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 330
 331         if ( index > -1 ) {
 332                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 333                 CClientDetailDialog dialog(this, client);
 334                 dialog.ShowModal();
 335         }
 336 }
 337
 338
 339 void CClientListCtrl::OnViewFiles( wxCommandEvent& WXUNUSED(event) )
 340 {
 341         long index = GetNextItem( -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 342
 343         if ( index > -1 ) {
 344                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 345                 client->RequestSharedFileList();
 346         }
 347 }
 348
 349
 350 void CClientListCtrl::OnSendMessage( wxCommandEvent& WXUNUSED(event) )
 351 {
 352         long index = GetNextItem( -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 353
 354         if ( index > -1 ) {
 355                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 356
 357                 // These values are cached, since calling wxGetTextFromUser will
 358                 // start an event-loop, in which the client may be deleted.
 359                 wxString userName = client->GetUserName();
 360                 uint64 userID = GUI_ID(client->GetIP(),client->GetUserPort());
 361
 362                 wxString message = ::wxGetTextFromUser( _("Send message to user"), _("Message to send:") );
 363
 364                 if (!message.IsEmpty()) {
 365                         theApp->amuledlg->m_chatwnd->SendMessage(message, userName, userID);
 366                 }
 367         }
 368 }
 369
 370
 371 void CClientListCtrl::OnUnbanClient( wxCommandEvent& WXUNUSED(event) )
 372 {
 373         long index = GetNextItem( -1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED );
 374
 375         if ( index > -1 ) {
 376                 CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( index ));
 377                 if ( client->IsBanned() ) {
 378                         client->UnBan();
 379                 }
 380         }
 381 }
 382
 383
 384 void CClientListCtrl::InsertClient( CUpDownClient* client, ViewType view )
 385 {
 386         wxCHECK_RET(client, wxT("Attempted to add NULL client pointer."));
 387
 388         if ( ( m_viewType != view ) || ( view == vtNone ) ) {
 389                 return;
 390         }
 391
 392         long index = InsertItem( GetItemCount(), wxEmptyString );
 393         SetItemPtrData( index, reinterpret_cast<wxUIntPtr>(client) );
 394
 395         wxListItem myitem;
 396         myitem.SetId( index );
 397         myitem.SetBackgroundColour( CMuleColour(wxSYS_COLOUR_LISTBOX) );
 398
 399         SetItem(myitem);
 400
 401         RefreshItem( index );
 402 }
 403
 404
 405 void CClientListCtrl::RemoveClient( CUpDownClient* client, ViewType view )
 406 {
 407         wxCHECK_RET(client, wxT("Attempted to remove NULL client pointer."));
 408
 409         if ( ( m_viewType != view ) || ( view == vtNone ) ) {
 410                 return;
 411         }
 412
 413         long index = FindItem( -1, reinterpret_cast<wxUIntPtr>(client) );
 414
 415         if ( index > -1 ) {
 416                 DeleteItem( index );
 417         }
 418 }
 419
 420
 421 void CClientListCtrl::UpdateClient( CUpDownClient* client, ViewType view )
 422 {
 423         wxCHECK_RET(client, wxT("Attempted to update NULL client pointer."));
 424
 425         if ( ( m_viewType != view ) || ( view == vtNone ) ) {
 426                 return;
 427         }
 428
 429         if ( theApp->amuledlg->IsDialogVisible( CamuleDlg::DT_TRANSFER_WND ) ) {
 430                 // Visible lines, default to all because not all platforms support the GetVisibleLines function
 431                 long first = 0, last = GetItemCount();
 432                 long result = FindItem( -1, reinterpret_cast<wxUIntPtr>(client) );
 433                 if ( result > -1 ) {
 434 #ifndef __WXMSW__
 435                         GetVisibleLines( &first, &last );
 436 #endif
 437                         if ( result >= first && result <= last) {
 438                                 RefreshItem(result);
 439                         }
 440                 }
 441         }
 442 }
 443
 444
 445 void CClientListCtrl::OnDrawItem( int item, wxDC* dc, const wxRect& rect, const wxRect& rectHL, bool highlighted )
 446 {
 447         // Don't do any drawing if we not being watched.
 448         if ( !theApp->amuledlg || !theApp->amuledlg->IsDialogVisible( CamuleDlg::DT_TRANSFER_WND ) ) {
 449                 return;
 450         }
 451
 452         if ( highlighted ) {
 453                 if ( GetFocus() ) {
 454                         dc->SetBackground(m_hilightBrush);
 455                         dc->SetTextForeground( CMuleColour(wxSYS_COLOUR_HIGHLIGHTTEXT) );
 456                 } else {
 457                         dc->SetBackground(m_hilightUnfocusBrush);
 458                         dc->SetTextForeground( CMuleColour(wxSYS_COLOUR_HIGHLIGHTTEXT));
 459                 }
 460
 461                 CMuleColour colour = GetFocus() ? m_hilightBrush.GetColour() : m_hilightUnfocusBrush.GetColour();
 462                 dc->SetPen( *(wxThePenList->FindOrCreatePen( colour.Blend(65), 1, wxSOLID) ));
 463         } else {
 464                 dc->SetBackground( CMuleColour(wxSYS_COLOUR_LISTBOX).GetBrush());
 465                 dc->SetTextForeground( CMuleColour(wxSYS_COLOUR_WINDOWTEXT) );
 466                 dc->SetPen(*wxTRANSPARENT_PEN);
 467         }
 468
 469         dc->SetBrush(dc->GetBackground());
 470         dc->DrawRectangle(rectHL);
 471         dc->SetPen(*wxTRANSPARENT_PEN);
 472
 473         CUpDownClient* client = reinterpret_cast<CUpDownClient *>(GetItemData(item));
 474         wxRect cur_rect = rect;
 475         cur_rect.x += 4;
 476
 477         const ClientListView& view = g_listViews[ (int)m_viewType ];
 478
 479         if ( view.m_draw ) {
 480                 for ( int i = 0; i < GetColumnCount(); i++ ) {
 481                         int width = GetColumnWidth( i );
 482                         if ( width ) {
 483                                 cur_rect.width = width - 8;
 484
 485                                 wxDCClipper clipper( *dc, cur_rect );
 486
 487                                 view.m_draw( client, i, dc, cur_rect );
 488                         }
 489                         cur_rect.x += width;
 490                 }
 491         }
 492 }
 493
 494
 495 wxString CClientListCtrl::GetTTSText(unsigned item) const
 496 {
 497         CUpDownClient *client = reinterpret_cast<CUpDownClient *>(GetItemData( item ));
 498
 499         return client->GetUserName();
 500 }
 501
 502
 503 wxString CClientListCtrl::GetOldColumnOrder() const
 504 {
 505         const ClientListView& view = g_listViews[ (int)m_viewType ];
 506         if (view.m_getOldColumnOrder) {
 507                 return view.m_getOldColumnOrder();
 508         }
 509         return wxEmptyString;
 510 }
 511
 512
 513 /////////////////////////////////////////////////////////////////////////////////////////////
 514 void CUploadingView::Initialize( CClientListCtrl* list )
 515 {
 516         list->InsertColumn( 0,  _("Username"),        wxLIST_FORMAT_LEFT, 150, wxT("U") );
 517         list->InsertColumn( 1,  _("File"),            wxLIST_FORMAT_LEFT, 275, wxT("F") );
 518         list->InsertColumn( 2,  _("Client Software"), wxLIST_FORMAT_LEFT, 100, wxT("C") );
 519         list->InsertColumn( 3,  _("Speed"),           wxLIST_FORMAT_LEFT,  60, wxT("S") );
 520         list->InsertColumn( 4,  _("Transferred"),     wxLIST_FORMAT_LEFT,  65, wxT("T") );
 521         list->InsertColumn( 5,  _("Waited"),          wxLIST_FORMAT_LEFT,  60, wxT("W") );
 522         list->InsertColumn( 6,  _("Upload Time"),     wxLIST_FORMAT_LEFT,  60, wxT("u") );
 523         list->InsertColumn( 7,  _("Status"),          wxLIST_FORMAT_LEFT, 110, wxT("s") );
 524         list->InsertColumn( 8,  _("Obtained Parts"),  wxLIST_FORMAT_LEFT, 100, wxT("P") );
 525         list->InsertColumn( 9,  _("Upload/Download"), wxLIST_FORMAT_LEFT, 100, wxT("R") );
 526         list->InsertColumn( 10, _("Remote Status"),   wxLIST_FORMAT_LEFT, 100, wxT("r") );
 527
 528         // Insert any existing items on the list
 529         const CClientPtrList& uploading = theApp->uploadqueue->GetUploadingList();
 530         CClientPtrList::const_iterator it = uploading.begin();
 531         for (; it != uploading.end(); ++it) {
 532                 list->InsertClient( *it, list->GetListView() );
 533         }
 534 }
 535
 536
 537 wxString CUploadingView::GetOldColumnOrder()
 538 {
 539         return wxT("U,F,C,S,T,W,u,s,P,R,r");
 540 }
 541
 542
 543 void CUploadingView::DrawCell( CUpDownClient* client, int column, wxDC* dc, const wxRect& rect )
 544 {
 545         wxString buffer;
 546
 547         switch ( column ) {
 548         case 0: {
 549                 uint8 clientImage;
 550
 551                 if ( client->IsFriend() ) {
 552                         clientImage = Client_Friend_Smiley;
 553                 } else {
 554                         switch (client->GetClientSoft()) {
 555                         case SO_AMULE:
 556                                 clientImage = Client_aMule_Smiley;
 557                                 break;
 558                         case SO_MLDONKEY:
 559                         case SO_NEW_MLDONKEY:
 560                         case SO_NEW2_MLDONKEY:
 561                                 clientImage = Client_mlDonkey_Smiley;
 562                                 break;
 563                         case SO_EDONKEY:
 564                         case SO_EDONKEYHYBRID:
 565                                 // Maybe we would like to make different icons?
 566                                 clientImage = Client_eDonkeyHybrid_Smiley;
 567                                 break;
 568                         case SO_EMULE:
 569                                 clientImage = Client_eMule_Smiley;
 570                                 break;
 571                         case SO_LPHANT:
 572                                 clientImage = Client_lphant_Smiley;
 573                                 break;
 574                         case SO_SHAREAZA:
 575                         case SO_NEW_SHAREAZA:
 576                         case SO_NEW2_SHAREAZA:
 577                                 clientImage = Client_Shareaza_Smiley;
 578                                 break;
 579                         case SO_LXMULE:
 580                                 clientImage = Client_xMule_Smiley;
 581                                 break;
 582                         default:
 583                                 // cDonkey, Compat Unk
 584                                 // No icon for those yet. Using the eMule one + '?'
 585                                 clientImage = Client_Unknown;
 586                                 break;
 587                         }
 588                 }
 589
 590                 m_imagelist.Draw(clientImage, *dc, rect.x, rect.y + 1,
 591                         wxIMAGELIST_DRAW_TRANSPARENT);
 592
 593                 if (client->GetScoreRatio() > 1) {
 594                         // Has credits, draw the gold star
 595                         m_imagelist.Draw(Client_CreditsYellow_Smiley, *dc, rect.x, rect.y + 1,
 596                                 wxIMAGELIST_DRAW_TRANSPARENT );
 597                 } else if (client->ExtProtocolAvailable()) {
 598                         // Ext protocol -> Draw the '+'
 599                         m_imagelist.Draw(Client_ExtendedProtocol_Smiley, *dc, rect.x, rect.y + 1,
 600                                 wxIMAGELIST_DRAW_TRANSPARENT );
 601                 }
 602
 603                 if (client->IsIdentified()) {
 604                         // the 'v'
 605                         m_imagelist.Draw(Client_SecIdent_Smiley, *dc, rect.x, rect.y + 1,
 606                                 wxIMAGELIST_DRAW_TRANSPARENT);
 607                 } else if (client->IsBadGuy()) {
 608                         // the 'X'
 609                         m_imagelist.Draw(Client_BadGuy_Smiley, *dc, rect.x, rect.y + 1,
 610                                 wxIMAGELIST_DRAW_TRANSPARENT);
 611                 }
 612
 613                 if (client->HasObfuscatedConnectionBeenEstablished()) {
 614                         // the "¿" except it's a key
 615                         m_imagelist.Draw(Client_Encryption_Smiley, *dc, rect.x, rect.y + 1,
 616                                 wxIMAGELIST_DRAW_TRANSPARENT);
 617                 }
 618
 619                 wxString userName;
 620 #ifdef ENABLE_IP2COUNTRY
 621                 // Draw the flag
 622                 const CountryData& countrydata =
 623                         theApp->amuledlg->m_IP2Country->GetCountryData(client->GetFullIP());
 624                 dc->DrawBitmap(countrydata.Flag, rect.x + 20, rect.y + 5,
 625                         wxIMAGELIST_DRAW_TRANSPARENT);
 626
 627                 userName << countrydata.Name;
 628                 userName << wxT(" - ");
 629 #endif // ENABLE_IP2COUNTRY
 630                 userName << client->GetUserName();
 631                 dc->DrawText(userName, rect.x + 40, rect.y + 3);
 632
 633                 return;
 634         }
 635
 636         case 1:
 637                 if ( client->GetUploadFile() ) {
 638                         buffer = client->GetUploadFile()->GetFileName().GetPrintable();
 639                 } else {
 640                         buffer = _("N/A");
 641                 }
 642                 break;
 643
 644         case 2:
 645                 buffer = client->GetClientVerString();
 646                 break;
 647
 648         case 3:
 649                 buffer = wxString::Format( wxT("%.1f"), client->GetUploadDatarate() / 1024.0f );
 650
 651                 buffer += wxT(" ");
 652                 buffer += _("kB/s");
 653                 break;
 654
 655         case 4:
 656                 buffer = CastItoXBytes(client->GetSessionUp());
 657                 break;
 658
 659         case 5:
 660                 buffer = CastSecondsToHM((client->GetWaitTime())/1000);
 661                 break;
 662
 663         case 6:
 664                 buffer = CastSecondsToHM((client->GetUpStartTimeDelay())/1000);
 665                 break;
 666
 667         case 7:
 668                 switch ( client->GetUploadState() ) {
 669                 case US_CONNECTING:
 670                         buffer = _("Connecting");
 671                         break;
 672
 673                 case US_WAITCALLBACK:
 674                         buffer = _("Connecting via server");
 675                         break;
 676
 677                 case US_UPLOADING:
 678                         buffer = wxT("<-- ");
 679                         buffer.Append(_("Transferring"));
 680
 681                         if (client->GetDownloadState() == DS_DOWNLOADING) {
 682                                 buffer.Append(wxT(" -->"));
 683                         }
 684                         break;
 685
 686                 case US_ONUPLOADQUEUE:
 687                         buffer = _("On Queue");
 688                         break;
 689
 690                 default:
 691                         buffer = _("Unknown");
 692                 }
 693                 break;
 694
 695         case 8:
 696                 if ( client->GetUpPartCount() ) {
 697                         CUploadingView::DrawStatusBar( client, dc, rect );
 698                 }
 699                 return;
 700
 701         case 9:
 702                 buffer = CastItoXBytes( client->GetUploadedTotal() ) +
 703                         wxT(" / ") + CastItoXBytes(client->GetDownloadedTotal());
 704                 break;
 705
 706         case 10:
 707                 if ( client->GetDownloadState() == DS_ONQUEUE ) {
 708                         if ( client->IsRemoteQueueFull() ) {
 709                                 buffer = _("Queue Full");
 710                         } else {
 711                                 if (client->GetRemoteQueueRank()) {
 712                                         buffer = wxString::Format(_("QR: %u"), client->GetRemoteQueueRank());
 713                                 } else {
 714                                         buffer = _("Unknown");
 715                                 }
 716                         }
 717                 } else if ( client->GetDownloadState() == DS_DOWNLOADING ) {
 718                         buffer += wxString::Format( wxT("%.1f"), client->GetKBpsDown() );
 719                         buffer += wxT(" ");
 720                         buffer += _("kB/s");
 721                 } else {
 722                         buffer = _("Unknown");
 723                 }
 724                 break;
 725         }
 726
 727         dc->DrawText( buffer, rect.x, rect.y + 3 );
 728 }
 729
 730
 731 int CUploadingView::SortProc(wxUIntPtr item1, wxUIntPtr item2, long sortData)
 732 {
 733         CUpDownClient* client1 = (CUpDownClient*)item1;
 734         CUpDownClient* client2 = (CUpDownClient*)item2;
 735
 736         // Sorting ascending or decending
 737         int mode = (sortData & CMuleListCtrl::SORT_DES) ? -1 : 1;
 738
 739         switch (sortData & CMuleListCtrl::COLUMN_MASK) {
 740         // Sort by username
 741         case 0: return mode * client1->GetUserName().CmpNoCase( client2->GetUserName() );
 742
 743
 744         // Sort by requested file
 745         case 1: {
 746                 const CKnownFile* file1 = client1->GetUploadFile();
 747                 const CKnownFile* file2 = client2->GetUploadFile();
 748
 749                 if ( file1 && file2  ) {
 750                         return mode * CmpAny(file1->GetFileName(), file2->GetFileName());
 751                 }
 752
 753                 return mode * CmpAny( file1, file2 );
 754         }
 755
 756         // Sort by client software
 757         case 2: return mode * CompareVersions(client1, client2);
 758
 759         // Sort by speed
 760         case 3: return mode * CmpAny( client1->GetUploadDatarate(), client2->GetUploadDatarate() );
 761
 762         // Sort by transferred
 763         case 4: return mode * CmpAny( client1->GetSessionUp(), client2->GetSessionUp() );
 764
 765         // Sort by wait-time
 766         case 5: return mode * CmpAny( client1->GetWaitTime(), client2->GetWaitTime() );
 767
 768         // Sort by upload time
 769         case 6: return mode * CmpAny( client1->GetUpStartTimeDelay(), client2->GetUpStartTimeDelay() );
 770
 771         // Sort by state
 772         case 7: return mode * CmpAny( client1->GetUploadState(), client2->GetUploadState() );
 773
 774         // Sort by partcount
 775         case 8: return mode * CmpAny( client1->GetUpPartCount(), client2->GetUpPartCount() );
 776
 777         // Sort by U/D ratio
 778         case 9: return mode * CmpAny( client2->GetDownloadedTotal(), client1->GetDownloadedTotal() );
 779
 780         // Sort by remote rank
 781         case 10: return mode * CmpAny( client2->GetRemoteQueueRank(), client1->GetRemoteQueueRank() );
 782
 783         default:
 784                 return 0;
 785         }
 786 }
 787
 788 static const CMuleColour crUnavailable(240, 240, 240);
 789 static const CMuleColour crFlatUnavailable(224, 224, 224);
 790
 791 static const CMuleColour crAvailable(104, 104, 104);
 792 static const CMuleColour crFlatAvailable(0, 0, 0);
 793
 794 void CUploadingView::DrawStatusBar( CUpDownClient* client, wxDC* dc, const wxRect& rect1 )
 795 {
 796         wxRect rect = rect1;
 797         rect.y          += 1;
 798         rect.height     -= 2;
 799
 800         wxPen   old_pen   = dc->GetPen();
 801         wxBrush old_brush = dc->GetBrush();
 802         bool bFlat = thePrefs::UseFlatBar();
 803
 804         wxRect barRect = rect;
 805         if (!bFlat) { // round bar has a black border, the bar itself is 1 pixel less on each border
 806                 barRect.x ++;
 807                 barRect.y ++;
 808                 barRect.height -= 2;
 809                 barRect.width -= 2;
 810         }
 811         static CBarShader s_StatusBar(16);
 812
 813         uint32 partCount = client->GetUpPartCount();
 814
 815         // Seems the partfile in the client object is not necessarily valid when bar is drawn for the first time.
 816         // Keep it simple and make all parts same size.
 817         s_StatusBar.SetFileSize(partCount * PARTSIZE);
 818         s_StatusBar.SetHeight(barRect.height);
 819         s_StatusBar.SetWidth(barRect.width);
 820         s_StatusBar.Set3dDepth( thePrefs::Get3DDepth() );
 821
 822         uint64 uEnd = 0;
 823         for ( uint64 i = 0; i < partCount; i++ ) {
 824                 uint64 uStart = PARTSIZE * i;
 825                 uEnd = uStart + PARTSIZE - 1;
 826
 827                 s_StatusBar.FillRange(uStart, uEnd, client->IsUpPartAvailable(i) ? (bFlat ? crFlatAvailable : crAvailable) : (bFlat ? crFlatUnavailable : crUnavailable));
 828         }
 829         // fill the rest (if partStatus is empty)
 830         s_StatusBar.FillRange(uEnd + 1, partCount * PARTSIZE - 1, bFlat ? crFlatUnavailable : crUnavailable);
 831         s_StatusBar.Draw(dc, barRect.x, barRect.y, bFlat);
 832
 833         if (!bFlat) {
 834                 // Draw black border
 835                 dc->SetPen( *wxBLACK_PEN );
 836                 dc->SetBrush( *wxTRANSPARENT_BRUSH );
 837                 dc->DrawRectangle(rect);
 838         }
 839
 840         dc->SetPen( old_pen );
 841         dc->SetBrush( old_brush );
 842 }
 843
 844
 845 /////////////////////////////////////////////////////////////////////////////////////////////
 846 void CQueuedView::Initialize( CClientListCtrl* list )
 847 {
 848         list->InsertColumn( 0,  _("Username"),        wxLIST_FORMAT_LEFT, 150, wxT("U") );
 849         list->InsertColumn( 1,  _("File"),            wxLIST_FORMAT_LEFT, 275, wxT("F") );
 850         list->InsertColumn( 2,  _("Client Software"), wxLIST_FORMAT_LEFT, 100, wxT("C") );
 851         list->InsertColumn( 3,  _("File Priority"),   wxLIST_FORMAT_LEFT, 110, wxT("p") );
 852         list->InsertColumn( 4,  _("Rating"),          wxLIST_FORMAT_LEFT,  60, wxT("R") );
 853         list->InsertColumn( 5,  _("Score"),           wxLIST_FORMAT_LEFT,  60, wxT("c") );
 854         list->InsertColumn( 6,  _("Asked"),           wxLIST_FORMAT_LEFT,  60, wxT("A") );
 855         list->InsertColumn( 7,  _("Last Seen"),       wxLIST_FORMAT_LEFT, 110, wxT("L") );
 856         list->InsertColumn( 8,  _("Entered Queue"),   wxLIST_FORMAT_LEFT, 110, wxT("Q") );
 857         list->InsertColumn( 9,  _("Banned"),          wxLIST_FORMAT_LEFT,  60, wxT("B") );
 858         list->InsertColumn( 10, _("Obtained Parts"),  wxLIST_FORMAT_LEFT, 100, wxT("P") );
 859
 860         // Insert any existing items on the list
 861         const CClientPtrList& uploading = theApp->uploadqueue->GetWaitingList();
 862         CClientPtrList::const_iterator it = uploading.begin();
 863         for (; it != uploading.end(); ++it) {
 864                 list->InsertClient( *it, list->GetListView() );
 865         }
 866 }
 867
 868
 869 wxString CQueuedView::GetOldColumnOrder()
 870 {
 871         return wxT("U,F,C,p,R,c,A,L,Q,B,P");
 872 }
 873
 874
 875 void CQueuedView::DrawCell( CUpDownClient* client, int column, wxDC* dc, const wxRect& rect )
 876 {
 877         wxString buffer;
 878
 879         switch ( column ) {
 880         // These 3 are the same for both lists
 881         case 0:
 882         case 1:
 883         case 2:
 884                 CUploadingView::DrawCell( client, column, dc, rect );
 885                 return;
 886
 887         case 3:
 888                 if ( client->GetUploadFile() ) {
 889                         buffer = PriorityToStr( client->GetUploadFile()->GetUpPriority(), false );
 890                 } else {
 891                         buffer = _("Unknown");
 892                 }
 893
 894                 break;
 895
 896         case 4:
 897                 buffer = wxString::Format( wxT("%.1f"), (float)client->GetScore(false,false,true) );
 898                 break;
 899
 900         case 5:
 901                 if ( client->HasLowID() ) {
 902                         buffer = wxString::Format( wxT("%i %s"), client->GetScore(false), _("LowID") );
 903                 } else {
 904                         buffer = wxString::Format(wxT("%i"),client->GetScore(false));
 905                 }
 906                 break;
 907
 908         case 6:
 909                 buffer = wxString::Format( wxT("%i"), client->GetAskedCount() );
 910                 break;
 911
 912 #ifndef CLIENT_GUI
 913         case 7:
 914                 buffer = CastSecondsToHM((::GetTickCount() - client->GetLastUpRequest())/1000);
 915                 break;
 916
 917         case 8:
 918                 buffer = CastSecondsToHM((::GetTickCount() - client->GetWaitStartTime())/1000);
 919                 break;
 920 #else
 921         case 7:
 922                 buffer = CastSecondsToHM(client->GetLastUpRequest()/1000);
 923                 break;
 924
 925         case 8:
 926                 buffer = CastSecondsToHM(client->GetWaitStartTime()/1000);
 927                 break;
 928 #endif
 929         case 9:
 930                 if ( client->IsBanned() ) {
 931                         buffer = _("Yes");
 932                 } else {
 933                         buffer = _("No");
 934                 }
 935
 936                 break;
 937
 938         case 10:
 939                 if ( client->GetUpPartCount() ) {
 940                         CUploadingView::DrawStatusBar( client, dc, rect );
 941                 }
 942
 943                 return;
 944         }
 945
 946         dc->DrawText( buffer, rect.x, rect.y + 3 );
 947 }
 948
 949
 950 int CQueuedView::SortProc(wxUIntPtr item1, wxUIntPtr item2, long sortData)
 951 {
 952         CUpDownClient* client1 = (CUpDownClient*)item1;
 953         CUpDownClient* client2 = (CUpDownClient*)item2;
 954
 955         // Ascending or decending?
 956         int mode = (sortData & CMuleListCtrl::SORT_DES) ? -1 : 1;
 957
 958         switch (sortData & CMuleListCtrl::COLUMN_MASK) {
 959         // Sort by username
 960         case 0: return mode * client1->GetUserName().CmpNoCase( client2->GetUserName() );
 961
 962         // Sort by filename
 963         case 1: {
 964                 const CKnownFile* file1 = client1->GetUploadFile();
 965                 const CKnownFile* file2 = client2->GetUploadFile();
 966
 967                 if ( file1 && file2 ) {
 968                         return mode * CmpAny(file1->GetFileName(), file2->GetFileName());
 969                 }
 970
 971                 // Place files with filenames on top
 972                 return -mode * CmpAny( file1, file2 );
 973         }
 974
 975         // Sort by client software
 976         case 2: return mode * CompareVersions(client1, client2);
 977
 978         // Sort by file upload-priority
 979         case 3: {
 980                 const CKnownFile* file1 = client1->GetUploadFile();
 981                 const CKnownFile* file2 = client2->GetUploadFile();
 982
 983                 if ( file1 && file2  ) {
 984                         int8 prioA = file1->GetUpPriority();
 985                         int8 prioB = file2->GetUpPriority();
 986
 987                         // Work-around for PR_VERYLOW which has value 4. See KnownFile.h for that stupidity ...
 988                         return mode * CmpAny( ( prioA != PR_VERYLOW ? prioA : -1 ), ( prioB != PR_VERYLOW ? prioB : -1 ) );
 989                 }
 990
 991                 // Place files with priorities on top
 992                 return -mode * CmpAny( file1, file2 );
 993         }
 994
 995         // Sort by rating
 996         case 4: return mode * CmpAny( client1->GetScore(false,false,true), client2->GetScore(false,false,true) );
 997
 998         // Sort by score
 999         case 5: return mode * CmpAny( client1->GetScore(false), client2->GetScore(false) );
1000
1001         // Sort by Asked count
1002         case 6: return mode * CmpAny( client1->GetAskedCount(), client2->GetAskedCount() );
1003
1004         // Sort by Last seen
1005         case 7: return mode * CmpAny( client1->GetLastUpRequest(), client2->GetLastUpRequest() );
1006
1007         // Sort by entered time
1008         case 8: return mode * CmpAny( client1->GetWaitStartTime(), client2->GetWaitStartTime() );
1009
1010         // Sort by banned
1011         case 9: return mode * CmpAny( client1->IsBanned(), client2->IsBanned() );
1012
1013         default: return 0;
1014         }
1015 }
1016
1017
1018 /////////////////////////////////////////////////////////////////////////////////////////////
1019 void CClientsView::Initialize( CClientListCtrl* list )
1020 {
1021         list->InsertColumn( 0, _("Username"),          wxLIST_FORMAT_LEFT, 150, wxT("U") );
1022         list->InsertColumn( 1, _("Upload Status"),     wxLIST_FORMAT_LEFT, 150, wxT("S") );
1023         list->InsertColumn( 2, _("Transferred Up"),    wxLIST_FORMAT_LEFT, 150, wxT("T") );
1024         list->InsertColumn( 3, _("Download Status"),   wxLIST_FORMAT_LEFT, 150, wxT("s") );
1025         list->InsertColumn( 4, _("Transferred Down"),  wxLIST_FORMAT_LEFT, 150, wxT("t") );
1026         list->InsertColumn( 5, _("Client Software"),   wxLIST_FORMAT_LEFT, 150, wxT("C") );
1027         list->InsertColumn( 6, _("Connected"),         wxLIST_FORMAT_LEFT, 150, wxT("c") );
1028         list->InsertColumn( 7, _("Userhash"),          wxLIST_FORMAT_LEFT, 150, wxT("H") );
1029         list->InsertColumn( 8, _("Encrypted"),         wxLIST_FORMAT_LEFT, 100, wxT("E") );
1030         list->InsertColumn( 9, _("Hide shared files"), wxLIST_FORMAT_LEFT, 100, wxT("h") );
1031
1032         const CClientList::IDMap& clist = theApp->clientlist->GetClientList();
1033         CClientList::IDMap::const_iterator it = clist.begin();
1034
1035         for ( ; it != clist.end(); ++it ) {
1036                 list->InsertClient( it->second, list->GetListView() );
1037         }
1038 }
1039
1040
1041 wxString CClientsView::GetOldColumnOrder()
1042 {
1043         return wxT("U,S,T,s,t,C,c,H,E,h");
1044 }
1045
1046
1047 void CClientsView::DrawCell( CUpDownClient* client, int column, wxDC* dc, const wxRect& rect )
1048 {
1049         wxString buffer;
1050
1051         switch ( column ) {
1052                 case 0:
1053                 CUploadingView::DrawCell( client, column, dc, rect );
1054                 return;
1055
1056         case 1:
1057                 CUploadingView::DrawCell( client, 7, dc, rect );
1058                 return;
1059
1060         case 2:
1061                 buffer = CastItoXBytes( client->GetUploadedTotal() );
1062
1063                 break;
1064
1065         case 3:
1066                 buffer = DownloadStateToStr( client->GetDownloadState(),
1067                                              client->IsRemoteQueueFull() );
1068                 break;
1069
1070         case 4:
1071                 buffer = CastItoXBytes( client->GetDownloadedTotal() );
1072                 break;
1073
1074         case 5:
1075                 buffer = client->GetClientVerString();
1076                 break;
1077
1078         case 6:
1079                 if ( client->IsConnected() ) {
1080                         buffer = _("Yes");
1081                 } else {
1082                         buffer = _("No");
1083                 }
1084
1085                 break;
1086
1087         case 7:
1088                 buffer = client->GetUserHash().Encode();
1089                 break;
1090
1091         case 8:
1092                 buffer = client->HasObfuscatedConnectionBeenEstablished() ?
1093                         _("Yes") : _("No");
1094                 break;
1095
1096         case 9:
1097                 buffer = client->GetUserName().IsEmpty() ?
1098                         wxT("?") :
1099                         (client->HasDisabledSharedFiles() ? _("Yes") : _("No"));
1100                 break;
1101         }
1102
1103         dc->DrawText( buffer, rect.x, rect.y + 3 );
1104 }
1105
1106
1107 int CClientsView::SortProc(wxUIntPtr item1, wxUIntPtr item2, long sortData)
1108 {
1109         CUpDownClient* client1 = (CUpDownClient*)item1;
1110         CUpDownClient* client2 = (CUpDownClient*)item2;
1111
1112         // Ascending or decending?
1113         int mode = (sortData & CMuleListCtrl::SORT_DES) ? -1 : 1;
1114
1115         switch (sortData & CMuleListCtrl::COLUMN_MASK) {
1116         // Sort by Username
1117         case 0: return mode * client1->GetUserName().CmpNoCase( client2->GetUserName() );
1118
1119         // Sort by Uploading-state
1120         case 1: return mode * CmpAny( client1->GetUploadState(), client2->GetUploadState() );
1121
1122         // Sort by data-uploaded
1123         case 2:
1124                 return mode * CmpAny( client1->GetUploadedTotal(), client2->GetUploadedTotal() );
1125
1126         // Sort by Downloading-state
1127         case 3:
1128                 if( client1->GetDownloadState() == client2->GetDownloadState() ){
1129                         if( client1->IsRemoteQueueFull() && client2->IsRemoteQueueFull() ) {
1130                                 return mode *  0;
1131                         } else if( client1->IsRemoteQueueFull() ) {
1132                                 return mode *  1;
1133                         } else if( client2->IsRemoteQueueFull() ) {
1134                                 return mode * -1;
1135                         } else {
1136                                 return mode *  0;
1137                         }
1138                 }
1139                 return mode * CmpAny( client1->GetDownloadState(), client2->GetDownloadState() );
1140
1141         // Sort by data downloaded
1142         case 4:
1143                 return mode * CmpAny( client1->GetDownloadedTotal(), client2->GetDownloadedTotal() );
1144
1145         // Sort by client-software
1146         case 5: return mode * CompareVersions(client1, client2);
1147
1148         // Sort by connection
1149         case 6: return mode * CmpAny( client1->IsConnected(), client2->IsConnected() );
1150
1151         // Sort by user-hash
1152         case 7: return mode * CmpAny( client1->GetUserHash(), client2->GetUserHash() );
1153
1154         // Sort by Obfuscation state
1155         case 8: return mode * CmpAny( client2->HasObfuscatedConnectionBeenEstablished(), client1->HasObfuscatedConnectionBeenEstablished() );
1156
1157         // Sort by Shared Files DISabled
1158         case 9: return mode * CmpAny( client2->HasDisabledSharedFiles(), client1->HasDisabledSharedFiles() );
1159
1160         default:
1161                 return 0;
1162         }
1163
1164 }
1165 // File_checked_for_headers