← Back to branch summary

~ubuntu-branches/debian/lenny/linuxdcpp/lenny

« back to all changes in this revision

Viewing changes to linux/mainwindow.cc

  • Committer: Bazaar Package Importer
  • Author(s): Romain Beauxis
  • Date: 2006-05-30 01:59:51 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060530015951-ph4q3gteuuix20x9
Tags: 0.0.1.cvs20060530-1
http://bugs.debian.org/352898
* New upstream release
* Changed window title to LinuxDC++ (Closes: #352898)

Show diffs side-by-side

added added

removed removed

Lines of Context:
linux/mainwindow.cc
20
20
#include "wulformanager.hh"
21
21
#include "selecter.hh"
22
22
#include "settingsdialog.hh"
23
 
#include "treeviewfactory.hh"
 
23
#include "treeview.hh"
 
24
#include "settingsmanager.hh"
 
25
#include "eggtrayicon.h"
24
26
 
25
27
#include <client/version.h>
26
28
#include <client/Socket.h>
35
37
 
36
38
using namespace std;
37
39
 
38
 
const int MainWindow::STATE_NORMAL = 0;
39
 
const int MainWindow::STATE_MAXIMIZED = 1;
40
 
 
41
40
MainWindow::MainWindow():
42
 
        connectCallback(this, &MainWindow::connectClicked_gui),
43
 
        pubHubsCallback(this, &MainWindow::pubHubsClicked_gui),
44
 
        dlQueueCallback(this, &MainWindow::dlQueueClicked_gui),
45
 
        settingsCallback(this, &MainWindow::settingsClicked_gui),
46
 
        favHubsCallback(this, &MainWindow::favHubsClicked_gui),
47
 
        searchCallback(this, &MainWindow::searchClicked_gui),
48
 
        hashCallback(this, &MainWindow::hashClicked_gui),
49
 
        aboutCallback(this, &MainWindow::aboutClicked_gui),
50
 
        quitCallback(this, &MainWindow::quitClicked_gui),
51
 
        finishedDL_Callback(this, &MainWindow::finishedDLclicked_gui),
52
 
        finishedUL_Callback(this, &MainWindow::finishedULclicked_gui),          
53
 
        deleteCallback(this, &MainWindow::deleteWindow_gui),
54
 
//      transferCallback(this, &MainWindow::transferClicked_gui),
55
 
        switchPageCallback(this, &MainWindow::switchPage_gui),
56
 
        openFListCallback(this, &MainWindow::openFList_gui),
57
 
        refreshFListCallback(this, &MainWindow::refreshFList_gui),
58
 
 
59
 
        lastUpdate(0),
60
 
 
61
 
        WIDTH_TYPE(20), 
62
 
        WIDTH_USER(150), 
63
 
        WIDTH_STATUS(250), 
64
 
        WIDTH_TIMELEFT(75),
65
 
        WIDTH_SPEED(175), 
66
 
        WIDTH_FILENAME(200), 
67
 
        WIDTH_SIZE(175), 
68
 
        WIDTH_PATH(200)
 
41
        lastUpdate(0)
69
42
{
70
43
        createWindow_gui();
 
44
        createTrayIcon_gui();
71
45
        startSocket_client();
72
46
 
73
47
        QueueManager::getInstance()->addListener(this);
87
61
        ConnectionManager::getInstance()->removeListener(this);
88
62
 
89
63
        //Save window state and position
90
 
        int posX, posY, sizeX, sizeY, state;
 
64
        int posX, posY, sizeX, sizeY, state, transferPanePosition;
91
65
        GdkWindowState gdkState;
92
 
        SettingsManager *sm = SettingsManager::getInstance();
93
 
        //The gtk move/get position cause drift, one adds window decorations, one does not
94
 
        gdk_window_get_position(GTK_WIDGET(window)->window, &posX, &posY);
 
66
        WulforSettingsManager *sm = WulforSettingsManager::get();
 
67
 
 
68
        gtk_window_get_position(window, &posX, &posY);
95
69
        gtk_window_get_size(window, &sizeX, &sizeY);
96
70
        gdkState = gdk_window_get_state(GTK_WIDGET(window)->window);
 
71
        transferPanePosition = gtk_paned_get_position(transferPane);
97
72
 
98
73
        if (gdkState & GDK_WINDOW_STATE_MAXIMIZED) {
99
 
                state = STATE_MAXIMIZED;
 
74
                state = 1;
100
75
        } else {
101
 
                state = STATE_NORMAL;
 
76
                state = 0;
102
77
                //The get pos/size functions return junk when window is maximized
103
 
                sm->set (SettingsManager::MAIN_WINDOW_POS_X, posX);
104
 
                sm->set (SettingsManager::MAIN_WINDOW_POS_Y, posY);
105
 
                sm->set (SettingsManager::MAIN_WINDOW_SIZE_X, sizeX);
106
 
                sm->set (SettingsManager::MAIN_WINDOW_SIZE_Y, sizeY);
 
78
                sm->set("main-window-pos-x", posX);
 
79
                sm->set("main-window-pos-y", posY);
 
80
                sm->set("main-window-size-x", sizeX);
 
81
                sm->set("main-window-size-y", sizeY);
107
82
        }
108
83
        
109
 
        sm->set (SettingsManager::MAIN_WINDOW_STATE, state);
 
84
        sm->set("main-window-maximized", state);
 
85
        sm->set("transfer-pane-position", transferPanePosition);
110
86
 
111
87
        //Make sure all windows are deallocated (probably not necessary)
112
88
        gtk_widget_destroy(GTK_WIDGET(connectDialog));
114
90
        gtk_widget_destroy(GTK_WIDGET(flistDialog));
115
91
        gtk_widget_destroy(GTK_WIDGET(aboutDialog));
116
92
        gtk_widget_destroy(GTK_WIDGET(window));
 
93
        gtk_widget_destroy(trayIcon);
117
94
 
118
 
        //this makes sure the pixmaps are freed (using gtk:s ref counting)
 
95
        // This makes sure the pixmaps are freed (using gtk's ref counting).
119
96
        g_object_unref(G_OBJECT(uploadPic));
120
97
        g_object_unref(G_OBJECT(downloadPic));
 
98
 
 
99
        // Free the transferMap
 
100
        map<UserID, TransferItem *>::iterator it;
 
101
        for (it = transferMap.begin(); it != transferMap.end(); it++)
 
102
        {
 
103
                gtk_tree_row_reference_free(it->second->rowRef);
 
104
                delete it->second;
 
105
        }
121
106
}
122
107
 
123
108
void MainWindow::createWindow_gui() {
132
117
        ulStatus = GTK_STATUSBAR(glade_xml_get_widget(xml, "status6"));
133
118
        dlStatus = GTK_STATUSBAR(glade_xml_get_widget(xml, "status7"));
134
119
 
135
 
        connectButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "connect"));
136
 
        pubHubsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "publicHubs"));
137
 
        searchButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "search"));
138
 
        settingsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "settings"));
139
 
        hashButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "hash"));
140
 
        queueButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "queue"));
141
 
        finishedDL_button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "finishedDownloads"));
142
 
        finishedUL_button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "finishedUploads"));
143
 
        favHubsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "favHubs"));
144
 
        quitButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "quit"));
 
120
        GtkToolButton *connectButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "connect"));
 
121
        GtkToolButton *pubHubsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "publicHubs"));
 
122
        GtkToolButton *searchButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "search"));
 
123
        GtkToolButton *settingsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "settings"));
 
124
        GtkToolButton *hashButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "hash"));
 
125
        GtkToolButton *queueButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "queue"));
 
126
        GtkToolButton *finishedDL_button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "finishedDownloads"));
 
127
        GtkToolButton *finishedUL_button = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "finishedUploads"));
 
128
        GtkToolButton *favHubsButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "favHubs"));
 
129
        GtkToolButton *quitButton = GTK_TOOL_BUTTON(glade_xml_get_widget(xml, "quit"));
145
130
 
146
131
        exitDialog = GTK_DIALOG(glade_xml_get_widget(xml, "exitDialog"));
147
132
        connectDialog = GTK_DIALOG(glade_xml_get_widget(xml, "connectDialog"));
148
133
        flistDialog = GTK_DIALOG(glade_xml_get_widget(xml, "flistDialog"));
149
134
        aboutDialog = GTK_DIALOG(glade_xml_get_widget(xml, "aboutDialog"));
 
135
        gtk_dialog_set_alternative_button_order(exitDialog, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
 
136
        gtk_dialog_set_alternative_button_order(connectDialog, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
 
137
        gtk_dialog_set_alternative_button_order(flistDialog, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1);
150
138
 
151
139
        window = GTK_WINDOW(glade_xml_get_widget(xml, "mainWindow"));
 
140
        transferPane = GTK_PANED(glade_xml_get_widget(xml, "pane"));
152
141
        book = GTK_NOTEBOOK(glade_xml_get_widget(xml, "book"));
153
 
        transferView = GTK_TREE_VIEW(glade_xml_get_widget(xml, "transfers"));
154
142
        connectEntry = GTK_ENTRY(glade_xml_get_widget(xml, "connectEntry"));
155
 
 
156
 
        openFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_file_list_1"));
157
 
        openOwnFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_own_list1"));
158
 
        refreshFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "refresh_file_list1"));
159
 
        openDLdir = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_downloads_directory1"));
160
 
        quickConnect = GTK_MENU_ITEM(glade_xml_get_widget(xml, "quick_connect1"));
161
 
        followRedirect = GTK_MENU_ITEM(glade_xml_get_widget(xml, "follow_last_redirect1"));
162
 
        reconnectItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "reconnect1"));
163
 
        settingsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "settings1"));
164
 
        quitItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "exit1"));
 
143
        windowMenu = glade_xml_get_widget(xml, "windowMenu");
 
144
 
 
145
        // Set the logo in the about menu.
 
146
        file = WulforManager::get()->getPath() + "/pixmaps/linuxdcpp.png";
 
147
        GtkImage *logo = GTK_IMAGE(gtk_image_new_from_file(file.c_str()));
 
148
        gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(aboutDialog), gtk_image_get_pixbuf(logo));
 
149
 
 
150
        // Set all windows to the default icon
 
151
        file = WulforManager::get()->getPath() + "/pixmaps/linuxdcpp-icon.png";
 
152
        gtk_window_set_icon_from_file(window, file.c_str(), NULL);
 
153
        gtk_window_set_default_icon_from_file(file.c_str(), NULL);
 
154
 
 
155
        GtkMenuItem *openFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_file_list_1"));
 
156
        GtkMenuItem *openOwnFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_own_list1"));
 
157
        GtkMenuItem *refreshFList = GTK_MENU_ITEM(glade_xml_get_widget(xml, "refresh_file_list1"));
 
158
        GtkMenuItem *openDLdir = GTK_MENU_ITEM(glade_xml_get_widget(xml, "open_downloads_directory1"));
 
159
        GtkMenuItem *quickConnect = GTK_MENU_ITEM(glade_xml_get_widget(xml, "quick_connect1"));
 
160
        GtkMenuItem *followRedirect = GTK_MENU_ITEM(glade_xml_get_widget(xml, "follow_last_redirect1"));
 
161
        GtkMenuItem *reconnectItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "reconnect1"));
 
162
        GtkMenuItem *settingsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "settings1"));
 
163
        GtkMenuItem *quitItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "exit1"));
165
164
        
166
 
        pubHubsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "public_hubs1"));
167
 
        queueItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "download_queue1"));
