Changeset 517

Show
Ignore:
Timestamp:
07/05/08 10:03:45 (2 months ago)
Author:
Mike Wey
Message:

Implement TreeModel? as an interface - see Ticket #24

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/src/build/gtkD.d

    r508 r517  
    272272private import gtk.TextView; 
    273273private import gtk.TextChildAnchor; 
    274 private import gtk.TreeModel; 
     274private import gtk.TreePath; 
     275private import gtk.TreeModelIF; 
     276private import gtk.TreeModelT; 
    275277private import gtk.TreeIter; 
    276 private import gtk.TreePath; 
    277278private import gtk.TreeRowReference; 
    278279private import gtk.TreeIterError; 
     280private import gtk.TreeModel; 
    279281private import gtk.TreeSelection; 
    280282private import gtk.TreeViewColumn; 
  • trunk/src/gtk/CellView.d

    r506 r517  
    4848 *  - glib.Str 
    4949 *  - gdk.Pixbuf 
    50  *  - gtk.TreeModel 
     50 *  - gtk.TreeModelIF 
    5151 *  - gtk.TreePath 
    5252 *  - gdk.Color 
     
    5656 *  - GdkColor* -> Color 
    5757 *  - GdkPixbuf* -> Pixbuf 
    58  *  - GtkTreeModel* -> TreeModel 
     58 *  - GtkTreeModel* -> TreeModelIF 
    5959 *  - GtkTreePath* -> TreePath 
    6060 * module aliases: 
     
    7272private import glib.Str; 
    7373private import gdk.Pixbuf; 
    74 private import gtk.TreeModel
     74private import gtk.TreeModelIF
    7575private import gtk.TreePath; 
    7676private import gdk.Color; 
     
    202202     * model =  a GtkTreeModel 
    203203     */ 
    204     public void setModel(TreeModel model) 
     204    public void setModel(TreeModelIF model) 
    205205    { 
    206206        // void gtk_cell_view_set_model (GtkCellView *cell_view,  GtkTreeModel *model); 
    207         gtk_cell_view_set_model(gtkCellView, (model is null) ? null : model.getTreeModelStruct()); 
     207        gtk_cell_view_set_model(gtkCellView, (model is null) ? null : model.getTreeModelTStruct()); 
    208208    } 
    209209     
  • trunk/src/gtk/ComboBox.d

    r506 r517  
    5050 *  - glib.Str 
    5151 *  - gtk.TreeModel 
     52 *  - gtk.TreeModelIF 
    5253 *  - gtk.TreeIter 
    5354 *  - gtk.CellRenderer 
     
    5859 *  - AtkObject* -> ObjectAtk 
    5960 *  - GtkTreeIter* -> TreeIter 
    60  *  - GtkTreeModel* -> TreeModel 
     61 *  - GtkTreeModel* -> TreeModelIF 
    6162 * module aliases: 
    6263 * local aliases: 
     
    7677private import glib.Str; 
    7778private import gtk.TreeModel; 
     79private import gtk.TreeModelIF; 
    7880private import gtk.TreeIter; 
    7981private import gtk.CellRenderer; 
     
    207209    { 
    208210        TreeIter iter = new TreeIter(); 
    209         TreeModel model = getModel(); 
     211        TreeModelIF model = getModel(); 
    210212        iter.setModel(model); 
    211213        int index = 0; 
     
    401403     * model =  A GtkTreeModel. 
    402404     */ 
    403     public this (TreeModel model) 
     405    public this (TreeModelIF model) 
    404406    { 
    405407        // GtkWidget* gtk_combo_box_new_with_model (GtkTreeModel *model); 
    406         auto p = gtk_combo_box_new_with_model((model is null) ? null : model.getTreeModelStruct()); 
     408        auto p = gtk_combo_box_new_with_model((model is null) ? null : model.getTreeModelTStruct()); 
    407409        if(p is null) 
    408410        { 
     
    550552     * Returns: A GtkTreeModel which was passed during construction. 
    551553     */ 
    552     public TreeModel getModel() 
     554    public TreeModelIF getModel() 
    553555    { 
    554556        // GtkTreeModel* gtk_combo_box_get_model (GtkComboBox *combo_box); 
     
    572574     * model =  A GtkTreeModel 
    573575     */ 
    574     public void setModel(TreeModel model) 
     576    public void setModel(TreeModelIF model) 
    575577    { 
    576578        // void gtk_combo_box_set_model (GtkComboBox *combo_box,  GtkTreeModel *model); 
    577         gtk_combo_box_set_model(gtkComboBox, (model is null) ? null : model.getTreeModelStruct()); 
     579        gtk_combo_box_set_model(gtkComboBox, (model is null) ? null : model.getTreeModelTStruct()); 
    578580    } 
    579581     
  • trunk/src/gtk/ComboBoxEntry.d

    r506 r517  
    4545 * omit signals: 
    4646 * imports: 
    47  *  - gtk.TreeModel 
     47 *  - gtk.TreeModelIF 
    4848 *  - gtk.Adjustment 
    4949 * structWrap: 
    5050 *  - GtkAdjustment* -> Adjustment 
    51  *  - GtkTreeModel* -> TreeModel 
     51 *  - GtkTreeModel* -> TreeModelIF 
    5252 * module aliases: 
    5353 * local aliases: 
     
    6262 
    6363 
    64 private import gtk.TreeModel
     64private import gtk.TreeModelIF
    6565private import gtk.Adjustment; 
    6666 
     
    175175     * textColumn =  A column in model to get the strings from. 
    176176     */ 
    177     public this (TreeModel model, int textColumn) 
     177    public this (TreeModelIF model, int textColumn) 
    178178    { 
    179179        // GtkWidget* gtk_combo_box_entry_new_with_model (GtkTreeModel *model,  gint text_column); 
    180         auto p = gtk_combo_box_entry_new_with_model((model is null) ? null : model.getTreeModelStruct(), textColumn); 
     180        auto p = gtk_combo_box_entry_new_with_model((model is null) ? null : model.getTreeModelTStruct(), textColumn); 
    181181        if(p is null) 
    182182        { 
  • trunk/src/gtk/EntryCompletion.d

    r506 r517  
    4747 *  - gtk.Widget 
    4848 *  - gtk.TreeModel 
     49 *  - gtk.TreeModelIF 
    4950 * structWrap: 
    50  *  - GtkTreeModel* -> TreeModel 
     51 *  - GtkTreeModel* -> TreeModelIF 
    5152 *  - GtkWidget* -> Widget 
    5253 * module aliases: 
     
    6768private import gtk.Widget; 
    6869private import gtk.TreeModel; 
     70private import gtk.TreeModelIF; 
    6971 
    7072 
     
    174176    } 
    175177     
    176     gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion)[] onCursorOnMatchListeners; 
     178    gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion)[] onCursorOnMatchListeners; 
    177179    /** 
    178180     * Gets emitted when a match from the cursor is on a match 
     
    182184     * Since 2.12 
    183185     */ 
    184     void addOnCursorOnMatch(gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
     186    void addOnCursorOnMatch(gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    185187    { 
    186188        if ( !("cursor-on-match" in connectedSignals) ) 
     
    201203        bool consumed = false; 
    202204         
    203         foreach ( gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion) dlg ; entryCompletion.onCursorOnMatchListeners ) 
     205        foreach ( gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion) dlg ; entryCompletion.onCursorOnMatchListeners ) 
    204206        { 
    205207            dlg(new TreeModel(model), iter, entryCompletion); 
     
    247249    } 
    248250     
    249     gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion)[] onMatchSelectedListeners; 
     251    gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion)[] onMatchSelectedListeners; 
    250252    /** 
    251253     * Gets emitted when a match from the list is selected. 
     
    255257     * Since 2.4 
    256258     */ 
    257     void addOnMatchSelected(gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
     259    void addOnMatchSelected(gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    258260    { 
    259261        if ( !("match-selected" in connectedSignals) ) 
     
    274276        bool consumed = false; 
    275277         
    276         foreach ( gboolean delegate(TreeModel, GtkTreeIter*, EntryCompletion) dlg ; entryCompletion.onMatchSelectedListeners ) 
     278        foreach ( gboolean delegate(TreeModelIF, GtkTreeIter*, EntryCompletion) dlg ; entryCompletion.onMatchSelectedListeners ) 
    277279        { 
    278280            dlg(new TreeModel(model), iter, entryCompletion); 
     
    325327     * model =  The GtkTreeModel. 
    326328     */ 
    327     public void setModel(TreeModel model) 
     329    public void setModel(TreeModelIF model) 
    328330    { 
    329331        // void gtk_entry_completion_set_model (GtkEntryCompletion *completion,  GtkTreeModel *model); 
    330         gtk_entry_completion_set_model(gtkEntryCompletion, (model is null) ? null : model.getTreeModelStruct()); 
     332        gtk_entry_completion_set_model(gtkEntryCompletion, (model is null) ? null : model.getTreeModelTStruct()); 
    331333    } 
    332334     
     
    337339     * Returns: A GtkTreeModel, or NULL if none is currently being used. 
    338340     */ 
    339     public TreeModel getModel() 
     341    public TreeModelIF getModel() 
    340342    { 
    341343        // GtkTreeModel* gtk_entry_completion_get_model (GtkEntryCompletion *completion); 
  • trunk/src/gtk/IconView.d

    r506 r517  
    4545 * imports: 
    4646 *  - gtk.TreeModel 
     47 *  - gtk.TreeModelIF 
    4748 *  - gtk.TreePath 
    4849 *  - gtk.CellRenderer 
     
    5758 *  - GtkTooltip* -> Tooltip 
    5859 *  - GtkTreeIter* -> TreeIter 
    59  *  - GtkTreeModel* -> TreeModel 
     60 *  - GtkTreeModel* -> TreeModelIF 
    6061 *  - GtkTreePath* -> TreePath 
    6162 * module aliases: 
     
    7475 
    7576private import gtk.TreeModel; 
     77private import gtk.TreeModelIF; 
    7678private import gtk.TreePath; 
    7779private import gtk.CellRenderer; 
     
    433435     * model =  The model. 
    434436     */ 
    435     public this (TreeModel model) 
     437    public this (TreeModelIF model) 
    436438    { 
    437439        // GtkWidget* gtk_icon_view_new_with_model (GtkTreeModel *model); 
    438         auto p = gtk_icon_view_new_with_model((model is null) ? null : model.getTreeModelStruct()); 
     440        auto p = gtk_icon_view_new_with_model((model is null) ? null : model.getTreeModelTStruct()); 
    439441        if(p is null) 
    440442        { 
     
    455457     * model =  The model. 
    456458     */ 
    457     public void setModel(TreeModel model) 
     459    public void setModel(TreeModelIF model) 
    458460    { 
    459461        // void gtk_icon_view_set_model (GtkIconView *icon_view,  GtkTreeModel *model); 
    460         gtk_icon_view_set_model(gtkIconView, (model is null) ? null : model.getTreeModelStruct()); 
     462        gtk_icon_view_set_model(gtkIconView, (model is null) ? null : model.getTreeModelTStruct()); 
    461463    } 
    462464     
     
    467469     * Returns: A GtkTreeModel, or NULL if none is currently being used. 
    468470     */ 
    469     public TreeModel getModel() 
     471    public TreeModelIF getModel() 
    470472    { 
    471473        // GtkTreeModel* gtk_icon_view_get_model (GtkIconView *icon_view); 
  • trunk/src/gtk/ListStore.d

    r506 r517  
    3434 * interface Code: No 
    3535 * template for: 
    36  * extend  = GtkTreeModel 
     36 * extend  =  
    3737 * implements: 
    3838 *  - BuildableIF 
     39 *  - TreeModelIF 
    3940 * prefixes: 
    4041 *  - gtk_list_store_ 
     
    5455 *  - gtk.BuildableIF 
    5556 *  - gtk.BuildableT 
     57 *  - gtk.TreePath 
     58 *  - gtk.TreeModelT 
     59 *  - gtk.TreeModelIF 
     60 *  - gobject.Signals 
    5661 * structWrap: 
    5762 *  - GValue* -> Value 
     
    7782private import gtk.BuildableIF; 
    7883private import gtk.BuildableT; 
    79  
    80  
    81  
    82 private import gtk.TreeModel; 
     84private import gtk.TreePath; 
     85private import gtk.TreeModelT; 
     86private import gtk.TreeModelIF; 
     87private import gobject.Signals; 
     88 
     89 
     90 
     91private import gobject.ObjectG; 
    8392 
    8493/** 
     
    200209 * </object> 
    201210 */ 
    202 public class ListStore : TreeModel, BuildableIF 
     211public class ListStore : ObjectG, BuildableIF, TreeModelIF 
    203212{ 
    204213     
     
    237246            return; 
    238247        } 
    239         super(cast(GtkTreeModel*)gtkListStore); 
     248        super(cast(GObject*)gtkListStore); 
    240249        this.gtkListStore = gtkListStore; 
    241250    } 
     
    243252    // add the Buildable capabilities 
    244253    mixin BuildableT!(GtkListStore); 
     254     
     255    // add the TreeModel capabilities 
     256    mixin TreeModelT!(GtkListStore); 
    245257     
    246258    /** 
  • trunk/src/gtk/TreeDragSource.d

    r480 r517  
    4545 * imports: 
    4646 *  - gtk.TreePath 
    47  *  - gtk.TreeModel 
     47 *  - gtk.TreeModelIF 
    4848 * structWrap: 
    49  *  - GtkTreeModel* -> TreeModel 
     49 *  - GtkTreeModel* -> TreeModelIF 
    5050 *  - GtkTreePath* -> TreePath 
    5151 * module aliases: 
     
    6262 
    6363private import gtk.TreePath; 
    64 private import gtk.TreeModel
     64private import gtk.TreeModelIF
    6565 
    6666 
     
    211211     * Returns: TRUE if the GtkSelectionData had the proper target type to allow us to set a tree row 
    212212     */ 
    213     public static int treeSetRowDragData(GtkSelectionData* selectionData, TreeModel treeModel, TreePath path) 
     213    public static int treeSetRowDragData(GtkSelectionData* selectionData, TreeModelIF treeModel, TreePath path) 
    214214    { 
    215215        // gboolean gtk_tree_set_row_drag_data (GtkSelectionData *selection_data,  GtkTreeModel *tree_model,  GtkTreePath *path); 
    216         return gtk_tree_set_row_drag_data(selectionData, (treeModel is null) ? null : treeModel.getTreeModelStruct(), (path is null) ? null : path.getTreePathStruct()); 
     216        return gtk_tree_set_row_drag_data(selectionData, (treeModel is null) ? null : treeModel.getTreeModelTStruct(), (path is null) ? null : path.getTreePathStruct()); 
    217217    } 
    218218     
  • trunk/src/gtk/TreeIter.d

    r480 r517  
    4242 * omit code: 
    4343 * omit signals: 
     44 *  - row-changed 
     45 *  - row-deleted 
     46 *  - row-has-child-toggled 
     47 *  - row-inserted 
     48 *  - rows-reordered 
    4449 * imports: 
    4550 *  - glib.Str 
    46  *  - gtk.TreeModel 
     51 *  - gtk.TreeModelIF 
    4752 *  - gtk.TreePath 
    4853 *  - gtk.TreeIterError 
    49  *  - gobject.Value; 
     54 *  - gobject.Value 
    5055 * structWrap: 
    5156 *  - GtkTreeIter* -> TreeIter 
    52  *  - GtkTreeModel* -> TreeModel 
    5357 * module aliases: 
    5458 * local aliases: 
     
    6670 
    6771private import glib.Str; 
    68 private import gtk.TreeModel
     72private import gtk.TreeModelIF
    6973private import gtk.TreePath; 
    7074private import gtk.TreeIterError; 
    71 private import gobject.Value;; 
     75private import gobject.Value; 
    7276 
    7377 
     
    241245     * is created from the model. 
    242246     */ 
    243     GtkTreeModel *gtkTreeModel; 
     247    GtkTreeModel* gtkTreeModel; 
    244248     
    245249    /** */ 
    246     public void setModel(GtkTreeModel *gtkTreeModel) 
     250    public void setModel(GtkTreeModel* gtkTreeModel) 
    247251    { 
    248252        this.gtkTreeModel = gtkTreeModel; 
     
    250254     
    251255    /** */ 
    252     public void setModel(TreeModel treeModel) 
    253     { 
    254         this.gtkTreeModel = treeModel.getTreeModelStruct(); 
     256    public void setModel(TreeModelIF treeModel) 
     257    { 
     258        this.gtkTreeModel = treeModel.getTreeModelTStruct(); 
    255259    } 
    256260     
    257261    /** */ 
    258     public this(TreeModel treeModel, TreePath treePath) 
     262    public this(TreeModelIF treeModel, TreePath treePath) 
    259263    { 
    260264        this(); 
    261265        setModel(treeModel); 
    262266        if ( gtk_tree_model_get_iter_from_string( 
    263         treeModel.getTreeModelStruct(), 
     267        treeModel.getTreeModelTStruct(), 
    264268        getTreeIterStruct(), Str.toStringz(treePath.toString())) ) 
    265269        { 
     
    401405    } 
    402406     
    403      
    404      
    405      
    406      
    407     /** 
    408      */ 
    409     int[char[]] connectedSignals; 
    410      
    411     void delegate(GtkTreePath*, TreeIter, TreeIter)[] onRowChangedListeners; 
    412     /** 
    413      * This signal is emitted when a row in the model has changed. 
    414      */ 
    415     void addOnRowChanged(void delegate(GtkTreePath*, TreeIter, TreeIter) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    416     { 
    417         if ( !("row-changed" in connectedSignals) ) 
    418         { 
    419             Signals.connectData( 
    420             getStruct(), 
    421             "row-changed", 
    422             cast(GCallback)&callBackRowChanged, 
    423             cast(void*)this, 
    424             null, 
    425             connectFlags); 
    426             connectedSignals["row-changed"] = 1; 
    427         } 
    428         onRowChangedListeners ~= dlg; 
    429     } 
    430     extern(C) static void callBackRowChanged(GtkTreeModel* treeModelStruct, GtkTreePath* path, GtkTreeIter* iter, TreeIter treeIter) 
    431     { 
    432         bool consumed = false; 
    433          
    434         foreach ( void delegate(GtkTreePath*, TreeIter, TreeIter) dlg ; treeIter.onRowChangedListeners ) 
    435         { 
    436             dlg(path, new TreeIter(iter), treeIter); 
    437         } 
    438          
    439         return consumed; 
    440     } 
    441      
    442     void delegate(GtkTreePath*, TreeIter)[] onRowDeletedListeners; 
    443     /** 
    444      * This signal is emitted when a row has been deleted. 
    445      * Note that no iterator is passed to the signal handler, 
    446      * since the row is already deleted. 
    447      * Implementations of GtkTreeModel must emit row-deleted 
    448      * before removing the node from its 
    449      * internal data structures. This is because models and 
    450      * views which access and monitor this model might have 
    451      * references on the node which need to be released in the 
    452      * row-deleted handler. 
    453      */ 
    454     void addOnRowDeleted(void delegate(GtkTreePath*, TreeIter) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    455     { 
    456         if ( !("row-deleted" in connectedSignals) ) 
    457         { 
    458             Signals.connectData( 
    459             getStruct(), 
    460             "row-deleted", 
    461             cast(GCallback)&callBackRowDeleted, 
    462             cast(void*)this, 
    463             null, 
    464             connectFlags); 
    465             connectedSignals["row-deleted"] = 1; 
    466         } 
    467         onRowDeletedListeners ~= dlg; 
    468     } 
    469     extern(C) static void callBackRowDeleted(GtkTreeModel* treeModelStruct, GtkTreePath* path, TreeIter treeIter) 
    470     { 
    471         bool consumed = false; 
    472          
    473         foreach ( void delegate(GtkTreePath*, TreeIter) dlg ; treeIter.onRowDeletedListeners ) 
    474         { 
    475             dlg(path, treeIter); 
    476         } 
    477          
    478         return consumed; 
    479     } 
    480      
    481     void delegate(GtkTreePath*, TreeIter, TreeIter)[] onRowHasChildToggledListeners; 
    482     /** 
    483      * This signal is emitted when a row has gotten the first child row or lost 
    484      * its last child row. 
    485      */ 
    486     void addOnRowHasChildToggled(void delegate(GtkTreePath*, TreeIter, TreeIter) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    487     { 
    488         if ( !("row-has-child-toggled" in connectedSignals) ) 
    489         { 
    490             Signals.connectData( 
    491             getStruct(), 
    492             "row-has-child-toggled", 
    493             cast(GCallback)&callBackRowHasChildToggled, 
    494             cast(void*)this, 
    495             null, 
    496             connectFlags); 
    497             connectedSignals["row-has-child-toggled"] = 1; 
    498         } 
    499         onRowHasChildToggledListeners ~= dlg; 
    500     } 
    501     extern(C) static void callBackRowHasChildToggled(GtkTreeModel* treeModelStruct, GtkTreePath* path, GtkTreeIter* iter, TreeIter treeIter) 
    502     { 
    503         bool consumed = false; 
    504          
    505         foreach ( void delegate(GtkTreePath*, TreeIter, TreeIter) dlg ; treeIter.onRowHasChildToggledListeners ) 
    506         { 
    507             dlg(path, new TreeIter(iter), treeIter); 
    508         } 
    509          
    510         return consumed; 
    511     } 
    512      
    513     void delegate(GtkTreePath*, TreeIter, TreeIter)[] onRowInsertedListeners; 
    514     /** 
    515      * This signal is emitted when a new row has been inserted in the model. 
    516      * Note that the row may still be empty at this point, since 
    517      * it is a common pattern to first insert an empty row, and 
    518      * then fill it with the desired values. 
    519      */ 
    520     void addOnRowInserted(void delegate(GtkTreePath*, TreeIter, TreeIter) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    521     { 
    522         if ( !("row-inserted" in connectedSignals) ) 
    523         { 
    524             Signals.connectData( 
    525             getStruct(), 
    526             "row-inserted", 
    527             cast(GCallback)&callBackRowInserted, 
    528             cast(void*)this, 
    529             null, 
    530             connectFlags); 
    531             connectedSignals["row-inserted"] = 1; 
    532         } 
    533         onRowInsertedListeners ~= dlg; 
    534     } 
    535     extern(C) static void callBackRowInserted(GtkTreeModel* treeModelStruct, GtkTreePath* path, GtkTreeIter* iter, TreeIter treeIter) 
    536     { 
    537         bool consumed = false; 
    538          
    539         foreach ( void delegate(GtkTreePath*, TreeIter, TreeIter) dlg ; treeIter.onRowInsertedListeners ) 
    540         { 
    541             dlg(path, new TreeIter(iter), treeIter); 
    542         } 
    543          
    544         return consumed; 
    545     } 
    546      
    547     void delegate(GtkTreePath*, TreeIter, gpointer, TreeIter)[] onRowsReorderedListeners; 
    548     /** 
    549      * This signal is emitted when the children of a node in the GtkTreeModel 
    550      * have been reordered. 
    551      * Note that this signal is not emitted 
    552      * when rows are reordered by DND, since this is implemented 
    553      * by removing and then reinserting the row. 
    554      * See Also 
    555      * GtkTreeView, GtkTreeStore, GtkListStore, GtkTreeDnd, GtkTreeSortable 
    556      * [4] 
    557      * Here, iter is short for iterator 
    558      */ 
    559     void addOnRowsReordered(void delegate(GtkTreePath*, TreeIter, gpointer, TreeIter) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    560     { 
    561         if ( !("rows-reordered" in connectedSignals) ) 
    562         { 
    563             Signals.connectData( 
    564             getStruct(), 
    565             "rows-reordered", 
    566             cast(GCallback)&callBackRowsReordered, 
    567             cast(void*)this, 
    568             null, 
    569             connectFlags); 
    570             connectedSignals["rows-reordered"] = 1; 
    571         } 
    572         onRowsReorderedListeners ~= dlg; 
    573     } 
    574     extern(C) static void callBackRowsReordered(GtkTreeModel* treeModelStruct, GtkTreePath* path, GtkTreeIter* iter, gpointer arg3, TreeIter treeIter) 
    575     { 
    576         bool consumed = false; 
    577          
    578         foreach ( void delegate(GtkTreePath*, TreeIter, gpointer, TreeIter) dlg ; treeIter.onRowsReorderedListeners ) 
    579         { 
    580             dlg(path, new TreeIter(iter), arg3, treeIter); 
    581         } 
    582          
    583         return consumed; 
    584     } 
    585      
     407    /** 
     408     */ 
    586409     
    587410    /** 
  • trunk/src/gtk/TreeModel.d

    r506 r517  
    2323/* 
    2424 * Conversion parameters: 
    25  * inFile  = GtkTreeModel.html 
     25 * inFile  =  
    2626 * outPack = gtk 
    2727 * outFile = TreeModel 
    28  * strct   = GtkTreeModel 
     28 * strct   =  
    2929 * realStrct= 
    3030 * ctorStrct= 
     
    3232 * interf  =  
    3333 * class Code: Yes 
    34  * interface Code: Yes 
     34 * interface Code: No 
    3535 * template for: 
    36  * extend  = GObject 
     36 * extend  = ObjectG 
    3737 * implements: 
     38 *  - TreeModelIF 
    3839 * prefixes: 
    39  *  - gtk_tree_model_ 
    4040 * omit structs: 
    4141 * omit prefixes: 
    42  *  - gtk_tree_row_reference_ 
    43  *  - gtk_tree_path_ 
    44  *  - gtk_tree_iter_ 
    4542 * omit code: 
    46  *  - gtk_tree_model_get_iter 
    4743 * omit signals: 
    4844 * imports: 
     45 *  - gobject.ObjectG; 
     46 *  - gtk.TreeModel 
    4947 *  - glib.Str 
    5048 *  - gtk.TreeIter 
    5149 *  - gtk.TreePath 
    5250 *  - gobject.Value 
     51 *  - gtk.TreeModelT 
     52 *  - gtk.TreeModelIF 
     53 *  - gobject.Signals 
    5354 * structWrap: 
    54  *  - GValue* -> Value 
    55  *  - GtkTreeIter* -> TreeIter 
    56  *  - GtkTreePath* -> TreePath 
    5755 * module aliases: 
    5856 * local aliases: 
     
    6664private import gtkc.gtk; 
    6765 
    68 private import gobject.Signals; 
    69 public  import gtkc.gdktypes; 
    7066 
     67private import gobject.ObjectG;; 
     68private import gtk.TreeModel; 
    7169private import glib.Str; 
    7270private import gtk.TreeIter; 
    7371private import gtk.TreePath; 
    7472private import gobject.Value; 
     73private import gtk.TreeModelT; 
     74private import gtk.TreeModelIF; 
     75private import gobject.Signals; 
    7576 
    7677 
    7778 
    78 private import gobject.ObjectG; 
    7979 
    8080/** 
    81  * Description 
    82  * The GtkTreeModel interface defines a generic tree interface for use by 
    83  * the GtkTreeView widget. It is an abstract interface, and is designed 
    84  * to be usable with any appropriate data structure. The programmer just 
    85  * has to implement this interface on their own data type for it to be 
    86  * viewable by a GtkTreeView widget. 
    87  * The model is represented as a hierarchical tree of strongly-typed, 
    88  * columned data. In other words, the model can be seen as a tree where 
    89  * every node has different values depending on which column is being 
    90  * queried. The type of data found in a column is determined by using the 
    91  * GType system (ie. G_TYPE_INT, GTK_TYPE_BUTTON, G_TYPE_POINTER, etc.). 
    92  * The types are homogeneous per column across all nodes. It is important 
    93  * to note that this interface only provides a way of examining a model and 
    94  * observing changes. The implementation of each individual model decides 
    95  * how and if changes are made. 
    96  * In order to make life simpler for programmers who do not need to write 
    97  * their own specialized model, two generic models are provided  the 
    98  * GtkTreeStore and the GtkListStore. To use these, the developer simply 
    99  * pushes data into these models as necessary. These models provide the 
    100  * data structure as well as all appropriate tree interfaces. As a result, 
    101  * implementing drag and drop, sorting, and storing data is trivial. For 
    102  * the vast majority of trees and lists, these two models are sufficient. 
    103  * Models are accessed on a node/column level of granularity. One can 
    104  * query for the value of a model at a certain node and a certain column 
    105  * on that node. There are two structures used to reference a particular 
    106  * node in a model. They are the GtkTreePath and the GtkTreeIter 
    107  * [4] 
    108  * Most of the interface consists of operations on a GtkTreeIter. 
    109  * A path is essentially a potential node. It is a location on a model 
    110  * that may or may not actually correspond to a node on a specific model. 
    111  * The GtkTreePath struct can be converted into either an array of 
    112  * unsigned integers or a string. The string form is a list of numbers 
    113  * separated by a colon. Each number refers to the offset at that level. 
    114  * Thus, the path 0 refers to the root node and the path 
    115  * 2:4 refers to the fifth child of the third node. 
    116  * By contrast, a GtkTreeIter is a reference to a specific node on a 
    117  * specific model. It is a generic struct with an integer and three 
    118  * generic pointers. These are filled in by the model in a model-specific 
    119  * way. One can convert a path to an iterator by calling 
    120  * gtk_tree_model_get_iter(). These iterators are the primary way of 
    121  * accessing a model and are similar to the iterators used by 
    122  * GtkTextBuffer. They are generally statically allocated on the stack and 
    123  * only used for a short time. The model interface defines a set of 
    124  * operations using them for navigating the model. 
    125  * It is expected that models fill in the iterator with private data. For 
    126  * example, the GtkListStore model, which is internally a simple linked 
    127  * list, stores a list node in one of the pointers. The GtkTreeModelSort 
    128  * stores an array and an offset in two of the pointers. Additionally, 
    129  * there is an integer field. This field is generally filled with a unique 
    130  * stamp per model. This stamp is for catching errors resulting from using 
    131  * invalid iterators with a model. 
    132  * The lifecycle of an iterator can be a little confusing at first. 
    133  * Iterators are expected to always be valid for as long as the model is 
    134  * unchanged (and doesn't emit a signal). The model is considered to own 
    135  * all outstanding iterators and nothing needs to be done to free them from 
    136  * the user's point of view. Additionally, some models guarantee that an 
    137  * iterator is valid for as long as the node it refers to is valid (most 
    138  * notably the GtkTreeStore and GtkListStore). Although generally 
    139  * uninteresting, as one always has to allow for the case where iterators 
    140  * do not persist beyond a signal, some very important performance 
    141  * enhancements were made in the sort model. As a result, the 
    142  * GTK_TREE_MODEL_ITERS_PERSIST flag was added to indicate this behavior. 
    143  * To help show some common operation of a model, some examples are 
    144  * provided. The first example shows three ways of getting the iter at the 
    145  * location 3:2:5. While the first method shown is easier, 
    146  * the second is much more common, as you often get paths from callbacks. 
    147  * Example15.Acquiring a GtkTreeIter 
    148  * /+* Three ways of getting the iter pointing to the location 
    149  *  +/ 
    150  * { 
    151      *  GtkTreePath *path; 
    152      *  GtkTreeIter iter; 
    153      *  GtkTreeIter parent_iter; 
    154      *  /+* get the iterator from a string +/ 
    155      *  gtk_tree_model_get_iter_from_string (model, iter, "3:2:5"); 
    156      *  /+* get the iterator from a path +/ 
    157      *  path = gtk_tree_path_new_from_string ("3:2:5"); 
    158      *  gtk_tree_model_get_iter (model, iter, path); 
    159      *  gtk_tree_path_free (path); 
    160      *  /+* walk the tree to find the iterator +/ 
    161      *  gtk_tree_model_iter_nth_child (model, iter, NULL, 3); 
    162      *  parent_iter = iter; 
    163      *  gtk_tree_model_iter_nth_child (model, iter, parent_iter, 2); 
    164      *  parent_iter = iter; 
    165      *  gtk_tree_model_iter_nth_child (model, iter, parent_iter, 5); 
    166  * } 
    167  * This second example shows a quick way of iterating through a list and 
    168  * getting a string and an integer from each row. The 
    169  * populate_model function used below is not shown, as 
    170  * it is specific to the GtkListStore. For information on how to write 
    171  * such a function, see the GtkListStore documentation. 
    172  * Example16.Reading data from a GtkTreeModel 
    173  * enum 
    174  * { 
    175      *  STRING_COLUMN, 
    176      *  INT_COLUMN, 
    177      *  N_COLUMNS 
    178  * }; 
    179  * { 
    180      *  GtkTreeModel *list_store; 
    181      *  GtkTreeIter iter; 
    182      *  gboolean valid; 
    183      *  gint row_count = 0; 
    184      *  /+* make a new list_store +/ 
    185      *  list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT); 
    186      *  /+* Fill the list store with data +/ 
    187      *  populate_model (list_store); 
    188      *  /+* Get the first iter in the list +/ 
    189      *  valid = gtk_tree_model_get_iter_first (list_store, iter); 
    190      *  while (valid) 
    191      *  { 
    192          *  /+* Walk through the list, reading each row +/ 
    193          *  gchar *str_data; 
    194          *  gint int_data; 
    195          *  /+* Make sure you terminate calls to gtk_tree_model_get() 
    196          *  * with a '-1' value 
    197          *  +/ 
    198          *  gtk_tree_model_get (list_store, iter, 
    199          *  STRING_COLUMN, str_data, 
    200          *  INT_COLUMN, int_data, 
    201          *  -1); 
    202          *  /+* Do something with the data +/ 
    203          *  g_print ("Row %d: (%s,%d)\n", row_count, str_data, int_data); 
    204          *  g_free (str_data); 
    205          *  row_count ++; 
    206          *  valid = gtk_tree_model_iter_next (list_store, iter); 
    207      *  } 
    208  * } 
    20981 */ 
    210 public class TreeModel : ObjectG 
     82public class TreeModel : ObjectG, TreeModelIF 
    21183{ 
    21284     
    213     /** the main Gtk struct */ 
    214     protected GtkTreeModel* gtkTreeModel; 
    215      
    216      
    217     public GtkTreeModel* getTreeModelStruct() 
    218     { 
    219         return gtkTreeModel; 
    220     } 
    221      
     85    // Minimal implementation. 
     86    mixin TreeModelT!(GtkTreeModel); 
    22287     
    22388    /** the main Gtk struct as a void* */ 
     
    250115     
    251116    /** 
    252      * Get the value of a column as a char array. 
    253      * this is the same calling getValue and get the string from the value object 
    254117     */ 
    255     string getValueString(TreeIter iter, int column) 
    256     { 
    257         Value value = new Value(); 
    258         getValue(iter, column, value); 
    259         return value.getString(); 
    260     } 
    261      
    262     /** 
    263      * Get the value of a column as a char array. 
    264      * this is the same calling getValue and get the int from the value object 
    265      */ 
    266     int getValueInt(TreeIter iter, int column) 
    267     { 
    268         Value value = new Value(); 
    269         getValue(iter, column, value); 
    270         return value.getInt(); 
    271     } 
    272      
    273     /** 
    274      * Sets iter to a valid iterator pointing to path. 
    275      * Params: 
    276      *  iter = The uninitialized GtkTreeIter. 
    277      *  path = The GtkTreePath. 
    278      * Returns: 
    279      *  TRUE, if iter was set. 
    280      */ 
    281     public int getIter(TreeIter iter, TreePath path) 
    282     { 
    283         // gboolean gtk_tree_model_get_iter (GtkTreeModel *tree_model,  GtkTreeIter *iter,  GtkTreePath *path); 
    284         iter.setModel(this); 
    285         return gtk_tree_model_get_iter(gtkTreeModel, (iter is null) ? null : iter.getTreeIterStruct(), (path is null) ? null : path.getTreePathStruct()); 
    286     } 
    287      
    288     /** 
    289      */ 
    290     int[char[]] connectedSignals; 
    291      
    292     void delegate(TreePath, TreeIter, TreeModel)[] onRowChangedListeners; 
    293     /** 
    294      * This signal is emitted when a row in the model has changed. 
    295      */ 
    296     void addOnRowChanged(void delegate(TreePath, TreeIter, TreeModel) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    297     { 
    298         if ( !("row-changed" in connectedSignals) ) 
    299         { 
    300             Signals.connectData( 
    301             getStruct(), 
    302             "row-changed", 
    303             cast(GCallback)&callBackRowChanged, 
    304             cast(void*)this, 
    305             null, 
    306             connectFlags); 
    307             connectedSignals["row-changed"] = 1; 
    308         } 
    309         onRowChangedListeners ~= dlg; 
    310     } 
    311     extern(C) static void callBackRowChanged(GtkTreeModel* treeModelStruct, GtkTreePath* path, GtkTreeIter* iter, TreeModel treeModel) 
    312     { 
    313         bool consumed = false; 
    314          
    315         foreach ( void delegate(TreePath, TreeIter, TreeModel) dlg ; treeModel.onRowChangedListeners ) 
    316         { 
    317             dlg(new TreePath(path), new TreeIter(iter), treeModel); 
    318         } 
    319          
    320         return consumed; 
    321     } 
    322      
    323     void delegate(TreePath, TreeModel)[] onRowDeletedListeners; 
    324     /** 
    325      * This signal is emitted when a row has been deleted. 
    326      * Note that no iterator is passed to the signal handler, 
    327      * since the row is already deleted. 
    328      * Implementations of GtkTreeModel must emit row-deleted 
    329      * before removing the node from its 
    330      * internal data structures. This is because models and 
    331      * views which access and monitor this model might have 
    332      * references on the node which need to be released in the 
    333      * row-deleted handler. 
    334      */ 
    335     void addOnRowDeleted(void delegate(TreePath, TreeModel) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    336     { 
    337         if ( !("row-deleted" in connectedSignals) ) 
    338         { 
    339             Signals.connectData( 
    340             getStruct(), 
    341             "row-deleted", 
    342