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++)
453 setCell (&iter, i++, *it);
454 if (item->selected())
455 focusItem (item,
true);
458 yuiError() <<
"Can only add YTableItems to a YTable.\n";
461 void doSelectItem (YItem *item,
bool select)
462 { focusItem (item, select); }
464 void doDeselectAllItems()
465 { unfocusAllItems(); }
469 static void activateButton (YWidget *button)
471 YWidgetEvent *
event =
new YWidgetEvent (button, YEvent::Activated);
472 YGUI::ui()->sendEvent (event);
477 if (pThis->notifyContextMenu())
478 return YGTreeView::right_click_cb (view, outreach, pThis);
483 static void key_activate_cb (GtkMenuItem *item, YWidget *button)
484 { activateButton (button); }
485 static void appendItem (GtkWidget *menu,
const gchar *stock,
int key)
487 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (key);
490 item = gtk_menu_item_new_with_mnemonic (stock);
491 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
492 g_signal_connect (G_OBJECT (item),
"activate",
493 G_CALLBACK (key_activate_cb), button);
498 GtkWidget *menu = gtk_menu_new();
499 YGDialog *dialog = YGDialog::currentDialog();
500 if (dialog->getClassWidgets (
"YTable").size() == 1) {
503 if (dialog->getFunctionWidget(3))
504 inner::appendItem (menu,
"list-add", 3);
507 if (dialog->getFunctionWidget(4))
508 inner::appendItem (menu,
"edit-cut", 4);
509 if (dialog->getFunctionWidget(5))
510 inner::appendItem (menu,
"list-remove", 5);
514 menu = ygtk_tree_view_append_show_columns_item (YGTK_TREE_VIEW (view), menu);
515 ygtk_tree_view_popup_menu (view, menu);
518 static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event,
YGTable *pThis)
520 if (event->keyval == GDK_KEY_Delete) {
521 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (5);
523 activateButton (button);
525 gtk_widget_error_bell (widget);
531 static gint tree_sort_cb (
532 GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer _index)
534 int index = GPOINTER_TO_INT (_index);
535 gchar *str_a, *str_b;
536 gtk_tree_model_get (model, a, index, &str_a, -1);
537 gtk_tree_model_get (model, b, index, &str_b, -1);
538 if (!str_a) str_a = g_strdup (
"");
539 if (!str_b) str_b = g_strdup (
"");
540 int ret = strcmp (str_a, str_b);
541 g_free (str_a); g_free (str_b);
545 YGLABEL_WIDGET_IMPL (YTable)
546 YGSELECTION_WIDGET_IMPL (YTable)
549 YTable *YGWidgetFactory::createTable (YWidget *parent, YTableHeader *headers,
552 return new YGTable (parent, headers, multiSelection);
555 #include "YSelectionBox.h"
561 : YSelectionBox (NULL, label),
564 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
565 addTextColumn (0, 1);
566 createStore (2, types);
572 virtual bool _shrinkable() {
return shrinkable(); }
576 void doAddItem (YItem *item)
579 addRow (item, &iter);
580 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
581 if (item->selected())
582 focusItem (item,
true);
585 void doSelectItem (YItem *item,
bool select)
586 { focusItem (item, select); }
588 void doDeselectAllItems()
589 { unfocusAllItems(); }
591 YGLABEL_WIDGET_IMPL (YSelectionBox)
592 YGSELECTION_WIDGET_IMPL (YSelectionBox)
595 YSelectionBox *YGWidgetFactory::createSelectionBox (YWidget *parent,
const std::string &label)
598 #include "YMultiSelectionBox.h"
604 : YMultiSelectionBox (NULL, label),
607 GType types [3] = { G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING };
609 addTextColumn (1, 2);
610 createStore (3, types);
612 addCountWidget (parent);
617 virtual bool _shrinkable() {
return shrinkable(); }
621 void doAddItem (YItem *item)
624 addRow (item, &iter);
625 setRowMark (&iter, 0, item->selected());
626 setRowText (&iter, 1, item->iconName(), 2, item->label(),
this);
630 void doSelectItem (YItem *item,
bool select)
633 getTreeIter (item, &iter);
634 setRowMark (&iter, 0, select);
638 void doDeselectAllItems()
639 { unmarkAll(); syncCount(); }
643 virtual YItem *currentItem()
644 {
return getFocusItem(); }
646 virtual void setCurrentItem (YItem *item)
647 { focusItem (item,
true); }
649 YGLABEL_WIDGET_IMPL (YMultiSelectionBox)
650 YGSELECTION_WIDGET_IMPL (YMultiSelectionBox)
653 YMultiSelectionBox *YGWidgetFactory::createMultiSelectionBox (YWidget *parent,
const std::string &label)
657 #include "YTreeItem.h"
662 YGTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
663 : YTree (NULL, label, multiselection, recursiveSelection),
666 if (multiselection) {
667 GType types [3] = { GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN };
669 addTextColumn (0, 1);
670 createStore (3, types);
671 addCountWidget (parent);
675 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
676 addTextColumn (0, 1);
677 createStore (2, types);
681 g_signal_connect (getWidget(),
"row-collapsed", G_CALLBACK (row_collapsed_cb),
this);
682 g_signal_connect (getWidget(),
"row-expanded", G_CALLBACK (row_expanded_cb),
this);
685 virtual bool _recursiveSelection() {
return recursiveSelection(); }
687 void addNode (YItem *item, GtkTreeIter *parent)
690 addRow (item, &iter, parent);
691 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
692 #if 0 // yast2-qt ignores `selected flag
693 if (item->selected()) {
694 if (hasMultiSelection())
695 setRowMark (&iter, 2, item->selected());
697 focusItem (item,
true);
699 if (((YTreeItem *) item)->isOpen())
702 for (YItemConstIterator it = item->childrenBegin();
703 it != item->childrenEnd(); it++)
704 addNode (*it, &iter);
708 void expand (GtkTreeIter *iter)
710 GtkTreePath *path = gtk_tree_model_get_path (getModel(), iter);
711 gtk_tree_view_expand_row (getView(), path, FALSE);
712 gtk_tree_path_free (path);
715 bool isReallyOpen (YTreeItem *item)
717 for (YTreeItem *i = item; i; i = i->parent())
726 virtual void rebuildTree()
731 for (YItemConstIterator it = YTree::itemsBegin(); it != YTree::itemsEnd(); it++)
734 int depth = getTreeDepth();
735 gtk_tree_view_set_show_expanders (getView(), depth > 1);
736 gtk_tree_view_set_enable_tree_lines (getView(), depth > 3);
741 static gboolean foreach_sync_open (
742 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
745 YTreeItem *item = (YTreeItem *) pThis->getYItem (iter);
747 gtk_tree_view_expand_row (pThis->getView(), path, FALSE);
752 g_signal_handlers_block_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
753 gtk_tree_model_foreach (getModel(), inner::foreach_sync_open,
this);
754 g_signal_handlers_unblock_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
759 virtual YTreeItem *currentItem()
760 {
return (YTreeItem *) getFocusItem(); }
762 void _markItem (YItem *item,
bool select,
bool recursive) {
764 getTreeIter (item, &iter);
765 setRowMark (&iter, 2, select);
768 YTreeItem *_item = (YTreeItem *) item;
769 for (YItemConstIterator it = _item->childrenBegin();
770 it != _item->childrenEnd(); it++)
771 _markItem (*it, select,
true);
777 void doAddItem (YItem *item) {}
779 void doSelectItem (YItem *item,
bool select)
781 if (hasMultiSelection()) {
782 _markItem (item, select, recursiveSelection());
786 focusItem (item, select);
789 void doDeselectAllItems()
791 if (hasMultiSelection()) {
801 void reportRowOpen (GtkTreeIter *iter,
bool open)
803 YTreeItem *item = static_cast <YTreeItem *> (getYItem (iter));
804 item->setOpen (open);
807 static void row_collapsed_cb (GtkTreeView *view, GtkTreeIter *iter,
808 GtkTreePath *path,
YGTree *pThis)
809 { pThis->reportRowOpen (iter,
false); }
811 static void row_expanded_cb (GtkTreeView *view, GtkTreeIter *iter,
812 GtkTreePath *path,
YGTree *pThis)
813 { pThis->reportRowOpen (iter,
true); }
819 YTreeItem *item = static_cast <YTreeItem *> (pThis->getYItem (iter));
820 for (YItemConstIterator it = item->childrenBegin();
821 it != item->childrenEnd(); it++) {
822 const YTreeItem *child = static_cast <YTreeItem *> (*it);
823 if (child->isOpen()) {
825 if (pThis->getIter (child, &iter))
826 pThis->expand (&iter);
831 YGLABEL_WIDGET_IMPL (YTree)
832 YGSELECTION_WIDGET_IMPL (YTree)
835 YTree *YGWidgetFactory::createTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
836 {
return new YGTree (parent, label, multiselection, recursiveSelection); }