168
 
        finishedDL_item = GTK_MENU_ITEM(glade_xml_get_widget(xml, "finished_downloads1"));
169
 
        finishedUL_item = GTK_MENU_ITEM(glade_xml_get_widget(xml, "finished_uploads1"));
170
 
        favHubsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "favorite_hubs1"));
171
 
        favUsersItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "favorite_users1"));
172
 
        searchItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "search1"));
173
 
        ADLSearchItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "adl_search1"));
174
 
        searchSpyItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "search_spy1"));
175
 
        networkStatsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "network_statistics1"));
176
 
        hashItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "indexing_progress1"));
177
 
        aboutItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "about"));
 
165
        GtkMenuItem *pubHubsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "public_hubs1"));
 
166
        GtkMenuItem *queueItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "download_queue1"));
 
167
        GtkMenuItem *finishedDL_item = GTK_MENU_ITEM(glade_xml_get_widget(xml, "finished_downloads1"));
 
168
        GtkMenuItem *finishedUL_item = GTK_MENU_ITEM(glade_xml_get_widget(xml, "finished_uploads1"));
 
169
        GtkMenuItem *favHubsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "favorite_hubs1"));
 
170
        GtkMenuItem *favUsersItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "favorite_users1"));
 
171
        GtkMenuItem *searchItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "search1"));
 
172
        GtkMenuItem *ADLSearchItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "adl_search1"));
 
173
        GtkMenuItem *searchSpyItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "search_spy1"));
 
174
        GtkMenuItem *networkStatsItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "network_statistics1"));
 
175
        GtkMenuItem *hashItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "indexing_progress1"));
 
176
        GtkMenuItem *aboutItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "about"));
178
177
 
179
178
        gtk_widget_set_sensitive(GTK_WIDGET(openDLdir), false);
180
179
        gtk_widget_set_sensitive(GTK_WIDGET(followRedirect), false);
184
183
        gtk_widget_set_sensitive(GTK_WIDGET(searchSpyItem), false);
185
184
        gtk_widget_set_sensitive(GTK_WIDGET(networkStatsItem), false);
186
185
 
187
 
        transferStore = gtk_list_store_new(10, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, 
188
 
                G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
189
 
        gtk_tree_view_set_model(transferView, GTK_TREE_MODEL(transferStore));
190
 
        transferSel = gtk_tree_view_get_selection(transferView);
191
 
        gtk_tree_selection_set_mode(gtk_tree_view_get_selection(transferView), GTK_SELECTION_MULTIPLE);
192
 
        g_signal_connect (G_OBJECT (transferView), "button_press_event", G_CALLBACK (transferClicked_gui), (gpointer)this);
193
 
        TreeViewFactory factory(transferView);
194
 
        factory.addColumn_gui(COLUMN_TYPE, "", TreeViewFactory::PIXBUF, WIDTH_TYPE);
195
 
        factory.addColumn_gui(COLUMN_USER, "User", TreeViewFactory::STRING, WIDTH_USER);
196
 
        factory.addColumn_gui(COLUMN_STATUS, "Status", TreeViewFactory::STRING, WIDTH_STATUS);
197
 
        factory.addColumn_gui(COLUMN_TIMELEFT, "Time Left", TreeViewFactory::STRING, WIDTH_TIMELEFT);
198
 
        factory.addColumn_gui(COLUMN_SPEED, "Speed", TreeViewFactory::STRING, WIDTH_SPEED);
199
 
        factory.addColumn_gui(COLUMN_FILENAME, "File", TreeViewFactory::STRING, WIDTH_FILENAME);
200
 
        factory.addColumn_gui(COLUMN_SIZE, "Size", TreeViewFactory::STRING, WIDTH_SIZE);
201
 
        factory.addColumn_gui(COLUMN_PATH, "Path", TreeViewFactory::STRING, WIDTH_PATH);
202
 
        gtk_tree_view_insert_column(transferView, gtk_tree_view_column_new(), COLUMN_ID);
 
186
        // Initialize transfer treeview
 
187
        transferView.setView(GTK_TREE_VIEW(glade_xml_get_widget(xml, "transfers")), true, "main");
 
188
        transferView.insertColumn("User", G_TYPE_STRING, TreeView::PIXBUF_STRING, 150, "Icon");
 
189
        transferView.insertColumn("Hub Name", G_TYPE_STRING, TreeView::STRING, 100);
 
190
        if (SETTING(SHOW_PROGRESS_BARS))
 
191
                transferView.insertColumn("Status", G_TYPE_STRING, TreeView::PROGRESS, 250, "Progress");
 
192
        else
 
193
                transferView.insertColumn("Status", G_TYPE_STRING, TreeView::STRING, 250);
 
194
        transferView.insertColumn("Time Left", G_TYPE_STRING, TreeView::STRING, 75);
 
195
        transferView.insertColumn("Speed", G_TYPE_STRING, TreeView::STRING, 175);
 
196
        transferView.insertColumn("Filename", G_TYPE_STRING, TreeView::STRING, 200);
 
197
        transferView.insertColumn("Size", G_TYPE_STRING, TreeView::STRING, 175);
 
198
        transferView.insertColumn("Path", G_TYPE_STRING, TreeView::STRING, 200);
 
199
        transferView.insertHiddenColumn("Icon", GDK_TYPE_PIXBUF);
 
200
        transferView.insertHiddenColumn("TransferItem", G_TYPE_POINTER);
 
201
        transferView.insertHiddenColumn("Progress", G_TYPE_INT);
 
202
        transferView.insertHiddenColumn("Sort Order", G_TYPE_STRING);
 
203
        transferView.insertHiddenColumn("Speed Order", G_TYPE_INT64);
 
204
        transferView.insertHiddenColumn("Size Order", G_TYPE_INT64);
 
205
        transferView.finalize();
 
206
        transferStore = gtk_list_store_newv(transferView.getColCount(), transferView.getGTypes());
 
207
        gtk_tree_view_set_model(transferView.get(), GTK_TREE_MODEL(transferStore));
 
208
        g_object_unref(transferStore);
 
209
        transferSel = gtk_tree_view_get_selection(transferView.get());
 
210
        gtk_tree_selection_set_mode(transferSel, GTK_SELECTION_MULTIPLE);
 
211
        transferView.setSortColumn_gui("User", "Sort Order");
 
212
        transferView.setSortColumn_gui("Speed", "Speed Order");
 
213
        transferView.setSortColumn_gui("Size", "Size Order");
 
214
        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(transferStore), transferView.col("Sort Order"), GTK_SORT_ASCENDING);
 
215
        gtk_tree_view_column_set_sort_indicator(gtk_tree_view_get_column(transferView.get(), transferView.col("User")), TRUE);
 
216
        gtk_tree_view_set_fixed_height_mode(transferView.get(), TRUE);
 
217
 
 
218
        g_signal_connect(G_OBJECT(transferView.get()), "button_press_event", G_CALLBACK(transferClicked_gui), (gpointer)this);
203
219
 
204
220
        file = WulforManager::get()->getPath() + "/pixmaps/upload.png";
205
221
        uploadPic = gdk_pixbuf_new_from_file(file.c_str(), NULL);
246
262
        gtk_menu_shell_append (GTK_MENU_SHELL (popupMenu), privateMessage);
247
263
        g_signal_connect (G_OBJECT (privateMessage), "activate", G_CALLBACK (onPrivateMessageClicked_gui), (gpointer)this);
248
264
        addToFavorites = gtk_menu_item_new_with_label ("Add to favorites");
 
265
        gtk_widget_set_sensitive(addToFavorites, FALSE); // Fav user not implemented yet.
249
266
        gtk_menu_shell_append (GTK_MENU_SHELL (popupMenu), addToFavorites);
250
267
        g_signal_connect (G_OBJECT (addToFavorites), "activate", G_CALLBACK (onAddFavoriteUserClicked_gui), (gpointer)this);
251
268
        grantExtraSlot = gtk_menu_item_new_with_label ("Grant extra slot");
263
280
        g_signal_connect (G_OBJECT (closeConnection), "activate", G_CALLBACK (onCloseConnectionClicked_gui), (gpointer)this);
264
281
        gtk_menu_shell_append (GTK_MENU_SHELL (popupMenu), closeConnection);
265
282
                
266
 
        gtk_widget_show_all (popupMenu);
267
 
                
268
283
        gtk_widget_show_all(GTK_WIDGET(window));
269
284
 
270
 
        connectCallback.connect(G_OBJECT(connectButton), "clicked", NULL);
271
 
        connectCallback.connect(G_OBJECT(quickConnect), "activate", NULL);
272
 
        pubHubsCallback.connect(G_OBJECT(pubHubsButton), "clicked", NULL);
273
 
        pubHubsCallback.connect(G_OBJECT(pubHubsItem), "activate", NULL);
274
 
        dlQueueCallback.connect(G_OBJECT(queueButton), "clicked", NULL);
275
 
        dlQueueCallback.connect(G_OBJECT(queueItem), "activate", NULL);
276
 
        favHubsCallback.connect(G_OBJECT(favHubsButton), "clicked", NULL);
277
 
        favHubsCallback.connect(G_OBJECT(favHubsItem), "activate", NULL);
278
 
        settingsCallback.connect(G_OBJECT(settingsButton), "clicked", NULL);
279
 
        settingsCallback.connect(G_OBJECT(settingsItem), "activate", NULL);
280
 
        searchCallback.connect(G_OBJECT(searchButton), "clicked", NULL);
281
 
        searchCallback.connect(G_OBJECT(searchItem), "activate", NULL);
282
 
        hashCallback.connect(G_OBJECT(hashButton), "clicked", NULL);
283
 
        hashCallback.connect(G_OBJECT(hashItem), "activate", NULL);
284
 
        aboutCallback.connect(G_OBJECT(aboutItem), "activate", NULL);
285
 
        quitCallback.connect(G_OBJECT(quitItem), "activate", NULL);
286
 
        quitCallback.connect(G_OBJECT(quitButton), "clicked", NULL);
287
 
        aboutItem = GTK_MENU_ITEM(glade_xml_get_widget(xml, "about"));
288
 
        finishedDL_Callback.connect(G_OBJECT(finishedDL_button), "clicked", NULL);
289
 
        finishedDL_Callback.connect(G_OBJECT(finishedDL_item), "activate", NULL);
290
 
        finishedUL_Callback.connect(G_OBJECT(finishedUL_button), "clicked", NULL);
291
 
        finishedUL_Callback.connect(G_OBJECT(finishedUL_item), "activate", NULL);
292
 
        openFListCallback.connect(G_OBJECT(openFList), "activate", NULL);
293
 
        openFListCallback.connect(G_OBJECT(openOwnFList), "activate", NULL);
294
 
        refreshFListCallback.connect(G_OBJECT(refreshFList), "activate", NULL);
295
 
        
296
 
        deleteCallback.connect(G_OBJECT(window), "delete-event", NULL);
297
 
//      transferCallback.connect(G_OBJECT(window), "button-release-event", this);
298
 
        switchPageCallback.connect(G_OBJECT(book), "switch-page", NULL);
 
285
        g_signal_connect(G_OBJECT(connectButton), "clicked", G_CALLBACK(connectClicked_gui), (gpointer)this);
 
286
        g_signal_connect(G_OBJECT(quickConnect), "activate", G_CALLBACK(connectClicked_gui), (gpointer)this);
 
287
        g_signal_connect(G_OBJECT(pubHubsButton), "clicked", G_CALLBACK(pubHubsClicked_gui), (gpointer)this);
 
