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());
342 { pThis->emitEvent (YEvent::ContextMenuActivated); }
346 #include "YGDialog.h"
347 #include <gdk/gdkkeysyms.h>
353 YGTable (YWidget *parent, YTableHeader *headers,
bool multiSelection)
354 : YTable (NULL, headers, multiSelection),
355 YGTreeView (
this, parent, std::string(),
false)
357 gtk_tree_view_set_headers_visible (getView(), TRUE);
359 # if GTK_CHECK_VERSION (3, 14, 0)
361 gtk_tree_view_set_rules_hint (getView(), columns() > 1);
364 ygtk_tree_view_set_empty_text (YGTK_TREE_VIEW (getView()), _(
"No entries."));
366 gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_MULTIPLE);
368 GType types [columns()*2];
369 for (
int i = 0; i < columns(); i++) {
371 types[t+0] = GDK_TYPE_PIXBUF;
372 types[t+1] = G_TYPE_STRING;
373 addTextColumn (header(i), alignment (i), t, t+1);
375 createStore (columns()*2, types);
381 YAlignmentType lastAlign = alignment (columns()-1);
382 if (lastAlign == YAlignCenter || lastAlign == YAlignEnd)
383 gtk_tree_view_append_column (getView(), gtk_tree_view_column_new());
385 g_signal_connect (getWidget(),
"key-press-event", G_CALLBACK (key_press_event_cb),
this);
388 void setSortable (
bool sortable)
391 GList *columns = gtk_tree_view_get_columns (getView());
392 for (GList *i = columns; i; i = i->next, n++) {
393 GtkTreeViewColumn *column = (GtkTreeViewColumn *) i->data;
394 if (n >= YGTable::columns())
398 gtk_tree_sortable_set_sort_func (
399 GTK_TREE_SORTABLE (getModel()), index, tree_sort_cb,
400 GINT_TO_POINTER (index), NULL);
401 gtk_tree_view_column_set_sort_column_id (column, index);
404 gtk_tree_view_column_set_sort_column_id (column, -1);
406 g_list_free (columns);
409 void setCell (GtkTreeIter *iter,
int column,
const YTableCell *cell)
412 std::string label (cell->label());
414 label = YUI::app()->glyph (YUIGlyph_CheckMark);
416 int index = column * 2;
417 setRowText (iter, index, cell->iconName(), index+1, label,
this);
422 virtual bool _immediateMode() {
return immediateMode(); }
426 virtual void setKeepSorting (
bool keepSorting)
428 YTable::setKeepSorting (keepSorting);
429 setSortable (!keepSorting);
431 GtkTreeViewColumn *column = gtk_tree_view_get_column (getView(), 0);
433 gtk_tree_view_column_clicked (column);
437 virtual void cellChanged (
const YTableCell *cell)
440 getTreeIter (cell->parent(), &iter);
441 setCell (&iter, cell->column(), cell);
446 void doAddItem (YItem *_item)
448 YTableItem *item =
dynamic_cast <YTableItem *
> (_item);
451 addRow (item, &iter);
453 for (YTableCellIterator it = item->cellsBegin();
454 it != item->cellsEnd(); it++)
457 yuiWarning() <<
"Item contains too many columns, current column is (starting from 0) " << i
458 <<
" but only " << columns() <<
" columns are configured. Skipping..." << std::endl;
461 setCell (&iter, i++, *it);
462 if (item->selected())
463 focusItem (item,
true);
466 yuiError() <<
"Can only add YTableItems to a YTable.\n";
469 void doSelectItem (YItem *item,
bool select)
470 { focusItem (item, select); }
472 void doDeselectAllItems()
473 { unfocusAllItems(); }
477 static void activateButton (YWidget *button)
479 YWidgetEvent *
event =
new YWidgetEvent (button, YEvent::Activated);
480 YGUI::ui()->sendEvent (event);
485 if (pThis->notifyContextMenu())
486 return YGTreeView::right_click_cb (view, outreach, pThis);
491 static void key_activate_cb (GtkMenuItem *item, YWidget *button)
492 { activateButton (button); }
493 static void appendItem (GtkWidget *menu,
const gchar *stock,
int key)
495 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (key);
498 item = gtk_menu_item_new_with_mnemonic (stock);
499 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
500 g_signal_connect (G_OBJECT (item),
"activate",
501 G_CALLBACK (key_activate_cb), button);
506 GtkWidget *menu = gtk_menu_new();
507 YGDialog *dialog = YGDialog::currentDialog();
508 if (dialog->getClassWidgets (
"YTable").size() == 1) {
511 if (dialog->getFunctionWidget(3))
512 inner::appendItem (menu,
"list-add", 3);
515 if (dialog->getFunctionWidget(4))
516 inner::appendItem (menu,
"edit-cut", 4);
517 if (dialog->getFunctionWidget(5))
518 inner::appendItem (menu,
"list-remove", 5);
522 menu = ygtk_tree_view_append_show_columns_item (YGTK_TREE_VIEW (view), menu);
523 ygtk_tree_view_popup_menu (view, menu);
526 static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event,
YGTable *pThis)
528 if (event->keyval == GDK_KEY_Delete) {
529 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (5);
531 activateButton (button);
533 gtk_widget_error_bell (widget);
539 static gint tree_sort_cb (
540 GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer _index)
542 int index = GPOINTER_TO_INT (_index);
543 gchar *str_a, *str_b;
544 gtk_tree_model_get (model, a, index, &str_a, -1);
545 gtk_tree_model_get (model, b, index, &str_b, -1);
546 if (!str_a) str_a = g_strdup (
"");
547 if (!str_b) str_b = g_strdup (
"");
548 int ret = strcmp (str_a, str_b);
549 g_free (str_a); g_free (str_b);
553 YGLABEL_WIDGET_IMPL (YTable)
554 YGSELECTION_WIDGET_IMPL (YTable)
557 YTable *YGWidgetFactory::createTable (YWidget *parent, YTableHeader *headers,
560 return new YGTable (parent, headers, multiSelection);
563 #include "YSelectionBox.h"
569 : YSelectionBox (NULL, label),
572 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
573 addTextColumn (0, 1);
574 createStore (2, types);
580 virtual bool _shrinkable() {
return shrinkable(); }
584 void doAddItem (YItem *item)
587 addRow (item, &iter);
588 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
589 if (item->selected())
590 focusItem (item,
true);
593 void doSelectItem (YItem *item,
bool select)
594 { focusItem (item, select); }
596 void doDeselectAllItems()
597 { unfocusAllItems(); }
599 YGLABEL_WIDGET_IMPL (YSelectionBox)
600 YGSELECTION_WIDGET_IMPL (YSelectionBox)
603 YSelectionBox *YGWidgetFactory::createSelectionBox (YWidget *parent,
const std::string &label)
606 #include "YMultiSelectionBox.h"
612 : YMultiSelectionBox (NULL, label),
615 GType types [3] = { G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING };
617 addTextColumn (1, 2);
618 createStore (3, types);
620 addCountWidget (parent);
625 virtual bool _shrinkable() {
return shrinkable(); }
629 void doAddItem (YItem *item)
632 addRow (item, &iter);
633 setRowMark (&iter, 0, item->selected());
634 setRowText (&iter, 1, item->iconName(), 2, item->label(),
this);
638 void doSelectItem (YItem *item,
bool select)
641 getTreeIter (item, &iter);
642 setRowMark (&iter, 0, select);
646 void doDeselectAllItems()
647 { unmarkAll(); syncCount(); }
651 virtual YItem *currentItem()
652 {
return getFocusItem(); }
654 virtual void setCurrentItem (YItem *item)
655 { focusItem (item,
true); }
657 YGLABEL_WIDGET_IMPL (YMultiSelectionBox)
658 YGSELECTION_WIDGET_IMPL (YMultiSelectionBox)
661 YMultiSelectionBox *YGWidgetFactory::createMultiSelectionBox (YWidget *parent,
const std::string &label)
665 #include "YTreeItem.h"
670 YGTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
671 : YTree (NULL, label, multiselection, recursiveSelection),
674 if (multiselection) {
675 GType types [3] = { GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN };
677 addTextColumn (0, 1);
678 createStore (3, types);
679 addCountWidget (parent);
683 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
684 addTextColumn (0, 1);
685 createStore (2, types);
689 g_signal_connect (getWidget(),
"row-collapsed", G_CALLBACK (row_collapsed_cb),
this);
690 g_signal_connect (getWidget(),
"row-expanded", G_CALLBACK (row_expanded_cb),
this);
693 virtual bool _recursiveSelection() {
return recursiveSelection(); }
695 void addNode (YItem *item, GtkTreeIter *parent)
698 addRow (item, &iter, parent);
699 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
700 if (item->selected()) {
701 if (hasMultiSelection())
702 setRowMark (&iter, 2, item->selected());
704 focusItem (item,
true);
706 if (((YTreeItem *) item)->isOpen())
708 for (YItemConstIterator it = item->childrenBegin();
709 it != item->childrenEnd(); it++)
710 addNode (*it, &iter);
714 void expand (GtkTreeIter *iter)
716 GtkTreePath *path = gtk_tree_model_get_path (getModel(), iter);
717 gtk_tree_view_expand_row (getView(), path, FALSE);
718 gtk_tree_path_free (path);
721 bool isReallyOpen (YTreeItem *item)
723 for (YTreeItem *i = item; i; i = i->parent())
732 virtual void rebuildTree()
737 for (YItemConstIterator it = YTree::itemsBegin(); it != YTree::itemsEnd(); it++)
740 int depth = getTreeDepth();
741 gtk_tree_view_set_show_expanders (getView(), depth > 1);
742 gtk_tree_view_set_enable_tree_lines (getView(), depth > 3);
747 static gboolean foreach_sync_open (
748 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
751 YTreeItem *item = (YTreeItem *) pThis->getYItem (iter);
753 gtk_tree_view_expand_row (pThis->getView(), path, FALSE);
758 g_signal_handlers_block_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
759 gtk_tree_model_foreach (getModel(), inner::foreach_sync_open,
this);
760 g_signal_handlers_unblock_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
765 virtual YTreeItem *currentItem()
766 {
return (YTreeItem *) getFocusItem(); }
768 void _markItem (YItem *item,
bool select,
bool recursive) {
770 getTreeIter (item, &iter);
771 setRowMark (&iter, 2, select);
774 YTreeItem *_item = (YTreeItem *) item;
775 for (YItemConstIterator it = _item->childrenBegin();
776 it != _item->childrenEnd(); it++)
777 _markItem (*it, select,
true);
783 void doAddItem (YItem *item) {}
785 void doSelectItem (YItem *item,
bool select)
787 if (hasMultiSelection()) {
788 _markItem (item, select, recursiveSelection());
792 focusItem (item, select);
795 void doDeselectAllItems()
797 if (hasMultiSelection()) {
807 void reportRowOpen (GtkTreeIter *iter,
bool open)
809 YTreeItem *item =
static_cast <YTreeItem *
> (getYItem (iter));
810 item->setOpen (open);
813 static void row_collapsed_cb (GtkTreeView *view, GtkTreeIter *iter,
814 GtkTreePath *path,
YGTree *pThis)
815 { pThis->reportRowOpen (iter,
false); }
817 static void row_expanded_cb (GtkTreeView *view, GtkTreeIter *iter,
818 GtkTreePath *path,
YGTree *pThis)
819 { pThis->reportRowOpen (iter,
true); }
825 YTreeItem *item =
static_cast <YTreeItem *
> (pThis->getYItem (iter));
826 for (YItemConstIterator it = item->childrenBegin();
827 it != item->childrenEnd(); it++) {
828 const YTreeItem *child =
static_cast <YTreeItem *
> (*it);
829 if (child->isOpen()) {
831 if (pThis->getIter (child, &iter))
832 pThis->expand (&iter);
842 YGUI::ui()->sendEvent(
new YWidgetEvent(
this,YEvent::Activated ) );
846 YGLABEL_WIDGET_IMPL (YTree)
847 YGSELECTION_WIDGET_IMPL (YTree)
850 YTree *YGWidgetFactory::createTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
851 {
return new YGTree (parent, label, multiselection, recursiveSelection); }