Author: rpmcruz
Date: Thu Dec 23 03:55:50 2010
New Revision: 63029
URL: http://svn.opensuse.org/viewcvs/yast?rev=63029&view=rev
Log:
* Implemented new YTree::multiselection flag.
* Cleaned that portion of the code considerably.
Added:
trunk/gtk/src/YGSelectionStore.cc
trunk/gtk/src/YGSelectionStore.h
trunk/gtk/src/YGTreeView.cc
Removed:
trunk/gtk/src/YGSelectionModel.cc
trunk/gtk/src/YGSelectionModel.h
trunk/gtk/src/YGTable.cc
Modified:
trunk/gtk/src/CMakeLists.txt
trunk/gtk/src/YGComboBox.cc
trunk/gtk/src/YGUI.h
Modified: trunk/gtk/src/CMakeLists.txt
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/CMakeLists.txt?rev=63029&r1=63028&r2=63029&view=diff
==============================================================================
--- trunk/gtk/src/CMakeLists.txt (original)
+++ trunk/gtk/src/CMakeLists.txt Thu Dec 23 03:55:50 2010
@@ -16,9 +16,9 @@
YGPushButton.cc
YGProgressBar.cc
YGRadioButton.cc
- YGSelectionModel.cc
- YGTable.cc
+ YGSelectionStore.cc
YGText.cc
+ YGTreeView.cc
YGUtils.cc
YGUI.cc
YGWidget.cc
Modified: trunk/gtk/src/YGComboBox.cc
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/YGComboBox.cc?rev=63029&r1=63028&r2=63029&view=diff
==============================================================================
--- trunk/gtk/src/YGComboBox.cc (original)
+++ trunk/gtk/src/YGComboBox.cc Thu Dec 23 03:55:50 2010
@@ -7,33 +7,35 @@
#include
#include "YGUtils.h"
#include "YComboBox.h"
-#include "YGSelectionModel.h"
+#include "YGSelectionStore.h"
#include "YGWidget.h"
-class YGComboBox : public YComboBox, public YGLabeledWidget, public YGSelectionModel
+class YGComboBox : public YComboBox, public YGLabeledWidget, public YGSelectionStore
{
public:
YGComboBox (YWidget *parent, const string &label, bool editable)
- : YComboBox (NULL, label, editable)
- , YGLabeledWidget (this, parent, label, YD_HORIZ,
- editable ? GTK_TYPE_COMBO_BOX_ENTRY : GTK_TYPE_COMBO_BOX, NULL)
- , YGSelectionModel (this, true, false)
+ : YComboBox (NULL, label, editable),
+ YGLabeledWidget (this, parent, label, YD_HORIZ,
+ editable ? GTK_TYPE_COMBO_BOX_ENTRY : GTK_TYPE_COMBO_BOX, NULL),
+ YGSelectionStore (false)
{
+ const GType types[2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
+ createStore (2, types);
gtk_combo_box_set_model (getComboBox(), getModel());
- GtkCellRenderer* cell;
+
+ GtkCellRenderer* cell = gtk_cell_renderer_pixbuf_new();
+ gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (getWidget()), cell, FALSE);
+ gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (getWidget()), cell,
+ "pixbuf", 0, NULL);
+
if (editable)
- gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (getWidget()),
- YGSelectionModel::LABEL_COLUMN);
+ gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (getWidget()), 1);
else {
- cell = gtk_cell_renderer_text_new ();
+ cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_end (GTK_CELL_LAYOUT (getWidget()), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (getWidget()), cell,
- "text", YGSelectionModel::LABEL_COLUMN, NULL);
+ "text", 1, NULL);
}
- cell = gtk_cell_renderer_pixbuf_new ();
- gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (getWidget()), cell, FALSE);
- gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (getWidget()), cell,
- "pixbuf", YGSelectionModel::ICON_COLUMN, NULL);
connect (getWidget(), "changed", G_CALLBACK (selected_changed_cb), this);
}
@@ -42,74 +44,70 @@
{ return GTK_COMBO_BOX (getWidget()); }
GtkEntry *getEntry()
+ { return GTK_ENTRY (gtk_bin_get_child (GTK_BIN (getWidget()))); }
+
+ // YGSelectionModel
+
+ void doAddItem (YItem *item)
{
- if (!GTK_IS_COMBO_BOX_ENTRY (getWidget())) {
- yuiError() << "YGComboBox: trying to edit read-only combo box\n";
- return NULL;
- }
+ GtkTreeIter iter;
+ addRow (item, &iter);
+ setRowText (&iter, 0, item->iconName(), 1, item->label(), this);
+ }
- GtkWidget *entry = gtk_bin_get_child (GTK_BIN (getWidget()));
- if (!GTK_IS_ENTRY (entry)) {
- g_error ("YGComboBox: GtkComboBoxEntry doesn't have a GtkEntry as child");
- return NULL;
+ void doSelectItem (YItem *item, bool select)
+ {
+ if (select) {
+ BlockEvents block (this);
+ GtkTreeIter iter;
+ getTreeIter (item, &iter);
+ gtk_combo_box_set_active_iter (getComboBox(), &iter);
}
+ }
- return GTK_ENTRY (entry);
+ void doDeselectAllItems()
+ {
+ BlockEvents block (this);
+ gtk_combo_box_set_active (getComboBox(), -1);
}
- virtual string text()
+ YItem *doSelectedItem()
+ {
+ GtkTreeIter iter;
+ if (gtk_combo_box_get_active_iter (getComboBox(), &iter))
+ return getYItem (&iter);
+ return NULL;
+ }
+
+ // YComboBox
+
+ virtual std::string text()
{
- gchar *str = 0;
+ gchar *str;
if (GTK_IS_COMBO_BOX_ENTRY (getWidget()))
str = gtk_combo_box_get_active_text (getComboBox());
else {
GtkTreeIter iter;
- if (gtk_combo_box_get_active_iter (getComboBox(), &iter)) {
- gchar *str = 0;
- gtk_tree_model_get (getModel(), &iter, LABEL_COLUMN, &str, -1);
- }
- }
- std::string ret;
- if (str) {
- ret = str;
- g_free (str);
+ if (gtk_combo_box_get_active_iter (getComboBox(), &iter))
+ gtk_tree_model_get (getModel(), &iter, 1, &str, -1);
+ else
+ return "";
}
+ std::string ret (str);
+ g_free (str);
return ret;
}
- virtual void setText (const string &value)
+ virtual void setText (const std::string &value)
{
BlockEvents block (this);
GtkTreeIter iter;
- if (findByText (value, &iter))
- doSelectItem (&iter);
+ if (findLabel (1, value, &iter))
+ gtk_combo_box_set_active_iter (getComboBox(), &iter);
else
gtk_entry_set_text (getEntry(), value.c_str());
}
- // YGSelectionModel
- virtual void doSelectItem (GtkTreeIter *iter)
- {
- BlockEvents block (this);
- gtk_combo_box_set_active_iter (getComboBox(), iter);
- }
-
- virtual void doUnselectAll()
- {
- BlockEvents block (this);
- gtk_combo_box_set_active (getComboBox(), -1);
- }
-
-
- virtual YItem *doSelectedItem()
- {
- GtkTreeIter iter;
- if (gtk_combo_box_get_active_iter (getComboBox(), &iter))
- return getItem (&iter);
- return NULL;
- }
-
- // YComboBox
virtual void setInputMaxLength (int length)
{
YComboBox::setInputMaxLength (length);
Added: trunk/gtk/src/YGSelectionStore.cc
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/YGSelectionStore.cc?rev=63029&view=auto
==============================================================================
--- trunk/gtk/src/YGSelectionStore.cc (added)
+++ trunk/gtk/src/YGSelectionStore.cc Thu Dec 23 03:55:50 2010
@@ -0,0 +1,181 @@
+/********************************************************************
+ * YaST2-GTK - http://en.opensuse.org/YaST2-GTK *
+ ********************************************************************/
+
+#define YUILogComponent "gtk"
+#include "config.h"
+#include
+#include
+#include
+#include "YGUtils.h"
+#include "YGSelectionStore.h"
+
+static inline int getYItemCol (GtkTreeModel *model)
+{ return gtk_tree_model_get_n_columns (model) - 2; }
+
+static inline int getRowIdCol (GtkTreeModel *model)
+{ return gtk_tree_model_get_n_columns (model) - 1; }
+
+YGSelectionStore::YGSelectionStore (bool tree)
+: isTree (tree), m_nextRowId (0)
+{}
+
+YGSelectionStore::~YGSelectionStore()
+{ g_object_unref (G_OBJECT (m_model)); }
+
+void YGSelectionStore::createStore (int cols, const GType types[])
+{
+ int _cols = cols + 2;
+ GType _types[_cols];
+ for (int i = 0; i < cols; i++)
+ _types[i] = types[i];
+ _types[cols+0] = G_TYPE_POINTER; // pointer to YItem
+ _types[cols+1] = G_TYPE_POINTER; // some unique value identifying this row
+
+ if (isTree)
+ m_model = GTK_TREE_MODEL (gtk_tree_store_newv (_cols, _types));
+ else
+ m_model = GTK_TREE_MODEL (gtk_list_store_newv (_cols, _types));
+}
+
+void YGSelectionStore::addRow (YItem *item, GtkTreeIter *iter, GtkTreeIter *parent)
+{
+ if (isTree) {
+ GtkTreeStore *store = GTK_TREE_STORE (m_model);
+ gtk_tree_store_append (store, iter, parent);
+ gtk_tree_store_set (store, iter, getYItemCol (m_model), item,
+ getRowIdCol (m_model), m_nextRowId, -1);
+ }
+ else {
+ GtkListStore *store = getListStore();
+ gtk_list_store_append (store, iter);
+ gtk_list_store_set (store, iter, getYItemCol (m_model), item,
+ getRowIdCol (m_model), m_nextRowId, -1);
+ }
+ item->setData (m_nextRowId);
+ m_nextRowId = GINT_TO_POINTER (GPOINTER_TO_INT (m_nextRowId) + 1);
+}
+
+void YGSelectionStore::setRowText (GtkTreeIter *iter, int iconCol, const std::string &icon, int labelCol, const std::string &label, const YSelectionWidget *widget)
+{
+ GdkPixbuf *pixbuf = 0;
+ if (!icon.empty()) {
+ std::string path (widget->iconFullPath (icon));
+ pixbuf = YGUtils::loadPixbuf (path);
+ }
+
+ if (isTree)
+ gtk_tree_store_set (getTreeStore(), iter, iconCol, pixbuf,
+ labelCol, label.c_str(), -1);
+ else
+ gtk_list_store_set (getListStore(), iter, iconCol, pixbuf,
+ labelCol, label.c_str(), -1);
+}
+
+void YGSelectionStore::setRowMark (GtkTreeIter *iter, int markCol, bool mark)
+{
+ if (isTree)
+ gtk_tree_store_set (getTreeStore(), iter, markCol, mark, -1);
+ else
+ gtk_list_store_set (getListStore(), iter, markCol, mark, -1);
+}
+
+void YGSelectionStore::doDeleteAllItems()
+{
+ if (isTree)
+ gtk_tree_store_clear (getTreeStore());
+ else
+ gtk_list_store_clear (getListStore());
+ m_nextRowId = 0;
+}
+
+YItem *YGSelectionStore::getYItem (GtkTreeIter *iter)
+{
+ gpointer ptr;
+ gtk_tree_model_get (m_model, iter, getYItemCol (m_model), &ptr, -1);
+ return (YItem *) ptr;
+}
+
+static GtkTreeIter *found_iter;
+
+void YGSelectionStore::getTreeIter (const YItem *item, GtkTreeIter *iter)
+{
+ struct inner {
+ static gboolean foreach_find (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer find_id)
+ {
+ gpointer id;
+ gtk_tree_model_get (model, iter, getRowIdCol (model), &id, -1);
+ if (id == find_id) {
+ found_iter = gtk_tree_iter_copy (iter);
+ return TRUE;
+ }
+ return FALSE;
+ }
+ };
+
+ found_iter = NULL;
+ gtk_tree_model_foreach (m_model, inner::foreach_find, item->data());
+ *iter = *found_iter;
+ gtk_tree_iter_free (found_iter);
+}
+
+GtkListStore *YGSelectionStore::getListStore()
+{ return GTK_LIST_STORE (m_model); }
+
+GtkTreeStore *YGSelectionStore::getTreeStore()
+{ return GTK_TREE_STORE (m_model); }
+
+bool YGSelectionStore::isEmpty()
+{
+ GtkTreeIter iter;
+ return !gtk_tree_model_get_iter_first (m_model, &iter);
+}
+
+int YGSelectionStore::getTreeDepth()
+{
+ struct inner {
+ static gboolean foreach_max_depth (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _depth)
+ {
+ int *depth = (int *) _depth;
+ *depth = MAX (*depth, gtk_tree_path_get_depth (path));
+ return FALSE;
+ }
+ };
+
+ int depth = 0;
+ gtk_tree_model_foreach (m_model, inner::foreach_max_depth, &depth);
+ return depth;
+}
+
+#include
+static int find_col;
+
+bool YGSelectionStore::findLabel (int labelCol, const std::string &label, GtkTreeIter *iter)
+{
+ struct inner {
+ static gboolean foreach_find (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _value)
+ {
+ gchar *value = (gchar *) _value;
+ gchar *v;
+ gtk_tree_model_get (model, iter, find_col, &v, -1);
+ if (!strcmp (v, value)) {
+ found_iter = gtk_tree_iter_copy (iter);
+ return TRUE;
+ }
+ return FALSE;
+ }
+ };
+
+ find_col = labelCol;
+ found_iter = NULL;
+ gtk_tree_model_foreach (m_model, inner::foreach_find, (gpointer) label.c_str());
+ if (found_iter) {
+ *iter = *found_iter;
+ gtk_tree_iter_free (found_iter);
+ }
+ return found_iter != NULL;
+}
+
Added: trunk/gtk/src/YGSelectionStore.h
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/YGSelectionStore.h?rev=63029&view=auto
==============================================================================
--- trunk/gtk/src/YGSelectionStore.h (added)
+++ trunk/gtk/src/YGSelectionStore.h Thu Dec 23 03:55:50 2010
@@ -0,0 +1,64 @@
+/********************************************************************
+ * YaST2-GTK - http://en.opensuse.org/YaST2-GTK *
+ ********************************************************************/
+
+/* Provides a basic model common to YSelectedWidget widgets. */
+
+#ifndef YGSELECTION_STORE_H
+#define YGSELECTION_STORE_H
+
+#include
+struct YItem;
+struct YSelectionWidget;
+
+struct YGSelectionStore
+{
+ YGSelectionStore (bool tree);
+ virtual ~YGSelectionStore();
+
+ GtkTreeModel *getModel() { return m_model; }
+ void createStore (int cols, const GType types[]);
+
+ void addRow (YItem *item, GtkTreeIter *iter, GtkTreeIter *parent = 0);
+ void setRowText (GtkTreeIter *iter, int iconCol, const std::string &icon,
+ int labelCol, const std::string &label, const YSelectionWidget *widget);
+ void setRowMark (GtkTreeIter *iter, int markCol, bool mark);
+ void doDeleteAllItems();
+
+ YItem *getYItem (GtkTreeIter *iter);
+ void getTreeIter (const YItem *item, GtkTreeIter *iter);
+
+ GtkListStore *getListStore();
+ GtkTreeStore *getTreeStore();
+
+ bool isEmpty();
+ int getTreeDepth();
+
+ bool findLabel (int labelCol, const std::string &label, GtkTreeIter *iter);
+
+protected:
+ GtkTreeModel *m_model;
+ bool isTree;
+ gpointer m_nextRowId;
+};
+
+#define YGSELECTION_WIDGET_IMPL(ParentClass) \
+ virtual void addItem(YItem *item) { \
+ ParentClass::addItem (item); \
+ doAddItem (item); \
+ } \
+ virtual void deleteAllItems() { \
+ ParentClass::deleteAllItems(); \
+ doDeleteAllItems(); \
+ } \
+ virtual void selectItem (YItem *item, bool select) { \
+ ParentClass::selectItem (item, select); \
+ doSelectItem (item, select); \
+ } \
+ virtual void deselectAllItems() { \
+ ParentClass::deselectAllItems(); \
+ doDeselectAllItems(); \
+ }
+
+#endif /*YGSELECTION_STORE_H*/
+
Added: trunk/gtk/src/YGTreeView.cc
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/YGTreeView.cc?rev=63029&view=auto
==============================================================================
--- trunk/gtk/src/YGTreeView.cc (added)
+++ trunk/gtk/src/YGTreeView.cc Thu Dec 23 03:55:50 2010
@@ -0,0 +1,728 @@
+/********************************************************************
+ * YaST2-GTK - http://en.opensuse.org/YaST2-GTK *
+ ********************************************************************/
+/*
+ Textdomain "gtk"
+ */
+
+#include "YGi18n.h"
+#define YUILogComponent "gtk"
+#include "config.h"
+#include "YGUI.h"
+#include "YGUtils.h"
+#include "YGWidget.h"
+#include "YSelectionWidget.h"
+#include "YGSelectionStore.h"
+#include "ygtktreeview.h"
+
+/* A generic widget for table related widgets. */
+
+class YGTreeView : public YGScrolledWidget, public YGSelectionStore
+{
+protected:
+ guint m_blockTimeout;
+
+public:
+ YGTreeView (YWidget *ywidget, YWidget *parent, const string &label, bool tree)
+ : YGScrolledWidget (ywidget, parent, label, YD_VERT, YGTK_TYPE_TREE_VIEW, NULL),
+ YGSelectionStore (tree)
+ {
+ gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (getWidget()), FALSE);
+
+ /* Yast tools expect the user to be unable to un-select the row. They
+ generally don't check to see if the returned value is -1. So, just
+ disallow un-selection. */
+ gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_BROWSE);
+
+ connect (getSelection(), "changed", G_CALLBACK (selection_changed_cb), this);
+ connect (getWidget(), "row-activated", G_CALLBACK (activated_cb), this);
+ connect (getWidget(), "right-click", G_CALLBACK (right_click_cb), this);
+
+ m_blockTimeout = 0; // GtkTreeSelection idiotically fires when showing widget
+ g_signal_connect (getWidget(), "map", G_CALLBACK (block_init_cb), this);
+ }
+
+ virtual ~YGTreeView()
+ { if (m_blockTimeout) g_source_remove (m_blockTimeout); }
+
+ inline GtkTreeView *getView()
+ { return GTK_TREE_VIEW (getWidget()); }
+ inline GtkTreeSelection *getSelection()
+ { return gtk_tree_view_get_selection (getView()); }
+
+ void addTextColumn (int iconCol, int textCol)
+ { addTextColumn ("", YAlignUnchanged, iconCol, textCol); }
+
+ void addTextColumn (const std::string &header, YAlignmentType align, int icon_col, int text_col)
+ {
+ gfloat xalign = -1;
+ switch (align) {
+ case YAlignBegin: xalign = 0.0; break;
+ case YAlignCenter: xalign = 0.5; break;
+ case YAlignEnd: xalign = 1.0; break;
+ case YAlignUnchanged: break;
+ }
+
+ GtkTreeViewColumn *column = gtk_tree_view_column_new();
+ gtk_tree_view_column_set_title (column, header.c_str());
+
+ GtkCellRenderer *renderer;
+ renderer = gtk_cell_renderer_pixbuf_new();
+ gtk_tree_view_column_pack_start (column, renderer, FALSE);
+ gtk_tree_view_column_set_attributes (column, renderer, "pixbuf", icon_col, NULL);
+
+ renderer = gtk_cell_renderer_text_new();
+ gtk_tree_view_column_pack_start (column, renderer, TRUE);
+ gtk_tree_view_column_set_attributes (column, renderer, "text", text_col, NULL);
+ if (xalign != -1)
+ g_object_set (renderer, "xalign", xalign, NULL);
+
+ gtk_tree_view_column_set_resizable (column, TRUE);
+ gtk_tree_view_append_column (getView(), column);
+ }
+
+ void addCheckColumn (int check_col)
+ {
+ GtkCellRenderer *renderer = gtk_cell_renderer_toggle_new();
+ g_object_set_data (G_OBJECT (renderer), "column", GINT_TO_POINTER (check_col));
+ GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes (
+ NULL, renderer, "active", check_col, NULL);
+ g_signal_connect (G_OBJECT (renderer), "toggled",
+ G_CALLBACK (toggled_cb), this);
+
+ gtk_tree_view_column_set_resizable (column, TRUE);
+ gtk_tree_view_append_column (getView(), column);
+ }
+
+ void readModel()
+ { gtk_tree_view_set_model (getView(), getModel()); }
+
+ void focusItem (YItem *item, bool select)
+ {
+ GtkTreeIter iter;
+ getTreeIter (item, &iter);
+ blockSelected();
+
+ if (select) {
+ GtkTreePath *path = gtk_tree_model_get_path (getModel(), &iter);
+ gtk_tree_view_expand_to_path (getView(), path);
+
+ if (gtk_tree_selection_get_mode (getSelection()) != GTK_SELECTION_MULTIPLE)
+ gtk_tree_view_scroll_to_cell (getView(), path, NULL, TRUE, 0.5, 0);
+ gtk_tree_path_free (path);
+
+ gtk_tree_selection_select_iter (getSelection(), &iter);
+ }
+ else
+ gtk_tree_selection_unselect_iter (getSelection(), &iter);
+ }
+
+ void unfocusAllItems()
+ {
+ blockSelected();
+ gtk_tree_selection_unselect_all (getSelection());
+ }
+
+ void unmarkAll()
+ {
+ struct inner {
+ static gboolean foreach_unmark (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
+ {
+ YGTreeView *pThis = (YGTreeView *) _pThis;
+ pThis->setRowMark (iter, pThis->markColumn(), FALSE);
+ return FALSE;
+ }
+ };
+
+ gtk_tree_model_foreach (getModel(), inner::foreach_unmark, this);
+ }
+
+ virtual bool _immediateMode() { return true; }
+ virtual bool _shrinkable() { return false; }
+
+ virtual int markColumn() { return -1; }
+
+ void toggleMark (GtkTreePath *path, gint column)
+ {
+ GtkTreeIter iter;
+ if (!gtk_tree_model_get_iter (getModel(), &iter, path))
+ return;
+
+ gboolean state;
+ gtk_tree_model_get (getModel(), &iter, column, &state, -1);
+ state = !state;
+ setRowMark (&iter, column, state);
+ getYItem (&iter)->setSelected (state);
+ emitEvent (YEvent::ValueChanged);
+ }
+
+ // YGWidget
+
+ virtual unsigned int getMinSize (YUIDimension dim)
+ {
+ if (dim == YD_VERT)
+ return YGUtils::getCharsHeight (getWidget(), _shrinkable() ? 2 : 5);
+ return 80;
+ }
+
+protected:
+ static gboolean block_selected_timeout_cb (gpointer data)
+ {
+ YGTreeView *pThis = (YGTreeView *) data;
+ pThis->m_blockTimeout = 0;
+ return FALSE;
+ }
+
+ void blockSelected()
+ { // GtkTreeSelection only fires when idle; so set a timeout
+ if (m_blockTimeout) g_source_remove (m_blockTimeout);
+ m_blockTimeout = g_timeout_add_full (G_PRIORITY_LOW, 250, block_selected_timeout_cb, this, NULL);
+ }
+
+ static void block_init_cb (GtkWidget *widget, YGTreeView *pThis)
+ { pThis->blockSelected(); }
+
+ // callbacks
+
+ static void selection_changed_cb (GtkTreeSelection *selection, YGTreeView *pThis)
+ {
+ struct inner {
+ static gboolean foreach_sync_select (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
+ {
+ YGTreeView *pThis = (YGTreeView *) _pThis;
+ GtkTreeSelection *selection = pThis->getSelection();
+ bool sel = gtk_tree_selection_iter_is_selected (selection, iter);
+ pThis->getYItem (iter)->setSelected (sel);
+ return FALSE;
+ }
+ };
+
+ if (pThis->m_blockTimeout) return;
+ if (pThis->markColumn() < 0)
+ gtk_tree_model_foreach (pThis->getModel(), inner::foreach_sync_select, pThis);
+ if (pThis->_immediateMode())
+ pThis->emitEvent (YEvent::SelectionChanged, IF_NOT_PENDING_EVENT);
+ }
+
+ static void activated_cb (GtkTreeView *tree_view, GtkTreePath *path,
+ GtkTreeViewColumn *column, YGTreeView* pThis)
+ {
+ if (pThis->markColumn() >= 0)
+ pThis->toggleMark (path, pThis->markColumn());
+ else {
+ // for tree - expand/collpase double-clicked rows
+ if (gtk_tree_view_row_expanded (tree_view, path))
+ gtk_tree_view_collapse_row (tree_view, path);
+ else
+ gtk_tree_view_expand_row (tree_view, path, FALSE);
+
+ pThis->emitEvent (YEvent::Activated);
+ }
+ }
+
+ static void toggled_cb (GtkCellRendererToggle *renderer, gchar *path_str,
+ YGTreeView *pThis)
+ {
+ GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
+ gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (renderer), "column"));
+ pThis->toggleMark (path, column);
+ gtk_tree_path_free (path);
+ }
+
+ static void right_click_cb (YGtkTreeView *view, gboolean outreach, YGTreeView *pThis)
+ { pThis->emitEvent (YEvent::ContextMenuActivated); }
+};
+
+#include "YTable.h"
+#include "YGDialog.h"
+#include
+#include
+
+class YGTable : public YTable, public YGTreeView
+{
+public:
+ YGTable (YWidget *parent, YTableHeader *headers, bool multiSelection)
+ : YTable (NULL, headers, multiSelection),
+ YGTreeView (this, parent, std::string(), false)
+ {
+ gtk_tree_view_set_headers_visible (getView(), TRUE);
+ gtk_tree_view_set_rules_hint (getView(), columns() > 1);
+ ygtk_tree_view_set_empty_text (YGTK_TREE_VIEW (getView()), _("No entries."));
+ if (multiSelection)
+ gtk_tree_selection_set_mode (getSelection(), GTK_SELECTION_MULTIPLE);
+
+ GType types [columns()*2];
+ for (int i = 0; i < columns(); i++) {
+ int t = i*2;
+ types[t+0] = GDK_TYPE_PIXBUF;
+ types[t+1] = G_TYPE_STRING;
+ addTextColumn (header(i), alignment (i), t, t+1);
+ }
+ createStore (columns()*2, types);
+ readModel();
+ if (!keepSorting())
+ setSortable (true);
+
+ // if last col is aligned: add some dummy so that it doesn't expand.
+ YAlignmentType lastAlign = alignment (columns()-1);
+ if (lastAlign == YAlignCenter || lastAlign == YAlignEnd)
+ gtk_tree_view_append_column (getView(), gtk_tree_view_column_new());
+
+ g_signal_connect (getWidget(), "key-press-event", G_CALLBACK (key_press_event_cb), this);
+ }
+
+ void setSortable (bool sortable)
+ {
+ if (!sortable && !GTK_WIDGET_REALIZED (getWidget()))
+ return;
+ int n = 0;
+ GList *columns = gtk_tree_view_get_columns (getView());
+ for (GList *i = columns; i; i = i->next, n++) {
+ GtkTreeViewColumn *column = (GtkTreeViewColumn *) i->data;
+ if (n >= YGTable::columns())
+ break;
+ if (sortable) {
+ int index = (n*2)+1;
+ if (!sortable)
+ index = -1;
+ gtk_tree_sortable_set_sort_func (
+ GTK_TREE_SORTABLE (getModel()), index, tree_sort_cb,
+ GINT_TO_POINTER (index), NULL);
+ gtk_tree_view_column_set_sort_column_id (column, index);
+ }
+ else
+ gtk_tree_view_column_set_sort_column_id (column, -1);
+ }
+ g_list_free (columns);
+ }
+
+ void setCell (GtkTreeIter *iter, int column, const YTableCell *cell)
+ {
+ std::string label (cell->label());
+ if (label == "X")
+ label = YUI::app()->glyph (YUIGlyph_CheckMark);
+
+ int index = column * 2;
+ setRowText (iter, index, cell->iconName(), index+1, label, this);
+ }
+
+ // YGTreeView
+
+ virtual bool _immediateMode() { return immediateMode(); }
+
+ // YTable
+
+ virtual void setKeepSorting (bool keepSorting)
+ {
+ YTable::setKeepSorting (keepSorting);
+ setSortable (!keepSorting);
+ if (!keepSorting) {
+ GtkTreeViewColumn *column = gtk_tree_view_get_column (getView(), 0);
+ if (column)
+ gtk_tree_view_column_clicked (column);
+ }
+ }
+
+ virtual void cellChanged (const YTableCell *cell)
+ {
+ GtkTreeIter iter;
+ getTreeIter (cell->parent(), &iter);
+ setCell (&iter, cell->column(), cell);
+ }
+
+ // YGSelectionStore
+
+ void doAddItem (YItem *_item)
+ {
+ YTableItem *item = dynamic_cast (_item);
+ if (item) {
+ GtkTreeIter iter;
+ addRow (item, &iter);
+ for (int i = 0; i < columns(); i++)
+ setCell (&iter, i, item->cell(i));
+ if (item->selected())
+ focusItem (item, true);
+ }
+ else
+ yuiError() << "Can only add YTableItems to a YTable.\n";
+ }
+
+ void doSelectItem (YItem *item, bool select)
+ { focusItem (item, select); }
+
+ void doDeselectAllItems()
+ { unfocusAllItems(); }
+
+ // callbacks
+
+ static void activateButton (YWidget *button)
+ {
+ YWidgetEvent *event = new YWidgetEvent (button, YEvent::Activated);
+ YGUI::ui()->sendEvent (event);
+ }
+
+ static void hack_right_click_cb (YGtkTreeView *view, gboolean outreach, YGTable *pThis)
+ {
+ if (pThis->notifyContextMenu())
+ return YGTreeView::right_click_cb (view, outreach, pThis);
+
+ // If no context menu is specified, hack one ;-)
+
+ struct inner {
+ static void key_activate_cb (GtkMenuItem *item, YWidget *button)
+ { activateButton (button); }
+ static void appendItem (GtkWidget *menu, const gchar *stock, int key)
+ {
+ YWidget *button = YGDialog::currentDialog()->getFunctionWidget (key);
+ if (button) {
+ GtkWidget *item;
+ item = gtk_image_menu_item_new_from_stock (stock, NULL);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+ g_signal_connect (G_OBJECT (item), "activate",
+ G_CALLBACK (key_activate_cb), button);
+ }
+ }
+ };
+
+ GtkWidget *menu = gtk_menu_new();
+ YGDialog *dialog = YGDialog::currentDialog();
+ if (dialog->getClassWidgets ("YTable").size() == 1) {
+ // if more than one table exists, function keys would be ambiguous
+ if (outreach) {
+ if (dialog->getFunctionWidget(3))
+ inner::appendItem (menu, GTK_STOCK_ADD, 3);
+ }
+ else {
+ if (dialog->getFunctionWidget(4))
+ inner::appendItem (menu, GTK_STOCK_EDIT, 4);
+ if (dialog->getFunctionWidget(5))
+ inner::appendItem (menu, GTK_STOCK_DELETE, 5);
+ }
+ }
+
+ menu = ygtk_tree_view_append_show_columns_item (YGTK_TREE_VIEW (view), menu);
+ ygtk_tree_view_popup_menu (view, menu);
+ }
+
+ static gboolean key_press_event_cb (GtkWidget *widget, GdkEventKey *event, YGTable *pThis)
+ {
+ if (event->keyval == GDK_Delete) {
+ YWidget *button = YGDialog::currentDialog()->getFunctionWidget (5);
+ if (button)
+ activateButton (button);
+ else
+ gtk_widget_error_bell (widget);
+ return TRUE;
+ }
+ return FALSE;
+ }
+
+ static gint tree_sort_cb (
+ GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, gpointer _index)
+ {
+ int index = GPOINTER_TO_INT (_index);
+ gchar *str_a, *str_b;
+ gtk_tree_model_get (model, a, index, &str_a, -1);
+ gtk_tree_model_get (model, b, index, &str_b, -1);
+ if (!str_a) str_a = g_strdup ("");
+ if (!str_b) str_b = g_strdup ("");
+ int ret = strcmp (str_a, str_b);
+ g_free (str_a); g_free (str_b);
+ return ret;
+ }
+
+ YGLABEL_WIDGET_IMPL (YTable)
+ YGSELECTION_WIDGET_IMPL (YTable)
+};
+
+YTable *YGWidgetFactory::createTable (YWidget *parent, YTableHeader *headers,
+ bool multiSelection)
+{
+ return new YGTable (parent, headers, multiSelection);
+}
+
+#include "YSelectionBox.h"
+
+class YGSelectionBox : public YSelectionBox, public YGTreeView
+{
+public:
+ YGSelectionBox (YWidget *parent, const string &label)
+ : YSelectionBox (NULL, label),
+ YGTreeView (this, parent, label, false)
+ {
+ GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
+ addTextColumn (0, 1);
+ createStore (2, types);
+ readModel();
+ }
+
+ // YGTreeView
+
+ virtual bool _shrinkable() { return shrinkable(); }
+
+ // YGSelectionStore
+
+ void doAddItem (YItem *item)
+ {
+ GtkTreeIter iter;
+ addRow (item, &iter);
+ setRowText (&iter, 0, item->iconName(), 1, item->label(), this);
+ if (item->selected())
+ focusItem (item, true);
+ }
+
+ void doSelectItem (YItem *item, bool select)
+ { focusItem (item, select); }
+
+ void doDeselectAllItems()
+ { unfocusAllItems(); }
+
+ YGLABEL_WIDGET_IMPL (YSelectionBox)
+ YGSELECTION_WIDGET_IMPL (YSelectionBox)
+};
+
+YSelectionBox *YGWidgetFactory::createSelectionBox (YWidget *parent, const string &label)
+{ return new YGSelectionBox (parent, label); }
+
+#include "YMultiSelectionBox.h"
+
+class YGMultiSelectionBox : public YMultiSelectionBox, public YGTreeView
+{
+public:
+ YGMultiSelectionBox (YWidget *parent, const string &label)
+ : YMultiSelectionBox (NULL, label),
+ YGTreeView (this, parent, label, false)
+ {
+ GType types [3] = { G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING };
+ addCheckColumn (0);
+ addTextColumn (1, 2);
+ createStore (3, types);
+ readModel();
+ }
+
+ // YGTreeView
+
+ virtual bool _shrinkable() { return shrinkable(); }
+ virtual int markColumn() { return 0; }
+
+ // YGSelectionStore
+
+ void doAddItem (YItem *item)
+ {
+ GtkTreeIter iter;
+ addRow (item, &iter);
+ setRowMark (&iter, 0, item->selected());
+ setRowText (&iter, 1, item->iconName(), 2, item->label(), this);
+ }
+
+ void doSelectItem (YItem *item, bool select)
+ {
+ GtkTreeIter iter;
+ getTreeIter (item, &iter);
+ setRowMark (&iter, 0, select);
+ }
+
+ void doDeselectAllItems()
+ { unmarkAll(); }
+
+ // YMultiSelectionBox
+
+ virtual YItem *currentItem()
+ {
+ GtkTreeIter iter;
+ if (gtk_tree_selection_get_selected (getSelection(), NULL, &iter))
+ return getYItem (&iter);
+ return NULL;
+ }
+
+ virtual void setCurrentItem (YItem *item)
+ { focusItem (item, true); }
+
+ YGLABEL_WIDGET_IMPL (YMultiSelectionBox)
+ YGSELECTION_WIDGET_IMPL (YMultiSelectionBox)
+};
+
+YMultiSelectionBox *YGWidgetFactory::createMultiSelectionBox (YWidget *parent, const string &label)
+{ return new YGMultiSelectionBox (parent, label); }
+
+#include "YTree.h"
+#include "YTreeItem.h"
+
+class YGTree : public YTree, public YGTreeView
+{
+public:
+#if YAST2_VERSION >= 2019002
+ YGTree (YWidget *parent, const string &label, bool multiselection)
+ : YTree (NULL, label, multiselection),
+#else
+ YGTree (YWidget *parent, const string &label)
+ : YTree (NULL, label),
+#endif
+ YGTreeView (this, parent, label, true)
+ {
+#if YAST2_VERSION >= 2019002
+ if (multiselection) {
+ GType types [3] = { GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_BOOLEAN };
+ addCheckColumn (2);
+ addTextColumn (0, 1);
+ createStore (3, types);
+ }
+ else
+#else
+ {
+ GType types [2] = { GDK_TYPE_PIXBUF, G_TYPE_STRING };
+ addTextColumn (0, 1);
+ createStore (2, types);
+ }
+#endif
+ readModel();
+
+ g_signal_connect (getWidget(), "row-collapsed", G_CALLBACK (row_collapsed_cb), this);
+ g_signal_connect (getWidget(), "row-expanded", G_CALLBACK (row_expanded_cb), this);
+ }
+
+ void addNode (YItem *item, GtkTreeIter *parent)
+ {
+ GtkTreeIter iter;
+ addRow (item, &iter, parent);
+ setRowText (&iter, 0, item->iconName(), 1, item->label(), this);
+ if (item->selected()) {
+#if YAST2_VERSION >= 2019002
+ if (hasMultiSelection())
+ setRowMark (&iter, 2, item->selected());
+ else
+#endif
+ focusItem (item, true);
+ }
+/* if (((YTreeItem *) item)->isOpen())
+ expand (&iter);*/
+ for (YItemConstIterator it = item->childrenBegin();
+ it != item->childrenEnd(); it++)
+ addNode (*it, &iter);
+ }
+
+/*
+ void expand (GtkTreeIter *iter)
+ {
+ GtkTreePath *path = gtk_tree_model_get_path (getModel(), iter);
+ gtk_tree_view_expand_row (getView(), path, FALSE);
+ gtk_tree_path_free (path);
+ }
+
+ bool isReallyOpen (YTreeItem *item) // are parents open as well?
+ {
+ for (YTreeItem *i = item; i; i = i->parent())
+ if (!i->isOpen())
+ return false;
+ return true;
+ }
+*/
+
+ // YTree
+
+ virtual void rebuildTree()
+ {
+ doDeleteAllItems();
+ for (YItemConstIterator it = YTree::itemsBegin(); it != YTree::itemsEnd(); it++)
+ addNode (*it, NULL);
+
+ int depth = getTreeDepth();
+ gtk_tree_view_set_show_expanders (getView(), depth > 1);
+ gtk_tree_view_set_enable_tree_lines (getView(), depth > 3);
+
+ // for whatever reason, we need to expand nodes only after the model
+ // is fully initialized
+ struct inner {
+ static gboolean foreach_sync_open (
+ GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer _pThis)
+ {
+ YGTree *pThis = (YGTree *) _pThis;
+ YTreeItem *item = (YTreeItem *) pThis->getYItem (iter);
+ if (item->isOpen())
+ gtk_tree_view_expand_row (pThis->getView(), path, FALSE);
+ return FALSE;
+ }
+ };
+
+ gtk_tree_model_foreach (getModel(), inner::foreach_sync_open, this);
+ }
+
+ // YGTreeView
+
+#if YAST2_VERSION >= 2019002
+ virtual int markColumn() { return hasMultiSelection() ? 2 : -1; }
+#endif
+
+ // YGSelectionStore
+
+ void doAddItem (YItem *item) {} // rebuild will be called anyway
+
+ void doSelectItem (YItem *item, bool select)
+ {
+#if YAST2_VERSION >= 2019002
+ if (hasMultiSelection()) {
+ GtkTreeIter iter;
+ getTreeIter (item, &iter);
+ setRowMark (&iter, 2, select);
+ }
+ else
+#endif
+ focusItem (item, select);
+ }
+
+ void doDeselectAllItems()
+ {
+#if YAST2_VERSION >= 2019002
+ if (hasMultiSelection())
+ unmarkAll();
+ else
+#endif
+ unfocusAllItems();
+ }
+
+ // callbacks
+
+ void reportRowOpen (GtkTreeIter *iter, bool open)
+ {
+ YTreeItem *item = static_cast (getYItem (iter));
+ item->setOpen (open);
+ }
+
+ static void row_collapsed_cb (GtkTreeView *view, GtkTreeIter *iter,
+ GtkTreePath *path, YGTree *pThis)
+ { pThis->reportRowOpen (iter, false); }
+
+ static void row_expanded_cb (GtkTreeView *view, GtkTreeIter *iter,
+ GtkTreePath *path, YGTree *pThis)
+ { pThis->reportRowOpen (iter, true); }
+
+#if 0
+ // we do a bit of a work-around here to mimic -qt behavior... A node can
+ // be initialized as open, yet its parent, or some grand-parent, be closed.
+ // We thus honor the open state when its parent gets open.
+ YTreeItem *item = static_cast (pThis->getYItem (iter));
+ for (YItemConstIterator it = item->childrenBegin();
+ it != item->childrenEnd(); it++) {
+ const YTreeItem *child = static_cast (*it);
+ if (child->isOpen()) {
+ GtkTreeIter iter;
+ if (pThis->getIter (child, &iter))
+ pThis->expand (&iter);
+ }
+ }
+#endif
+
+ YGLABEL_WIDGET_IMPL (YTree)
+ YGSELECTION_WIDGET_IMPL (YTree)
+};
+
+#if YAST2_VERSION >= 2019002
+YTree *YGWidgetFactory::createTree (YWidget *parent, const string &label, bool multiselection)
+{ return new YGTree (parent, label, multiselection); }
+#else
+YTree *YGWidgetFactory::createTree (YWidget *parent, const string &label)
+{ return new YGTree (parent, label); }
+#endif
+
Modified: trunk/gtk/src/YGUI.h
URL: http://svn.opensuse.org/viewcvs/yast/trunk/gtk/src/YGUI.h?rev=63029&r1=63028&r2=63029&view=diff
==============================================================================
--- trunk/gtk/src/YGUI.h (original)
+++ trunk/gtk/src/YGUI.h Thu Dec 23 03:55:50 2010
@@ -89,12 +89,12 @@
virtual YRadioButton *createRadioButton (YWidget *parent, const string &label, bool isChecked);
virtual YComboBox *createComboBox (YWidget *parent, const string & label, bool editable);
virtual YSelectionBox *createSelectionBox (YWidget *parent, const string &label);
- virtual YTree *createTree (YWidget *parent, const string &label);
-#if YAST2_VERSION >= 2017005
- virtual YTable *createTable (YWidget *parent, YTableHeader *headers, bool multiSelection);
+#if YAST2_VERSION >= 2019002
+ virtual YTree *createTree (YWidget *parent, const string &label, bool multiselection);
#else
- virtual YTable *createTable (YWidget *parent, YTableHeader *headers);
+ virtual YTree *createTree (YWidget *parent, const string &label);
#endif
+ virtual YTable *createTable (YWidget *parent, YTableHeader *headers, bool multiSelection);
virtual YProgressBar *createProgressBar (YWidget *parent, const string &label, int maxValue);
virtual YBusyIndicator *createBusyIndicator (YWidget *parent, const string &label, int timeout);
virtual YRichText *createRichText (YWidget *parent, const string &text, bool plainTextMode);
@@ -110,9 +110,7 @@
virtual YWidget *createPkgSpecial (YWidget * parent, const string & subwidgetName) RET (NULL) // for ncurses
virtual YLayoutBox *createLayoutBox (YWidget *parent, YUIDimension dimension);
-#if YAST2_VERSION >= 2017006
virtual YButtonBox *createButtonBox (YWidget *parent);
-#endif
virtual YSpacing *createSpacing (YWidget *parent, YUIDimension dim, bool stretchable, YLayoutSize_t size);
virtual YEmpty *createEmpty (YWidget *parent);
@@ -224,9 +222,7 @@
virtual bool richTextSupportsTable() RET (false)
#endif
-#if YAST2_VERSION > 2018003
virtual bool openContextMenu (const YItemCollection &itemCollection);
-#endif
private:
// for screenshots:
--
To unsubscribe, e-mail: yast-commit+unsubscribe@opensuse.org
For additional commands, e-mail: yast-commit+help@opensuse.org