288
        g_signal_connect(G_OBJECT(pubHubsItem), "activate", G_CALLBACK(pubHubsClicked_gui), (gpointer)this);
 
289
        g_signal_connect(G_OBJECT(searchButton), "clicked", G_CALLBACK(searchClicked_gui), (gpointer)this);
 
290
        g_signal_connect(G_OBJECT(searchItem), "activate", G_CALLBACK(searchClicked_gui), (gpointer)this);
 
291
        g_signal_connect(G_OBJECT(settingsButton), "clicked", G_CALLBACK(settingsClicked_gui), (gpointer)this);
 
292
        g_signal_connect(G_OBJECT(settingsItem), "activate", G_CALLBACK(settingsClicked_gui), (gpointer)this);
 
293
        g_signal_connect(G_OBJECT(hashButton), "clicked", G_CALLBACK(hashClicked_gui), (gpointer)this);
 
294
        g_signal_connect(G_OBJECT(hashItem), "activate", G_CALLBACK(hashClicked_gui), (gpointer)this);
 
295
        g_signal_connect(G_OBJECT(queueButton), "clicked", G_CALLBACK(dlQueueClicked_gui), (gpointer)this);
 
296
        g_signal_connect(G_OBJECT(queueItem), "activate", G_CALLBACK(dlQueueClicked_gui), (gpointer)this);
 
297
        g_signal_connect(G_OBJECT(finishedDL_button), "clicked", G_CALLBACK(finishedDLclicked_gui), (gpointer)this);
 
298
        g_signal_connect(G_OBJECT(finishedDL_item), "activate", G_CALLBACK(finishedDLclicked_gui), (gpointer)this);
 
299
        g_signal_connect(G_OBJECT(finishedUL_button), "clicked", G_CALLBACK(finishedULclicked_gui), (gpointer)this);
 
300
        g_signal_connect(G_OBJECT(finishedUL_item), "activate", G_CALLBACK(finishedULclicked_gui), (gpointer)this);
 
301
        g_signal_connect(G_OBJECT(favHubsButton), "clicked", G_CALLBACK(favHubsClicked_gui), (gpointer)this);
 
302
        g_signal_connect(G_OBJECT(favHubsItem), "activate", G_CALLBACK(favHubsClicked_gui), (gpointer)this);
 
303
        g_signal_connect(G_OBJECT(quitItem), "activate", G_CALLBACK(quitClicked_gui), (gpointer)this);
 
304
        g_signal_connect(G_OBJECT(quitButton), "clicked", G_CALLBACK(quitClicked_gui), (gpointer)this);
 
305
        g_signal_connect(G_OBJECT(aboutItem), "activate", G_CALLBACK(aboutClicked_gui), (gpointer)this);
 
306
        g_signal_connect(G_OBJECT(openFList), "activate", G_CALLBACK(openFileList_gui), (gpointer)this);
 
307
        g_signal_connect(G_OBJECT(openOwnFList), "activate", G_CALLBACK(openOwnList_gui), (gpointer)this);
 
308
        g_signal_connect(G_OBJECT(refreshFList), "activate", G_CALLBACK(refreshFList_gui), (gpointer)this);
 
309
        g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(deleteWindow_gui), (gpointer)this);
299
310
 
300
311
        //Load window state and position from settings manager
301
 
        int posX =  SETTING(MAIN_WINDOW_POS_X);
302
 
        int posY = SETTING(MAIN_WINDOW_POS_Y);
303
 
        int sizeX = SETTING(MAIN_WINDOW_SIZE_X);
304
 
        int sizeY = SETTING(MAIN_WINDOW_SIZE_Y);
 
312
        WulforSettingsManager *sm = WulforSettingsManager::get();
 
313
        int posX =  sm->getInt("main-window-pos-x");
 
314
        int posY = sm->getInt("main-window-pos-y");
 
315
        int sizeX = sm->getInt("main-window-size-x");
 
316
        int sizeY = sm->getInt("main-window-size-y");
 
317
        int transferPanePosition = sm->getInt("transfer-pane-position");
305
318
        
306
 
        //The gtk move/get position cause drift, one adds window decorations, one does not
307
 
        gdk_window_move(GTK_WIDGET(window)->window, posX, posY);
308
 
        gtk_window_resize(window, sizeX, sizeY);
309
 
        if (SETTING(MAIN_WINDOW_STATE) == STATE_MAXIMIZED)
 
319
        gtk_window_move(window, posX, posY);
 
320
        gtk_window_resize(window, sizeX, sizeY);
 
321
        if (sm->getInt("main-window-maximized"))
310
322
                gtk_window_maximize(window);
311
 
 
312
 
        //Create text in about window
313
 
        GtkLabel *al = GTK_LABEL(glade_xml_get_widget(xml, "aboutLabel"));
314
 
        string text =   string("<big>Linux DC++</big>\n") +
315
 
                                        string("Bringing DC++ to Linux!\n") +
316
 
                                        string("<b>Version:</b> 0.1-rc1\n") +
317
 
                                        string("<b>Core version:</b> ") + string(VERSIONSTRING) + string("\n") +
318
 
                                        string("<b>Developers:</b>\n ") +
319
 
                                        string("Jens Oknelid (paskharen)\n") +
320
 
                                        string("Alexander Nordfelth (phase)\n") +
321
 
                                        string("Dyluck\n") +
322
 
                                        string("s4kk3\n") +
323
 
                                        string("Trent Lloyd\n") +
324
 
                                        string("Kristian Berg/Ixan\n") +
325
 
                                        string("luusl\n") +
326
 
                                        string("Rikard Bj�rklind\n") +
327
 
                                        string("clairvoyant\n") +
328
 
                                        string("obi\n") +
329
 
                                        string("John Armstrong\n") +
330
 
                                        string("Naga");
331
 
        gtk_label_set_markup(al, Text::acpToUtf8(text).c_str());
 
323
        gtk_paned_set_position(transferPane, transferPanePosition);
332
324
        
333
325
        GtkWidget *dummy;
334
326
        GtkRequisition req;
337
329
        gtk_widget_destroy(dummy);
338
330
        emptyStatusWidth = req.width;
339
331
        
340
 
        gtk_statusbar_push(mainStatus, 0, "Welcome to Wulfor - Reloaded");
 
332
        gtk_statusbar_push(mainStatus, 0, "Welcome to Linux DC++");
 
333
}
 
334
 
 
335
/*
 
336
 * Create tray icon.
 
337
 * @todo: Replace with GtkStatusIcon after GTK+ 2.10 is released and on enough systems.
 
338
 */
 
339
void MainWindow::createTrayIcon_gui()
 
340
{
 
341
        GtkWidget *trayBox, *trayImage, *toggleWindowItem, *quitItem;
 
342
        string iconPath;
 
343
        gint alpha;
 
344
        GdkPixmap *pixmap;
 
345
 
 
346
        trayIcon = GTK_WIDGET(egg_tray_icon_new("Linux DC++"));
 
347
        trayBox = gtk_event_box_new();
 
348
        iconPath = WulforManager::get()->getPath() + "/pixmaps/linuxdcpp-icon.png";
 
349
        trayImage = gtk_image_new_from_file(iconPath.c_str());
 
350
        trayToolTip = gtk_tooltips_new();
 
351
        trayMenu = gtk_menu_new();
 
352
        toggleWindowItem = gtk_menu_item_new_with_label("Show/Hide Interface");
 
353
        quitItem = gtk_menu_item_new_with_label("Quit");
 
354
 
 
355
        // Have to set icon background as transparent manually since eggtrayicon sucks.
 
356
        gdk_pixbuf_render_pixmap_and_mask(gtk_image_get_pixbuf(GTK_IMAGE(trayImage)), NULL, &pixmap, 64);
 
357
        gtk_widget_shape_combine_mask(trayIcon, pixmap, 0, 0);
 
358
        g_object_unref(pixmap);
 
359
 
 
360
        gtk_menu_shell_append(GTK_MENU_SHELL(trayMenu), toggleWindowItem);
 
361
        gtk_menu_shell_append(GTK_MENU_SHELL(trayMenu), quitItem);
 
362
        gtk_container_add(GTK_CONTAINER(trayBox), trayImage);
 
363
        gtk_container_add(GTK_CONTAINER(trayIcon), trayBox);
 
364
 
 
365
        g_signal_connect(G_OBJECT(quitItem), "activate", G_CALLBACK(quitClicked_gui), (gpointer)this);
 
366
        g_signal_connect(G_OBJECT(toggleWindowItem), "activate", G_CALLBACK(onToggleWindowVisibility_gui), (gpointer)this);
 
367
        g_signal_connect(G_OBJECT(trayIcon), "button-press-event", G_CALLBACK(onTrayIconClicked_gui), (gpointer)this);
 
368
 
 
369
        if (WGETI("show-tray-icon"))
 
370
                gtk_widget_show_all(trayIcon);
341
371
}
342
372
 
343
373
GtkWindow *MainWindow::getWindow() {
344
374
        return window;
345
375
}
346
376
 
347
 
gboolean MainWindow::transferClicked_gui (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
 
377
void MainWindow::appendWindowItem(GtkWidget *page, string title)
 
378
{
 
379
        GtkWidget *menuItem = gtk_menu_item_new_with_label(title.c_str());
 
380
        g_object_set_data(G_OBJECT(menuItem), "tabWidget", page);
 
381
        g_signal_connect(G_OBJECT(menuItem), "activate", G_CALLBACK(raisePage), (gpointer)this);
 
382
        gtk_menu_shell_append(GTK_MENU_SHELL(windowMenu), menuItem);
 
383
        gtk_widget_show_all(windowMenu);
 
384
        windowMenuItems[page] = menuItem;
 
385
}
 
386
 
 
387
void MainWindow::removeWindowItem(GtkWidget *page)
 
388
{
 
389
        gtk_container_remove(GTK_CONTAINER(windowMenu), windowMenuItems[page]);
 
390
        windowMenuItems.erase(page);
 
391
}
 
392
 
 
393
void MainWindow::modifyWindowItem(GtkWidget *page, string title)
 
394
{
 
395
        GtkWidget *child = gtk_bin_get_child(GTK_BIN(windowMenuItems[page]));
 
396
        if (child && GTK_IS_LABEL(child))
 
397
                gtk_label_set_text(GTK_LABEL(child), title.c_str());
 
398
}
 
399
 
 
400
void MainWindow::raisePage(GtkMenuItem *item, gpointer data)
 
401
{
 
402
        MainWindow *mw = (MainWindow *)data;
 
403
        GtkWidget *page = (GtkWidget *)g_object_get_data(G_OBJECT(item), "tabWidget");
 
404
        mw->raisePage_gui(page);
 
405
}
 
406
 
 
407
gboolean MainWindow::transferClicked_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
348
408
{
349
409
        if (event->type == GDK_BUTTON_PRESS)
350
410
        {
351
411
                if (event->button == 3)
352
412
                {
353
 
                        MainWindow *mw = (MainWindow*)user_data;
 
413
                        MainWindow *mw = (MainWindow*)data;
354
414
                        GtkTreeSelection *selection;
355
415
                        GtkTreeModel *m = GTK_TREE_MODEL (mw->transferStore);
356
416
                        selection = mw->transferSel;
374
434
                                gtk_widget_set_sensitive (mw->grantExtraSlot, false);
375
435
                                gtk_widget_set_sensitive (mw->removeUser, false);                       
376
436
                        }
377
 
                        ((MainWindow*)user_data)->popup (event, user_data);
 
437
                        mw->popup_gui(mw->popupMenu, event);
378
438
                        return TRUE;
379
439
                }
380
440
        }
381
441
        return FALSE;
382
442
}
383
443
 
