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