Changeset 519

Show
Ignore:
Timestamp:
07/07/08 16:16:35 (3 months ago)
Author:
Mike Wey
Message:

implement CellEditable? interface - see ticket #24

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/build/gtkD.d

    r517 r519  
    291291private import gtk.CellLayoutT; 
    292292private import gtk.CellRenderer; 
     293private import gtk.CellEditableIF; 
     294private import gtk.CellEditableT; 
    293295private import gtk.CellEditable; 
    294296private import gtk.CellRendererAccel; 

  • trunk/src/gtk/CellEditable.d

    r480 r519  
    2323/* 
    2424 * Conversion parameters: 
    25  * inFile  = GtkCellEditable.html 
     25 * inFile  =  
    2626 * outPack = gtk 
    2727 * outFile = CellEditable 
    28  * strct   = GtkCellEditable 
     28 * strct   =  
    2929 * realStrct= 
    3030 * ctorStrct= 
    3131 * clss    = CellEditable 
    3232 * interf  =  
    33  * class Code: No 
     33 * class Code: Yes 
    3434 * interface Code: No 
    3535 * template for: 
    36  * extend  =  
     36 * extend  = ObjectG 
    3737 * implements: 
     38 *  - CellEditableIF 
    3839 * prefixes: 
    39  *  - gtk_cell_editable_ 
    40  *  - gtk_ 
    4140 * omit structs: 
    4241 * omit prefixes: 
    …… 
    4443 * omit signals: 
    4544 * imports: 
     45 *  - gobject.ObjectG; 
    4646 *  - gdk.Event 
     47 *  - gtk.CellEditableT 
     48 *  - gtk.CellEditableIF 
     49 *  - gobject.Signals 
    4750 * structWrap: 
    48  *  - GdkEvent* -> Event 
    4951 * module aliases: 
    5052 * local aliases: 
    …… 
    5860private import gtkc.gtk; 
    5961 
     62 
     63private import gobject.ObjectG;; 
     64private import gdk.Event; 
     65private import gtk.CellEditableT; 
     66private import gtk.CellEditableIF; 
    6067private import gobject.Signals; 
    61 public  import gtkc.gdktypes; 
    62  
    63 private import gdk.Event; 
    6468 
    6569 
    …… 
    6771 
    6872/** 
    69  * Description 
    70  * The GtkCellEditable interface must be implemented for widgets 
    71  * to be usable when editing the contents of a GtkTreeView cell. 
    7273 */ 
    73 public class CellEditable 
     74public class CellEditable : ObjectG, CellEditableIF 
    7475{ 
    7576     
    76     /** the main Gtk struct */ 
    77     protected GtkCellEditable* gtkCellEditable; 
    78      
    79      
    80     public GtkCellEditable* getCellEditableStruct() 
    81     { 
    82         return gtkCellEditable; 
    83     } 
    84      
     77    // Minimal implementation. 
     78    mixin CellEditableT!(GtkCellEditable); 
    8579     
    8680    /** the main Gtk struct as a void* */ 
    87     protected void* getStruct() 
     81    protected override void* getStruct() 
    8882    { 
    8983        return cast(void*)gtkCellEditable; 
    …… 
    10195            else return; 
    10296        } 
     97        //Check if there already is a D object for this gtk struct 
     98        void* ptr = getDObject(cast(GObject*)gtkCellEditable); 
     99        if( ptr !is null ) 
     100        { 
     101            this = cast(CellEditable)ptr; 
     102            return; 
     103        } 
     104        super(cast(GObject*)gtkCellEditable); 
    103105        this.gtkCellEditable = gtkCellEditable; 
    104106    } 
    …… 
    106108    /** 
    107109     */ 
    108     int[char[]] connectedSignals; 
    109      
    110     void delegate(CellEditable)[] onEditingDoneListeners; 
    111     /** 
    112      * This signal is a sign for the cell renderer to update its 
    113      * value from the cell_editable. 
    114      * Implementations of GtkCellEditable are responsible for 
    115      * emitting this signal when they are done editing, e.g. 
    116      * GtkEntry is emitting it when the user presses Enter. 
    117      * gtk_cell_editable_editing_done() is a convenience method 
    118      * for emitting ::editing-done. 
    119      */ 
    120     void addOnEditingDone(void delegate(CellEditable) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    121     { 
    122         if ( !("editing-done" in connectedSignals) ) 
    123         { 
    124             Signals.connectData( 
    125             getStruct(), 
    126             "editing-done", 
    127             cast(GCallback)&callBackEditingDone, 
    128             cast(void*)this, 
    129             null, 
    130             connectFlags); 
    131             connectedSignals["editing-done"] = 1; 
    132         } 
    133         onEditingDoneListeners ~= dlg; 
    134     } 
    135     extern(C) static void callBackEditingDone(GtkCellEditable* cellEditableStruct, CellEditable cellEditable) 
    136     { 
    137         bool consumed = false; 
    138          
    139         foreach ( void delegate(CellEditable) dlg ; cellEditable.onEditingDoneListeners ) 
    140         { 
    141             dlg(cellEditable); 
    142         } 
    143          
    144         return consumed; 
    145     } 
    146      
    147     void delegate(CellEditable)[] onRemoveWidgetListeners; 
    148     /** 
    149      * This signal is meant to indicate that the cell is finished 
    150      * editing, and the widget may now be destroyed. 
    151      * Implementations of GtkCellEditable are responsible for 
    152      * emitting this signal when they are done editing. It must 
    153      * be emitted after the "editing-done" signal, 
    154      * to give the cell renderer a chance to update the cell's value 
    155      * before the widget is removed. 
    156      * gtk_cell_editable_remove_widget() is a convenience method 
    157      * for emitting ::remove-widget. 
    158      */ 
    159     void addOnRemoveWidget(void delegate(CellEditable) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    160     { 
    161         if ( !("remove-widget" in connectedSignals) ) 
    162         { 
    163             Signals.connectData( 
    164             getStruct(), 
    165             "remove-widget", 
    166             cast(GCallback)&callBackRemoveWidget, 
    167             cast(void*)this, 
    168             null, 
    169             connectFlags); 
    170             connectedSignals["remove-widget"] = 1; 
    171         } 
    172         onRemoveWidgetListeners ~= dlg; 
    173     } 
    174     extern(C) static void callBackRemoveWidget(GtkCellEditable* cellEditableStruct, CellEditable cellEditable) 
    175     { 
    176         bool consumed = false; 
    177          
    178         foreach ( void delegate(CellEditable) dlg ; cellEditable.onRemoveWidgetListeners ) 
    179         { 
    180             dlg(cellEditable); 
    181         } 
    182          
    183         return consumed; 
    184     } 
    185      
    186      
    187     /** 
    188      * Begins editing on a cell_editable. event is the GdkEvent that began 
    189      * the editing process. It may be NULL, in the instance that editing was 
    190      * initiated through programatic means. 
    191      * Params: 
    192      * event =  A GdkEvent, or NULL 
    193      */ 
    194     public void startEditing(Event event) 
    195     { 
    196         // void gtk_cell_editable_start_editing (GtkCellEditable *cell_editable,  GdkEvent *event); 
    197         gtk_cell_editable_start_editing(gtkCellEditable, (event is null) ? null : event.getEventStruct()); 
    198     } 
    199      
    200     /** 
    201      * Emits the "editing-done" signal. 
    202      */ 
    203     public void editingDone() 
    204     { 
    205         // void gtk_cell_editable_editing_done (GtkCellEditable *cell_editable); 
    206         gtk_cell_editable_editing_done(gtkCellEditable); 
    207     } 
    208      
    209     /** 
    210      * Emits the "remove-widget" signal. 
    211      */ 
    212     public void removeWidget() 
    213     { 
    214         // void gtk_cell_editable_remove_widget (GtkCellEditable *cell_editable); 
    215         gtk_cell_editable_remove_widget(gtkCellEditable); 
    216     } 
    217110} 

  • trunk/src/gtk/CellRenderer.d

    r506 r519  
    5050 *  - gdk.Event 
    5151 *  - gtk.CellEditable 
     52 *  - gtk.CellEditableIF 
    5253 * structWrap: 
    5354 *  - GdkEvent* -> Event 
    5455 *  - GdkRectangle* -> Rectangle 
    5556 *  - GdkWindow* -> Window 
    56  *  - GtkCellEditable* -> CellEditable 
     57 *  - GtkCellEditable* -> CellEditableIF 
    5758 *  - GtkWidget* -> Widget 
    5859 * module aliases: 
    …… 
    7677private import gdk.Event; 
    7778private import gtk.CellEditable; 
     79private import gtk.CellEditableIF; 
    7880 
    7981 
    …… 
    190192    } 
    191193     
    192     void delegate(CellEditable, string, CellRenderer)[] onEditingStartedListeners; 
     194    void delegate(CellEditableIF, string, CellRenderer)[] onEditingStartedListeners; 
    193195    /** 
    194196     * This signal gets emitted when a cell starts to be edited. 
    …… 
    218220     * GtkCellRendererText,GtkCellRendererPixbuf,GtkCellRendererToggle 
    219221     */ 
    220     void addOnEditingStarted(void delegate(CellEditable, string, CellRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
     222    void addOnEditingStarted(void delegate(CellEditableIF, string, CellRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 
    221223    { 
    222224        if ( !("editing-started" in connectedSignals) ) 
    …… 
    237239        bool consumed = false; 
    238240         
    239         foreach ( void delegate(CellEditable, string, CellRenderer) dlg ; cellRenderer.onEditingStartedListeners ) 
     241        foreach ( void delegate(CellEditableIF, string, CellRenderer) dlg ; cellRenderer.onEditingStartedListeners ) 
    240242        { 
    241243            dlg(new CellEditable(editable), Str.toString(path), cellRenderer); 
    …… 
    326328     * Returns: A new GtkCellEditable, or NULL 
    327329     */ 
    328     public CellEditable startEditing(Event event, Widget widget, string path, Rectangle backgroundArea, Rectangle cellArea, GtkCellRendererState flags) 
     330    public CellEditableIF startEditing(Event event, Widget widget, string path, Rectangle backgroundArea, Rectangle cellArea, GtkCellRendererState flags) 
    329331    { 
    330332        // GtkCellEditable* gtk_cell_renderer_start_editing (GtkCellRenderer *cell,  GdkEvent *event,  GtkWidget *widget,  const gchar *path,  GdkRectangle *background_area,  GdkRectangle *cell_area,  GtkCellRendererState flags); 

  • trunk/src/gtk/ComboBox.d

    r517 r519  
    3737 * implements: 
    3838 *  - CellLayoutIF 
     39 *  - CellEditableIF 
    3940 * prefixes: 
    4041 *  - gtk_combo_box_ 
    …… 
    5657 *  - gtk.CellLayoutIF 
    5758 *  - gtk.CellLayoutT 
     59 *  - gdk.Event 
     60 *  - gtk.CellEditableT 
     61 *  - gtk.CellEditableIF 
     62 *  - gobject.Signals 
    5863 * structWrap: 
    5964 *  - AtkObject* -> ObjectAtk 
    …… 
    8388private import gtk.CellLayoutIF; 
    8489private import gtk.CellLayoutT; 
     90private import gdk.Event; 
     91private import gtk.CellEditableT; 
     92private import gtk.CellEditableIF; 
     93private import gobject.Signals; 
    8594 
    8695 
    …… 
    111120 * gtk_combo_box_get_active_text(). 
    112121 */ 
    113 public class ComboBox : Bin, CellLayoutIF 
     122public class ComboBox : Bin, CellLayoutIF, CellEditableIF 
    114123{ 
    115124     
    …… 
    158167    // add the CellLayout capabilities 
    159168    mixin CellLayoutT!(GtkComboBox); 
     169     
     170    // add the CellEditable capabilities 
     171    mixin CellEditableT!(GtkComboBox); 
    160172     
    161173    /** 

  • trunk/src/gtk/Entry.d

    r506 r519  
    3636 * extend  =  
    3737 * implements: 
     38 *  - CellEditableIF 
    3839 * prefixes: 
    3940 *  - gtk_entry_ 
    …… 
    4849 *  - gtk.EntryCompletion 
    4950 *  - pango.PgLayout 
     51 *  - gdk.Event 
     52 *  - gtk.CellEditableT 
     53 *  - gtk.CellEditableIF 
     54 *  - gobject.Signals 
    5055 * structWrap: 
    5156 *  - GtkAdjustment* -> Adjustment 
    …… 
    7075private import gtk.EntryCompletion; 
    7176private import pango.PgLayout; 
     77private import gdk.Event; 
     78private import gtk.CellEditableT; 
     79private import gtk.CellEditableIF; 
     80private import gobject.Signals; 
    7281 
    7382 
    …… 
    8392 * position is visible. 
    8493 */ 
    85 public class Entry : Widget 
     94public class Entry : Widget, CellEditableIF 
    8695{ 
    8796     
    …… 
    123132        this.gtkEntry = gtkEntry; 
    124133    } 
     134     
     135    // add the CellEditable capabilities 
     136    mixin CellEditableT!(GtkEntry); 
    125137     
    126138    /** */ 

  • trunk/src/gtk/Widget.d

    r518 r519  
    448448        tt.setTip(this, tipText, tipPrivate); 
    449449    } 
    450  
     450     
    451451    //get the addOnDestroy from ObjectGtk 
    452452    alias ObjectGtk.addOnDestroy addOnDestroy; 

  • trunk/src/gtkc/gtk.d

    r517 r519  
    17381738    void function(GtkCellRenderer* cell, gint width, gint height)gtk_cell_renderer_set_fixed_size; 
    17391739     
    1740     // gtk.CellEditable 
     1740    // gtk.CellEditableT 
     1741     
     1742     
     1743    // gtk.CellEditableT 
    17411744     
    17421745    void function(GtkCellEditable* cellEditable, GdkEvent* event)gtk_cell_editable_start_editing; 
    17431746    void function(GtkCellEditable* cellEditable)gtk_cell_editable_editing_done; 
    17441747    void function(GtkCellEditable* cellEditable)gtk_cell_editable_remove_widget; 
     1748     
     1749    // gtk.CellEditable 
     1750     
    17451751     
    17461752    // gtk.CellRendererAccel 

  • trunk/wrap/APILookupGtk.txt

    r517 r519  
    17461746struct: GtkEntry 
    17471747class: Entry 
     1748implements: CellEditableIF 
    17481749prefix: gtk_entry_ 
    17491750prefix: gtk_ 
    …… 
    17561757structWrap: PangoLayout* PgLayout 
    17571758 
    1758 code: start 
     1759# imports for CellEditable Interface 
     1760import: gdk.Event 
     1761import: gtk.CellEditableT 
     1762import: gtk.CellEditableIF 
     1763import: gobject.Signals 
     1764 
     1765code: start 
     1766    // add the CellEditable capabilities 
     1767    mixin CellEditableT!(GtkEntry); 
     1768 
    17591769    /** */ 
    17601770    public this (string text) 
    …… 
    32173227structWrap: GdkEvent* Event 
    32183228import: gtk.CellEditable 
    3219 structWrap: GtkCellEditable* CellEditable 
     3229import: gtk.CellEditableIF 
     3230structWrap: GtkCellEditable* CellEditableIF 
    32203231outFile: CellRenderer 
    32213232 
    32223233file: GtkCellEditable.html 
    32233234struct: GtkCellEditable 
    3224 class: CellEditable 
     3235class: CellEditableT 
     3236template: TStruct 
    32253237prefix: gtk_cell_editable_ 
    32263238prefix: gtk_ 
    32273239import: gdk.Event 
    32283240structWrap: GdkEvent* Event 
     3241interface: CellEditableIF 
     3242outFile: CellEditableT 
     3243 
     3244file: 
     3245class: CellEditable 
     3246extend: ObjectG 
     3247implements: CellEditableIF 
     3248import: gobject.ObjectG; 
     3249 
     3250# imports for CellEditable Interface 
     3251import: gdk.Event 
     3252import: gtk.CellEditableT 
     3253import: gtk.CellEditableIF 
     3254import: gobject.Signals 
     3255 
     3256code: start 
     3257    // Minimal implementation. 
     3258    mixin CellEditableT!(GtkCellEditable); 
     3259 
     3260    /** the main Gtk struct as a void* */ 
     3261    protected override void* getStruct() 
     3262    { 
     3263        return cast(void*)gtkCellEditable; 
     3264    } 
     3265     
     3266    /** 
     3267     * Sets our main struct and passes it to the parent class 
     3268     */ 
     3269    public this (GtkCellEditable* gtkCellEditable) 
     3270    { 
     3271        if(gtkCellEditable is null) 
     3272        { 
     3273            this = null; 
     3274            version(Exceptions) throw new Exception("Null gtkCellEditable passed to constructor."); 
     3275            else return; 
     3276        } 
     3277        //Check if there already is a D object for this gtk struct 
     3278        void* ptr = getDObject(cast(GObject*)gtkCellEditable); 
     3279        if( ptr !is null ) 
     3280        { 
     3281            this = cast(CellEditable)ptr; 
     3282            return; 
     3283        } 
     3284        super(cast(GObject*)gtkCellEditable); 
     3285        this.gtkCellEditable = gtkCellEditable; 
     3286    } 
     3287code: end 
    32293288outFile: CellEditable 
    32303289 
    …… 
    36413700class: ComboBox 
    36423701implements: CellLayoutIF 
     3702implements: CellEditableIF 
    36433703import: atk.ObjectAtk 
    36443704structWrap: AtkObject* ObjectAtk 
    …… 
    36643724import: gtk.CellLayoutT 
    36653725 
     3726# imports for CellEditable Interface 
     3727import: gdk.Event 
     3728import: gtk.CellEditableT 
     3729import: gtk.CellEditableIF 
     3730import: gobject.Signals 
     3731 
    36663732nocode: gtk_combo_box_new 
    36673733nocode: gtk_combo_box_new_text 
    …… 
    36753741    // add the CellLayout capabilities 
    36763742    mixin CellLayoutT!(GtkComboBox); 
     3743 
     3744    // add the CellEditable capabilities 
     3745    mixin CellEditableT!(GtkComboBox); 
    36773746 
    36783747    /**