384
 
void MainWindow::popup (GdkEventButton *event, gpointer user_data)
 
444
void MainWindow::popup_gui(GtkWidget *menu, GdkEventButton *event)
385
445
{
386
 
    gtk_menu_popup(GTK_MENU (popupMenu), NULL, NULL, NULL, NULL,
387
 
                (event != NULL) ? 1 : 0,
388
 
                gdk_event_get_time((GdkEvent*)event));  
 
446
    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
 
447
                event ? event->button : 0,
 
448
                gdk_event_get_time((GdkEvent*)event));
 
449
        gtk_widget_show_all(menu);
389
450
}
390
451
 
391
452
User::Ptr MainWindow::getSelectedTransfer_gui()
392
453
{
393
454
        GtkTreeSelection *selection;
394
 
        GtkTreeModel *m = GTK_TREE_MODEL (transferStore);
395
 
        selection = transferSel;
396
 
 
397
 
        GList *list = gtk_tree_selection_get_selected_rows (selection, &m);
398
 
        GList *tmp = g_list_first (list);
 
455
        GtkTreeModel *m = GTK_TREE_MODEL(transferStore);
 
456
        GList *list = gtk_tree_selection_get_selected_rows(transferSel, &m);
 
457
        GtkTreePath *path = (GtkTreePath*)g_list_nth_data(list, 0);
399
458
        GtkTreeIter iter;
400
 
        
401
 
        if (!tmp)
 
459
        TransferItem *item;
 
460
 
 
461
        if (!gtk_tree_model_get_iter(m, &iter, path))
402
462
                return NULL;
403
 
        if (!gtk_tree_model_get_iter (m, &iter, (GtkTreePath*)tmp->data))
404
 
                return NULL;    
405
 
        return TreeViewFactory::getValue<gpointer,ConnectionQueueItem*>(m, &iter, COLUMN_USERPTR)->getUser ();
 
463
 
 
464
        gtk_tree_path_free(path);
 
465
        g_list_free(list);
 
466
 
 
467
        item = transferView.getValue<gpointer, TransferItem*>(&iter, "TransferItem");
 
468
        return item->user;
406
469
}
407
470
 
408
 
void MainWindow::onGetFileListClicked_gui (GtkMenuItem *item, gpointer user_data)
 
471
void MainWindow::onGetFileListClicked_gui(GtkMenuItem *item, gpointer data)
409
472
{
410
 
        MainWindow *mw = (MainWindow*)user_data;
411
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
473
        MainWindow *mw = (MainWindow*)data;
 
474
        User::Ptr user = mw->getSelectedTransfer_gui();
412
475
        try 
413
476
        {
414
477
                QueueManager::getInstance()->addList(user, QueueItem::FLAG_CLIENT_VIEW);
418
481
        }
419
482
}
420
483
 
421
 
void MainWindow::onMatchQueueClicked_gui (GtkMenuItem *item, gpointer user_data)
 
484
void MainWindow::onMatchQueueClicked_gui(GtkMenuItem *item, gpointer data)
422
485
{
423
 
        MainWindow *mw = (MainWindow*)user_data;
424
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
486
        MainWindow *mw = (MainWindow*)data;
 
487
        User::Ptr user = mw->getSelectedTransfer_gui();
425
488
        try 
426
489
        {
427
490
                QueueManager::getInstance()->addList(user, QueueItem::FLAG_MATCH_QUEUE);
431
494
        }
432
495
}
433
496
 
434
 
void MainWindow::onPrivateMessageClicked_gui (GtkMenuItem *item, gpointer user_data)
 
497
void MainWindow::onPrivateMessageClicked_gui(GtkMenuItem *item, gpointer data)
435
498
{
436
 
        MainWindow *mw = (MainWindow*)user_data;
437
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
499
        MainWindow *mw = (MainWindow*)data;
 
500
        User::Ptr user = mw->getSelectedTransfer_gui();
438
501
        WulforManager::get()->addPrivMsg_gui(user);
439
502
}
440
503
 
441
 
void MainWindow::onAddFavoriteUserClicked_gui (GtkMenuItem *item, gpointer user_data)
 
504
void MainWindow::onAddFavoriteUserClicked_gui(GtkMenuItem *item, gpointer data)
442
505
{
443
 
        MainWindow *mw = (MainWindow*)user_data;
444
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
506
        MainWindow *mw = (MainWindow*)data;
 
507
        User::Ptr user = mw->getSelectedTransfer_gui();
445
508
        HubManager::getInstance()->addFavoriteUser(user);
446
509
}
447
510
 
448
 
void MainWindow::onGrantExtraSlotClicked_gui (GtkMenuItem *item, gpointer user_data)
 
511
void MainWindow::onGrantExtraSlotClicked_gui(GtkMenuItem *item, gpointer data)
449
512
{
450
 
        MainWindow *mw = (MainWindow*)user_data;
451
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
513
        MainWindow *mw = (MainWindow*)data;
 
514
        User::Ptr user = mw->getSelectedTransfer_gui();
452
515
        UploadManager::getInstance()->reserveSlot(user);
453
516
}
454
517
 
455
 
void MainWindow::onRemoveUserFromQueueClicked_gui (GtkMenuItem *item, gpointer user_data)
 
518
void MainWindow::onRemoveUserFromQueueClicked_gui(GtkMenuItem *item, gpointer data)
456
519
{
457
 
        MainWindow *mw = (MainWindow*)user_data;
458
 
        User::Ptr user = mw->getSelectedTransfer_gui ();
 
520
        MainWindow *mw = (MainWindow*)data;
 
521
        User::Ptr user = mw->getSelectedTransfer_gui();
459
522
        QueueManager::getInstance()->removeSources(user, QueueItem::Source::FLAG_REMOVED);
460
523
}
461
524
 
462
 
void MainWindow::onForceAttemptClicked_gui (GtkMenuItem *item, gpointer user_data)
463
 
{
464
 
 
465
 
        MainWindow *mw = (MainWindow*)user_data;
466
 
        GtkTreeSelection *selection;
467
 
        GtkTreeModel *m = GTK_TREE_MODEL (mw->transferStore);
468
 
        selection = mw->transferSel;
469
 
 
470
 
        GList *list = gtk_tree_selection_get_selected_rows (selection, &m);
471
 
        GList *tmp = g_list_first (list);
472
 
        vector<User::Ptr> user;
473
 
        GtkTreeIter tmpiter;
474
 
        
475
 
        if (!tmp)
476
 
                return;
477
 
        
478
 
        while (1)
479
 
        {
480
 
                if (gtk_tree_model_get_iter (m, &tmpiter, (GtkTreePath*)tmp->data))
481
 
                {
482
 
                        user.push_back (TreeViewFactory::getValue<gpointer,ConnectionQueueItem*>(m, &tmpiter, COLUMN_USERPTR)->getUser ());
483
 
                        gtk_list_store_set(mw->transferStore, &tmpiter, COLUMN_STATUS, "Connecting (forced)...", -1);
484
 
                }
485
 
                
486
 
                tmp = g_list_next (tmp);
487
 
                if (!tmp)
488
 
                        break;
489
 
        }       
490
 
        
491
 
        for (int i=0;i<user.size ();i++)
492
 
                user[i]->connect ();
493
 
}
494
 
 
495
 
void MainWindow::onCloseConnectionClicked_gui (GtkMenuItem *item, gpointer user_data)
496
 
{
497
 
        MainWindow *mw = (MainWindow*)user_data;
498
 
        GtkTreeSelection *selection;
499
 
        GtkTreeModel *m = GTK_TREE_MODEL (mw->transferStore);
500
 
        selection = mw->transferSel;
501
 
 
502
 
        GList *list = gtk_tree_selection_get_selected_rows (selection, &m);
503
 
        GList *tmp = g_list_first (list);
504
 
        vector<User::Ptr> user;
505
 
        vector<bool> isDownload;
506
 
        GtkTreeIter tmpiter;
507
 
        
508
 
        if (!tmp)
509
 
                return;
510
 
        
511
 
        while (1)
512
 
        {
513
 
                if (gtk_tree_model_get_iter (m, &tmpiter, (GtkTreePath*)tmp->data))
514
 
                {
515
 
                        ConnectionQueueItem *qi = TreeViewFactory::getValue<gpointer,ConnectionQueueItem*>(m, &tmpiter, COLUMN_USERPTR);
516
 
                        if (qi->getConnection())
517
 
                        {
518
 
                                if (qi->getConnection()->isSet(UserConnection::FLAG_UPLOAD))
519
 
                                        isDownload.push_back(false);
520
 
                                else
521
 
                                        isDownload.push_back(true);
522
 
                                user.push_back (qi->getUser ());
523
 
                        }
524
 
                }
525
 
                
526
 
                tmp = g_list_next (tmp);
527
 
                if (!tmp)
528
 
                        break;
529
 
        }       
530
 
 
531
 
        for (int i=0;i<user.size ();i++)
532
 
                ConnectionManager::getInstance()->removeConnection(user[i], isDownload[i]);
533
 
}
534
 
 
535
 
