9 #define YUILogComponent "gtk"
10 #include <yui/Libyui_config.h>
14 #include "YSelectionWidget.h"
15 #include "YGSelectionStore.h"
16 #include "ygtktreeview.h"
30 YGTreeView (YWidget *ywidget, YWidget *parent,
const std::string &label,
bool tree)
31 :
YGScrolledWidget (ywidget, parent, label, YD_VERT, YGTK_TYPE_TREE_VIEW, NULL),
34 gtk_tree_view_set_headers_visible (getView(), FALSE);
39 gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_BROWSE);
41 connect (getSelection(),
"changed", G_CALLBACK (selection_changed_cb),
this);
42 connect (getWidget(),
"row-activated", G_CALLBACK (activated_cb),
this);
43 connect (getWidget(),
"right-click", G_CALLBACK (right_click_cb),
this);
46 markColumn = -1; m_count = NULL;
48 g_signal_connect (getWidget(),
"map", G_CALLBACK (block_init_cb),
this);
52 {
if (m_blockTimeout) g_source_remove (m_blockTimeout); }
54 inline GtkTreeView *getView()
55 {
return GTK_TREE_VIEW (getWidget()); }
56 inline GtkTreeSelection *getSelection()
57 {
return gtk_tree_view_get_selection (getView()); }
59 void addTextColumn (
int iconCol,
int textCol)
60 { addTextColumn (
"", YAlignUnchanged, iconCol, textCol); }
62 void addTextColumn (
const std::string &header, YAlignmentType align,
int icon_col,
int text_col)
66 case YAlignBegin: xalign = 0.0;
break;
67 case YAlignCenter: xalign = 0.5;
break;
68 case YAlignEnd: xalign = 1.0;
break;
69 case YAlignUnchanged:
break;
72 GtkTreeViewColumn *column = gtk_tree_view_column_new();
73 gtk_tree_view_column_set_title (column, header.c_str());
75 GtkCellRenderer *renderer;
76 renderer = gtk_cell_renderer_pixbuf_new();
77 gtk_tree_view_column_pack_start (column, renderer, FALSE);
78 gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", icon_col, NULL);
80 renderer = gtk_cell_renderer_text_new();
81 gtk_tree_view_column_pack_start (column, renderer, TRUE);
82 gtk_tree_view_column_set_attributes (column, renderer,
"text", text_col, NULL);
84 g_object_set (renderer,
"xalign", xalign, NULL);
86 gtk_tree_view_column_set_resizable (column, TRUE);
87 gtk_tree_view_append_column (getView(), column);
88 if (gtk_tree_view_get_search_column (getView()) == -1)
89 gtk_tree_view_set_search_column (getView(), text_col);
92 void addCheckColumn (
int check_col)
94 GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
95 g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (check_col));
96 GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (
97 NULL, renderer,
"active", check_col, NULL);
98 gtk_tree_view_column_set_cell_data_func (column, renderer, inconsistent_mark_cb,
this, NULL);
99 g_signal_connect (G_OBJECT (renderer),
"toggled",
100 G_CALLBACK (toggled_cb),
this);
102 gtk_tree_view_column_set_resizable (column, TRUE);
103 gtk_tree_view_append_column (getView(), column);
104 if (markColumn == -1)
105 markColumn = check_col;
109 { gtk_tree_view_set_model (getView(), getModel()); }
111 void addCountWidget (YWidget *yparent)
113 bool mainWidget = !yparent || !strcmp (yparent->widgetClass(),
"YVBox") || !strcmp (yparent->widgetClass(),
"YReplacePoint");
115 m_count = gtk_label_new (
"0");
116 GtkWidget *hbox = YGTK_HBOX_NEW(4);
117 gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
119 GtkWidget *label = gtk_label_new (_(
"Total selected:"));
121 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
122 gtk_box_pack_start (GTK_BOX (hbox), m_count, FALSE, TRUE, 0);
123 gtk_box_pack_start (GTK_BOX (YGWidget::getWidget()), hbox, FALSE, TRUE, 0);
124 gtk_widget_show_all (hbox);
130 if (!m_count)
return;
133 static gboolean
foreach (
134 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
138 gtk_tree_model_get (model, iter, pThis->markColumn, &mark, -1);
140 int count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model),
"count"));
141 g_object_set_data (G_OBJECT (model),
"count", GINT_TO_POINTER (count+1));
147 GtkTreeModel *model = getModel();
148 g_object_set_data (G_OBJECT (model),
"count", 0);
149 gtk_tree_model_foreach (model, inner::foreach,
this);
151 int count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model),
"count"));
152 gchar *str = g_strdup_printf (
"%d", count);
153 gtk_label_set_text (GTK_LABEL (m_count), str);
157 void focusItem (YItem *item,
bool select)
160 getTreeIter (item, &iter);
164 GtkTreePath *path = gtk_tree_model_get_path (getModel(), &iter);
165 gtk_tree_view_expand_to_path (getView(), path);
167 if (gtk_tree_selection_get_mode (getSelection()) != GTK_SELECTION_MULTIPLE)
168 gtk_tree_view_scroll_to_cell (getView(), path, NULL, TRUE, 0.5, 0);
169 gtk_tree_path_free (path);
171 gtk_tree_selection_select_iter (getSelection(), &iter);
174 gtk_tree_selection_unselect_iter (getSelection(), &iter);
177 void unfocusAllItems()
180 gtk_tree_selection_unselect_all (getSelection());
186 static gboolean foreach_unmark (
187 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
190 pThis->setRowMark (iter, pThis->markColumn, FALSE);
195 gtk_tree_model_foreach (getModel(), inner::foreach_unmark,
this);
198 YItem *getFocusItem()
201 if (gtk_tree_selection_get_selected (getSelection(), NULL, &iter))
202 return getYItem (&iter);
206 virtual bool _immediateMode() {
return true; }
207 virtual bool _shrinkable() {
return false; }
208 virtual bool _recursiveSelection() {
return false; }
210 void setMark (GtkTreeIter *iter, YItem *yitem, gint column,
bool state,
bool recursive)
212 setRowMark (iter, column, state);
213 yitem->setSelected (state);
216 for (YItemConstIterator it = yitem->childrenBegin();
217 it != yitem->childrenEnd(); it++) {
219 getTreeIter (*it, &_iter);
220 setMark (&_iter, *it, column, state,
true);
224 void toggleMark (GtkTreePath *path, gint column)
227 if (!gtk_tree_model_get_iter (getModel(), &iter, path))
230 gtk_tree_model_get (getModel(), &iter, column, &state, -1);
233 YItem *yitem = getYItem (&iter);
234 setMark (&iter, yitem, column, state, _recursiveSelection());
236 emitEvent (YEvent::ValueChanged);
241 virtual unsigned int getMinSize (YUIDimension dim)
244 return YGUtils::getCharsHeight (getWidget(), _shrinkable() ? 2 : 5);
249 static gboolean block_selected_timeout_cb (gpointer data)
252 pThis->m_blockTimeout = 0;
258 if (m_blockTimeout) g_source_remove (m_blockTimeout);
259 m_blockTimeout = g_timeout_add_full (G_PRIORITY_LOW, 50, block_selected_timeout_cb,
this, NULL);
262 static void block_init_cb (GtkWidget *widget,
YGTreeView *pThis)
263 { pThis->blockSelected(); }
267 static bool all_marked (GtkTreeModel *model, GtkTreeIter *iter,
int mark_col)
270 GtkTreeIter child_iter;
271 if (gtk_tree_model_iter_children (model, &child_iter, iter))
273 gtk_tree_model_get (model, &child_iter, mark_col, &marked, -1);
274 if (!marked)
return false;
275 all_marked (model, &child_iter, mark_col);
276 }
while (gtk_tree_model_iter_next (model, &child_iter));
280 static void inconsistent_mark_cb (GtkTreeViewColumn *column,
281 GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
285 gtk_tree_model_get (model, iter, pThis->markColumn, &marked, -1);
286 gboolean consistent = !marked || all_marked (model, iter, pThis->markColumn);
287 g_object_set (G_OBJECT (cell),
"inconsistent", !consistent, NULL);
290 static void selection_changed_cb (GtkTreeSelection *selection,
YGTreeView *pThis)
293 static gboolean foreach_sync_select (
294 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
297 GtkTreeSelection *selection = pThis->getSelection();
298 bool sel = gtk_tree_selection_iter_is_selected (selection, iter);
299 pThis->getYItem (iter)->setSelected (sel);
304 if (pThis->m_blockTimeout)
return;
305 if (pThis->markColumn == -1)
306 gtk_tree_model_foreach (pThis->getModel(), inner::foreach_sync_select, pThis);
307 if (pThis->_immediateMode())
308 pThis->emitEvent (YEvent::SelectionChanged, IF_NOT_PENDING_EVENT);
311 static void activated_cb (GtkTreeView *tree_view, GtkTreePath *path,
314 if (pThis->markColumn >= 0)
315 pThis->toggleMark (path, pThis->markColumn);
318 if (gtk_tree_view_row_expanded (tree_view, path))
319 gtk_tree_view_collapse_row (tree_view, path);
321 gtk_tree_view_expand_row (tree_view, path, FALSE);
323 pThis->emitEvent (YEvent::Activated);
327 static void toggled_cb (GtkCellRendererToggle *renderer, gchar *path_str,
330 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
331 gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (renderer),
"column"));
332 pThis->toggleMark (path, column);
333 gtk_tree_path_free (path);
336 if (gtk_tree_path_get_depth (path) >= 2)
337 gtk_widget_queue_draw (pThis->getWidget());
341 { pThis->emitEvent (YEvent::ContextMenuActivated); }
345 #include "YGDialog.h"
346 #include <gdk/gdkkeysyms.h>
352 YGTable (YWidget *parent, YTableHeader *headers,
bool multiSelection)
353 : YTable (NULL, headers, multiSelection),
354 YGTreeView (
this, parent, std::string(),
false)
356 gtk_tree_view_set_headers_visible (getView(), TRUE);
357 gtk_tree_view_set_rules_hint (getView(), columns() > 1);
358 ygtk_tree_view_set_empty_text (YGTK_TREE_VIEW (getView()), _(
"No entries."));
360 gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_MULTIPLE);
362 GType types [columns()*2];
363 for (
int i = 0; i < columns(); i++) {
365 types[t+0] = GDK_TYPE_PIXBUF;
366 types[t+1] = G_TYPE_STRING;
367 addTextColumn (header(i), alignment (i), t, t+1);
369 createStore (columns()*2, types);
375 YAlignmentType lastAlign = alignment (columns()-1);
376 if (lastAlign == YAlignCenter || lastAlign == YAlignEnd)
377 gtk_tree_view_append_column (getView(), gtk_tree_view_column_new());
379 g_signal_connect (getWidget(),
"key-press-event", G_CALLBACK (key_press_event_cb),
this);
382 void setSortable (
bool sortable)
384 if (!sortable && !gtk_widget_get_realized (getWidget()))
387 GList *columns = gtk_tree_view_get_columns (getView());
388 for (GList *i = columns; i; i = i->next, n++) {
389 GtkTreeViewColumn *column = (GtkTreeViewColumn *) i->data;
390 if (n >= YGTable::columns())
396 gtk_tree_sortable_set_sort_func (
397 GTK_TREE_SORTABLE (getModel()), index, tree_sort_cb,
398 GINT_TO_POINTER (index), NULL);
399 gtk_tree_view_column_set_sort_column_id (column, index);
402 gtk_tree_view_column_set_sort_column_id (column, -1);
404 g_list_free (columns);
407 void setCell (GtkTreeIter *iter,
int column,
const YTableCell *cell)
410 std::string label (cell->label());
412 label = YUI::app()->glyph (YUIGlyph_CheckMark);
414 int index = column * 2;
415 setRowText (iter, index, cell->iconName(), index+1, label,
this);
420 virtual bool _immediateMode() {
return immediateMode(); }
424 virtual void setKeepSorting (
bool keepSorting)
426 YTable::setKeepSorting (keepSorting);
427 setSortable (!keepSorting);
429 GtkTreeViewColumn *column = gtk_tree_view_get_column (getView(), 0);
431 gtk_tree_view_column_clicked (column);
435 virtual void cellChanged (
const YTableCell *cell)
438 getTreeIter (cell->parent(), &iter);
439 setCell (&iter, cell->column(), cell);
444 void doAddItem (YItem *_item)
446 YTableItem *item = dynamic_cast <YTableItem *> (_item);
449 addRow (item, &iter);
451 for (YTableCellIterator it = item->cellsBegin();
452 it != item->cellsEnd(); it++)
455 yuiWarning() <<
"Item contains too many columns, current column is (starting from 0) " << i
456 <<
" but only " << columns() <<
" columns are configured. Skipping..." << std::endl;
459 setCell (&iter, i++, *it);
460 if (item->selected())
461 focusItem (item,
true);
464 yuiError() <<
"Can only add YTableItems to a YTable.\n";
467 void doSelectItem (YItem *item,
bool select)
468 { focusItem (item, select); }
470 void doDeselectAllItems()
471 { unfocusAllItems(); }
475 static void activateButton (YWidget *button)
477 YWidgetEvent *
event =
new YWidgetEvent (button, YEvent::Activated);
478 YGUI::ui()->sendEvent (event);
483 if (pThis->notifyContextMenu())
484 return YGTreeView::right_click_cb (view, outreach, pThis);
489 static void key_activate_cb (GtkMenuItem *item, YWidget *button)
490 { activateButton (button); }
491 static void appendItem (GtkWidget *menu,
const gchar *stock,
int key)
493 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (key);
496 item = gtk_menu_item_new_with_mnemonic (stock);
497 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
498 g_signal_connect (G_OBJECT (item),
"activate",
499 G_CALLBACK (key_activate_cb), button);
504 GtkWidget *menu = gtk_menu_new();
505 YGDialog *dialog = YGDialog::currentDialog();
506 if (dialog->getClassWidgets (
"YTable").size() == 1) {
509 if (dialog->getFunctionWidget(3))
510 inner::appendItem (menu,
"list-add", 3);
513 if (dialog->getFunctionWidget(4))
514 inner::appendItem (menu,
"edit-cut", 4);
515 if (dialog->getFunctionWidget(5))
516 inner::appendItem (menu,
"list-remove", 5);
520 menu = ygtk_tree_view_append_show_columns_item (YGTK_TREE_VIEW (view), menu);
521 ygtk_tree_view_popup_menu (view, menu);
524 static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event,
YGTable *pThis)
526 if (event->keyval == GDK_KEY_Delete) {
527 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (5);
529 activateButton (button);
531 gtk_widget_error_bell (widget);
537 static gint tree_sort_cb (
538 GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer _index)
540 int index = GPOINTER_TO_INT (_index);
541 gchar *str_a, *str_b;
542 gtk_tree_model_get (model, a, index, &str_a, -1);
543 gtk_tree_model_get (model, b, index, &str_b, -1);
544 if (!str_a) str_a = g_strdup (
"");
545 if (!str_b) str_b = g_strdup (
"");
546 int ret = strcmp (str_a, str_b);
547 g_free (str_a); g_free (str_b);
551 YGLABEL_WIDGET_IMPL (YTable)
552 YGSELECTION_WIDGET_IMPL (YTable)
555 YTable *YGWidgetFactory::createTable (YWidget *parent, YTableHeader *headers,
558 return new YGTable (parent, headers, multiSelection);
561 #include "YSelectionBox.h"
567 : YSelectionBox (NULL, label),
570 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
571 addTextColumn (0, 1);
572 createStore (2, types);
578 virtual bool _shrinkable() {
return shrinkable(); }
582 void doAddItem (YItem *item)
585 addRow (item, &iter);
586 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
587 if (item->selected())
588 focusItem (item,
true);
591 void doSelectItem (YItem *item,
bool select)
592 { focusItem (item, select); }
594 void doDeselectAllItems()
595 { unfocusAllItems(); }
597 YGLABEL_WIDGET_IMPL (YSelectionBox)
598 YGSELECTION_WIDGET_IMPL (YSelectionBox)
601 YSelectionBox *YGWidgetFactory::createSelectionBox (YWidget *parent,
const std::string &label)
604 #include "YMultiSelectionBox.h"
610 : YMultiSelectionBox (NULL, label),
613 GType types [3] = { G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING };
615 addTextColumn (1, 2);
616 createStore (3, types);
618 addCountWidget (parent);
623 virtual bool _shrinkable() {
return shrinkable(); }
627 void doAddItem (YItem *item)
630 addRow (item, &iter);
631 setRowMark (&iter, 0, item->selected());
632 setRowText (&iter, 1, item->iconName(), 2, item->label(),
this);
636 void doSelectItem (YItem *item,
bool select)
639 getTreeIter (item, &iter);
640 setRowMark (&iter, 0, select);
644 void doDeselectAllItems()
645 { unmarkAll(); syncCount(); }
649 virtual YItem *currentItem()
650 {
return getFocusItem(); }
652 virtual void setCurrentItem (YItem *item)
653 { focusItem (item,
true); }
655 YGLABEL_WIDGET_IMPL (YMultiSelectionBox)
656 YGSELECTION_WIDGET_IMPL (YMultiSelectionBox)
659 YMultiSelectionBox *YGWidgetFactory::createMultiSelectionBox (YWidget *parent,
const std::string &label)
663 #include "YTreeItem.h"
668 YGTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
669 : YTree (NULL, label, multiselection, recursiveSelection),
672 if (multiselection) {
673 GType types [3] = { GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN };
675 addTextColumn (0, 1);
676 createStore (3, types);
677 addCountWidget (parent);
681 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
682 addTextColumn (0, 1);
683 createStore (2, types);
687 g_signal_connect (getWidget(),
"row-collapsed", G_CALLBACK (row_collapsed_cb),
this);
688 g_signal_connect (getWidget(),
"row-expanded", G_CALLBACK (row_expanded_cb),
this);
691 virtual bool _recursiveSelection() {
return recursiveSelection(); }
693 void addNode (YItem *item, GtkTreeIter *parent)
696 addRow (item, &iter, parent);
697 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
698 if (item->selected()) {
699 if (hasMultiSelection())
700 setRowMark (&iter, 2, item->selected());
702 focusItem (item,
true);
704 if (((YTreeItem *) item)->isOpen())
706 for (YItemConstIterator it = item->childrenBegin();
707 it != item->childrenEnd(); it++)
708 addNode (*it, &iter);
712 void expand (GtkTreeIter *iter)
714 GtkTreePath *path = gtk_tree_model_get_path (getModel(), iter);
715 gtk_tree_view_expand_row (getView(), path, FALSE);
716 gtk_tree_path_free (path);
719 bool isReallyOpen (YTreeItem *item)
721 for (YTreeItem *i = item; i; i = i->parent())
730 virtual void rebuildTree()
735 for (YItemConstIterator it = YTree::itemsBegin(); it != YTree::itemsEnd(); it++)
738 int depth = getTreeDepth();
739 gtk_tree_view_set_show_expanders (getView(), depth > 1);
740 gtk_tree_view_set_enable_tree_lines (getView(), depth > 3);
745 static gboolean foreach_sync_open (
746 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
749 YTreeItem *item = (YTreeItem *) pThis->getYItem (iter);
751 gtk_tree_view_expand_row (pThis->getView(), path, FALSE);
756 g_signal_handlers_block_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
757 gtk_tree_model_foreach (getModel(), inner::foreach_sync_open,
this);
758 g_signal_handlers_unblock_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
763 virtual YTreeItem *currentItem()
764 {
return (YTreeItem *) getFocusItem(); }
766 void _markItem (YItem *item,
bool select,
bool recursive) {
768 getTreeIter (item, &iter);
769 setRowMark (&iter, 2, select);
772 YTreeItem *_item = (YTreeItem *) item;
773 for (YItemConstIterator it = _item->childrenBegin();
774 it != _item->childrenEnd(); it++)
775 _markItem (*it, select,
true);
781 void doAddItem (YItem *item) {}
783 void doSelectItem (YItem *item,
bool select)
785 if (hasMultiSelection()) {
786 _markItem (item, select, recursiveSelection());
790 focusItem (item, select);
793 void doDeselectAllItems()
795 if (hasMultiSelection()) {
805 void reportRowOpen (GtkTreeIter *iter,
bool open)
807 YTreeItem *item = static_cast <YTreeItem *> (getYItem (iter));
808 item->setOpen (open);
811 static void row_collapsed_cb (GtkTreeView *view, GtkTreeIter *iter,
812 GtkTreePath *path,
YGTree *pThis)
813 { pThis->reportRowOpen (iter,
false); }
815 static void row_expanded_cb (GtkTreeView *view, GtkTreeIter *iter,
816 GtkTreePath *path,
YGTree *pThis)
817 { pThis->reportRowOpen (iter,
true); }
823 YTreeItem *item = static_cast <YTreeItem *> (pThis->getYItem (iter));
824 for (YItemConstIterator it = item->childrenBegin();
825 it != item->childrenEnd(); it++) {
826 const YTreeItem *child = static_cast <YTreeItem *> (*it);
827 if (child->isOpen()) {
829 if (pThis->getIter (child, &iter))
830 pThis->expand (&iter);
835 YGLABEL_WIDGET_IMPL (YTree)
836 YGSELECTION_WIDGET_IMPL (YTree)
839 YTree *YGWidgetFactory::createTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
840 {
return new YGTree (parent, label, multiselection, recursiveSelection); }