src/amuleDlg.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 <wx/app.h>
  27
  28 #include <wx/archive.h>
  29 #include <wx/config.h>          // Do_not_auto_remove (MacOS 10.3, wx 2.7)
  30 #include <wx/confbase.h>        // Do_not_auto_remove (MacOS 10.3, wx 2.7)
  31 #include <wx/html/htmlwin.h>
  32 #include <wx/mimetype.h>        // Do_not_auto_remove (win32)
  33 #include <wx/stattext.h>
  34 #include <wx/stdpaths.h>
  35 #include <wx/textfile.h>        // Do_not_auto_remove (win32)
  36 #include <wx/tokenzr.h>
  37 #include <wx/wfstream.h>
  38 #include <wx/zipstrm.h>
  39 #include <wx/wupdlock.h>        // Needed for wxWindowUpdateLocker
  40
  41 #include <common/EventIDs.h>
  42
  43 #ifdef HAVE_CONFIG_H
  44 #include "config.h"             // Needed for SVNDATE, PACKAGE, VERSION
  45 #else
  46 #include <common/ClientVersion.h>
  47 #endif // HAVE_CONFIG_H
  48
  49 #include "amuleDlg.h"           // Interface declarations.
  50
  51 #include <common/Format.h>      // Needed for CFormat
  52 #include "amule.h"              // Needed for theApp
  53 #include "ChatWnd.h"            // Needed for CChatWnd
  54 #include "ClientListCtrl.h"     // Needed for CClientListCtrl
  55 #include "DownloadListCtrl.h"   // Needed for CDownloadListCtrl
  56 #include "DownloadQueue.h"      // Needed for CDownloadQueue
  57 #include "KadDlg.h"             // Needed for CKadDlg
  58 #include "Logger.h"
  59 #include "MuleTrayIcon.h"
  60 #include "muuli_wdr.h"          // Needed for ID_BUTTON*
  61 #include "Preferences.h"        // Needed for CPreferences
  62 #include "PrefsUnifiedDlg.h"
  63 #include "SearchDlg.h"          // Needed for CSearchDlg
  64 #include "Server.h"             // Needed for CServer
  65 #include "ServerConnect.h"      // Needed for CServerConnect
  66 #include "ServerWnd.h"          // Needed for CServerWnd
  67 #include "SharedFilesWnd.h"     // Needed for CSharedFilesWnd
  68 #include "Statistics.h"         // Needed for theStats
  69 #include "StatisticsDlg.h"      // Needed for CStatisticsDlg
  70 #include "TerminationProcess.h" // Needed for CTerminationProcess
  71 #include "TransferWnd.h"        // Needed for CTransferWnd
  72 #ifndef CLIENT_GUI
  73 #include "PartFileConvert.h"
  74 #endif
  75
  76 #ifndef __WXMSW__
  77 #include "aMule.xpm"
  78 #endif
  79
  80 #include "kademlia/kademlia/Kademlia.h"
  81
  82 #ifdef ENABLE_IP2COUNTRY
  83         #include "IP2Country.h"         // Needed for IP2Country
  84 #endif
  85
  86 BEGIN_EVENT_TABLE(CamuleDlg, wxFrame)
  87
  88         EVT_TOOL(ID_BUTTONNETWORKS, CamuleDlg::OnToolBarButton)
  89         EVT_TOOL(ID_BUTTONSEARCH, CamuleDlg::OnToolBarButton)
  90         EVT_TOOL(ID_BUTTONTRANSFER, CamuleDlg::OnToolBarButton)
  91         EVT_TOOL(ID_BUTTONSHARED, CamuleDlg::OnToolBarButton)
  92         EVT_TOOL(ID_BUTTONMESSAGES, CamuleDlg::OnToolBarButton)
  93         EVT_TOOL(ID_BUTTONSTATISTICS, CamuleDlg::OnToolBarButton)
  94         EVT_TOOL(ID_ABOUT, CamuleDlg::OnAboutButton)
  95
  96         EVT_TOOL(ID_BUTTONNEWPREFERENCES, CamuleDlg::OnPrefButton)
  97 #ifndef CLIENT_GUI
  98         EVT_TOOL(ID_BUTTONIMPORT, CamuleDlg::OnImportButton)
  99 #endif
 100
 101         EVT_TOOL(ID_BUTTONCONNECT, CamuleDlg::OnBnConnect)
 102
 103         EVT_CLOSE(CamuleDlg::OnClose)
 104         EVT_ICONIZE(CamuleDlg::OnMinimize)
 105
 106         EVT_BUTTON(ID_BUTTON_FAST, CamuleDlg::OnBnClickedFast)
 107         EVT_BUTTON(IDC_SHOWSTATUSTEXT, CamuleDlg::OnBnStatusText)
 108
 109         EVT_TIMER(ID_GUI_TIMER_EVENT, CamuleDlg::OnGUITimer)
 110
 111         EVT_SIZE(CamuleDlg::OnMainGUISizeChange)
 112
 113         EVT_KEY_UP(CamuleDlg::OnKeyPressed)
 114
 115         EVT_MENU(wxID_EXIT, CamuleDlg::OnExit)
 116
 117 END_EVENT_TABLE()
 118
 119 #ifndef wxCLOSE_BOX
 120         #define wxCLOSE_BOX 0
 121 #endif
 122
 123 CamuleDlg::CamuleDlg(
 124         wxWindow* pParent,
 125         const wxString &title,
 126         wxPoint where,
 127         wxSize dlg_size)
 128 :
 129 wxFrame(
 130         pParent, -1, title, where, dlg_size,
 131         wxCAPTION|wxRESIZE_BORDER|wxSYSTEM_MENU|wxDIALOG_NO_PARENT|
 132         wxRESIZE_BORDER|wxMINIMIZE_BOX|wxMAXIMIZE_BOX|wxCLOSE_BOX,
 133         wxT("aMule")),
 134 m_activewnd(NULL),
 135 m_transferwnd(NULL),
 136 m_serverwnd(NULL),
 137 m_sharedfileswnd(NULL),
 138 m_searchwnd(NULL),
 139 m_chatwnd(NULL),
 140 m_statisticswnd(NULL),
 141 m_kademliawnd(NULL),
 142 m_prefsDialog(NULL),
 143 m_srv_split_pos(0),
 144 m_imagelist(16,16),
 145 m_tblist(32,32),
 146 m_prefsVisible(false),
 147 m_wndToolbar(NULL),
 148 m_wndTaskbarNotifier(NULL),
 149 m_nActiveDialog(DT_NETWORKS_WND),
 150 m_is_safe_state(false),
 151 m_BlinkMessages(false),
 152 m_CurrentBlinkBitmap(24),
 153 m_last_iconizing(0),
 154 m_skinFileName(),
 155 m_clientSkinNames(CLIENT_SKIN_SIZE)
 156 {
 157         // Initialize skin names
 158         m_clientSkinNames[Client_Green_Smiley]            = wxT("Transfer");
 159         m_clientSkinNames[Client_Red_Smiley]              = wxT("Connecting");
 160         m_clientSkinNames[Client_Yellow_Smiley]           = wxT("OnQueue");
 161         m_clientSkinNames[Client_Grey_Smiley]             = wxT("A4AFNoNeededPartsQueueFull");
 162         m_clientSkinNames[Client_White_Smiley]            = wxT("StatusUnknown");
 163         m_clientSkinNames[Client_ExtendedProtocol_Smiley] = wxT("ExtendedProtocol");
 164         m_clientSkinNames[Client_SecIdent_Smiley]         = wxT("SecIdent");
 165         m_clientSkinNames[Client_BadGuy_Smiley]           = wxT("BadGuy");
 166         m_clientSkinNames[Client_CreditsGrey_Smiley]      = wxT("CreditsGrey");
 167         m_clientSkinNames[Client_CreditsYellow_Smiley]    = wxT("CreditsYellow");
 168         m_clientSkinNames[Client_Upload_Smiley]           = wxT("Upload");
 169         m_clientSkinNames[Client_Friend_Smiley]           = wxT("Friend");
 170         m_clientSkinNames[Client_eMule_Smiley]            = wxT("eMule");
 171         m_clientSkinNames[Client_mlDonkey_Smiley]         = wxT("mlDonkey");
 172         m_clientSkinNames[Client_eDonkeyHybrid_Smiley]    = wxT("eDonkeyHybrid");
 173         m_clientSkinNames[Client_aMule_Smiley]            = wxT("aMule");
 174         m_clientSkinNames[Client_lphant_Smiley]           = wxT("lphant");
 175         m_clientSkinNames[Client_Shareaza_Smiley]         = wxT("Shareaza");
 176         m_clientSkinNames[Client_xMule_Smiley]            = wxT("xMule");
 177         m_clientSkinNames[Client_Unknown]                 = wxT("Unknown");
 178         m_clientSkinNames[Client_InvalidRating_Smiley]    = wxT("InvalidRatingOnFile");
 179         m_clientSkinNames[Client_PoorRating_Smiley]       = wxT("PoorRatingOnFile");
 180         m_clientSkinNames[Client_GoodRating_Smiley]       = wxT("GoodRatingOnFile");
 181         m_clientSkinNames[Client_FairRating_Smiley]       = wxT("FairRatingOnFile");
 182         m_clientSkinNames[Client_ExcellentRating_Smiley]  = wxT("ExcellentRatingOnFile");
 183         m_clientSkinNames[Client_CommentOnly_Smiley]      = wxT("CommentOnly");
 184         m_clientSkinNames[Client_Encryption_Smiley]       = wxT("Encrypted");
 185
 186         // wxWidgets send idle events to ALL WINDOWS by default... *SIGH*
 187         wxIdleEvent::SetMode(wxIDLE_PROCESS_SPECIFIED);
 188         wxUpdateUIEvent::SetMode(wxUPDATE_UI_PROCESS_SPECIFIED);
 189         wxInitAllImageHandlers();
 190         Apply_Clients_Skin();
 191
 192         bool override_where = where != wxDefaultPosition;
 193         bool override_size =
 194                 dlg_size.x != DEFAULT_SIZE_X ||
 195                 dlg_size.y != DEFAULT_SIZE_Y;
 196         if (!LoadGUIPrefs(override_where, override_size)) {
 197                 // Prefs not loaded for some reason, exit
 198                 AddLogLineM( true, wxT("Error! Unable to load Preferences") );
 199                 return;
 200         }
 201
 202         SetIcon(wxICON(aMule));
 203
 204         srand(time(NULL));
 205
 206         // Create new sizer and stuff a wxPanel in there.
 207         wxFlexGridSizer *s_main = new wxFlexGridSizer(1);
 208         s_main->AddGrowableCol(0);
 209         s_main->AddGrowableRow(0);
 210
 211         wxPanel* p_cnt = new wxPanel(this, -1, wxDefaultPosition, wxDefaultSize);
 212         s_main->Add(p_cnt, 0, wxGROW|wxEXPAND, 0);
 213         muleDlg(p_cnt, false, true);
 214         SetSizer(s_main, true);
 215
 216         m_serverwnd = new CServerWnd(p_cnt, m_srv_split_pos);
 217         AddLogLineM(false, wxEmptyString);
 218         AddLogLineM(false, wxT(" - ") +
 219                 CFormat(_("This is aMule %s based on eMule.")) % GetMuleVersion());
 220         AddLogLineM(false, wxT("   ") +
 221                 CFormat(_("Running on %s")) % wxGetOsDescription());
 222         AddLogLineM(false, wxT(" - ") +
 223                 wxString(_("Visit http://www.amule.org to check if a new version is available.")));
 224         AddLogLineM(false, wxEmptyString);
 225
 226 #ifdef ENABLE_IP2COUNTRY
 227         m_IP2Country = new CIP2Country();
 228 #endif
 229         m_searchwnd = new CSearchDlg(p_cnt);
 230         m_transferwnd = new CTransferWnd(p_cnt);
 231         m_sharedfileswnd = new CSharedFilesWnd(p_cnt);
 232         m_statisticswnd = new CStatisticsDlg(p_cnt, theApp->m_statistics);
 233         m_chatwnd = new CChatWnd(p_cnt);
 234         m_kademliawnd = CastChild(wxT("kadWnd"), CKadDlg);
 235
 236         m_serverwnd->Show(false);
 237         m_searchwnd->Show(false);
 238         m_transferwnd->Show(false);
 239         m_sharedfileswnd->Show(false);
 240         m_statisticswnd->Show(false);
 241         m_chatwnd->Show(false);
 242
 243         // Create the GUI timer
 244         gui_timer=new wxTimer(this,ID_GUI_TIMER_EVENT);
 245         if (!gui_timer) {
 246                 AddLogLine(false, _("Fatal Error: Failed to create Timer"));
 247                 exit(1);
 248         }
 249
 250         // Set Serverlist as active window
 251         Create_Toolbar(thePrefs::VerticalToolbar());
 252         SetActiveDialog(DT_NETWORKS_WND, m_serverwnd);
 253         m_wndToolbar->ToggleTool(ID_BUTTONNETWORKS, true );
 254
 255         m_is_safe_state = true;
 256
 257         // Init statistics stuff, better do it asap
 258         m_statisticswnd->Init();
 259         m_kademliawnd->Init();
 260         m_searchwnd->UpdateCatChoice();
 261         if (thePrefs::UseTrayIcon()) {
 262                 CreateSystray();
 263         }
 264
 265         Show(true);
 266         // Must we start minimized?
 267         if (thePrefs::GetStartMinimized()) {
 268                 DoIconize(true);
 269         }
 270
 271         // Set shortcut keys
 272         wxAcceleratorEntry entries[] = {
 273                 wxAcceleratorEntry(wxACCEL_CTRL, wxT('Q'), wxID_EXIT)
 274         };
 275
 276         SetAcceleratorTable(wxAcceleratorTable(itemsof(entries), entries));
 277         ShowED2KLinksHandler( thePrefs::GetFED2KLH() );
 278 }
 279
 280
 281 // Madcat - Sets Fast ED2K Links Handler on/off.
 282 void CamuleDlg::ShowED2KLinksHandler( bool show )
 283 {
 284         // Errorchecking in case the pointer becomes invalid ...
 285         if (s_fed2klh == NULL) {
 286                 wxLogWarning(wxT("Unable to find Fast ED2K Links handler sizer! Hiding FED2KLH aborted."));
 287                 return;
 288         }
 289
 290         s_dlgcnt->Show( s_fed2klh, show );
 291         s_dlgcnt->Layout();
 292 }
 293
 294 // Toogles ed2k link handler.
 295 void CamuleDlg::ToogleED2KLinksHandler()
 296 {
 297         // Errorchecking in case the pointer becomes invalid ...
 298         if (s_fed2klh == NULL) {
 299                 wxLogWarning(wxT("Unable to find Fast ED2K Links handler sizer! Toogling FED2KLH aborted."));
 300                 return;
 301         }
 302         ShowED2KLinksHandler(!s_dlgcnt->IsShown(s_fed2klh));
 303 }
 304
 305 void CamuleDlg::SetActiveDialog(DialogType type, wxWindow* dlg)
 306 {
 307         m_nActiveDialog = type;
 308
 309         if ( type == DT_TRANSFER_WND ) {
 310                 if (thePrefs::ShowCatTabInfos()) {
 311                         m_transferwnd->UpdateCatTabTitles();
 312                 }
 313         }
 314
 315         if ( m_activewnd ) {
 316                 m_activewnd->Show(false);
 317                 contentSizer->Detach(m_activewnd);
 318         }
 319
 320         contentSizer->Add(dlg, 1, wxALIGN_LEFT|wxEXPAND);
 321         dlg->Show(true);
 322         m_activewnd=dlg;
 323         s_dlgcnt->Layout();
 324
 325         // Since we might be suspending redrawing while hiding the dialog
 326         // we have to refresh it once it is visible again
 327         dlg->Refresh( true );
 328         dlg->SetFocus();
 329 }
 330
 331
 332 void CamuleDlg::UpdateTrayIcon(int percent)
 333 {
 334         // set trayicon-icon
 335         if(!theApp->IsConnected()) {
 336                 m_wndTaskbarNotifier->SetTrayIcon(TRAY_ICON_DISCONNECTED, percent);
 337         } else {
 338                 if(theApp->IsConnectedED2K() && theApp->serverconnect->IsLowID()) {
 339                         m_wndTaskbarNotifier->SetTrayIcon(TRAY_ICON_LOWID, percent);
 340                 } else {
 341                         m_wndTaskbarNotifier->SetTrayIcon(TRAY_ICON_HIGHID, percent);
 342                 }
 343         }
 344 }
 345
 346
 347 void CamuleDlg::CreateSystray()
 348 {
 349         wxCHECK_RET(m_wndTaskbarNotifier == NULL,
 350                 wxT("Systray already created"));
 351
 352         m_wndTaskbarNotifier = new CMuleTrayIcon();
 353         // This will effectively show the Tray Icon.
 354         UpdateTrayIcon(0);
 355 }
 356
 357
 358 void CamuleDlg::RemoveSystray()
 359 {
 360         delete m_wndTaskbarNotifier;
 361         m_wndTaskbarNotifier = NULL;
 362 }
 363
 364
 365 void CamuleDlg::OnToolBarButton(wxCommandEvent& ev)
 366 {
 367         static int lastbutton = ID_BUTTONNETWORKS;
 368
 369         // Kry - just if the GUI is ready for it
 370         if ( m_is_safe_state ) {
 371
 372                 // Rehide the handler if needed
 373                 if ( lastbutton == ID_BUTTONSEARCH && !thePrefs::GetFED2KLH() ) {
 374                         if (ev.GetId() != ID_BUTTONSEARCH) {
 375                                 ShowED2KLinksHandler( false );
 376                         } else {
 377                                 // Toogle ED2K handler.
 378                                 ToogleED2KLinksHandler();
 379                         }
 380                 }
 381
 382                 if ( lastbutton != ev.GetId() ) {
 383                         switch ( ev.GetId() ) {
 384                                 case ID_BUTTONNETWORKS:
 385                                         SetActiveDialog(DT_NETWORKS_WND, m_serverwnd);
 386                                         // Set serverlist splitter position
 387                                         CastChild( wxT("SrvSplitterWnd"), wxSplitterWindow )->SetSashPosition(m_srv_split_pos, true);
 388                                         break;
 389
 390                                 case ID_BUTTONSEARCH:
 391                                         // The search dialog should always display the handler
 392                                         if ( !thePrefs::GetFED2KLH() )
 393                                                 ShowED2KLinksHandler( true );
 394
 395                                         SetActiveDialog(DT_SEARCH_WND, m_searchwnd);
 396                                         break;
 397
 398                                 case ID_BUTTONTRANSFER:
 399                                         SetActiveDialog(DT_TRANSFER_WND, m_transferwnd);
 400                                         // Prepare the dialog, sets the splitter-position
 401                                         m_transferwnd->Prepare();
 402                                         break;
 403
 404                                 case ID_BUTTONSHARED:
 405                                         SetActiveDialog(DT_SHARED_WND, m_sharedfileswnd);
 406                                         break;
 407
 408                                 case ID_BUTTONMESSAGES:
 409                                         m_BlinkMessages = false;
 410                                         SetActiveDialog(DT_CHAT_WND, m_chatwnd);
 411                                         break;
 412
 413                                 case ID_BUTTONSTATISTICS:
 414                                         SetActiveDialog(DT_STATS_WND, m_statisticswnd);
 415                                         break;
 416
 417                                 // This shouldn't happen, but just in case
 418                                 default:
 419                                         AddLogLineM( true, wxT("Unknown button triggered CamuleApp::OnToolBarButton().") );
 420                                         break;
 421                         }
 422                 }
 423
 424                 m_wndToolbar->ToggleTool(lastbutton, lastbutton == ev.GetId() );
 425                 lastbutton = ev.GetId();
 426         }
 427 }
 428
 429
 430 void CamuleDlg::OnAboutButton(wxCommandEvent& WXUNUSED(ev))
 431 {
 432         wxString msg = wxT(" ");
 433 #ifdef CLIENT_GUI
 434         msg << _("aMule remote control ") << wxT(VERSION);
 435 #else
 436         msg << wxT("aMule ") << wxT(VERSION);
 437 #endif
 438         msg << wxT(" ");
 439 #ifdef SVNDATE
 440         msg << _("Snapshot:") << wxT("\n ") << wxT(SVNDATE);
 441 #endif
 442         msg << wxT("\n\n") << _(" 'All-Platform' p2p client based on eMule \n\n") <<
 443                 _(" Website: http://www.amule.org \n") <<
 444                 _(" Forum: http://forum.amule.org \n") <<
 445                 _(" FAQ: http://wiki.amule.org \n\n") <<
 446                 _(" Contact: admin@amule.org (administrative issues) \n") <<
 447                 _(" Copyright (C) 2003-2008 aMule Team \n\n") <<
 448                 _(" Part of aMule is based on \n") <<
 449                 _("Kademlia: Peer-to-peer routing based on the XOR metric.\n") <<
 450                 _(" Copyright (C) 2002 Petar Maymounkov\n") <<
 451                 _(" http://kademlia.scs.cs.nyu.edu\n");
 452
 453         if (m_is_safe_state) {
 454                 wxMessageBox(msg, _("Message"), wxOK | wxICON_INFORMATION, this);
 455         }
 456 }
 457
 458
 459 void CamuleDlg::OnPrefButton(wxCommandEvent& WXUNUSED(ev))
 460 {
 461         if (m_is_safe_state) {
 462                 if (m_prefsDialog == NULL) {
 463                         m_prefsDialog = new PrefsUnifiedDlg(this);
 464                 }
 465
 466                 m_prefsDialog->TransferToWindow();
 467                 m_prefsDialog->Show(true);
 468                 m_prefsDialog->Raise();
 469         }
 470 }
 471
 472
 473 #ifndef CLIENT_GUI
 474 void CamuleDlg::OnImportButton(wxCommandEvent& WXUNUSED(ev))
 475 {
 476         if ( m_is_safe_state ) {
 477                 CPartFileConvert::ShowGUI(NULL);
 478         }
 479 }
 480 #endif
 481
 482 CamuleDlg::~CamuleDlg()
 483 {
 484         printf("Shutting down aMule...\n");
 485
 486         SaveGUIPrefs();
 487
 488         theApp->amuledlg = NULL;
 489
 490         printf("aMule dialog destroyed\n");
 491 }
 492
 493
 494 void CamuleDlg::OnBnConnect(wxCommandEvent& WXUNUSED(evt))
 495 {
 496
 497         bool disconnect = (theApp->IsConnectedED2K() || theApp->serverconnect->IsConnecting())
 498                                                 #ifndef CLIENT_GUI
 499                                                 || (Kademlia::CKademlia::IsRunning())
 500                                                 #endif
 501                                                 ;
 502         if (thePrefs::GetNetworkED2K()) {
 503                 if (disconnect) {
 504                         //disconnect if currently connected
 505                         if (theApp->serverconnect->IsConnecting()) {
 506                                 theApp->serverconnect->StopConnectionTry();
 507                         } else {
 508                                 theApp->serverconnect->Disconnect();
 509                         }
 510                 } else {
 511                         //connect if not currently connected
 512                         AddLogLine(true, _("Connecting"));
 513                         theApp->serverconnect->ConnectToAnyServer();
 514                 }
 515         } else {
 516                 wxASSERT(!theApp->IsConnectedED2K());
 517         }
 518
 519         // Connect Kad also
 520         if (thePrefs::GetNetworkKademlia()) {
 521                 if( disconnect ) {
 522                         theApp->StopKad();
 523                 } else {
 524                         theApp->StartKad();
 525                 }
 526         } else {
 527                 #ifndef CLIENT_GUI
 528                         wxASSERT(!Kademlia::CKademlia::IsRunning());
 529                 #endif
 530         }
 531
 532         ShowConnectionState();
 533 }
 534
 535
 536 void CamuleDlg::OnBnStatusText(wxCommandEvent& WXUNUSED(evt))
 537 {
 538         wxString line = CastChild(wxT("infoLabel"), wxStaticText)->GetLabel();
 539
 540         if (!line.IsEmpty()) {
 541                 wxMessageBox(line, wxString(_("Status text")), wxOK|wxICON_INFORMATION, this);
 542         }
 543 }
 544
 545
 546 void CamuleDlg::ResetLog(int id)
 547 {
 548         wxTextCtrl* ct = CastByID(id, m_serverwnd, wxTextCtrl);
 549         wxCHECK_RET(ct, wxT("Resetting unknown log"));
 550
 551         ct->Clear();
 552
 553         if (id == ID_LOGVIEW) {
 554                 // Also clear the log line
 555                 wxStaticText* text = CastChild(wxT("infoLabel"), wxStaticText);
 556                 text->SetLabel(wxEmptyString);
 557                 text->GetParent()->Layout();
 558         }
 559 }
 560
 561
 562 void CamuleDlg::AddLogLine(bool addtostatusbar, const wxString& line)
 563 {
 564         // Remove newspace at end, it causes problems with the layout...
 565         wxString bufferline = line.Strip(wxString::trailing);
 566
 567         // Create the timestamp
 568         wxString stamp = wxDateTime::Now().FormatISODate() + wxT(" ") + wxDateTime::Now().FormatISOTime() + wxT(": ");
 569
 570         // Add the message to the log-view
 571         wxTextCtrl* ct = CastByID( ID_LOGVIEW, m_serverwnd, wxTextCtrl );
 572         if ( ct ) {
 573                 if ( bufferline.IsEmpty() ) {
 574                         // If it's empty we just write a blank line with no timestamp.
 575                         ct->AppendText( wxT("\n") );
 576                 } else {
 577                         // Bold critical log-lines
 578                         wxTextAttr style = ct->GetDefaultStyle();
 579                         wxFont font = style.GetFont();
 580                         font.SetWeight(addtostatusbar ? wxFONTWEIGHT_BOLD : wxFONTWEIGHT_NORMAL);
 581                         style.SetFont(font);
 582                         ct->SetDefaultStyle(style);
 583
 584                         // Split multi-line messages into individual lines
 585                         wxStringTokenizer tokens( bufferline, wxT("\n") );
 586                         while ( tokens.HasMoreTokens() ) {
 587                                 ct->AppendText( stamp + tokens.GetNextToken() + wxT("\n") );
 588                         }
 589                 }
 590
 591                 ct->ShowPosition( ct->GetLastPosition() - 1 );
 592         }
 593
 594
 595         // Set the status-bar if the event warrents it
 596         if ( addtostatusbar ) {
 597                 // Escape "&"s, which would otherwise not show up
 598                 bufferline.Replace( wxT("&"), wxT("&&") );
 599                 wxStaticText* text = CastChild( wxT("infoLabel"), wxStaticText );
 600                 // Only show the first line if multiple lines
 601                 text->SetLabel( bufferline.BeforeFirst( wxT('\n') ) );
 602                 text->GetParent()->Layout();
 603         }
 604
 605 }
 606
 607
 608 void CamuleDlg::AddServerMessageLine(wxString& message)
 609 {
 610         wxTextCtrl* cv= CastByID( ID_SERVERINFO, m_serverwnd, wxTextCtrl );
 611         if(cv) {
 612                 if (message.Length() > 500) {
 613                         cv->AppendText(message.Left(500) + wxT("\n"));
 614                 } else {
 615                         cv->AppendText(message + wxT("\n"));
 616                 }
 617                 cv->ShowPosition(cv->GetLastPosition()-1);
 618         }
 619 }
 620
 621
 622 void CamuleDlg::ShowConnectionState()
 623 {
 624         static wxImageList status_arrows(16,16,true,0);
 625         if (!status_arrows.GetImageCount()) {
 626                 // Generate the image list (This is only done once)
 627                 for (int t = 0; t < 7; ++t) {
 628                         status_arrows.Add(connImages(t));
 629                 }
 630         }
 631
 632         m_serverwnd->UpdateED2KInfo();
 633         m_serverwnd->UpdateKadInfo();
 634
 635
 636         ////////////////////////////////////////////////////////////
 637         // Determine the status of the networks
 638         //
 639         enum ED2KState { ED2KOff = 0, ED2KLowID = 1, ED2KConnecting = 2, ED2KHighID = 3 };
 640         enum EKadState { EKadOff = 4, EKadFW = 5, EKadConnecting = 5, EKadOK = 6 };
 641
 642         ED2KState ed2kState = ED2KOff;
 643         EKadState kadState  = EKadOff;
 644
 645         ////////////////////////////////////////////////////////////
 646         // Update the label on the status-bar and determine
 647         // the states of the two networks.
 648         //
 649         wxString msgED2K;
 650         if (theApp->IsConnectedED2K()) {
 651                 CServer* server = theApp->serverconnect->GetCurrentServer();
 652                 if (server) {
 653                         msgED2K = CFormat(wxT("ED2K: %s")) % server->GetListName();
 654                 }
 655
 656                 if (theApp->serverconnect->IsLowID()) {
 657                         ed2kState = ED2KLowID;
 658                 } else {
 659                         ed2kState = ED2KHighID;
 660                 }
 661         } else if (theApp->serverconnect->IsConnecting()) {
 662                 msgED2K = _("ED2K: Connecting");
 663
 664                 ed2kState = ED2KConnecting;
 665         } else if (thePrefs::GetNetworkED2K()) {
 666                 msgED2K = _("ED2K: Disconnected");
 667         }
 668
 669         wxString msgKad;
 670         if (theApp->IsConnectedKad()) {
 671                 if (theApp->IsFirewalledKad()) {
 672                         msgKad = _("Kad: Firewalled");
 673
 674                         kadState = EKadFW;
 675                 } else {
 676                         msgKad = _("Kad: Connected");
 677
 678                         kadState = EKadOK;
 679                 }
 680         } else if (theApp->IsKadRunning()) {
 681                 msgKad = _("Kad: Connecting");
 682
 683                 kadState = EKadConnecting;
 684         } else if (thePrefs::GetNetworkKademlia()) {
 685                 msgKad = _("Kad: Off");
 686         }
 687
 688         wxStaticText* connLabel = CastChild( wxT("connLabel"), wxStaticText );
 689         wxCHECK_RET(connLabel, wxT("'connLabel' widget not found"));
 690
 691         wxString labelMsg;
 692         if (msgED2K.Length() && msgKad.Length()) {
 693                 labelMsg = msgED2K + wxT(" | ") + msgKad;
 694         } else {
 695                 labelMsg = msgED2K + msgKad;
 696         }
 697
 698         connLabel->SetLabel(labelMsg);
 699         connLabel->GetParent()->Layout();
 700
 701
 702         ////////////////////////////////////////////////////////////
 703         // Update the connect/disconnect/cancel button.
 704         //
 705         enum EConnState {
 706                 ECS_Unknown,
 707                 ECS_Connected,
 708                 ECS_Connecting,
 709                 ECS_Disconnected
 710         };
 711
 712         static EConnState s_oldState = ECS_Unknown;
 713         EConnState currentState = ECS_Disconnected;
 714
 715         if (theApp->serverconnect->IsConnecting() ||
 716                         (theApp->IsKadRunning() && !theApp->IsConnectedKad())) {
 717                 currentState = ECS_Connecting;
 718         } else if (theApp->IsConnected()) {
 719                 currentState = ECS_Connected;
 720         } else {
 721                 currentState = ECS_Disconnected;
 722         }
 723
 724         if (currentState != s_oldState) {
 725                 m_wndToolbar->Freeze();
 726                 wxToolBarToolBase* toolbarTool = m_wndToolbar->RemoveTool(ID_BUTTONCONNECT);
 727
 728                 switch (currentState) {
 729                         case ECS_Connecting:
 730                                 toolbarTool->SetLabel(_("Cancel"));
 731                                 toolbarTool->SetShortHelp(_("Stop the current connection attempts"));
 732                                 toolbarTool->SetNormalBitmap(m_tblist.GetBitmap(2));
 733                                 break;
 734
 735                         case ECS_Connected:
 736                                 toolbarTool->SetLabel(_("Disconnect"));
 737                                 toolbarTool->SetShortHelp(_("Disconnect from the currently connected networks"));
 738                                 toolbarTool->SetNormalBitmap(m_tblist.GetBitmap(1));
 739                                 break;
 740
 741                         default:
 742                                 toolbarTool->SetLabel(_("Connect"));
 743                                 toolbarTool->SetShortHelp(_("Connect to the currently enabled networks"));
 744                                 toolbarTool->SetNormalBitmap(m_tblist.GetBitmap(0));
 745                 }
 746
 747                 m_wndToolbar->InsertTool(0, toolbarTool);
 748                 m_wndToolbar->Realize();
 749                 m_wndToolbar->Thaw();
 750
 751                 s_oldState = currentState;
 752         }
 753
 754
 755         ////////////////////////////////////////////////////////////
 756         // Update the globe-icon in the lower-right corner.
 757         //
 758         wxStaticBitmap* connBitmap = CastChild( wxT("connImage"), wxStaticBitmap );
 759         wxCHECK_RET(connBitmap, wxT("'connImage' widget not found"));
 760
 761         wxBitmap statusIcon = connBitmap->GetBitmap();
 762         wxMemoryDC bitmapDC(statusIcon);
 763
 764         status_arrows.Draw(kadState, bitmapDC, 0, 0, wxIMAGELIST_DRAW_TRANSPARENT);
 765         status_arrows.Draw(ed2kState, bitmapDC, 0, 0, wxIMAGELIST_DRAW_TRANSPARENT);
 766
 767         connBitmap->SetBitmap(statusIcon);
 768 }
 769
 770
 771 void CamuleDlg::ShowUserCount(const wxString& info)
 772 {
 773         wxStaticText* label = CastChild( wxT("userLabel"), wxStaticText );
 774
 775         // Update Kad tab
 776         m_serverwnd->UpdateKadInfo();
 777
 778         label->SetLabel(info);
 779         label->GetParent()->Layout();
 780 }
 781
 782
 783 void CamuleDlg::ShowTransferRate()
 784 {
 785         float kBpsUp = theStats::GetUploadRate() / 1024.0;
 786         float kBpsDown = theStats::GetDownloadRate() / 1024.0;
 787         wxString buffer;
 788         if( thePrefs::ShowOverhead() )
 789         {
 790                 buffer = wxString::Format(_("Up: %.1f(%.1f) | Down: %.1f(%.1f)"), kBpsUp, theStats::GetUpOverheadRate() / 1024.0, kBpsDown, theStats::GetDownOverheadRate() / 1024.0);
 791         } else {
 792                 buffer = wxString::Format(_("Up: %.1f | Down: %.1f"), kBpsUp, kBpsDown);
 793         }
 794         buffer.Truncate(50); // Max size 50
 795
 796         wxStaticText* label = CastChild( wxT("speedLabel"), wxStaticText );
 797         label->SetLabel(buffer);
 798         label->GetParent()->Layout();
 799
 800         // Show upload/download speed in title
 801         if (thePrefs::GetShowRatesOnTitle()) {
 802                 wxString UpDownSpeed = wxString::Format(wxT(" -- Up: %.1f | Down: %.1f"), kBpsUp, kBpsDown);
 803                 SetTitle(theApp->m_FrameTitle + UpDownSpeed);
 804         }
 805
 806         wxASSERT((m_wndTaskbarNotifier != NULL) == thePrefs::UseTrayIcon());
 807         if (m_wndTaskbarNotifier) {
 808                 // set trayicon-icon
 809                 int percentDown = (int)ceil((kBpsDown*100) / thePrefs::GetMaxGraphDownloadRate());
 810                 UpdateTrayIcon( ( percentDown > 100 ) ? 100 : percentDown);
 811
 812                 wxString buffer2;
 813                 if ( theApp->IsConnected() ) {
 814                         buffer2 = CFormat(_("aMule (%s | Connected)")) % buffer;
 815                 } else {
 816                         buffer2 = CFormat(_("aMule (%s | Disconnected)")) % buffer;
 817                 }
 818                 m_wndTaskbarNotifier->SetTrayToolTip(buffer2);
 819         }
 820
 821         wxStaticBitmap* bmp = CastChild( wxT("transferImg"), wxStaticBitmap );
 822         bmp->SetBitmap(dlStatusImages((kBpsUp>0.01 ? 2 : 0) + (kBpsDown>0.01 ? 1 : 0)));
 823 }
 824
 825 void CamuleDlg::DlgShutDown()
 826 {
 827         // Are we already shutting down or still on init?
 828         if ( m_is_safe_state == false ) {
 829                 return;
 830         }
 831
 832         // we are going DOWN
 833         m_is_safe_state = false;
 834
 835         // Stop the GUI Timer
 836         delete gui_timer;
 837         m_transferwnd->downloadlistctrl->DeleteAllItems();
 838
 839         // We want to delete the systray too!
 840         RemoveSystray();
 841 }
 842
 843 void CamuleDlg::OnClose(wxCloseEvent& evt)
 844 {
 845         // This will be here till the core close is != app close
 846         if (evt.CanVeto() && thePrefs::IsConfirmExitEnabled() ) {
 847                 if (wxNO == wxMessageBox(wxString(_("Do you really want to exit aMule?")),
 848                                 wxString(_("Exit confirmation")), wxYES_NO, this)) {
 849                         evt.Veto();
 850                         return;
 851                 }
 852         }
 853
 854         Enable(false);
 855         Show(false);
 856
 857         theApp->ShutDown(evt);
 858 }
 859
 860
 861 void CamuleDlg::OnBnClickedFast(wxCommandEvent& WXUNUSED(evt))
 862 {
 863         wxTextCtrl* ctl = CastChild( wxT("FastEd2kLinks"), wxTextCtrl );
 864
 865         for ( int i = 0; i < ctl->GetNumberOfLines(); i++ ) {
 866                 wxString strlink = ctl->GetLineText(i);
 867                 strlink.Trim(true);
 868                 strlink.Trim(false);
 869                 if ( !strlink.IsEmpty() ) {
 870                         theApp->downloadqueue->AddLink( strlink, m_transferwnd->downloadlistctrl->GetCategory() );
 871                 }
 872         }
 873
 874         ctl->SetValue(wxEmptyString);
 875 }
 876
 877
 878 // Formerly known as LoadRazorPrefs()
 879 bool CamuleDlg::LoadGUIPrefs(bool override_pos, bool override_size)
 880 {
 881         // Create a config base for loading razor preferences
 882         wxConfigBase *config = wxConfigBase::Get();
 883         // If config haven't been created exit without loading
 884         if (config == NULL) {
 885                 return false;
 886         }
 887
 888         // The section where to save in in file
 889         wxString section = wxT("/Razor_Preferences/");
 890
 891         // Get window size and position
 892         int x1 = config->Read(section + wxT("MAIN_X_POS"), -1);
 893         int y1 = config->Read(section + wxT("MAIN_Y_POS"), -1);
 894         int x2 = config->Read(section + wxT("MAIN_X_SIZE"), -1);
 895         int y2 = config->Read(section + wxT("MAIN_Y_SIZE"), -1);
 896
 897         int maximized = config->Read(section + wxT("Maximized"), 01);
 898
 899         // Kry - Random usable pos for m_srv_split_pos
 900         m_srv_split_pos = config->Read(section + wxT("SRV_SPLITTER_POS"), 463l);
 901         if (!override_size) {
 902                 if (x2 > 0 && y2 > 0) {
 903                         SetSize(x2, y2);
 904                 } else {
 905 #ifndef __WXGTK__
 906                         // Probably first run.
 907                         Maximize();
 908 #endif
 909                 }
 910         }
 911
 912         if (!override_pos) {
 913                 // If x1 and y1 != -1 Redefine location
 914                 if(x1 != -1 && y1 != -1) {
 915                         wxRect display = wxGetClientDisplayRect();
 916                         if (x1 <= display.GetRightTop().x && y1 <= display.GetRightBottom().y) {
 917                                 Move(x1, y1);
 918                         } else {
 919                                 // It's offscreen... so let's not.
 920                         }
 921                 }
 922         }
 923
 924         if (!override_size && !override_pos && maximized) {
 925                 Maximize();
 926         }
 927
 928         return true;
 929 }
 930
 931
 932 bool CamuleDlg::SaveGUIPrefs()
 933 {
 934         /* Razor 1a - Modif by MikaelB
 935            Save client size and position */
 936
 937         // Create a config base for saving razor preferences
 938         wxConfigBase *config = wxConfigBase::Get();
 939         // If config haven't been created exit without saving
 940         if (config == NULL) {
 941                 return false;
 942         }
 943         // The section where to save in in file
 944         wxString section = wxT("/Razor_Preferences/");
 945
 946         // Main window location and size
 947         int x1, y1, x2, y2;
 948         GetPosition(&x1, &y1);
 949         GetSize(&x2, &y2);
 950
 951         // Saving window size and position
 952         config->Write(section+wxT("MAIN_X_POS"), (long) x1);
 953         config->Write(section+wxT("MAIN_Y_POS"), (long) y1);
 954
 955         config->Write(section+wxT("MAIN_X_SIZE"), (long) x2);
 956         config->Write(section+wxT("MAIN_Y_SIZE"), (long) y2);
 957
 958         config->Write(section+wxT("Maximized"), (long) (IsMaximized() ? 1 : 0));
 959
 960         // Saving sash position of splitter in server window
 961         config->Write(section+wxT("SRV_SPLITTER_POS"), (long) m_srv_split_pos);
 962
 963         config->Flush(true);
 964
 965         /* End modif */
 966
 967         return true;
 968 }
 969
 970
 971 void CamuleDlg::DoIconize(bool iconize)
 972 {
 973         // Evil Hack: check if the mouse is inside the window
 974 #ifndef __WINDOWS__
 975         if (GetScreenRect().Contains(wxGetMousePosition()))
 976 #endif
 977         {
 978                 if (m_wndTaskbarNotifier && thePrefs::DoMinToTray()) {
 979                         if (iconize) {
 980                                 // Skip() will do it.
 981                                 //Iconize(true);
 982                                 if (SafeState()) {
 983                                         Show(false);
 984                                 }
 985                         } else {
 986                                 Show(true);
 987                                 Raise();
 988                         }
 989                 } else {
 990                         // Will be done by Skip();
 991                         //Iconize(iconize);
 992                 }
 993         }
 994 }
 995
 996 void CamuleDlg::OnMinimize(wxIconizeEvent& evt)
 997 {
 998         if (m_prefsDialog && m_prefsDialog->IsShown()) {
 999                 // Veto.
1000         } else {
1001                 if (m_wndTaskbarNotifier) {
1002                         DoIconize(evt.Iconized());
1003                 }
1004                 evt.Skip();
1005         }
1006 }
1007
1008 void CamuleDlg::OnGUITimer(wxTimerEvent& WXUNUSED(evt))
1009 {
1010         // Former TimerProc section
1011
1012         static uint32   msPrev1, msPrev5, msPrevStats;
1013
1014         uint32                  msCur = theStats::GetUptimeMillis();
1015
1016         // can this actually happen under wxwin ?
1017         if (!SafeState()) {
1018                 return;
1019         }
1020
1021 #ifndef CLIENT_GUI
1022         static uint32 msPrevGraph;
1023         int msGraphUpdate = thePrefs::GetTrafficOMeterInterval() * 1000;
1024         if ((msGraphUpdate > 0)  && ((msCur / msGraphUpdate) > (msPrevGraph / msGraphUpdate))) {
1025                 // trying to get the graph shifts evenly spaced after a change in the update period
1026                 msPrevGraph = msCur;
1027
1028                 GraphUpdateInfo update = theApp->m_statistics->GetPointsForUpdate();
1029
1030                 m_statisticswnd->UpdateStatGraphs(theStats::GetPeakConnections(), update);
1031                 m_kademliawnd->UpdateGraph(update);
1032         }
1033 #else
1034         //#warning TODO: CORE/GUI -- EC needed
1035 #endif
1036
1037         int sStatsUpdate = thePrefs::GetStatsInterval();
1038         if ((sStatsUpdate > 0) && ((int)(msCur - msPrevStats) > sStatsUpdate*1000)) {
1039                 if (m_statisticswnd->IsShownOnScreen()) {
1040                         msPrevStats = msCur;
1041                         m_statisticswnd->ShowStatistics();
1042                 }
1043         }
1044
1045         if (msCur-msPrev5 > 5000) {  // every 5 seconds
1046                 msPrev5 = msCur;
1047                 ShowTransferRate();
1048                 if (thePrefs::ShowCatTabInfos() && theApp->amuledlg->m_activewnd == theApp->amuledlg->m_transferwnd) {
1049                         m_transferwnd->UpdateCatTabTitles();
1050                 }
1051                 if (thePrefs::AutoSortDownload()) {
1052                         m_transferwnd->downloadlistctrl->SortList();
1053                 }
1054         }
1055
1056         if (msCur-msPrev1 > 1000) {  // every second
1057                 msPrev1 = msCur;
1058                 if (m_CurrentBlinkBitmap == 12) {
1059                         m_CurrentBlinkBitmap = 7;
1060                         SetMessagesTool();
1061                 } else {
1062                         if (m_BlinkMessages) {
1063                                 m_CurrentBlinkBitmap = 12;
1064                                 SetMessagesTool();
1065                         }
1066                 }
1067
1068         }
1069 }
1070
1071
1072 void CamuleDlg::SetMessagesTool()
1073 {
1074         int pos = m_wndToolbar->GetToolPos(ID_BUTTONMESSAGES);
1075         wxASSERT(pos == 6); // so we don't miss a change on wx2.4
1076
1077         wxWindowUpdateLocker freezer(m_wndToolbar);
1078         wxToolBarToolBase* item = m_wndToolbar->RemoveTool(ID_BUTTONMESSAGES);
1079         item->SetNormalBitmap(m_tblist.GetBitmap(m_CurrentBlinkBitmap));
1080
1081         m_wndToolbar->InsertTool(pos, item);
1082         m_wndToolbar->Realize();
1083 }
1084
1085
1086 /*
1087         Try to launch the specified url:
1088          - Windows: Default or custom browser will be used.
1089          - Mac: Currently not implemented
1090          - Anything else: Try a number of hardcoded browsers. Should be made configurable...
1091 */
1092 void CamuleDlg::LaunchUrl( const wxString& url )
1093 {
1094         wxString cmd;
1095
1096         cmd = thePrefs::GetBrowser();
1097         if ( !cmd.IsEmpty() ) {
1098                 wxString tmp = url;
1099                 // Pipes cause problems, so escape them
1100                 tmp.Replace( wxT("|"), wxT("%7C") );
1101
1102                 if (!cmd.Replace(wxT("%s"), tmp)) {
1103                         // No %s found, just append the url
1104                         cmd += wxT(" ") + tmp;
1105                 }
1106
1107                 CTerminationProcess *p = new CTerminationProcess(cmd);
1108                 if (wxExecute(cmd, wxEXEC_ASYNC, p)) {
1109                         printf( "Launch Command: %s\n", (const char *)unicode2char(cmd));
1110                         return;
1111                 } else {
1112                         delete p;
1113                 }
1114 #ifdef __WXMSW__
1115         } else {
1116                 wxFileType* ft =
1117                         wxTheMimeTypesManager->GetFileTypeFromExtension(wxT("html"));
1118                 if (!ft) {
1119                         wxLogError(wxT("Impossible to determine the file type for extension html. Please edit your MIME types."));
1120                         return;
1121                 }
1122
1123                 bool ok = ft->GetOpenCommand(
1124                         &cmd, wxFileType::MessageParameters(url, wxT("")));
1125                 delete ft;
1126
1127                 if (!ok) {
1128                         wxMessageBox(
1129                                 _("Could not determine the command for running the browser."),
1130                                 wxT("Browsing problem"), wxOK|wxICON_EXCLAMATION, this);
1131                         return;
1132                 }
1133
1134                 wxPuts(wxT("Launch Command: ") + cmd);
1135                 CTerminationProcess *p = new CTerminationProcess(cmd);
1136                 if (wxExecute(cmd, wxEXEC_ASYNC, p)) {
1137                         return;
1138                 } else {
1139                         delete p;
1140                 }
1141 #endif // __WXMSW__
1142         }
1143         // Unable to execute browser. But this error message doesn't make sense,
1144         // cosidering that you _can't_ set the browser executable path... =/
1145         wxLogError(wxT("Unable to launch browser. Please set correct browser executable path in Preferences."));
1146 }
1147
1148
1149 wxString CamuleDlg::GenWebSearchUrl(const wxString &filename, WebSearch wsProvider )
1150 {
1151         wxString URL;
1152         switch (wsProvider)  {
1153                 case WS_FILEHASH:
1154                         URL = wxT("http://www.filehash.com/search.html?pattern=FILENAME&submit=Find");
1155                         break;
1156                 default:
1157                         wxASSERT(0);
1158         }
1159         URL.Replace(wxT("FILENAME"), filename);
1160
1161         return URL;
1162 }
1163
1164
1165 bool CamuleDlg::Check_and_Init_Skin()
1166 {
1167         bool ret = true;
1168         wxString skinFileName(thePrefs::GetSkin());
1169
1170         wxString userDir(JoinPaths(GetConfigDir(), wxT("skins")) + wxFileName::GetPathSeparator());
1171
1172         wxStandardPathsBase &spb(wxStandardPaths::Get());
1173 #ifdef __WXMSW__
1174         wxString dataDir(spb.GetPluginsDir());
1175 #elif defined(__WXMAC__)
1176                 wxString dataDir(spb.GetDataDir());
1177 #else
1178         wxString dataDir(spb.GetDataDir().BeforeLast(wxT('/')) + wxT("/amule"));
1179 #endif
1180         wxString systemDir(JoinPaths(dataDir,wxT("skins")) + wxFileName::GetPathSeparator());
1181
1182
1183         skinFileName.Replace(wxT("User:"), userDir );
1184         skinFileName.Replace(wxT("System:"), systemDir );
1185
1186         m_skinFileName.Assign(skinFileName);
1187         if (!m_skinFileName.FileExists()) {
1188                 AddLogLineM(true, CFormat(
1189                         _("Skin directory '%s' does not exist")) %
1190                         skinFileName );
1191                 ret = false;
1192         } else if (!m_skinFileName.IsFileReadable()) {
1193                 AddLogLineM(true, CFormat(
1194                         _("Warning: Unable to open skin file '%s' for read")) %
1195                         skinFileName);
1196                 ret = false;
1197         }
1198
1199                 wxFFileInputStream in(m_skinFileName.GetFullPath());
1200                 wxZipInputStream zip(in);
1201
1202                 while ((entry = zip.GetNextEntry()) != NULL) {
1203                         wxZipEntry*& current = cat[entry->GetInternalName()];
1204                         delete current;
1205                         current = entry;
1206                 }
1207
1208         return ret;
1209 }
1210
1211
1212 void CamuleDlg::Add_Skin_Icon(
1213         const wxString &iconName,
1214         const wxBitmap &stdIcon,
1215         bool useSkins)
1216 {
1217         wxImage new_image;
1218         if (useSkins) {
1219                 wxFFileInputStream in(m_skinFileName.GetFullPath());
1220                 wxZipInputStream zip(in);
1221
1222                 it = cat.find(wxZipEntry::GetInternalName(iconName + wxT(".png")));
1223                 if ( it != cat.end() ) {
1224                         zip.OpenEntry(*it->second);
1225                         if ( !new_image.LoadFile(zip,wxBITMAP_TYPE_PNG) ) {
1226                                 AddLogLineM(false,
1227                                         wxT("Warning: Error loading icon for ") +
1228                                                 iconName);
1229                                 useSkins = false;
1230                         }
1231                 }else {
1232                                 AddLogLineM(false,
1233                                         wxT("Warning: Can't load icon for ") +
1234                                                 iconName);
1235                                 useSkins = false;
1236                 }
1237
1238         }
1239
1240         wxBitmap bmp(useSkins ? new_image : stdIcon);
1241         if (iconName.StartsWith(wxT("Client_"))) {
1242                 m_imagelist.Add(bmp);
1243         } else if (iconName.StartsWith(wxT("Toolbar_"))) {
1244                 m_tblist.Add(bmp);
1245         }
1246 }
1247
1248
1249 void CamuleDlg::Apply_Clients_Skin()
1250 {
1251         bool useSkins = thePrefs::UseSkins() && Check_and_Init_Skin();
1252
1253         // Clear the client image list
1254         m_imagelist.RemoveAll();
1255
1256         // Add the images to the image list
1257         for (int i = 0; i < CLIENT_SKIN_SIZE; ++i) {
1258                 Add_Skin_Icon(wxT("Client_") + m_clientSkinNames[i],
1259                         clientImages(i), useSkins);
1260         }
1261 }
1262
1263
1264 void CamuleDlg::Apply_Toolbar_Skin(wxToolBar *wndToolbar)
1265 {
1266         bool useSkins = thePrefs::UseSkins() && Check_and_Init_Skin();
1267
1268         // Clear the toolbar image list
1269         m_tblist.RemoveAll();
1270
1271         // Add the images to the image list
1272         Add_Skin_Icon(wxT("Toolbar_Connect"),    connButImg(0),      useSkins);
1273         Add_Skin_Icon(wxT("Toolbar_Disconnect"), connButImg(1),      useSkins);
1274         Add_Skin_Icon(wxT("Toolbar_Connecting"), connButImg(2),      useSkins);
1275         Add_Skin_Icon(wxT("Toolbar_Network"),    amuleDlgImages(20), useSkins);
1276         Add_Skin_Icon(wxT("Toolbar_Transfers"),  amuleDlgImages(21), useSkins);
1277         Add_Skin_Icon(wxT("Toolbar_Search"),     amuleDlgImages(22), useSkins);
1278         Add_Skin_Icon(wxT("Toolbar_Shared"),     amuleDlgImages(23), useSkins);
1279         Add_Skin_Icon(wxT("Toolbar_Messages"),   amuleDlgImages(24), useSkins);
1280         Add_Skin_Icon(wxT("Toolbar_Stats"),      amuleDlgImages(25), useSkins);
1281         Add_Skin_Icon(wxT("Toolbar_Prefs"),      amuleDlgImages(26), useSkins);
1282         Add_Skin_Icon(wxT("Toolbar_Import"),     amuleDlgImages(32), useSkins);
1283         Add_Skin_Icon(wxT("Toolbar_About"),      amuleDlgImages(29), useSkins);
1284         Add_Skin_Icon(wxT("Toolbar_Blink"),          amuleDlgImages(33), useSkins);
1285
1286         // Build aMule toolbar
1287         wndToolbar->SetMargins(0, 0);
1288
1289         // Placeholder. Gets updated by ShowConnectionState
1290         wndToolbar->AddTool(ID_BUTTONCONNECT, wxT("..."), m_tblist.GetBitmap(0));
1291
1292         wndToolbar->AddSeparator();
1293         wndToolbar->AddTool(ID_BUTTONNETWORKS,
1294                 _("Networks"), m_tblist.GetBitmap(3),
1295                 wxNullBitmap, wxITEM_CHECK,
1296                 _("Networks Window"));
1297         wndToolbar->ToggleTool(ID_BUTTONNETWORKS, true);
1298         wndToolbar->AddTool(ID_BUTTONSEARCH,
1299                 _("Searches"), m_tblist.GetBitmap(5),
1300                 wxNullBitmap, wxITEM_CHECK,
1301                 _("Searches Window"));
1302         wndToolbar->AddTool(ID_BUTTONTRANSFER,
1303                 _("Transfers"), m_tblist.GetBitmap(4),
1304                 wxNullBitmap, wxITEM_CHECK,
1305                 _("Files Transfers Window"));
1306         wndToolbar->AddTool(ID_BUTTONSHARED,
1307                 _("Shared Files"), m_tblist.GetBitmap(6),
1308                 wxNullBitmap, wxITEM_CHECK,
1309                 _("Shared Files Window"));
1310         wndToolbar->AddTool(ID_BUTTONMESSAGES,
1311                 _("Messages"), m_tblist.GetBitmap(7),
1312                 wxNullBitmap, wxITEM_CHECK,
1313                 _("Messages Window"));
1314         wndToolbar->AddTool(ID_BUTTONSTATISTICS,
1315                 _("Statistics"), m_tblist.GetBitmap(8),
1316                 wxNullBitmap, wxITEM_CHECK,
1317                 _("Statistics Graph Window"));
1318         wndToolbar->AddSeparator();
1319         wndToolbar->AddTool(ID_BUTTONNEWPREFERENCES,
1320                 _("Preferences"), m_tblist.GetBitmap(9),
1321                 wxNullBitmap, wxITEM_NORMAL,
1322                 _("Preferences Settings Window"));
1323         wndToolbar->AddTool(ID_BUTTONIMPORT,
1324                 _("Import"), m_tblist.GetBitmap(10),
1325                 wxNullBitmap, wxITEM_NORMAL,
1326                 _("The partfile importer tool"));
1327         wndToolbar->AddTool(ID_ABOUT,
1328                 _("About"), m_tblist.GetBitmap(11),
1329                 wxNullBitmap, wxITEM_NORMAL,
1330                 _("About/Help"));
1331
1332         // Needed for non-GTK platforms, where the
1333         // items don't get added immediatly.
1334         wndToolbar->Realize();
1335
1336         // Updates the "Connect" button, and so on.
1337         ShowConnectionState();
1338 }
1339
1340
1341 void CamuleDlg::Create_Toolbar(bool orientation)
1342 {
1343         Freeze();
1344         // Create ToolBar from the one designed by wxDesigner (BigBob)
1345         wxToolBar *current = GetToolBar();
1346
1347         wxASSERT(current == m_wndToolbar);
1348
1349         if (current) {
1350                 bool oldorientation = ((current->GetWindowStyle() & wxTB_VERTICAL) == wxTB_VERTICAL);
1351                 if (oldorientation != orientation) {
1352                         current->Destroy();
1353                         SetToolBar(NULL); // Remove old one if present
1354                         m_wndToolbar = NULL;
1355                 } else {
1356                         current->ClearTools();
1357                 }
1358         }
1359
1360         if (!m_wndToolbar) {
1361                 m_wndToolbar = CreateToolBar(
1362                         (orientation ? wxTB_VERTICAL : wxTB_HORIZONTAL) |
1363                         wxNO_BORDER | wxTB_TEXT | wxTB_3DBUTTONS |
1364                         wxTB_FLAT | wxCLIP_CHILDREN | wxTB_NODIVIDER);
1365
1366
1367                         m_wndToolbar->SetToolBitmapSize(wxSize(32, 32));
1368         }
1369
1370         Apply_Toolbar_Skin(m_wndToolbar);
1371         #ifdef CLIENT_GUI
1372                 m_wndToolbar->DeleteTool(ID_BUTTONIMPORT);
1373         #endif
1374
1375         Thaw();
1376 }
1377
1378
1379 void CamuleDlg::OnMainGUISizeChange(wxSizeEvent& evt)
1380 {
1381         wxFrame::OnSize(evt);
1382         if (m_transferwnd && m_transferwnd->clientlistctrl) {
1383                 // Transfer window's splitter set again if it's hidden.
1384                 if (m_transferwnd->clientlistctrl->GetListView() == vtNone) {
1385                         int height = m_transferwnd->clientlistctrl->GetSize().GetHeight();
1386                         wxSplitterWindow* splitter =
1387                                 CastChild(wxT("splitterWnd"), wxSplitterWindow);
1388                         height += splitter->GetWindow1()->GetSize().GetHeight();
1389                         splitter->SetSashPosition( height );
1390                 }
1391         }
1392
1393 }
1394
1395
1396 void CamuleDlg::OnKeyPressed(wxKeyEvent& event)
1397 {
1398         if (event.GetKeyCode() == WXK_F1) {
1399                 // Ctrl/Alt/Shift must not be pressed, to avoid
1400                 // conflicts with other (global) shortcuts.
1401                 if (!event.HasModifiers() && !event.ShiftDown()) {
1402                         LaunchUrl(wxT("http://wiki.amule.org"));
1403                         return;
1404                 }
1405         }
1406
1407         event.Skip();
1408 }
1409
1410
1411 void CamuleDlg::OnExit(wxCommandEvent& WXUNUSED(evt))
1412 {
1413         Close();
1414 }
1415
1416 // File_checked_for_headers