void MainWindow::connectClicked_gui(GtkWidget *widget, gpointer data) {
 
525
void MainWindow::onForceAttemptClicked_gui(GtkMenuItem *menuItem, gpointer data)
 
526
{
 
527
        MainWindow *mw = (MainWindow *)data;
 
528
        GtkTreeModel *m = GTK_TREE_MODEL(mw->transferStore);
 
529
        GtkTreeIter iter;
 
530
        GtkTreePath *path;
 
531
        TransferItem *item;
 
532
        GList *list = gtk_tree_selection_get_selected_rows(mw->transferSel, NULL);
 
533
        gint count = gtk_tree_selection_count_selected_rows(mw->transferSel);
 
534
 
 
535
        for (int i = 0; i < count; i++)
 
536
        {
 
537
                path = (GtkTreePath *)g_list_nth_data(list, i);
 
538
                if (gtk_tree_model_get_iter(m, &iter, path))
 
539
                {
 
540
                        item = mw->transferView.getValue<gpointer, TransferItem*>(&iter, "TransferItem");
 
541
                        item->user->connect();
 
542
                        gtk_list_store_set(mw->transferStore, &iter, mw->transferView.col("Status"), "Connecting (forced)...", -1);
 
543
                }
 
544
                gtk_tree_path_free(path);
 
545
        }
 
546
        g_list_free(list);
 
547
}
 
548
 
 
549
void MainWindow::onCloseConnectionClicked_gui(GtkMenuItem *menuItem, gpointer data)
 
550
{
 
551
        MainWindow *mw = (MainWindow *)data;
 
552
        GtkTreeModel *m = GTK_TREE_MODEL(mw->transferStore);
 
553
        GtkTreeIter iter;
 
554
        GtkTreePath *path;
 
555
        TransferItem *item;
 
556
        GList *list = gtk_tree_selection_get_selected_rows(mw->transferSel, NULL);
 
557
        gint count = gtk_tree_selection_count_selected_rows(mw->transferSel);
 
558
 
 
559
        for (int i = 0; i < count; i++)
 
560
        {
 
561
                path = (GtkTreePath *)g_list_nth_data(list, i);
 
562
                if (gtk_tree_model_get_iter(m, &iter, path))
 
563
                {
 
564
                        item = mw->transferView.getValue<gpointer, TransferItem*>(&iter, "TransferItem");
 
565
                        ConnectionManager::getInstance()->removeConnection(item->user, item->isDownload);
 
566
                }
 
567
                gtk_tree_path_free(path);
 
568
        }
 
569
        g_list_free(list);
 
570
}
 
571
 
 
572
void MainWindow::connectClicked_gui(GtkWidget *widget, gpointer data)
 
573
{
 
574
        MainWindow *mw = (MainWindow *)data;
536
575
        int response;
537
576
        string address;
538
577
        
539
 
        gtk_widget_show_all(GTK_WIDGET(connectDialog));
540
 
        response = gtk_dialog_run(connectDialog);
541
 
        gtk_widget_hide(GTK_WIDGET(connectDialog));
 
578
        gtk_widget_show_all(GTK_WIDGET(mw->connectDialog));
 
579
        response = gtk_dialog_run(mw->connectDialog);
 
580
        gtk_widget_hide(GTK_WIDGET(mw->connectDialog));
542
581
        
543
582
        if (response == GTK_RESPONSE_OK) {
544
 
                address = gtk_entry_get_text(connectEntry);
 
583
                address = gtk_entry_get_text(mw->connectEntry);
545
584
                WulforManager::get()->addHub_gui(address);
546
585
        }
547
586
}
557
596
void MainWindow::hashClicked_gui(GtkWidget *widget, gpointer data) {
558
597
        Hash *h = WulforManager::get()->openHashDialog_gui();
559
598
        gtk_dialog_run(GTK_DIALOG(h->getDialog()));
560
 
        WulforManager::get()->deleteDialogEntry_gui();
561
599
}
562
600
 
563
601
void MainWindow::dlQueueClicked_gui(GtkWidget *widget, gpointer data) {
570
608
 
571
609
void MainWindow::finishedDLclicked_gui(GtkWidget *widget, gpointer data)
572
610
{
573
 
        WulforManager *wm;
574
 
        wm->get()->addFinishedTransfers_gui(wm->get()->FINISHED_DOWNLOADS, "Finished Downloads"); 
 
611
        WulforManager *wm = WulforManager::get();
 
612
        wm->addFinishedTransfers_gui("Finished Downloads"); 
575
613
}
576
614
 
577
615
void MainWindow::finishedULclicked_gui(GtkWidget *widget, gpointer data)
578
616
{
579
 
        WulforManager *wm;
580
 
        wm->get()->addFinishedTransfers_gui(wm->get()->FINISHED_UPLOADS, "Finished Uploads");
 
617
        WulforManager *wm = WulforManager::get();
 
618
        wm->addFinishedTransfers_gui("Finished Uploads");
581
619
}
582
620
 
583
 
void MainWindow::settingsClicked_gui(GtkWidget *widget, gpointer data) {
 
621
void MainWindow::settingsClicked_gui(GtkWidget *widget, gpointer data)
 
622
{
 
623
        MainWindow *mw = (MainWindow *)data;
584
624
        Settings *s = WulforManager::get()->openSettingsDialog_gui();
585
625
        typedef Func0<MainWindow> F0;
586
626
        F0 *func;
587
627
 
588
628
        short lastPort = (short)SETTING(IN_PORT);
589
 
        int lastConn = SETTING(CONNECTION_TYPE);        
 
629
        int lastConn = SETTING(CONNECTION_TYPE);
 
630
        bool lastShowProgressSetting = SETTING(SHOW_PROGRESS_BARS);
590
631
        
591
632
        if (gtk_dialog_run(GTK_DIALOG(s->getDialog())) == GTK_RESPONSE_OK) {
592
633
                s->saveSettings_client();
595
636
                if (SETTING(CONNECTION_TYPE) != lastConn || SETTING(IN_PORT) != lastPort) {
596
637
                        Selecter::quit();
597
638
                        
598
 
                        func = new F0(this, &MainWindow::startSocket_client);
 
639
                        func = new F0(mw, &MainWindow::startSocket_client);
599
640
                        WulforManager::get()->dispatchClientFunc(func);
600
 
                }               
 
641
                }
 
642
 
 
643
                if (!lastShowProgressSetting && SETTING(SHOW_PROGRESS_BARS))
 
644
                {
 
645
                        GtkTreeViewColumn *col = gtk_tree_view_get_column(mw->transferView.get(), mw->transferView.col("Status"));
 
646
                        GtkCellRenderer *renderer = gtk_cell_renderer_progress_new();
 
647
                        gtk_tree_view_column_clear(col);
 
648
                        gtk_tree_view_column_pack_start(col, renderer, TRUE);
 
649
                        gtk_tree_view_column_set_attributes(col, renderer, "text", mw->transferView.col("Status"),
 
650
                                "value", mw->transferView.col("Progress"), NULL);
 
651
                }
 
652
                else if (lastShowProgressSetting && !SETTING(SHOW_PROGRESS_BARS))
 
653
                {
 
654
                        GtkTreeViewColumn *col = gtk_tree_view_get_column(mw->transferView.get(), mw->transferView.col("Status"));
 
655
                        GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
 
656
                        gtk_tree_view_column_clear(col);
 
657
                        gtk_tree_view_column_pack_start(col, renderer, TRUE);
 
658
                        gtk_tree_view_column_set_attributes(col, renderer, "text", mw->transferView.col("Status"), NULL);
 
659
                }
 
660
 
 
661
                if (WGETI("show-tray-icon"))
 
662
                        gtk_widget_show_all(mw->trayIcon);
 
663
                else
 
664
                        gtk_widget_hide_all(mw->trayIcon);
601
665
        }
602
666
 
603
667
        gtk_widget_destroy(s->getDialog());
604
668
        delete s;
605
669
}
606
670
 
607
 
void MainWindow::quitClicked_gui(GtkWidget *widget, gpointer data) {
608
 
        gboolean retVal;                // Not interested in the value though.
609
 
        g_signal_emit_by_name(G_OBJECT(window), "delete-event", NULL, &retVal);
610
 
}
611
 
 
612
 
void MainWindow::aboutClicked_gui(GtkWidget *widget, gpointer data) {
613
 
        gtk_widget_show_all(GTK_WIDGET(aboutDialog));
614
 
        gtk_dialog_run(aboutDialog);
615
 
        gtk_widget_hide(GTK_WIDGET(aboutDialog));
616
 
}
617
 
 
618
 
gboolean MainWindow::deleteWindow_gui(
619
 
        GtkWidget *widget, GdkEvent *event, gpointer data)
620
 
{
 
671
void MainWindow::quitClicked_gui(GtkWidget *widget, gpointer data)
 
672
{
 
673
        MainWindow *mw = (MainWindow *)data;
 
674
        gboolean retVal; // Not interested in the value, though.
 
675
        g_signal_emit_by_name(G_OBJECT(mw->getWindow()), "delete-event", NULL, &retVal);
 
676
}
 
677
 
 
678
void MainWindow::aboutClicked_gui(GtkWidget *widget, gpointer data)
 
679
{
 
680
        MainWindow *mw = (MainWindow *)data;
 
681
        gtk_widget_show_all(GTK_WIDGET(mw->aboutDialog));
 
682
        gtk_dialog_run(mw->aboutDialog);
 
683
        gtk_widget_hide(GTK_WIDGET(mw->aboutDialog));
 
684
}
 
685
 
 
686
gboolean MainWindow::deleteWindow_gui(GtkWidget *widget, GdkEvent *event, gpointer data)
 
687
{
 
688
        MainWindow *mw = (MainWindow *)data;
621
689
        int response;
622
 
        
623
 
        if (!BOOLSETTING(CONFIRM_EXIT)) {
 
690
 
 
691
        if (!BOOLSETTING(CONFIRM_EXIT))
 
692
        {
 
693
                mw->transferView.saveSettings();
 
694
                WulforManager::get()->deleteAllDialogEntries();
 
695
                WulforManager::get()->deleteAllBookEntries();
624
696
                gtk_main_quit();
625
697
                return TRUE;
626
698
        }
627
699
        
628
 
        gtk_widget_show_all(GTK_WIDGET(exitDialog));
629
 
        response = gtk_dialog_run(exitDialog);
630
 
        gtk_widget_hide(GTK_WIDGET(exitDialog));
 
700
        gtk_widget_show_all(GTK_WIDGET(mw->exitDialog));
 
701
        response = gtk_dialog_run(mw->exitDialog);
 
702
        gtk_widget_hide(GTK_WIDGET(mw->exitDialog));
631
703
 
632
 
        if (response == GTK_RESPONSE_OK) {
 
704
        if (response == GTK_RESPONSE_OK)
 
705
        {
 
706
                mw->transferView.saveSettings();
 
707
                WulforManager::get()->deleteAllDialogEntries();
 
708
                WulforManager::get()->deleteAllBookEntries();
633
709
                gtk_main_quit();
634
710
                return TRUE;
635
711
        }
637
713
        return TRUE;
638
714
}
639
715
 
640
 
void MainWindow::switchPage_gui(GtkNotebook *notebook, 
641
 
        GtkNotebookPage *page, guint page_num, gpointer user_data)
642
 
{
643
 
        BookEntry *b = WulforManager::get()->getBookEntry_gui(page_num);
644
 
        if (b)
645
 
                b->switchedPage();
646
 
}
647
 
 
648
 
void MainWindow::openHub_gui(
649
 
        string server, string nick, string desc, string password)
 
716
void MainWindow::openHub_gui(string server, string nick, string desc, string password)
650
717
{
651
718
        WulforManager::get()->addHub_gui(server, nick, desc, password);
652
719
}
686
753
        if (SETTING(OPEN_FAVORITE_HUBS))
687
754
                WulforManager::get()->addFavoriteHubs_gui();
688
755
        if (BOOLSETTING(OPEN_FINISHED_DOWNLOADS)) {
689
 
                WulforManager::get()->addFinishedTransfers_gui(
690
 
                        WulforManager::FINISHED_DOWNLOADS, "Finished Downloads"); 
 
756
                WulforManager::get()->addFinishedTransfers_gui("Finished Downloads"); 
691
757
        }
692
758
}
693
759
 
761
827
        typedef Func6<MainWindow, string, string, string, string, string, string> func_t;
762
828
        func_t *func = new func_t(this, &MainWindow::setStats_gui, status1, status2, status3, status4, status5, status6);
763
829
        WulforManager::get()->dispatchGuiFunc(func);
 
830
 
 
831
        if (WGETI("show-tray-icon"))
 
832
        {
 
833
                string toolTip = status5 + status6;
 
834
                typedef Func1<MainWindow, string> F1;
 
835
                F1 *f1 = new F1(this, &MainWindow::updateTrayToolTip_gui, toolTip);
 
836
                WulforManager::get()->dispatchGuiFunc(f1);
 
837
        }
764
838
}
765
839
 
766
840
//From QueueManagerListener
799
873
        for (i=0; i<gtk_notebook_get_n_pages(book); i++)
800
874
                if (page == gtk_notebook_get_nth_page(book, i)) pageNum = i;
801
875
                
802
 
        assert(pageNum != -1);
 
876
        dcassert(pageNum != -1);
803
877
        gtk_notebook_remove_page(book, pageNum);
804
878
}
805
879
 
809
883
        for (i=0; i<gtk_notebook_get_n_pages(book); i++)
810
884
                if (page == gtk_notebook_get_nth_page(book, i)) pageNum = i;
811
885
                
812
 
        assert(pageNum != -1);
 
886
        dcassert(pageNum != -1);
813
887
        gtk_notebook_set_current_page(book, pageNum);
814
888
}
815
889
 
855
929
        setStatus_gui(dlStatus, dl);
856
930
}
857
931
 
