#include "wx/log.h"
#include "wx/dcclient.h"
#include "wx/sizer.h"
+ #include "wx/icon.h"
+ #include "wx/list.h"
+ #include "wx/settings.h"
+ #include "wx/crt.h"
#endif
#include "wx/stockitem.h"
#include "wx/calctrl.h"
#include "wx/popupwin.h"
-#include "wx/icon.h"
-#include "wx/list.h"
#include "wx/listimpl.cpp"
-
#include "wx/gtk/private.h"
-#include "wx/gtk/win_gtk.h"
-
-#include <gobject/gvaluecollector.h>
-#include <gtk/gtktreemodel.h>
-#include <gtk/gtktreesortable.h>
-#include <gtk/gtktreednd.h>
-
-#include <gdk/gdkkeysyms.h>
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
WX_DECLARE_LIST(wxDataViewItem, ItemList);
-WX_DEFINE_LIST(ItemList);
+WX_DEFINE_LIST(ItemList)
class wxDataViewCtrlInternal
{
void SetSortColumn( int column ) { m_sort_column = column; }
int GetSortColumn() { return m_sort_column; }
+ void SetDataViewSortColumn( wxDataViewColumn *column ) { m_dataview_sort_column = column; }
+ wxDataViewColumn *GetDataViewSortColumn() { return m_dataview_sort_column; }
+
bool IsSorted() { return (m_sort_column >= 0); }
GtkWxTreeModel *m_gtk_model;
wxDataViewCtrl *m_owner;
GtkSortType m_sort_order;
+ wxDataViewColumn *m_dataview_sort_column;
int m_sort_column;
};
void *id = child->GetItem().GetID();
m_children.Add( id );
-#if 0
- if (m_internal->IsSorted())
+
+ if (m_internal->IsSorted() || m_internal->GetDataViewModel()->HasDefaultCompare())
{
g_internal = m_internal;
m_children.Sort( &wxGtkTreeModelChildCmp );
return m_children.Index( id );
}
-#endif
+
return m_children.GetCount()-1;
}
unsigned int AddLeave( void* id )
{
m_children.Add( id );
-#if 0
- if (m_internal->IsSorted())
+
+ if (m_internal->IsSorted() || m_internal->GetDataViewModel()->HasDefaultCompare())
{
g_internal = m_internal;
m_children.Sort( &wxGtkTreeModelChildCmp );
return m_children.Index( id );
}
-#endif
+
return m_children.GetCount()-1;
}
gtype = G_TYPE_STRING;
else
{
- wxFAIL_MSG( _T("non-string columns not supported yet") );
+ gtype = G_TYPE_STRING;
+ // wxFAIL_MSG( _T("non-string columns not supported yet") );
}
return gtype;
return TRUE;
}
+wxDataViewColumn *gs_lastLeftClickHeader = NULL;
+
void wxgtk_tree_model_set_sort_column_id (GtkTreeSortable *sortable,
gint sort_column_id,
GtkSortType order)
GtkWxTreeModel *tree_model = (GtkWxTreeModel *) sortable;
g_return_if_fail (GTK_IS_WX_TREE_MODEL (sortable) );
- if ((sort_column_id == (gint) tree_model->internal->GetSortColumn()) &&
- (order == tree_model->internal->GetSortOrder()))
- return;
+ tree_model->internal->SetDataViewSortColumn( gs_lastLeftClickHeader );
- tree_model->internal->SetSortColumn( sort_column_id );
-
- tree_model->internal->SetSortOrder( order );
+ if ((sort_column_id != (gint) tree_model->internal->GetSortColumn()) ||
+ (order != tree_model->internal->GetSortOrder()))
+ {
+ tree_model->internal->SetSortColumn( sort_column_id );
+ tree_model->internal->SetSortOrder( order );
- gtk_tree_sortable_sort_column_changed (sortable);
+ gtk_tree_sortable_sort_column_changed (sortable);
- tree_model->internal->GetDataViewModel()->Resort();
+ tree_model->internal->GetDataViewModel()->Resort();
+ }
- wxDataViewCtrl *dv = tree_model->internal->GetOwner();
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, dv->GetId() );
- // TODO event.SetDataViewColumn( column );
- event.SetModel( dv->GetModel() );
- dv->GetEventHandler()->ProcessEvent( event );
+ if (gs_lastLeftClickHeader)
+ {
+ wxDataViewCtrl *dv = tree_model->internal->GetOwner();
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED, dv->GetId() );
+ event.SetDataViewColumn( gs_lastLeftClickHeader );
+ event.SetModel( dv->GetModel() );
+ dv->GetEventHandler()->ProcessEvent( event );
+ }
+
+ gs_lastLeftClickHeader = NULL;
}
void wxgtk_tree_model_set_sort_func (GtkTreeSortable *sortable,
GtkWxCellRenderer *wxrenderer = (GtkWxCellRenderer *) renderer;
wxDataViewCustomRenderer *cell = wxrenderer->cell;
+ cell->window = window;
+ cell->widget = widget;
+ cell->background_area = (void*) background_area;
+ cell->cell_area = (void*) cell_area;
+ cell->expose_area = (void*) expose_area;
+ cell->flags = (int) flags;
+
GdkRectangle rect;
gtk_wx_cell_renderer_get_size (renderer, widget, cell_area,
&rect.x,
wxDataViewModel *model = cell->GetOwner()->GetOwner()->GetModel();
GtkTreePath *treepath = gtk_tree_path_new_from_string( path );
- // TODO
- wxDataViewItem item;
+
+ GtkTreeIter iter;
+ cell->GetOwner()->GetOwner()->GtkGetInternal()->get_iter( &iter, treepath );
+ wxDataViewItem item( iter.user_data );
gtk_tree_path_free( treepath );
unsigned int model_col = cell->GetOwner()->GetModelColumn();
// wxDataViewRenderer
// ---------------------------------------------------------
+static gpointer s_user_data = NULL;
+
+static void
+wxgtk_cell_editable_editing_done( GtkCellEditable *editable,
+ wxDataViewRenderer *wxrenderer )
+{
+ wxDataViewColumn *column = wxrenderer->GetOwner();
+ wxDataViewCtrl *dv = column->GetOwner();
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE, dv->GetId() );
+ event.SetDataViewColumn( column );
+ event.SetModel( dv->GetModel() );
+ wxDataViewItem item( s_user_data );
+ event.SetItem( item );
+ dv->GetEventHandler()->ProcessEvent( event );
+}
+
+static void
+wxgtk_renderer_editing_started( GtkCellRenderer *cell, GtkCellEditable *editable,
+ gchar *path, wxDataViewRenderer *wxrenderer )
+{
+ wxDataViewColumn *column = wxrenderer->GetOwner();
+ wxDataViewCtrl *dv = column->GetOwner();
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED, dv->GetId() );
+ event.SetDataViewColumn( column );
+ event.SetModel( dv->GetModel() );
+ GtkTreePath *tree_path = gtk_tree_path_new_from_string( path );
+ GtkTreeIter iter;
+ dv->GtkGetInternal()->get_iter( &iter, tree_path );
+ gtk_tree_path_free( tree_path );
+ wxDataViewItem item( iter.user_data );
+ event.SetItem( item );
+ dv->GetEventHandler()->ProcessEvent( event );
+
+ if (GTK_IS_CELL_EDITABLE(editable))
+ {
+ s_user_data = iter.user_data;
+
+ g_signal_connect (GTK_CELL_EDITABLE (editable), "editing_done",
+ G_CALLBACK (wxgtk_cell_editable_editing_done),
+ (gpointer) wxrenderer );
+
+ }
+}
+
+
IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer, wxDataViewRendererBase)
wxDataViewRenderer::wxDataViewRenderer( const wxString &varianttype, wxDataViewCellMode mode,
// after the m_renderer pointer has been initialized
}
+void wxDataViewRenderer::GtkInitHandlers()
+{
+ if (!gtk_check_version(2,6,0))
+ {
+ g_signal_connect (GTK_CELL_RENDERER(m_renderer), "editing_started",
+ G_CALLBACK (wxgtk_renderer_editing_started),
+ this);
+ }
+}
+
void wxDataViewRenderer::SetMode( wxDataViewCellMode mode )
{
GtkCellRendererMode gtkMode;
break;
}
+ // This value is most often ignored in GtkTreeView
GValue gvalue = { 0, };
g_value_init( &gvalue, gtk_cell_renderer_mode_get_type() );
g_value_set_enum( &gvalue, gtkMode );
g_value_unset( &gvalue );
g_signal_connect_after( m_renderer, "edited", G_CALLBACK(wxGtkTextRendererEditedCallback), this );
+
+ GtkInitHandlers();
}
SetMode(mode);
GValue gvalue = { 0, };
g_value_init( &gvalue, G_TYPE_STRING );
- g_value_set_string( &gvalue, wxGTK_CONV_FONT( tmp, GetOwner()->GetOwner()->GetFont() ) );
+ g_value_set_string( &gvalue, wxGTK_CONV( tmp ) );
g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
g_value_unset( &gvalue );
GValue gvalue = { 0, };
g_value_init( &gvalue, G_TYPE_STRING );
g_object_get_property( G_OBJECT(m_renderer), "text", &gvalue );
- wxString tmp = wxGTK_CONV_BACK_FONT( g_value_get_string( &gvalue ),
- wx_const_cast(wxDataViewTextRenderer*, this)->GetOwner()->GetOwner()->GetFont() );
+ wxString tmp = wxGTK_CONV_BACK( g_value_get_string( &gvalue ) );
g_value_unset( &gvalue );
value = tmp;
wxDataViewRenderer( varianttype, mode, align )
{
m_dc = NULL;
+ m_text_renderer = NULL;
if (no_init)
m_renderer = NULL;
Init(mode, align);
}
+void wxDataViewCustomRenderer::RenderText( const wxString &text, int xoffset, wxRect cell, wxDC *dc, int state )
+{
+#if 0
+ wxDataViewCtrl *view = GetOwner()->GetOwner();
+ wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ?
+ wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) :
+ view->GetForegroundColour();
+ dc->SetTextForeground(col);
+ dc->DrawText( text, cell.x + xoffset, cell.y + ((cell.height - dc->GetCharHeight()) / 2));
+#else
+ if (!m_text_renderer)
+ m_text_renderer = gtk_cell_renderer_text_new();
+
+ GValue gvalue = { 0, };
+ g_value_init( &gvalue, G_TYPE_STRING );
+ g_value_set_string( &gvalue, wxGTK_CONV( text ) );
+ g_object_set_property( G_OBJECT(m_text_renderer), "text", &gvalue );
+ g_value_unset( &gvalue );
+
+ ((GdkRectangle*) cell_area)->x += xoffset;
+ ((GdkRectangle*) cell_area)->width -= xoffset;
+
+ gtk_cell_renderer_render( m_text_renderer,
+ window,
+ widget,
+ (GdkRectangle*) background_area,
+ (GdkRectangle*) cell_area,
+ (GdkRectangle*) expose_area,
+ (GtkCellRendererState) flags );
+
+ ((GdkRectangle*) cell_area)->x -= xoffset;
+ ((GdkRectangle*) cell_area)->width += xoffset;
+#endif
+}
+
bool wxDataViewCustomRenderer::Init(wxDataViewCellMode mode, int align)
{
GtkWxCellRenderer *renderer = (GtkWxCellRenderer *) gtk_wx_cell_renderer_new();
SetMode(mode);
SetAlignment(align);
+ GtkInitHandlers();
+
return true;
}
{
if (m_dc)
delete m_dc;
+
+ if (m_text_renderer)
+ gtk_object_sink( GTK_OBJECT(m_text_renderer) );
}
wxDC *wxDataViewCustomRenderer::GetDC()
GValue gvalue = { 0, };
g_value_init( &gvalue, G_TYPE_STRING );
- // FIXME: font encoding support
- g_value_set_string( &gvalue, wxGTK_CONV_SYS(m_label) );
+ g_value_set_string( &gvalue, wxGTK_CONV(m_label) );
g_object_set_property( G_OBJECT(m_renderer), "text", &gvalue );
g_value_unset( &gvalue );
{
dc->SetFont( GetOwner()->GetOwner()->GetFont() );
wxString tmp = m_date.FormatDate();
- dc->DrawText( tmp, cell.x, cell.y );
-
+ RenderText( tmp, 0, cell, dc, state );
return true;
}
return true;
}
+
+// ---------------------------------------------------------
+// wxDataViewIconTextRenderer
+// ---------------------------------------------------------
+
+IMPLEMENT_CLASS(wxDataViewIconTextRenderer, wxDataViewCustomRenderer)
+
+wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(
+ const wxString &varianttype, wxDataViewCellMode mode, int align ) :
+ wxDataViewCustomRenderer( varianttype, mode, align )
+{
+ SetMode(mode);
+ SetAlignment(align);
+}
+
+wxDataViewIconTextRenderer::~wxDataViewIconTextRenderer()
+{
+}
+
+bool wxDataViewIconTextRenderer::SetValue( const wxVariant &value )
+{
+ m_value << value;
+ return true;
+}
+
+bool wxDataViewIconTextRenderer::GetValue( wxVariant &value ) const
+{
+ return false;
+}
+
+bool wxDataViewIconTextRenderer::Render( wxRect cell, wxDC *dc, int state )
+{
+ const wxIcon &icon = m_value.GetIcon();
+ int offset = 0;
+ if (icon.IsOk())
+ {
+ int yoffset = wxMax( 0, (cell.height - icon.GetHeight()) / 2 );
+ dc->DrawIcon( icon, cell.x, cell.y + yoffset );
+ offset = icon.GetWidth() + 4;
+ }
+
+ RenderText( m_value.GetText(), offset, cell, dc, state );
+
+ return true;
+}
+
+wxSize wxDataViewIconTextRenderer::GetSize() const
+{
+ wxSize size;
+ if (m_value.GetIcon().IsOk())
+ size.x = 4 + m_value.GetIcon().GetWidth();
+ wxCoord x,y,d;
+ GetView()->GetTextExtent( m_value.GetText(), &x, &y, &d );
+ size.x += x;
+ size.y = y+d;
+ return size;
+}
+
+wxControl* wxDataViewIconTextRenderer::CreateEditorCtrl( wxWindow *parent, wxRect labelRect, const wxVariant &value )
+{
+ return NULL;
+}
+
+bool wxDataViewIconTextRenderer::GetValueFromEditorCtrl( wxControl* editor, wxVariant &value )
+{
+ return false;
+}
+
// ---------------------------------------------------------
// wxDataViewColumn
// ---------------------------------------------------------
if (gdk_event->button == 1)
{
+ gs_lastLeftClickHeader = column;
+
wxDataViewCtrl *dv = column->GetOwner();
wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK, dv->GetId() );
event.SetDataViewColumn( column );
return FALSE;
}
+ if (gdk_event->button == 3)
+ {
+ wxDataViewCtrl *dv = column->GetOwner();
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_RIGHT_CLICK, dv->GetId() );
+ event.SetDataViewColumn( column );
+ event.SetModel( dv->GetModel() );
+ if (dv->GetEventHandler()->ProcessEvent( event ))
+ return FALSE;
+ }
+
return FALSE;
}
wxDataViewItem item( (void*) iter->user_data );
+ wxDataViewModel *wx_model = tree_model->internal->GetDataViewModel();
+
+ if (wx_model->IsContainer( item ))
+ {
+ if (wx_model->HasContainerColumns( item ) || (cell->GetOwner()->GetModelColumn() == 0))
+ {
+ GValue gvalue = { 0, };
+ g_value_init( &gvalue, G_TYPE_BOOLEAN );
+ g_value_set_boolean( &gvalue, TRUE );
+ g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
+ g_value_unset( &gvalue );
+ }
+ else
+ {
+ GValue gvalue = { 0, };
+ g_value_init( &gvalue, G_TYPE_BOOLEAN );
+ g_value_set_boolean( &gvalue, FALSE );
+ g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
+ g_value_unset( &gvalue );
+
+ return;
+ }
+ }
+ else
+ {
+ GValue gvalue = { 0, };
+ g_value_init( &gvalue, G_TYPE_BOOLEAN );
+ g_value_set_boolean( &gvalue, TRUE );
+ g_object_set_property( G_OBJECT(renderer), "visible", &gvalue );
+ g_value_unset( &gvalue );
+ }
+
wxVariant value;
- tree_model->internal->GetDataViewModel()->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
+ wx_model->GetValue( value, item, cell->GetOwner()->GetModelColumn() );
if (value.GetType() != cell->GetVariantType())
wxLogError( wxT("Wrong type, required: %s but: %s"),
#if 0
wxListItemAttr attr;
- tree_model->model->GetAttr( attr, cell->GetOwner()->GetModelColumn(), model_row );
+ wx_model->GetAttr( item, attr, cell->GetOwner()->GetModelColumn() );
if (attr.HasBackgroundColour())
{
IMPLEMENT_CLASS(wxDataViewColumn, wxDataViewColumnBase)
+#include <wx/listimpl.cpp>
+WX_DEFINE_LIST(wxDataViewColumnList)
+
wxDataViewColumn::wxDataViewColumn( const wxString &title, wxDataViewRenderer *cell,
unsigned int model_column, int width,
wxAlignment align, int flags ) :
GtkTreeViewColumn *column = GTK_TREE_VIEW_COLUMN(m_column);
if (sortable)
+ {
gtk_tree_view_column_set_sort_column_id( column, GetModelColumn() );
+ }
else
+ {
gtk_tree_view_column_set_sort_column_id( column, -1 );
+ gtk_tree_view_column_set_sort_indicator( column, FALSE );
+ }
}
bool wxDataViewColumn::IsSortable() const
gtk_tree_view_column_set_sort_order( column, GTK_SORT_ASCENDING );
else
gtk_tree_view_column_set_sort_order( column, GTK_SORT_DESCENDING );
+
+ gtk_tree_view_column_set_sort_indicator( column, TRUE );
}
bool wxDataViewColumn::IsSortOrderAscending() const
m_root = NULL;
m_sort_order = GTK_SORT_ASCENDING;
m_sort_column = -1;
+ m_dataview_sort_column = NULL;
InitTree();
}
{
if (node->GetChildCount() == 0)
{
- wxDataViewItem child = m_wx_model->GetFirstChild( node->GetItem() );
- while (child.IsOk())
+ wxDataViewItemArray children;
+ unsigned int count = m_wx_model->GetChildren( node->GetItem(), children );
+ unsigned int pos;
+ for (pos = 0; pos < count; pos++)
{
+ wxDataViewItem child = children[pos];
+
if (m_wx_model->IsContainer( child ))
node->AddNode( new wxGtkTreeModelNode( node, child, this ) );
else
node->AddLeave( child.GetID() );
// Don't send any events here
-
- child = m_wx_model->GetNextSibling( child );
}
}
}
parent_node->AddNode( new wxGtkTreeModelNode( parent_node, item, this ) );
else
parent_node->AddLeave( item.GetID() );
-
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_ADDED, m_owner->GetId() );
- event.SetEventObject( m_owner );
- event.SetModel( m_owner->GetModel() );
- event.SetItem( item );
- m_owner->GetEventHandler()->ProcessEvent( event );
-
+
return true;
}
wxGtkTreeModelNode *parent_node = FindNode( parent );
parent_node->DeleteChild( item.GetID() );
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_DELETED, m_owner->GetId() );
- event.SetEventObject( m_owner );
- event.SetModel( m_owner->GetModel() );
- event.SetItem( item );
- m_owner->GetEventHandler()->ProcessEvent( event );
-
return true;
}
bool wxDataViewCtrlInternal::ItemChanged( const wxDataViewItem &item )
{
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_MODEL_ITEM_CHANGED, m_owner->GetId() );
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
event.SetEventObject( m_owner );
event.SetModel( m_owner->GetModel() );
event.SetItem( item );
bool wxDataViewCtrlInternal::ValueChanged( const wxDataViewItem &item, unsigned int col )
{
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_MODEL_VALUE_CHANGED, m_owner->GetId() );
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED, m_owner->GetId() );
event.SetEventObject( m_owner );
event.SetModel( m_owner->GetModel() );
event.SetColumn( col );
+ event.SetDataViewColumn( GetOwner()->GetColumn(col) );
event.SetItem( item );
m_owner->GetEventHandler()->ProcessEvent( event );
bool wxDataViewCtrlInternal::Cleared()
{
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_MODEL_CLEARED, m_owner->GetId() );
- event.SetEventObject( m_owner );
- event.SetModel( m_owner->GetModel() );
- m_owner->GetEventHandler()->ProcessEvent( event );
-
return true;
}
gboolean wxDataViewCtrlInternal::iter_has_child( GtkTreeIter *iter )
{
wxDataViewItem item( (void*) iter->user_data );
+
bool is_container = m_wx_model->IsContainer( item );
if (!is_container)
return FALSE;
-
+
wxGtkTreeModelNode *node = FindNode( iter );
BuildBranch( node );
ItemList list;
list.DeleteContents( true );
wxDataViewItem it( item );
+
while( it.IsOk() )
{
wxDataViewItem * pItem = new wxDataViewItem( it );
if (!result)
{
- wxPrintf( "Not found %d\n", (int) iter->user_data );
+ wxLogDebug( "Not found %p", iter->user_data );
char *crash = NULL;
*crash = 0;
}
if (!result)
{
- wxPrintf( "Not found %d\n", (int) item.GetID() );
+ wxLogDebug( "Not found %p", item.GetID() );
char *crash = NULL;
*crash = 0;
}
if (!GTK_WIDGET_REALIZED(dv->m_widget))
return;
- wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_ITEM_SELECTED, dv->GetId() );
+ wxDataViewEvent event( wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED, dv->GetId() );
event.SetItem( dv->GetSelection() );
event.SetModel( dv->GetModel() );
dv->GetEventHandler()->ProcessEvent( event );
}
+//-----------------------------------------------------------------------------
+// "motion_notify_event"
+//-----------------------------------------------------------------------------
+
+static gboolean
+gtk_dataview_motion_notify_callback( GtkWidget *widget,
+ GdkEventMotion *gdk_event,
+ wxDataViewCtrl *dv )
+{
+ if (gdk_event->is_hint)
+ {
+ int x = 0;
+ int y = 0;
+ GdkModifierType state;
+ gdk_window_get_pointer(gdk_event->window, &x, &y, &state);
+ gdk_event->x = x;
+ gdk_event->y = y;
+ }
+
+ GtkTreePath *path = NULL;
+ GtkTreeViewColumn *column = NULL;
+ gint cell_x = 0;
+ gint cell_y = 0;
+ if (gtk_tree_view_get_path_at_pos(
+ GTK_TREE_VIEW(dv->GtkGetTreeView()),
+ (int) gdk_event->x, (int) gdk_event->y,
+ &path,
+ &column,
+ &cell_x,
+ &cell_y))
+ {
+ if (path)
+ {
+ GtkTreeIter iter;
+ dv->GtkGetInternal()->get_iter( &iter, path );
+
+ // wxPrintf( "mouse %d %d\n", (int) gdk_event->x, (int) gdk_event->y );
+
+ gtk_tree_path_free( path );
+ }
+ }
+
+
+ return FALSE;
+}
+
IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl, wxDataViewCtrlBase)
g_signal_connect_after (m_treeview, "row-expanded",
G_CALLBACK (wxdataview_row_expanded_callback), this);
+ g_signal_connect (m_treeview, "motion_notify_event",
+ G_CALLBACK (gtk_dataview_motion_notify_callback), this);
+
return true;
}
if (!wxDataViewCtrlBase::AppendColumn(col))
return false;
- GtkTreeViewColumn *column = (GtkTreeViewColumn *)col->GetGtkHandle();
+ m_cols.Append( col );
+
+ gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview),
+ GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
+
+ return true;
+}
+
+bool wxDataViewCtrl::PrependColumn( wxDataViewColumn *col )
+{
+ if (!wxDataViewCtrlBase::PrependColumn(col))
+ return false;
+
+ m_cols.Insert( col );
+
+ gtk_tree_view_insert_column( GTK_TREE_VIEW(m_treeview),
+ GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()), 0 );
+
+ return true;
+}
+
+unsigned int wxDataViewCtrl::GetColumnCount() const
+{
+ return m_cols.GetCount();
+}
+
+wxDataViewColumn* wxDataViewCtrl::GetColumn( unsigned int pos ) const
+{
+ GtkTreeViewColumn *gtk_col = gtk_tree_view_get_column( GTK_TREE_VIEW(m_treeview), pos );
+ if (!gtk_col)
+ return NULL;
+
+ wxDataViewColumnList::const_iterator iter;
+ for (iter = m_cols.begin(); iter != m_cols.end(); iter++)
+ {
+ wxDataViewColumn *col = *iter;
+ if (GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) == gtk_col)
+ {
+ return col;
+ }
+ }
+
+ return NULL;
+}
+
+bool wxDataViewCtrl::DeleteColumn( wxDataViewColumn *column )
+{
+ gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
+ GTK_TREE_VIEW_COLUMN(column->GetGtkHandle()) );
+
+ m_cols.remove( column );
- gtk_tree_view_append_column( GTK_TREE_VIEW(m_treeview), column );
+ delete column;
return true;
}
-wxDataViewItem wxDataViewCtrl::GetSelection()
+bool wxDataViewCtrl::ClearColumns()
+{
+ wxDataViewColumnList::iterator iter;
+ for (iter = m_cols.begin(); iter != m_cols.end(); iter++)
+ {
+ wxDataViewColumn *col = *iter;
+ gtk_tree_view_remove_column( GTK_TREE_VIEW(m_treeview),
+ GTK_TREE_VIEW_COLUMN(col->GetGtkHandle()) );
+ }
+
+ m_cols.clear();
+
+ return true;
+}
+
+int wxDataViewCtrl::GetColumnPosition( const wxDataViewColumn *column ) const
+{
+ GtkTreeViewColumn *gtk_column = GTK_TREE_VIEW_COLUMN(column->GetConstGtkHandle());
+
+ GList *list = gtk_tree_view_get_columns( GTK_TREE_VIEW(m_treeview) );
+
+ gint pos = g_list_index( list, (gconstpointer) gtk_column );
+
+ g_list_free( list );
+
+ return pos;
+}
+
+wxDataViewColumn *wxDataViewCtrl::GetSortingColumn() const
+{
+ return m_internal->GetDataViewSortColumn();
+}
+
+void wxDataViewCtrl::Expand( const wxDataViewItem & item )
+{
+ GtkTreeIter iter;
+ iter.user_data = item.GetID();
+ GtkTreePath *path = m_internal->get_path( &iter );
+ gtk_tree_view_expand_row( GTK_TREE_VIEW(m_treeview), path, false );
+ gtk_tree_path_free( path );
+}
+
+void wxDataViewCtrl::Collapse( const wxDataViewItem & item )
+{
+ GtkTreeIter iter;
+ iter.user_data = item.GetID();
+ GtkTreePath *path = m_internal->get_path( &iter );
+ gtk_tree_view_collapse_row( GTK_TREE_VIEW(m_treeview), path );
+ gtk_tree_path_free( path );
+}
+
+wxDataViewItem wxDataViewCtrl::GetSelection() const
{
GtkTreeSelection *selection = gtk_tree_view_get_selection( GTK_TREE_VIEW(m_treeview) );
GtkEnableSelectionEvents();
}
-void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, wxDataViewColumn *column )
+void wxDataViewCtrl::EnsureVisible( const wxDataViewItem & item, const wxDataViewColumn *column )
{
GtkTreeIter iter;
iter.user_data = (gpointer) item.GetID();
}
void wxDataViewCtrl::HitTest( const wxPoint &point,
- wxDataViewItem &item, unsigned int &column ) const
+ wxDataViewItem &item, wxDataViewColumn *&column ) const
{
item = wxDataViewItem(0);
- column = 0;
+ column = NULL;
}
wxRect wxDataViewCtrl::GetItemRect( const wxDataViewItem &item,
- unsigned int column ) const
+ const wxDataViewColumn *column ) const
{
return wxRect();
}
void wxDataViewCtrl::DoSetExpanderColumn()
{
+ gtk_tree_view_set_expander_column( GTK_TREE_VIEW(m_treeview),
+ GTK_TREE_VIEW_COLUMN( GetExpanderColumn()->GetGtkHandle() ) );
}
void wxDataViewCtrl::DoSetIndent()
projects / wxWidgets.git / blobdiff