1333 lines
30 KiB
C++
1333 lines
30 KiB
C++
/*
|
|
* moocpp/gobjtypes-gtk.cpp
|
|
*
|
|
* Copyright (C) 2004-2016 by Yevgen Muntyan <emuntyan@users.sourceforge.net>
|
|
*
|
|
* This file is part of medit. medit is free software; you can
|
|
* redistribute it and/or modify it under the terms of the
|
|
* GNU Lesser General Public License as published by the
|
|
* Free Software Foundation; either version 2.1 of the License,
|
|
* or (at your option) any later version.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with medit. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "moocpp/moocpp.h"
|
|
|
|
using namespace moo;
|
|
using namespace moo::gtk;
|
|
|
|
#if 0
|
|
|
|
namespace moo {
|
|
|
|
namespace _test {
|
|
|
|
void test()
|
|
{
|
|
ListStorePtr m1 = wrap_new (gtk_list_store_new (1, G_TYPE_STRING));
|
|
TreeStorePtr m2 = wrap_new (gtk_tree_store_new (1, G_TYPE_STRING));
|
|
TreeModelPtr m3 = wrap_new<GtkTreeModel> (GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING)));
|
|
ListStorePtr m4 = ListStore::create ({ G_TYPE_STRING });
|
|
|
|
if (true)
|
|
return;
|
|
|
|
//gobj_ptr<GtkTreeModel> m4 = m1;
|
|
|
|
//create_cpp_gobj<A>();
|
|
//init_cpp_gobj(a);
|
|
|
|
//GtkObject* xyz = nullptr;
|
|
//init_cpp_gobj(xyz);
|
|
|
|
//create_cpp_gobj<GtkToolbar>(GTK_TYPE_TOOLBAR);
|
|
|
|
{
|
|
gobj_ptr<GtkObject> p;
|
|
gobj_ref<GtkObject> r = *p;
|
|
GtkObject* o1 = r.gobj();
|
|
GtkObject* o2 = p->gobj();
|
|
g_assert(o1 == o2);
|
|
GObject* o = p.gobj<GObject>();
|
|
g_assert(o == nullptr);
|
|
GtkObject* x = p.gobj<GtkObject>();
|
|
GObject* y = p.gobj<GObject>();
|
|
g_assert((void*) x == (void*) y);
|
|
const GObject* c1 = p;
|
|
const GtkObject* c2 = p;
|
|
g_assert((void*) c1 == (void*) c2);
|
|
}
|
|
|
|
{
|
|
gobj_ptr<GtkWidget> p = wrap_new(gtk_widget_new(0, "blah", nullptr, nullptr));
|
|
gobj_ref<GtkWidget> r = *p;
|
|
GtkWidget* o1 = r.gobj();
|
|
GtkWidget* o2 = p->gobj();
|
|
g_assert(o1 == o2);
|
|
GtkWidget* x = p.gobj<GtkWidget>();
|
|
GtkWidget* y = p.gobj();
|
|
GtkObject* z = p.gobj<GtkObject>();
|
|
GObject* t = p.gobj<GObject>();
|
|
g_assert((void*) x == (void*) y);
|
|
g_assert((void*) z == (void*) t);
|
|
const GObject* c1 = p;
|
|
const GtkObject* c2 = p;
|
|
const GtkWidget* c3 = p;
|
|
g_assert((void*) c1 == (void*) c2);
|
|
g_assert((void*) c1 == (void*) c3);
|
|
|
|
gobj_ref<GtkWidget> or(*p.gobj());
|
|
or.freeze_notify();
|
|
p->freeze_notify();
|
|
|
|
gobj_raw_ptr<GtkWidget> rp = p.gobj();
|
|
}
|
|
}
|
|
|
|
} // namespace _test
|
|
} // namespace moo
|
|
|
|
#endif // 0
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkObject
|
|
//
|
|
|
|
void
|
|
Object::destroy ()
|
|
{
|
|
gtk_object_destroy (gobj ());
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkTreeModel
|
|
//
|
|
|
|
GtkTreeModelFlags
|
|
TreeModel::get_flags ()
|
|
{
|
|
return gtk_tree_model_get_flags (gobj ());
|
|
}
|
|
|
|
int
|
|
TreeModel::get_n_columns ()
|
|
{
|
|
return gtk_tree_model_get_n_columns (gobj ());
|
|
}
|
|
|
|
GType
|
|
TreeModel::get_column_type (int index_)
|
|
{
|
|
return gtk_tree_model_get_column_type (gobj (), index_);
|
|
}
|
|
|
|
bool
|
|
TreeModel::get_iter (GtkTreeIter& iter, const GtkTreePath& path)
|
|
{
|
|
return gtk_tree_model_get_iter (gobj (), &iter, const_cast<GtkTreePath*>(&path));
|
|
}
|
|
|
|
bool
|
|
TreeModel::get_iter_from_string (GtkTreeIter& iter, const char* path_string)
|
|
{
|
|
return gtk_tree_model_get_iter_from_string (gobj (), &iter, path_string);
|
|
}
|
|
|
|
gstr
|
|
TreeModel::get_string_from_iter (const GtkTreeIter& iter)
|
|
{
|
|
return gstr::wrap_new (gtk_tree_model_get_string_from_iter (gobj (), const_cast<GtkTreeIter*>(&iter)));
|
|
}
|
|
|
|
bool
|
|
TreeModel::get_iter_first (GtkTreeIter& iter)
|
|
{
|
|
return gtk_tree_model_get_iter_first (gobj (), &iter);
|
|
}
|
|
|
|
GtkTreePath*
|
|
TreeModel::get_path (const GtkTreeIter& iter)
|
|
{
|
|
return gtk_tree_model_get_path (gobj (), const_cast<GtkTreeIter*>(&iter));
|
|
}
|
|
|
|
void
|
|
TreeModel::get_value (const GtkTreeIter& iter, int column, GValue* value)
|
|
{
|
|
gtk_tree_model_get_value (gobj (), const_cast<GtkTreeIter*>(&iter), column, value);
|
|
}
|
|
|
|
bool
|
|
TreeModel::iter_next (GtkTreeIter& iter)
|
|
{
|
|
return gtk_tree_model_iter_next (gobj (), &iter);
|
|
}
|
|
|
|
bool
|
|
TreeModel::iter_children (GtkTreeIter& iter, const GtkTreeIter& parent)
|
|
{
|
|
return gtk_tree_model_iter_children (gobj (), &iter, const_cast<GtkTreeIter*>(&parent));
|
|
}
|
|
|
|
bool
|
|
TreeModel::iter_has_child (const GtkTreeIter& iter)
|
|
{
|
|
return gtk_tree_model_iter_has_child (gobj (), const_cast<GtkTreeIter*>(&iter));
|
|
}
|
|
|
|
int
|
|
TreeModel::iter_n_children (const GtkTreeIter& iter)
|
|
{
|
|
return gtk_tree_model_iter_n_children (gobj (), const_cast<GtkTreeIter*>(&iter));
|
|
}
|
|
|
|
bool
|
|
TreeModel::iter_nth_child (GtkTreeIter& iter, const GtkTreeIter& parent, int n)
|
|
{
|
|
return gtk_tree_model_iter_nth_child (gobj (), &iter, const_cast<GtkTreeIter*>(&parent), n);
|
|
}
|
|
|
|
bool
|
|
TreeModel::iter_parent (GtkTreeIter& iter, const GtkTreeIter& child)
|
|
{
|
|
return gtk_tree_model_iter_parent (gobj (), &iter, const_cast<GtkTreeIter*>(&child));
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkListStore
|
|
//
|
|
|
|
ListStorePtr
|
|
ListStore::create (size_t n_types, const GType* types)
|
|
{
|
|
g_return_val_if_fail (types != nullptr, nullptr);
|
|
g_return_val_if_fail (n_types != 0, nullptr);
|
|
return wrap_new (gtk_list_store_newv (n_types, const_cast<GType*>(types)));
|
|
}
|
|
|
|
void
|
|
ListStore::set_value (const GtkTreeIter& iter,
|
|
int column,
|
|
GValue* value)
|
|
{
|
|
gtk_list_store_set_value (gobj (), const_cast<GtkTreeIter*>(&iter), column, value);
|
|
}
|
|
|
|
void
|
|
ListStore::set_valuesv (const GtkTreeIter& iter,
|
|
int* columns,
|
|
GValue* values,
|
|
int n_values)
|
|
{
|
|
gtk_list_store_set_valuesv (gobj (), const_cast<GtkTreeIter*>(&iter), columns, values, n_values);
|
|
}
|
|
|
|
bool
|
|
ListStore::remove (GtkTreeIter& iter)
|
|
{
|
|
return gtk_list_store_remove (gobj (), &iter);
|
|
}
|
|
|
|
void
|
|
ListStore::insert (GtkTreeIter& iter,
|
|
int position)
|
|
{
|
|
gtk_list_store_insert (gobj (), &iter, position);
|
|
}
|
|
|
|
void
|
|
ListStore::insert_before (GtkTreeIter& iter,
|
|
GtkTreeIter& sibling)
|
|
{
|
|
gtk_list_store_insert_before (gobj (), &iter, &sibling);
|
|
}
|
|
|
|
void
|
|
ListStore::insert_after (GtkTreeIter& iter,
|
|
GtkTreeIter& sibling)
|
|
{
|
|
gtk_list_store_insert_after (gobj (), &iter, &sibling);
|
|
}
|
|
|
|
//void
|
|
//ListStore::insert_with_values (GtkTreeIter* iter,
|
|
// int position,
|
|
// ...)
|
|
//{
|
|
// gtk_list_store_insert_with_values (gobj (), &iter, position, ...);
|
|
//}
|
|
//
|
|
//void
|
|
//ListStore::insert_with_values (GtkTreeIter* iter,
|
|
// int position,
|
|
// int* columns,
|
|
// GValue* values,
|
|
// int n_values)
|
|
//{
|
|
// gtk_list_store_insert_with_values (gobj (), &iter, position, columns, values, n_values);
|
|
//}
|
|
|
|
void
|
|
ListStore::prepend (GtkTreeIter& iter)
|
|
{
|
|
gtk_list_store_prepend (gobj (), &iter);
|
|
}
|
|
|
|
void
|
|
ListStore::append (GtkTreeIter& iter)
|
|
{
|
|
gtk_list_store_append (gobj (), &iter);
|
|
}
|
|
|
|
void
|
|
ListStore::clear ()
|
|
{
|
|
gtk_list_store_clear (gobj ());
|
|
}
|
|
|
|
bool
|
|
ListStore::iter_is_valid (const GtkTreeIter& iter)
|
|
{
|
|
return gtk_list_store_iter_is_valid (gobj (), const_cast<GtkTreeIter*>(&iter));
|
|
}
|
|
|
|
void
|
|
ListStore::reorder (int* new_order)
|
|
{
|
|
gtk_list_store_reorder (gobj (), new_order);
|
|
}
|
|
|
|
void
|
|
ListStore::swap (GtkTreeIter& a,
|
|
GtkTreeIter& b)
|
|
{
|
|
gtk_list_store_swap (gobj (), &a, &b);
|
|
}
|
|
|
|
void
|
|
ListStore::move_after (GtkTreeIter& iter,
|
|
GtkTreeIter& position)
|
|
{
|
|
gtk_list_store_move_after (gobj (), &iter, &position);
|
|
}
|
|
|
|
void
|
|
ListStore::move_before (GtkTreeIter& iter,
|
|
GtkTreeIter& position)
|
|
{
|
|
gtk_list_store_move_before (gobj (), &iter, &position);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkTreeView
|
|
//
|
|
|
|
TreeViewPtr
|
|
TreeView::create (TreeModelPtr model)
|
|
{
|
|
GtkWidget* w = model ? gtk_tree_view_new_with_model (model->gobj ()) : gtk_tree_view_new ();
|
|
return w ? wrap_new (GTK_TREE_VIEW (w)) : nullptr;
|
|
}
|
|
|
|
TreeModelPtr
|
|
TreeView::get_model ()
|
|
{
|
|
return wrap (gtk_tree_view_get_model (gobj()));
|
|
}
|
|
|
|
void
|
|
TreeView::set_model (TreeModelPtr model)
|
|
{
|
|
gtk_tree_view_set_model (gobj (), model ? model->gobj () : nullptr);
|
|
}
|
|
|
|
GtkTreeSelection*
|
|
TreeView::get_selection ()
|
|
{
|
|
return gtk_tree_view_get_selection (gobj ());
|
|
}
|
|
|
|
GtkAdjustment*
|
|
TreeView::get_hadjustment ()
|
|
{
|
|
return gtk_tree_view_get_hadjustment (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_hadjustment (GtkAdjustment* adjustment)
|
|
{
|
|
gtk_tree_view_set_hadjustment (gobj (), adjustment);
|
|
}
|
|
|
|
GtkAdjustment*
|
|
TreeView::get_vadjustment ()
|
|
{
|
|
return gtk_tree_view_get_vadjustment (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_vadjustment (GtkAdjustment* adjustment)
|
|
{
|
|
gtk_tree_view_set_vadjustment (gobj (), adjustment);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_headers_visible ()
|
|
{
|
|
return gtk_tree_view_get_headers_visible (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_headers_visible (bool headers_visible)
|
|
{
|
|
gtk_tree_view_set_headers_visible (gobj (), headers_visible);
|
|
}
|
|
|
|
void
|
|
TreeView::columns_autosize ()
|
|
{
|
|
gtk_tree_view_columns_autosize (gobj ());
|
|
}
|
|
|
|
bool
|
|
TreeView::get_headers_clickable ()
|
|
{
|
|
return gtk_tree_view_get_headers_clickable (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_headers_clickable (bool setting)
|
|
{
|
|
gtk_tree_view_set_headers_clickable (gobj (), setting);
|
|
}
|
|
|
|
void
|
|
TreeView::set_rules_hint (bool setting)
|
|
{
|
|
gtk_tree_view_set_rules_hint (gobj (), setting);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_rules_hint ()
|
|
{
|
|
return gtk_tree_view_get_rules_hint (gobj ());
|
|
}
|
|
|
|
int
|
|
TreeView::append_column (TreeViewColumn& column)
|
|
{
|
|
return gtk_tree_view_append_column (gobj (), column.gobj ());
|
|
}
|
|
|
|
int
|
|
TreeView::remove_column (TreeViewColumn& column)
|
|
{
|
|
return gtk_tree_view_remove_column (gobj (), column.gobj ());
|
|
}
|
|
|
|
int
|
|
TreeView::insert_column (TreeViewColumn& column,
|
|
int position)
|
|
{
|
|
return gtk_tree_view_insert_column (gobj (), column.gobj (), position);
|
|
}
|
|
|
|
//int
|
|
//TreeView::insert_column_with_attributes (int position,
|
|
// const char* title,
|
|
// CellRenderer& cell,
|
|
// ...)
|
|
//{
|
|
// gtk_tree_view_insert_column_with_attributes (gobj (), position,
|
|
// const char* title,
|
|
// CellRenderer& cell,
|
|
// ...);
|
|
//}
|
|
|
|
TreeViewColumnPtr
|
|
TreeView::get_column (int n)
|
|
{
|
|
return wrap_new (gtk_tree_view_get_column (gobj (), n));
|
|
}
|
|
|
|
std::vector<TreeViewColumnPtr>
|
|
TreeView::get_columns ()
|
|
{
|
|
GList* list = gtk_tree_view_get_columns (gobj ());
|
|
auto ret = object_list_to_vector<GtkTreeViewColumn> (list);
|
|
g_list_free (list);
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
TreeView::move_column_after (TreeViewColumn& column,
|
|
TreeViewColumn& base_column)
|
|
{
|
|
return gtk_tree_view_move_column_after (gobj (), column.gobj (), base_column.gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_expander_column (TreeViewColumn& column)
|
|
{
|
|
return gtk_tree_view_set_expander_column (gobj (), column.gobj ());
|
|
}
|
|
|
|
TreeViewColumnPtr
|
|
TreeView::get_expander_column ()
|
|
{
|
|
return wrap (gtk_tree_view_get_expander_column (gobj ()));
|
|
}
|
|
|
|
void
|
|
TreeView::set_column_drag_function (GtkTreeViewColumnDropFunc func,
|
|
gpointer user_data,
|
|
GDestroyNotify destroy)
|
|
{
|
|
gtk_tree_view_set_column_drag_function (gobj (), func, user_data, destroy);
|
|
}
|
|
|
|
void
|
|
TreeView::scroll_to_point (int tree_x,
|
|
int tree_y)
|
|
{
|
|
gtk_tree_view_scroll_to_point (gobj (), tree_x, tree_y);
|
|
}
|
|
|
|
void
|
|
TreeView::scroll_to_cell (GtkTreePath* path,
|
|
TreeViewColumn& column,
|
|
bool use_align,
|
|
float row_align,
|
|
float col_align)
|
|
{
|
|
gtk_tree_view_scroll_to_cell (gobj (), path, column.gobj (), use_align, row_align, col_align);
|
|
}
|
|
|
|
void
|
|
TreeView::row_activated (GtkTreePath* path,
|
|
TreeViewColumn& column)
|
|
{
|
|
gtk_tree_view_row_activated (gobj (), path, column.gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::expand_all ()
|
|
{
|
|
gtk_tree_view_expand_all (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::collapse_all ()
|
|
{
|
|
gtk_tree_view_collapse_all (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::expand_to_path (GtkTreePath* path)
|
|
{
|
|
gtk_tree_view_expand_to_path (gobj (), path);
|
|
}
|
|
|
|
bool
|
|
TreeView::expand_row (GtkTreePath* path,
|
|
bool open_all)
|
|
{
|
|
return gtk_tree_view_expand_row (gobj (), path, open_all);
|
|
}
|
|
|
|
bool
|
|
TreeView::collapse_row (GtkTreePath* path)
|
|
{
|
|
return gtk_tree_view_collapse_row (gobj (), path);
|
|
}
|
|
|
|
void
|
|
TreeView::map_expanded_rows (GtkTreeViewMappingFunc func,
|
|
gpointer data)
|
|
{
|
|
gtk_tree_view_map_expanded_rows (gobj (), func, data);
|
|
}
|
|
|
|
bool
|
|
TreeView::row_expanded (GtkTreePath* path)
|
|
{
|
|
return gtk_tree_view_row_expanded (gobj (), path);
|
|
}
|
|
|
|
void
|
|
TreeView::set_reorderable (bool reorderable)
|
|
{
|
|
gtk_tree_view_set_reorderable (gobj (), reorderable);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_reorderable ()
|
|
{
|
|
return gtk_tree_view_get_reorderable (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_cursor (GtkTreePath* path,
|
|
TreeViewColumn& focus_column,
|
|
bool start_editing)
|
|
{
|
|
gtk_tree_view_set_cursor (gobj (), path, focus_column.gobj (), start_editing);
|
|
}
|
|
|
|
void
|
|
TreeView::set_cursor_on_cell (GtkTreePath* path,
|
|
TreeViewColumn& focus_column,
|
|
CellRenderer& focus_cell,
|
|
bool start_editing)
|
|
{
|
|
gtk_tree_view_set_cursor_on_cell (gobj (), path, focus_column.gobj (), focus_cell.gobj (), start_editing);
|
|
}
|
|
|
|
void
|
|
TreeView::get_cursor (GtkTreePath** path,
|
|
TreeViewColumnPtr& focus_column)
|
|
{
|
|
GtkTreeViewColumn* col = nullptr;
|
|
gtk_tree_view_get_cursor (gobj (), path, &col);
|
|
focus_column.set (col);
|
|
}
|
|
|
|
GdkWindow*
|
|
TreeView::get_bin_window ()
|
|
{
|
|
return gtk_tree_view_get_bin_window (gobj ());
|
|
}
|
|
|
|
bool
|
|
TreeView::get_path_at_pos (int x,
|
|
int y,
|
|
GtkTreePath** path,
|
|
TreeViewColumnPtr& column,
|
|
int* cell_x,
|
|
int* cell_y)
|
|
{
|
|
GtkTreeViewColumn* col = nullptr;
|
|
bool ret = gtk_tree_view_get_path_at_pos (gobj (), x, y, path, &col, cell_x, cell_y);
|
|
column.set (col);
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
TreeView::get_cell_area (GtkTreePath* path,
|
|
TreeViewColumn& column,
|
|
GdkRectangle& rect)
|
|
{
|
|
gtk_tree_view_get_cell_area (gobj (), path, column.gobj(), &rect);
|
|
}
|
|
|
|
void
|
|
TreeView::get_background_area (GtkTreePath* path,
|
|
TreeViewColumn& column,
|
|
GdkRectangle& rect)
|
|
{
|
|
gtk_tree_view_get_background_area (gobj (), path, column.gobj (), &rect);
|
|
}
|
|
|
|
void
|
|
TreeView::get_visible_rect (GdkRectangle& visible_rect)
|
|
{
|
|
gtk_tree_view_get_visible_rect (gobj (), &visible_rect);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_visible_range (GtkTreePath** start_path,
|
|
GtkTreePath** end_path)
|
|
{
|
|
return gtk_tree_view_get_visible_range (gobj (), start_path, end_path);
|
|
}
|
|
|
|
void
|
|
TreeView::enable_model_drag_source (GdkModifierType start_button_mask,
|
|
const GtkTargetEntry* targets,
|
|
int n_targets,
|
|
GdkDragAction actions)
|
|
{
|
|
gtk_tree_view_enable_model_drag_source (gobj (), start_button_mask,
|
|
targets, n_targets, actions);
|
|
}
|
|
|
|
void
|
|
TreeView::enable_model_drag_dest (const GtkTargetEntry* targets,
|
|
int n_targets,
|
|
GdkDragAction actions)
|
|
{
|
|
gtk_tree_view_enable_model_drag_dest (gobj (), targets, n_targets, actions);
|
|
}
|
|
|
|
void
|
|
TreeView::unset_rows_drag_source ()
|
|
{
|
|
gtk_tree_view_unset_rows_drag_source (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::unset_rows_drag_dest ()
|
|
{
|
|
gtk_tree_view_unset_rows_drag_dest (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_drag_dest_row (GtkTreePath* path,
|
|
GtkTreeViewDropPosition pos)
|
|
{
|
|
gtk_tree_view_set_drag_dest_row (gobj (), path, pos);
|
|
}
|
|
|
|
void
|
|
TreeView::get_drag_dest_row (GtkTreePath** path,
|
|
GtkTreeViewDropPosition* pos)
|
|
{
|
|
gtk_tree_view_get_drag_dest_row (gobj (), path, pos);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_dest_row_at_pos (int drag_x,
|
|
int drag_y,
|
|
GtkTreePath** path,
|
|
GtkTreeViewDropPosition* pos)
|
|
{
|
|
return gtk_tree_view_get_dest_row_at_pos (gobj (), drag_x, drag_y, path, pos);
|
|
}
|
|
|
|
GdkPixmap*
|
|
TreeView::create_row_drag_icon (GtkTreePath* path)
|
|
{
|
|
return gtk_tree_view_create_row_drag_icon (gobj (), path);
|
|
}
|
|
|
|
void
|
|
TreeView::set_enable_search (bool enable_search)
|
|
{
|
|
gtk_tree_view_set_enable_search (gobj (), enable_search);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_enable_search ()
|
|
{
|
|
return gtk_tree_view_get_enable_search (gobj ());
|
|
}
|
|
|
|
int
|
|
TreeView::get_search_column ()
|
|
{
|
|
return gtk_tree_view_get_search_column (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_search_column (int column)
|
|
{
|
|
gtk_tree_view_set_search_column (gobj (), column);
|
|
}
|
|
|
|
GtkTreeViewSearchEqualFunc
|
|
TreeView::get_search_equal_func ()
|
|
{
|
|
return gtk_tree_view_get_search_equal_func (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_search_equal_func (GtkTreeViewSearchEqualFunc search_equal_func,
|
|
gpointer search_user_data,
|
|
GDestroyNotify search_destroy)
|
|
{
|
|
gtk_tree_view_set_search_equal_func (gobj (), search_equal_func, search_user_data, search_destroy);
|
|
}
|
|
|
|
GtkEntry*
|
|
TreeView::get_search_entry ()
|
|
{
|
|
return gtk_tree_view_get_search_entry (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_search_entry (GtkEntry* entry)
|
|
{
|
|
gtk_tree_view_set_search_entry (gobj (), entry);
|
|
}
|
|
|
|
GtkTreeViewSearchPositionFunc
|
|
TreeView::get_search_position_func ()
|
|
{
|
|
return gtk_tree_view_get_search_position_func (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_search_position_func (GtkTreeViewSearchPositionFunc func,
|
|
gpointer data,
|
|
GDestroyNotify destroy)
|
|
{
|
|
gtk_tree_view_set_search_position_func (gobj (), func, data, destroy);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_widget_to_tree_coords (int wx,
|
|
int wy,
|
|
int* tx,
|
|
int* ty)
|
|
{
|
|
gtk_tree_view_convert_widget_to_tree_coords (gobj (), wx, wy, tx, ty);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_tree_to_widget_coords (int tx,
|
|
int ty,
|
|
int* wx,
|
|
int* wy)
|
|
{
|
|
gtk_tree_view_convert_tree_to_widget_coords (gobj (), tx, ty, wx, wy);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_widget_to_bin_window_coords (int wx,
|
|
int wy,
|
|
int* bx,
|
|
int* by)
|
|
{
|
|
gtk_tree_view_convert_widget_to_bin_window_coords (gobj (), wx, wy, bx, by);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_bin_window_to_widget_coords (int bx,
|
|
int by,
|
|
int* wx,
|
|
int* wy)
|
|
{
|
|
gtk_tree_view_convert_bin_window_to_widget_coords (gobj (), bx, by, wx, wy);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_tree_to_bin_window_coords (int tx,
|
|
int ty,
|
|
int* bx,
|
|
int* by)
|
|
{
|
|
gtk_tree_view_convert_tree_to_bin_window_coords (gobj (), tx, ty, bx, by);
|
|
}
|
|
|
|
void
|
|
TreeView::convert_bin_window_to_tree_coords (int bx,
|
|
int by,
|
|
int* tx,
|
|
int* ty)
|
|
{
|
|
gtk_tree_view_convert_bin_window_to_tree_coords (gobj (), bx, by, tx, ty);
|
|
}
|
|
|
|
void
|
|
TreeView::set_fixed_height_mode (bool enable)
|
|
{
|
|
gtk_tree_view_set_fixed_height_mode (gobj (), enable);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_fixed_height_mode ()
|
|
{
|
|
return gtk_tree_view_get_fixed_height_mode (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_hover_selection (bool hover)
|
|
{
|
|
gtk_tree_view_set_hover_selection (gobj (), hover);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_hover_selection ()
|
|
{
|
|
return gtk_tree_view_get_hover_selection (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_hover_expand (bool expand)
|
|
{
|
|
gtk_tree_view_set_hover_expand (gobj (), expand);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_hover_expand ()
|
|
{
|
|
return gtk_tree_view_get_hover_expand (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_rubber_banding (bool enable)
|
|
{
|
|
gtk_tree_view_set_rubber_banding (gobj (), enable);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_rubber_banding ()
|
|
{
|
|
return gtk_tree_view_get_rubber_banding (gobj ());
|
|
}
|
|
|
|
bool
|
|
TreeView::is_rubber_banding_active ()
|
|
{
|
|
return gtk_tree_view_is_rubber_banding_active (gobj ());
|
|
}
|
|
|
|
GtkTreeViewRowSeparatorFunc
|
|
TreeView::get_row_separator_func ()
|
|
{
|
|
return gtk_tree_view_get_row_separator_func (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_row_separator_func (GtkTreeViewRowSeparatorFunc func,
|
|
gpointer data,
|
|
GDestroyNotify destroy)
|
|
{
|
|
gtk_tree_view_set_row_separator_func (gobj (), func, data, destroy);
|
|
}
|
|
|
|
GtkTreeViewGridLines
|
|
TreeView::get_grid_lines ()
|
|
{
|
|
return gtk_tree_view_get_grid_lines (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_grid_lines (GtkTreeViewGridLines grid_lines)
|
|
{
|
|
gtk_tree_view_set_grid_lines (gobj (), grid_lines);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_enable_tree_lines ()
|
|
{
|
|
return gtk_tree_view_get_enable_tree_lines (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_enable_tree_lines (bool enabled)
|
|
{
|
|
gtk_tree_view_set_enable_tree_lines (gobj (), enabled);
|
|
}
|
|
|
|
void
|
|
TreeView::set_show_expanders (bool enabled)
|
|
{
|
|
gtk_tree_view_set_show_expanders (gobj (), enabled);
|
|
}
|
|
|
|
bool
|
|
TreeView::get_show_expanders ()
|
|
{
|
|
return gtk_tree_view_get_show_expanders (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_level_indentation (int indentation)
|
|
{
|
|
gtk_tree_view_set_level_indentation (gobj (), indentation);
|
|
}
|
|
|
|
int
|
|
TreeView::get_level_indentation ()
|
|
{
|
|
return gtk_tree_view_get_level_indentation (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeView::set_tooltip_row (GtkTooltip* tooltip,
|
|
GtkTreePath* path)
|
|
{
|
|
gtk_tree_view_set_tooltip_row (gobj (), tooltip, path);
|
|
}
|
|
|
|
void
|
|
TreeView::set_tooltip_cell (GtkTooltip* tooltip,
|
|
GtkTreePath* path,
|
|
TreeViewColumn& column,
|
|
CellRenderer& cell)
|
|
{
|
|
gtk_tree_view_set_tooltip_cell (gobj (), tooltip, path, column.gobj (), cell.gobj ());
|
|
}
|
|
|
|
bool
|
|
TreeView::get_tooltip_context (int* x,
|
|
int* y,
|
|
bool keyboard_tip,
|
|
GtkTreeModel** model,
|
|
GtkTreePath** path,
|
|
GtkTreeIter* iter)
|
|
{
|
|
return gtk_tree_view_get_tooltip_context (gobj (), x, y, keyboard_tip, model, path, iter);
|
|
}
|
|
|
|
void
|
|
TreeView::set_tooltip_column (int column)
|
|
{
|
|
gtk_tree_view_set_tooltip_column (gobj (), column);
|
|
}
|
|
|
|
int
|
|
TreeView::get_tooltip_column ()
|
|
{
|
|
return gtk_tree_view_get_tooltip_column (gobj ());
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkTreeViewColumn
|
|
//
|
|
|
|
TreeViewColumnPtr
|
|
TreeViewColumn::create ()
|
|
{
|
|
return wrap_new (gtk_tree_view_column_new ());
|
|
}
|
|
|
|
//TreeViewColumnPtr
|
|
//TreeViewColumn::create (const char* title,
|
|
// CellRendererPtr cell,
|
|
// ...)
|
|
//{
|
|
//}
|
|
|
|
void
|
|
TreeViewColumn::pack_start (CellRenderer& cell, bool expand)
|
|
{
|
|
gtk_tree_view_column_pack_start (gobj (), cell.gobj(), expand);
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::pack_end (CellRenderer& cell, bool expand)
|
|
{
|
|
gtk_tree_view_column_pack_end (gobj (), cell.gobj (), expand);
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::clear ()
|
|
{
|
|
gtk_tree_view_column_clear (gobj ());
|
|
}
|
|
|
|
std::vector<CellRendererPtr>
|
|
TreeViewColumn::get_cell_renderers ()
|
|
{
|
|
GList* list = gtk_tree_view_column_get_cell_renderers (gobj ());
|
|
auto ret = object_list_to_vector<GtkCellRenderer> (list);
|
|
g_list_free (list);
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::add_attribute (CellRenderer& cell,
|
|
const char* attribute,
|
|
int column)
|
|
{
|
|
gtk_tree_view_column_add_attribute (gobj (), cell.gobj (), attribute, column);
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_attributes (gtk::CellRenderer& cell_renderer, const char* prop, int column)
|
|
{
|
|
gtk_tree_view_column_set_attributes (gobj (), cell_renderer.gobj (), prop, column, nullptr);
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::clear_attributes (CellRenderer& cell_renderer)
|
|
{
|
|
gtk_tree_view_column_clear_attributes (gobj (), cell_renderer.gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_spacing (int spacing)
|
|
{
|
|
gtk_tree_view_column_set_spacing (gobj (), spacing);
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_spacing ()
|
|
{
|
|
return gtk_tree_view_column_get_spacing (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_visible (bool visible)
|
|
{
|
|
gtk_tree_view_column_set_visible (gobj (), visible);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_visible ()
|
|
{
|
|
return gtk_tree_view_column_get_visible (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_resizable (bool resizable)
|
|
{
|
|
gtk_tree_view_column_set_resizable (gobj (), resizable);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_resizable ()
|
|
{
|
|
return gtk_tree_view_column_get_resizable (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_sizing (GtkTreeViewColumnSizing type)
|
|
{
|
|
gtk_tree_view_column_set_sizing (gobj (), type);
|
|
}
|
|
|
|
GtkTreeViewColumnSizing
|
|
TreeViewColumn::get_sizing ()
|
|
{
|
|
return gtk_tree_view_column_get_sizing (gobj ());
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_width ()
|
|
{
|
|
return gtk_tree_view_column_get_width (gobj ());
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_fixed_width ()
|
|
{
|
|
return gtk_tree_view_column_get_fixed_width (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_fixed_width (int fixed_width)
|
|
{
|
|
gtk_tree_view_column_set_fixed_width (gobj (), fixed_width);
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_min_width (int min_width)
|
|
{
|
|
gtk_tree_view_column_set_min_width (gobj (), min_width);
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_min_width ()
|
|
{
|
|
return gtk_tree_view_column_get_min_width (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_max_width (int max_width)
|
|
{
|
|
gtk_tree_view_column_set_max_width (gobj (), max_width);
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_max_width ()
|
|
{
|
|
return gtk_tree_view_column_get_max_width (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::clicked ()
|
|
{
|
|
gtk_tree_view_column_clicked (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_title (const char* title)
|
|
{
|
|
gtk_tree_view_column_set_title (gobj (), title);
|
|
}
|
|
|
|
gstr
|
|
TreeViewColumn::get_title ()
|
|
{
|
|
return gstr::wrap (gtk_tree_view_column_get_title (gobj ()));
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_expand (bool expand)
|
|
{
|
|
gtk_tree_view_column_set_expand (gobj (), expand);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_expand ()
|
|
{
|
|
return gtk_tree_view_column_get_expand (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_clickable (bool clickable)
|
|
{
|
|
gtk_tree_view_column_set_clickable (gobj (), clickable);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_clickable ()
|
|
{
|
|
return gtk_tree_view_column_get_clickable (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_widget (WidgetPtr widget)
|
|
{
|
|
gtk_tree_view_column_set_widget (gobj (), widget.gobj ());
|
|
}
|
|
|
|
WidgetPtr
|
|
TreeViewColumn::get_widget ()
|
|
{
|
|
return wrap (gtk_tree_view_column_get_widget (gobj ()));
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_alignment (float xalign)
|
|
{
|
|
gtk_tree_view_column_set_alignment (gobj (), xalign);
|
|
}
|
|
|
|
float
|
|
TreeViewColumn::get_alignment ()
|
|
{
|
|
return gtk_tree_view_column_get_alignment (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_reorderable (bool reorderable)
|
|
{
|
|
gtk_tree_view_column_set_reorderable (gobj (), reorderable);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_reorderable ()
|
|
{
|
|
return gtk_tree_view_column_get_reorderable (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_sort_column_id (int sort_column_id)
|
|
{
|
|
gtk_tree_view_column_set_sort_column_id (gobj (), sort_column_id);
|
|
}
|
|
|
|
int
|
|
TreeViewColumn::get_sort_column_id ()
|
|
{
|
|
return gtk_tree_view_column_get_sort_column_id (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_sort_indicator (bool setting)
|
|
{
|
|
gtk_tree_view_column_set_sort_indicator (gobj (), setting);
|
|
}
|
|
|
|
bool
|
|
TreeViewColumn::get_sort_indicator ()
|
|
{
|
|
return gtk_tree_view_column_get_sort_indicator (gobj ());
|
|
}
|
|
|
|
void
|
|
TreeViewColumn::set_sort_order (GtkSortType order)
|
|
{
|
|
gtk_tree_view_column_set_sort_order (gobj (), order);
|
|
}
|
|
|
|
GtkSortType
|
|
TreeViewColumn::get_sort_order ()
|
|
{
|
|
return gtk_tree_view_column_get_sort_order (gobj ());
|
|
}
|
|
|
|
TreeViewPtr
|
|
TreeViewColumn::get_tree_view ()
|
|
{
|
|
GtkWidget* w = gtk_tree_view_column_get_tree_view (gobj ());
|
|
return w ? wrap (GTK_TREE_VIEW (w)) : nullptr;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkCellRenderer
|
|
//
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkCellRendererText
|
|
//
|
|
|
|
gtk::CellRendererTextPtr
|
|
CellRendererText::create ()
|
|
{
|
|
return wrap_new (up_cast<GtkCellRendererText> (gtk_cell_renderer_text_new ()));
|
|
}
|
|
|
|
void CellRendererText::set_fixed_height_from_font (int number_of_rows)
|
|
{
|
|
gtk_cell_renderer_text_set_fixed_height_from_font (gobj (), number_of_rows);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkCellRendererPixbuf
|
|
//
|
|
|
|
gtk::CellRendererPixbufPtr
|
|
CellRendererPixbuf::create ()
|
|
{
|
|
return wrap_new (up_cast<GtkCellRendererPixbuf> (gtk_cell_renderer_pixbuf_new ()));
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GtkCellRendererToggle
|
|
//
|
|
|
|
gtk::CellRendererTogglePtr
|
|
CellRendererToggle::create ()
|
|
{
|
|
return wrap_new (up_cast<GtkCellRendererToggle> (gtk_cell_renderer_toggle_new ()));
|
|
}
|
|
|
|
bool
|
|
CellRendererToggle::get_radio ()
|
|
{
|
|
return gtk_cell_renderer_toggle_get_radio (gobj ());
|
|
}
|
|
|
|
void
|
|
CellRendererToggle::set_radio (bool radio)
|
|
{
|
|
gtk_cell_renderer_toggle_set_radio (gobj (), radio);
|
|
}
|
|
|
|
bool
|
|
CellRendererToggle::get_active ()
|
|
{
|
|
return gtk_cell_renderer_toggle_get_active (gobj ());
|
|
}
|
|
|
|
void
|
|
CellRendererToggle::set_active (bool active)
|
|
{
|
|
gtk_cell_renderer_toggle_set_active (gobj(), active);
|
|
}
|