858
 
void MainWindow::updateTransfer_gui(string id, connection_t type, ConnectionQueueItem *item, 
859
 
        string status, string time, string speed, string file, string size, string path)
860
 
{
861
 
        GtkTreeIter iter;
862
 
        findId_gui(id, &iter);
863
 
        
864
 
        if (!gtk_list_store_iter_is_valid(transferStore, &iter)) {
865
 
                gtk_list_store_append(transferStore, &iter);
866
 
                gtk_list_store_set(transferStore, &iter, COLUMN_ID, id.c_str(), -1);
867
 
        }
868
 
 
869
 
        if (type == CONNECTION_UL) {
870
 
                gtk_list_store_set(transferStore, &iter, COLUMN_TYPE, uploadPic, -1);
871
 
        }
872
 
        if (type == CONNECTION_DL) {
873
 
                gtk_list_store_set(transferStore, &iter, COLUMN_TYPE, downloadPic, -1);
874
 
        }
875
 
        if (item) {
876
 
                gtk_list_store_set(transferStore, &iter, COLUMN_USER, item->getUser()->getNick().c_str(), COLUMN_USERPTR, (gpointer)item, -1);
877
 
        }
878
 
        if (status != "") {
879
 
                gtk_list_store_set(transferStore, &iter, COLUMN_STATUS, status.c_str(), -1);
880
 
        }
881
 
        if (time != "") {
882
 
                gtk_list_store_set(transferStore, &iter, COLUMN_TIMELEFT, time.c_str(), -1);
883
 
        }
884
 
        if (speed != "") {
885
 
                gtk_list_store_set(transferStore, &iter, COLUMN_SPEED, speed.c_str(), -1);
886
 
        }
887
 
        if (file != "") {
888
 
                gtk_list_store_set(transferStore, &iter, COLUMN_FILENAME, file.c_str(), -1);
889
 
        }
890
 
        if (size != "") {
891
 
                gtk_list_store_set(transferStore, &iter, COLUMN_SIZE, size.c_str(), -1);
892
 
        }
893
 
        if (path != "") {
894
 
                gtk_list_store_set(transferStore, &iter, COLUMN_PATH, path.c_str(), -1);
895
 
        }
896
 
}
897
 
 
898
 
void MainWindow::removeTransfer_gui(string id) {
899
 
        GtkTreeIter iter;
900
 
        findId_gui(id, &iter);
901
 
        
902
 
        if (gtk_list_store_iter_is_valid(transferStore, &iter)) {
903
 
                gtk_list_store_remove(transferStore, &iter);
904
 
        }
905
 
}
906
 
 
907
 
void MainWindow::findId_gui(string id, GtkTreeIter *iter) {
908
 
        gtk_tree_model_get_iter_first(GTK_TREE_MODEL(transferStore), iter);
909
 
 
910
 
        while (gtk_list_store_iter_is_valid(transferStore, iter)) {
911
 
                char *t;
912
 
                string text;
913
 
                gtk_tree_model_get(GTK_TREE_MODEL(transferStore), iter, 
914
 
                        COLUMN_ID, &t, -1);
915
 
                text = t;
916
 
                g_free(t);
917
 
 
918
 
                if (id == text) return;
919
 
 
920
 
                //When the connection is just created we don't know the type.
921
 
                //Thus we have a special "connecting" id that matches any other id
922
 
                //from the same user, as well as separate upload and download ids.
923
 
                if (text.find("$Connecting", 0) != string::npos || 
924
 
                        id.find("$Connecting", 0) != string::npos)
925
 
                {
926
 
                        if (text.substr(0, text.find('$', 0)) == 
927
 
                                id.substr(0, id.find('$', 0)))
928
 
                        {
929
 
                                gtk_list_store_set(transferStore, iter, 
930
 
                                        COLUMN_ID, id.c_str(), -1);
931
 
                                return;
932
 
                        }
933
 
                }
934
 
 
935
 
                gtk_tree_model_iter_next(GTK_TREE_MODEL(transferStore), iter);
936
 
        }
937
 
}
938
 
 
939
 
string MainWindow::getId_client(ConnectionQueueItem *item) {
940
 
        string ret = item->getUser()->getNick() + "$" + 
941
 
                item->getUser()->getLastHubAddress();
942
 
 
943
 
        //The $ is a special char in DC that can't be used in nicks.
944
 
        //Thus nobody can make an evil nick to mess with this list.
945
 
        if (item->getConnection()) {
946
 
                if (item->getConnection()->isSet(UserConnection::FLAG_UPLOAD)) {
947
 
                        ret += "$Upload";
948
 
                } else {
949
 
                        ret += "$Download";
950
 
                }
951
 
        } else {
952
 
                ret += "$Connecting";
953
 
        }
954
 
 
955
 
        return ret;
956
 
}
957
 
 
958
 
string MainWindow::getId_client(Transfer *t) {
959
 
        assert (t->getUserConnection());
960
 
        assert (t->getUserConnection()->getCQI());
961
 
 
962
 
        return getId_client(t->getUserConnection()->getCQI());
963
 
}
964
 
 
965
 
void MainWindow::transferComplete_client(Transfer *t) {
966
 
        string status, id = getId_client(t);
967
 
 
968
 
        if (t->getUserConnection()->isSet(UserConnection::FLAG_UPLOAD)) {
969
 
                status = "Upload finished, idle...";
970
 
        } else {
971
 
                status = "Download finished, idle...";
972
 
        }
973
 
 
974
 
        UFunc *func;
975
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, status,
976
 
                "Done", " ", "", "", "");
977
 
        WulforManager::get()->dispatchGuiFunc(func);
978
 
}
979
 
 
980
 
 
981
 
void MainWindow::openFList_gui(GtkWidget *widget, gpointer data)
982
 
{
 
932
void MainWindow::openFileList_gui(GtkWidget *widget, gpointer data)
 
933
{
 
934
        MainWindow *mw = (MainWindow *)data;
983
935
        User::Ptr user;
984
936
        string path, filename;
985
937
 
986
 
        if (widget == GTK_WIDGET(openFList))
 
938
        gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(mw->flistDialog), 
 
939
                Text::toT(Util::getDataPath() + "FileLists/").c_str());
 
940
        gtk_widget_show_all(GTK_WIDGET(mw->flistDialog));
 
941
        int ret = gtk_dialog_run(mw->flistDialog);
 
942
        gtk_widget_hide(GTK_WIDGET(mw->flistDialog));
 
943
 
 
944
        if (ret == GTK_RESPONSE_OK)
987
945
        {
988
 
                gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(flistDialog), 
989
 
                        Text::toT(Util::getDataPath() + "FileLists/").c_str());
990
 
                gtk_widget_show_all(GTK_WIDGET(flistDialog));
991
 
                int ret = gtk_dialog_run(flistDialog);
992
 
                gtk_widget_hide(GTK_WIDGET(flistDialog));
993
 
        
994
 
                if (ret != GTK_RESPONSE_OK && ret != GTK_RESPONSE_ACCEPT) return;
995
 
        
996
 
                path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(flistDialog));
 
946
                path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(mw->flistDialog));
997
947
                filename = g_path_get_basename(path.c_str());
998
948
                if (filename.substr(filename.length()-8, 8) != ".xml.bz2" && Util::getFileExt(filename) != ".DcLst")
999
949
                        return;
1000
950
                user = new User(filename);
1001
 
        }
1002
 
        else
1003
 
        {
1004
 
                user = new User("My List");
1005
 
                path = Util::getDataPath() + "files.xml.bz2";
1006
 
                try
1007
 
                {
1008
 
                        // Test if file list already exists
1009
 
                        ::File myFileList(path, ::File::READ, ::File::OPEN);
1010
 
                        myFileList.close();
1011
 
                }
1012
 
                catch (const FileException&)
1013
 
                {
1014
 
                        // No existing file list; create one instead
1015
 
                        ShareManager::getInstance()->getOwnListFile();
1016
 
                }
1017
 
        }
 
951
                WulforManager::get()->addShareBrowser_gui(user, path);
 
952
        }
 
953
}
1018
954
 
 
955
void MainWindow::openOwnList_gui(GtkWidget *widget, gpointer data)
 
956
{
 
957
        MainWindow *mw = (MainWindow *)data;
 
958
        User::Ptr user;
 
959
        string path, filename;
 
960
        user = new User(SETTING(NICK));
 
961
        path = Util::getDataPath() + "files.xml.bz2";
 
962
        try
 
963
        {
 
964
                // Test if file list already exists
 
965
                ::File myFileList(path, ::File::READ, ::File::OPEN);
 
966
                myFileList.close();
 
967
        }
 
968
        catch (const FileException&)
 
969
        {
 
970
                // No existing file list; create one instead
 
971
                ShareManager::getInstance()->getOwnListFile();
 
972
        }
1019
973
        WulforManager::get()->addShareBrowser_gui(user, path);
1020
974
}
1021
975
 
 
976
void MainWindow::updateTransfer_gui(TransferItem *item)
 
977
{
 
978
        dcassert(item);
 
979
 
 
980
        GtkTreeIter iter;
 
981
        GtkTreePath *path;
 
982
 
 
983
        path = gtk_tree_row_reference_get_path(item->rowRef);
 
984
        if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(transferStore), &iter, path))
 
985
        {
 
986
                gtk_tree_path_free(path);
 
987
                return;
 
988
        }
 
989
        gtk_tree_path_free(path);
 
990
 
 
991
        if (item->isSet(TransferItem::MASK_FILE) && !item->file.empty())
 
992
                gtk_list_store_set(transferStore, &iter, transferView.col("Filename"), item->file.c_str(), -1);
 
993
 
 
994
        if (item->isSet(TransferItem::MASK_PATH) && !item->path.empty())
 
995
                gtk_list_store_set(transferStore, &iter, transferView.col("Path"), item->path.c_str(), -1);
 
996
 
 
997
        if (item->isSet(TransferItem::MASK_STATUS) && !item->status.empty())
 
998
                gtk_list_store_set(transferStore, &iter, transferView.col("Status"), item->status.c_str(), -1);
 
999
 
 
1000
        if (item->isSet(TransferItem::MASK_TIME) && !item->time.empty())
 
1001
                gtk_list_store_set(transferStore, &iter, transferView.col("Time Left"), item->time.c_str(), -1);
 
1002
 
 
1003
        if (item->isSet(TransferItem::MASK_SORT_ORDER) && !item->sortOrder.empty())
 
1004
                gtk_list_store_set(transferStore, &iter, transferView.col("Sort Order"), item->sortOrder.c_str(), -1);
 
1005
 
 
1006
        if (item->isSet(TransferItem::MASK_SIZE) && item->size >= 0)
 
1007
        {
 
1008
                gtk_list_store_set(transferStore, &iter,
 
1009
                        transferView.col("Size"), Util::formatBytes(item->size).c_str(),
 
1010
                        transferView.col("Size Order"), item->size,
 
1011
                        -1);
 
1012
        }
 
1013
 
 
1014
        if (item->isSet(TransferItem::MASK_SPEED) && item->speed >= 0)
 
1015
        {
 
1016
                gtk_list_store_set(transferStore, &iter,
 
1017
                        transferView.col("Speed"),  Util::formatBytes(item->speed).append("/s").c_str(),
 
1018
                        transferView.col("Speed Order"), item->speed,
 
1019
                        -1);
 
1020
        }
 
1021
 
 
1022
        if (item->isSet(TransferItem::MASK_PROGRESS) && item->progress >= 0 && item->progress <= 100)
 
