src/amule-remote-gui.h

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2005-2008 aMule Team ( admin@amule.org / http://www.amule.org )
   5 //
   6 // Any parts of this program derived from the xMule, lMule or eMule project,
   7 // or contributed by third-party developers are copyrighted by their
   8 // respective authors.
   9 //
  10 // This program is free software; you can redistribute it and/or modify
  11 // it under the terms of the GNU General Public License as published by
  12 // the Free Software Foundation; either version 2 of the License, or
  13 // (at your option) any later version.
  14 //
  15 // This program is distributed in the hope that it will be useful,
  16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 // GNU General Public License for more details.
  19 //
  20 // You should have received a copy of the GNU General Public License
  21 // along with this program; if not, write to the Free Software
  22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  23 //
  24
  25 #ifndef AMULE_REMOTE_GUI_H
  26 #define AMULE_REMOTE_GUI_H
  27
  28
  29 #include <ec/cpp/RemoteConnect.h>               // Needed for CRemoteConnect
  30
  31
  32 #include "Statistics.h"
  33 #include "Preferences.h"
  34 #include "Statistics.h"
  35 #include "RLE.h"
  36 #include "SearchList.h"                 // Needed for CSearchFile
  37
  38
  39 class CED2KFileLink;
  40 class CServer;
  41 class CKnownFile;
  42 class CSearchFile;
  43 class CPartFile;
  44 class CUpDownClient;
  45 class CStatistics;
  46 class CPath;
  47
  48 class wxEvtHandler;
  49 class wxTimer;
  50 class wxTimerEvent;
  51
  52 #include <wx/dialog.h>
  53
  54 class CEConnectDlg : public wxDialog {
  55         wxString host;
  56         int port;
  57
  58         wxString pwd_hash;
  59         wxString login, passwd;
  60         bool m_save_user_pass;
  61
  62         DECLARE_EVENT_TABLE()
  63 public:
  64         CEConnectDlg();
  65
  66         void OnOK(wxCommandEvent& event);
  67
  68         wxString Host() { return host; }
  69         int Port() { return port; }
  70
  71         wxString Login() { return login; }
  72         wxString PassHash();
  73         bool SaveUserPass() { return m_save_user_pass; }
  74 };
  75
  76 DECLARE_LOCAL_EVENT_TYPE(wxEVT_EC_INIT_DONE, wxEVT_USER_FIRST + 1001)
  77
  78 class wxECInitDoneEvent : public wxEvent {
  79 public:
  80         wxECInitDoneEvent() : wxEvent(-1, wxEVT_EC_INIT_DONE)
  81         {
  82         }
  83
  84         wxEvent *Clone(void) const
  85         {
  86                 return new wxECInitDoneEvent(*this);
  87         }
  88 };
  89
  90 class CPreferencesRem : public CPreferences, public CECPacketHandlerBase {
  91         CRemoteConnect *m_conn;
  92         uint32 m_exchange_send_selected_prefs;
  93         uint32 m_exchange_recv_selected_prefs;
  94
  95         virtual void HandlePacket(const CECPacket *packet);
  96 public:
  97         CPreferencesRem(CRemoteConnect *);
  98
  99         bool CreateCategory(Category_Struct *& category, const wxString& name, const CPath& path,
 100                                                 const wxString& comment, uint32 color, uint8 prio);
 101         bool UpdateCategory(uint8 cat, const wxString& name, const CPath& path,
 102                                                 const wxString& comment, uint32 color, uint8 prio);
 103
 104         void RemoveCat(uint8 cat);
 105
 106         bool LoadRemote();
 107         void SendToRemote();
 108 };
 109
 110 //
 111 // T - type if item in container
 112 // I - type of id of item
 113 // G - type of tag used to create/update items
 114 //
 115 template <class T, class I, class G = CECTag>
 116 class CRemoteContainer : public CECPacketHandlerBase {
 117 protected:
 118         enum {
 119                 IDLE,            // no request in the air
 120                 STATUS_REQ_SENT, // sent request for item status
 121                 FULL_REQ_SENT    // sent request for full info
 122         } m_state;
 123
 124         CRemoteConnect *m_conn;
 125
 126         std::list<T *> m_items;
 127         std::map<I, T *> m_items_hash;
 128
 129         // for GetByIndex
 130         std::vector<T *> m_idx_items;
 131
 132         // .size() is O(N) operation in stl
 133         int m_item_count;
 134
 135         // use incremental tags algorithm
 136         bool m_inc_tags;
 137
 138         // command that will be used in full request
 139         int m_full_req_cmd, m_full_req_tag;
 140
 141         virtual void HandlePacket(const CECPacket *packet)
 142         {
 143                 switch(this->m_state) {
 144                         case IDLE: wxFAIL; // not expecting anything
 145                         case STATUS_REQ_SENT:
 146                                 // if derived class choose not to proceed, return - but with good status
 147                                 this->m_state = IDLE;
 148                                 if ( this->Phase1Done(packet) ) {
 149                                         if (this->m_inc_tags) {
 150                                                 // Incremental tags: new items always carry full info.
 151                                                 ProcessUpdate(packet, NULL, m_full_req_tag);
 152                                         } else {
 153                                                 // Non-incremental tags: we might get partial info on new items.
 154                                                 // Collect all this items in a tag, and then request full info about them.
 155                                                 CECPacket req_full(this->m_full_req_cmd);
 156
 157                                                 ProcessUpdate(packet, &req_full, m_full_req_tag);
 158
 159                                                 // Phase 3: request full info about files we don't have yet
 160                                                 if ( req_full.GetTagCount() ) {
 161                                                         m_conn->SendRequest(this, &req_full);
 162                                                         this->m_state = FULL_REQ_SENT;
 163                                                 }
 164                                         }
 165                                 }
 166                                 break;
 167                         case FULL_REQ_SENT:
 168                                 ProcessFull(packet);
 169                                 m_state = IDLE;
 170                                 break;
 171                 }
 172         }
 173 public:
 174         CRemoteContainer(CRemoteConnect *conn, bool inc_tags)
 175         {
 176                 m_state = IDLE;
 177
 178                 m_conn = conn;
 179                 m_item_count = 0;
 180                 m_inc_tags = inc_tags;
 181         }
 182
 183         virtual ~CRemoteContainer()
 184         {
 185         }
 186
 187         uint32 GetCount()
 188         {
 189                 return m_item_count;
 190         }
 191
 192         void AddItem(T *item)
 193         {
 194                 m_items.push_back(item);
 195                 m_items_hash[GetItemID(item)] = item;
 196                 m_idx_items.resize(m_item_count+1);
 197                 m_idx_items[m_item_count] = item;
 198                 m_item_count++;
 199         }
 200
 201         T *GetByID(I id)
 202         {
 203                 // avoid creating nodes
 204                 return m_items_hash.count(id) ? m_items_hash[id] : NULL;
 205         }
 206
 207         T *GetByIndex(int index)
 208         {
 209                 return ( (index >= 0) && (index < m_item_count) ) ? m_idx_items[index] : NULL;
 210         }
 211
 212         void Flush()
 213         {
 214                 m_items.erase(this->m_items.begin(), this->m_items.end());
 215                 m_items_hash.erase(this->m_items_hash.begin(), this->m_items_hash.end());
 216                 m_item_count = 0;
 217         }
 218
 219         //
 220         // Flush & reload
 221         //
 222         /*
 223         We usually don't keep outdated code as comments, but this blocking implementation
 224         shows the overall procedure well. It had to be scattered for the event driven implementation.
 225
 226         bool FullReload(int cmd)
 227         {
 228                 CECPacket req(cmd);
 229                 CScopedPtr<const CECPacket> reply(this->m_conn->SendRecvPacket(&req));
 230                 if ( !reply.get() ) {
 231                         return false;
 232                 }
 233                 for(typename std::list<T *>::iterator j = this->m_items.begin(); j != this->m_items.end(); j++) {
 234                         this->DeleteItem(*j);
 235                 }
 236
 237                 Flush();
 238
 239                 ProcessFull(reply.get());
 240
 241                 return true;
 242         }
 243         */
 244         void FullReload(int cmd)
 245         {
 246                 if ( this->m_state != IDLE ) {
 247                         return;
 248                 }
 249
 250                 for(typename std::list<T *>::iterator j = this->m_items.begin(); j != this->m_items.end(); j++) {
 251                         this->DeleteItem(*j);
 252                 }
 253
 254                 Flush();
 255
 256                 CECPacket req(cmd);
 257                 this->m_conn->SendRequest(this, &req);
 258                 this->m_state = FULL_REQ_SENT;
 259                 this->m_full_req_cmd = cmd;
 260         }
 261
 262         //
 263         // Following are like basicly same code as in webserver. Eventually it must
 264         // be same class
 265         //
 266         void DoRequery(int cmd, int tag)
 267         {
 268                 if ( this->m_state != IDLE ) {
 269                         return;
 270                 }
 271                 CECPacket req_sts(cmd, m_inc_tags ? EC_DETAIL_INC_UPDATE : EC_DETAIL_UPDATE);
 272                 this->m_conn->SendRequest(this, &req_sts);
 273                 this->m_state = STATUS_REQ_SENT;
 274                 this->m_full_req_cmd = cmd;
 275                 this->m_full_req_tag = tag;
 276         }
 277         /*
 278         We usually don't keep outdated code as comments, but this blocking implementation
 279         shows the overall procedure well. It had to be scattered for the event driven implementation.
 280
 281         bool DoRequery(int cmd, int tag)
 282         {
 283                 CECPacket req_sts(cmd, m_inc_tags ? EC_DETAIL_INC_UPDATE : EC_DETAIL_UPDATE);
 284
 285                 //
 286                 // Phase 1: request status
 287                 CScopedPtr<const CECPacket> reply(this->m_conn->SendRecvPacket(&req_sts));
 288                 if ( !reply.get() ) {
 289                         return false;
 290                 }
 291
 292                 if ( !this->Phase1Done(reply.get()) ) {
 293                         // if derived class choose not to proceed, return - but with good status
 294                         return true;
 295                 }
 296                 //
 297                 // Phase 2: update status, mark new files for subsequent query
 298                 CECPacket req_full(cmd);
 299
 300                 ProcessUpdate(reply.get(), &req_full, tag);
 301
 302                 reply.reset();
 303
 304                 if ( !m_inc_tags ) {
 305                         // Phase 3: request full info about files we don't have yet
 306                         if ( req_full.GetTagCount() ) {
 307                                 reply.reset(this->m_conn->SendRecvPacket(&req_full));
 308                                 if ( !reply.get() ) {
 309                                         return false;
 310                                 }
 311                                 ProcessFull(reply.get());
 312                         }
 313                 }
 314                 return true;
 315         }
 316         */
 317
 318         void ProcessFull(const CECPacket *reply)
 319         {
 320                 for (size_t i = 0;i < reply->GetTagCount();i++) {
 321                         G *tag = (G *)reply->GetTagByIndex(i);
 322                         // initialize item data from EC tag
 323                         T *item = this->CreateItem(tag);
 324                         AddItem(item);
 325                 }
 326         }
 327
 328         void ProcessUpdate(const CECPacket *reply, CECPacket *full_req, int req_type)
 329         {
 330                 std::set<I> core_files;
 331                 for (size_t i = 0;i < reply->GetTagCount();i++) {
 332                         G *tag = (G *)reply->GetTagByIndex(i);
 333                         if ( tag->GetTagName() != req_type ) {
 334                                 continue;
 335                         }
 336
 337                         core_files.insert(tag->ID());
 338                         if ( m_items_hash.count(tag->ID()) ) {
 339                                 // Item already known: update it
 340                                 T *item = m_items_hash[tag->ID()];
 341                                 ProcessItemUpdate(tag, item);
 342                         } else {
 343                                 // New item
 344                                 if (full_req) {
 345                                         // Non-incremental mode: we have only partial info
 346                                         // so we need to request full info before we can use the item
 347                                         full_req->AddTag(CECTag(req_type, tag->ID()));
 348                                 } else {
 349                                         // Incremental mode: new items always carry full info,
 350                                         // so we can add it right away
 351                                         T *item = this->CreateItem(tag);
 352                                         AddItem(item);
 353                                 }
 354                         }
 355                 }
 356                 std::list<I> del_ids;
 357                 for(typename std::list<T *>::iterator j = this->m_items.begin(); j != this->m_items.end(); j++) {
 358                         I item_id = GetItemID(*j);
 359                         if ( core_files.count(item_id) == 0 ) {
 360                                 del_ids.push_back(item_id);
 361                         }
 362                 }
 363                 for(typename std::list<I>::iterator j = del_ids.begin(); j != del_ids.end(); j++) {
 364                         for(int idx = 0;idx < m_item_count;idx++) {
 365                                 if ( this->GetItemID(m_idx_items[idx]) == *j ) {
 366                                         m_idx_items[idx] = m_idx_items[m_item_count-1];
 367                                         break;
 368                                 }
 369                         }
 370                         m_item_count--;
 371                         m_items_hash.erase(*j);
 372                         for(typename std::list<T *>::iterator k = this->m_items.begin(); k != this->m_items.end(); k++) {
 373                                 if ( *j == GetItemID(*k) ) {
 374                                         // item may contain data that need to be freed externally, before
 375                                         // dtor is called and memory freed
 376                                         this->DeleteItem(*k);
 377
 378                                         this->m_items.erase(k);
 379
 380                                         break;
 381                                 }
 382                         }
 383                 }
 384         }
 385
 386         virtual T *CreateItem(G *)
 387         {
 388                 return 0;
 389         }
 390         virtual void DeleteItem(T *)
 391         {
 392         }
 393         virtual I GetItemID(T *)
 394         {
 395                 return I();
 396         }
 397         virtual void ProcessItemUpdate(G *, T *)
 398         {
 399         }
 400
 401         virtual bool Phase1Done(const CECPacket *)
 402         {
 403                 return true;
 404         }
 405 };
 406
 407 class CServerConnectRem : public CECPacketHandlerBase {
 408         CRemoteConnect *m_Conn;
 409         uint32 m_ID;
 410
 411         CServer *m_CurrServer;
 412
 413         virtual void HandlePacket(const CECPacket *packet);
 414
 415 public:
 416         CServerConnectRem(CRemoteConnect *);
 417         bool ReQuery();
 418
 419         bool IsConnected() { return (m_ID != 0) && (m_ID != 0xffffffff); }
 420         bool IsConnecting() { return m_ID == 0xffffffff; }
 421         bool IsLowID() { return m_ID < 16777216; }
 422         uint32 GetClientID() { return m_ID; }
 423         CServer *GetCurrentServer() { return m_CurrServer; }
 424
 425         //
 426         // Actions
 427         //
 428         void ConnectToServer(CServer* server);
 429         void ConnectToAnyServer();
 430         void StopConnectionTry();
 431         void Disconnect();
 432 };
 433
 434 class CServerListRem : public CRemoteContainer<CServer, uint32, CEC_Server_Tag> {
 435         uint32 m_TotalUser, m_TotalFile;
 436
 437         virtual void HandlePacket(const CECPacket *packet);
 438 public:
 439         CServerListRem(CRemoteConnect *);
 440         void GetUserFileStatus(uint32 &total_user, uint32 &total_file)
 441         {
 442                 total_user = m_TotalUser;
 443                 total_file = m_TotalFile;
 444         }
 445
 446         void UpdateUserFileStatus(CServer *server);
 447
 448         CServer* GetServerByAddress(const wxString& address, uint16 port) const;
 449         CServer* GetServerByIPTCP(uint32 nIP, uint16 nPort) const;
 450
 451         void ReloadControl();
 452
 453         //
 454         // Actions
 455         //
 456         void RemoveServer(CServer* server);
 457         void UpdateServerMetFromURL(wxString url);
 458         void SaveServerMet();
 459         void FilterServers();
 460
 461         //
 462         // template
 463         //
 464         CServer *CreateItem(CEC_Server_Tag *);
 465         void DeleteItem(CServer *);
 466         uint32 GetItemID(CServer *);
 467         void ProcessItemUpdate(CEC_Server_Tag *, CServer *);
 468 };
 469
 470 class CUpDownClientListRem : public CRemoteContainer<CUpDownClient, uint32, CEC_UpDownClient_Tag> {
 471         int m_viewtype;
 472 public:
 473         CUpDownClientListRem(CRemoteConnect *, int viewtype);
 474
 475         const CClientPtrList& GetList() const { return m_items; };
 476
 477         //
 478         // template
 479         //
 480         CUpDownClient *CreateItem(CEC_UpDownClient_Tag *);
 481         void DeleteItem(CUpDownClient *);
 482         uint32 GetItemID(CUpDownClient *);
 483         void ProcessItemUpdate(CEC_UpDownClient_Tag *, CUpDownClient *);
 484 };
 485
 486 class CUpQueueRem {
 487         CUpDownClientListRem m_up_list, m_wait_list;
 488 public:
 489         CUpQueueRem(CRemoteConnect *);
 490
 491         void ReQueryUp() { m_up_list.DoRequery(EC_OP_GET_ULOAD_QUEUE, EC_TAG_CLIENT); }
 492         void ReQueryWait() { m_wait_list.DoRequery(EC_OP_GET_WAIT_QUEUE, EC_TAG_CLIENT); }
 493
 494         const CClientPtrList& GetWaitingList() const { return m_wait_list.GetList(); }
 495         const CClientPtrList& GetUploadingList() const { return m_up_list.GetList(); }
 496         uint16 GetWaitingPosition(const CUpDownClient *client) const;
 497 };
 498
 499 class CDownQueueRem : public CRemoteContainer<CPartFile, CMD4Hash, CEC_PartFile_Tag> {
 500         std::map<CMD4Hash, PartFileEncoderData> m_enc_map;
 501 public:
 502         CDownQueueRem(CRemoteConnect *);
 503
 504         uint32 GetFileCount() { return GetCount(); }
 505         CPartFile* GetFileByID(const CMD4Hash& id) { return GetByID(id); }
 506         CPartFile* GetFileByIndex(unsigned int idx) { return GetByIndex(idx); }
 507
 508         bool IsPartFile(const CKnownFile* totest) const;
 509         void OnConnectionState(bool bConnected);
 510
 511         //
 512         // User actions
 513         //
 514         void Prio(CPartFile *file, uint8 prio);
 515         void AutoPrio(CPartFile *file, bool flag);
 516         void Category(CPartFile *file, uint8 cat);
 517
 518         void SendFileCommand(CPartFile *file, ec_tagname_t cmd);
 519         //
 520         // Actions
 521         //
 522         void StopUDPRequests();
 523         void AddFileLinkToDownload(CED2KFileLink*, uint8);
 524         bool AddLink(const wxString &link, uint8 category = 0);
 525         void UnsetCompletedFilesExist();
 526         void ResetCatParts(int cat);
 527         void AddSearchToDownload(CSearchFile* toadd, uint8 category);
 528
 529         //
 530         // template
 531         //
 532         CPartFile *CreateItem(CEC_PartFile_Tag *);
 533         void DeleteItem(CPartFile *);
 534         CMD4Hash GetItemID(CPartFile *);
 535         void ProcessItemUpdate(CEC_PartFile_Tag *, CPartFile *);
 536         bool Phase1Done(const CECPacket *);
 537 };
 538
 539 class CSharedFilesRem : public CRemoteContainer<CKnownFile, CMD4Hash, CEC_SharedFile_Tag> {
 540         std::map<CMD4Hash, RLE_Data> m_enc_map;
 541
 542         virtual void HandlePacket(const CECPacket *);
 543
 544         //
 545         // For file renaming operation
 546         //
 547         CKnownFile* m_rename_file;
 548         wxString m_new_name;
 549 public:
 550         CSharedFilesRem(CRemoteConnect *);
 551
 552         CKnownFile *GetFileByID(CMD4Hash id) { return GetByID(id); }
 553
 554         void SetFilePrio(CKnownFile *file, uint8 prio);
 555
 556         //
 557         // Actions
 558         //
 559         void AddFilesFromDirectory(const CPath&);
 560         void Reload(bool sendtoserver = true, bool firstload = false);
 561         bool RenameFile(CKnownFile* file, const CPath& newName);
 562
 563         //
 564         // template
 565         //
 566         CKnownFile *CreateItem(CEC_SharedFile_Tag *);
 567         void DeleteItem(CKnownFile *);
 568         CMD4Hash GetItemID(CKnownFile *);
 569         void ProcessItemUpdate(CEC_SharedFile_Tag *, CKnownFile *);
 570         bool Phase1Done(const CECPacket *);
 571 };
 572
 573 class CKnownFilesRem {
 574         CSharedFilesRem *m_shared_files;
 575 public:
 576         CKnownFilesRem(CSharedFilesRem *shared)
 577         {
 578                 m_shared_files = shared;
 579
 580                 requested = 0;
 581                 transferred = 0;
 582                 accepted = 0;
 583         }
 584
 585         CKnownFile *FindKnownFileByID(const CMD4Hash& id)
 586         {
 587                 return m_shared_files->GetByID(id);
 588         }
 589
 590         uint16 requested;
 591         uint32 transferred;
 592         uint16 accepted;
 593 };
 594
 595 class CClientListRem {
 596         CRemoteConnect *m_conn;
 597
 598         //
 599         // map of user_ID -> client
 600         std::multimap<uint32, CUpDownClient*> m_client_list;
 601 public:
 602         CClientListRem(CRemoteConnect *);
 603
 604         const std::multimap<uint32, CUpDownClient*>& GetClientList() { return m_client_list; }
 605
 606         //
 607         // Actions
 608         //
 609         void AddClient(CUpDownClient *);
 610         void FilterQueues();
 611 };
 612
 613 class CIPFilterRem {
 614         CRemoteConnect *m_conn;
 615 public:
 616         CIPFilterRem(CRemoteConnect *conn);
 617
 618         //
 619         // Actions
 620         //
 621         void Reload();
 622         void Update(wxString strURL = wxEmptyString);
 623 };
 624
 625 class CSearchListRem : public CRemoteContainer<CSearchFile, CMD4Hash, CEC_SearchFile_Tag> {
 626         virtual void HandlePacket(const CECPacket *);
 627 public:
 628         CSearchListRem(CRemoteConnect *);
 629
 630         int m_curr_search;
 631         typedef std::map<long, CSearchResultList> ResultMap;
 632         ResultMap m_results;
 633
 634         const CSearchResultList& GetSearchResults(long nSearchID);
 635         void RemoveResults(long nSearchID);
 636         const CSearchResultList& GetSearchResults(long nSearchID) const;
 637         //
 638         // Actions
 639         //
 640
 641         wxString StartNewSearch(uint32* nSearchID, SearchType search_type,
 642                 const CSearchList::CSearchParams& params);
 643
 644         void StopGlobalSearch();
 645         void StopKadSearch();
 646
 647         //
 648         // template
 649         //
 650         CSearchFile *CreateItem(CEC_SearchFile_Tag *);
 651         void DeleteItem(CSearchFile *);
 652         CMD4Hash GetItemID(CSearchFile *);
 653         void ProcessItemUpdate(CEC_SearchFile_Tag *, CSearchFile *);
 654         bool Phase1Done(const CECPacket *);
 655 };
 656
 657 class CStatsUpdaterRem : public CECPacketHandlerBase {
 658         virtual void HandlePacket(const CECPacket *);
 659 public:
 660         CStatsUpdaterRem() {}
 661 };
 662
 663 class CListenSocketRem {
 664         uint32 m_peak_connections;
 665 public:
 666         uint32 GetPeakConnections() { return m_peak_connections; }
 667 };
 668
 669 class CamuleRemoteGuiApp : public wxApp, public CamuleGuiBase, public CamuleAppCommon {
 670         wxTimer*        poll_timer;
 671
 672         virtual int InitGui(bool geometry_enable, wxString &geometry_string);
 673
 674         bool OnInit();
 675
 676         int OnExit();
 677
 678         void OnPollTimer(wxTimerEvent& evt);
 679
 680         void OnECConnection(wxEvent& event);
 681         void OnECInitDone(wxEvent& event);
 682         void OnNotifyEvent(CMuleGUIEvent& evt);
 683         void OnFinishedHTTPDownload(CMuleInternalEvent& event);
 684
 685         CStatsUpdaterRem m_stats_updater;
 686 public:
 687
 688         void Startup();
 689
 690         bool ShowConnectionDialog();
 691
 692         class CRemoteConnect *m_connect;
 693
 694         CEConnectDlg *dialog;
 695
 696         bool CopyTextToClipboard(wxString strText);
 697
 698         virtual int ShowAlert(wxString msg, wxString title, int flags);
 699
 700         void ShutDown(wxCloseEvent &evt);
 701
 702         CPreferencesRem *glob_prefs;
 703
 704         //
 705         // Provide access to core data thru EC
 706         CServerConnectRem *serverconnect;
 707         CServerListRem *serverlist;
 708         CUpQueueRem *uploadqueue;
 709         CDownQueueRem *downloadqueue;
 710         CSharedFilesRem *sharedfiles;
 711         CKnownFilesRem *knownfiles;
 712         CClientListRem *clientlist;
 713         CIPFilterRem *ipfilter;
 714         CSearchListRem *searchlist;
 715         CListenSocketRem *listensocket;
 716
 717         CStatistics *m_statistics;
 718
 719         bool AddServer(CServer *srv, bool fromUser = false);
 720
 721         uint32 GetPublicIP();
 722
 723         wxString GetLog(bool reset = false);
 724         wxString GetServerLog(bool reset = false);
 725
 726         void AddServerMessageLine(wxString &msg);
 727         void AddRemoteLogLine(const wxString& line);
 728
 729         void SetOSFiles(wxString ) { /* onlinesig is created on remote side */ }
 730
 731         bool IsConnected() const { return IsConnectedED2K() || IsConnectedKad(); }
 732         bool IsFirewalled() const;
 733         bool IsConnectedED2K() const;
 734         bool IsConnectedKad() const
 735         {
 736                 return ((m_ConnState & CONNECTED_KAD_OK)
 737                                 || (m_ConnState & CONNECTED_KAD_FIREWALLED));
 738         }
 739         bool IsFirewalledKad() const { return (m_ConnState & CONNECTED_KAD_FIREWALLED) != 0; }
 740
 741         bool IsKadRunning() const { return ((m_ConnState & CONNECTED_KAD_OK)
 742                                 || (m_ConnState & CONNECTED_KAD_FIREWALLED)
 743                                 || (m_ConnState & CONNECTED_KAD_NOT)); }
 744
 745         // Check Kad state (UDP)
 746         bool IsFirewalledKadUDP() const         { return theStats::IsFirewalledKadUDP(); }
 747         // Kad stats
 748         uint32 GetKadUsers() const                      { return theStats::GetKadUsers(); }
 749         uint32 GetKadFiles() const                      { return theStats::GetKadFiles(); }
 750         uint32 GetKadIndexedSources() const     { return theStats::GetKadIndexedSources(); }
 751         uint32 GetKadIndexedKeywords() const{ return theStats::GetKadIndexedKeywords(); }
 752         uint32 GetKadIndexedNotes() const       { return theStats::GetKadIndexedNotes(); }
 753         uint32 GetKadIndexedLoad() const        { return theStats::GetKadIndexedLoad(); }
 754         // True IP of machine
 755         uint32 GetKadIPAdress() const           { return theStats::GetKadIPAdress(); }
 756         // Buddy status
 757         uint8   GetBuddyStatus() const          { return theStats::GetBuddyStatus(); }
 758         uint32  GetBuddyIP() const                      { return theStats::GetBuddyIP(); }
 759         uint32  GetBuddyPort() const            { return theStats::GetBuddyPort(); }
 760
 761         void StartKad();
 762         void StopKad();
 763
 764         /** Bootstraps kad from the specified IP (must be in hostorder). */
 765         void BootstrapKad(uint32 ip, uint16 port);
 766         /** Updates the nodes.dat file from the specified url. */
 767         void UpdateNotesDat(const wxString& str);
 768
 769         void DisconnectED2K();
 770
 771         bool CryptoAvailable() const;
 772
 773         uint32 GetED2KID() const;
 774         uint32 GetID() const;
 775         void ShowUserCount();
 776
 777         uint8 m_ConnState;
 778         uint32 m_clientID;
 779
 780         wxLocale        m_locale;
 781
 782         DECLARE_EVENT_TABLE()
 783 };
 784
 785 DECLARE_APP(CamuleRemoteGuiApp)
 786 #ifdef AMULE_REMOTE_GUI_CPP
 787         CamuleRemoteGuiApp *theApp;
 788 #else
 789         extern CamuleRemoteGuiApp *theApp;
 790 #endif
 791
 792
 793 #endif /* AMULE_REMOTE_GUI_H */
 794
 795 // File_checked_for_headers