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