1023
                gtk_list_store_set(transferStore, &iter, transferView.col("Progress"), item->progress, -1);
 
1024
}
 
1025
 
 
1026
void MainWindow::removeTransfer_gui(TransferItem *item)
 
1027
{
 
1028
        GtkTreeIter iter;
 
1029
        GtkTreePath *path;
 
1030
 
 
1031
        path = gtk_tree_row_reference_get_path(item->rowRef);
 
1032
        if (gtk_tree_model_get_iter(GTK_TREE_MODEL(transferStore), &iter, path))
 
1033
                gtk_list_store_remove(transferStore, &iter);
 
1034
 
 
1035
        gtk_tree_path_free(path);
 
1036
        gtk_tree_row_reference_free(item->rowRef);
 
1037
        delete item;
 
1038
        item = NULL;
 
1039
}
 
1040
 
 
1041
MainWindow::TransferItem* MainWindow::getTransferItem(UserID id)
 
1042
{
 
1043
        TransferItem *item;
 
1044
 
 
1045
        if (transferMap.find(id) == transferMap.end())
 
1046
        {
 
1047
                transferMap[id] = item = new TransferItem(id.first, id.second);
 
1048
                typedef Func1<MainWindow, TransferItem *> F1;
 
1049
                F1 *f1 = new F1(this, &MainWindow::insertTransfer_gui, item);
 
1050
                WulforManager::get()->dispatchGuiFunc(f1);
 
1051
        }
 
1052
        else
 
1053
                item = transferMap[id];
 
1054
 
 
1055
        item->updateMask = 0;
 
1056
        return item;
 
1057
}
 
1058
 
 
1059
void MainWindow::insertTransfer_gui(TransferItem *item)
 
1060
{
 
1061
        dcassert(item);
 
1062
 
 
1063
        GtkTreeIter iter;
 
1064
        GtkTreePath *path;
 
1065
        GtkTreeModel *m = GTK_TREE_MODEL(transferStore);
 
1066
 
 
1067
        gtk_list_store_append(transferStore, &iter);
 
1068
        path = gtk_tree_model_get_path(m, &iter);
 
1069
        item->rowRef = gtk_tree_row_reference_new(m, path);
 
1070
        gtk_tree_path_free(path);
 
1071
 
 
1072
        if (item->isDownload)
 
1073
                gtk_list_store_set(transferStore, &iter, transferView.col("Icon"), downloadPic, -1);
 
1074
        else
 
1075
                gtk_list_store_set(transferStore, &iter, transferView.col("Icon"), uploadPic, -1);
 
1076
 
 
1077
        gtk_list_store_set(transferStore, &iter,
 
1078
                transferView.col("User"), item->nicks.c_str(),
 
1079
                transferView.col("Hub Name"), item->hubs.c_str(),
 
1080
                transferView.col("TransferItem"), (gpointer)item,
 
1081
                -1);
 
1082
}
 
1083
 
 
1084
void MainWindow::transferComplete_client(Transfer *t)
 
1085
{
 
1086
        bool isDownload = t->getUserConnection()->isSet(UserConnection::FLAG_DOWNLOAD);
 
1087
        UserID id(t->getUserConnection()->getUser(), isDownload);
 
1088
        TransferItem *item = getTransferItem(id);
 
1089
 
 
1090
        if (isDownload)
 
1091
                item->setStatus("Download finished, idle...");
 
1092
        else
 
1093
                item->setStatus("Upload finished, idle...");
 
1094
        item->setTime("Done");
 
1095
        item->setProgress(100);
 
1096
        item->setSortOrder("w" + item->nicks + item->hubs);
 
1097
 
 
1098
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
 
1099
        WulforManager::get()->dispatchGuiFunc(func);
 
1100
}
 
1101
 
1022
1102
void MainWindow::refreshFList_gui(GtkWidget *widget, gpointer data)
1023
1103
{
1024
 
        //fingers crossed this works, I have no ideas if this works
1025
 
        typedef Func3<ShareManager, bool, bool, bool> F0;
1026
 
        F0 *func = new F0(ShareManager::getInstance(), &ShareManager::refresh, true, true, false);
1027
 
        WulforManager::get()->dispatchGuiFunc(func);
 
1104
        ShareManager::getInstance()->setDirty();
 
1105
        // Function would simply not work when put into GUI queue.
 
1106
        ShareManager::getInstance()->refresh(true, true, false);
 
1107
        ShareManager::getInstance()->getOwnListFile();
1028
1108
}
1029
1109
 
1030
 
 
1031
1110
//From Connection manager
1032
 
void MainWindow::on(ConnectionManagerListener::Added, ConnectionQueueItem *item) throw() {
1033
 
        string status = "Connecting...";
1034
 
        string id = getId_client(item);
1035
 
 
1036
 
        UFunc *func;
1037
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, 
1038
 
                item, status, "", "", "", "", "");
1039
 
        WulforManager::get()->dispatchGuiFunc(func);
1040
 
}
1041
 
 
1042
 
void MainWindow::on(ConnectionManagerListener::Removed, ConnectionQueueItem *item) throw() {
1043
 
        string id = getId_client(item);
1044
 
 
1045
 
        typedef Func1 <MainWindow, string> F1;
1046
 
        F1 *func = new F1(this, &MainWindow::removeTransfer_gui, id);
1047
 
        WulforManager::get()->dispatchGuiFunc(func);
1048
 
}
1049
 
 
1050
 
void MainWindow::on(ConnectionManagerListener::Failed, ConnectionQueueItem *item, const string &reason) throw() {
1051
 
        string status = reason;
1052
 
        string id = getId_client(item);
1053
 
 
1054
 
        UFunc *func;
1055
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, status,
1056
 
                "", "", "", "", "");
1057
 
        WulforManager::get()->dispatchGuiFunc(func);
1058
 
}
1059
 
 
1060
 
