« back to all changes in this revision
Viewing changes to src/FolderList.cc
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Enrico Zini
- Date: 2004-10-31 14:50:26 UTC
- Revision ID: james.westby@ubuntu.com-20041031145026-9z3xr78y8j3o5uis
Tags: upstream-0.5
Import upstream version 0.5
- files added:
- autom4te.cache
- debian
- libbuffy
- src
added
removed
src/FolderList.cc
1
/*
2
* Folder list widget
3
*
4
* Copyright (C) 2003 Enrico Zini <enrico@debian.org>
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; either version 2 of the License, or
9
* (at your option) any later version.
10
*
11
* This program is distributed in the hope that it will be useful,
12
* but WITHOUT ANY WARRANTY; without even the implied warranty of
13
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
* GNU General Public License for more details.
15
*
16
* You should have received a copy of the GNU General Public License
17
* along with this program; if not, write to the Free Software
18
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
*/
20
21
#pragma implementation
22
23
#include "FolderList.h"
24
25
#include <map>
26
27
#include <sigc++/sigc++.h>
28
#include <gtkmm/treemodel.h>
29
#include <gtkmm/treemodelfilter.h>
30
31
#include "Environment.h"
32
33
using namespace std;
34
35
/*
36
void FolderList::on_filter_changed()
37
{
38
filter = filterEdit.get_text();
39
updateList();
40
}
41
42
void FolderList::on_document_changed()
43
{
44
updateList();
45
}
46
47
void FolderList::on_add_tag(Tag tag)
48
{
49
Glib::RefPtr<Gtk::TreeSelection> sel = itemList.get_selection();
50
51
// Build the list of selected items
52
selected.clear();
53
54
Gtk::TreeSelection::ListHandle_Path lhp = sel->get_selected_rows();
55
for (Gtk::TreeSelection::ListHandle_Path::const_iterator i = lhp.begin(); i != lhp.end(); i++)
56
{
57
Gtk::TreeModel::Row row = *itemListModel->get_iter(*i);
58
Glib::ustring s = row[itemListModelColumns.name];
59
selected.push_back(s);
60
}
61
62
// Build the Change
63
TagcollChange<string, Tag> change;
64
for (vector<string>::const_iterator i = selected.begin();
65
i != selected.end(); i++)
66
{
67
TagSet ts = doc.collection().getTagsetForFolder(*i);
68
change.insert(make_pair(*i, ts + tag));
69
}
70
71
// Post the change
72
do_signal_request_tagcoll_change(change);
73
}
74
75
void FolderList::on_remove_tag(Tag tag)
76
{
77
Glib::RefPtr<Gtk::TreeSelection> sel = itemList.get_selection();
78
79
// Build the list of selected items
80
selected.clear();
81
82
Gtk::TreeSelection::ListHandle_Path lhp = sel->get_selected_rows();
83
for (Gtk::TreeSelection::ListHandle_Path::const_iterator i = lhp.begin(); i != lhp.end(); i++)
84
{
85
Gtk::TreeModel::Row row = *itemListModel->get_iter(*i);
86
Glib::ustring s = row[itemListModelColumns.name];
87
selected.push_back(s);
88
}
89
90
// Build the Change
91
TagcollChange<string, Tag> change;
92
for (vector<string>::const_iterator i = selected.begin();
93
i != selected.end(); i++)
94
{
95
TagSet ts = doc.collection().getTagsetForFolder(*i);
96
change.insert(make_pair(*i, ts - tag));
97
}
98
99
// Post the change
100
do_signal_request_tagcoll_change(change);
101
}
102
103
void FolderList::do_signal_request_tagcoll_change(TagcollChange<string, Tag> change)
104
{
105
signal_request_tagcoll_change().emit(change);
106
}
107
108
void FolderList::do_signal_request_tagset_merge()
109
{
110
signal_request_tagset_merge().emit();
111
}
112
113
void FolderList::do_signal_request_tagset_intersect()
114
{
115
signal_request_tagset_intersect().emit();
116
}
117
118
void FolderList::do_signal_request_item_copy()
119
{
120
signal_request_item_copy().emit();
121
}
122
123
void FolderList::do_signal_request_item_move()
124
{
125
signal_request_item_move().emit();
126
}
127
128
void FolderList::do_signal_select_tagset(TagSet tagset)
129
{
130
//debug("SRTA %.*s %.*s\n", PFSTR(item), PFSTR(tag));
131
signal_select_tagset().emit(tagset);
132
}
133
134
void FolderList::do_signal_select_tagset_other_panel(TagSet tagset)
135
{
136
//debug("SRTA %.*s %.*s\n", PFSTR(item), PFSTR(tag));
137
signal_select_tagset_other_panel().emit(tagset);
138
}
139
*/
140
141
bool FolderList::on_event(GdkEvent* e)
142
{
143
if (e->type == GDK_BUTTON_PRESS && e->button.button > 1)
144
{
145
Gtk::TreeModel::Path path;
146
Gtk::TreeViewColumn* column;
147
int cell_x, cell_y;
148
if (folderList.get_path_at_pos(
149
(int)e->button.x, (int)e->button.y,
150
path, column,
151
cell_x, cell_y))
152
{
153
// Clicked on an item
154
debug("Cell %d, %d\n", cell_x, cell_y);
155
156
Gtk::TreeModel::Row row = *folderListModel->get_iter(path);
157
MailFolder folder = row[folderListModelColumns.folder];
158
verbose("Clicked on %.*s\n", PFSTR(folder.path()));
159
160
folderList.get_selection()->select(row);
161
162
/*
163
Glib::ustring tag = row[itemListModelColumns.name];
164
TagSet ts = row[itemListModelColumns.tags];
165
166
debug("Name: %.*s, %d tags\n", PFSTR(tag), ts.size());
167
168
Glib::RefPtr<Gtk::TreeSelection> sel = itemList.get_selection();
169
int rows = sel->count_selected_rows();
170
171
itemPopup.items().clear();
172
173
if (rows == 1)
174
{
175
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Select this tag set",
176
sigc::bind< TagSet >(
177
sigc::mem_fun(*this, &FolderList::do_signal_select_tagset), ts)));
178
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Select this tag set in the other panel",
179
sigc::bind< TagSet >(
180
sigc::mem_fun(*this, &FolderList::do_signal_select_tagset_other_panel), ts)));
181
}
182
else
183
{
184
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Merge",
185
sigc::mem_fun(*this, &FolderList::do_signal_request_tagset_merge)));
186
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Intersect",
187
sigc::mem_fun(*this, &FolderList::do_signal_request_tagset_intersect)));
188
}
189
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Copy to other panel",
190
sigc::mem_fun(*this, &FolderList::do_signal_request_item_copy)));
191
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Move to other panel",
192
sigc::mem_fun(*this, &FolderList::do_signal_request_item_move)));
193
194
TagMenu<TagcollDocument<string> >* addMenu = new TagMenu<TagcollDocument<string> >();
195
addMenu->set_manage();
196
addMenu->populateUnselected(doc, ts);
197
string stag = tag;
198
addMenu->signal_selected().connect(
199
sigc::mem_fun(*this, &FolderList::on_add_tag));
200
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("_Add...", *addMenu));
201
202
if (!ts.empty())
203
{
204
itemPopup.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
205
for (TagSet::const_iterator i = ts.begin();
206
i != ts.end(); i++)
207
itemPopup.items().push_back(Gtk::Menu_Helpers::MenuElem("Remove " + i->fullname(),
208
sigc::bind<Tag>(
209
sigc::mem_fun(*this, &FolderList::on_remove_tag), *i)));
210
}
211
212
itemPopup.popup(e->button.button, e->button.time);
213
214
//printf("Menu finished\n");
215
216
//delete addMenu;
217
*/
218
return true;
219
} else {
220
// Clicked outside
221
warning("itemList.get_path_at_pos failed\n");
222
return false;
223
}
224
}
225
return false;
226
}
227
228
void FolderList::on_row_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn*)
229
{
230
if(const Gtk::TreeIter iter = folderList.get_model()->get_iter(path))
231
{
232
Gtk::TreeModel::Row row = *iter;
233
MailFolder folder = row[folderListModelColumns.folder];
234
signal_open_folder().emit(folder);
235
/*
236
warning("Activated %.*s\n", PFSTR(folder.path()));
237
string cmdline = "x-terminal-emulator -e mutt -f " + folder.path();
238
try {
239
warning("Running: %.*s\n", PFSTR(cmdline));
240
Environment::get().spawnCommand(cmdline);
241
} catch (SystemException& e) {
242
warning("%s: %.*s\n", e.type(), PFSTR(e.desc()));
243
}
244
*/
245
}
246
}
247
248
bool FolderList::filter_row(const Gtk::TreeModel::const_iterator& iter)
249
{
250
// Hide empty folders
251
Gtk::TreeModel::Row row = *iter;
252
253
if (row[folderListModelColumns.msg_unread] > 0)
254
return true;
255
256
if (viewImportant && row[folderListModelColumns.msg_flagged] > 0)
257
return true;
258
259
if (viewRead && row[folderListModelColumns.msg_total] > 0)
260
return true;
261
262
return viewEmpty;
263
264
}
265
266
267
FolderList::FolderList()
268
: viewEmpty(true), viewRead(true)
269
{
270
// Add the TreeView, inside a ScrolledWindow
271
scrolledFolderList.add(folderList);
272
273
// Only show the scrollbars when they are necessary:
274
scrolledFolderList.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
275
276
pack_start(scrolledFolderList, Gtk::PACK_EXPAND_WIDGET);
277
278
// Create the Tree model
279
folderListModel = Gtk::ListStore::create(folderListModelColumns);
280
281
filteredModel = Gtk::TreeModelFilter::create(
282
folderListModel,
283
folderListModel->get_path(folderListModel->children().begin()));
284
filteredModel->set_visible_func(sigc::mem_fun(*this, &FolderList::filter_row));
285
286
sortedModel = Gtk::TreeModelSort::create(
287
filteredModel);
288
289
//folderList.set_model(folderListModel);
290
//folderList.set_model(filteredModel);
291
folderList.set_model(sortedModel);
292
293
294
// Add the view columns
295
Gtk::TreeViewColumn* column;
296
int count;
297
298
count = folderList.append_column("Name", folderListModelColumns.name);
299
column = folderList.get_column(count - 1);
300
column->set_sort_column(folderListModelColumns.name);
301
302
count = folderList.append_column("New", folderListModelColumns.msg_new);
303
column = folderList.get_column(count - 1);
304
column->set_sort_column(folderListModelColumns.msg_new);
305
306
count = folderList.append_column("Unread", folderListModelColumns.msg_unread);
307
column = folderList.get_column(count - 1);
308
column->set_sort_column(folderListModelColumns.msg_unread);
309
310
count = folderList.append_column("Total", folderListModelColumns.msg_total);
311
column = folderList.get_column(count - 1);
312
column->set_sort_column(folderListModelColumns.msg_total);
313
314
count = folderList.append_column("Flagged", folderListModelColumns.msg_flagged);
315
column = folderList.get_column(count - 1);
316
column->set_sort_column(folderListModelColumns.msg_flagged);
317
318
/*
319
folderList.get_column(0)->set_resizable(true);
320
folderList.get_column(1)->set_resizable(true);
321
*/
322
323
Glib::RefPtr<Gtk::TreeSelection> folderListSelection = folderList.get_selection();
324
folderListSelection->set_mode(Gtk::SELECTION_SINGLE);
325
326
folderList.add_events(Gdk::BUTTON_PRESS_MASK);
327
folderList.signal_event().connect(sigc::mem_fun(*this, &FolderList::on_event));
328
folderList.signal_row_activated().connect(sigc::mem_fun(*this, &FolderList::on_row_activated));
329
330
// Fill the list
331
//updateList();
332
333
/*
334
folderList.signal_focus_in_event().connect(sigc::mem_fun(*this, &FolderList::on_focus_in));
335
filterEdit.signal_changed().connect(sigc::mem_fun(*this, &FolderList::on_filter_changed));
336
doc.signal_changed().connect(sigc::mem_fun(*this, &FolderList::on_document_changed));
337
*/
338
}
339
340
void FolderList::consume(MailFolder& folder)
341
{
342
Gtk::TreeModel::Row row = *(folderListModel->append());
343
row[folderListModelColumns.folder] = folder;
344
row[folderListModelColumns.name] = folder.name();
345
346
//int msg_total, msg_unread, msg_new, msg_flagged;
347
//folder.computeStatistics(&msg_total, &msg_unread, &msg_new, &msg_flagged);
348
if (folder.changed())
349
{
350
folder.updateStatistics();
351
352
row[folderListModelColumns.msg_new] = folder.getMsgNew();
353
row[folderListModelColumns.msg_unread] = folder.getMsgUnread();
354
row[folderListModelColumns.msg_total] = folder.getMsgTotal();
355
row[folderListModelColumns.msg_flagged] = folder.getMsgFlagged();
356
}
357
}
358
359
void FolderList::clear()
360
{
361
folderListModel->clear();
362
}
363
364
void FolderList::do_update()
365
{
366
debug("FolderList::do_update\n");
367
for (Gtk::TreeModel::Children::const_iterator i = folderListModel->children().begin();
368
i != folderListModel->children().end(); i++)
369
{
370
Gtk::TreeModel::Row row = *i;
371
MailFolder folder = row[folderListModelColumns.folder];
372
//row[folderListModelColumns.name] = folder.name();
373
374
folder.updateStatistics();
375
376
row[folderListModelColumns.msg_new] = folder.getMsgNew();
377
row[folderListModelColumns.msg_unread] = folder.getMsgUnread();
378
row[folderListModelColumns.msg_total] = folder.getMsgTotal();
379
row[folderListModelColumns.msg_flagged] = folder.getMsgFlagged();
380
}
381
}
382
383
bool FolderList::do_timer_tick()
384
{
385
do_update();
386
return true;
387
}
388
389
void FolderList::configureFilter(bool viewEmpty, bool viewRead, bool viewImportant)
390
{
391
this->viewEmpty = viewEmpty;
392
this->viewRead = viewRead;
393
this->viewImportant = viewImportant;
394
filteredModel->refilter();
395
}
396
397
398
/*
399
void FolderList::on_itemList_drag_data_get(
400
const Glib::RefPtr<Gdk::DragContext>&, Gtk::SelectionData& selection_data, guint, guint)
401
{
402
std::map<std::string, TagSet > sel = getSelection();
403
if (sel.size())
404
{
405
Glib::ustring str;
406
for (std::map< string, TagSet >::const_iterator i = sel.begin();
407
i != sel.end(); i++)
408
{
409
str += i->first;
410
411
for (TagSet::const_iterator j = i->second.begin();
412
j != i->second.end(); j++)
413
if (j == i->second.begin())
414
str += ": " + j->fullname();
415
else
416
str += ", " + j->fullname();
417
418
str += "\n";
419
}
420
421
selection_data.set(selection_data.get_target(), 8, (const guchar*)str.data(), str.size());
422
}
423
}
424
425
void FolderList::on_itemList_drop_drag_data_received(
426
const Glib::RefPtr<Gdk::DragContext>& context, int, int, const Gtk::SelectionData& selection_data, guint, guint time)
427
{
428
if ((selection_data.get_length() >= 0) && (selection_data.get_format() == 8))
429
{
430
string type = selection_data.get_data_type();
431
warning("Type: %.*s\n", PFSTR(type));
432
Glib::ustring data((const char*)selection_data.get_data(), selection_data.get_length());
433
Tag tag = doc.vocabulary().findTag(data);
434
warning("Received: %.*s [%sfound in vocabulary]\n", PFSTR(data), tag ? "" : "not ");
435
436
if (type == "TAG" && tag)
437
{
438
std::map< std::string, TagSet > sel = getSelection();
439
440
TagcollChange<string, Tag> change;
441
442
for (std::map< string, TagSet >::const_iterator i = sel.begin();
443
i != sel.end(); i++)
444
change.insert(make_pair(i->first, i->second + tag));
445
446
doc.applyChange(change);
447
}
448
else if (type == "TAGCOLL")
449
{
450
}
451
}
452
453
context->drag_finish(false, false, time);
454
}
455
456
457
458
void FolderList::updateList()
459
{
460
time_t start = time(NULL);
461
462
std::map< std::string, TagSet > sel = getSelection();
463
464
if (_tagset.empty())
465
{
466
OpSet<string> items = doc.collection().getUntaggedFolders();
467
468
Gtk::TreeModel::Row row;
469
itemListModel->clear();
470
for (OpSet<string>::const_iterator i = items.begin(); i != items.end(); i++)
471
{
472
if (filter.empty() || i->find(filter) != string::npos)
473
{
474
row = *(itemListModel->append());
475
row[itemListModelColumns.name] = *i;
476
row[itemListModelColumns.tags] = TagSet();
477
if (sel.find(*i) != sel.end())
478
itemList.get_selection()->select(row);
479
}
480
}
481
} else {
482
std::map< string, OpSet<Tag> > items = doc.collection().getCompanionFoldersAndTagsets(_tagset);
483
484
Gtk::TreeModel::Row row;
485
itemListModel->clear();
486
for (std::map< string, OpSet<Tag> >::const_iterator i = items.begin(); i != items.end(); i++)
487
{
488
if (filter.empty() || i->first.find(filter) != string::npos)
489
{
490
row = *(itemListModel->append());
491
row[itemListModelColumns.name] = i->first;
492
row[itemListModelColumns.tags] = i->second;
493
if (sel.find(i->first) != sel.end())
494
itemList.get_selection()->select(row);
495
}
496
}
497
}
498
499
time_t end = time(NULL);
500
if (end != start)
501
fprintf(stderr, "FolderList::updateList: %d seconds\n", (end-start));
502
}
503
504
map< string, TagSet > FolderList::getAllFolders()
505
{
506
std::map< string, TagSet > res;
507
508
for (Gtk::TreeModel::Children::const_iterator i = itemListModel->children().begin();
509
i != itemListModel->children().end(); i++)
510
{
511
Gtk::TreeModel::Row row = *i;
512
Glib::ustring s = row[itemListModelColumns.name];
513
TagSet ts = row[itemListModelColumns.tags];
514
res.insert(make_pair(s, ts));
515
debug("Found: %.*s\n", PFSTR(s));
516
}
517
518
return res;
519
}
520
521
map< string, TagSet > FolderList::getSelection()
522
{
523
Glib::RefPtr<Gtk::TreeSelection> itemSelection = itemList.get_selection();
524
Gtk::TreeSelection::ListHandle_Path lhp = itemSelection->get_selected_rows();
525
std::map< string, TagSet > res;
526
527
for (Gtk::TreeSelection::ListHandle_Path::const_iterator i = lhp.begin(); i != lhp.end(); i++)
528
{
529
Gtk::TreeModel::Row row = *itemListModel->get_iter(*i);
530
Glib::ustring s = row[itemListModelColumns.name];
531
TagSet ts = row[itemListModelColumns.tags];
532
res.insert(make_pair(s, ts));
533
}
534
535
return res;
536
537
/ *
538
FolderListSelectionDataGatherer data(*this);
539
itemSelection->selected_foreach(sigc::slot(data, &FolderListSelectionDataGatherer::selected_row_callback));
540
* /
541
//return data.data();
542
}
543
544
int FolderList::getSelectionSize()
545
{
546
Glib::RefPtr<Gtk::TreeSelection> itemSelection = itemList.get_selection();
547
return itemSelection->count_selected_rows();
548
}
549
550
void FolderList::do_selection_changed()
551
{
552
signal_selection_changed().emit();
553
}
554
555
void FolderList::do_focus_in()
556
{
557
signal_focus_in().emit();
558
}
559
560
bool FolderList::on_focus_in(GdkEventFocus*)
561
{
562
//debug("FOCUS IN\n");
563
do_focus_in();
564
return false;
565
}
566
*/
567
568
// vim:set ts=4 sw=4:
Loggerhead is a web-based interface for Breezy
Version: 2.0.1