1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
|
/***************************************************************************
* Copyright (C) 2005 by Joris Guisson *
* joris.guisson@gmail.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
#ifndef KTCOREINTERFACE_H
#define KTCOREINTERFACE_H
#include <kurl.h>
#include <qobject.h>
#include <util/constants.h>
#include <torrent/queuemanager.h>
///Stats struct
struct CurrentStats
{
bt::Uint32 download_speed;
bt::Uint32 upload_speed;
bt::Uint64 bytes_downloaded;
bt::Uint64 bytes_uploaded;
};
namespace bt
{
class QueueManager;
}
namespace kt
{
class TorrentInterface;
/**
* @author Joris Guisson
* @brief Interface for plugins to communicate with the application's core
*
* This interface provides the plugin with the functionality to modify
* the applications core, the core is responsible for managing all
* TorrentControl objects.
*/
class CoreInterface : public QObject
{
Q_OBJECT
public:
CoreInterface();
virtual ~CoreInterface();
/**
* Set the maximum number of simultanious downloads.
* @param max The max num (0 == no limit)
*/
virtual void setMaxDownloads(int max) = 0;
virtual void setMaxSeeds(int max) = 0;
virtual void setMaxDownloadSpeed(int v) = 0;
virtual void setMaxUploadSpeed(int v) = 0;
/**
* Set wether or not we should keep seeding after
* a download has finished.
* @param ks Keep seeding yes or no
*/
virtual void setKeepSeeding(bool ks) = 0;
/**
* Change the data dir. This involves copying
* all data from the old dir to the new.
* This can offcourse go horribly wrong, therefore
* if it doesn't succeed it returns false
* and leaves everything where it supposed to be.
* @param new_dir The new directory
*/
virtual bool changeDataDir(const QString & new_dir) = 0;
/**
* Start all, takes into account the maximum number of downloads.
* @param type - Weather to start downloads, seeds or both. 1=Downloads, 2=Seeds, 3=All
*/
virtual void startAll(int type) = 0;
/**
* Stop all torrents.
* @param type - Weather to start downloads, seeds or both. 1=Downloads, 2=Seeds, 3=All
*/
virtual void stopAll(int type) = 0;
/**
* Start a torrent, takes into account the maximum number of downloads.
* @param tc The TorrentControl
*/
virtual void start(TorrentInterface* tc) = 0;
/**
* Stop a torrent, may start another download if it hasn't been started.
* @param tc The TorrentControl
* @param user true if user stopped the torrent, false otherwise
*/
virtual void stop(TorrentInterface* tc, bool user = false) = 0;
/**
* Enqueue/Dequeue function. Places a torrent in queue.
* If the torrent is already in queue this will remove it from queue.
* @param tc TorrentControl pointer.
*/
virtual void queue(kt::TorrentInterface* tc) = 0;
virtual bt::QueueManager* getQueueManager() = 0;
virtual CurrentStats getStats() = 0;
/**
* Switch the port when no torrents are running.
* @param port The new port
* @return true if we can, false if there are torrents running
*/
virtual bool changePort(bt::Uint16 port) = 0;
/// Get the number of torrents running (including seeding torrents).
virtual bt::Uint32 getNumTorrentsRunning() const = 0;
/// Get the number of torrents not running.
virtual bt::Uint32 getNumTorrentsNotRunning() const = 0;
/**
* Load a torrent file. Pops up an error dialog
* if something goes wrong.
* @param file The torrent file
* @param savedir Dir to save the data
* @param silently Wether or not to do this silently
*/
virtual bool load(const QString & file,const QString & savedir,bool silently) = 0;
/**
* Load a torrent file. Pops up an error dialog
* if something goes wrong. Will ask the user for a save location, or use
* the default.
* @param url The torrent file
*/
virtual void load(const KURL& url) = 0;
/**
* Load a torrent file. Pops up an error dialog
* if something goes wrong. Will ask the user for a save location, or use
* the default. This will not popup a file selection dialog for multi file torrents.
* @param url The torrent file
*/
virtual void loadSilently(const KURL& url) = 0;
/**
* Remove a download.This will delete all temp
* data from this TorrentControl And delete the
* TorrentControl itself. It can also potentially
* start a new download (when one is waiting to be downloaded).
* @param tc The torrent
* @param data_to Wether or not to delete the file data to
*/
virtual void remove(TorrentInterface* tc,bool data_to) = 0;
/**
* Inserts IP range to be blocked into IPBlocklist
* @param ip QString reference to single IP or IP range. For example:
* single - 127.0.0.5
* range - 127.0.*.*
**/
virtual void addBlockedIP(QString& ip) = 0;
/**
* Removes IP range from IPBlocklist
* @param ip QString reference to single IP or IP range. For example:
* single - 127.0.0.5
* range - 127.0.*.*
**/
virtual void removeBlockedIP(QString& ip) = 0;
/**
* Find the next free torX dir.
* @return Path to the dir (including the torX part)
*/
virtual QString findNewTorrentDir() const = 0;
/**
* Load an existing torrent, which has already a properly set up torX dir.
* @param tor_dir The torX dir
*/
virtual void loadExistingTorrent(const QString & tor_dir) = 0;
/**
* Returns maximum allowed download speed.
*/
virtual int getMaxDownloadSpeed() = 0;
/**
* Returns maximum allowed upload speed.
*/
virtual int getMaxUploadSpeed() = 0;
/**
* Sets global paused state for all torrents (QueueManager) and stopps all torrents.
* No torrents will be automatically started/stopped.
*/
virtual void setPausedState(bool pause) = 0;
/// Get the global share ratio limit
virtual float getGlobalMaxShareRatio() const = 0;
signals:
/**
* Seeing that when load returns the loading process may not have finished yet,
* and some code expects this. We emit this signal to notify that code of it.
* @param url The url which has been loaded
* @param success Wether or not it succeeded
* @param canceled Wether or not it was canceled by the user
*/
void loadingFinished(const KURL & url,bool success,bool canceled);
/**
* A TorrentInterface was added
* @param tc
*/
void torrentAdded(kt::TorrentInterface* tc);
/**
* A TorrentInterface was removed
* @param tc
*/
void torrentRemoved(kt::TorrentInterface* tc);
/**
* A TorrentInterface has finished downloading.
* @param tc
*/
void finished(kt::TorrentInterface* tc);
/**
* Torrent download is stopped by error
* @param tc TorrentInterface
* @param msg Error message
*/
void torrentStoppedByError(kt::TorrentInterface* tc, QString msg);
};
}
#endif
|