void MainWindow::on(ConnectionManagerListener::StatusChanged, ConnectionQueueItem *item) throw() {
1061
 
        string status;
1062
 
        string id = getId_client(item);
1063
 
 
1064
 
        if (item->getState() == ConnectionQueueItem::CONNECTING) {
1065
 
                status = "Connecting...";
1066
 
        } else {
1067
 
                status = "Waiting to retry...";
 
1111
void MainWindow::on(ConnectionManagerListener::Added, ConnectionQueueItem *cqi) throw()
 
1112
{
 
1113
        UserID id(cqi->getUser(), cqi->getDownload());
 
1114
        TransferItem *item = getTransferItem(id);
 
1115
        item->setStatus("Connecting...");
 
1116
        item->setProgress(0);
 
1117
        item->setSortOrder("w" + item->nicks + item->hubs);
 
1118
 
 
1119
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
 
1120
        WulforManager::get()->dispatchGuiFunc(func);
 
1121
}
 
1122
 
 
1123
void MainWindow::on(ConnectionManagerListener::Removed, ConnectionQueueItem *cqi) throw()
 
1124
{
 
1125
        UserID id(cqi->getUser(), cqi->getDownload());
 
1126
 
 
1127
        if (transferMap.find(id) != transferMap.end())
 
1128
        {
 
1129
                TransferItem *item = transferMap[id];
 
1130
                transferMap.erase(id);
 
1131
                typedef Func1 <MainWindow, TransferItem *> F1;
 
1132
                F1 *func = new F1(this, &MainWindow::removeTransfer_gui, item);
 
1133
                WulforManager::get()->dispatchGuiFunc(func);
1068
1134
        }
1069
 
 
1070
 
        UFunc *func;
1071
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, status,
1072
 
                "", "", "", "", "");
 
1135
}
 
1136
 
 
1137
void MainWindow::on(ConnectionManagerListener::Failed, ConnectionQueueItem *cqi, const string &reason) throw()
 
1138
{
 
1139
        UserID id(cqi->getUser(), cqi->getDownload());
 
1140
        TransferItem *item = getTransferItem(id);
 
1141
        item->setStatus(reason, true);
 
1142
        item->setSortOrder("w" + item->nicks + item->hubs);
 
1143
 
 
1144
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
 
1145
        WulforManager::get()->dispatchGuiFunc(func);
 
1146
}
 
1147
 
 
1148
void MainWindow::on(ConnectionManagerListener::StatusChanged, ConnectionQueueItem *cqi) throw()
 
1149
{
 
1150
        UserID id(cqi->getUser(), cqi->getDownload());
 
1151
        TransferItem *item = getTransferItem(id);
 
1152
 
 
1153
        if (cqi->getState() == ConnectionQueueItem::CONNECTING)
 
1154
                item->setStatus("Connecting...");
 
1155
        else
 
1156
                item->setStatus("Waiting to retry...");
 
1157
 
 
1158
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1073
1159
        WulforManager::get()->dispatchGuiFunc(func);
1074
1160
}
1075
1161
 
1076
1162
//From Download manager
1077
 
void MainWindow::on(DownloadManagerListener::Starting, Download *dl) throw() {
1078
 
        string status, size, path, file, target;
1079
 
        string id = getId_client(dl);
1080
 
 
1081
 
        size = Util::formatBytes(dl->getSize());
1082
 
        target = Text::acpToUtf8(dl->getTarget());
1083
 
        status = "Download starting...";
 
1163
void MainWindow::on(DownloadManagerListener::Starting, Download *dl) throw()
 
1164
{
 
1165
        UserID id(dl->getUserConnection()->getUser(), TRUE);
 
1166
        TransferItem *item = getTransferItem(id);
 
1167
        string target = Text::acpToUtf8(dl->getTarget());
1084
1168
 
1085
1169
        if (dl->isSet(Download::FLAG_USER_LIST))
1086
 
        {
1087
 
                file = "Filelist";
1088
 
                path = "";
1089
 
        }
 
1170
                item->setFile("Filelist");
 
1171
        else if (dl->isSet(Download::FLAG_TREE_DOWNLOAD))
 
1172
                item->setFile("TTH: " + Util::getFileName(target));
1090
1173
        else
1091
 
        {
1092
 
                file = Util::getFileName(target);
1093
 
                path = Util::getFilePath(target);
1094
 
        }
1095
 
 
1096
 
        UFunc *func;
1097
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_DL, NULL, status,
1098
 
                "", "", file, size, path);
 
1174
                item->setFile(Util::getFileName(target));
 
1175
 
 
1176
        item->setPath(Util::getFilePath(target));
 
1177
        item->setStatus("Download starting...");
 
1178
        item->setSize(dl->getSize());
 
1179
        item->setSortOrder("d" + item->nicks + item->hubs);
 
1180
 
 
1181
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1099
1182
        WulforManager::get()->dispatchGuiFunc(func);
1100
1183
}
1101
1184
 
1102
 
void MainWindow::on(DownloadManagerListener::Tick, const Download::List &list) throw() {
1103
 
        string id, status, timeLeft, speed;
 
1185
void MainWindow::on(DownloadManagerListener::Tick, const Download::List &list) throw()
 
1186
{
 
1187
        string status, time, bytes;
 
1188
        double percent;
 
1189
        Download* dl;
1104
1190
        Download::List::const_iterator it;
1105
 
        
1106
 
        for (it = list.begin(); it != list.end(); it++) {
1107
 
                Download* dl = *it;
 
1191
        TransferItem *item;
 
1192
 
 
1193
        for (it = list.begin(); it != list.end(); it++)
 
1194
        {
 
1195
                dl = *it;
1108
1196
                ostringstream stream;
1109
 
 
1110
 
                id = getId_client(dl); 
1111
 
 
1112
 
                string bytes = Util::formatBytes(dl->getPos());
1113
 
                double percent = (double)(dl->getPos() * 100.0) / dl->getSize();
1114
 
                string time = Util::formatSeconds((GET_TICK() - dl->getStart()) / 1000);
 
1197
                UserID id(dl->getUserConnection()->getUser(), TRUE);
 
1198
                item = getTransferItem(id);
 
1199
 
 
1200
                bytes = Util::formatBytes(dl->getPos());
 
1201
                percent = (double)(dl->getPos() * 100.0) / dl->getSize();
 
1202
                time = Util::formatSeconds((GET_TICK() - dl->getStart()) / 1000);
1115
1203
                stream << setiosflags(ios::fixed) << setprecision(1);
1116
1204
                stream << "Downloaded " << bytes << " (" << percent << "%) in " << time;
1117
1205
 
1118
 
                timeLeft = Util::formatSeconds(dl->getSecondsLeft());
1119
 
                speed = Util::formatBytes(dl->getRunningAverage()) + "/s";
1120
 
 
1121
 
                if (dl->isSet(Download::FLAG_ZDOWNLOAD)) {
1122
 
                        status = "* " + stream.str();
1123
 
                } else {
1124
 
                        status = stream.str();
1125
 
                }
1126
 
 
1127
 
                UFunc *func;
1128
 
                func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, 
1129
 
                        status, timeLeft, speed, "", "", "");
 
1206
                status.clear();
 
1207
/*              Future flags in DC++ > 0.674
 
1208
                if (dl->getUserConnection()->isSecure())
 
1209
                        status += "[S]";
 
1210
                if (dl->isSet(Download::FLAG_TTH_CHECK))
 
1211
                        status += "[T]";
 
1212
*/              if (dl->isSet(Download::FLAG_ZDOWNLOAD))
 
1213
                        status += "[Z]";
 
1214
                if (dl->isSet(Download::FLAG_ROLLBACK))
 
1215
                        status += "[R]";
 
1216
                if (!status.empty())
 
1217
                        status += " ";
 
1218
                status += stream.str();
 
1219
 
 
1220
                item->setStatus(status);
 
1221
                item->setTime(Util::formatSeconds(dl->getSecondsLeft()));
 
1222
                item->setSpeed(dl->getRunningAverage());
 
1223
                item->setProgress((int)percent);
 
1224
 
 
1225
                UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1130
1226
                WulforManager::get()->dispatchGuiFunc(func);
1131
1227
        }
1132
1228
}
1133
1229
 
1134
 
void MainWindow::on(DownloadManagerListener::Complete, Download *dl) throw() {
 
1230
void MainWindow::on(DownloadManagerListener::Complete, Download *dl) throw()
 
1231
{
1135
1232
        transferComplete_client(dl);
1136
1233
}
1137
1234
 
1138
 
void MainWindow::on(DownloadManagerListener::Failed, Download *dl, const string &reason) throw() {
1139
 
        string status, size, file, path, target;
1140
 
        string id = getId_client(dl); 
1141
 
 
1142
 
        status = reason;
1143
 
        size = Util::formatBytes(dl->getSize());
1144
 
        target = Text::acpToUtf8(dl->getTarget());
 
1235
void MainWindow::on(DownloadManagerListener::Failed, Download *dl, const string &reason) throw()
 
1236
{
 
1237
        UserID id(dl->getUserConnection()->getUser(), TRUE);
 
1238
        TransferItem *item = getTransferItem(id);
 
1239
        string target = Text::acpToUtf8(dl->getTarget());
1145
1240
 
1146
1241
        if (dl->isSet(Download::FLAG_USER_LIST))
1147
 
        {
1148
 
                file = "Filelist";
1149
 
                path = "";
1150
 
        }
 
1242
                item->setFile("Filelist");
 
1243
        else if (dl->isSet(Download::FLAG_TREE_DOWNLOAD))
 
1244
                item->setFile("TTH: " + Util::getFileName(target));
1151
1245
        else
1152
 
        {
1153
 
                file = Util::getFileName(target);
1154
 
                path = Util::getFilePath(target);
1155
 
        }
1156
 
 
1157
 
        UFunc *func;
1158
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, 
1159
 
                status, "", "", file, size, path);
 
1246
                item->setFile(Util::getFileName(target));
 
1247
 
 
1248
        item->setPath(Util::getFilePath(target));
 
1249
        item->setStatus(reason, true);
 
1250
        item->setSize(dl->getSize());
 
1251
        item->setSortOrder("w" + item->nicks + item->hubs);
 
1252
 
 
1253
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1160
1254
        WulforManager::get()->dispatchGuiFunc(func);
1161
1255
}
1162
1256
 
1163
1257
//From Upload manager
1164
 
void MainWindow::on(UploadManagerListener::Starting, Upload *ul) throw() {
1165
 
        string status, size, path, file, target;
1166
 
        string id = getId_client(ul);
1167
 
 
1168
 
        size = Util::formatBytes(ul->getSize());
1169
 
        target = Text::acpToUtf8(ul->getFileName());
1170
 
        status = "Upload starting...";
1171
 
 
1172
 
        if (ul->isSet(Upload::FLAG_USER_LIST))
1173
 
        {
1174
 
                file = "Filelist";
1175
 
                path = "";
1176
 
        }
 
1258
void MainWindow::on(UploadManagerListener::Starting, Upload *ul) throw()
 
1259
{
 
1260
        UserID id(ul->getUserConnection()->getUser(), FALSE);
 
1261
        TransferItem *item = getTransferItem(id);
 
1262
        string target = Text::acpToUtf8(ul->getFileName());
 
1263
 
 
1264
        if (ul->isSet(Download::FLAG_USER_LIST))
 
1265
                item->setFile("Filelist");
 
1266
        else if (ul->isSet(Download::FLAG_TREE_DOWNLOAD))
 
1267
                item->setFile("TTH: " + Util::getFileName(target));
1177
1268
        else
1178
 
        {
1179
 
                file = Util::getFileName(target);
1180
 
                path = Util::getFilePath(target);
1181
 
        }
1182
 
 
1183
 
        UFunc *func;
1184
 
        func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_UL, NULL, status,
1185
 
                "", "", file, size, path);
 
1269
                item->setFile(Util::getFileName(target));
 
1270
 
 
1271
        item->setPath(Util::getFilePath(target));
 
1272
        item->setStatus("Upload starting...");
 
1273
        item->setSize(ul->getSize());
 
1274
        item->setSortOrder("u" + item->nicks + item->hubs);
 
1275
 
 
1276
        UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1186
1277
        WulforManager::get()->dispatchGuiFunc(func);
1187
1278
}
1188
1279
 
1189
 
void MainWindow::on(UploadManagerListener::Tick, const Upload::List &list) throw() {
1190
 
        string id, status, timeLeft, speed;
 
1280
void MainWindow::on(UploadManagerListener::Tick, const Upload::List &list) throw()
 
1281
{
 
1282
        string status, time, bytes;
 
1283
        double percent;
 
1284
        Upload* ul;
1191
1285
        Upload::List::const_iterator it;
1192
 
        
1193
 
        for (it = list.begin(); it != list.end(); it++) {
1194
 
                Upload* ul = *it;
 
1286
        TransferItem *item;
 
1287
 
 
1288
        for (it = list.begin(); it != list.end(); it++)
 
1289
        {
 
1290
                ul = *it;
1195
1291
                ostringstream stream;
1196
 
 
1197
 
                id = getId_client(ul); 
1198
 
 
1199
 
                string bytes = Util::formatBytes(ul->getPos());
1200
 
                double percent = (double)(ul->getPos() * 100.0) / ul->getSize();
1201
 
                string time = Util::formatSeconds((GET_TICK() - ul->getStart()) / 1000);
 
1292
                UserID id(ul->getUserConnection()->getUser(), FALSE);
 
1293
                item = getTransferItem(id);
 
1294
 
 
1295
                bytes = Util::formatBytes(ul->getPos());
 
1296
                percent = (double)(ul->getPos() * 100.0) / ul->getSize();
 
1297
                time = Util::formatSeconds((GET_TICK() - ul->getStart()) / 1000);
1202
1298
                stream << setiosflags(ios::fixed) << setprecision(1);
1203
1299
                stream << "Uploaded " << bytes << " (" << percent << "%) in " << time;
1204
1300
 
1205
 
                timeLeft = Util::formatSeconds(ul->getSecondsLeft());
1206
 
                speed = Util::formatBytes(ul->getRunningAverage()) + "/s";
1207
 
 
1208
 
                if (ul->isSet(Download::FLAG_ZDOWNLOAD)) {
1209
 
                        status = "* " + stream.str();
1210
 
                } else {
1211
 
                        status = stream.str();
1212
 
                }
1213
 
 
1214
 
                UFunc *func;
1215
 
                func = new UFunc(this, &MainWindow::updateTransfer_gui, id, CONNECTION_NA, NULL, 
1216
 
                        status, timeLeft, speed, "", "", "");
 
1301
                status.clear();
 
1302
/*              Future flags in DC++ > 0.674
 
1303
                if (ul->getUserConnection()->isSecure())
 
1304
                        status += "[S]";
 
1305
*/              if (ul->isSet(Upload::FLAG_ZUPLOAD))
 
1306
                        status += "[Z]";
 
1307
                if (!status.empty())
 
1308
                        status += " ";
 
1309
                status += stream.str();
 
1310
 
 
1311
                item->setStatus(status);
 
1312
                item->setTime(Util::formatSeconds(ul->getSecondsLeft()));
 
1313
                item->setSpeed(ul->getRunningAverage());
 
1314
                item->setProgress((int)percent);
 
1315
 
 
1316
                UFunc *func = new UFunc(this, &MainWindow::updateTransfer_gui, item);
1217
1317
                WulforManager::get()->dispatchGuiFunc(func);
1218
1318
        }
1219
1319
}
1220
1320
 
1221
 
void MainWindow::on(UploadManagerListener::Complete, Upload *ul) throw() {
 
1321
void MainWindow::on(UploadManagerListener::Complete, Upload *ul) throw()
 
1322
{
1222
1323
        transferComplete_client(ul);
1223
1324
}
1224
1325
 
1229
1330
        WulforManager::get()->dispatchGuiFunc(func);
1230
1331
}
1231
1332
 
 
1333
void MainWindow::onTrayIconClicked_gui(GtkWidget *widget, GdkEventButton *event, gpointer data)
 
1334
{
 
1335
        MainWindow *mw = (MainWindow *)data;
 
1336
 
 
1337
        if (event->type == GDK_BUTTON_PRESS && event->button == 1)
 
1338
                onToggleWindowVisibility_gui(NULL, data);
 
1339
        else if (event->type == GDK_BUTTON_PRESS && event->button == 3)
 
1340
                mw->popup_gui(mw->trayMenu, event);
 
1341
}
 
1342
 
 
1343
void MainWindow::onToggleWindowVisibility_gui(GtkMenuItem *item, gpointer data)
 
1344
{
 
1345
        GtkWindow *win = ((MainWindow *)data)->getWindow();
 
1346
 
 
1347
        if (GTK_WIDGET_VISIBLE(win))
 
1348
                gtk_widget_hide_all(GTK_WIDGET(win));
 
1349
        else
 
1350
                gtk_widget_show_all(GTK_WIDGET(win));
 
1351
}
 
1352
 
 
1353
void MainWindow::updateTrayToolTip_gui(string toolTip)
 
1354
{
 
1355
        gtk_tooltips_set_tip(trayToolTip, trayIcon, toolTip.c_str(), NULL);
 
1356
}