1 /*
2 * Copyright © 2004-2010 Jens Oknelid, paskharen@gmail.com
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 *
18 * In addition, as a special exception, compiling, linking, and/or
19 * using OpenSSL with this program is allowed.
20 */
21
22 #include "settingsdialog.hh"
23 #include <dcpp/File.h>
24 #include <dcpp/SimpleXML.h>
25 #include <dcpp/CryptoManager.h>
26 #include <dcpp/FavoriteManager.h>
27 #include <dcpp/NmdcHub.h>
28 #include <dcpp/ShareManager.h>
29 #include <dcpp/StringTokenizer.h>
30 #include <dcpp/ThrottleManager.h>
31 #include "settingsmanager.hh"
32 #include "sound.hh"
33 #include "notify.hh"
34 #include "wulformanager.hh"
35 #include "WulforUtil.hh"
36
37 #define ICON_SIZE 32
38 #define ICON_SIZE_NORMAL 22
39
40 using namespace std;
41 using namespace dcpp;
42
Settings(GtkWindow * parent)43 Settings::Settings(GtkWindow* parent):
44 DialogEntry(Entry::SETTINGS_DIALOG, "settingsdialog.ui", parent)
45 {
46 // Configure the dialogs.
47 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("dialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
48 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("publicHubsDialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
49 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("nameDialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
50 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("dirChooserDialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
51 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("fileChooserDialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
52 gtk_dialog_set_alternative_button_order(GTK_DIALOG(getWidget("ExtensionsDialog")), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
53 gtk_window_set_transient_for(GTK_WINDOW(getWidget("ExtensionsDialog")), GTK_WINDOW(getWidget("dialog")));
54
55 // the reference count on the buffer is not incremented and caller of this function won't own a new reference.
56 textStyleBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(getWidget("textViewPreviewStyles")));
57 gtk_text_view_set_buffer(GTK_TEXT_VIEW(getWidget("textViewPreviewStylesTheme")), textStyleBuffer);
58
59 defaultStringTheme.insert(StringMap::value_type("icon-dc++", "eiskaltdcpp-dc++"));
60 defaultStringTheme.insert(StringMap::value_type("icon-dc++-fw", "eiskaltdcpp-dc++-fw"));
61 defaultStringTheme.insert(StringMap::value_type("icon-dc++-fw-op", "eiskaltdcpp-dc++-fw-op"));
62 defaultStringTheme.insert(StringMap::value_type("icon-dc++-op", "eiskaltdcpp-dc++-op"));
63 defaultStringTheme.insert(StringMap::value_type("icon-normal", "eiskaltdcpp-normal"));
64 defaultStringTheme.insert(StringMap::value_type("icon-normal-fw", "eiskaltdcpp-normal-fw"));
65 defaultStringTheme.insert(StringMap::value_type("icon-normal-fw-op", "eiskaltdcpp-normal-fw-op"));
66 defaultStringTheme.insert(StringMap::value_type("icon-normal-op", "eiskaltdcpp-normal-op"));
67 defaultStringTheme.insert(StringMap::value_type("icon-smile", "face-smile"));
68 defaultStringTheme.insert(StringMap::value_type("icon-download", "eiskaltdcpp-go-down"));
69 defaultStringTheme.insert(StringMap::value_type("icon-favorite-hubs", "eiskaltdcpp-favserver"));
70 defaultStringTheme.insert(StringMap::value_type("icon-favorite-users", "eiskaltdcpp-favusers"));
71 defaultStringTheme.insert(StringMap::value_type("icon-finished-downloads", "eiskaltdcpp-go-down-search"));
72 defaultStringTheme.insert(StringMap::value_type("icon-finished-uploads", "eiskaltdcpp-go-up-search"));
73 defaultStringTheme.insert(StringMap::value_type("icon-hash", "eiskaltdcpp-hashing"));
74 defaultStringTheme.insert(StringMap::value_type("icon-refresh", "eiskaltdcpp-refrlist"));
75 defaultStringTheme.insert(StringMap::value_type("icon-preferences", "eiskaltdcpp-configure"));
76 defaultStringTheme.insert(StringMap::value_type("icon-public-hubs", "eiskaltdcpp-server"));
77 defaultStringTheme.insert(StringMap::value_type("icon-queue", "eiskaltdcpp-download"));
78 defaultStringTheme.insert(StringMap::value_type("icon-search", "eiskaltdcpp-edit-find"));
79 defaultStringTheme.insert(StringMap::value_type("icon-search-spy", "eiskaltdcpp-spy"));
80 defaultStringTheme.insert(StringMap::value_type("icon-search-adl", "eiskaltdcpp-adls"));
81 defaultStringTheme.insert(StringMap::value_type("icon-upload", "eiskaltdcpp-go-up"));
82 defaultStringTheme.insert(StringMap::value_type("icon-quit", "eiskaltdcpp-application-exit"));
83 defaultStringTheme.insert(StringMap::value_type("icon-connect", "eiskaltdcpp-network-connect"));
84 defaultStringTheme.insert(StringMap::value_type("icon-reconnect", "eiskaltdcpp-reconnect"));
85 defaultStringTheme.insert(StringMap::value_type("icon-file", GTK_STOCK_FILE));
86 defaultStringTheme.insert(StringMap::value_type("icon-directory", "eiskaltdcpp-folder-blue"));
87 defaultStringTheme.insert(StringMap::value_type("icon-openlist", "eiskaltdcpp-openlist"));
88 defaultStringTheme.insert(StringMap::value_type("icon-own-filelist", "eiskaltdcpp-own_filelist"));
89 defaultStringTheme.insert(StringMap::value_type("icon-magnet", "eiskaltdcpp-gui"));
90 defaultStringTheme.insert(StringMap::value_type("text-general-back-color", "#FFFFFF"));
91 defaultStringTheme.insert(StringMap::value_type("text-general-fore-color", "#4D4D4D"));
92 defaultStringTheme.insert(StringMap::value_type("text-myown-back-color", "#FFFFFF"));
93 defaultStringTheme.insert(StringMap::value_type("text-myown-fore-color", "#207505"));
94 defaultStringTheme.insert(StringMap::value_type("text-private-back-color", "#FFFFFF"));
95 defaultStringTheme.insert(StringMap::value_type("text-private-fore-color", "#2763CE"));
96 defaultStringTheme.insert(StringMap::value_type("text-system-back-color", "#FFFFFF"));
97 defaultStringTheme.insert(StringMap::value_type("text-system-fore-color", "#1A1A1A"));
98 defaultStringTheme.insert(StringMap::value_type("text-status-back-color", "#FFFFFF"));
99 defaultStringTheme.insert(StringMap::value_type("text-status-fore-color", "#7F7F7F"));
100 defaultStringTheme.insert(StringMap::value_type("text-timestamp-back-color", "#FFFFFF"));
101 defaultStringTheme.insert(StringMap::value_type("text-timestamp-fore-color", "#43629A"));
102 defaultStringTheme.insert(StringMap::value_type("text-mynick-back-color", "#FFFFFF"));
103 defaultStringTheme.insert(StringMap::value_type("text-mynick-fore-color", "#A52A2A"));
104 defaultStringTheme.insert(StringMap::value_type("text-fav-back-color", "#FFFFFF"));
105 defaultStringTheme.insert(StringMap::value_type("text-fav-fore-color", "#FFA500"));
106 defaultStringTheme.insert(StringMap::value_type("text-op-back-color", "#FFFFFF"));
107 defaultStringTheme.insert(StringMap::value_type("text-op-fore-color", "#0000FF"));
108 defaultStringTheme.insert(StringMap::value_type("text-url-back-color", "#FFFFFF"));
109 defaultStringTheme.insert(StringMap::value_type("text-url-fore-color", "#0000FF"));
110 defaultIntTheme.insert(IntMap::value_type("text-general-bold", 0));
111 defaultIntTheme.insert(IntMap::value_type("text-general-italic", 0));
112 defaultIntTheme.insert(IntMap::value_type("text-myown-bold", 1));
113 defaultIntTheme.insert(IntMap::value_type("text-myown-italic", 0));
114 defaultIntTheme.insert(IntMap::value_type("text-private-bold", 0));
115 defaultIntTheme.insert(IntMap::value_type("text-private-italic", 0));
116 defaultIntTheme.insert(IntMap::value_type("text-system-bold", 1));
117 defaultIntTheme.insert(IntMap::value_type("text-system-italic", 0));
118 defaultIntTheme.insert(IntMap::value_type("text-status-bold", 1));
119 defaultIntTheme.insert(IntMap::value_type("text-status-italic", 0));
120 defaultIntTheme.insert(IntMap::value_type("text-timestamp-bold", 1));
121 defaultIntTheme.insert(IntMap::value_type("text-timestamp-italic", 0));
122 defaultIntTheme.insert(IntMap::value_type("text-mynick-bold", 1));
123 defaultIntTheme.insert(IntMap::value_type("text-mynick-italic", 0));
124 defaultIntTheme.insert(IntMap::value_type("text-fav-bold", 1));
125 defaultIntTheme.insert(IntMap::value_type("text-fav-italic", 0));
126 defaultIntTheme.insert(IntMap::value_type("text-op-bold", 1));
127 defaultIntTheme.insert(IntMap::value_type("text-op-italic", 0));
128 defaultIntTheme.insert(IntMap::value_type("text-url-bold", 0));
129 defaultIntTheme.insert(IntMap::value_type("text-url-italic", 0));
130
131 // Initialize the tabs in the GtkNotebook.
132 initPersonal_gui();
133 initConnection_gui();
134 initDownloads_gui();
135 initSharing_gui();
136 initAppearance_gui();
137 initLog_gui();
138 initAdvanced_gui();
139 initSearchTypes_gui();
140 }
141
~Settings()142 Settings::~Settings()
143 {
144 if (getResponseID() == GTK_RESPONSE_OK)
145 saveSettings_client();
146
147 gtk_widget_destroy(getWidget("publicHubsDialog"));
148 gtk_widget_destroy(getWidget("nameDialog"));
149 gtk_widget_destroy(getWidget("dirChooserDialog"));
150 gtk_widget_destroy(getWidget("fileChooserDialog"));
151 gtk_widget_destroy(getWidget("commandDialog"));
152 gtk_widget_destroy(getWidget("fontSelectionDialog"));
153 gtk_widget_destroy(getWidget("colorSelectionDialog"));
154 gtk_widget_destroy(getWidget("ExtensionsDialog"));
155 }
156
response_gui()157 void Settings::response_gui()
158 {
159 gtk_dialog_response(GTK_DIALOG(getContainer()), GTK_RESPONSE_CANCEL);
160
161 gtk_dialog_response(GTK_DIALOG(getWidget("publicHubsDialog")), GTK_RESPONSE_CANCEL);
162 gtk_dialog_response(GTK_DIALOG(getWidget("nameDialog")), GTK_RESPONSE_CANCEL);
163 gtk_dialog_response(GTK_DIALOG(getWidget("dirChooserDialog")), GTK_RESPONSE_CANCEL);
164 gtk_dialog_response(GTK_DIALOG(getWidget("fileChooserDialog")), GTK_RESPONSE_CANCEL);
165 gtk_dialog_response(GTK_DIALOG(getWidget("commandDialog")), GTK_RESPONSE_CANCEL);
166 gtk_dialog_response(GTK_DIALOG(getWidget("fontSelectionDialog")), GTK_RESPONSE_CANCEL);
167 gtk_dialog_response(GTK_DIALOG(getWidget("colorSelectionDialog")), GTK_RESPONSE_CANCEL);
168 gtk_dialog_response(GTK_DIALOG(getWidget("ExtensionsDialog")), GTK_RESPONSE_CANCEL);
169 }
170
saveSettings_client()171 void Settings::saveSettings_client()
172 {
173 SettingsManager *sm = SettingsManager::getInstance();
174 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
175 string path;
176
177 { // Personal
178 sm->set(SettingsManager::NICK, gtk_entry_get_text(GTK_ENTRY(getWidget("nickEntry"))));
179 sm->set(SettingsManager::EMAIL, gtk_entry_get_text(GTK_ENTRY(getWidget("emailEntry"))));
180 sm->set(SettingsManager::DESCRIPTION, gtk_entry_get_text(GTK_ENTRY(getWidget("descriptionEntry"))));
181 sm->set(SettingsManager::UPLOAD_SPEED, SettingsManager::connectionSpeeds[gtk_combo_box_get_active(GTK_COMBO_BOX(connectionSpeedComboBox))]);
182
183 gchar *encoding = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(getWidget("comboboxCharset")));
184 WSET("default-charset", string(encoding));
185 g_free(encoding);
186 }
187
188 { // Connection
189 { // Connection
190 // Incoming connection
191 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("activeRadioButton"))))
192 sm->set(SettingsManager::INCOMING_CONNECTIONS, SettingsManager::INCOMING_DIRECT);
193 #ifdef USE_MINIUPNP
194 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("upnpRadioButton"))))
195 sm->set(SettingsManager::INCOMING_CONNECTIONS, SettingsManager::INCOMING_FIREWALL_UPNP);
196 #endif
197 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("portForwardRadioButton"))))
198 sm->set(SettingsManager::INCOMING_CONNECTIONS, SettingsManager::INCOMING_FIREWALL_NAT);
199 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("passiveRadioButton"))))
200 sm->set(SettingsManager::INCOMING_CONNECTIONS, SettingsManager::INCOMING_FIREWALL_PASSIVE);
201
202 sm->set(SettingsManager::EXTERNAL_IP, gtk_entry_get_text(GTK_ENTRY(getWidget("ipEntry"))));
203 sm->set(SettingsManager::NO_IP_OVERRIDE, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("forceIPCheckButton"))));
204
205 int port = Util::toInt(gtk_entry_get_text(GTK_ENTRY(getWidget("tcpEntry"))));
206 if (port > 0 && port <= 65535)
207 sm->set(SettingsManager::TCP_PORT, port);
208 port = Util::toInt(gtk_entry_get_text(GTK_ENTRY(getWidget("udpEntry"))));
209 if (port > 0 && port <= 65535)
210 sm->set(SettingsManager::UDP_PORT, port);
211 port = Util::toInt(gtk_entry_get_text(GTK_ENTRY(getWidget("tlsEntry"))));
212 if (port > 0 && port <= 65535) {
213 if (port != SETTING(TCP_PORT))
214 sm->set(SettingsManager::TLS_PORT, port);
215 else
216 sm->set(SettingsManager::TLS_PORT, port+1);
217 }
218
219 // Outgoing connection
220 int type = SETTING(OUTGOING_CONNECTIONS);
221 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("outDirectRadioButton"))))
222 sm->set(SettingsManager::OUTGOING_CONNECTIONS, SettingsManager::OUTGOING_DIRECT);
223 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("socksRadioButton"))))
224 sm->set(SettingsManager::OUTGOING_CONNECTIONS, SettingsManager::OUTGOING_SOCKS5);
225
226 if (SETTING(OUTGOING_CONNECTIONS) != type)
227 Socket::socksUpdated();
228
229 sm->set(SettingsManager::SOCKS_SERVER, gtk_entry_get_text(GTK_ENTRY(getWidget("socksIPEntry"))));
230 sm->set(SettingsManager::SOCKS_USER, gtk_entry_get_text(GTK_ENTRY(getWidget("socksUserEntry"))));
231 sm->set(SettingsManager::SOCKS_PASSWORD, gtk_entry_get_text(GTK_ENTRY(getWidget("socksPassEntry"))));
232 sm->set(SettingsManager::SOCKS_RESOLVE, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("socksCheckButton"))));
233
234 port = Util::toInt(gtk_entry_get_text(GTK_ENTRY(getWidget("socksPortEntry"))));
235 if (port > 0 && port <= 65535)
236 sm->set(SettingsManager::SOCKS_PORT, port);
237 }
238 { // Limits
239 sm->set(SettingsManager::THROTTLE_ENABLE,gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("useLimitCheckButton"))));
240 // Transfer Rate Limiting
241 sm->set(SettingsManager::MAX_UPLOAD_SPEED_MAIN,
242 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("transferMaxUpload"))));
243 sm->set(SettingsManager::MAX_DOWNLOAD_SPEED_MAIN,
244 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("transferMaxDownload"))));
245
246 // Secondary Transfer Rate Limiting
247 bool secondary = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("useLimitSecondCheckButton")));
248 sm->set(SettingsManager::TIME_DEPENDENT_THROTTLE, secondary);
249
250 if (secondary)
251 {
252 // Secondary Transfer Rate Settings
253 sm->set(SettingsManager::MAX_UPLOAD_SPEED_ALTERNATE,
254 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("secondaryMaxUpload"))));
255 sm->set(SettingsManager::MAX_DOWNLOAD_SPEED_ALTERNATE,
256 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("secondaryMaxDownload"))));
257 sm->set(SettingsManager::SLOTS_ALTERNATE_LIMITING,
258 (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("secondaryUploadSlots"))));
259 sm->set(SettingsManager::BANDWIDTH_LIMIT_START,
260 gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("limitsFromCombobox"))));
261 sm->set(SettingsManager::BANDWIDTH_LIMIT_END,
262 gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("limitsToCombobox"))));
263 }
264 }
265 { // Advanced
266 sm->set(SettingsManager::DYNDNS_ENABLE,
267 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("enableDynDNSCheckButton"))));
268 sm->set(SettingsManager::DYNDNS_SERVER,
269 gtk_entry_get_text(GTK_ENTRY(getWidget("dyndnsEntry"))));
270
271 sm->set(SettingsManager::USE_DHT,
272 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("useDHTCheckButton"))));
273 int port = Util::toInt(gtk_entry_get_text(GTK_ENTRY(getWidget("dhtEntry"))));
274 if (port > 0 && port <= 65535) {
275 if (port != SETTING(UDP_PORT))
276 sm->set(SettingsManager::DHT_PORT, port);
277 else
278 sm->set(SettingsManager::DHT_PORT, port+1);
279 }
280 }
281 }
282
283 { // Downloads
284 path = gtk_entry_get_text(GTK_ENTRY(getWidget("finishedDownloadsEntry")));
285 if (path[path.length() - 1] != PATH_SEPARATOR)
286 path += PATH_SEPARATOR;
287 sm->set(SettingsManager::DOWNLOAD_DIRECTORY, path);
288
289 path = gtk_entry_get_text(GTK_ENTRY(getWidget("unfinishedDownloadsEntry")));
290 if (!path.empty() && path[path.length() - 1] != PATH_SEPARATOR)
291 path += PATH_SEPARATOR;
292 sm->set(SettingsManager::TEMP_DOWNLOAD_DIRECTORY, path);
293 sm->set(SettingsManager::NO_USE_TEMP_DIR, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("noUseTempDirButton"))));
294 sm->set(SettingsManager::DOWNLOAD_SLOTS, (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("maxDownloadsSpinButton"))));
295 sm->set(SettingsManager::MAX_DOWNLOAD_SPEED, (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("newDownloadsSpinButton"))));
296 sm->set(SettingsManager::HTTP_PROXY, gtk_entry_get_text(GTK_ENTRY(getWidget("proxyEntry"))));
297
298 { // Queue
299 // Auto-priority
300 sm->set(SettingsManager::PRIO_HIGHEST_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("priorityHighestSpinButton")))));
301 sm->set(SettingsManager::PRIO_HIGH_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("priorityHighSpinButton")))));
302 sm->set(SettingsManager::PRIO_NORMAL_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("priorityNormalSpinButton")))));
303 sm->set(SettingsManager::PRIO_LOW_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("priorityLowSpinButton")))));
304
305 // Auto-drop
306 sm->set(SettingsManager::AUTODROP_SPEED, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropSpeedSpinButton")))));
307 sm->set(SettingsManager::AUTODROP_ELAPSED, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropElapsedSpinButton")))));
308 sm->set(SettingsManager::AUTODROP_MINSOURCES, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropMinSourcesSpinButton")))));
309 sm->set(SettingsManager::AUTODROP_INTERVAL, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropCheckSpinButton")))));
310 sm->set(SettingsManager::AUTODROP_INACTIVITY, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropInactiveSpinButton")))));
311 sm->set(SettingsManager::AUTODROP_FILESIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("dropSizeSpinButton")))));
312
313 // Other queue options
314 saveOptionsView_gui(queueView, sm);
315 }
316 }
317
318 { // Sharing
319 sm->set(SettingsManager::FOLLOW_LINKS, (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("followLinksCheckButton"))));
320 sm->set(SettingsManager::MIN_UPLOAD_SPEED, (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("sharedExtraSlotSpinButton"))));
321 int sl = gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("sharedUploadSlotsSpinButton")));
322 sm->set(SettingsManager::SLOTS_PRIMARY, sl);
323
324 GtkTreeIter iter; string lists = "";
325 GtkTreeModel *m = GTK_TREE_MODEL(exceptionStore);
326 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
327 while (valid)
328 {
329 lists += exceptionView.getString(&iter, _("List")) + "|";
330 valid = gtk_tree_model_iter_next(m, &iter);
331 }
332 if (!lists.empty())
333 lists.erase(lists.size() - 1);
334 SettingsManager::getInstance()->set(SettingsManager::SKIPLIST_SHARE, lists);
335
336 sm->set(SettingsManager::SHARE_SKIP_ZERO_BYTE, (int)gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("skipZeroSizedFilesCheckButton"))));
337 }
338
339 { // Appearance
340 int lang_ind = gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("languageComboBox")));
341 if (lang_ind >= 0)
342 WSET("translation-lang",vectorLangShortNames.at(lang_ind));
343
344 saveOptionsView_gui(appearanceView, sm);
345
346 WSET("tab-position", gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("tabPositionComboBox"))));
347 WSET("toolbar-style", gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("toolbarStyleComboBox"))));
348
349 sm->set(SettingsManager::DEFAULT_AWAY_MESSAGE, string(gtk_entry_get_text(GTK_ENTRY(getWidget("awayMessageEntry")))));
350 sm->set(SettingsManager::TIME_STAMPS_FORMAT, string(gtk_entry_get_text(GTK_ENTRY(getWidget("timestampEntry")))));
351
352 { // Tabs
353 saveOptionsView_gui(tabView, sm);
354 }
355
356 { // Sounds
357 GtkTreeIter iter;
358 GtkTreeModel *m = GTK_TREE_MODEL(soundStore);
359 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
360
361 while (valid)
362 {
363 wsm->set(soundView.getString(&iter, "keyUse"), soundView.getValue<int>(&iter, _("Use")));
364 wsm->set(soundView.getString(&iter, "keyFile"), soundView.getString(&iter, _("File")));
365
366 valid = gtk_tree_model_iter_next(m, &iter);
367 }
368
369 WSET("sound-pm",gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("soundPMReceivedCheckButton"))));
370 WSET("sound-pm-open", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("soundPMWindowCheckButton"))));
371
372 wsm->set("sound-command", string(gtk_entry_get_text(GTK_ENTRY(getWidget("soundCommandEntry")))));
373 }
374
375 { // Colors & Fonts
376
377 GtkTreeIter iter;
378 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
379 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
380
381 while (valid)
382 {
383 wsm->set(textStyleView.getString(&iter, "keyForeColor"), textStyleView.getString(&iter, "ForeColor"));
384 wsm->set(textStyleView.getString(&iter, "keyBackColor"), textStyleView.getString(&iter, "BackColor"));
385 wsm->set(textStyleView.getString(&iter, "keyBolt"), textStyleView.getValue<int>(&iter, "Bolt"));
386 wsm->set(textStyleView.getString(&iter, "keyItalic"), textStyleView.getValue<int>(&iter, "Italic"));
387
388 valid = gtk_tree_model_iter_next(m, &iter);
389 }
390
391 WSET("text-bold-autors", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("checkBoldAuthors"))));
392 }
393
394 { // Notify
395 GtkTreeIter iter;
396 GtkTreeModel *m = GTK_TREE_MODEL(notifyStore);
397 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
398
399 while (valid)
400 {
401 wsm->set(notifyView.getString(&iter, "keyUse"), notifyView.getValue<int>(&iter, _("Use")));
402 wsm->set(notifyView.getString(&iter, "keyTitle"), notifyView.getString(&iter, _("Title")));
403 wsm->set(notifyView.getString(&iter, "keyIcon"), notifyView.getString(&iter, _("Icon")));
404
405 valid = gtk_tree_model_iter_next(m, &iter);
406 }
407
408 WSET("notify-pm-length", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("notifyPMLengthSpinButton"))));
409 WSET("notify-icon-size", gtk_combo_box_get_active(GTK_COMBO_BOX(getWidget("notifyIconSizeComboBox"))));
410 WSET("notify-only-not-active", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("notifyAppActiveCheckButton"))));
411 }
412
413 { // Theme
414 GtkTreeIter iter;
415 GtkTreeModel *m = GTK_TREE_MODEL(themeIconsStore);
416 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
417
418 while (valid)
419 {
420 wsm->set(themeIconsView.getString(&iter, "keyIcon"), themeIconsView.getString(&iter, "iconName"));
421 valid = gtk_tree_model_iter_next(m, &iter);
422 }
423
424 string theme = gtk_label_get_text(GTK_LABEL(getWidget("currentThemeLabel")));
425 wsm->set("theme-name", theme);
426 }
427
428 { // Toolbar
429 GtkTreeIter iter;
430 GtkTreeModel *m = GTK_TREE_MODEL(toolbarStore);
431 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
432
433 while (valid)
434 {
435 wsm->set(toolbarView.getString(&iter, "keyUse"), toolbarView.getValue<int>(&iter, (_("Use"))));
436 valid = gtk_tree_model_iter_next(m, &iter);
437 }
438 }
439
440 { // Search Spy
441
442 #if GTK_CHECK_VERSION(3,4,0)
443 GdkRGBA color;
444 #define g_c_b_g gtk_color_chooser_get_rgba
445 #define G_C_B GTK_COLOR_CHOOSER
446 #else
447 GdkColor color;
448 #define g_c_b_g gtk_color_button_get_color
449 #define G_C_B GTK_COLOR_BUTTON
450 #endif
451 g_c_b_g(G_C_B(getWidget("aSPColorButton")), &color);
452 WSET("search-spy-a-color", WulforUtil::colorToString(&color));
453
454 g_c_b_g(G_C_B(getWidget("tSPColorButton")), &color);
455 WSET("search-spy-t-color", WulforUtil::colorToString(&color));
456
457 g_c_b_g(G_C_B(getWidget("qSPColorButton")), &color);
458 WSET("search-spy-q-color", WulforUtil::colorToString(&color));
459
460 g_c_b_g(G_C_B(getWidget("cSPColorButton")), &color);
461 WSET("search-spy-c-color", WulforUtil::colorToString(&color));
462
463 g_c_b_g(G_C_B(getWidget("rSPColorButton")), &color);
464 WSET("search-spy-r-color", WulforUtil::colorToString(&color));
465
466 WSET("search-spy-frame", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("frameSPSpinButton"))));
467 WSET("search-spy-waiting", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("waitingSPSpinButton"))));
468 WSET("search-spy-top", (int)gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("topSPSpinButton"))));
469
470 #undef g_c_b_g
471 #undef G_C_B
472
473 }
474
475 { // Window
476 // Auto-open on startup
477 saveOptionsView_gui(windowView1, sm);
478
479 // Window options
480 saveOptionsView_gui(windowView2, sm);
481
482 // Confirm dialog options
483 saveOptionsView_gui(windowView3, sm);
484 }
485 }
486
487 { // Logs
488 path = gtk_entry_get_text(GTK_ENTRY(getWidget("logDirectoryEntry")));
489 if (!path.empty() && path[path.length() - 1] != PATH_SEPARATOR)
490 path += PATH_SEPARATOR;
491 sm->set(SettingsManager::LOG_DIRECTORY, path);
492 sm->set(SettingsManager::LOG_MAIN_CHAT, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logMainCheckButton"))));
493 sm->set(SettingsManager::LOG_FORMAT_MAIN_CHAT, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logMainEntry")))));
494 sm->set(SettingsManager::LOG_FILE_MAIN_CHAT, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logMainEntryFile")))));
495 sm->set(SettingsManager::LOG_PRIVATE_CHAT, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logPrivateCheckButton"))));
496 sm->set(SettingsManager::LOG_FORMAT_PRIVATE_CHAT, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logPrivateEntry")))));
497 sm->set(SettingsManager::LOG_FILE_PRIVATE_CHAT, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logPrivateEntryFile")))));
498 sm->set(SettingsManager::LOG_DOWNLOADS, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logDownloadsCheckButton"))));
499 sm->set(SettingsManager::LOG_FORMAT_POST_DOWNLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logDownloadsEntry")))));
500 sm->set(SettingsManager::LOG_FILE_DOWNLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logDownloadsEntryFile")))));
501 sm->set(SettingsManager::LOG_UPLOADS, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logUploadsCheckButton"))));
502 sm->set(SettingsManager::LOG_FORMAT_POST_UPLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logUploadsEntry")))));
503 sm->set(SettingsManager::LOG_FILE_UPLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logUploadsEntryFile")))));
504 sm->set(SettingsManager::LOG_FORMAT_POST_FINISHED_DOWNLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logFinishedDownloadsEntry")))));
505 sm->set(SettingsManager::LOG_FILE_FINISHED_DOWNLOAD, string(gtk_entry_get_text(GTK_ENTRY(getWidget("logFinishedDownloadsEntryFile")))));
506 sm->set(SettingsManager::LOG_SYSTEM, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logSystemCheckButton"))));
507 sm->set(SettingsManager::LOG_STATUS_MESSAGES, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logStatusCheckButton"))));
508 sm->set(SettingsManager::LOG_FILELIST_TRANSFERS, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logFilelistTransfersCheckButton"))));
509 sm->set(SettingsManager::REPORT_ALTERNATES, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("logSearchAltCheckButton"))));
510 }
511
512 { // Advanced
513 saveOptionsView_gui(advancedView, sm);
514
515 // Expert
516 sm->set(SettingsManager::MAX_HASH_SPEED, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("hashSpeedSpinButton")))));
517 sm->set(SettingsManager::BUFFER_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("writeBufferSpinButton")))));
518 sm->set(SettingsManager::SHOW_LAST_LINES_LOG, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("pmHistorySpinButton")))));
519 sm->set(SettingsManager::SET_MINISLOT_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("slotSizeSpinButton")))));
520 sm->set(SettingsManager::MAX_FILELIST_SIZE, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("maxListSizeSpinButton")))));
521 sm->set(SettingsManager::PRIVATE_ID, string(gtk_entry_get_text(GTK_ENTRY(getWidget("CIDEntry")))));
522 sm->set(SettingsManager::AUTO_REFRESH_TIME, Util::toString (gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("autoRefreshSpinButton")))));
523 sm->set(SettingsManager::SEARCH_HISTORY, Util::toString (gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("searchHistorySpinButton")))));
524 sm->set(SettingsManager::BIND_ADDRESS, string(gtk_entry_get_text(GTK_ENTRY(getWidget("bindAddressEntry")))));
525 sm->set(SettingsManager::SOCKET_IN_BUFFER, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("socketReadSpinButton")))));
526 sm->set(SettingsManager::SOCKET_OUT_BUFFER, Util::toString(gtk_spin_button_get_value(GTK_SPIN_BUTTON(getWidget("socketWriteSpinButton")))));
527 // Security Certificates
528 path = gtk_entry_get_text(GTK_ENTRY(getWidget("trustedCertificatesPathEntry")));
529 if (!path.empty() && path[path.length() - 1] != PATH_SEPARATOR)
530 path += PATH_SEPARATOR;
531 sm->set(SettingsManager::TLS_PRIVATE_KEY_FILE, string(gtk_entry_get_text(GTK_ENTRY(getWidget("privateKeyEntry")))));
532 sm->set(SettingsManager::TLS_CERTIFICATE_FILE, string(gtk_entry_get_text(GTK_ENTRY(getWidget("certificateFileEntry")))));
533 sm->set(SettingsManager::TLS_TRUSTED_CERTIFICATES_PATH, path);
534
535 saveOptionsView_gui(certificatesView, sm);
536 }
537 sm->save();
538 }
539
540 /* Adds a core option */
541
addOption_gui(GtkListStore * store,const string & name,SettingsManager::IntSetting setting)542 void Settings::addOption_gui(GtkListStore *store, const string &name, SettingsManager::IntSetting setting)
543 {
544 GtkTreeIter iter;
545 gtk_list_store_append(store, &iter);
546 gtk_list_store_set(store, &iter,
547 0, SettingsManager::getInstance()->get(setting),
548 1, name.c_str(),
549 2, setting,
550 3, "",
551 -1);
552 }
553
554 /* Adds a custom UI specific option */
555
addOption_gui(GtkListStore * store,const string & name,const string & setting)556 void Settings::addOption_gui(GtkListStore *store, const string &name, const string &setting)
557 {
558 GtkTreeIter iter;
559 gtk_list_store_append(store, &iter);
560 gtk_list_store_set(store, &iter,
561 0, WGETI(setting),
562 1, name.c_str(),
563 2, -2,
564 3, setting.c_str(),
565 -1);
566 }
567
568 /* Adds a sounds options */
569
addOption_gui(GtkListStore * store,WulforSettingsManager * wsm,const string & name,const string & key1,const string & key2)570 void Settings::addOption_gui(GtkListStore *store, WulforSettingsManager *wsm, const string &name, const string &key1, const string &key2)
571 {
572 GtkTreeIter iter;
573 gtk_list_store_append(store, &iter);
574 gtk_list_store_set(store, &iter,
575 0, wsm->getInt(key1), //use
576 1, name.c_str(), //sounds
577 2, wsm->getString(key2).c_str(), //file
578 3, key1.c_str(), //key use
579 4, key2.c_str(), //key file
580 -1);
581 }
582
583 /* Adds a notify options */
584
addOption_gui(GtkListStore * store,WulforSettingsManager * wsm,const string & name,const string & key1,const string & key2,const string & key3,const int key4)585 void Settings::addOption_gui(GtkListStore *store, WulforSettingsManager *wsm,
586 const string &name, const string &key1, const string &key2, const string &key3, const int key4)
587 {
588 GdkPixbuf *icon = NULL;
589 string pathIcon = wsm->getString(key3);
590 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(Text::fromUtf8(pathIcon).c_str(), NULL);
591
592 if (pixbuf)
593 {
594 icon = WulforUtil::scalePixbuf(pixbuf, ICON_SIZE, ICON_SIZE);
595 g_object_unref(pixbuf);
596 }
597 else
598 pathIcon = "";
599
600 GtkTreeIter iter;
601 gtk_list_store_append(store, &iter);
602 gtk_list_store_set(store, &iter,
603 0, wsm->getInt(key1), //use
604 1, name.c_str(), //notify
605 2, wsm->getString(key2).c_str(), //title
606 3, pathIcon.c_str(), //icon path
607 4, key1.c_str(), //key use
608 5, key2.c_str(), //key title
609 6, key3.c_str(), //key icon
610 7, icon, //icon
611 8, key4, //urgency
612 -1);
613
614 if (icon)
615 g_object_unref(icon);
616 }
617
618 /* Adds a theme options */
619
addOption_gui(GtkListStore * store,WulforSettingsManager * wsm,GtkIconTheme * iconTheme,const string & name,const string & key1)620 void Settings::addOption_gui(GtkListStore *store, WulforSettingsManager *wsm, GtkIconTheme *iconTheme,
621 const string &name, const string &key1)
622 {
623 string iconName = wsm->getString(key1);
624 GdkPixbuf *icon = gtk_icon_theme_load_icon(iconTheme, iconName.c_str(),
625 ICON_SIZE, GTK_ICON_LOOKUP_FORCE_SVG, NULL);
626
627 GtkTreeIter iter;
628 gtk_list_store_append(store, &iter);
629 gtk_list_store_set(store, &iter,
630 0, name.c_str(),
631 1, icon,
632 2, iconName.c_str(),
633 3, key1.c_str(),
634 -1);
635
636 if (icon)
637 g_object_unref(icon);
638
639 set(key1, iconName);
640 }
641
642 /* Adds a toolbar buttons options*/
addOption_gui(GtkListStore * store,WulforSettingsManager * wsm,GtkIconTheme * iconTheme,const string & name,const string & key1,const string & key2)643 void Settings::addOption_gui(GtkListStore *store, WulforSettingsManager *wsm, GtkIconTheme *iconTheme,
644 const string &name, const string &key1, const string &key2)
645 {
646 string iconName = wsm->getString(key2);
647 GdkPixbuf *icon = gtk_icon_theme_load_icon(iconTheme, iconName.c_str(),
648 ICON_SIZE_NORMAL, GTK_ICON_LOOKUP_FORCE_SVG, NULL);
649
650 GtkTreeIter iter;
651 gtk_list_store_append(store, &iter);
652 gtk_list_store_set(store, &iter,
653 0, wsm->getInt(key1),
654 1, name.c_str(),
655 2, icon,
656 3, key1.c_str(),
657 -1);
658
659 if (icon)
660 g_object_unref(icon);
661 }
662
663 /* Adds a colors and fonts options */
664
addOption_gui(GtkListStore * store,WulforSettingsManager * wsm,const string & name,const string & key1,const string & key2,const string & key3,const string & key4)665 void Settings::addOption_gui(GtkListStore *store, WulforSettingsManager *wsm, const string &name,
666 const string &key1, const string &key2, const string &key3, const string &key4)
667 {
668 GtkTreeIter iter;
669 gtk_list_store_append(store, &iter);
670 gtk_list_store_set(store, &iter,
671 0, name.c_str(),
672 1, wsm->getString(key1).c_str(),
673 2, wsm->getString(key2).c_str(),
674 3, wsm->getInt(key3),
675 4, wsm->getInt(key4),
676 5, key1.c_str(),
677 6, key2.c_str(),
678 7, key3.c_str(),
679 8, key4.c_str(),
680 -1);
681 }
682
683 /* Creates a generic checkbox-based options GtkTreeView */
684
createOptionsView_gui(TreeView & treeView,GtkListStore * & store,const string & widgetName)685 void Settings::createOptionsView_gui(TreeView &treeView, GtkListStore *&store, const string &widgetName)
686 {
687 // Create the view
688 treeView.setView(GTK_TREE_VIEW(getWidget(widgetName)));
689 treeView.insertColumn(_("Use"), G_TYPE_BOOLEAN, TreeView::BOOL, -1);
690 treeView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::STRING, -1);
691 treeView.insertHiddenColumn("Core Setting", G_TYPE_INT);
692 treeView.insertHiddenColumn("UI Setting", G_TYPE_STRING);
693 treeView.finalize();
694
695 // Create the store
696 store = gtk_list_store_newv(treeView.getColCount(), treeView.getGTypes());
697 gtk_tree_view_set_model(treeView.get(), GTK_TREE_MODEL(store));
698 g_object_unref(store);
699 gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), treeView.col(_("Name")), GTK_SORT_ASCENDING);
700
701 // Connect the signal handlers
702 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(gtk_tree_view_get_column(treeView.get(), treeView.col(_("Use")))));
703 GObject *renderer = (GObject *)g_list_nth_data(list, 0);
704 g_signal_connect(renderer, "toggled", G_CALLBACK(onOptionsViewToggled_gui), (gpointer)store);
705 g_list_free(list);
706 }
707
708 /* Saves the core or UI values stored in the options GtkTreeView */
709
saveOptionsView_gui(TreeView & treeView,SettingsManager * sm)710 void Settings::saveOptionsView_gui(TreeView &treeView, SettingsManager *sm)
711 {
712 GtkTreeIter iter;
713 GtkTreeModel *m = gtk_tree_view_get_model(treeView.get());
714 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
715
716 while (valid)
717 {
718 gboolean toggled = treeView.getValue<gboolean>(&iter, _("Use"));
719 gint coreSetting = treeView.getValue<gint>(&iter, "Core Setting");
720
721 // If core setting has been set to a valid value
722 if (coreSetting >= 0)
723 {
724 sm->set((SettingsManager::IntSetting)coreSetting, toggled);
725 }
726 else
727 {
728 string uiSetting = treeView.getString(&iter, "UI Setting");
729 WSET(uiSetting, toggled);
730 }
731 valid = gtk_tree_model_iter_next(m, &iter);
732 }
733 }
734
initPersonal_gui()735 void Settings::initPersonal_gui()
736 {
737 gtk_entry_set_text(GTK_ENTRY(getWidget("nickEntry")), SETTING(NICK).c_str());
738 gtk_entry_set_text(GTK_ENTRY(getWidget("emailEntry")), SETTING(EMAIL).c_str());
739 gtk_entry_set_text(GTK_ENTRY(getWidget("descriptionEntry")), SETTING(DESCRIPTION).c_str());
740 connectionSpeedComboBox = GTK_COMBO_BOX_TEXT(gtk_combo_box_text_new());
741 gtk_box_pack_start(GTK_BOX(getWidget("connectionBox")), GTK_WIDGET(connectionSpeedComboBox), FALSE, TRUE, 0);
742 gtk_widget_show_all(GTK_WIDGET(connectionSpeedComboBox));
743
744 for (StringIter i = SettingsManager::connectionSpeeds.begin(); i != SettingsManager::connectionSpeeds.end(); ++i)
745 {
746 gtk_combo_box_text_append_text(connectionSpeedComboBox, (*i).c_str());
747 if (SETTING(UPLOAD_SPEED) == *i)
748 gtk_combo_box_set_active(GTK_COMBO_BOX(connectionSpeedComboBox), i - SettingsManager::connectionSpeeds.begin());
749 }
750
751 // Fill charset drop-down list
752 vector<string> &charsets = WulforUtil::getCharsets();
753 for (auto it = charsets.begin(); it != charsets.end(); ++it)
754 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(getWidget("comboboxCharset")), it->c_str());
755
756 gtk_entry_set_text(GTK_ENTRY(getWidget("comboboxentryCharset")), WGETS("default-charset").c_str());
757 }
758
initConnection_gui()759 void Settings::initConnection_gui()
760 {
761 { // Connection
762 // Incoming
763 g_signal_connect(getWidget("activeRadioButton"), "toggled", G_CALLBACK(onInDirect_gui), (gpointer)this);
764 g_signal_connect(getWidget("upnpRadioButton"), "toggled", G_CALLBACK(onInFW_UPnP_gui), (gpointer)this);
765 g_signal_connect(getWidget("portForwardRadioButton"), "toggled", G_CALLBACK(onInFW_NAT_gui), (gpointer)this);
766 g_signal_connect(getWidget("passiveRadioButton"), "toggled", G_CALLBACK(onInPassive_gui), (gpointer)this);
767 gtk_entry_set_text(GTK_ENTRY(getWidget("ipEntry")), SETTING(EXTERNAL_IP).c_str());
768
769 // Fill IP address combo box
770 vector<string> addresses = WulforUtil::getLocalIPs();
771 for (auto it = addresses.begin(); it != addresses.end(); ++it)
772 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(getWidget("ipComboboxEntry")), it->c_str());
773
774 gtk_entry_set_text(GTK_ENTRY(getWidget("tcpEntry")), Util::toString(SETTING(TCP_PORT)).c_str());
775 gtk_entry_set_text(GTK_ENTRY(getWidget("udpEntry")), Util::toString(SETTING(UDP_PORT)).c_str());
776 gtk_entry_set_text(GTK_ENTRY(getWidget("tlsEntry")), Util::toString(SETTING(TLS_PORT)).c_str());
777 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("forceIPCheckButton")), SETTING(NO_IP_OVERRIDE));
778
779 switch (SETTING(INCOMING_CONNECTIONS))
780 {
781 case SettingsManager::INCOMING_DIRECT:
782 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("activeRadioButton")), TRUE);
783 break;
784 case SettingsManager::INCOMING_FIREWALL_NAT:
785 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("portForwardRadioButton")), TRUE);
786 break;
787 case SettingsManager::INCOMING_FIREWALL_UPNP:
788 #ifdef USE_MINIUPNP
789 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("upnpRadioButton")), TRUE);
790 #endif
791 break;
792 case SettingsManager::INCOMING_FIREWALL_PASSIVE:
793 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("passiveRadioButton")), TRUE);
794 break;
795 }
796 #ifndef USE_MINIUPNP
797 gtk_widget_set_sensitive(getWidget("upnpRadioButton"), FALSE);
798 #endif
799
800 // Outgoing
801 g_signal_connect(getWidget("outDirectRadioButton"), "toggled", G_CALLBACK(onOutDirect_gui), (gpointer)this);
802 g_signal_connect(getWidget("socksRadioButton"), "toggled", G_CALLBACK(onSocks5_gui), (gpointer)this);
803 gtk_entry_set_text(GTK_ENTRY(getWidget("socksIPEntry")), SETTING(SOCKS_SERVER).c_str());
804 gtk_entry_set_text(GTK_ENTRY(getWidget("socksUserEntry")), SETTING(SOCKS_USER).c_str());
805 gtk_entry_set_text(GTK_ENTRY(getWidget("socksPortEntry")), Util::toString(SETTING(SOCKS_PORT)).c_str());
806 gtk_entry_set_text(GTK_ENTRY(getWidget("socksPassEntry")), SETTING(SOCKS_PASSWORD).c_str());
807 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("socksCheckButton")), SETTING(SOCKS_RESOLVE));
808
809 switch (SETTING(OUTGOING_CONNECTIONS))
810 {
811 case SettingsManager::OUTGOING_DIRECT:
812 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("outDirectRadioButton")), TRUE);
813 onOutDirect_gui(NULL, (gpointer)this);
814 break;
815 case SettingsManager::OUTGOING_SOCKS5:
816 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("socksRadioButton")), TRUE);
817 break;
818 }
819 }
820 { // Limits
821 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("useLimitCheckButton")), BOOLSETTING( THROTTLE_ENABLE));
822 // Transfer Rate Limiting
823 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("transferMaxUpload")), (double)SETTING(MAX_UPLOAD_SPEED_MAIN));
824 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("transferMaxDownload")), (double)SETTING(MAX_DOWNLOAD_SPEED_MAIN));
825
826 // Secondary Transfer Rate Settings
827 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("secondaryMaxUpload")), (double)SETTING(MAX_UPLOAD_SPEED_ALTERNATE));
828 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("secondaryMaxDownload")), (double)SETTING(MAX_DOWNLOAD_SPEED_ALTERNATE));
829 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("secondaryUploadSlots")), (double)SETTING(SLOTS_ALTERNATE_LIMITING));
830
831 // Secondary Transfer Rate Limiting
832 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("limitsFromCombobox")), SETTING(BANDWIDTH_LIMIT_START));
833 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("limitsToCombobox")), SETTING(BANDWIDTH_LIMIT_END));
834
835 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("useLimitSecondCheckButton")), BOOLSETTING(TIME_DEPENDENT_THROTTLE));
836
837 onLimitToggled_gui(NULL, (gpointer)this);
838 g_signal_connect(getWidget("useLimitCheckButton"), "toggled", G_CALLBACK(onLimitToggled_gui), (gpointer)this);
839
840 onLimitSecondToggled_gui(NULL, (gpointer)this);
841 g_signal_connect(getWidget("useLimitSecondCheckButton"), "toggled", G_CALLBACK(onLimitSecondToggled_gui), (gpointer)this);
842 }
843 { // Advanced
844 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("enableDynDNSCheckButton")), BOOLSETTING(DYNDNS_ENABLE));
845 gtk_entry_set_text(GTK_ENTRY(getWidget("dyndnsEntry")), SETTING(DYNDNS_SERVER).c_str());
846
847 onEnableDynDNSCheckToggled_gui(NULL, (gpointer)this);
848 g_signal_connect(getWidget("enableDynDNSCheckButton"), "toggled", G_CALLBACK(onEnableDynDNSCheckToggled_gui), (gpointer)this);
849
850 #ifdef WITH_DHT
851 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("useDHTCheckButton")), BOOLSETTING(USE_DHT));
852 gtk_entry_set_text(GTK_ENTRY(getWidget("dhtEntry")), Util::toString(SETTING(DHT_PORT)).c_str());
853
854 onDHTCheckToggled_gui(NULL, (gpointer)this);
855 g_signal_connect(getWidget("useDHTCheckButton"), "toggled", G_CALLBACK(onDHTCheckToggled_gui), (gpointer)this);
856 #else
857 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("useDHTCheckButton")), false);
858 gtk_entry_set_text(GTK_ENTRY(getWidget("dhtEntry")), "6250");
859 gtk_widget_set_sensitive(getWidget("dhtFrame"), FALSE);
860 #endif
861 }
862 }
863
initDownloads_gui()864 void Settings::initDownloads_gui()
865 {
866 GtkTreeIter iter;
867
868 { // Downloads
869 g_signal_connect(getWidget("finishedDownloadsButton"), "clicked", G_CALLBACK(onBrowseFinished_gui), (gpointer)this);
870 g_signal_connect(getWidget("unfinishedDownloadsButton"), "clicked", G_CALLBACK(onBrowseUnfinished_gui), (gpointer)this);
871 g_signal_connect(getWidget("noUseTempDirButton"), "toggled", G_CALLBACK(onNoUseTempDir_gui), (gpointer)this);
872 g_signal_connect(getWidget("publicHubsButton"), "clicked", G_CALLBACK(onPublicHubs_gui), (gpointer)this);
873 g_signal_connect(getWidget("publicHubsDialogAddButton"), "clicked", G_CALLBACK(onPublicAdd_gui), (gpointer)this);
874 g_signal_connect(getWidget("publicHubsDialogUpButton"), "clicked", G_CALLBACK(onPublicMoveUp_gui), (gpointer)this);
875 g_signal_connect(getWidget("publicHubsDialogDownButton"), "clicked", G_CALLBACK(onPublicMoveDown_gui), (gpointer)this);
876 g_signal_connect(getWidget("publicHubsDialogRemoveButton"), "clicked", G_CALLBACK(onPublicRemove_gui), (gpointer)this);
877
878 gtk_entry_set_text(GTK_ENTRY(getWidget("finishedDownloadsEntry")), SETTING(DOWNLOAD_DIRECTORY).c_str());
879 gtk_entry_set_text(GTK_ENTRY(getWidget("unfinishedDownloadsEntry")), SETTING(TEMP_DOWNLOAD_DIRECTORY).c_str());
880 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("maxDownloadsSpinButton")), (double)SETTING(DOWNLOAD_SLOTS));
881 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("newDownloadsSpinButton")), (double)SETTING(MAX_DOWNLOAD_SPEED));
882 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("noUseTempDirButton")), SETTING(NO_USE_TEMP_DIR));
883
884 gtk_entry_set_text(GTK_ENTRY(getWidget("proxyEntry")), SETTING(HTTP_PROXY).c_str());
885
886 publicListView.setView(GTK_TREE_VIEW(getWidget("publicHubsDialogTreeView")));
887 publicListView.insertColumn(_("List"), G_TYPE_STRING, TreeView::EDIT_STRING, -1);
888 publicListView.finalize();
889 publicListStore = gtk_list_store_newv(publicListView.getColCount(), publicListView.getGTypes());
890 gtk_tree_view_set_model(publicListView.get(), GTK_TREE_MODEL(publicListStore));
891 g_object_unref(publicListStore);
892 gtk_tree_view_set_headers_visible(publicListView.get(), FALSE);
893 GtkTreeViewColumn *col = gtk_tree_view_get_column(publicListView.get(), 0);
894 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
895 GObject *editRenderer = G_OBJECT(g_list_nth_data(list, 0));
896 g_list_free(list);
897 g_signal_connect(editRenderer, "edited", G_CALLBACK(onPublicEdit_gui), (gpointer)this);
898 }
899
900 { // Download to
901 g_signal_connect(getWidget("favoriteAddButton"), "clicked", G_CALLBACK(onAddFavorite_gui), (gpointer)this);
902 g_signal_connect(getWidget("favoriteRemoveButton"), "clicked", G_CALLBACK(onRemoveFavorite_gui), (gpointer)this);
903 downloadToView.setView(GTK_TREE_VIEW(getWidget("favoriteTreeView")));
904 downloadToView.insertColumn(_("Favorite Name"), G_TYPE_STRING, TreeView::STRING, -1);
905 downloadToView.insertColumn(_("Directory"), G_TYPE_STRING, TreeView::STRING, -1);
906 downloadToView.finalize();
907 downloadToStore = gtk_list_store_newv(downloadToView.getColCount(), downloadToView.getGTypes());
908 gtk_tree_view_set_model(downloadToView.get(), GTK_TREE_MODEL(downloadToStore));
909 g_object_unref(downloadToStore);
910 g_signal_connect(downloadToView.get(), "button-release-event", G_CALLBACK(onFavoriteButtonReleased_gui), (gpointer)this);
911 gtk_widget_set_sensitive(getWidget("favoriteRemoveButton"), FALSE);
912
913 StringPairList directories = FavoriteManager::getInstance()->getFavoriteDirs();
914 for (StringPairIter j = directories.begin(); j != directories.end(); ++j)
915 {
916 gtk_list_store_append(downloadToStore, &iter);
917 gtk_list_store_set(downloadToStore, &iter,
918 downloadToView.col(_("Favorite Name")), j->second.c_str(),
919 downloadToView.col(_("Directory")), j->first.c_str(),
920 -1);
921 }
922 }
923
924 { // Preview
925 previewAppView.setView(GTK_TREE_VIEW(getWidget("previewTreeView")));
926 previewAppView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::STRING, -1);
927 previewAppView.insertColumn(_("Application"), G_TYPE_STRING, TreeView::STRING, -1);
928 previewAppView.insertColumn(_("Extensions"), G_TYPE_STRING, TreeView::STRING, -1);
929 previewAppView.finalize();
930
931 g_signal_connect(getWidget("previewAddButton"), "clicked", G_CALLBACK(onPreviewAdd_gui), (gpointer)this);
932 g_signal_connect(getWidget("previewRemoveButton"), "clicked", G_CALLBACK(onPreviewRemove_gui), (gpointer)this);
933 g_signal_connect(getWidget("previewApplyButton"), "clicked", G_CALLBACK(onPreviewApply_gui), (gpointer)this);
934 g_signal_connect(getWidget("previewTreeView"), "key-release-event", G_CALLBACK(onPreviewKeyReleased_gui), (gpointer)this);
935 g_signal_connect(previewAppView.get(), "button-release-event", G_CALLBACK(onPreviewButtonReleased_gui), (gpointer)this);
936
937 previewAppToStore = gtk_list_store_newv(previewAppView.getColCount(), previewAppView.getGTypes());
938 gtk_tree_view_set_model(previewAppView.get(), GTK_TREE_MODEL(previewAppToStore));
939 g_object_unref(previewAppToStore);
940
941 gtk_widget_set_sensitive(getWidget("previewAddButton"), TRUE);
942 gtk_widget_set_sensitive(getWidget("previewRemoveButton"), TRUE);
943 gtk_widget_set_sensitive(getWidget("previewApplyButton"), TRUE);
944
945 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
946 const PreviewApp::List &Apps = wsm->getPreviewApps();
947
948 // add default applications players
949 if (Apps.empty())
950 {
951 wsm->addPreviewApp(_("Xine player"), "xine --no-logo --session volume=50", "avi; mov; vob; mpg; mp3");
952 wsm->addPreviewApp(_("Kaffeine player"), "kaffeine -p", "avi; mov; mpg; vob; mp3");
953 wsm->addPreviewApp(_("Mplayer player"), "mplayer", "avi; mov; vob; mp3");
954 wsm->addPreviewApp(_("Amarok player"), "amarok", "mp3");
955 }
956
957 for (PreviewApp::Iter item = Apps.begin(); item != Apps.end(); ++item)
958 {
959 gtk_list_store_append(previewAppToStore, &iter);
960 gtk_list_store_set(previewAppToStore, &iter,
961 previewAppView.col(_("Name")), ((*item)->name).c_str(),
962 previewAppView.col(_("Application")), ((*item)->app).c_str(),
963 previewAppView.col(_("Extensions")), ((*item)->ext).c_str(),
964 -1);
965 }
966 }
967
968 { // Queue
969 // Auto-priority
970 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("priorityHighestSpinButton")), (double)SETTING(PRIO_HIGHEST_SIZE));
971 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("priorityHighSpinButton")), (double)SETTING(PRIO_HIGH_SIZE));
972 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("priorityNormalSpinButton")), (double)SETTING(PRIO_NORMAL_SIZE));
973 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("priorityLowSpinButton")), (double)SETTING(PRIO_LOW_SIZE));
974
975 // Auto-drop
976 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropSpeedSpinButton")), (double)SETTING(AUTODROP_SPEED));
977 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropElapsedSpinButton")), (double)SETTING(AUTODROP_ELAPSED));
978 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropMinSourcesSpinButton")), (double)SETTING(AUTODROP_MINSOURCES));
979 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropCheckSpinButton")), (double)SETTING(AUTODROP_INTERVAL));
980 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropInactiveSpinButton")), (double)SETTING(AUTODROP_INACTIVITY));
981 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("dropSizeSpinButton")), (double)SETTING(AUTODROP_FILESIZE));
982
983 // Other queue options
984 createOptionsView_gui(queueView, queueStore, "queueOtherTreeView");
985
986 addOption_gui(queueStore, _("Set lowest priority for newly added files larger than low priority size"), SettingsManager::PRIO_LOWEST);
987 addOption_gui(queueStore, _("Auto-drop slow sources for all queue items (except filelists)"), SettingsManager::AUTODROP_ALL);
988 addOption_gui(queueStore, _("Remove slow filelists"), SettingsManager::AUTODROP_FILELISTS);
989 addOption_gui(queueStore, _("Don't remove the source when auto-dropping, only disconnect"), SettingsManager::AUTODROP_DISCONNECT);
990 addOption_gui(queueStore, _("Automatically search for alternative download locations"), SettingsManager::AUTO_SEARCH);
991 addOption_gui(queueStore, _("Automatically match queue for auto search hits"), SettingsManager::AUTO_SEARCH_AUTO_MATCH);
992 addOption_gui(queueStore, _("Skip zero-byte files"), SettingsManager::SKIP_ZERO_BYTE);
993 addOption_gui(queueStore, _("Don't download files already in share"), SettingsManager::DONT_DL_ALREADY_SHARED);
994 addOption_gui(queueStore, _("Don't download files already in the queue"), SettingsManager::DONT_DL_ALREADY_QUEUED);
995 }
996 }
997
initSharing_gui()998 void Settings::initSharing_gui()
999 {
1000 g_signal_connect(getWidget("shareHiddenCheckButton"), "toggled", G_CALLBACK(onShareHiddenPressed_gui), (gpointer)this);
1001 g_signal_connect(getWidget("sharedAddButton"), "clicked", G_CALLBACK(onAddShare_gui), (gpointer)this);
1002 g_signal_connect(getWidget("sharedRemoveButton"), "clicked", G_CALLBACK(onRemoveShare_gui), (gpointer)this);
1003 g_signal_connect(getWidget("pictureButton"), "clicked", G_CALLBACK(onPictureShare_gui), (gpointer)this);
1004
1005 g_signal_connect(getWidget("addEXButton"), "clicked", G_CALLBACK(onExceptionAdd_gui), (gpointer)this);
1006 g_signal_connect(getWidget("removeEXButton"), "clicked", G_CALLBACK(onExceptionRemove_gui), (gpointer)this);
1007 g_signal_connect(getWidget("defaultEXButton"), "clicked", G_CALLBACK(onExceptionDefault_gui), (gpointer)this);
1008
1009 exceptionView.setView(GTK_TREE_VIEW(getWidget("exceptionTreeView")));
1010 exceptionView.insertColumn(_("List"), G_TYPE_STRING, TreeView::EDIT_STRING, -1);
1011 exceptionView.finalize();
1012 exceptionStore = gtk_list_store_newv(exceptionView.getColCount(), exceptionView.getGTypes());
1013 gtk_tree_view_set_model(exceptionView.get(), GTK_TREE_MODEL(exceptionStore));
1014 g_object_unref(exceptionStore);
1015 gtk_tree_view_set_headers_visible(exceptionView.get(), FALSE);
1016 GtkTreeViewColumn *col = gtk_tree_view_get_column(exceptionView.get(), 0);
1017 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(col));
1018 GObject *editRenderer = G_OBJECT(g_list_nth_data(list, 0));
1019 g_list_free(list);
1020 g_signal_connect(editRenderer, "edited", G_CALLBACK(onExceptionEdit_gui), (gpointer)this);
1021
1022 GtkTreeIter iter;
1023 gtk_list_store_clear(exceptionStore);
1024 StringTokenizer<string> lists(SETTING(SKIPLIST_SHARE), "|");
1025 for (auto idx = lists.getTokens().begin(); idx != lists.getTokens().end(); ++idx)
1026 {
1027 gtk_list_store_append(exceptionStore, &iter);
1028 gtk_list_store_set(exceptionStore, &iter, exceptionView.col(_("List")), (*idx).c_str(), -1);
1029 }
1030
1031 shareView.setView(GTK_TREE_VIEW(getWidget("sharedTreeView")));
1032 shareView.insertColumn(_("Virtual Name"), G_TYPE_STRING, TreeView::STRING, -1);
1033 shareView.insertColumn(_("Directory"), G_TYPE_STRING, TreeView::STRING, -1);
1034 shareView.insertColumn(_("Size"), G_TYPE_STRING, TreeView::STRING, -1);
1035 shareView.insertHiddenColumn("Real Size", G_TYPE_INT64);
1036 shareView.finalize();
1037 shareStore = gtk_list_store_newv(shareView.getColCount(), shareView.getGTypes());
1038 gtk_tree_view_set_model(shareView.get(), GTK_TREE_MODEL(shareStore));
1039 g_object_unref(shareStore);
1040 shareView.setSortColumn_gui(_("Size"), "Real Size");
1041 g_signal_connect(shareView.get(), "button-release-event", G_CALLBACK(onShareButtonReleased_gui), (gpointer)this);
1042 gtk_widget_set_sensitive(getWidget("sharedRemoveButton"), FALSE);
1043
1044 updateShares_gui();
1045
1046 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("shareHiddenCheckButton")), BOOLSETTING(SHARE_HIDDEN));
1047 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("followLinksCheckButton")), BOOLSETTING(FOLLOW_LINKS));
1048 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("skipZeroSizedFilesCheckButton")), BOOLSETTING(SHARE_SKIP_ZERO_BYTE));
1049 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("sharedExtraSlotSpinButton")), (double)SETTING(MIN_UPLOAD_SPEED));
1050 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("sharedUploadSlotsSpinButton")), (double)SETTING(SLOTS_PRIMARY));
1051 }
1052
initAppearance_gui()1053 void Settings::initAppearance_gui()
1054 {
1055 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
1056
1057 { // Appearance
1058 vectorLangFullNames.push_back(_("System default"));
1059 vectorLangShortNames.push_back("");
1060 vectorLangFullNames.push_back(_("English"));
1061 vectorLangShortNames.push_back("en");
1062 vectorLangFullNames.push_back(_("Russian"));
1063 vectorLangShortNames.push_back("ru");
1064 vectorLangFullNames.push_back(_("Belarusian"));
1065 vectorLangShortNames.push_back("be");
1066 vectorLangFullNames.push_back(_("Hungarian"));
1067 vectorLangShortNames.push_back("hu");
1068 vectorLangFullNames.push_back(_("French"));
1069 vectorLangShortNames.push_back("fr");
1070 vectorLangFullNames.push_back(_("Polish"));
1071 vectorLangShortNames.push_back("pl");
1072 vectorLangFullNames.push_back(_("Portuguese (Brazil)"));
1073 vectorLangShortNames.push_back("pt_BR");
1074 vectorLangFullNames.push_back(_("Serbian (Cyrillic)"));
1075 vectorLangShortNames.push_back("sr");
1076 vectorLangFullNames.push_back(_("Serbian (Latin)"));
1077 vectorLangShortNames.push_back("sr@latin");
1078 vectorLangFullNames.push_back(_("Ukrainian"));
1079 vectorLangShortNames.push_back("uk");
1080 vectorLangFullNames.push_back(_("Spanish"));
1081 vectorLangShortNames.push_back("es");
1082 vectorLangFullNames.push_back(_("Basque"));
1083 vectorLangShortNames.push_back("eu");
1084 vectorLangFullNames.push_back(_("Bulgarian"));
1085 vectorLangShortNames.push_back("bg");
1086 vectorLangFullNames.push_back(_("Slovak"));
1087 vectorLangShortNames.push_back("sk");
1088 vectorLangFullNames.push_back(_("Czech"));
1089 vectorLangShortNames.push_back("cs");
1090 vectorLangFullNames.push_back(_("German"));
1091 vectorLangShortNames.push_back("de");
1092 vectorLangFullNames.push_back(_("Greek"));
1093 vectorLangShortNames.push_back("el");
1094 vectorLangFullNames.push_back(_("Italian"));
1095 vectorLangShortNames.push_back("it");
1096 vectorLangFullNames.push_back(_("Vietnamese"));
1097 vectorLangShortNames.push_back("vi");
1098 vectorLangFullNames.push_back(_("Chinese (China)"));
1099 vectorLangShortNames.push_back("zh_CN");
1100 vectorLangFullNames.push_back(_("Swedish (Sweden)"));
1101 vectorLangShortNames.push_back("sv_SE");
1102
1103 // Fill language drop-down list
1104 uint8_t lang_ind = 0;
1105 for (uint8_t i=0; i<vectorLangFullNames.size(); ++i)
1106 {
1107 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(getWidget("languageComboBox")),
1108 vectorLangFullNames.at(i).c_str());
1109 if(!strcmp(vectorLangShortNames.at(i).c_str(), WGETS("translation-lang").c_str()))
1110 lang_ind = i;
1111 }
1112 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("languageComboBox")), lang_ind);
1113
1114 createOptionsView_gui(appearanceView, appearanceStore, "appearanceOptionsTreeView");
1115
1116 addOption_gui(appearanceStore, _("Filter kick and NMDC debug messages"), SettingsManager::FILTER_MESSAGES);
1117 addOption_gui(appearanceStore, _("Show status icon in the system tray"), "always-tray");
1118 addOption_gui(appearanceStore, _("Show timestamps in chat by default"), SettingsManager::TIME_STAMPS);
1119 addOption_gui(appearanceStore, _("View status messages in main chat"), "status-in-chat");
1120 addOption_gui(appearanceStore, _("Show joins / parts in chat by default"), "show-joins");
1121 addOption_gui(appearanceStore, _("Only show joins / parts for favorite users"), "fav-show-joins");
1122 addOption_gui(appearanceStore, _("Sort favorite users first"), "sort-favusers-first");
1123 addOption_gui(appearanceStore, _("Use OEM monospaced font for chat windows"), "use-oem-monofont");
1124 addOption_gui(appearanceStore, _("Use magnet split"), "use-magnet-split");
1125 addOption_gui(appearanceStore, _("Use blinking status icon"), "status-icon-blink-use");
1126 addOption_gui(appearanceStore, _("Use emoticons"), "emoticons-use");
1127 addOption_gui(appearanceStore, _("Do not close the program, hide in the system tray"), "main-window-no-close");
1128 addOption_gui(appearanceStore, _("Send PM when double clicked in the user list"), "pm");
1129
1130 /// @todo: Uncomment when implemented
1131 addOption_gui(appearanceStore, _("Minimize to tray on startup"), "minimize-tray");
1132 //addOption_gui(appearanceStore, _("Use system icons"), "use-system-icons");
1133
1134 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("tabPositionComboBox")), WGETI("tab-position"));
1135 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("toolbarStyleComboBox")), WGETI("toolbar-style"));
1136
1137 gtk_entry_set_text(GTK_ENTRY(getWidget("awayMessageEntry")), SETTING(DEFAULT_AWAY_MESSAGE).c_str());
1138 gtk_entry_set_text(GTK_ENTRY(getWidget("timestampEntry")), SETTING(TIME_STAMPS_FORMAT).c_str());
1139 }
1140
1141 { // Tabs
1142 createOptionsView_gui(tabView, tabStore, "tabBoldingTreeView");
1143
1144 addOption_gui(tabStore, _("Finished Downloads"), "bold-finished-downloads");
1145 addOption_gui(tabStore, _("Finished Uploads"), "bold-finished-uploads");
1146 addOption_gui(tabStore, _("Download Queue"), "bold-queue");
1147 addOption_gui(tabStore, _("Hub (also sets urgency hint)"), "bold-hub");
1148 addOption_gui(tabStore, _("Private Message (also sets urgency hint)"), "bold-pm");
1149 addOption_gui(tabStore, _("Search"), "bold-search");
1150 addOption_gui(tabStore, _("Search Spy"), "bold-search-spy");
1151 }
1152
1153 { // Sounds
1154 g_signal_connect(getWidget("soundPlayButton"), "clicked", G_CALLBACK(onSoundPlayButton_gui), (gpointer)this);
1155 g_signal_connect(getWidget("soundFileBrowseButton"), "clicked", G_CALLBACK(onSoundFileBrowseClicked_gui), (gpointer)this);
1156
1157 soundView.setView(GTK_TREE_VIEW(getWidget("soundsTreeView")));
1158 soundView.insertColumn(_("Use"), G_TYPE_BOOLEAN, TreeView::BOOL, -1);
1159 soundView.insertColumn(_("Sounds"), G_TYPE_STRING, TreeView::STRING, -1);
1160 soundView.insertColumn(_("File"), G_TYPE_STRING, TreeView::STRING, -1);
1161 soundView.insertHiddenColumn("keyUse", G_TYPE_STRING);
1162 soundView.insertHiddenColumn("keyFile", G_TYPE_STRING);
1163 soundView.finalize();
1164
1165 soundStore = gtk_list_store_newv(soundView.getColCount(), soundView.getGTypes());
1166 gtk_tree_view_set_model(soundView.get(), GTK_TREE_MODEL(soundStore));
1167 g_object_unref(soundStore);
1168
1169 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(gtk_tree_view_get_column(soundView.get(), soundView.col(_("Use")))));
1170 GObject *renderer = (GObject *)g_list_nth_data(list, 0);
1171 g_signal_connect(renderer, "toggled", G_CALLBACK(onOptionsViewToggled_gui), (gpointer)soundStore);
1172 g_list_free(list);
1173
1174 // TODO: download begins, uncomment when implemented
1175 // addOption_gui(soundStore, wsm, _("Download begins"), "sound-download-begins-use", "sound-download-begins");
1176 addOption_gui(soundStore, wsm, _("Download finished"), "sound-download-finished-use", "sound-download-finished");
1177 addOption_gui(soundStore, wsm, _("Download finished file list"), "sound-download-finished-ul-use", "sound-download-finished-ul");
1178 addOption_gui(soundStore, wsm, _("Upload finished"), "sound-upload-finished-use", "sound-upload-finished");
1179 addOption_gui(soundStore, wsm, _("Private message"), "sound-private-message-use", "sound-private-message");
1180 addOption_gui(soundStore, wsm, _("Hub connected"), "sound-hub-connect-use", "sound-hub-connect");
1181 addOption_gui(soundStore, wsm, _("Hub disconnected"), "sound-hub-disconnect-use", "sound-hub-disconnect");
1182 addOption_gui(soundStore, wsm, _("Favorite user joined"), "sound-fuser-join-use", "sound-fuser-join");
1183 addOption_gui(soundStore, wsm, _("Favorite user quit"), "sound-fuser-quit-use", "sound-fuser-quit");
1184
1185 gtk_widget_set_sensitive(getWidget("soundPlayButton"), TRUE);
1186 gtk_widget_set_sensitive(getWidget("soundFileBrowseButton"), TRUE);
1187
1188 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("soundPMReceivedCheckButton")), WGETB("sound-pm"));
1189 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("soundPMWindowCheckButton")), WGETB("sound-pm-open"));
1190
1191 gtk_entry_set_text(GTK_ENTRY(getWidget("soundCommandEntry")), wsm->getString("sound-command").c_str());
1192
1193 #if defined(USE_LIBGNOME2) || defined(USE_LIBCANBERRA)
1194 gtk_widget_hide((GtkWidget*)GTK_LABEL(getWidget("soundCommandLabel")));
1195 gtk_widget_hide((GtkWidget*)GTK_ENTRY(getWidget("soundCommandEntry")));
1196 #endif
1197 }
1198
1199 { // Colors & Fonts
1200 g_signal_connect(getWidget("textColorForeButton"), "clicked", G_CALLBACK(onTextColorForeClicked_gui), (gpointer)this);
1201 g_signal_connect(getWidget("textColorBackButton"), "clicked", G_CALLBACK(onTextColorBackClicked_gui), (gpointer)this);
1202 g_signal_connect(getWidget("textColorBWButton"), "clicked", G_CALLBACK(onTextColorBWClicked_gui), (gpointer)this);
1203 g_signal_connect(getWidget("textStyleButton"), "clicked", G_CALLBACK(onTextStyleClicked_gui), (gpointer)this);
1204 g_signal_connect(getWidget("textStylesDefaultButton"), "clicked", G_CALLBACK(onTextStyleDefaultClicked_gui), (gpointer)this);
1205
1206 textStyleView.setView(GTK_TREE_VIEW(getWidget("treeViewAvailableStyles")));
1207 textStyleView.insertColumn("Style", G_TYPE_STRING, TreeView::STRING, -1);
1208 textStyleView.insertHiddenColumn("ForeColor", G_TYPE_STRING);
1209 textStyleView.insertHiddenColumn("BackColor", G_TYPE_STRING);
1210 textStyleView.insertHiddenColumn("Bolt", G_TYPE_INT);
1211 textStyleView.insertHiddenColumn("Italic", G_TYPE_INT);
1212 textStyleView.insertHiddenColumn("keyForeColor", G_TYPE_STRING);
1213 textStyleView.insertHiddenColumn("keyBackColor", G_TYPE_STRING);
1214 textStyleView.insertHiddenColumn("keyBolt", G_TYPE_STRING);
1215 textStyleView.insertHiddenColumn("keyItalic", G_TYPE_STRING);
1216 textStyleView.finalize();
1217
1218 textStyleStore = gtk_list_store_newv(textStyleView.getColCount(), textStyleView.getGTypes());
1219 gtk_tree_view_set_model(textStyleView.get(), GTK_TREE_MODEL(textStyleStore));
1220 g_object_unref(textStyleStore);
1221
1222 // Available styles
1223 addOption_gui(textStyleStore, wsm, _("General text"),
1224 "text-general-fore-color", "text-general-back-color", "text-general-bold", "text-general-italic");
1225
1226 addOption_gui(textStyleStore, wsm, _("My nick"),
1227 "text-mynick-fore-color", "text-mynick-back-color", "text-mynick-bold", "text-mynick-italic");
1228
1229 addOption_gui(textStyleStore, wsm, _("My own message"),
1230 "text-myown-fore-color", "text-myown-back-color", "text-myown-bold", "text-myown-italic");
1231
1232 addOption_gui(textStyleStore, wsm, _("Private message"),
1233 "text-private-fore-color", "text-private-back-color", "text-private-bold", "text-private-italic");
1234
1235 addOption_gui(textStyleStore, wsm, _("System message"),
1236 "text-system-fore-color", "text-system-back-color", "text-system-bold", "text-system-italic");
1237
1238 addOption_gui(textStyleStore, wsm, _("Status message"),
1239 "text-status-fore-color", "text-status-back-color", "text-status-bold", "text-status-italic");
1240
1241 addOption_gui(textStyleStore, wsm, _("Timestamp"),
1242 "text-timestamp-fore-color", "text-timestamp-back-color", "text-timestamp-bold", "text-timestamp-italic");
1243
1244 addOption_gui(textStyleStore, wsm, _("URL"),
1245 "text-url-fore-color", "text-url-back-color", "text-url-bold", "text-url-italic");
1246
1247 addOption_gui(textStyleStore, wsm, _("Favorite User"),
1248 "text-fav-fore-color", "text-fav-back-color", "text-fav-bold", "text-fav-italic");
1249
1250 addOption_gui(textStyleStore, wsm, _("Operator"),
1251 "text-op-fore-color", "text-op-back-color", "text-op-bold", "text-op-italic");
1252
1253 // Preview style
1254 GtkTreeIter treeIter;
1255 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
1256 gboolean valid = gtk_tree_model_get_iter_first(m, &treeIter);
1257
1258 GtkTextIter textIter, textStartIter, textEndIter;
1259 string line, style;
1260
1261 string timestamp = "[" + Util::getShortTimeString() + "] ";
1262 const gint ts_strlen = g_utf8_strlen(timestamp.c_str(), -1);
1263 string fore = wsm->getString("text-timestamp-fore-color");
1264 string back = wsm->getString("text-timestamp-back-color");
1265 int bold = wsm->getInt("text-timestamp-bold");
1266 int italic = wsm->getInt("text-timestamp-italic");
1267
1268 GtkTextTag *tag = NULL;
1269 GtkTextTag *tagTimeStamp =
1270 WGETB("use-native-back-color-for-text") ?
1271 gtk_text_buffer_create_tag(textStyleBuffer, _("Timestamp"),
1272 "foreground", fore.c_str(),
1273 "weight", bold ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
1274 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
1275 NULL) :
1276 gtk_text_buffer_create_tag(textStyleBuffer, _("Timestamp"),
1277 "background", back.c_str(),
1278 "foreground", fore.c_str(),
1279 "weight", bold ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
1280 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
1281 NULL);
1282
1283 gint row_count = 0;
1284
1285 while (valid)
1286 {
1287 style = textStyleView.getString(&treeIter, "Style");
1288 fore = wsm->getString(textStyleView.getString(&treeIter, "keyForeColor"));
1289 back = wsm->getString(textStyleView.getString(&treeIter, "keyBackColor"));
1290 bold = wsm->getInt(textStyleView.getString(&treeIter, "keyBolt"));
1291 italic = wsm->getInt(textStyleView.getString(&treeIter, "keyItalic"));
1292 const gint st_strlen = g_utf8_strlen(style.c_str(), -1);
1293
1294 line = timestamp + style + "\n";
1295
1296 gtk_text_buffer_get_end_iter(textStyleBuffer, &textIter);
1297 gtk_text_buffer_insert(textStyleBuffer, &textIter, line.c_str(), line.size());
1298
1299 textStartIter = textEndIter = textIter;
1300
1301 // apply text style
1302 gtk_text_iter_backward_chars(&textStartIter, st_strlen + 1);
1303
1304 if (row_count != 6)
1305 tag =
1306 WGETB("use-native-back-color-for-text") ?
1307 gtk_text_buffer_create_tag(textStyleBuffer, style.c_str(),
1308 "foreground", fore.c_str(),
1309 "weight", bold ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
1310 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
1311 NULL) :
1312 gtk_text_buffer_create_tag(textStyleBuffer, style.c_str(),
1313 "background", back.c_str(),
1314 "foreground", fore.c_str(),
1315 "weight", bold ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
1316 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
1317 NULL);
1318 else
1319 tag = tagTimeStamp;
1320
1321 gtk_text_buffer_apply_tag(textStyleBuffer, tag, &textStartIter, &textEndIter);
1322
1323 // apply timestamp style
1324 gtk_text_iter_backward_chars(&textStartIter, ts_strlen);
1325 gtk_text_iter_backward_chars(&textEndIter, st_strlen + 2);
1326 gtk_text_buffer_apply_tag(textStyleBuffer, tagTimeStamp, &textStartIter, &textEndIter);
1327
1328 row_count++;
1329
1330 valid = gtk_tree_model_iter_next(m, &treeIter);
1331 }
1332
1333 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("checkBoldAuthors")), WGETB("text-bold-autors"));
1334 }
1335
1336 { // Notify
1337 notifyView.setView(GTK_TREE_VIEW(getWidget("notifyTreeView")));
1338 notifyView.insertColumn(_("Use"), G_TYPE_BOOLEAN, TreeView::BOOL, -1);
1339 notifyView.insertColumn(_("Notify"), G_TYPE_STRING, TreeView::PIXBUF_STRING, -1, "icon");
1340 notifyView.insertColumn(_("Title"), G_TYPE_STRING, TreeView::STRING, -1);
1341 notifyView.insertColumn(_("Icon"), G_TYPE_STRING, TreeView::STRING, -1);
1342 notifyView.insertHiddenColumn("keyUse", G_TYPE_STRING);
1343 notifyView.insertHiddenColumn("keyTitle", G_TYPE_STRING);
1344 notifyView.insertHiddenColumn("keyIcon", G_TYPE_STRING);
1345 notifyView.insertHiddenColumn("icon", GDK_TYPE_PIXBUF);
1346 notifyView.insertHiddenColumn("Urgency", G_TYPE_INT);
1347 notifyView.finalize();
1348
1349 notifyStore = gtk_list_store_newv(notifyView.getColCount(), notifyView.getGTypes());
1350 gtk_tree_view_set_model(notifyView.get(), GTK_TREE_MODEL(notifyStore));
1351 g_object_unref(notifyStore);
1352
1353 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(gtk_tree_view_get_column(notifyView.get(), notifyView.col(_("Use")))));
1354 GObject *renderer = (GObject *)g_list_nth_data(list, 0);
1355 g_signal_connect(renderer, "toggled", G_CALLBACK(onOptionsViewToggled_gui), (gpointer)notifyStore);
1356 g_list_free(list);
1357
1358 addOption_gui(notifyStore, wsm, _("Download finished"),
1359 "notify-download-finished-use", "notify-download-finished-title",
1360 "notify-download-finished-icon", NOTIFY_URGENCY_NORMAL);
1361
1362 addOption_gui(notifyStore, wsm, _("Download finished file list"),
1363 "notify-download-finished-ul-use", "notify-download-finished-ul-title",
1364 "notify-download-finished-ul-icon", NOTIFY_URGENCY_LOW);
1365
1366 addOption_gui(notifyStore, wsm, _("Private message"),
1367 "notify-private-message-use", "notify-private-message-title",
1368 "notify-private-message-icon", NOTIFY_URGENCY_NORMAL);
1369
1370 addOption_gui(notifyStore, wsm, _("Hub connected"),
1371 "notify-hub-connect-use", "notify-hub-connect-title",
1372 "notify-hub-connect-icon", NOTIFY_URGENCY_NORMAL);
1373
1374 addOption_gui(notifyStore, wsm, _("Hub disconnected"),
1375 "notify-hub-disconnect-use", "notify-hub-disconnect-title",
1376 "notify-hub-disconnect-icon", NOTIFY_URGENCY_CRITICAL);
1377
1378 addOption_gui(notifyStore, wsm, _("Favorite user joined"),
1379 "notify-fuser-join", "notify-fuser-join-title",
1380 "notify-fuser-join-icon", NOTIFY_URGENCY_NORMAL);
1381
1382 addOption_gui(notifyStore, wsm, _("Favorite user quit"),
1383 "notify-fuser-quit", "notify-fuser-quit-title",
1384 "notify-fuser-quit-icon", NOTIFY_URGENCY_NORMAL);
1385
1386 g_signal_connect(getWidget("notifyTestButton"), "clicked", G_CALLBACK(onNotifyTestButton_gui), (gpointer)this);
1387 g_signal_connect(getWidget("notifyIconFileBrowseButton"), "clicked", G_CALLBACK(onNotifyIconFileBrowseClicked_gui), (gpointer)this);
1388 g_signal_connect(getWidget("notifyOKButton"), "clicked", G_CALLBACK(onNotifyOKClicked_gui), (gpointer)this);
1389 g_signal_connect(getWidget("notifyIconNoneButton"), "clicked", G_CALLBACK(onNotifyIconNoneButton_gui), (gpointer)this);
1390 g_signal_connect(getWidget("notifyDefaultButton"), "clicked", G_CALLBACK(onNotifyDefaultButton_gui), (gpointer)this);
1391 g_signal_connect(getWidget("notifyTreeView"), "key-release-event", G_CALLBACK(onNotifyKeyReleased_gui), (gpointer)this);
1392 g_signal_connect(notifyView.get(), "button-release-event", G_CALLBACK(onNotifyButtonReleased_gui), (gpointer)this);
1393
1394 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("notifyPMLengthSpinButton")), (gdouble)WGETI("notify-pm-length"));
1395 gtk_combo_box_set_active(GTK_COMBO_BOX(getWidget("notifyIconSizeComboBox")), WGETI("notify-icon-size"));
1396 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("notifyAppActiveCheckButton")), WGETI("notify-only-not-active"));
1397 }
1398
1399 { // Themes
1400 themeIconsView.setView(GTK_TREE_VIEW(getWidget("treeViewIconsTheme")));
1401 themeIconsView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::PIXBUF_STRING, -1, "icon");
1402 themeIconsView.insertHiddenColumn("icon", GDK_TYPE_PIXBUF);
1403 themeIconsView.insertHiddenColumn("iconName", G_TYPE_STRING);
1404 themeIconsView.insertHiddenColumn("keyIcon", G_TYPE_STRING);
1405 themeIconsView.finalize();
1406
1407 themeIconsStore = gtk_list_store_newv(themeIconsView.getColCount(), themeIconsView.getGTypes());
1408 gtk_tree_view_set_model(themeIconsView.get(), GTK_TREE_MODEL(themeIconsStore));
1409 g_object_unref(themeIconsStore);
1410
1411 GtkIconTheme *iconTheme = gtk_icon_theme_get_default();
1412
1413 addOption_gui(themeIconsStore, wsm, iconTheme, _("User (dc)"), "icon-dc++");
1414 addOption_gui(themeIconsStore, wsm, iconTheme, _("User firewall (dc)"), "icon-dc++-fw");
1415 addOption_gui(themeIconsStore, wsm, iconTheme, _("User operator firewall (dc)"), "icon-dc++-fw-op");
1416 addOption_gui(themeIconsStore, wsm, iconTheme, _("User operator (dc)"), "icon-dc++-op");
1417 addOption_gui(themeIconsStore, wsm, iconTheme, _("User (normal)"), "icon-normal");
1418 addOption_gui(themeIconsStore, wsm, iconTheme, _("User firewall (normal)"), "icon-normal-fw");
1419 addOption_gui(themeIconsStore, wsm, iconTheme, _("User operator firewall (normal)"), "icon-normal-fw-op");
1420 addOption_gui(themeIconsStore, wsm, iconTheme, _("User operator (normal)"), "icon-normal-op");
1421 addOption_gui(themeIconsStore, wsm, iconTheme, _("Button smile"), "icon-smile");
1422 addOption_gui(themeIconsStore, wsm, iconTheme, _("Download"), "icon-download");
1423 addOption_gui(themeIconsStore, wsm, iconTheme, _("Upload"), "icon-upload");
1424 addOption_gui(themeIconsStore, wsm, iconTheme, _("Favorite Hubs"), "icon-favorite-hubs");
1425 addOption_gui(themeIconsStore, wsm, iconTheme, _("Favorite Users"), "icon-favorite-users");
1426 addOption_gui(themeIconsStore, wsm, iconTheme, _("Finished Downloads"), "icon-finished-downloads");
1427 addOption_gui(themeIconsStore, wsm, iconTheme, _("Finished Uploads"), "icon-finished-uploads");
1428 addOption_gui(themeIconsStore, wsm, iconTheme, _("Own file list"), "icon-own-filelist");
1429 addOption_gui(themeIconsStore, wsm, iconTheme, _("Refresh"), "icon-refresh");
1430 addOption_gui(themeIconsStore, wsm, iconTheme, _("Hash"), "icon-hash");
1431 addOption_gui(themeIconsStore, wsm, iconTheme, _("Preferences"), "icon-preferences");
1432 addOption_gui(themeIconsStore, wsm, iconTheme, _("Public Hubs"), "icon-public-hubs");
1433 addOption_gui(themeIconsStore, wsm, iconTheme, _("Queue"), "icon-queue");
1434 addOption_gui(themeIconsStore, wsm, iconTheme, _("Search"), "icon-search");
1435 addOption_gui(themeIconsStore, wsm, iconTheme, _("Search Spy"), "icon-search-spy");
1436 addOption_gui(themeIconsStore, wsm, iconTheme, _("Quit"), "icon-quit");
1437 addOption_gui(themeIconsStore, wsm, iconTheme, _("Connect"), "icon-connect");
1438 addOption_gui(themeIconsStore, wsm, iconTheme, _("Reconnect"), "icon-reconnect");
1439 addOption_gui(themeIconsStore, wsm, iconTheme, _("File"), "icon-file");
1440 addOption_gui(themeIconsStore, wsm, iconTheme, _("Directory"), "icon-directory");
1441 addOption_gui(themeIconsStore, wsm, iconTheme, _("Search ADL"), "icon-search-adl");
1442
1443 g_signal_connect(getWidget("importThemeButton"), "clicked", G_CALLBACK(onImportThemeButton_gui), (gpointer)this);
1444 g_signal_connect(getWidget("exportThemeButton"), "clicked", G_CALLBACK(onExportThemeButton_gui), (gpointer)this);
1445 g_signal_connect(getWidget("defaultIconsThemeButton"), "clicked", G_CALLBACK(onDefaultIconsThemeButton_gui), (gpointer)this);
1446 g_signal_connect(getWidget("systemIconsThemeButton"), "clicked", G_CALLBACK(onSystemIconsThemeButton_gui), (gpointer)this);
1447 g_signal_connect(getWidget("defaultThemeButton"), "clicked", G_CALLBACK(onDefaultThemeButton_gui), (gpointer)this);
1448
1449 gtk_label_set_text(GTK_LABEL(getWidget("currentThemeLabel")), wsm->getString("theme-name").c_str());
1450 }
1451
1452 { // Toolbar
1453 toolbarView.setView(GTK_TREE_VIEW(getWidget("toolbarTreeView")));
1454 toolbarView.insertColumn(_("Use"), G_TYPE_BOOLEAN, TreeView::BOOL, -1);
1455 toolbarView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::PIXBUF_STRING, -1, "icon");
1456 toolbarView.insertHiddenColumn("icon", GDK_TYPE_PIXBUF);
1457 toolbarView.insertHiddenColumn("keyUse", G_TYPE_STRING);
1458 toolbarView.finalize();
1459
1460 toolbarStore = gtk_list_store_newv(toolbarView.getColCount(), toolbarView.getGTypes());
1461 gtk_tree_view_set_model(toolbarView.get(), GTK_TREE_MODEL(toolbarStore));
1462 g_object_unref(toolbarStore);
1463
1464 GList *list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(gtk_tree_view_get_column(toolbarView.get(), toolbarView.col(_("Use")))));
1465 GObject *renderer = (GObject *)g_list_nth_data(list, 0);
1466 g_signal_connect(renderer, "toggled", G_CALLBACK(onOptionsViewToggled_gui), (gpointer)toolbarStore);
1467 g_list_free(list);
1468
1469 GtkIconTheme *iconTheme = gtk_icon_theme_get_default();
1470 addOption_gui(toolbarStore, wsm, iconTheme, _("+/-"), "toolbar-button-add",
1471 ""); //GTK_STOCK_ADD
1472 addOption_gui(toolbarStore, wsm, iconTheme, _("Separators"), "toolbar-button-separators",
1473 "");
1474 addOption_gui(toolbarStore, wsm, iconTheme, _("Reconnect"), "toolbar-button-reconnect",
1475 "icon-reconnect");
1476 addOption_gui(toolbarStore, wsm, iconTheme, _("Connect"), "toolbar-button-connect",
1477 "icon-connect");
1478 addOption_gui(toolbarStore, wsm, iconTheme, _("Favorite Hubs"), "toolbar-button-fav-hubs",
1479 "icon-favorite-hubs");
1480 addOption_gui(toolbarStore, wsm, iconTheme, _("Favorite Users"), "toolbar-button-fav-users",
1481 "icon-favorite-users");
1482 addOption_gui(toolbarStore, wsm, iconTheme, _("Public Hubs"), "toolbar-button-public-hubs",
1483 "icon-public-hubs");
1484 addOption_gui(toolbarStore, wsm, iconTheme, _("Preferences"), "toolbar-button-settings",
1485 "icon-preferences");
1486 addOption_gui(toolbarStore, wsm, iconTheme, _("Own file list"), "toolbar-button-own-filelist",
1487 "icon-own-filelist");
1488 addOption_gui(toolbarStore, wsm, iconTheme, _("Refresh"), "toolbar-button-refresh",
1489 "icon-refresh");
1490 addOption_gui(toolbarStore, wsm, iconTheme, _("Hash"), "toolbar-button-hash",
1491 "icon-hash");
1492 addOption_gui(toolbarStore, wsm, iconTheme, _("Search"), "toolbar-button-search",
1493 "icon-search");
1494 addOption_gui(toolbarStore, wsm, iconTheme, _("searchADL"), "toolbar-button-search-adl",
1495 "icon-search-adl");
1496 addOption_gui(toolbarStore, wsm, iconTheme, _("Search Spy"), "toolbar-button-search-spy",
1497 "icon-search-spy");
1498 addOption_gui(toolbarStore, wsm, iconTheme, _("Queue"), "toolbar-button-queue",
1499 "icon-queue");
1500 addOption_gui(toolbarStore, wsm, iconTheme, _("Finished Downloads"), "toolbar-button-finished-downloads",
1501 "icon-finished-downloads");
1502 addOption_gui(toolbarStore, wsm, iconTheme, _("Finished Uploads"), "toolbar-button-finished-uploads",
1503 "icon-finished-uploads");
1504 addOption_gui(toolbarStore, wsm, iconTheme, _("Quit"), "toolbar-button-quit",
1505 "icon-quit");
1506 }
1507
1508 { // Search Spy
1509
1510 #if GTK_CHECK_VERSION(3,4,0)
1511 GdkRGBA color;
1512 #define g_c_b_s gtk_color_chooser_get_rgba
1513 #define G_C_B GTK_COLOR_CHOOSER
1514 #define g_c_p(a,b) gdk_rgba_parse(b,a)
1515 #else
1516 GdkColor color;
1517 #define g_c_b_s gtk_color_button_get_color
1518 #define G_C_B GTK_COLOR_BUTTON
1519 #define g_c_p(a,b) gdk_color_parse(a,b)
1520 #endif
1521
1522 if (g_c_p(wsm->getString("search-spy-a-color").c_str(), &color))
1523 g_c_b_s(G_C_B(getWidget("aSPColorButton")), &color);
1524
1525 if (g_c_p(wsm->getString("search-spy-t-color").c_str(), &color))
1526 g_c_b_s(G_C_B(getWidget("tSPColorButton")), &color);
1527
1528 if (g_c_p(wsm->getString("search-spy-q-color").c_str(), &color))
1529 g_c_b_s(G_C_B(getWidget("qSPColorButton")), &color);
1530
1531 if (g_c_p(wsm->getString("search-spy-c-color").c_str(), &color))
1532 g_c_b_s(G_C_B(getWidget("cSPColorButton")), &color);
1533
1534 if (g_c_p(wsm->getString("search-spy-r-color").c_str(), &color))
1535 g_c_b_s(G_C_B(getWidget("rSPColorButton")), &color);
1536
1537 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("frameSPSpinButton")), (double)WGETI("search-spy-frame"));
1538 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("waitingSPSpinButton")), (double)WGETI("search-spy-waiting"));
1539 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("topSPSpinButton")), (double)WGETI("search-spy-top"));
1540
1541 g_signal_connect(getWidget("defaultColorsSPButton"), "clicked", G_CALLBACK(onDefaultColorsSPButton_gui), (gpointer)this);
1542 g_signal_connect(getWidget("defaultFrameSPButton"), "clicked", G_CALLBACK(onDefaultFrameSPButton_gui), (gpointer)this);
1543
1544 #undef g_c_b_s
1545 #undef G_C_B
1546 #undef g_c_p
1547
1548 }
1549
1550 { // Window
1551 // Auto-open
1552 createOptionsView_gui(windowView1, windowStore1, "windowsAutoOpenTreeView");
1553
1554 addOption_gui(windowStore1, _("Public Hubs"), "open-public");
1555 addOption_gui(windowStore1, _("Favorite Hubs"), "open-favorite-hubs");
1556 addOption_gui(windowStore1, _("Download Queue"), "open-queue");
1557 addOption_gui(windowStore1, _("Finished Downloads"), "open-finished-downloads");
1558 addOption_gui(windowStore1, _("Finished Uploads"), "open-finished-uploads");
1559 addOption_gui(windowStore1, _("Favorite Users"), "open-favorite-users");
1560 addOption_gui(windowStore1, _("Search Spy"), "open-search-spy");
1561 /// @todo: Uncomment when implemented
1562
1563 // Window options
1564 createOptionsView_gui(windowView2, windowStore2, "windowsOptionsTreeView");
1565
1566 addOption_gui(windowStore2, _("Open file list window in the background"), "popunder-filelist");
1567 addOption_gui(windowStore2, _("Open new private messages from other users in the background"), "popunder-pm");
1568 addOption_gui(windowStore2, _("Open new window when using /join"), "join-open-new-window");
1569 addOption_gui(windowStore2, _("Ignore private messages from the hub"), SettingsManager::IGNORE_HUB_PMS);
1570 addOption_gui(windowStore2, _("Ignore private messages from bots"), SettingsManager::IGNORE_BOT_PMS);
1571 addOption_gui(windowStore2, _("Popup box to input password for hubs"), SettingsManager::PROMPT_PASSWORD);
1572 addOption_gui(windowStore2, _("Show nicklist in hub frame on the left side"), "hub-nickview-left");
1573
1574 // Confirmation dialog
1575 createOptionsView_gui(windowView3, windowStore3, "windowsConfirmTreeView");
1576
1577 addOption_gui(windowStore3, _("Confirm application exit"), "confirm-exit");
1578 addOption_gui(windowStore3, _("Confirm favorite hub removal"), "confirm-hub-removal");
1579 /// @todo: Uncomment when implemented
1580 //addOption_gui(windowStore3, _("Confirm item removal in download queue"), "confirm-item-removal");
1581 }
1582 }
1583
initLog_gui()1584 void Settings::initLog_gui()
1585 {
1586 g_signal_connect(getWidget("logBrowseButton"), "clicked", G_CALLBACK(onLogBrowseClicked_gui), (gpointer)this);
1587 gtk_entry_set_text(GTK_ENTRY(getWidget("logDirectoryEntry")), SETTING(LOG_DIRECTORY).c_str());
1588
1589 g_signal_connect(getWidget("logMainCheckButton"), "toggled", G_CALLBACK(onLogMainClicked_gui), (gpointer)this);
1590 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logMainCheckButton")), BOOLSETTING(LOG_MAIN_CHAT));
1591 gtk_entry_set_text(GTK_ENTRY(getWidget("logMainEntry")), SETTING(LOG_FORMAT_MAIN_CHAT).c_str());
1592 gtk_entry_set_text(GTK_ENTRY(getWidget("logMainEntryFile")), SETTING(LOG_FILE_MAIN_CHAT).c_str());
1593 gtk_widget_set_sensitive(getWidget("logMainLabel"), BOOLSETTING(LOG_MAIN_CHAT));
1594 gtk_widget_set_sensitive(getWidget("logMainEntry"), BOOLSETTING(LOG_MAIN_CHAT));
1595 gtk_widget_set_sensitive(getWidget("logMainLabelFile"), BOOLSETTING(LOG_MAIN_CHAT));
1596 gtk_widget_set_sensitive(getWidget("logMainEntryFile"), BOOLSETTING(LOG_MAIN_CHAT));
1597
1598 g_signal_connect(getWidget("logPrivateCheckButton"), "toggled", G_CALLBACK(onLogPrivateClicked_gui), (gpointer)this);
1599 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logPrivateCheckButton")), BOOLSETTING(LOG_PRIVATE_CHAT));
1600 gtk_entry_set_text(GTK_ENTRY(getWidget("logPrivateEntry")), SETTING(LOG_FORMAT_PRIVATE_CHAT).c_str());
1601 gtk_entry_set_text(GTK_ENTRY(getWidget("logPrivateEntryFile")), SETTING(LOG_FILE_PRIVATE_CHAT).c_str());
1602 gtk_widget_set_sensitive(getWidget("logPrivateLabel"), BOOLSETTING(LOG_PRIVATE_CHAT));
1603 gtk_widget_set_sensitive(getWidget("logPrivateEntry"), BOOLSETTING(LOG_PRIVATE_CHAT));
1604 gtk_widget_set_sensitive(getWidget("logPrivateLabelFile"), BOOLSETTING(LOG_PRIVATE_CHAT));
1605 gtk_widget_set_sensitive(getWidget("logPrivateEntryFile"), BOOLSETTING(LOG_PRIVATE_CHAT));
1606
1607 g_signal_connect(getWidget("logDownloadsCheckButton"), "toggled", G_CALLBACK(onLogDownloadClicked_gui), (gpointer)this);
1608 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logDownloadsCheckButton")), BOOLSETTING(LOG_DOWNLOADS));
1609 gtk_entry_set_text(GTK_ENTRY(getWidget("logDownloadsEntry")), SETTING(LOG_FORMAT_POST_DOWNLOAD).c_str());
1610 gtk_entry_set_text(GTK_ENTRY(getWidget("logDownloadsEntryFile")), SETTING(LOG_FILE_DOWNLOAD).c_str());
1611 gtk_widget_set_sensitive(getWidget("logDownloadsLabel"), BOOLSETTING(LOG_DOWNLOADS));
1612 gtk_widget_set_sensitive(getWidget("logDownloadsEntry"), BOOLSETTING(LOG_DOWNLOADS));
1613 gtk_widget_set_sensitive(getWidget("logDownloadsLabelFile"), BOOLSETTING(LOG_DOWNLOADS));
1614 gtk_widget_set_sensitive(getWidget("logDownloadsEntryFile"), BOOLSETTING(LOG_DOWNLOADS));
1615
1616 g_signal_connect(getWidget("logUploadsCheckButton"), "toggled", G_CALLBACK(onLogUploadClicked_gui), (gpointer)this);
1617 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logUploadsCheckButton")), BOOLSETTING(LOG_UPLOADS));
1618 gtk_entry_set_text(GTK_ENTRY(getWidget("logUploadsEntry")), SETTING(LOG_FORMAT_POST_UPLOAD).c_str());
1619 gtk_entry_set_text(GTK_ENTRY(getWidget("logUploadsEntryFile")), SETTING(LOG_FILE_UPLOAD).c_str());
1620 gtk_widget_set_sensitive(getWidget("logUploadsLabel"), BOOLSETTING(LOG_UPLOADS));
1621 gtk_widget_set_sensitive(getWidget("logUploadsEntry"), BOOLSETTING(LOG_UPLOADS));
1622 gtk_widget_set_sensitive(getWidget("logUploadsLabelFile"), BOOLSETTING(LOG_UPLOADS));
1623 gtk_widget_set_sensitive(getWidget("logUploadsEntryFile"), BOOLSETTING(LOG_UPLOADS));
1624
1625 g_signal_connect(getWidget("logFinishedDownloadsCheckButton"), "toggled", G_CALLBACK(onLogFinishedDownloadClicked_gui), (gpointer)this);
1626 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logFinishedDownloadsCheckButton")), BOOLSETTING(LOG_FINISHED_DOWNLOADS));
1627 gtk_entry_set_text(GTK_ENTRY(getWidget("logFinishedDownloadsEntry")), SETTING(LOG_FORMAT_POST_FINISHED_DOWNLOAD).c_str());
1628 gtk_entry_set_text(GTK_ENTRY(getWidget("logFinishedDownloadsEntryFile")), SETTING(LOG_FILE_FINISHED_DOWNLOAD).c_str());
1629 gtk_widget_set_sensitive(getWidget("logFinishedDownloadsLabel"), BOOLSETTING(LOG_FINISHED_DOWNLOADS));
1630 gtk_widget_set_sensitive(getWidget("logFinishedDownloadsEntry"), BOOLSETTING(LOG_FINISHED_DOWNLOADS));
1631 gtk_widget_set_sensitive(getWidget("logFinishedDownloadsLabelFile"), BOOLSETTING(LOG_FINISHED_DOWNLOADS));
1632 gtk_widget_set_sensitive(getWidget("logFinishedDownloadsEntryFile"), BOOLSETTING(LOG_FINISHED_DOWNLOADS));
1633
1634 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logSystemCheckButton")), BOOLSETTING(LOG_SYSTEM));
1635 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logStatusCheckButton")), BOOLSETTING(LOG_STATUS_MESSAGES));
1636 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logFilelistTransfersCheckButton")), BOOLSETTING(LOG_FILELIST_TRANSFERS));
1637 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(getWidget("logSearchAltCheckButton")), BOOLSETTING(REPORT_ALTERNATES));
1638 }
1639
initAdvanced_gui()1640 void Settings::initAdvanced_gui()
1641 {
1642 { // Advanced
1643 createOptionsView_gui(advancedView, advancedStore, "advancedTreeView");
1644
1645 addOption_gui(advancedStore, _("Auto-away on minimize (and back on restore)"), SettingsManager::AUTO_AWAY);
1646 addOption_gui(advancedStore, _("Automatically follow redirects"), SettingsManager::AUTO_FOLLOW);
1647 addOption_gui(advancedStore, _("Clear search box after each search"), "clearsearch");
1648 addOption_gui(advancedStore, _("Keep duplicate files in your file list (duplicates never count towards your share size)"), SettingsManager::LIST_DUPES);
1649 addOption_gui(advancedStore, _("Keep filelists when exiting"), SettingsManager::KEEP_LISTS);
1650 addOption_gui(advancedStore, _("Automatically disconnect users who leave the hub"), SettingsManager::AUTO_KICK);
1651 addOption_gui(advancedStore, _("Enable segmented downloads"), SettingsManager::SEGMENTED_DL);
1652 addOption_gui(advancedStore, _("Enable automatic SFV checking"), SettingsManager::SFV_CHECK);
1653 addOption_gui(advancedStore, _("Enable safe and compressed transfers"), SettingsManager::COMPRESS_TRANSFERS);
1654 addOption_gui(advancedStore, _("Accept custom user commands from hub"), SettingsManager::HUB_USER_COMMANDS);
1655 addOption_gui(advancedStore, _("Send unknown /commands to the hub"), SettingsManager::SEND_UNKNOWN_COMMANDS);
1656 addOption_gui(advancedStore, _("Add finished files to share instantly (if shared)"), SettingsManager::ADD_FINISHED_INSTANTLY);
1657 addOption_gui(advancedStore, _("Don't send the away message to bots"), SettingsManager::NO_AWAYMSG_TO_BOTS);
1658 addOption_gui(advancedStore, _("Use fast hashing method (disable if you have problems with hashing)"), SettingsManager::FAST_HASH);
1659 addOption_gui(advancedStore, _("Register with the OS to handle dchub:// and adc:// URL links"), "urlhandler");
1660 addOption_gui(advancedStore, _("Register with the OS to handle magnet: URL links"), "magnet-register");
1661 addOption_gui(advancedStore, _("Show IP's' in chats"), SettingsManager::USE_IP);
1662 addOption_gui(advancedStore, _("Show user country in chat"), SettingsManager::GET_USER_COUNTRY);
1663 addOption_gui(advancedStore, _("Allow overlap chunks"), SettingsManager::OVERLAP_CHUNKS);
1664 addOption_gui(advancedStore, _("Allow few connections from one IP"), SettingsManager::ALLOW_UPLOAD_MULTI_HUB);
1665 addOption_gui(advancedStore, _("Allow some connections for one user"), SettingsManager::ALLOW_SIM_UPLOADS);
1666 addOption_gui(advancedStore, _("Use ADL search only in own file list"), SettingsManager::USE_ADL_ONLY_OWN_LIST);
1667 addOption_gui(advancedStore, _("Keep downloaded files and dirs in queue"), SettingsManager::KEEP_FINISHED_FILES);
1668
1669 /// @todo: Uncomment when implemented
1670 //addOption_gui(advancedStore, _("Use CTRL for line history"), "use-ctrl-for-line-history");
1671 }
1672
1673 { // User Commands
1674 userCommandView.setView(GTK_TREE_VIEW(getWidget("userCommandTreeView")));
1675 userCommandView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::STRING, -1);
1676 userCommandView.insertColumn(_("Hub"), G_TYPE_STRING, TreeView::STRING, -1);
1677 userCommandView.insertColumn(_("Command"), G_TYPE_STRING, TreeView::STRING, -1);
1678 userCommandView.finalize();
1679 userCommandStore = gtk_list_store_newv(userCommandView.getColCount(), userCommandView.getGTypes());
1680 gtk_tree_view_set_model(userCommandView.get(), GTK_TREE_MODEL(userCommandStore));
1681 g_object_unref(userCommandStore);
1682
1683 // Don't allow the columns to be sorted since we use move up/down functions
1684 gtk_tree_view_column_set_sort_column_id(gtk_tree_view_get_column(userCommandView.get(), userCommandView.col(_("Name"))), -1);
1685 gtk_tree_view_column_set_sort_column_id(gtk_tree_view_get_column(userCommandView.get(), userCommandView.col(_("Command"))), -1);
1686 gtk_tree_view_column_set_sort_column_id(gtk_tree_view_get_column(userCommandView.get(), userCommandView.col(_("Hub"))), -1);
1687
1688 gtk_window_set_transient_for(GTK_WINDOW(getWidget("commandDialog")), GTK_WINDOW(getContainer()));
1689
1690 g_signal_connect(getWidget("userCommandAddButton"), "clicked", G_CALLBACK(onUserCommandAdd_gui), (gpointer)this);
1691 g_signal_connect(getWidget("userCommandRemoveButton"), "clicked", G_CALLBACK(onUserCommandRemove_gui), (gpointer)this);
1692 g_signal_connect(getWidget("userCommandEditButton"), "clicked", G_CALLBACK(onUserCommandEdit_gui), (gpointer)this);
1693 g_signal_connect(getWidget("userCommandUpButton"), "clicked", G_CALLBACK(onUserCommandMoveUp_gui), (gpointer)this);
1694 g_signal_connect(getWidget("userCommandDownButton"), "clicked", G_CALLBACK(onUserCommandMoveDown_gui), (gpointer)this);
1695 g_signal_connect(getWidget("commandDialogSeparator"), "toggled", G_CALLBACK(onUserCommandTypeSeparator_gui), (gpointer)this);
1696 g_signal_connect(getWidget("commandDialogRaw"), "toggled", G_CALLBACK(onUserCommandTypeRaw_gui), (gpointer)this);
1697 g_signal_connect(getWidget("commandDialogChat"), "toggled", G_CALLBACK(onUserCommandTypeChat_gui), (gpointer)this);
1698 g_signal_connect(getWidget("commandDialogPM"), "toggled", G_CALLBACK(onUserCommandTypePM_gui), (gpointer)this);
1699 g_signal_connect(getWidget("commandDialogCommand"), "key-release-event", G_CALLBACK(onUserCommandKeyPress_gui), (gpointer)this);
1700 g_signal_connect(getWidget("commandDialogTo"), "key-release-event", G_CALLBACK(onUserCommandKeyPress_gui), (gpointer)this);
1701 loadUserCommands_gui();
1702 }
1703
1704 { // Experts
1705 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("hashSpeedSpinButton")), (double)SETTING(MAX_HASH_SPEED));
1706 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("writeBufferSpinButton")), (double)SETTING(BUFFER_SIZE));
1707 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("pmHistorySpinButton")), (double)SETTING(SHOW_LAST_LINES_LOG));
1708 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("slotSizeSpinButton")), (double)SETTING(SET_MINISLOT_SIZE));
1709 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("maxListSizeSpinButton")), (double)SETTING(MAX_FILELIST_SIZE));
1710 gtk_entry_set_text(GTK_ENTRY(getWidget("CIDEntry")), SETTING(PRIVATE_ID).c_str());
1711 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("autoRefreshSpinButton")), (double)SETTING(AUTO_REFRESH_TIME));
1712 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("searchHistorySpinButton")), (double)SETTING(SEARCH_HISTORY));
1713 gtk_entry_set_text(GTK_ENTRY(getWidget("bindAddressEntry")), SETTING(BIND_ADDRESS).c_str());
1714 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("socketReadSpinButton")), (double)SETTING(SOCKET_IN_BUFFER));
1715 gtk_spin_button_set_value(GTK_SPIN_BUTTON(getWidget("socketWriteSpinButton")), (double)SETTING(SOCKET_OUT_BUFFER));
1716 }
1717
1718 { // Security Certificates
1719 gtk_entry_set_text(GTK_ENTRY(getWidget("privateKeyEntry")), SETTING(TLS_PRIVATE_KEY_FILE).c_str());
1720 gtk_entry_set_text(GTK_ENTRY(getWidget("certificateFileEntry")), SETTING(TLS_CERTIFICATE_FILE).c_str());
1721 gtk_entry_set_text(GTK_ENTRY(getWidget("trustedCertificatesPathEntry")), SETTING(TLS_TRUSTED_CERTIFICATES_PATH).c_str());
1722 g_signal_connect(getWidget("privateKeyButton"), "clicked", G_CALLBACK(onCertificatesPrivateBrowseClicked_gui), (gpointer)this);
1723 g_signal_connect(getWidget("certificateFileButton"), "clicked", G_CALLBACK(onCertificatesFileBrowseClicked_gui), (gpointer)this);
1724 g_signal_connect(getWidget("trustedCertificatesPathButton"), "clicked", G_CALLBACK(onCertificatesPathBrowseClicked_gui), (gpointer)this);
1725
1726 createOptionsView_gui(certificatesView, certificatesStore, "certificatesTreeView");
1727
1728 addOption_gui(certificatesStore, _("Use TLS when remote client supports it"), SettingsManager::USE_TLS);
1729 addOption_gui(certificatesStore, _("Allow TLS connections to hubs without trusted certificate"), SettingsManager::ALLOW_UNTRUSTED_HUBS);
1730 addOption_gui(certificatesStore, _("Allow TLS connections to clients without trusted certificate"), SettingsManager::ALLOW_UNTRUSTED_CLIENTS);
1731 addOption_gui(certificatesStore, _("Allow only TLS connections to clients"), SettingsManager::REQUIRE_TLS);
1732
1733 g_signal_connect(getWidget("generateCertificatesButton"), "clicked", G_CALLBACK(onGenerateCertificatesClicked_gui), (gpointer)this);
1734 }
1735 }
1736
initSearchTypes_gui()1737 void Settings::initSearchTypes_gui()
1738 {
1739 // search type list
1740 searchTypeView.setView(GTK_TREE_VIEW(getWidget("searchTypeTreeView")));
1741 searchTypeView.insertColumn(_("Search type"), G_TYPE_STRING, TreeView::STRING, -1);
1742 searchTypeView.insertColumn(_("Predefined"), G_TYPE_STRING, TreeView::STRING, -1);
1743 searchTypeView.insertColumn(_("Extensions"), G_TYPE_STRING, TreeView::STRING, -1);
1744 searchTypeView.insertHiddenColumn("Key", G_TYPE_INT);
1745 searchTypeView.finalize();
1746
1747 searchTypeStore = gtk_list_store_newv(searchTypeView.getColCount(), searchTypeView.getGTypes());
1748 gtk_tree_view_set_model(searchTypeView.get(), GTK_TREE_MODEL(searchTypeStore));
1749 g_object_unref(searchTypeStore);
1750
1751 // extension list
1752 extensionView.setView(GTK_TREE_VIEW(getWidget("extensionTreeView")));
1753 extensionView.insertColumn(_("Name"), G_TYPE_STRING, TreeView::STRING, -1);
1754 extensionView.finalize();
1755
1756 extensionStore = gtk_list_store_newv(extensionView.getColCount(), extensionView.getGTypes());
1757 gtk_tree_view_set_model(extensionView.get(), GTK_TREE_MODEL(extensionStore));
1758 g_object_unref(extensionStore);
1759
1760 // search types
1761 const SettingsManager::SearchTypes &searchTypes = SettingsManager::getInstance()->getSearchTypes();
1762 for (SettingsManager::SearchTypesIterC i = searchTypes.begin(), iend = searchTypes.end(); i != iend; ++i)
1763 {
1764 string type = i->first;
1765 bool predefined = false;
1766 int key = SearchManager::TYPE_ANY;
1767
1768 if (type.size() == 1 && type[0] >= '1' && type[0] <= '7')
1769 {
1770 key = type[0] - '0';
1771 if (type[0] == '7')
1772 key = 9;
1773 type = SearchManager::getTypeStr(key);
1774 predefined = true;
1775 }
1776 addOption_gui(searchTypeStore, type, i->second, predefined, key);
1777 }
1778
1779 g_signal_connect(getWidget("addSTButton"), "clicked", G_CALLBACK(onAddSTButton_gui), (gpointer)this);
1780 g_signal_connect(getWidget("modifySTButton"), "clicked", G_CALLBACK(onModifySTButton_gui), (gpointer)this);
1781 g_signal_connect(getWidget("renameSTButton"), "clicked", G_CALLBACK(onRenameSTButton_gui), (gpointer)this);
1782 g_signal_connect(getWidget("removeSTButton"), "clicked", G_CALLBACK(onRemoveSTButton_gui), (gpointer)this);
1783 g_signal_connect(getWidget("defaultSTButton"), "clicked", G_CALLBACK(onDefaultSTButton_gui), (gpointer)this);
1784
1785 g_signal_connect(getWidget("addExtensionButton"), "clicked", G_CALLBACK(onAddExtensionButton_gui), (gpointer)this);
1786 g_signal_connect(getWidget("editExtensionButton"), "clicked", G_CALLBACK(onEditExtensionButton_gui), (gpointer)this);
1787 g_signal_connect(getWidget("removeExtensionButton"), "clicked", G_CALLBACK(onRemoveExtensionButton_gui), (gpointer)this);
1788 g_signal_connect(getWidget("upExtensionButton"), "clicked", G_CALLBACK(onUpExtensionButton_gui), (gpointer)this);
1789 g_signal_connect(getWidget("downExtensionButton"), "clicked", G_CALLBACK(onDownExtensionButton_gui), (gpointer)this);
1790
1791 g_signal_connect(searchTypeView.get(), "key-release-event", G_CALLBACK(onSTKeyReleased_gui), (gpointer)this);
1792 g_signal_connect(searchTypeView.get(), "button-release-event", G_CALLBACK(onSTButtonReleased_gui), (gpointer)this);
1793 }
1794
onSTKeyReleased_gui(GtkWidget * widget,GdkEventKey * event,gpointer data)1795 void Settings::onSTKeyReleased_gui(GtkWidget *widget, GdkEventKey *event, gpointer data)
1796 {
1797 Settings *s = (Settings *)data;
1798
1799 if (event->keyval == GDK_Up || event->keyval == GDK_Down)
1800 {
1801 GtkTreeIter iter;
1802 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->searchTypeView.get());
1803
1804 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
1805 {
1806 int key = s->searchTypeView.getValue<int>(&iter, "Key");
1807 gboolean sensitive = FALSE;
1808 if (key == SearchManager::TYPE_ANY)
1809 sensitive = TRUE;
1810 gtk_widget_set_sensitive(s->getWidget("renameSTButton"), sensitive);
1811 gtk_widget_set_sensitive(s->getWidget("removeSTButton"), sensitive);
1812 }
1813 }
1814 }
1815
onSTButtonReleased_gui(GtkWidget * widget,GdkEventButton * event,gpointer data)1816 void Settings::onSTButtonReleased_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
1817 {
1818 Settings *s = (Settings *)data;
1819
1820 if (event->button == 3 || event->button == 1)
1821 {
1822 GtkTreeIter iter;
1823 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->searchTypeView.get());
1824
1825 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
1826 {
1827 int key = s->searchTypeView.getValue<int>(&iter, "Key");
1828 gboolean sensitive = FALSE;
1829 if (key == SearchManager::TYPE_ANY)
1830 sensitive = TRUE;
1831 gtk_widget_set_sensitive(s->getWidget("renameSTButton"), sensitive);
1832 gtk_widget_set_sensitive(s->getWidget("removeSTButton"), sensitive);
1833 }
1834 }
1835 }
1836
addOption_gui(GtkListStore * store,const string & type,const StringList & exts,bool predefined,const int key)1837 void Settings::addOption_gui(GtkListStore *store, const string &type, const StringList &exts, bool predefined, const int key)
1838 {
1839 GtkTreeIter iter;
1840 gtk_list_store_append(store, &iter);
1841 gtk_list_store_set(store, &iter,
1842 0, type.c_str(), //searchtype
1843 1, predefined ? _("Predefined") : "", //predefined
1844 2, Util::toString(";", exts).c_str(), //extensions
1845 3, key, //key predefined
1846 -1);
1847 }
1848
onAddSTButton_gui(GtkWidget * widget,gpointer data)1849 void Settings::onAddSTButton_gui(GtkWidget *widget, gpointer data)
1850 {
1851 Settings *s = (Settings *)data;
1852
1853 GtkWidget *dialog = s->getWidget("nameDialog");
1854 GtkWidget *entry = s->getWidget("nameDialogEntry");
1855 gtk_window_set_title(GTK_WINDOW(dialog), _("New search type"));
1856 gtk_label_set_markup(GTK_LABEL(s->getWidget("labelNameDialog")), _("<b>Name of the new search type</b>"));
1857 gtk_entry_set_text(GTK_ENTRY(entry), "");
1858 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
1859
1860 if (response == GTK_RESPONSE_OK)
1861 {
1862 string name = gtk_entry_get_text(GTK_ENTRY(entry));
1863 gtk_widget_hide(dialog);
1864 try
1865 {
1866 SettingsManager::getInstance()->validateSearchTypeName(name);
1867 }
1868 catch (const SearchTypeException& e)
1869 {
1870 s->showErrorDialog(e.getError());
1871 return;
1872 }
1873 gtk_list_store_clear(s->extensionStore);
1874 gtk_entry_set_text(GTK_ENTRY(s->getWidget("extensionEntry")), "");
1875 s->showExtensionDialog_gui(TRUE);
1876 }
1877 else
1878 gtk_widget_hide(dialog);
1879 }
1880
showExtensionDialog_gui(bool add)1881 void Settings::showExtensionDialog_gui(bool add)
1882 {
1883 GtkWidget *dialog = getWidget("ExtensionsDialog");
1884 gtk_window_set_title(GTK_WINDOW(dialog), _("Extensions"));
1885 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
1886
1887 if (response == GTK_RESPONSE_OK)
1888 {
1889 if (add)
1890 addSearchType_gui();
1891 else
1892 modSearchType_gui();
1893 }
1894 gtk_widget_hide(dialog);
1895 }
1896
addSearchType_gui()1897 void Settings::addSearchType_gui()
1898 {
1899 string name = gtk_entry_get_text(GTK_ENTRY(getWidget("nameDialogEntry")));
1900
1901 GtkTreeIter iter;
1902 GtkTreeModel *m = GTK_TREE_MODEL(extensionStore);
1903 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
1904
1905 StringList extensions;
1906
1907 while (valid)
1908 {
1909 string ext = extensionView.getString(&iter, _("Name"));
1910 extensions.push_back(ext);
1911
1912 valid = gtk_tree_model_iter_next(m, &iter);
1913 }
1914
1915 if (extensions.empty())
1916 {
1917 showErrorDialog(_("Error"));
1918 return;
1919 }
1920
1921 try
1922 {
1923 SettingsManager::getInstance()->addSearchType(name, extensions);
1924 }
1925 catch (const SearchTypeException& e)
1926 {
1927 showErrorDialog(e.getError());
1928 return;
1929 }
1930
1931 gtk_list_store_append(searchTypeStore, &iter);
1932 gtk_list_store_set(searchTypeStore, &iter,
1933 searchTypeView.col(_("Search type")), name.c_str(),
1934 searchTypeView.col(_("Predefined")), "",
1935 searchTypeView.col(_("Extensions")), Util::toString(";", extensions).c_str(),
1936 -1);
1937 }
1938
modSearchType_gui()1939 void Settings::modSearchType_gui()
1940 {
1941 GtkTreeIter t_iter, e_iter;
1942 GtkTreeSelection *selection = gtk_tree_view_get_selection(searchTypeView.get());
1943 if (!gtk_tree_selection_get_selected(selection, NULL, &t_iter))
1944 return;
1945
1946 GtkTreeModel *m = GTK_TREE_MODEL(extensionStore);
1947 gboolean valid = gtk_tree_model_get_iter_first(m, &e_iter);
1948
1949 StringList extensions;
1950
1951 while (valid)
1952 {
1953 string ext = extensionView.getString(&e_iter, _("Name"));
1954 extensions.push_back(ext);
1955
1956 valid = gtk_tree_model_iter_next(m, &e_iter);
1957 }
1958
1959 if (extensions.empty())
1960 {
1961 showErrorDialog(_("Error"));
1962 return;
1963 }
1964
1965 int key = searchTypeView.getValue<int>(&t_iter, "Key");
1966 string name = searchTypeView.getString(&t_iter, _("Search type"));
1967
1968 try
1969 {
1970 if (key == SearchManager::TYPE_ANY)
1971 {
1972 // Custom searchtype
1973 SettingsManager::getInstance()->modSearchType(name, extensions);
1974 }
1975 else if (key > SearchManager::TYPE_ANY && key < SearchManager::TYPE_DIRECTORY)
1976 {
1977 // Predefined searchtype
1978 SettingsManager::getInstance()->modSearchType(string(1, '0' + key), extensions);
1979 }
1980 else
1981 return;
1982 }
1983 catch (const SearchTypeException& e)
1984 {
1985 showErrorDialog(e.getError());
1986 return;
1987 }
1988
1989 gtk_list_store_set(searchTypeStore, &t_iter,
1990 searchTypeView.col(_("Extensions")), Util::toString(";", extensions).c_str(),
1991 -1);
1992 }
1993
addExtension_gui(const string ext)1994 void Settings::addExtension_gui(const string ext)
1995 {
1996 GtkTreeIter iter;
1997 GtkTreeModel *m = GTK_TREE_MODEL(extensionStore);
1998 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
1999
2000 while (valid)
2001 {
2002 string name = extensionView.getString(&iter, _("Name"));
2003 if (name == ext)
2004 return;
2005
2006 valid = gtk_tree_model_iter_next(m, &iter);
2007 }
2008
2009 gtk_list_store_append(extensionStore, &iter);
2010 gtk_list_store_set(extensionStore, &iter,
2011 0, ext.c_str(),
2012 -1);
2013 }
2014
onAddExtensionButton_gui(GtkWidget * widget,gpointer data)2015 void Settings::onAddExtensionButton_gui(GtkWidget *widget, gpointer data)
2016 {
2017 Settings *s = (Settings *)data;
2018
2019 string error;
2020 string text = gtk_entry_get_text(GTK_ENTRY(s->getWidget("extensionEntry")));
2021 StringTokenizer<string> exts(text, ';');
2022 for (StringIterC i = exts.getTokens().begin(), j = exts.getTokens().end(); i != j; ++i)
2023 {
2024 if (!i->empty())
2025 {
2026 string ext = *i;
2027 if (Util::checkExtension(ext))
2028 {
2029 s->addExtension_gui(ext);
2030 }
2031 else
2032 error += ext + " ";
2033 }
2034 }
2035
2036 if (!error.empty())
2037 s->showErrorDialog(string(_("Invalid extension: ")) + error);
2038 }
2039
onModifySTButton_gui(GtkWidget * widget,gpointer data)2040 void Settings::onModifySTButton_gui(GtkWidget *widget, gpointer data)
2041 {
2042 Settings *s = (Settings *)data;
2043
2044 GtkTreeIter iter;
2045 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->searchTypeView.get());
2046 int key = SearchManager::TYPE_ANY;
2047 string name;
2048
2049 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2050 {
2051 key = s->searchTypeView.getValue<int>(&iter, "Key");
2052 name = s->searchTypeView.getString(&iter, _("Search type"));
2053 }
2054 else
2055 return;
2056
2057 StringList list;
2058 try
2059 {
2060 if (key == SearchManager::TYPE_ANY)
2061 {
2062 // Custom searchtype
2063 list = SettingsManager::getInstance()->getExtensions(name);
2064 }
2065 else if (key > SearchManager::TYPE_ANY && key < SearchManager::TYPE_DIRECTORY)
2066 {
2067 // Predefined searchtype
2068 list = SettingsManager::getInstance()->getExtensions(string(1, '0' + key));
2069 }
2070 else
2071 return;
2072 }
2073 catch (const SearchTypeException& e)
2074 {
2075 s->showErrorDialog(e.getError());
2076 return;
2077 }
2078
2079 gtk_list_store_clear(s->extensionStore);
2080 gtk_entry_set_text(GTK_ENTRY(s->getWidget("extensionEntry")), "");
2081
2082 for (StringIterC i = list.begin(), j = list.end(); i != j; ++i)
2083 {
2084 string ext = *i;
2085 gtk_list_store_append(s->extensionStore, &iter);
2086 gtk_list_store_set(s->extensionStore, &iter, 0, ext.c_str(), -1);
2087 }
2088 s->showExtensionDialog_gui(FALSE);
2089 }
2090
onRenameSTButton_gui(GtkWidget * widget,gpointer data)2091 void Settings::onRenameSTButton_gui(GtkWidget *widget, gpointer data)
2092 {
2093 Settings *s = (Settings *)data;
2094
2095 GtkTreeIter iter;
2096 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->searchTypeView.get());
2097 string old_name, new_name;
2098
2099 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2100 {
2101 old_name = s->searchTypeView.getString(&iter, _("Search type"));
2102 }
2103 else
2104 return;
2105
2106 GtkWidget *dialog = s->getWidget("nameDialog");
2107 GtkWidget *entry = s->getWidget("nameDialogEntry");
2108 gtk_window_set_title(GTK_WINDOW(dialog), _("Rename a search type"));
2109 gtk_label_set_markup(GTK_LABEL(s->getWidget("labelNameDialog")), _("<b>New name</b>"));
2110 gtk_entry_set_text(GTK_ENTRY(entry), old_name.c_str());
2111
2112 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
2113
2114 if (response == GTK_RESPONSE_OK)
2115 {
2116 new_name = gtk_entry_get_text(GTK_ENTRY(entry));
2117 gtk_widget_hide(dialog);
2118 try
2119 {
2120 SettingsManager::getInstance()->renameSearchType(old_name, new_name);
2121 }
2122 catch (const SearchTypeException& e)
2123 {
2124 s->showErrorDialog(e.getError());
2125 return;
2126 }
2127 }
2128 else
2129 {
2130 gtk_widget_hide(dialog);
2131 return;
2132 }
2133
2134 gtk_list_store_set(s->searchTypeStore, &iter,
2135 0, new_name.c_str(),
2136 -1);
2137 }
2138
onRemoveSTButton_gui(GtkWidget * widget,gpointer data)2139 void Settings::onRemoveSTButton_gui(GtkWidget *widget, gpointer data)
2140 {
2141 Settings *s = (Settings *)data;
2142
2143 GtkTreeIter iter;
2144 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->searchTypeView.get());
2145 string name;
2146
2147 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2148 {
2149 name = s->searchTypeView.getString(&iter, _("Search type"));
2150 }
2151 else
2152 return;
2153
2154 try
2155 {
2156 SettingsManager::getInstance()->delSearchType(name);
2157 }
2158 catch (const SearchTypeException& e)
2159 {
2160 s->showErrorDialog(e.getError());
2161 return;
2162 }
2163 gtk_list_store_remove(s->searchTypeStore, &iter);
2164 }
2165
onDefaultSTButton_gui(GtkWidget * widget,gpointer data)2166 void Settings::onDefaultSTButton_gui(GtkWidget *widget, gpointer data)
2167 {
2168 Settings *s = (Settings *)data;
2169
2170 gtk_list_store_clear(s->searchTypeStore);
2171 SettingsManager::getInstance()->setSearchTypeDefaults();
2172
2173 // search types
2174 const SettingsManager::SearchTypes &searchTypes = SettingsManager::getInstance()->getSearchTypes();
2175 for (SettingsManager::SearchTypesIterC i = searchTypes.begin(), j = searchTypes.end(); i != j; ++i)
2176 {
2177 string type = i->first;
2178 bool predefined = false;
2179 int key = SearchManager::TYPE_ANY;
2180 if (type.size() == 1 && type[0] >= '1' && type[0] <= '7')
2181 {
2182 key = type[0] - '0';
2183 if (type[0] == '7')
2184 key = 9;
2185 type = SearchManager::getTypeStr(key);
2186 predefined = true;
2187 }
2188 s->addOption_gui(s->searchTypeStore, type, i->second, predefined, key);
2189 }
2190 }
2191
onEditExtensionButton_gui(GtkWidget * widget,gpointer data)2192 void Settings::onEditExtensionButton_gui(GtkWidget *widget, gpointer data)
2193 {
2194 Settings *s = (Settings *)data;
2195
2196 GtkTreeIter iter;
2197 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->extensionView.get());
2198 string old_ext, new_ext;
2199
2200 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2201 {
2202 old_ext = s->extensionView.getString(&iter, _("Name"));
2203 }
2204 else
2205 return;
2206
2207 GtkWidget *dialog = s->getWidget("nameDialog");
2208 GtkWidget *entry = s->getWidget("nameDialogEntry");
2209 gtk_window_set_title(GTK_WINDOW(dialog), _("Extension edition"));
2210 gtk_label_set_markup(GTK_LABEL(s->getWidget("labelNameDialog")), _("<b>Extension</b>"));
2211
2212 gtk_entry_set_text(GTK_ENTRY(entry), old_ext.c_str());
2213 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
2214
2215 if (response == GTK_RESPONSE_OK)
2216 {
2217 new_ext = gtk_entry_get_text(GTK_ENTRY(entry));
2218 if (new_ext.find(";") == string::npos && Util::checkExtension(new_ext))
2219 {
2220 gtk_list_store_set(s->extensionStore, &iter,
2221 0, new_ext.c_str(),
2222 -1);
2223 }
2224 else
2225 s->showErrorDialog(string(_("Invalid extension: ")) + new_ext);
2226 }
2227 gtk_widget_hide(dialog);
2228 }
2229
onRemoveExtensionButton_gui(GtkWidget * widget,gpointer data)2230 void Settings::onRemoveExtensionButton_gui(GtkWidget *widget, gpointer data)
2231 {
2232 Settings *s = (Settings *)data;
2233
2234 GtkTreeIter iter;
2235 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->extensionView.get());
2236
2237 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2238 {
2239 gtk_list_store_remove(s->extensionStore, &iter);
2240 }
2241 }
2242
onUpExtensionButton_gui(GtkWidget * widget,gpointer data)2243 void Settings::onUpExtensionButton_gui(GtkWidget *widget, gpointer data)
2244 {
2245 Settings *s = (Settings *)data;
2246 GtkTreeIter prev, current;
2247 GtkTreeModel *m = GTK_TREE_MODEL(s->extensionStore);
2248 GtkTreeSelection *sel = gtk_tree_view_get_selection(s->extensionView.get());
2249
2250 if (gtk_tree_selection_get_selected(sel, NULL, ¤t))
2251 {
2252 GtkTreePath *path = gtk_tree_model_get_path(m, ¤t);
2253 if (gtk_tree_path_prev(path) && gtk_tree_model_get_iter(m, &prev, path))
2254 gtk_list_store_swap(s->extensionStore, ¤t, &prev);
2255 gtk_tree_path_free(path);
2256 }
2257 }
2258
onDownExtensionButton_gui(GtkWidget * widget,gpointer data)2259 void Settings::onDownExtensionButton_gui(GtkWidget *widget, gpointer data)
2260 {
2261 Settings *s = (Settings *)data;
2262 GtkTreeIter current, next;
2263 GtkTreeSelection *sel = gtk_tree_view_get_selection(s->extensionView.get());
2264
2265 if (gtk_tree_selection_get_selected(sel, NULL, ¤t))
2266 {
2267 next = current;
2268 if (gtk_tree_model_iter_next(GTK_TREE_MODEL(s->extensionStore), &next))
2269 gtk_list_store_swap(s->extensionStore, ¤t, &next);
2270 }
2271 }
onNoUseTempDir_gui(GtkToggleButton * button,gpointer data)2272 void Settings::onNoUseTempDir_gui(GtkToggleButton *button, gpointer data)
2273 {
2274 Settings *s = (Settings *)data;
2275 bool b = gtk_toggle_button_get_active((GtkToggleButton*)s->getWidget("noUseTempDirButton"));
2276 gtk_widget_set_sensitive(s->getWidget("unfinishedDownloadsEntry"), !b);
2277 gtk_widget_set_sensitive(s->getWidget("unfinishedDownloadsButton"), !b);
2278 gtk_widget_set_sensitive(s->getWidget("labelunfinishedDownloadsEntry"), !b);
2279 }
onNotifyTestButton_gui(GtkWidget * widget,gpointer data)2280 void Settings::onNotifyTestButton_gui(GtkWidget *widget, gpointer data)
2281 {
2282 Settings *s = (Settings *)data;
2283
2284 GtkTreeIter iter;
2285 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2286
2287 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2288 {
2289 string title = s->notifyView.getString(&iter, _("Title"));
2290 string icon = s->notifyView.getString(&iter, _("Icon"));
2291 NotifyUrgency urgency = (NotifyUrgency)s->notifyView.getValue<int>(&iter, "Urgency");
2292 Notify::get()->showNotify(title, "<span weight=\"bold\" size=\"larger\">" + string(_("*** T E S T ***")) + "</span>",
2293 "", icon, gtk_combo_box_get_active(GTK_COMBO_BOX(s->getWidget("notifyIconSizeComboBox"))), urgency);
2294 }
2295 }
2296
onNotifyIconFileBrowseClicked_gui(GtkWidget * widget,gpointer data)2297 void Settings::onNotifyIconFileBrowseClicked_gui(GtkWidget *widget, gpointer data)
2298 {
2299 Settings *s = (Settings *)data;
2300
2301 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_OPEN);
2302 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
2303 gtk_widget_hide(s->getWidget("fileChooserDialog"));
2304
2305 if (response == GTK_RESPONSE_OK)
2306 {
2307 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
2308
2309 if (path)
2310 {
2311 GtkTreeIter iter;
2312 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2313
2314 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2315 {
2316 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(path, NULL);
2317
2318 if (pixbuf)
2319 {
2320 string target = Text::toUtf8(path);
2321 GdkPixbuf *icon = WulforUtil::scalePixbuf(pixbuf, ICON_SIZE, ICON_SIZE);
2322 g_object_unref(pixbuf);
2323
2324 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col(_("Icon")), target.c_str(), -1);
2325 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col("icon"), icon, -1);
2326 g_object_unref(icon);
2327 }
2328 }
2329 g_free(path);
2330 }
2331 }
2332 }
2333
onNotifyKeyReleased_gui(GtkWidget * widget,GdkEventKey * event,gpointer data)2334 void Settings::onNotifyKeyReleased_gui(GtkWidget *widget, GdkEventKey *event, gpointer data)
2335 {
2336 Settings *s = (Settings *)data;
2337
2338 if (event->keyval == GDK_Up || event->keyval == GDK_Down)
2339 {
2340 GtkTreeIter iter;
2341 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2342
2343 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2344 {
2345 gtk_entry_set_text(GTK_ENTRY(s->getWidget("notifyTitleEntry")), s->notifyView.getString(&iter, _("Title")).c_str());
2346 }
2347 }
2348 }
2349
onNotifyButtonReleased_gui(GtkWidget * widget,GdkEventButton * event,gpointer data)2350 void Settings::onNotifyButtonReleased_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
2351 {
2352 Settings *s = (Settings *)data;
2353
2354 if (event->button == 3 || event->button == 1)
2355 {
2356 GtkTreeIter iter;
2357 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2358
2359 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2360 {
2361 gtk_entry_set_text(GTK_ENTRY(s->getWidget("notifyTitleEntry")), s->notifyView.getString(&iter, _("Title")).c_str());
2362 }
2363 }
2364 }
2365
onNotifyOKClicked_gui(GtkWidget * widget,gpointer data)2366 void Settings::onNotifyOKClicked_gui(GtkWidget *widget, gpointer data)
2367 {
2368 Settings *s = (Settings *)data;
2369
2370 string title = gtk_entry_get_text(GTK_ENTRY(s->getWidget("notifyTitleEntry")));
2371
2372 if (title.empty())
2373 {
2374 s->showErrorDialog(_("...must not be empty"));
2375 return;
2376 }
2377
2378 GtkTreeIter iter;
2379 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2380
2381 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2382 {
2383 string temp = s->notifyView.getString(&iter, _("Title"));
2384
2385 if (temp != title)
2386 {
2387 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col(_("Title")), title.c_str(), -1);
2388 }
2389 }
2390 }
2391
onNotifyIconNoneButton_gui(GtkWidget * widget,gpointer data)2392 void Settings::onNotifyIconNoneButton_gui(GtkWidget *widget, gpointer data)
2393 {
2394 Settings *s = (Settings *)data;
2395
2396 GtkTreeIter iter;
2397 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2398
2399 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2400
2401 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col("icon"), NULL, s->notifyView.col(_("Icon")), "", -1);
2402 else
2403 s->showErrorDialog(_("...must not be empty"));
2404 }
2405
onNotifyDefaultButton_gui(GtkWidget * widget,gpointer data)2406 void Settings::onNotifyDefaultButton_gui(GtkWidget *widget, gpointer data)
2407 {
2408 Settings *s = (Settings *)data;
2409
2410 GtkTreeIter iter;
2411 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->notifyView.get());
2412
2413 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2414 {
2415 GdkPixbuf *icon = NULL;
2416 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
2417 string title = wsm->getString(s->notifyView.getString(&iter, "keyTitle"), TRUE);
2418 string path = wsm->getString(s->notifyView.getString(&iter, "keyIcon"), TRUE);
2419
2420 if (!path.empty())
2421 {
2422 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file(Text::fromUtf8(path).c_str(), NULL);
2423
2424 if (pixbuf)
2425 {
2426 icon = WulforUtil::scalePixbuf(pixbuf, ICON_SIZE, ICON_SIZE);
2427 g_object_unref(pixbuf);
2428
2429 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col("icon"), icon, -1);
2430 g_object_unref(icon);
2431 }
2432 }
2433 else
2434 gtk_list_store_set(s->notifyStore, &iter, s->notifyView.col("icon"), icon, -1);
2435
2436 gtk_list_store_set(s->notifyStore, &iter,
2437 s->notifyView.col(_("Icon")), path.c_str(), s->notifyView.col(_("Title")), _(title.c_str()), -1);
2438 }
2439 else
2440 s->showErrorDialog(_("...must not be empty"));
2441 }
2442
onImportThemeButton_gui(GtkWidget * widget,gpointer data)2443 void Settings::onImportThemeButton_gui(GtkWidget *widget, gpointer data)
2444 {
2445 Settings *s = (Settings *)data;
2446
2447 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_OPEN);
2448 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
2449 gtk_widget_hide(s->getWidget("fileChooserDialog"));
2450
2451 if (response == GTK_RESPONSE_OK)
2452 {
2453 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
2454
2455 if (path)
2456 {
2457 string file = path;
2458 g_free(path);
2459
2460 if (s->loadFileTheme(file))
2461 {
2462 s->applyIconsTheme();
2463 s->applyTextTheme();
2464
2465 string fileName = Util::getFileName(Text::toUtf8(file));
2466 string::size_type i = fileName.rfind('.');
2467 string theme = fileName.substr(0, i);
2468 gtk_label_set_text(GTK_LABEL(s->getWidget("currentThemeLabel")), theme.c_str());
2469 }
2470 else
2471 s->showErrorDialog(_("...must be *.theme"));
2472 }
2473 }
2474 }
2475
onExportThemeButton_gui(GtkWidget * widget,gpointer data)2476 void Settings::onExportThemeButton_gui(GtkWidget *widget, gpointer data)
2477 {
2478 Settings *s = (Settings *)data;
2479
2480 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_SAVE);
2481 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
2482 gtk_widget_hide(s->getWidget("fileChooserDialog"));
2483
2484 if (response == GTK_RESPONSE_OK)
2485 {
2486 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
2487
2488 if (path)
2489 {
2490 string file = path;
2491 g_free(path);
2492
2493 if (Util::getFileExt(file) != ".theme" || Util::getFileName(file) == ".theme")
2494 {
2495 s->showErrorDialog(_("...must be *.theme"));
2496 }
2497 else
2498 {
2499 s->setTheme();
2500 s->saveFileTheme(file);
2501 }
2502 }
2503 }
2504 }
2505
onDefaultIconsThemeButton_gui(GtkWidget * widget,gpointer data)2506 void Settings::onDefaultIconsThemeButton_gui(GtkWidget *widget, gpointer data)
2507 {
2508 Settings *s = (Settings *)data;
2509
2510 gtk_label_set_text(GTK_LABEL(s->getWidget("currentThemeLabel")), _("default icons"));
2511 s->applyIconsTheme(TRUE);
2512 }
2513
onSystemIconsThemeButton_gui(GtkWidget * widget,gpointer data)2514 void Settings::onSystemIconsThemeButton_gui(GtkWidget *widget, gpointer data)
2515 {
2516 Settings *s = (Settings *)data;
2517
2518 string theme = gtk_label_get_text(GTK_LABEL(s->getWidget("currentThemeLabel")));
2519 theme += _(" + system icons");
2520 gtk_label_set_text(GTK_LABEL(s->getWidget("currentThemeLabel")), theme.c_str());
2521 s->set("icon-download", GTK_STOCK_GO_DOWN);
2522 s->set("icon-favorite-hubs", GTK_STOCK_HOME);
2523 s->set("icon-finished-downloads", GTK_STOCK_GO_DOWN);
2524 s->set("icon-finished-uploads", GTK_STOCK_GO_UP);
2525 s->set("icon-hash", GTK_STOCK_CONVERT);
2526 s->set("icon-preferences", GTK_STOCK_PREFERENCES);
2527 s->set("icon-public-hubs", GTK_STOCK_NETWORK);
2528 s->set("icon-queue", GTK_STOCK_DIRECTORY);
2529 s->set("icon-search", GTK_STOCK_FIND);
2530 s->set("icon-upload", GTK_STOCK_GO_UP);
2531 s->set("icon-quit", GTK_STOCK_QUIT);
2532 s->set("icon-connect", GTK_STOCK_CONNECT);
2533 s->set("icon-file", GTK_STOCK_FILE);
2534 s->set("icon-directory", GTK_STOCK_DIRECTORY);
2535 s->applyIconsTheme();
2536 }
2537
onDefaultThemeButton_gui(GtkWidget * widget,gpointer data)2538 void Settings::onDefaultThemeButton_gui(GtkWidget *widget, gpointer data)
2539 {
2540 Settings *s = (Settings *)data;
2541
2542 gtk_label_set_text(GTK_LABEL(s->getWidget("currentThemeLabel")), _("default theme"));
2543 s->applyIconsTheme(TRUE);
2544 s->applyTextTheme(TRUE);
2545 }
2546
onDefaultColorsSPButton_gui(GtkWidget * widget,gpointer data)2547 void Settings::onDefaultColorsSPButton_gui(GtkWidget *widget, gpointer data)
2548 {
2549 Settings *s = (Settings *)data;
2550
2551 #if GTK_CHECK_VERSION(3,4,0)
2552 GdkRGBA color;
2553 #define g_c_b_s gtk_color_chooser_get_rgba
2554 #define G_C_B GTK_COLOR_CHOOSER
2555 #define g_c_p(a,b) gdk_rgba_parse(b,a)
2556 #else
2557 GdkColor color;
2558 #define g_c_b_s gtk_color_button_get_color
2559 #define G_C_B GTK_COLOR_BUTTON
2560 #define g_c_p(a,b) gdk_color_parse(a,b)
2561 #endif
2562
2563 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
2564
2565 if (g_c_p(wsm->getString("search-spy-a-color", TRUE).c_str(), &color))
2566 g_c_b_s(G_C_B(s->getWidget("aSPColorButton")), &color);
2567
2568 if (g_c_p(wsm->getString("search-spy-t-color", TRUE).c_str(), &color))
2569 g_c_b_s(G_C_B(s->getWidget("tSPColorButton")), &color);
2570
2571 if (g_c_p(wsm->getString("search-spy-q-color", TRUE).c_str(), &color))
2572 g_c_b_s(G_C_B(s->getWidget("qSPColorButton")), &color);
2573
2574 if (g_c_p(wsm->getString("search-spy-c-color", TRUE).c_str(), &color))
2575 g_c_b_s(G_C_B(s->getWidget("cSPColorButton")), &color);
2576
2577 if (g_c_p(wsm->getString("search-spy-r-color", TRUE).c_str(), &color))
2578 g_c_b_s(G_C_B(s->getWidget("rSPColorButton")), &color);
2579
2580 #undef g_c_p
2581 #undef G_C_B
2582 #undef g_c_b_s
2583
2584 }
2585
onDefaultFrameSPButton_gui(GtkWidget * widget,gpointer data)2586 void Settings::onDefaultFrameSPButton_gui(GtkWidget *widget, gpointer data)
2587 {
2588 Settings *s = (Settings *)data;
2589
2590 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
2591 gtk_spin_button_set_value(GTK_SPIN_BUTTON(s->getWidget("frameSPSpinButton")), double(wsm->getInt("search-spy-frame", TRUE)));
2592 gtk_spin_button_set_value(GTK_SPIN_BUTTON(s->getWidget("waitingSPSpinButton")), double(wsm->getInt("search-spy-waiting", TRUE)));
2593 gtk_spin_button_set_value(GTK_SPIN_BUTTON(s->getWidget("topSPSpinButton")), double(wsm->getInt("search-spy-top", TRUE)));
2594 }
2595
onEnableDynDNSCheckToggled_gui(GtkWidget * widget,gpointer data)2596 void Settings::onEnableDynDNSCheckToggled_gui(GtkWidget *widget, gpointer data)
2597 {
2598 Settings *s = (Settings *)data;
2599
2600 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->getWidget("enableDynDNSCheckButton"))))
2601 {
2602 gtk_widget_set_sensitive(s->getWidget("dyndnsEntry"), TRUE);
2603 gtk_widget_set_sensitive(s->getWidget("dyndnsLabel"), TRUE);
2604 }
2605 else
2606 {
2607 gtk_widget_set_sensitive(s->getWidget("dyndnsEntry"), FALSE);
2608 gtk_widget_set_sensitive(s->getWidget("dyndnsLabel"), FALSE);
2609 }
2610 }
2611
onDHTCheckToggled_gui(GtkWidget * widget,gpointer data)2612 void Settings::onDHTCheckToggled_gui(GtkWidget *widget, gpointer data)
2613 {
2614 Settings *s = (Settings *)data;
2615
2616 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->getWidget("useDHTCheckButton"))))
2617 {
2618 gtk_widget_set_sensitive(s->getWidget("dhtEntry"), TRUE);
2619 gtk_widget_set_sensitive(s->getWidget("dhtLabel"), TRUE);
2620 }
2621 else
2622 {
2623 gtk_widget_set_sensitive(s->getWidget("dhtEntry"), FALSE);
2624 gtk_widget_set_sensitive(s->getWidget("dhtLabel"), FALSE);
2625 }
2626 }
2627
2628
onLimitToggled_gui(GtkWidget * widget,gpointer data)2629 void Settings::onLimitToggled_gui(GtkWidget *widget, gpointer data)
2630 {
2631 Settings *s = (Settings *)data;
2632
2633 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->getWidget("useLimitCheckButton"))))
2634 {
2635 gtk_widget_set_sensitive(s->getWidget("transferSettingsFrame"), TRUE);
2636 gtk_widget_set_sensitive(s->getWidget("secondaryTransferSwitcherFrame"), TRUE);
2637 onLimitSecondToggled_gui(NULL, (gpointer)s);
2638 }
2639 else
2640 {
2641 gtk_widget_set_sensitive(s->getWidget("transferSettingsFrame"), FALSE);
2642 gtk_widget_set_sensitive(s->getWidget("secondaryTransferSwitcherFrame"), FALSE);
2643 gtk_widget_set_sensitive(s->getWidget("secondaryTransferSettingsFrame"), FALSE);
2644 }
2645 }
2646
onLimitSecondToggled_gui(GtkWidget * widget,gpointer data)2647 void Settings::onLimitSecondToggled_gui(GtkWidget *widget, gpointer data)
2648 {
2649 Settings *s = (Settings *)data;
2650
2651 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->getWidget("useLimitSecondCheckButton"))))
2652 {
2653 gtk_widget_set_sensitive(s->getWidget("secondaryTransferSettingsFrame"), TRUE);
2654 gtk_widget_set_sensitive(s->getWidget("limitsFromCombobox"), TRUE);
2655 gtk_widget_set_sensitive(s->getWidget("limitsToCombobox"), TRUE);
2656 }
2657 else
2658 {
2659 gtk_widget_set_sensitive(s->getWidget("secondaryTransferSettingsFrame"), FALSE);
2660 gtk_widget_set_sensitive(s->getWidget("limitsFromCombobox"), FALSE);
2661 gtk_widget_set_sensitive(s->getWidget("limitsToCombobox"), FALSE);
2662 }
2663 }
2664
2665
applyIconsTheme(bool useDefault)2666 void Settings::applyIconsTheme(bool useDefault)
2667 {
2668 GtkTreeIter iter;
2669 GtkTreeModel *m = GTK_TREE_MODEL(themeIconsStore);
2670 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
2671 GtkIconTheme *iconTheme = gtk_icon_theme_get_default();
2672
2673 while (valid)
2674 {
2675 string keyIcon = themeIconsView.getString(&iter, "keyIcon");
2676 string iconName = getStringTheme(keyIcon, useDefault);
2677 GdkPixbuf *icon = gtk_icon_theme_load_icon(iconTheme, iconName.c_str(),
2678 ICON_SIZE, GTK_ICON_LOOKUP_FORCE_SVG, NULL);
2679
2680 gtk_list_store_set(themeIconsStore, &iter,
2681 themeIconsView.col("icon"), icon,
2682 themeIconsView.col("iconName"), iconName.c_str(),
2683 -1);
2684
2685 if (icon)
2686 g_object_unref(icon);
2687
2688 set(keyIcon, iconName);
2689 valid = gtk_tree_model_iter_next(m, &iter);
2690 }
2691 }
2692
applyTextTheme(bool useDefault)2693 void Settings::applyTextTheme(bool useDefault)
2694 {
2695 GtkTreeIter iter;
2696 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
2697 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
2698 GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(textStyleBuffer);
2699 string style, fore, back;
2700 int bolt, italic;
2701
2702 while (valid)
2703 {
2704 style = textStyleView.getString(&iter, "Style");
2705 fore = getStringTheme(textStyleView.getString(&iter, "keyForeColor"), useDefault);
2706 back = getStringTheme(textStyleView.getString(&iter, "keyBackColor"), useDefault);
2707 bolt = getIntTheme(textStyleView.getString(&iter, "keyBolt"), useDefault);
2708 italic = getIntTheme(textStyleView.getString(&iter, "keyItalic"), useDefault);
2709
2710 gtk_list_store_set(textStyleStore, &iter,
2711 textStyleView.col("ForeColor"), fore.c_str(),
2712 textStyleView.col("BackColor"), back.c_str(),
2713 textStyleView.col("Bolt"), bolt,
2714 textStyleView.col("Italic"), italic,
2715 -1);
2716
2717 GtkTextTag *tag = gtk_text_tag_table_lookup(tag_table, style.c_str());
2718
2719 if (tag)
2720 g_object_set(tag,
2721 "foreground", fore.c_str(),
2722 "background", back.c_str(),
2723 "weight", bolt ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
2724 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
2725 NULL);
2726
2727 valid = gtk_tree_model_iter_next(m, &iter);
2728 }
2729
2730 gtk_widget_queue_draw(getWidget("textViewPreviewStylesTheme"));
2731 }
2732
loadFileTheme(const string & file)2733 bool Settings::loadFileTheme(const string &file)
2734 {
2735 if (Util::getFileExt(file) != ".theme" || Util::getFileName(file) == ".theme")
2736 return FALSE;
2737
2738 intMapTheme.clear();
2739 stringMapTheme.clear();
2740
2741 try
2742 {
2743 SimpleXML xml;
2744 xml.fromXML(File(file, File::READ, File::OPEN).read());
2745 xml.resetCurrentChild();
2746 xml.stepIn();
2747
2748 if (xml.findChild("Settings"))
2749 {
2750 xml.stepIn();
2751
2752 IntMap::iterator iit;
2753 for (iit = defaultIntTheme.begin(); iit != defaultIntTheme.end(); ++iit)
2754 {
2755 if (xml.findChild(iit->first))
2756 intMapTheme.insert(IntMap::value_type(iit->first, Util::toInt(xml.getChildData())));
2757 xml.resetCurrentChild();
2758 }
2759
2760 StringMap::iterator sit;
2761 for (sit = defaultStringTheme.begin(); sit != defaultStringTheme.end(); ++sit)
2762 {
2763 if (xml.findChild(sit->first))
2764 {
2765 stringMapTheme.insert(StringMap::value_type(sit->first, xml.getChildData()));
2766 }
2767 xml.resetCurrentChild();
2768 }
2769
2770 xml.stepOut();
2771 }
2772 }
2773 catch (const Exception& e)
2774 {
2775 dcdebug(_("eiskaltdcpp-gtk: load theme %s...\n"), e.getError().c_str());
2776 return FALSE;
2777 }
2778
2779 return TRUE;
2780 }
2781
setTheme()2782 void Settings::setTheme()
2783 {
2784 GtkTreeIter iter;
2785 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
2786 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
2787
2788 while (valid)
2789 {
2790 set(textStyleView.getString(&iter, "keyForeColor"), textStyleView.getString(&iter, "ForeColor"));
2791 set(textStyleView.getString(&iter, "keyBackColor"), textStyleView.getString(&iter, "BackColor"));
2792 set(textStyleView.getString(&iter, "keyBolt"), textStyleView.getValue<int>(&iter, "Bolt"));
2793 set(textStyleView.getString(&iter, "keyItalic"), textStyleView.getValue<int>(&iter, "Italic"));
2794
2795 valid = gtk_tree_model_iter_next(m, &iter);
2796 }
2797
2798 m = GTK_TREE_MODEL(themeIconsStore);
2799 valid = gtk_tree_model_get_iter_first(m, &iter);
2800
2801 while (valid)
2802 {
2803 set(themeIconsView.getString(&iter, "keyIcon"), themeIconsView.getString(&iter, "iconName"));
2804 valid = gtk_tree_model_iter_next(m, &iter);
2805 }
2806 }
2807
saveFileTheme(const string & file)2808 void Settings::saveFileTheme(const string &file)
2809 {
2810 SimpleXML xml;
2811 xml.addTag("Theme");
2812 xml.stepIn();
2813 xml.addTag("Settings");
2814 xml.stepIn();
2815
2816 IntMap::iterator iit;
2817
2818 for (iit = intMapTheme.begin(); iit != intMapTheme.end(); ++iit)
2819 {
2820 xml.addTag(iit->first, iit->second);
2821 xml.addChildAttrib(string("type"), string("int"));
2822 }
2823
2824 StringMap::iterator sit;
2825
2826 for (sit = stringMapTheme.begin(); sit != stringMapTheme.end(); ++sit)
2827 {
2828 xml.addTag(sit->first, sit->second);
2829 xml.addChildAttrib(string("type"), string("string"));
2830 }
2831
2832 xml.stepOut();
2833
2834 try
2835 {
2836 File out(file + ".tmp", File::WRITE, File::CREATE | File::TRUNCATE);
2837 BufferedOutputStream<false> f(&out);
2838 f.write(SimpleXML::utf8Header);
2839 xml.toXML(&f);
2840 f.flush();
2841 out.close();
2842 File::deleteFile(file);
2843 File::renameFile(file + ".tmp", file);
2844 }
2845 catch (const FileException &)
2846 {
2847 }
2848 }
2849
getIntTheme(const string & key,bool useDefault)2850 int Settings::getIntTheme(const string &key, bool useDefault)
2851 {
2852 dcassert(intMapTheme.find(key) != intMapTheme.end() || defaultIntTheme.find(key) != defaultIntTheme.end());
2853
2854 if (useDefault)
2855 return defaultIntTheme[key];
2856
2857 if (intMapTheme.find(key) == intMapTheme.end())
2858 return defaultIntTheme[key];
2859 else
2860 return intMapTheme[key];
2861 }
2862
getStringTheme(const string & key,bool useDefault)2863 string Settings::getStringTheme(const string &key, bool useDefault)
2864 {
2865 dcassert(stringMapTheme.find(key) != stringMapTheme.end() || defaultStringTheme.find(key) != defaultStringTheme.end());
2866
2867 if (useDefault)
2868 return defaultStringTheme[key];
2869
2870 if (stringMapTheme.find(key) == stringMapTheme.end())
2871 return defaultStringTheme[key];
2872 else
2873 return stringMapTheme[key];
2874 }
2875
set(const string & key,int value)2876 void Settings::set(const string &key, int value)
2877 {
2878 dcassert(defaultIntTheme.find(key) != defaultIntTheme.end());
2879 intMapTheme[key] = value;
2880 }
2881
set(const string & key,const string & value)2882 void Settings::set(const string &key, const string &value)
2883 {
2884 dcassert(defaultStringTheme.find(key) != defaultStringTheme.end());
2885 stringMapTheme[key] = value;
2886 }
2887
onSoundFileBrowseClicked_gui(GtkWidget * widget,gpointer data)2888 void Settings::onSoundFileBrowseClicked_gui(GtkWidget *widget, gpointer data)
2889 {
2890 Settings *s = (Settings *)data;
2891
2892 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_OPEN);
2893 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
2894 gtk_widget_hide(s->getWidget("fileChooserDialog"));
2895
2896 if (response == GTK_RESPONSE_OK)
2897 {
2898 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
2899
2900 if (path)
2901 {
2902 GtkTreeIter iter;
2903 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->soundView.get());
2904
2905 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2906 {
2907 string target = Text::toUtf8(path);
2908 gtk_list_store_set(s->soundStore, &iter, s->soundView.col(_("File")), target.c_str(), -1);
2909 }
2910 g_free(path);
2911 }
2912 }
2913 }
2914
onSoundPlayButton_gui(GtkWidget * widget,gpointer data)2915 void Settings::onSoundPlayButton_gui(GtkWidget *widget, gpointer data)
2916 {
2917 Settings *s = (Settings *)data;
2918
2919 GtkTreeIter iter;
2920 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->soundView.get());
2921
2922 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
2923 wsm->set("sound-command", string(gtk_entry_get_text(GTK_ENTRY(s->getWidget("soundCommandEntry")))));
2924
2925 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
2926 {
2927 string target = s->soundView.getString(&iter, _("File"));
2928 Sound::get()->playSound(target);
2929 }
2930 }
2931
onTextColorForeClicked_gui(GtkWidget * widget,gpointer data)2932 void Settings::onTextColorForeClicked_gui(GtkWidget *widget, gpointer data)
2933 {
2934 Settings *s = (Settings *)data;
2935 s->selectTextColor_gui(0);
2936 }
2937
onTextColorBackClicked_gui(GtkWidget * widget,gpointer data)2938 void Settings::onTextColorBackClicked_gui(GtkWidget *widget, gpointer data)
2939 {
2940 Settings *s = (Settings *)data;
2941 s->selectTextColor_gui(1);
2942 }
2943
onTextColorBWClicked_gui(GtkWidget * widget,gpointer data)2944 void Settings::onTextColorBWClicked_gui(GtkWidget *widget, gpointer data)
2945 {
2946 Settings *s = (Settings *)data;
2947 s->selectTextColor_gui(2);
2948 }
2949
onTextStyleClicked_gui(GtkWidget * widget,gpointer data)2950 void Settings::onTextStyleClicked_gui(GtkWidget *widget, gpointer data)
2951 {
2952 Settings *s = (Settings *)data;
2953 s->selectTextStyle_gui(0);
2954 }
2955
onTextStyleDefaultClicked_gui(GtkWidget * widget,gpointer data)2956 void Settings::onTextStyleDefaultClicked_gui(GtkWidget *widget, gpointer data)
2957 {
2958 Settings *s = (Settings *)data;
2959 s->selectTextStyle_gui(1);
2960 }
2961
onPreviewAdd_gui(GtkWidget * widget,gpointer data)2962 void Settings::onPreviewAdd_gui(GtkWidget *widget, gpointer data)
2963 {
2964 Settings *s = (Settings*)data;
2965
2966 string name = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewNameEntry")));
2967 string app = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewApplicationEntry")));
2968 string ext = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewExtensionsEntry")));
2969
2970 if (name.empty() || app.empty() || ext.empty())
2971 {
2972 s->showErrorDialog(_("Must not be empty..."));
2973 return;
2974 }
2975
2976 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
2977
2978 if (wsm->getPreviewApp(name))
2979 {
2980 s->showErrorDialog(_("Error"));
2981 return;
2982 }
2983
2984 if (wsm->addPreviewApp(name, app, ext))
2985 {
2986 GtkTreeIter it;
2987 gtk_list_store_append(s->previewAppToStore, &it);
2988 gtk_list_store_set(s->previewAppToStore, &it,
2989 s->previewAppView.col(_("Name")), name.c_str(),
2990 s->previewAppView.col(_("Application")), app.c_str(),
2991 s->previewAppView.col(_("Extensions")), ext.c_str(),
2992 -1);
2993 }
2994 }
2995
onPreviewRemove_gui(GtkWidget * widget,gpointer data)2996 void Settings::onPreviewRemove_gui(GtkWidget *widget, gpointer data)
2997 {
2998 Settings *s = (Settings *)data;
2999
3000 GtkTreeIter iter;
3001 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->previewAppView.get());
3002
3003 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3004 {
3005 string name = s->previewAppView.getString(&iter, _("Name"));
3006
3007 if (WulforSettingsManager::getInstance()->removePreviewApp(name))
3008 gtk_list_store_remove(s->previewAppToStore, &iter);
3009 }
3010 }
3011
onPreviewKeyReleased_gui(GtkWidget * widget,GdkEventKey * event,gpointer data)3012 void Settings::onPreviewKeyReleased_gui(GtkWidget *widget, GdkEventKey *event, gpointer data)
3013 {
3014 Settings *s = (Settings *)data;
3015
3016 if (event->keyval == GDK_Up || event->keyval == GDK_Down)
3017 {
3018 GtkTreeIter iter;
3019 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->previewAppView.get());
3020
3021 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3022 {
3023 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewNameEntry")), s->previewAppView.getString(&iter, _("Name")).c_str() );
3024 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewApplicationEntry")), s->previewAppView.getString(&iter, _("Application")).c_str());
3025 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewExtensionsEntry")), s->previewAppView.getString(&iter, _("Extensions")).c_str());
3026 }
3027 }
3028 }
3029
onPreviewButtonReleased_gui(GtkWidget * widget,GdkEventButton * event,gpointer data)3030 void Settings::onPreviewButtonReleased_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
3031 {
3032 Settings *s = (Settings *)data;
3033
3034 if (event->button == 3 || event->button == 1)
3035 {
3036 GtkTreeIter iter;
3037 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->previewAppView.get());
3038
3039 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3040 {
3041 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewNameEntry")), s->previewAppView.getString(&iter, _("Name")).c_str());
3042 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewApplicationEntry")), s->previewAppView.getString(&iter, _("Application")).c_str());
3043 gtk_entry_set_text(GTK_ENTRY(s->getWidget("previewExtensionsEntry")), s->previewAppView.getString(&iter, _("Extensions")).c_str());
3044 }
3045 }
3046 }
3047
onPreviewApply_gui(GtkWidget * widget,gpointer data)3048 void Settings::onPreviewApply_gui(GtkWidget *widget, gpointer data)
3049 {
3050 Settings *s = (Settings *)data;
3051
3052 string name = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewNameEntry")));
3053 string app = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewApplicationEntry")));
3054 string ext = gtk_entry_get_text(GTK_ENTRY(s->getWidget("previewExtensionsEntry")));
3055
3056 if (name.empty() || app.empty() || ext.empty())
3057 {
3058 s->showErrorDialog(_("Must not be empty..."));
3059 return;
3060 }
3061
3062 GtkTreeIter iter;
3063 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->previewAppView.get());
3064
3065 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3066 {
3067 string oldName = s->previewAppView.getString(&iter, _("Name"));
3068
3069 if (WulforSettingsManager::getInstance()->applyPreviewApp(oldName, name, app, ext))
3070 {
3071 gtk_list_store_set(s->previewAppToStore, &iter,
3072 s->previewAppView.col(_("Name")), name.c_str(),
3073 s->previewAppView.col(_("Application")), app.c_str(),
3074 s->previewAppView.col(_("Extensions")), ext.c_str(),
3075 -1);
3076 }
3077 }
3078 }
3079
onAddShare_gui(GtkWidget * widget,gpointer data)3080 void Settings::onAddShare_gui(GtkWidget *widget, gpointer data)
3081 {
3082 Settings *s = (Settings *)data;
3083
3084 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
3085 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
3086 gtk_widget_hide(s->getWidget("dirChooserDialog"));
3087
3088 if (response == GTK_RESPONSE_OK)
3089 {
3090 gchar *temp = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
3091 if (temp)
3092 {
3093 string path = Text::toUtf8(temp);
3094 g_free(temp);
3095
3096 if (path[path.length() - 1] != PATH_SEPARATOR)
3097 path += PATH_SEPARATOR;
3098
3099 GtkWidget *dialog = s->getWidget("nameDialog");
3100 gtk_window_set_title(GTK_WINDOW(dialog), _("Virtual name"));
3101 gtk_entry_set_text(GTK_ENTRY(s->getWidget("nameDialogEntry")), Util::getLastDir(path).c_str());
3102 gtk_editable_select_region(GTK_EDITABLE(s->getWidget("nameDialogEntry")), 0, -1);
3103 gtk_label_set_markup(GTK_LABEL(s->getWidget("labelNameDialog")), _("<b>Name under which the others see the directory</b>"));
3104 response = gtk_dialog_run(GTK_DIALOG(dialog));
3105 gtk_widget_hide(dialog);
3106
3107 if (response == GTK_RESPONSE_OK)
3108 {
3109 string name = gtk_entry_get_text(GTK_ENTRY(s->getWidget("nameDialogEntry")));
3110 typedef Func2<Settings, string, string> F2;
3111 F2 *func = new F2(s, &Settings::addShare_client, path, name);
3112 WulforManager::get()->dispatchClientFunc(func);
3113 }
3114 }
3115 }
3116 }
3117
onPictureShare_gui(GtkWidget * widget,gpointer data)3118 void Settings::onPictureShare_gui(GtkWidget *widget, gpointer data)
3119 {
3120 Settings *s = (Settings *)data;
3121
3122 string name = "MAGNET-IMAGE";
3123 string path = Util::getPath(Util::PATH_USER_LOCAL) + "Images/";
3124 typedef Func2<Settings, string, string> F2;
3125 F2 *func = new F2(s, &Settings::addShare_client, path, name);
3126 WulforManager::get()->dispatchClientFunc(func);
3127 }
3128
selectTextColor_gui(const int select)3129 void Settings::selectTextColor_gui(const int select)
3130 {
3131 GtkTreeIter iter;
3132
3133 if (select == 2)
3134 {
3135 /* black and white style */
3136 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
3137 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
3138
3139 string style = "";
3140 GtkTextTag *tag = NULL;
3141 GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(textStyleBuffer);
3142
3143 while (valid)
3144 {
3145 gtk_list_store_set(textStyleStore, &iter,
3146 textStyleView.col("ForeColor"), "#000000",
3147 textStyleView.col("BackColor"), "#FFFFFF", -1);
3148
3149 style = textStyleView.getString(&iter, "Style");
3150 tag = gtk_text_tag_table_lookup(tag_table, style.c_str());
3151
3152 if (tag)
3153 g_object_set(tag, "foreground", "#000000", "background", "#FFFFFF", NULL);
3154
3155 valid = gtk_tree_model_iter_next(m, &iter);
3156 }
3157
3158 gtk_widget_queue_draw(getWidget("textViewPreviewStyles"));
3159
3160 return;
3161 }
3162
3163 GtkTreeSelection *selection = gtk_tree_view_get_selection(textStyleView.get());
3164
3165 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
3166 {
3167 showErrorDialog(_("selected style failed"));
3168 return;
3169 }
3170
3171 string currentcolor = "";
3172
3173 #if GTK_CHECK_VERSION(3,4,0)
3174 GdkRGBA color;
3175 GtkWidget *dialog = gtk_color_chooser_dialog_new(_("Select Color"),GTK_WINDOW(getContainer()));
3176 #else
3177 GdkColor color;
3178 GtkColorSelection *colorsel = GTK_COLOR_SELECTION(getWidget("colorsel-color_selection"));
3179 #endif
3180
3181 if (select == 0)
3182 currentcolor = textStyleView.getString(&iter, "ForeColor");
3183 else
3184 currentcolor = textStyleView.getString(&iter, "BackColor");
3185
3186 #if GTK_CHECK_VERSION(3,4,0)
3187 if (gdk_rgba_parse(&color, currentcolor.c_str()))
3188 gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(dialog), &color);
3189 gint response = gtk_dialog_run(GTK_DIALOG(dialog));
3190 gtk_widget_hide(dialog);
3191 #else
3192 if (gdk_color_parse(currentcolor.c_str(), &color))
3193 gtk_color_selection_set_current_color(colorsel, &color);
3194 gint response = gtk_dialog_run(GTK_DIALOG(getWidget("colorSelectionDialog")));gtk_widget_hide(getWidget("colorSelectionDialog"));
3195 #endif
3196
3197 if (response == GTK_RESPONSE_OK)
3198 {
3199 #if GTK_CHECK_VERSION(3,4,0)
3200 gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(dialog), &color);
3201 #else
3202 gtk_color_selection_get_current_color(colorsel, &color);
3203 #endif
3204
3205 string ground = "";
3206 string strcolor = WulforUtil::colorToString(&color);
3207 string style = textStyleView.getString(&iter, "Style");
3208
3209 if (select == 0)
3210 {
3211 ground = "foreground-gdk";
3212 gtk_list_store_set(textStyleStore, &iter, textStyleView.col("ForeColor"), strcolor.c_str(), -1);
3213 }
3214 else
3215 {
3216 ground = "background-gdk";
3217 if (WGETB("use-native-back-color-for-text"))
3218 return;
3219 gtk_list_store_set(textStyleStore, &iter, textStyleView.col("BackColor"), strcolor.c_str(), -1);
3220 }
3221
3222 GtkTextTag *tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textStyleBuffer), style.c_str());
3223
3224 if (ground == "background-gdk" && WGETB("use-native-back-color-for-text"))
3225 return;
3226
3227 if (tag)
3228 g_object_set(tag, ground.c_str(), &color, NULL);
3229
3230 gtk_widget_queue_draw(getWidget("textViewPreviewStyles"));
3231 }
3232 }
3233
selectTextStyle_gui(const int select)3234 void Settings::selectTextStyle_gui(const int select)
3235 {
3236 GtkTreeIter iter;
3237 int bolt, italic;
3238 GtkTextTag *tag = NULL;
3239 string style = "";
3240
3241 WulforSettingsManager *wsm = WulforSettingsManager::getInstance();
3242
3243 if (select == 1)
3244 {
3245 /* default style */
3246 GtkTreeModel *m = GTK_TREE_MODEL(textStyleStore);
3247 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
3248 GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(textStyleBuffer);
3249 string fore, back;
3250
3251 while (valid)
3252 {
3253 style = textStyleView.getString(&iter, "Style");
3254 fore = wsm->getString(textStyleView.getString(&iter, "keyForeColor"), true);
3255 back = wsm->getString(textStyleView.getString(&iter, "keyBackColor"), true);
3256 bolt = wsm->getInt(textStyleView.getString(&iter, "keyBolt"), true);
3257 italic = wsm->getInt(textStyleView.getString(&iter, "keyItalic"), true);
3258
3259 gtk_list_store_set(textStyleStore, &iter,
3260 textStyleView.col("ForeColor"), fore.c_str(),
3261 textStyleView.col("BackColor"), back.c_str(),
3262 textStyleView.col("Bolt"), bolt,
3263 textStyleView.col("Italic"), italic,
3264 -1);
3265
3266 tag = gtk_text_tag_table_lookup(tag_table, style.c_str());
3267
3268 if (tag)
3269 WGETB("use-native-back-color-for-text") ?
3270 g_object_set(tag,
3271 "foreground", fore.c_str(),
3272 "weight", bolt ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
3273 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
3274 NULL) :
3275 g_object_set(tag,
3276 "foreground", fore.c_str(),
3277 "background", back.c_str(),
3278 "weight", bolt ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
3279 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
3280 NULL);
3281
3282 valid = gtk_tree_model_iter_next(m, &iter);
3283 }
3284
3285 gtk_widget_queue_draw(getWidget("textViewPreviewStyles"));
3286
3287 return;
3288 }
3289
3290 GtkTreeSelection *selection = gtk_tree_view_get_selection(textStyleView.get());
3291
3292 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
3293 {
3294 showErrorDialog(_("selected style failed"));
3295 return;
3296 }
3297 #if GTK_CHECK_VERSION(3, 2, 0)
3298 GtkWidget *fontSelDialog = gtk_font_chooser_dialog_new(_("Select Font"), GTK_WINDOW(getContainer()));
3299 gint response = gtk_dialog_run(GTK_DIALOG(fontSelDialog));
3300 gtk_widget_hide(fontSelDialog);
3301 #else
3302 gint response = gtk_dialog_run(GTK_DIALOG(getWidget("fontSelectionDialog")));
3303 gtk_widget_hide(getWidget("fontSelectionDialog"));
3304 #endif
3305 if (response == GTK_RESPONSE_OK)
3306 {
3307 #if GTK_CHECK_VERSION(3, 2, 0)
3308 gchar *temp = gtk_font_chooser_get_font(GTK_FONT_CHOOSER(fontSelDialog));
3309 #else
3310 GtkFontSelection *fontsel = GTK_FONT_SELECTION(getWidget("fontsel-font_selection"));
3311 gchar *temp = gtk_font_selection_get_font_name(fontsel);
3312 #endif
3313 if (temp)
3314 {
3315 string font_name = temp;
3316 g_free(temp);
3317
3318 bolt = font_name.find("Bold") != string::npos ? 1 : 0;
3319 italic = font_name.find("Italic") != string::npos ? 1 : 0;
3320
3321 style = textStyleView.getString(&iter, "Style");
3322 gtk_list_store_set(textStyleStore, &iter, textStyleView.col("Bolt"), bolt, textStyleView.col("Italic"), italic, -1);
3323
3324 tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(textStyleBuffer), style.c_str());
3325
3326 if (tag)
3327 g_object_set(tag,
3328 "weight", bolt ? TEXT_WEIGHT_BOLD : TEXT_WEIGHT_NORMAL,
3329 "style", italic ? TEXT_STYLE_ITALIC : TEXT_STYLE_NORMAL,
3330 NULL);
3331 gtk_widget_queue_draw(getWidget("textViewPreviewStyles"));
3332 }
3333 }
3334 }
3335
loadUserCommands_gui()3336 void Settings::loadUserCommands_gui()
3337 {
3338 GtkTreeIter iter;
3339 gtk_list_store_clear(userCommandStore);
3340
3341 UserCommand::List userCommands = FavoriteManager::getInstance()->getUserCommands();
3342
3343 for (auto i = userCommands.begin(); i != userCommands.end(); ++i)
3344 {
3345 UserCommand &uc = *i;
3346 if (!uc.isSet(UserCommand::FLAG_NOSAVE))
3347 {
3348 gtk_list_store_append(userCommandStore, &iter);
3349 gtk_list_store_set(userCommandStore, &iter,
3350 userCommandView.col(_("Name")), uc.getName().c_str(),
3351 userCommandView.col(_("Hub")), uc.getHub().c_str(),
3352 userCommandView.col(_("Command")), uc.getCommand().c_str(),
3353 -1);
3354 }
3355 }
3356 }
3357
saveUserCommand(UserCommand * uc)3358 void Settings::saveUserCommand(UserCommand *uc)
3359 {
3360 string name, command, hub;
3361 int ctx = 0;
3362 int type = 0;
3363 GtkTreeIter iter;
3364
3365 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogHubMenu"))))
3366 ctx |= UserCommand::CONTEXT_HUB;
3367 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogUserMenu"))))
3368 ctx |= UserCommand::CONTEXT_USER;
3369 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogSearchMenu"))))
3370 ctx |= UserCommand::CONTEXT_SEARCH;
3371 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogFilelistMenu"))))
3372 ctx |= UserCommand::CONTEXT_FILELIST;
3373
3374 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogSeparator"))))
3375 {
3376 name = _("Separator");
3377 type = UserCommand::TYPE_SEPARATOR;
3378 }
3379 else
3380 {
3381 name = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogName")));
3382 command = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogCommand")));
3383 hub = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogHub")));
3384
3385 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogChat"))))
3386 {
3387 command = "<%[myNI]> " + NmdcHub::validateMessage(command, FALSE) + "|";
3388 }
3389 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogPM"))))
3390 {
3391 string to = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogTo")));
3392 if (to.empty() == 0)
3393 to = "%[userNI]";
3394
3395 command = "$To: " + to + " From: %[myNI] $<%[myNI]> " + NmdcHub::validateMessage(command, FALSE) + "|";
3396 }
3397
3398 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogOnce"))))
3399 type = UserCommand::TYPE_RAW_ONCE;
3400 else
3401 type = UserCommand::TYPE_RAW;
3402 }
3403
3404 if (!uc)
3405 {
3406 FavoriteManager::getInstance()->addUserCommand(type, ctx, 0, name, command, ""/*to*/, hub);
3407 gtk_list_store_append(userCommandStore, &iter);
3408 }
3409 else
3410 {
3411 uc->setType(type);
3412 uc->setCtx(ctx);
3413 uc->setName(name);
3414 uc->setCommand(command);
3415 uc->setHub(hub);
3416 FavoriteManager::getInstance()->updateUserCommand(*uc);
3417
3418 GtkTreeSelection *selection = gtk_tree_view_get_selection(userCommandView.get());
3419 if (!gtk_tree_selection_get_selected(selection, NULL, &iter))
3420 return;
3421 }
3422
3423 gtk_list_store_set(userCommandStore, &iter,
3424 userCommandView.col(_("Name")), name.c_str(),
3425 userCommandView.col(_("Hub")), hub.c_str(),
3426 userCommandView.col(_("Command")), command.c_str(),
3427 -1);
3428 }
3429
3430
updateUserCommandTextSent_gui()3431 void Settings::updateUserCommandTextSent_gui()
3432 {
3433 string command = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogCommand")));
3434
3435 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogSeparator"))))
3436 {
3437 command.clear();
3438 }
3439 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogChat"))))
3440 {
3441 command = "<%[myNI]> " + NmdcHub::validateMessage(command, FALSE) + "|";
3442 }
3443 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogPM"))))
3444 {
3445 string to = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogTo")));
3446 if (to.empty())
3447 to = "%[userNI]";
3448 command = "$To: " + to + " From: %[myNI] $<%[myNI]> " + NmdcHub::validateMessage(command, FALSE) + "|";
3449 }
3450
3451 gtk_entry_set_text(GTK_ENTRY(getWidget("commandDialogTextSent")), command.c_str());
3452 }
3453
validateUserCommandInput(const string & oldName)3454 bool Settings::validateUserCommandInput(const string &oldName)
3455 {
3456 if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(getWidget("commandDialogSeparator"))))
3457 {
3458 string name = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogName")));
3459 string command = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogCommand")));
3460 string hub = gtk_entry_get_text(GTK_ENTRY(getWidget("commandDialogHub")));
3461
3462 if (name.empty() || command.empty())
3463 {
3464 showErrorDialog(_("Name and command must not be empty"));
3465 return FALSE;
3466 }
3467
3468 if (name != oldName && FavoriteManager::getInstance()->findUserCommand(name, hub) != -1)
3469 {
3470 showErrorDialog(_("Command name already exists"));
3471 return FALSE;
3472 }
3473 }
3474 else if (FavoriteManager::getInstance()->findUserCommand(_("Separator"), "") != -1)
3475 {
3476 showErrorDialog(_("Command name already exists"));
3477 return FALSE;
3478 }
3479
3480 return TRUE;
3481 }
3482
showErrorDialog(const string error)3483 void Settings::showErrorDialog(const string error)
3484 {
3485 GtkWidget *errorDialog = gtk_message_dialog_new(GTK_WINDOW(getWidget("dialog")),
3486 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "%s", error.c_str());
3487 gtk_window_set_modal(GTK_WINDOW(errorDialog), TRUE);
3488 g_signal_connect(errorDialog, "response", G_CALLBACK(gtk_widget_destroy), errorDialog);
3489 gtk_widget_show(errorDialog);
3490 }
3491
onOptionsViewToggled_gui(GtkCellRendererToggle * cell,gchar * path,gpointer data)3492 void Settings::onOptionsViewToggled_gui(GtkCellRendererToggle *cell, gchar *path, gpointer data)
3493 {
3494 GtkTreeIter iter;
3495 GtkListStore *store = (GtkListStore *)data;
3496 GtkTreeModel *model = GTK_TREE_MODEL(store);
3497
3498 if (gtk_tree_model_get_iter_from_string(model, &iter, path))
3499 {
3500 gboolean fixed;
3501 gtk_tree_model_get(model, &iter, 0, &fixed, -1);
3502 gtk_list_store_set(store, &iter, 0, !fixed, -1);
3503 }
3504 }
3505
onInDirect_gui(GtkToggleButton * button,gpointer data)3506 void Settings::onInDirect_gui(GtkToggleButton *button, gpointer data)
3507 {
3508 Settings *s = (Settings *)data;
3509 gtk_widget_set_sensitive(s->getWidget("ipEntry"), TRUE);
3510 gtk_widget_set_sensitive(s->getWidget("ipLabel"), TRUE);
3511 gtk_widget_set_sensitive(s->getWidget("tcpEntry"), TRUE);
3512 gtk_widget_set_sensitive(s->getWidget("tcpLabel"), TRUE);
3513 gtk_widget_set_sensitive(s->getWidget("udpEntry"), TRUE);
3514 gtk_widget_set_sensitive(s->getWidget("udpLabel"), TRUE);
3515 gtk_widget_set_sensitive(s->getWidget("tlsEntry"), TRUE);
3516 gtk_widget_set_sensitive(s->getWidget("tlsLabel"), TRUE);
3517 gtk_widget_set_sensitive(s->getWidget("forceIPCheckButton"), TRUE);
3518 }
3519
onInFW_UPnP_gui(GtkToggleButton * button,gpointer data)3520 void Settings::onInFW_UPnP_gui(GtkToggleButton *button, gpointer data)
3521 {
3522 Settings *s = (Settings *)data;
3523 gtk_widget_set_sensitive(s->getWidget("ipEntry"), TRUE);
3524 gtk_widget_set_sensitive(s->getWidget("ipLabel"), TRUE);
3525 gtk_widget_set_sensitive(s->getWidget("tcpEntry"), TRUE);
3526 gtk_widget_set_sensitive(s->getWidget("tcpLabel"), TRUE);
3527 gtk_widget_set_sensitive(s->getWidget("udpEntry"), TRUE);
3528 gtk_widget_set_sensitive(s->getWidget("udpLabel"), TRUE);
3529 gtk_widget_set_sensitive(s->getWidget("tlsEntry"), TRUE);
3530 gtk_widget_set_sensitive(s->getWidget("tlsEntry"), TRUE);
3531 gtk_widget_set_sensitive(s->getWidget("forceIPCheckButton"), TRUE);
3532 }
3533
3534
onInFW_NAT_gui(GtkToggleButton * button,gpointer data)3535 void Settings::onInFW_NAT_gui(GtkToggleButton *button, gpointer data)
3536 {
3537 Settings *s = (Settings *)data;
3538 gtk_widget_set_sensitive(s->getWidget("ipEntry"), TRUE);
3539 gtk_widget_set_sensitive(s->getWidget("ipLabel"), TRUE);
3540 gtk_widget_set_sensitive(s->getWidget("tcpEntry"), TRUE);
3541 gtk_widget_set_sensitive(s->getWidget("tcpLabel"), TRUE);
3542 gtk_widget_set_sensitive(s->getWidget("udpEntry"), TRUE);
3543 gtk_widget_set_sensitive(s->getWidget("udpLabel"), TRUE);
3544 gtk_widget_set_sensitive(s->getWidget("tlsEntry"), TRUE);
3545 gtk_widget_set_sensitive(s->getWidget("tlsLabel"), TRUE);
3546 gtk_widget_set_sensitive(s->getWidget("forceIPCheckButton"), TRUE);
3547 }
3548
onInPassive_gui(GtkToggleButton * button,gpointer data)3549 void Settings::onInPassive_gui(GtkToggleButton *button, gpointer data)
3550 {
3551 Settings *s = (Settings *)data;
3552 gtk_widget_set_sensitive(s->getWidget("ipEntry"), FALSE);
3553 gtk_widget_set_sensitive(s->getWidget("ipLabel"), FALSE);
3554 gtk_widget_set_sensitive(s->getWidget("tcpEntry"), FALSE);
3555 gtk_widget_set_sensitive(s->getWidget("tcpLabel"), FALSE);
3556 gtk_widget_set_sensitive(s->getWidget("udpEntry"), FALSE);
3557 gtk_widget_set_sensitive(s->getWidget("udpLabel"), FALSE);
3558 gtk_widget_set_sensitive(s->getWidget("tlsEntry"), FALSE);
3559 gtk_widget_set_sensitive(s->getWidget("tlsLabel"), FALSE);
3560 gtk_widget_set_sensitive(s->getWidget("forceIPCheckButton"), FALSE);
3561 }
3562
onOutDirect_gui(GtkToggleButton * button,gpointer data)3563 void Settings::onOutDirect_gui(GtkToggleButton *button, gpointer data)
3564 {
3565 Settings *s = (Settings *)data;
3566 gtk_widget_set_sensitive(s->getWidget("socksIPEntry"), FALSE);
3567 gtk_widget_set_sensitive(s->getWidget("socksIPLabel"), FALSE);
3568 gtk_widget_set_sensitive(s->getWidget("socksUserEntry"), FALSE);
3569 gtk_widget_set_sensitive(s->getWidget("socksUserLabel"), FALSE);
3570 gtk_widget_set_sensitive(s->getWidget("socksPortEntry"), FALSE);
3571 gtk_widget_set_sensitive(s->getWidget("socksPortLabel"), FALSE);
3572 gtk_widget_set_sensitive(s->getWidget("socksPassEntry"), FALSE);
3573 gtk_widget_set_sensitive(s->getWidget("socksPassLabel"), FALSE);
3574 gtk_widget_set_sensitive(s->getWidget("socksCheckButton"), FALSE);
3575 }
3576
onSocks5_gui(GtkToggleButton * button,gpointer data)3577 void Settings::onSocks5_gui(GtkToggleButton *button, gpointer data)
3578 {
3579 Settings *s = (Settings *)data;
3580 gtk_widget_set_sensitive(s->getWidget("socksIPEntry"), TRUE);
3581 gtk_widget_set_sensitive(s->getWidget("socksIPLabel"), TRUE);
3582 gtk_widget_set_sensitive(s->getWidget("socksUserEntry"), TRUE);
3583 gtk_widget_set_sensitive(s->getWidget("socksUserLabel"), TRUE);
3584 gtk_widget_set_sensitive(s->getWidget("socksPortEntry"), TRUE);
3585 gtk_widget_set_sensitive(s->getWidget("socksPortLabel"), TRUE);
3586 gtk_widget_set_sensitive(s->getWidget("socksPassEntry"), TRUE);
3587 gtk_widget_set_sensitive(s->getWidget("socksPassLabel"), TRUE);
3588 gtk_widget_set_sensitive(s->getWidget("socksCheckButton"), TRUE);
3589 }
3590
onBrowseFinished_gui(GtkWidget * widget,gpointer data)3591 void Settings::onBrowseFinished_gui(GtkWidget *widget, gpointer data)
3592 {
3593 Settings *s = (Settings *)data;
3594
3595 //gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")), GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
3596 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
3597 gtk_widget_hide(s->getWidget("dirChooserDialog"));
3598
3599 if (response == GTK_RESPONSE_OK)
3600 {
3601 gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
3602 if (path)
3603 {
3604 gtk_entry_set_text(GTK_ENTRY(s->getWidget("finishedDownloadsEntry")), Text::toUtf8(path).c_str());
3605 g_free(path);
3606 }
3607 }
3608 }
3609
onBrowseUnfinished_gui(GtkWidget * widget,gpointer data)3610 void Settings::onBrowseUnfinished_gui(GtkWidget *widget, gpointer data)
3611 {
3612 Settings *s = (Settings *)data;
3613
3614 //gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")), GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER);
3615 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
3616 gtk_widget_hide(s->getWidget("dirChooserDialog"));
3617
3618 if (response == GTK_RESPONSE_OK)
3619 {
3620 gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
3621 if (path)
3622 {
3623 gtk_entry_set_text(GTK_ENTRY(s->getWidget("unfinishedDownloadsEntry")), Text::toUtf8(path).c_str());
3624 g_free(path);
3625 }
3626 }
3627 }
3628
onPublicHubs_gui(GtkWidget * widget,gpointer data)3629 void Settings::onPublicHubs_gui(GtkWidget *widget, gpointer data)
3630 {
3631 Settings *s = (Settings *)data;
3632 GtkTreeIter iter;
3633
3634 gtk_list_store_clear(s->publicListStore);
3635 StringList lists(FavoriteManager::getInstance()->getHubLists());
3636 for (auto idx = lists.begin(); idx != lists.end(); ++idx)
3637 {
3638 gtk_list_store_append(s->publicListStore, &iter);
3639 gtk_list_store_set(s->publicListStore, &iter, s->publicListView.col(_("List")), (*idx).c_str(), -1);
3640 }
3641
3642 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("publicHubsDialog")));
3643 gtk_widget_hide(s->getWidget("publicHubsDialog"));
3644
3645 if (response == GTK_RESPONSE_OK)
3646 {
3647 string lists = "";
3648 GtkTreeModel *m = GTK_TREE_MODEL(s->publicListStore);
3649 gboolean valid = gtk_tree_model_get_iter_first(m, &iter);
3650 while (valid)
3651 {
3652 lists += s->publicListView.getString(&iter, _("List")) + ";";
3653 valid = gtk_tree_model_iter_next(m, &iter);
3654 }
3655 if (!lists.empty())
3656 lists.erase(lists.size() - 1);
3657 SettingsManager::getInstance()->set(SettingsManager::HUBLIST_SERVERS, lists);
3658 }
3659 }
3660
onPublicAdd_gui(GtkWidget * widget,gpointer data)3661 void Settings::onPublicAdd_gui(GtkWidget *widget, gpointer data)
3662 {
3663 Settings *s = (Settings *)data;
3664 GtkTreeIter iter;
3665 GtkTreePath *path;
3666 GtkTreeViewColumn *col;
3667
3668 gtk_list_store_append(s->publicListStore, &iter);
3669 gtk_list_store_set(s->publicListStore, &iter, s->publicListView.col(_("List")), _("New list"), -1);
3670 path = gtk_tree_model_get_path(GTK_TREE_MODEL(s->publicListStore), &iter);
3671 col = gtk_tree_view_get_column(s->publicListView.get(), 0);
3672 gtk_tree_view_set_cursor(s->publicListView.get(), path, col, TRUE);
3673 gtk_tree_path_free(path);
3674 }
3675
onPublicMoveUp_gui(GtkWidget * widget,gpointer data)3676 void Settings::onPublicMoveUp_gui(GtkWidget *widget, gpointer data)
3677 {
3678 Settings *s = (Settings *)data;
3679 GtkTreeIter prev, current;
3680 GtkTreeModel *m = GTK_TREE_MODEL(s->publicListStore);
3681 GtkTreeSelection *sel = gtk_tree_view_get_selection(s->publicListView.get());
3682
3683 if (gtk_tree_selection_get_selected(sel, NULL, ¤t))
3684 {
3685 GtkTreePath *path = gtk_tree_model_get_path(m, ¤t);
3686 if (gtk_tree_path_prev(path) && gtk_tree_model_get_iter(m, &prev, path))
3687 gtk_list_store_swap(s->publicListStore, ¤t, &prev);
3688 gtk_tree_path_free(path);
3689 }
3690 }
3691
onPublicMoveDown_gui(GtkWidget * widget,gpointer data)3692 void Settings::onPublicMoveDown_gui(GtkWidget *widget, gpointer data)
3693 {
3694 Settings *s = (Settings *)data;
3695 GtkTreeIter current, next;
3696 GtkTreeSelection *sel = gtk_tree_view_get_selection(s->publicListView.get());
3697
3698 if (gtk_tree_selection_get_selected(sel, NULL, ¤t))
3699 {
3700 next = current;
3701 if (gtk_tree_model_iter_next(GTK_TREE_MODEL(s->publicListStore), &next))
3702 gtk_list_store_swap(s->publicListStore, ¤t, &next);
3703 }
3704 }
3705
onPublicEdit_gui(GtkCellRendererText * cell,char * path,char * text,gpointer data)3706 void Settings::onPublicEdit_gui(GtkCellRendererText *cell, char *path, char *text, gpointer data)
3707 {
3708 Settings *s = (Settings *)data;
3709 GtkTreeIter iter;
3710
3711 if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(s->publicListStore), &iter, path))
3712 gtk_list_store_set(s->publicListStore, &iter, 0, text, -1);
3713 }
3714
onPublicRemove_gui(GtkWidget * widget,gpointer data)3715 void Settings::onPublicRemove_gui(GtkWidget *widget, gpointer data)
3716 {
3717 Settings *s = (Settings *)data;
3718 GtkTreeIter iter;
3719 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->publicListView.get());
3720
3721 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3722 gtk_list_store_remove(s->publicListStore, &iter);
3723 }
3724
onAddFavorite_gui(GtkWidget * widget,gpointer data)3725 void Settings::onAddFavorite_gui(GtkWidget *widget, gpointer data)
3726 {
3727 Settings *s = (Settings *)data;
3728
3729 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
3730 gtk_widget_hide(s->getWidget("dirChooserDialog"));
3731
3732 if (response == GTK_RESPONSE_OK)
3733 {
3734 gchar *temp = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
3735 if (temp)
3736 {
3737 string path = Text::toUtf8(temp);
3738 g_free(temp);
3739
3740 GtkWidget *dialog = s->getWidget("nameDialog");
3741 gtk_window_set_title(GTK_WINDOW(dialog), _("Favorite name"));
3742 gtk_entry_set_text(GTK_ENTRY(s->getWidget("nameDialogEntry")), "");
3743 gtk_label_set_markup(GTK_LABEL(s->getWidget("labelNameDialog")), _("<b>Name, under which you see the directory</b>"));
3744 response = gtk_dialog_run(GTK_DIALOG(dialog));
3745 gtk_widget_hide(dialog);
3746
3747 if (response == GTK_RESPONSE_OK)
3748 {
3749 string name = gtk_entry_get_text(GTK_ENTRY(s->getWidget("nameDialogEntry")));
3750 if (path[path.length() - 1] != PATH_SEPARATOR)
3751 path += PATH_SEPARATOR;
3752
3753 if (!name.empty() && FavoriteManager::getInstance()->addFavoriteDir(path, name))
3754 {
3755 GtkTreeIter iter;
3756 gtk_list_store_append(s->downloadToStore, &iter);
3757 gtk_list_store_set(s->downloadToStore, &iter,
3758 s->downloadToView.col(_("Favorite Name")), name.c_str(),
3759 s->downloadToView.col(_("Directory")), path.c_str(),
3760 -1);
3761 }
3762 else
3763 {
3764 s->showErrorDialog(_("Directory or favorite name already exists"));
3765 }
3766 }
3767 }
3768 }
3769 }
3770
onRemoveFavorite_gui(GtkWidget * widget,gpointer data)3771 void Settings::onRemoveFavorite_gui(GtkWidget *widget, gpointer data)
3772 {
3773 Settings *s = (Settings *)data;
3774 GtkTreeIter iter;
3775 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->downloadToView.get());
3776
3777 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3778 {
3779 string path = s->downloadToView.getString(&iter, _("Directory"));
3780 if (FavoriteManager::getInstance()->removeFavoriteDir(path))
3781 {
3782 gtk_list_store_remove(s->downloadToStore, &iter);
3783 gtk_widget_set_sensitive(s->getWidget("favoriteRemoveButton"), FALSE);
3784 }
3785 }
3786 }
3787
onFavoriteButtonReleased_gui(GtkWidget * widget,GdkEventButton * event,gpointer data)3788 gboolean Settings::onFavoriteButtonReleased_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
3789 {
3790 Settings *s = (Settings *)data;
3791 GtkTreeIter iter;
3792 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->downloadToView.get());
3793
3794 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3795 gtk_widget_set_sensitive(s->getWidget("favoriteRemoveButton"), TRUE);
3796 else
3797 gtk_widget_set_sensitive(s->getWidget("favoriteRemoveButton"), FALSE);
3798
3799 return FALSE;
3800 }
3801
addShare_gui(string path,string name,int64_t size)3802 void Settings::addShare_gui(string path, string name, int64_t size)
3803 {
3804 GtkTreeIter iter;
3805 gtk_list_store_append(shareStore, &iter);
3806 gtk_list_store_set(shareStore, &iter,
3807 shareView.col(_("Virtual Name")), name.c_str(),
3808 shareView.col(_("Directory")), path.c_str(),
3809 shareView.col(_("Size")), Util::formatBytes(size).c_str(),
3810 shareView.col("Real Size"), size,
3811 -1);
3812 }
3813
onRemoveShare_gui(GtkWidget * widget,gpointer data)3814 void Settings::onRemoveShare_gui(GtkWidget *widget, gpointer data)
3815 {
3816 Settings *s = (Settings *)data;
3817 GtkTreeIter iter;
3818 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->shareView.get());
3819
3820 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3821 {
3822 string path = s->shareView.getString(&iter, _("Directory"));
3823 gtk_list_store_remove(s->shareStore, &iter);
3824 gtk_widget_set_sensitive(s->getWidget("sharedRemoveButton"), FALSE);
3825
3826 ShareManager::getInstance()->removeDirectory(path);
3827 }
3828 }
3829
onShareButtonReleased_gui(GtkWidget * widget,GdkEventButton * event,gpointer data)3830 gboolean Settings::onShareButtonReleased_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
3831 {
3832 Settings *s = (Settings *)data;
3833 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->shareView.get());
3834
3835 if(!gtk_tree_selection_count_selected_rows(selection))
3836 gtk_widget_set_sensitive(s->getWidget("sharedRemoveButton"), FALSE);
3837 else
3838 gtk_widget_set_sensitive(s->getWidget("sharedRemoveButton"), TRUE);
3839
3840 return FALSE;
3841 }
3842
onShareHiddenPressed_gui(GtkToggleButton * togglebutton,gpointer data)3843 gboolean Settings::onShareHiddenPressed_gui(GtkToggleButton *togglebutton, gpointer data)
3844 {
3845 Settings *s = (Settings *)data;
3846
3847 bool show = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(s->getWidget("shareHiddenCheckButton")));
3848
3849 Func1<Settings, bool> *func = new Func1<Settings, bool>(s, &Settings::shareHidden_client, show);
3850 WulforManager::get()->dispatchClientFunc(func);
3851
3852 return FALSE;
3853 }
3854
updateShares_gui()3855 void Settings::updateShares_gui()
3856 {
3857 GtkTreeIter iter;
3858 int64_t size = 0;
3859 string vname;
3860
3861 gtk_list_store_clear(shareStore);
3862 StringPairList directories = ShareManager::getInstance()->getDirectories();
3863 for (auto it = directories.begin(); it != directories.end(); ++it)
3864 {
3865 size = ShareManager::getInstance()->getShareSize(it->second);
3866
3867 if (size == -1 && !BOOLSETTING(SHARE_HIDDEN))
3868 {
3869 vname = _("[HIDDEN SHARE] ") + it->first;
3870 size = 0;
3871 } else
3872 vname = it->first;
3873
3874 gtk_list_store_append(shareStore, &iter);
3875 gtk_list_store_set(shareStore, &iter,
3876 shareView.col(_("Virtual Name")), vname.c_str(),
3877 shareView.col(_("Directory")), it->second.c_str(),
3878 shareView.col(_("Size")), Util::formatBytes(size).c_str(),
3879 shareView.col("Real Size"), size,
3880 -1);
3881 }
3882
3883 string text = _("Total size: ") + Util::formatBytes(ShareManager::getInstance()->getShareSize());
3884 gtk_label_set_text(GTK_LABEL(getWidget("sharedSizeLabel")), text.c_str());
3885 }
3886
onLogBrowseClicked_gui(GtkWidget * widget,gpointer data)3887 void Settings::onLogBrowseClicked_gui(GtkWidget *widget, gpointer data)
3888 {
3889 Settings *s = (Settings *)data;
3890
3891 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
3892 gtk_widget_hide(s->getWidget("dirChooserDialog"));
3893
3894 if (response == GTK_RESPONSE_OK)
3895 {
3896 gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
3897 if (path)
3898 {
3899 gtk_entry_set_text(GTK_ENTRY(s->getWidget("logDirectoryEntry")), Text::toUtf8(path).c_str());
3900 g_free(path);
3901 }
3902 }
3903 }
3904
onLogMainClicked_gui(GtkToggleButton * button,gpointer data)3905 void Settings::onLogMainClicked_gui(GtkToggleButton *button, gpointer data)
3906 {
3907 Settings *s = (Settings *)data;
3908 bool toggled = gtk_toggle_button_get_active(button);
3909 gtk_widget_set_sensitive(s->getWidget("logMainLabel"), toggled);
3910 gtk_widget_set_sensitive(s->getWidget("logMainEntry"), toggled);
3911 gtk_widget_set_sensitive(s->getWidget("logMainLabelFile"), toggled);
3912 gtk_widget_set_sensitive(s->getWidget("logMainEntryFile"), toggled);
3913 }
3914
onLogPrivateClicked_gui(GtkToggleButton * button,gpointer data)3915 void Settings::onLogPrivateClicked_gui(GtkToggleButton *button, gpointer data)
3916 {
3917 Settings *s = (Settings *)data;
3918 bool toggled = gtk_toggle_button_get_active(button);
3919 gtk_widget_set_sensitive(s->getWidget("logPrivateLabel"), toggled);
3920 gtk_widget_set_sensitive(s->getWidget("logPrivateEntry"), toggled);
3921 gtk_widget_set_sensitive(s->getWidget("logPrivateLabelFile"), toggled);
3922 gtk_widget_set_sensitive(s->getWidget("logPrivateEntryFile"), toggled);
3923 }
3924
onLogDownloadClicked_gui(GtkToggleButton * button,gpointer data)3925 void Settings::onLogDownloadClicked_gui(GtkToggleButton *button, gpointer data)
3926 {
3927 Settings *s = (Settings *)data;
3928 bool toggled = gtk_toggle_button_get_active(button);
3929 gtk_widget_set_sensitive(s->getWidget("logDownloadsLabel"), toggled);
3930 gtk_widget_set_sensitive(s->getWidget("logDownloadsEntry"), toggled);
3931 gtk_widget_set_sensitive(s->getWidget("logDownloadsLabelFile"), toggled);
3932 gtk_widget_set_sensitive(s->getWidget("logDownloadsEntryFile"), toggled);
3933 }
3934
onLogUploadClicked_gui(GtkToggleButton * button,gpointer data)3935 void Settings::onLogUploadClicked_gui(GtkToggleButton *button, gpointer data)
3936 {
3937 Settings *s = (Settings *)data;
3938 bool toggled = gtk_toggle_button_get_active(button);
3939 gtk_widget_set_sensitive(s->getWidget("logUploadsLabel"), toggled);
3940 gtk_widget_set_sensitive(s->getWidget("logUploadsEntry"), toggled);
3941 gtk_widget_set_sensitive(s->getWidget("logUploadsLabelFile"), toggled);
3942 gtk_widget_set_sensitive(s->getWidget("logUploadsEntryFile"), toggled);
3943 }
3944
onLogFinishedDownloadClicked_gui(GtkToggleButton * button,gpointer data)3945 void Settings::onLogFinishedDownloadClicked_gui(GtkToggleButton *button, gpointer data)
3946 {
3947 Settings *s = (Settings *)data;
3948 bool toggled = gtk_toggle_button_get_active(button);
3949 gtk_widget_set_sensitive(s->getWidget("logFinishedDownloadsLabel"), toggled);
3950 gtk_widget_set_sensitive(s->getWidget("logFinishedDownloadsEntry"), toggled);
3951 gtk_widget_set_sensitive(s->getWidget("logFinishedDownloadsLabelFile"), toggled);
3952 gtk_widget_set_sensitive(s->getWidget("logFinishedDownloadsEntryFile"), toggled);
3953 }
3954
onUserCommandAdd_gui(GtkWidget * widget,gpointer data)3955 void Settings::onUserCommandAdd_gui(GtkWidget *widget, gpointer data)
3956 {
3957 Settings *s = (Settings *)data;
3958
3959 // Reset dialog to default
3960 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogSeparator")), TRUE);
3961 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogHubMenu")), TRUE);
3962 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogUserMenu")), TRUE);
3963 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogSearchMenu")), TRUE);
3964 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogFilelistMenu")), TRUE);
3965 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogOnce")), FALSE);
3966 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogName")), "");
3967 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogCommand")), "");
3968 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogHub")), "");
3969 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogTo")), "");
3970 gtk_widget_set_sensitive(s->getWidget("commandDialogName"), FALSE);
3971 gtk_widget_set_sensitive(s->getWidget("commandDialogCommand"), FALSE);
3972 gtk_widget_set_sensitive(s->getWidget("commandDialogHub"), FALSE);
3973 gtk_widget_set_sensitive(s->getWidget("commandDialogTo"), FALSE);
3974 gtk_widget_set_sensitive(s->getWidget("commandDialogOnce"), FALSE);
3975
3976 gint response;
3977
3978 do
3979 {
3980 response = gtk_dialog_run(GTK_DIALOG(s->getWidget("commandDialog")));
3981 }
3982 while (response == GTK_RESPONSE_OK && !s->validateUserCommandInput());
3983
3984 gtk_widget_hide(s->getWidget("commandDialog"));
3985
3986 if (response == GTK_RESPONSE_OK)
3987 s->saveUserCommand(NULL);
3988 }
3989
onUserCommandEdit_gui(GtkWidget * widget,gpointer data)3990 void Settings::onUserCommandEdit_gui(GtkWidget *widget, gpointer data)
3991 {
3992 Settings *s = (Settings *)data;
3993 GtkTreeIter iter;
3994 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->userCommandView.get());
3995
3996 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
3997 {
3998 string name = s->userCommandView.getString(&iter, _("Name"));
3999 string hubStr = s->userCommandView.getString(&iter, _("Hub"));
4000 int cid = FavoriteManager::getInstance()->findUserCommand(name, hubStr);
4001 if (cid < 0)
4002 return;
4003
4004 UserCommand uc;
4005 string command, nick;
4006 FavoriteManager::getInstance()->getUserCommand(cid, uc);
4007 bool hub = uc.getCtx() & UserCommand::CONTEXT_HUB;
4008 bool user = uc.getCtx() & UserCommand::CONTEXT_USER;
4009 bool search = uc.getCtx() & UserCommand::CONTEXT_SEARCH;
4010 bool filelist = uc.getCtx() & UserCommand::CONTEXT_FILELIST;
4011
4012 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogHubMenu")), hub);
4013 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogUserMenu")), user);
4014 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogSearchMenu")), search);
4015 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogFilelistMenu")), filelist);
4016
4017 if (uc.getType() == UserCommand::TYPE_SEPARATOR)
4018 {
4019 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogSeparator")), TRUE);
4020 }
4021 else
4022 {
4023 command = uc.getCommand();
4024 bool once = uc.getType() == UserCommand::TYPE_RAW_ONCE;
4025 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogOnce")), once);
4026
4027 // Chat Command
4028 if((!strncmp(command.c_str(), "<%[mynick]> ", 12) ||
4029 !strncmp(command.c_str(), "<%[myNI]> ", 10)) &&
4030 command.find('|') == command.length() - 1)
4031 {
4032 string::size_type i = command.find('>') + 2;
4033 command = NmdcHub::validateMessage(command.substr(i, command.length() - i - 1), TRUE);
4034 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogChat")), TRUE);
4035 }
4036 // PM command
4037 else if (!strncmp(command.c_str(), "$To: ", 5) && (
4038 command.find(" From: %[myNI] $<%[myNI]> ") != string::npos ||
4039 command.find(" From: %[mynick] $<%[mynick]> ") != string::npos) &&
4040 command.find('|') == command.length() - 1)
4041 {
4042 string::size_type i = command.find(' ', 5);
4043 nick = command.substr(5, i - 5);
4044 i = command.find('>', 5) + 2;
4045 command = NmdcHub::validateMessage(command.substr(i, command.length() - i - 1), FALSE);
4046 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogPM")), TRUE);
4047 }
4048 // Raw command
4049 else
4050 {
4051 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(s->getWidget("commandDialogRaw")), TRUE);
4052 }
4053 }
4054
4055 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogName")), name.c_str());
4056 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogCommand")), command.c_str());
4057 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogHub")), uc.getHub().c_str());
4058 gtk_entry_set_text(GTK_ENTRY(s->getWidget("commandDialogTo")), nick.c_str());
4059
4060 s->updateUserCommandTextSent_gui();
4061
4062 gint response;
4063
4064 do
4065 {
4066 response = gtk_dialog_run(GTK_DIALOG(s->getWidget("commandDialog")));
4067 }
4068 while (response == GTK_RESPONSE_OK && !s->validateUserCommandInput(name));
4069
4070 gtk_widget_hide(s->getWidget("commandDialog"));
4071
4072 if (response == GTK_RESPONSE_OK)
4073 s->saveUserCommand(&uc);
4074 }
4075 }
4076
onUserCommandMoveUp_gui(GtkWidget * widget,gpointer data)4077 void Settings::onUserCommandMoveUp_gui(GtkWidget *widget, gpointer data)
4078 {
4079 Settings *s = (Settings *)data;
4080 GtkTreeIter prev, current;
4081 GtkTreeModel *m = GTK_TREE_MODEL(s->userCommandStore);
4082 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->userCommandView.get());
4083
4084 if (gtk_tree_selection_get_selected(selection, NULL, ¤t))
4085 {
4086 GtkTreePath *path = gtk_tree_model_get_path(m, ¤t);
4087 if (gtk_tree_path_prev(path) && gtk_tree_model_get_iter(m, &prev, path))
4088 {
4089 string name = s->userCommandView.getString(¤t, _("Name"));
4090 string hub= s->userCommandView.getString(¤t, _("Hub"));
4091 gtk_list_store_swap(s->userCommandStore, ¤t, &prev);
4092
4093 typedef Func3<Settings, string, string, int> F3;
4094 F3 *func = new F3(s, &Settings::moveUserCommand_client, name, hub, -1);
4095 WulforManager::get()->dispatchClientFunc(func);
4096 }
4097 gtk_tree_path_free(path);
4098 }
4099 }
4100
onUserCommandMoveDown_gui(GtkWidget * widget,gpointer data)4101 void Settings::onUserCommandMoveDown_gui(GtkWidget *widget, gpointer data)
4102 {
4103 Settings *s = (Settings *)data;
4104 GtkTreeIter current, next;
4105 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->userCommandView.get());
4106
4107 if (gtk_tree_selection_get_selected(selection, NULL, ¤t))
4108 {
4109 next = current;
4110 if (gtk_tree_model_iter_next(GTK_TREE_MODEL(s->userCommandStore), &next))
4111 {
4112 string name = s->userCommandView.getString(¤t, _("Name"));
4113 string hub = s->userCommandView.getString(¤t, _("Hub"));
4114 gtk_list_store_swap(s->userCommandStore, ¤t, &next);
4115
4116 typedef Func3<Settings, string, string, int> F3;
4117 F3 *func = new F3(s, &Settings::moveUserCommand_client, name, hub, 1);
4118 WulforManager::get()->dispatchClientFunc(func);
4119 }
4120 }
4121 }
4122
onUserCommandRemove_gui(GtkWidget * widget,gpointer data)4123 void Settings::onUserCommandRemove_gui(GtkWidget *widget, gpointer data)
4124 {
4125 Settings *s = (Settings *)data;
4126 GtkTreeIter iter;
4127 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->userCommandView.get());
4128
4129 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
4130 {
4131 string name = s->userCommandView.getString(&iter, _("Name"));
4132 string hub = s->userCommandView.getString(&iter, _("Hub"));
4133 gtk_list_store_remove(s->userCommandStore, &iter);
4134
4135 typedef Func2<Settings, string, string> F2;
4136 F2 *func = new F2(s, &Settings::removeUserCommand_client, name, hub);
4137 WulforManager::get()->dispatchClientFunc(func);
4138 }
4139 }
4140
onUserCommandTypeSeparator_gui(GtkWidget * widget,gpointer data)4141 void Settings::onUserCommandTypeSeparator_gui(GtkWidget *widget, gpointer data)
4142 {
4143 Settings *s = (Settings *)data;
4144
4145 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
4146 {
4147 gtk_widget_set_sensitive(s->getWidget("commandDialogName"), FALSE);
4148 gtk_widget_set_sensitive(s->getWidget("commandDialogCommand"), FALSE);
4149 gtk_widget_set_sensitive(s->getWidget("commandDialogHub"), FALSE);
4150 gtk_widget_set_sensitive(s->getWidget("commandDialogTo"), FALSE);
4151 gtk_widget_set_sensitive(s->getWidget("commandDialogOnce"), FALSE);
4152
4153 s->updateUserCommandTextSent_gui();
4154 }
4155 }
4156
onUserCommandTypeRaw_gui(GtkWidget * widget,gpointer data)4157 void Settings::onUserCommandTypeRaw_gui(GtkWidget *widget, gpointer data)
4158 {
4159 Settings *s = (Settings *)data;
4160
4161 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
4162 {
4163 gtk_widget_set_sensitive(s->getWidget("commandDialogName"), TRUE);
4164 gtk_widget_set_sensitive(s->getWidget("commandDialogCommand"), TRUE);
4165 gtk_widget_set_sensitive(s->getWidget("commandDialogHub"), TRUE);
4166 gtk_widget_set_sensitive(s->getWidget("commandDialogTo"), FALSE);
4167 gtk_widget_set_sensitive(s->getWidget("commandDialogOnce"), TRUE);
4168
4169 s->updateUserCommandTextSent_gui();
4170 }
4171 }
4172
onUserCommandTypeChat_gui(GtkWidget * widget,gpointer data)4173 void Settings::onUserCommandTypeChat_gui(GtkWidget *widget, gpointer data)
4174 {
4175 Settings *s = (Settings *)data;
4176
4177 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
4178 {
4179 gtk_widget_set_sensitive(s->getWidget("commandDialogName"), TRUE);
4180 gtk_widget_set_sensitive(s->getWidget("commandDialogCommand"), TRUE);
4181 gtk_widget_set_sensitive(s->getWidget("commandDialogHub"), FALSE);
4182 gtk_widget_set_sensitive(s->getWidget("commandDialogTo"), FALSE);
4183 gtk_widget_set_sensitive(s->getWidget("commandDialogOnce"), TRUE);
4184
4185 s->updateUserCommandTextSent_gui();
4186 }
4187 }
4188
onUserCommandTypePM_gui(GtkWidget * widget,gpointer data)4189 void Settings::onUserCommandTypePM_gui(GtkWidget *widget, gpointer data)
4190 {
4191 Settings *s = (Settings *)data;
4192
4193 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
4194 {
4195 gtk_widget_set_sensitive(s->getWidget("commandDialogName"), TRUE);
4196 gtk_widget_set_sensitive(s->getWidget("commandDialogCommand"), TRUE);
4197 gtk_widget_set_sensitive(s->getWidget("commandDialogHub"), TRUE);
4198 gtk_widget_set_sensitive(s->getWidget("commandDialogTo"), TRUE);
4199 gtk_widget_set_sensitive(s->getWidget("commandDialogOnce"), TRUE);
4200
4201 s->updateUserCommandTextSent_gui();
4202 }
4203 }
4204
onUserCommandKeyPress_gui(GtkWidget * widget,GdkEventKey * event,gpointer data)4205 gboolean Settings::onUserCommandKeyPress_gui(GtkWidget *widget, GdkEventKey *event, gpointer data)
4206 {
4207 Settings *s = (Settings *)data;
4208
4209 s->updateUserCommandTextSent_gui();
4210
4211 return FALSE;
4212 }
4213
onCertificatesPrivateBrowseClicked_gui(GtkWidget * widget,gpointer data)4214 void Settings::onCertificatesPrivateBrowseClicked_gui(GtkWidget *widget, gpointer data)
4215 {
4216 Settings *s = (Settings *)data;
4217
4218 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_OPEN);
4219 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
4220 gtk_widget_hide(s->getWidget("fileChooserDialog"));
4221
4222 if (response == GTK_RESPONSE_OK)
4223 {
4224 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
4225 if (path)
4226 {
4227 gtk_entry_set_text(GTK_ENTRY(s->getWidget("privateKeyEntry")), Text::toUtf8(path).c_str());
4228 g_free(path);
4229 }
4230 }
4231 }
4232
onCertificatesFileBrowseClicked_gui(GtkWidget * widget,gpointer data)4233 void Settings::onCertificatesFileBrowseClicked_gui(GtkWidget *widget, gpointer data)
4234 {
4235 Settings *s = (Settings *)data;
4236
4237 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")), GTK_FILE_CHOOSER_ACTION_OPEN);
4238 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("fileChooserDialog")));
4239 gtk_widget_hide(s->getWidget("fileChooserDialog"));
4240
4241 if (response == GTK_RESPONSE_OK)
4242 {
4243 gchar *path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(s->getWidget("fileChooserDialog")));
4244 if (path)
4245 {
4246 gtk_entry_set_text(GTK_ENTRY(s->getWidget("certificateFileEntry")), Text::toUtf8(path).c_str());
4247 g_free(path);
4248 }
4249 }
4250 }
4251
onCertificatesPathBrowseClicked_gui(GtkWidget * widget,gpointer data)4252 void Settings::onCertificatesPathBrowseClicked_gui(GtkWidget *widget, gpointer data)
4253 {
4254 Settings *s = (Settings *)data;
4255
4256 gtk_file_chooser_set_action(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
4257 gint response = gtk_dialog_run(GTK_DIALOG(s->getWidget("dirChooserDialog")));
4258 gtk_widget_hide(s->getWidget("dirChooserDialog"));
4259
4260 if (response == GTK_RESPONSE_OK)
4261 {
4262 gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(s->getWidget("dirChooserDialog")));
4263 if (path)
4264 {
4265 gtk_entry_set_text(GTK_ENTRY(s->getWidget("trustedCertificatesPathEntry")), Text::toUtf8(path).c_str());
4266 g_free(path);
4267 }
4268 }
4269 }
4270
onGenerateCertificatesClicked_gui(GtkWidget * widget,gpointer data)4271 void Settings::onGenerateCertificatesClicked_gui(GtkWidget *widget, gpointer data)
4272 {
4273 Settings *s = (Settings *)data;
4274 Func0<Settings> *func = new Func0<Settings>(s, &Settings::generateCertificates_client);
4275 WulforManager::get()->dispatchClientFunc(func);
4276 }
4277
shareHidden_client(bool show)4278 void Settings::shareHidden_client(bool show)
4279 {
4280 SettingsManager::getInstance()->set(SettingsManager::SHARE_HIDDEN, show);
4281 ShareManager::getInstance()->setDirty();
4282 ShareManager::getInstance()->refresh(TRUE, FALSE, TRUE);
4283
4284 Func0<Settings> *func = new Func0<Settings>(this, &Settings::updateShares_gui);
4285 WulforManager::get()->dispatchGuiFunc(func);
4286 }
4287
addShare_client(string path,string name)4288 void Settings::addShare_client(string path, string name)
4289 {
4290 int64_t size = 0;
4291
4292 try
4293 {
4294 ShareManager::getInstance()->addDirectory(path, name);
4295 size = ShareManager::getInstance()->getShareSize(path);
4296 }
4297 catch (const ShareException &e)
4298 {
4299 typedef Func1<Settings, const string> F1;
4300 F1 *func = new F1(this, &Settings::showErrorDialog, e.getError());
4301 WulforManager::get()->dispatchGuiFunc(func);
4302 }
4303
4304 typedef Func3<Settings, string, string, int64_t> F3;
4305 F3 *func = new F3(this, &Settings::addShare_gui, path, name, size);
4306 WulforManager::get()->dispatchGuiFunc(func);
4307 }
4308
removeUserCommand_client(string name,string hub)4309 void Settings::removeUserCommand_client(string name, string hub)
4310 {
4311 if (!name.empty())
4312 {
4313 FavoriteManager *fm = FavoriteManager::getInstance();
4314 fm->removeUserCommand(fm->findUserCommand(name, hub));
4315 }
4316 }
4317
moveUserCommand_client(string name,string hub,int pos)4318 void Settings::moveUserCommand_client(string name, string hub, int pos)
4319 {
4320 if (!name.empty())
4321 {
4322 FavoriteManager *fm = FavoriteManager::getInstance();
4323 fm->moveUserCommand(fm->findUserCommand(name, hub), pos);
4324 fm->save();
4325 }
4326 }
4327
generateCertificates_client()4328 void Settings::generateCertificates_client()
4329 {
4330 try
4331 {
4332 CryptoManager::getInstance()->generateCertificate();
4333 }
4334 catch (const CryptoException &e)
4335 {
4336 }
4337 }
4338
onExceptionAdd_gui(GtkWidget * widget,gpointer data)4339 void Settings::onExceptionAdd_gui(GtkWidget *widget, gpointer data)
4340 {
4341 Settings *s = (Settings *)data;
4342 GtkTreeIter iter;
4343 GtkTreePath *path;
4344 GtkTreeViewColumn *col;
4345
4346 gtk_list_store_append(s->exceptionStore, &iter);
4347 gtk_list_store_set(s->exceptionStore, &iter, s->exceptionView.col(_("List")), _("New exception"), -1);
4348 path = gtk_tree_model_get_path(GTK_TREE_MODEL(s->exceptionStore), &iter);
4349 col = gtk_tree_view_get_column(s->exceptionView.get(), 0);
4350 gtk_tree_view_set_cursor(s->exceptionView.get(), path, col, TRUE);
4351 gtk_tree_path_free(path);
4352 }
4353
onExceptionEdit_gui(GtkCellRendererText * cell,char * path,char * text,gpointer data)4354 void Settings::onExceptionEdit_gui(GtkCellRendererText *cell, char *path, char *text, gpointer data)
4355 {
4356 Settings *s = (Settings *)data;
4357 GtkTreeIter iter;
4358
4359 if (gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(s->exceptionStore), &iter, path))
4360 gtk_list_store_set(s->exceptionStore, &iter, 0, text, -1);
4361 }
4362
onExceptionRemove_gui(GtkWidget * widget,gpointer data)4363 void Settings::onExceptionRemove_gui(GtkWidget *widget, gpointer data)
4364 {
4365 Settings *s = (Settings *)data;
4366 GtkTreeIter iter;
4367 GtkTreeSelection *selection = gtk_tree_view_get_selection(s->exceptionView.get());
4368
4369 if (gtk_tree_selection_get_selected(selection, NULL, &iter))
4370 gtk_list_store_remove(s->exceptionStore, &iter);
4371 }
4372
onExceptionDefault_gui(GtkWidget * widget,gpointer data)4373 void Settings::onExceptionDefault_gui(GtkWidget *widget, gpointer data)
4374 {
4375 Settings *s = (Settings *)data;
4376 GtkTreeIter iter;
4377
4378 gtk_list_store_clear(s->exceptionStore);
4379 StringTokenizer<string> lists(SETTING(SKIPLIST_SHARE), "|");
4380 for (auto idx = lists.getTokens().begin(); idx != lists.getTokens().end(); ++idx)
4381 {
4382 gtk_list_store_append(s->exceptionStore, &iter);
4383 gtk_list_store_set(s->exceptionStore, &iter, s->exceptionView.col(_("List")), (*idx).c_str(), -1);
4384 }
4385 }
4386