9 #define YUILogComponent "gtk"
10 #include <yui/Libyui_config.h>
14 #include "YSelectionWidget.h"
15 #include "YGSelectionStore.h"
16 #include "ygtktreeview.h"
29 YGTreeView (YWidget *ywidget, YWidget *parent,
const std::string &label,
bool tree)
30 :
YGScrolledWidget (ywidget, parent, label, YD_VERT, YGTK_TYPE_TREE_VIEW, NULL),
33 gtk_tree_view_set_headers_visible (getView(), FALSE);
38 gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_BROWSE);
40 connect (getSelection(),
"changed", G_CALLBACK (selection_changed_cb),
this);
41 connect (getWidget(),
"row-activated", G_CALLBACK (activated_cb),
this);
42 connect (getWidget(),
"right-click", G_CALLBACK (right_click_cb),
this);
45 markColumn = -1; m_count = NULL;
47 g_signal_connect (getWidget(),
"map", G_CALLBACK (block_init_cb),
this);
51 {
if (m_blockTimeout) g_source_remove (m_blockTimeout); }
53 inline GtkTreeView *getView()
54 {
return GTK_TREE_VIEW (getWidget()); }
55 inline GtkTreeSelection *getSelection()
56 {
return gtk_tree_view_get_selection (getView()); }
58 void addTextColumn (
int iconCol,
int textCol)
59 { addTextColumn (
"", YAlignUnchanged, iconCol, textCol); }
61 void addTextColumn (
const std::string &header, YAlignmentType align,
int icon_col,
int text_col)
65 case YAlignBegin: xalign = 0.0;
break;
66 case YAlignCenter: xalign = 0.5;
break;
67 case YAlignEnd: xalign = 1.0;
break;
68 case YAlignUnchanged:
break;
71 GtkTreeViewColumn *column = gtk_tree_view_column_new();
72 gtk_tree_view_column_set_title (column, header.c_str());
74 GtkCellRenderer *renderer;
75 renderer = gtk_cell_renderer_pixbuf_new();
76 gtk_tree_view_column_pack_start (column, renderer, FALSE);
77 gtk_tree_view_column_set_attributes (column, renderer,
"pixbuf", icon_col, NULL);
79 renderer = gtk_cell_renderer_text_new();
80 gtk_tree_view_column_pack_start (column, renderer, TRUE);
81 gtk_tree_view_column_set_attributes (column, renderer,
"text", text_col, NULL);
83 g_object_set (renderer,
"xalign", xalign, NULL);
85 gtk_tree_view_column_set_resizable (column, TRUE);
86 gtk_tree_view_append_column (getView(), column);
87 if (gtk_tree_view_get_search_column (getView()) == -1)
88 gtk_tree_view_set_search_column (getView(), text_col);
91 void addCheckColumn (
int check_col)
93 GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
94 g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (check_col));
95 GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (
96 NULL, renderer,
"active", check_col, NULL);
97 gtk_tree_view_column_set_cell_data_func (column, renderer, inconsistent_mark_cb,
this, NULL);
98 g_signal_connect (G_OBJECT (renderer),
"toggled",
99 G_CALLBACK (toggled_cb),
this);
101 gtk_tree_view_column_set_resizable (column, TRUE);
102 gtk_tree_view_append_column (getView(), column);
103 if (markColumn == -1)
104 markColumn = check_col;
108 { gtk_tree_view_set_model (getView(), getModel()); }
110 void addCountWidget (YWidget *yparent)
112 bool mainWidget = !yparent || !strcmp (yparent->widgetClass(),
"YVBox") || !strcmp (yparent->widgetClass(),
"YReplacePoint");
114 m_count = gtk_label_new (
"0");
115 GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
116 gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
118 GtkWidget *label = gtk_label_new (_(
"Total selected:"));
120 gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
121 gtk_box_pack_start (GTK_BOX (hbox), m_count, FALSE, TRUE, 0);
122 gtk_box_pack_start (GTK_BOX (YGWidget::getWidget()), hbox, FALSE, TRUE, 0);
123 gtk_widget_show_all (hbox);
129 if (!m_count)
return;
132 static gboolean
foreach (
133 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
137 gtk_tree_model_get (model, iter, pThis->markColumn, &mark, -1);
139 int count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model),
"count"));
140 g_object_set_data (G_OBJECT (model),
"count", GINT_TO_POINTER (count+1));
146 GtkTreeModel *model = getModel();
147 g_object_set_data (G_OBJECT (model),
"count", 0);
148 gtk_tree_model_foreach (model, inner::foreach,
this);
150 int count = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model),
"count"));
151 gchar *str = g_strdup_printf (
"%d", count);
152 gtk_label_set_text (GTK_LABEL (m_count), str);
156 void focusItem (YItem *item,
bool select)
159 getTreeIter (item, &iter);
163 GtkTreePath *path = gtk_tree_model_get_path (getModel(), &iter);
164 gtk_tree_view_expand_to_path (getView(), path);
166 if (gtk_tree_selection_get_mode (getSelection()) != GTK_SELECTION_MULTIPLE)
167 gtk_tree_view_scroll_to_cell (getView(), path, NULL, TRUE, 0.5, 0);
168 gtk_tree_path_free (path);
170 gtk_tree_selection_select_iter (getSelection(), &iter);
173 gtk_tree_selection_unselect_iter (getSelection(), &iter);
176 void unfocusAllItems()
179 gtk_tree_selection_unselect_all (getSelection());
185 static gboolean foreach_unmark (
186 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
189 pThis->setRowMark (iter, pThis->markColumn, FALSE);
194 gtk_tree_model_foreach (getModel(), inner::foreach_unmark,
this);
197 YItem *getFocusItem()
200 if (gtk_tree_selection_get_selected (getSelection(), NULL, &iter))
201 return getYItem (&iter);
205 virtual bool _immediateMode() {
return true; }
206 virtual bool _shrinkable() {
return false; }
207 virtual bool _recursiveSelection() {
return false; }
209 void setMark (GtkTreeIter *iter, YItem *yitem, gint column,
bool state,
bool recursive)
211 setRowMark (iter, column, state);
212 yitem->setSelected (state);
215 for (YItemConstIterator it = yitem->childrenBegin();
216 it != yitem->childrenEnd(); it++) {
218 getTreeIter (*it, &_iter);
219 setMark (&_iter, *it, column, state,
true);
223 void toggleMark (GtkTreePath *path, gint column)
226 if (!gtk_tree_model_get_iter (getModel(), &iter, path))
229 gtk_tree_model_get (getModel(), &iter, column, &state, -1);
232 YItem *yitem = getYItem (&iter);
233 setMark (&iter, yitem, column, state, _recursiveSelection());
235 emitEvent (YEvent::ValueChanged);
240 virtual unsigned int getMinSize (YUIDimension dim)
243 return YGUtils::getCharsHeight (getWidget(), _shrinkable() ? 2 : 5);
248 static gboolean block_selected_timeout_cb (gpointer data)
251 pThis->m_blockTimeout = 0;
257 if (m_blockTimeout) g_source_remove (m_blockTimeout);
258 m_blockTimeout = g_timeout_add_full (G_PRIORITY_LOW, 50, block_selected_timeout_cb,
this, NULL);
261 static void block_init_cb (GtkWidget *widget,
YGTreeView *pThis)
262 { pThis->blockSelected(); }
266 static bool all_marked (GtkTreeModel *model, GtkTreeIter *iter,
int mark_col)
269 GtkTreeIter child_iter;
270 if (gtk_tree_model_iter_children (model, &child_iter, iter))
272 gtk_tree_model_get (model, &child_iter, mark_col, &marked, -1);
273 if (!marked)
return false;
274 all_marked (model, &child_iter, mark_col);
275 }
while (gtk_tree_model_iter_next (model, &child_iter));
279 static void inconsistent_mark_cb (GtkTreeViewColumn *column,
280 GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
284 gtk_tree_model_get (model, iter, pThis->markColumn, &marked, -1);
285 gboolean consistent = !marked || all_marked (model, iter, pThis->markColumn);
286 g_object_set (G_OBJECT (cell),
"inconsistent", !consistent, NULL);
289 static void selection_changed_cb (GtkTreeSelection *selection,
YGTreeView *pThis)
292 static gboolean foreach_sync_select (
293 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
296 GtkTreeSelection *selection = pThis->getSelection();
297 bool sel = gtk_tree_selection_iter_is_selected (selection, iter);
298 pThis->getYItem (iter)->setSelected (sel);
303 if (pThis->m_blockTimeout)
return;
304 if (pThis->markColumn == -1)
305 gtk_tree_model_foreach (pThis->getModel(), inner::foreach_sync_select, pThis);
306 if (pThis->_immediateMode())
307 pThis->emitEvent (YEvent::SelectionChanged, IF_NOT_PENDING_EVENT);
310 static void activated_cb (GtkTreeView *tree_view, GtkTreePath *path,
313 if (pThis->markColumn >= 0)
314 pThis->toggleMark (path, pThis->markColumn);
317 if (gtk_tree_view_row_expanded (tree_view, path))
318 gtk_tree_view_collapse_row (tree_view, path);
320 gtk_tree_view_expand_row (tree_view, path, FALSE);
322 pThis->emitEvent (YEvent::Activated);
326 static void toggled_cb (GtkCellRendererToggle *renderer, gchar *path_str,
329 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
330 gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (renderer),
"column"));
331 pThis->toggleMark (path, column);
332 gtk_tree_path_free (path);
335 if (gtk_tree_path_get_depth (path) >= 2)
336 gtk_widget_queue_draw (pThis->getWidget());
340 { pThis->emitEvent (YEvent::ContextMenuActivated); }
344 #include "YGDialog.h"
345 #include <gdk/gdkkeysyms.h>
351 YGTable (YWidget *parent, YTableHeader *headers,
bool multiSelection)
352 : YTable (NULL, headers, multiSelection),
353 YGTreeView (
this, parent, std::string(),
false)
355 gtk_tree_view_set_headers_visible (getView(), TRUE);
356 gtk_tree_view_set_rules_hint (getView(), columns() > 1);
357 ygtk_tree_view_set_empty_text (YGTK_TREE_VIEW (getView()), _(
"No entries."));
359 gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_MULTIPLE);
361 GType types [columns()*2];
362 for (
int i = 0; i < columns(); i++) {
364 types[t+0] = GDK_TYPE_PIXBUF;
365 types[t+1] = G_TYPE_STRING;
366 addTextColumn (header(i), alignment (i), t, t+1);
368 createStore (columns()*2, types);
374 YAlignmentType lastAlign = alignment (columns()-1);
375 if (lastAlign == YAlignCenter || lastAlign == YAlignEnd)
376 gtk_tree_view_append_column (getView(), gtk_tree_view_column_new());
378 g_signal_connect (getWidget(),
"key-press-event", G_CALLBACK (key_press_event_cb),
this);
381 void setSortable (
bool sortable)
383 if (!sortable && !gtk_widget_get_realized (getWidget()))
386 GList *columns = gtk_tree_view_get_columns (getView());
387 for (GList *i = columns; i; i = i->next, n++) {
388 GtkTreeViewColumn *column = (GtkTreeViewColumn *) i->data;
389 if (n >= YGTable::columns())
395 gtk_tree_sortable_set_sort_func (
396 GTK_TREE_SORTABLE (getModel()), index, tree_sort_cb,
397 GINT_TO_POINTER (index), NULL);
398 gtk_tree_view_column_set_sort_column_id (column, index);
401 gtk_tree_view_column_set_sort_column_id (column, -1);
403 g_list_free (columns);
406 void setCell (GtkTreeIter *iter,
int column,
const YTableCell *cell)
409 std::string label (cell->label());
411 label = YUI::app()->glyph (YUIGlyph_CheckMark);
413 int index = column * 2;
414 setRowText (iter, index, cell->iconName(), index+1, label,
this);
419 virtual bool _immediateMode() {
return immediateMode(); }
423 virtual void setKeepSorting (
bool keepSorting)
425 YTable::setKeepSorting (keepSorting);
426 setSortable (!keepSorting);
428 GtkTreeViewColumn *column = gtk_tree_view_get_column (getView(), 0);
430 gtk_tree_view_column_clicked (column);
434 virtual void cellChanged (
const YTableCell *cell)
437 getTreeIter (cell->parent(), &iter);
438 setCell (&iter, cell->column(), cell);
443 void doAddItem (YItem *_item)
445 YTableItem *item = dynamic_cast <YTableItem *> (_item);
448 addRow (item, &iter);
450 for (YTableCellIterator it = item->cellsBegin();
451 it != item->cellsEnd(); it++)
452 setCell (&iter, i++, *it);
453 if (item->selected())
454 focusItem (item,
true);
457 yuiError() <<
"Can only add YTableItems to a YTable.\n";
460 void doSelectItem (YItem *item,
bool select)
461 { focusItem (item, select); }
463 void doDeselectAllItems()
464 { unfocusAllItems(); }
468 static void activateButton (YWidget *button)
470 YWidgetEvent *
event =
new YWidgetEvent (button, YEvent::Activated);
471 YGUI::ui()->sendEvent (event);
476 if (pThis->notifyContextMenu())
477 return YGTreeView::right_click_cb (view, outreach, pThis);
482 static void key_activate_cb (GtkMenuItem *item, YWidget *button)
483 { activateButton (button); }
484 static void appendItem (GtkWidget *menu,
const gchar *stock,
int key)
486 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (key);
489 item = gtk_image_menu_item_new_from_stock (stock, NULL);
490 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
491 g_signal_connect (G_OBJECT (item),
"activate",
492 G_CALLBACK (key_activate_cb), button);
497 GtkWidget *menu = gtk_menu_new();
498 YGDialog *dialog = YGDialog::currentDialog();
499 if (dialog->getClassWidgets (
"YTable").size() == 1) {
502 if (dialog->getFunctionWidget(3))
503 inner::appendItem (menu, GTK_STOCK_ADD, 3);
506 if (dialog->getFunctionWidget(4))
507 inner::appendItem (menu, GTK_STOCK_EDIT, 4);
508 if (dialog->getFunctionWidget(5))
509 inner::appendItem (menu, GTK_STOCK_DELETE, 5);
513 menu = ygtk_tree_view_append_show_columns_item (YGTK_TREE_VIEW (view), menu);
514 ygtk_tree_view_popup_menu (view, menu);
517 static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event,
YGTable *pThis)
519 if (event->keyval == GDK_KEY_Delete) {
520 YWidget *button = YGDialog::currentDialog()->getFunctionWidget (5);
522 activateButton (button);
524 gtk_widget_error_bell (widget);
530 static gint tree_sort_cb (
531 GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer _index)
533 int index = GPOINTER_TO_INT (_index);
534 gchar *str_a, *str_b;
535 gtk_tree_model_get (model, a, index, &str_a, -1);
536 gtk_tree_model_get (model, b, index, &str_b, -1);
537 if (!str_a) str_a = g_strdup (
"");
538 if (!str_b) str_b = g_strdup (
"");
539 int ret = strcmp (str_a, str_b);
540 g_free (str_a); g_free (str_b);
544 YGLABEL_WIDGET_IMPL (YTable)
545 YGSELECTION_WIDGET_IMPL (YTable)
548 YTable *YGWidgetFactory::createTable (YWidget *parent, YTableHeader *headers,
551 return new YGTable (parent, headers, multiSelection);
554 #include "YSelectionBox.h"
560 : YSelectionBox (NULL, label),
563 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
564 addTextColumn (0, 1);
565 createStore (2, types);
571 virtual bool _shrinkable() {
return shrinkable(); }
575 void doAddItem (YItem *item)
578 addRow (item, &iter);
579 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
580 if (item->selected())
581 focusItem (item,
true);
584 void doSelectItem (YItem *item,
bool select)
585 { focusItem (item, select); }
587 void doDeselectAllItems()
588 { unfocusAllItems(); }
590 YGLABEL_WIDGET_IMPL (YSelectionBox)
591 YGSELECTION_WIDGET_IMPL (YSelectionBox)
594 YSelectionBox *YGWidgetFactory::createSelectionBox (YWidget *parent,
const std::string &label)
597 #include "YMultiSelectionBox.h"
603 : YMultiSelectionBox (NULL, label),
606 GType types [3] = { G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING };
608 addTextColumn (1, 2);
609 createStore (3, types);
611 addCountWidget (parent);
616 virtual bool _shrinkable() {
return shrinkable(); }
620 void doAddItem (YItem *item)
623 addRow (item, &iter);
624 setRowMark (&iter, 0, item->selected());
625 setRowText (&iter, 1, item->iconName(), 2, item->label(),
this);
629 void doSelectItem (YItem *item,
bool select)
632 getTreeIter (item, &iter);
633 setRowMark (&iter, 0, select);
637 void doDeselectAllItems()
638 { unmarkAll(); syncCount(); }
642 virtual YItem *currentItem()
643 {
return getFocusItem(); }
645 virtual void setCurrentItem (YItem *item)
646 { focusItem (item,
true); }
648 YGLABEL_WIDGET_IMPL (YMultiSelectionBox)
649 YGSELECTION_WIDGET_IMPL (YMultiSelectionBox)
652 YMultiSelectionBox *YGWidgetFactory::createMultiSelectionBox (YWidget *parent,
const std::string &label)
656 #include "YTreeItem.h"
661 YGTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
662 : YTree (NULL, label, multiselection, recursiveSelection),
665 if (multiselection) {
666 GType types [3] = { GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN };
668 addTextColumn (0, 1);
669 createStore (3, types);
670 addCountWidget (parent);
674 GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
675 addTextColumn (0, 1);
676 createStore (2, types);
680 g_signal_connect (getWidget(),
"row-collapsed", G_CALLBACK (row_collapsed_cb),
this);
681 g_signal_connect (getWidget(),
"row-expanded", G_CALLBACK (row_expanded_cb),
this);
684 virtual bool _recursiveSelection() {
return recursiveSelection(); }
686 void addNode (YItem *item, GtkTreeIter *parent)
689 addRow (item, &iter, parent);
690 setRowText (&iter, 0, item->iconName(), 1, item->label(),
this);
691 #if 0 // yast2-qt ignores `selected flag
692 if (item->selected()) {
693 if (hasMultiSelection())
694 setRowMark (&iter, 2, item->selected());
696 focusItem (item,
true);
698 if (((YTreeItem *) item)->isOpen())
701 for (YItemConstIterator it = item->childrenBegin();
702 it != item->childrenEnd(); it++)
703 addNode (*it, &iter);
707 void expand (GtkTreeIter *iter)
709 GtkTreePath *path = gtk_tree_model_get_path (getModel(), iter);
710 gtk_tree_view_expand_row (getView(), path, FALSE);
711 gtk_tree_path_free (path);
714 bool isReallyOpen (YTreeItem *item)
716 for (YTreeItem *i = item; i; i = i->parent())
725 virtual void rebuildTree()
730 for (YItemConstIterator it = YTree::itemsBegin(); it != YTree::itemsEnd(); it++)
733 int depth = getTreeDepth();
734 gtk_tree_view_set_show_expanders (getView(), depth > 1);
735 gtk_tree_view_set_enable_tree_lines (getView(), depth > 3);
740 static gboolean foreach_sync_open (
741 GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
744 YTreeItem *item = (YTreeItem *) pThis->getYItem (iter);
746 gtk_tree_view_expand_row (pThis->getView(), path, FALSE);
751 g_signal_handlers_block_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
752 gtk_tree_model_foreach (getModel(), inner::foreach_sync_open,
this);
753 g_signal_handlers_unblock_by_func (getWidget(), (gpointer) row_expanded_cb,
this);
758 virtual YTreeItem *currentItem()
759 {
return (YTreeItem *) getFocusItem(); }
761 void _markItem (YItem *item,
bool select,
bool recursive) {
763 getTreeIter (item, &iter);
764 setRowMark (&iter, 2, select);
767 YTreeItem *_item = (YTreeItem *) item;
768 for (YItemConstIterator it = _item->childrenBegin();
769 it != _item->childrenEnd(); it++)
770 _markItem (*it, select,
true);
776 void doAddItem (YItem *item) {}
778 void doSelectItem (YItem *item,
bool select)
780 if (hasMultiSelection()) {
781 _markItem (item, select, recursiveSelection());
785 focusItem (item, select);
788 void doDeselectAllItems()
790 if (hasMultiSelection()) {
800 void reportRowOpen (GtkTreeIter *iter,
bool open)
802 YTreeItem *item = static_cast <YTreeItem *> (getYItem (iter));
803 item->setOpen (open);
806 static void row_collapsed_cb (GtkTreeView *view, GtkTreeIter *iter,
807 GtkTreePath *path,
YGTree *pThis)
808 { pThis->reportRowOpen (iter,
false); }
810 static void row_expanded_cb (GtkTreeView *view, GtkTreeIter *iter,
811 GtkTreePath *path,
YGTree *pThis)
812 { pThis->reportRowOpen (iter,
true); }
818 YTreeItem *item = static_cast <YTreeItem *> (pThis->getYItem (iter));
819 for (YItemConstIterator it = item->childrenBegin();
820 it != item->childrenEnd(); it++) {
821 const YTreeItem *child = static_cast <YTreeItem *> (*it);
822 if (child->isOpen()) {
824 if (pThis->getIter (child, &iter))
825 pThis->expand (&iter);
830 YGLABEL_WIDGET_IMPL (YTree)
831 YGSELECTION_WIDGET_IMPL (YTree)
834 YTree *YGWidgetFactory::createTree (YWidget *parent,
const std::string &label,
bool multiselection,
bool recursiveSelection)
835 {
return new YGTree (parent, label, multiselection, recursiveSelection); }