Ticket #1: ddoc-gtk.diff

File ddoc-gtk.diff, 55.1 kB (added by Mike Wey, 1 year ago)

DDoc in APILookupGtk.txt + added empty comments to functions that had none

  • gtkD/wrap/APILookupGtk.txt

    old new  
    186186     *      interval =  the timeout in milieconds 
    187187     *      delegate() =    the delegate to be executed 
    188188     *      fireNow =   When true the delegate will be executed emmidiatly 
    189      * Returns:  
    190189     */ 
    191190    this(uint interval, bool delegate() dlg, bool fireNow=false) 
    192191    { 
    …… 
    201200        } 
    202201    } 
    203202 
     203    /** */ 
    204204    public void stop() 
    205205    { 
    206206        if ( timeoutID > 0 ) 
    …… 
    212212     
    213213    /** 
    214214     * Removes the timeout from gtk 
    215      * Returns:  
    216215     */ 
    217216    ~this() 
    218217    { 
    …… 
    222221    /** 
    223222     * Adds a new delegate to this timeout cycle 
    224223     * Params: 
    225      *      delegate() =   
     224     *      dlg =      
    226225     *      fireNow =    
    227226     */ 
    228227    public void addListener(bool delegate() dlg, bool fireNow=false) 
    …… 
    287286    /** 
    288287     * Creates a new idle cycle. 
    289288     * Params: 
    290      *      interval =  the idle in milieconds 
    291      *      delegate() =    the delegate to be executed 
    292      *      fireNow =   When true the delegate will be executed emmidiatly 
    293      * Returns:  
     289     *      interval = the idle in milieconds 
     290     *      dlg = the delegate to be executed 
     291     *      fireNow = When true the delegate will be executed emmidiatly 
    294292     */ 
    295293    this(bool delegate() dlg, bool fireNow=false) 
    296294    { 
    …… 
    305303        } 
    306304    } 
    307305 
     306    /** */ 
    308307    public void stop() 
    309308    { 
    310309        if ( idleID > 0 ) 
    …… 
    316315     
    317316    /** 
    318317     * Removes the idle from gtk 
    319      * Returns:  
    320318     */ 
    321319    ~this() 
    322320    { 
    …… 
    326324    /** 
    327325     * Adds a new delegate to this idle cycle 
    328326     * Params: 
    329      *      delegate() =   
     327     *      dlg =      
    330328     *      fireNow =    
    331329     */ 
    332330    public void addListener(bool delegate() dlg, bool fireNow=false) 
    …… 
    722720structWrap: GdkScreen* Screen 
    723721 
    724722code: start 
    725  
     723    /** */ 
    726724    public Widget addButton(StockID stockID, int responseId) 
    727725    { 
    728726        return addButton(StockDesc[stockID], responseId); 
    729727    } 
    730728     
    731  
     729    /** */ 
    732730    public void addButtons(char[][] buttonsText, ResponseType[] responses) 
    733731    { 
    734732        for ( int i=0 ; i<buttonsText.length && i<responses.length ; i++) 
    …… 
    737735        } 
    738736    } 
    739737     
     738    /** */ 
    740739    public void addButtons(StockID[] stockIDs, ResponseType[] responses) 
    741740    { 
    742741        for ( int i=0 ; i<stockIDs.length && i<responses.length ; i++) 
    …… 
    776775     * user may want to see. When the user clicks a button a "response" 
    777776     * signal is emitted with response IDs from GtkResponseType. See 
    778777     * GtkDialog for more details. 
    779      * parent: 
    780      *  transient parent, or NULL for none 
    781      * flags: 
    782      *  flags 
    783      * type: 
    784      *  type of message 
    785      * buttons: 
    786      *  set of buttons to use 
    787      * message_format: 
    788      *  printf()-style format string, or NULL 
    789      * message: 
    790      *  the message - should be null, any formatting should be done prior to call this constructor 
     778     * Params: 
     779     *      parent = transient parent, or NULL for none 
     780     *      flags = flags 
     781     *      type = type of message 
     782     *      buttons= set of buttons to use 
     783     *      messageFormat = printf()-style format string, or NULL 
     784     *      message = the message - should be null, any formatting should be done prior to call this constructor 
    791785     *  arguments for message_format 
    792786     * Returns: 
    793787     *  a new GtkMessageDialog 
    …… 
    813807     * instead, since you can't pass the markup string either 
    814808     * as the format (it might contain '%' characters) or as a string 
    815809     * argument. 
     810     * Since 2.4 
     811     * Examples: 
     812     * -------------------- 
    816813     *  GtkWidget *dialog; 
    817814     *  dialog = gtk_message_dialog_new (main_application_window, 
    818815     *  GTK_DIALOG_DESTROY_WITH_PARENT, 
    …… 
    821818     *  NULL); 
    822819     *  gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), 
    823820     *  markup); 
    824      * parent: 
    825      *  transient parent, or NULL for none 
    826      * flags: 
    827      *  flags 
    828      * type: 
    829      *  type of message 
    830      * buttons: 
    831      *  set of buttons to use 
    832      * message_format: 
    833      *  printf()-style format string, or NULL 
    834      * message: 
    835      *  the message - should be null, any formatting should be done prior to call this constructor 
    836      * ...: 
    837      *  arguments for message_format 
    838      * Returns: 
    839      *  a new GtkMessageDialog 
    840      * Since 2.4 
     821     * -------------------- 
     822     * Params: 
     823     *  parent = transient parent, or NULL for none 
     824     *  flags = flags 
     825     *  type = type of message 
     826     *  buttons = set of buttons to use 
     827     *  messageFormat = printf()-style format string, or NULL 
     828     *  message = the message - should be null, any formatting should be done prior to call this constructor 
    841829     */ 
    842830    public this (Window parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, bool markup, char[] messageFormat, char[] message=null ) 
    843831    { 
    …… 
    885873code: start 
    886874    /** 
    887875     * Create an information popup dialog. 
    888      * @param message The message to show on the dialog 
    889      * @param title The title of the dialog 
     876     * Params: 
     877     *  message = The message to show on the dialog 
     878     *  title = The title of the dialog 
    890879     */ 
    891880    public static void information(char[] message, char[] title) 
    892881    { 
    …… 
    895884     
    896885    /** 
    897886     * Create an information popup dialog. 
    898      * @param parent The parent window of this popup dialog 
    899      * @param message The message to show on the dialog 
    900      * @param title The title of the dialog 
     887     * Params: 
     888     *  parent = The parent window of this popup dialog 
     889     *  message = The message to show on the dialog 
     890     *  title = The title of the dialog 
    901891     */ 
    902892    public static void information(Window parent, char[] message, char[] title) 
    903893    { 
    …… 
    914904     
    915905    /** 
    916906     * Create an error popup dialog. 
    917      * @param message The message to show on the dialog 
    918      * @param title The title of the dialog 
     907     * Params: 
     908     *  message = The message to show on the dialog 
     909     *  title = The title of the dialog 
    919910     */ 
    920911    public static void error(char[] message, char[] title) 
    921912    { 
    …… 
    924915     
    925916    /** 
    926917     * Create an error popup dialog. 
    927      * @param parent The parent window of this popup dialog 
    928      * @param message The message to show on the dialog 
    929      * @param title The title of the dialog 
     918     * Params: 
     919     *  parent = The parent window of this popup dialog 
     920     *  message = The message to show on the dialog 
     921     *  title = The title of the dialog 
    930922     */ 
    931923    public static void error(Window parent, char[] message, char[] title) 
    932924    { 
    …… 
    944936     
    945937    /** 
    946938     * Create an 'yes' or 'no' popup dialog. 
    947      * @param message The message to show on the dialog 
    948      * @param title The title of the dialog 
     939     * Params: 
     940     *  message = The message to show on the dialog 
     941     *  title = The title of the dialog 
    949942     */ 
    950943    public static bool yesNo(char[] message, char[] title) 
    951944    { 
    …… 
    954947     
    955948    /** 
    956949     * Create an 'yes' or 'no' popup dialog. 
    957      * @param parent The parent window of this popup dialog 
    958      * @param message The message to show on the dialog 
    959      * @param title The title of the dialog 
     950     * Params: 
     951     *  parent = The parent window of this popup dialog 
     952     *  message = The message to show on the dialog 
     953     *  title = The title of the dialog 
    960954     */ 
    961955    public static bool yesNo(Window parent, char[] message, char[] title) 
    962956    { 
    …… 
    976970     
    977971    /** 
    978972     * Create an 'yes', 'no' or 'cancel' popup dialog. 
    979      * @param message The message to show on the dialog 
    980      * @param title The title of the dialog 
     973     * Params: 
     974     *  message = The message to show on the dialog 
     975     *  title = The title of the dialog 
    981976     */ 
    982977    public static ResponseType yesNoCancel(char[] message, char[] title) 
    983978    { 
    …… 
    986981     
    987982    /** 
    988983     * Create an 'yes', 'no' or 'cancel' popup dialog. 
    989      * @param parent The parent window of this popup dialog 
    990      * @param message The message to show on the dialog 
    991      * @param title The title of the dialog 
     984     * Params: 
     985     *  parent = The parent window of this popup dialog 
     986     *  message = The message to show on the dialog 
     987     *  title = The title of the dialog 
    992988     */ 
    993989    public static ResponseType yesNoCancel(Window parent, char[] message, char[] title) 
    994990    { 
    …… 
    10361032    /** 
    10371033     * Creates a top level window with a title 
    10381034     * Params: 
    1039      *      title: The Window title 
     1035     *      title = The Window title 
    10401036     */ 
    10411037    public this(char[] title) 
    10421038    { 
    …… 
    10901086     
    10911087    /** 
    10921088     * Executed when the user tries to close the window 
    1093      * @return true to refuse to close the window 
     1089     * Returns: true to refuse to close the window 
    10941090     */ 
    10951091    protected int windowDelete(Event event, Widget widget) 
    10961092    { 
    …… 
    11061102     
    11071103    /** 
    11081104     * Allows the application to close and decide if it can exit 
    1109      * @param code the code reason to exit 
    1110      * @param force if true the application must expect to be closed even against it's will 
    1111      * @return false to refuse to exit 
     1105     * Params: 
     1106     *  code = the code reason to exit 
     1107     *  force = if true the application must expect to be closed even against it's will 
     1108     * Returns: false to refuse to exit 
    11121109     */ 
    11131110    protected bool exit(int code, bool force) 
    11141111    { 
    …… 
    12111208     * icon name isn't known, the image will be empty. 
    12121209     * You can register your own stock icon names, see 
    12131210     * gtk_icon_factory_add_default() and gtk_icon_factory_add(). 
    1214      * stock_id: 
    1215      *  a stock icon name 
    1216      * size: 
    1217      *  a stock icon size 
     1211     * Params: 
     1212     *  StockID = a stock icon name 
     1213     *  size = a stock icon size 
    12181214     * Returns: 
    12191215     *  a new GtkImage displaying the stock icon 
    12201216     */ 
    …… 
    12281224     * Creates a GtkImage displaying an icon from the current icon theme. 
    12291225     * If the icon name isn't known, a "broken image" icon will be 
    12301226     * displayed instead. If the current icon theme is changed, the icon 
    1231      * will be updated appropriately. 
    1232      * icon_name: 
    1233      *  an icon name 
    1234      * size: 
    1235      *  a stock icon size 
     1227     * will be updated appropriately. Since 2.6 
     1228     * Params: 
     1229     *  iconName = an icon name 
     1230     *  size = a stock icon size 
    12361231     * Returns: 
    12371232     *  a new GtkImage displaying the themed icon 
    1238      * Since 2.6 
    12391233     */ 
    12401234    public this (char[] iconName, GtkIconSize size) 
    12411235    { 
    …… 
    12721266     * label is inside a button or menu item, the button or menu item will 
    12731267     * automatically become the mnemonic widget and be activated by 
    12741268     * the mnemonic. 
    1275      * str: 
    1276      *  The text of the label, with an underscore in front of the 
     1269     * Params: 
     1270     *  str = The text of the label, with an underscore in front of the 
    12771271     *  mnemonic character 
    1278      * mnemonic: when false uses the literal text passed in without mnemonic 
    1279      * Returns: 
    1280      *  the new GtkLabel 
     1272     *  mnemonic = when false uses the literal text passed in without mnemonic 
    12811273     */ 
    12821274    public this (char[] str, bool mnemonic=true) 
    12831275    { 
    …… 
    13401332    /** An arbitrary string to be used by the application */ 
    13411333    private char[] action; 
    13421334 
     1335    /** */ 
    13431336    public static void setIconSize(IconSize iconSize) 
    13441337    { 
    13451338        currentIconSize = iconSize; 
    13461339    } 
     1340 
     1341    /** */ 
    13471342    public static IconSize getIconSize() 
    13481343    { 
    13491344        return currentIconSize; 
    13501345    } 
    13511346 
     1347    /** */ 
    13521348    public void setActionName(char[] action) 
    13531349    { 
    13541350        this.action = action.dup; 
    13551351    } 
    1356      
     1352 
     1353    /** */ 
    13571354    public char[] getActionName() 
    13581355    { 
    13591356        return action; 
    …… 
    13661363     * underscores). The first underlined character represents a keyboard 
    13671364     * accelerator called a mnemonic. 
    13681365     * Pressing Alt and that key activates the button. 
    1369      * label: 
    1370      *  The text of the button, with an underscore in front of the 
     1366     * Params: 
     1367     *  label = The text of the button, with an underscore in front of the 
    13711368     *  mnemonic character 
     1369     *  mnemonic = true if the button has an mnemnonic 
    13721370     * Returns: 
    13731371     *  a new GtkButton 
    13741372     */ 
    …… 
    13921390     * GTK_STOCK_APPLY. 
    13931391     * If stock_id is unknown, then it will be treated as a mnemonic 
    13941392     * label (as for gtk_button_new_with_mnemonic()). 
    1395      * stock_id: 
    1396      *  the name of the stock item 
    1397      * Returns: 
    1398      *  a new GtkButton 
     1393     * Params: 
     1394     *  StockID = the name of the stock item 
    13991395     */ 
    14001396    public this (StockID stockID, bool hideLabel=false) 
    14011397    { 
    …… 
    14131409         
    14141410    } 
    14151411     
     1412    /** */ 
    14161413    public this(StockID stockID, void delegate(Button) dlg, bool hideLabel=false) 
    14171414    { 
    14181415        this(stockID, hideLabel); 
    14191416        addOnClicked(dlg); 
    14201417    } 
    14211418     
    1422  
     1419    /** */ 
    14231420    public this(char[] label, void delegate(Button) dlg, bool mnemonic=true) 
    14241421    { 
    14251422        this(label, mnemonic); 
    14261423        addOnClicked(dlg); 
    14271424    } 
    14281425 
     1426    /** */ 
    14291427    public this(char[] label, void delegate(Button) dlg, char[] action) 
    14301428    { 
    14311429        this(label); 
    …… 
    14551453     * If mnemonic is true the label 
    14561454     * will be created using gtk_label_new_with_mnemonic(), so underscores 
    14571455     * in label indicate the mnemonic for the check button. 
    1458      * label: 
    1459      *  The text of the button, with an underscore in front of the 
     1456     * Params: 
     1457     *  label = The text of the button, with an underscore in front of the 
    14601458     *  mnemonic character 
    1461      * label: 
    1462      * the text for the check button. 
    1463      * Returns: 
    1464      * a GtkWidget. 
     1459     *  mnemonic = true if the button has an mnemnonic 
    14651460     */ 
    14661461    public this (char[] label, bool mnemonic=true) 
    14671462    { 
    …… 
    14761471            this(cast(GtkCheckButton*)gtk_check_button_new_with_label(Str.toStringz(label)) ); 
    14771472        } 
    14781473    } 
    1479      
     1474 
     1475    /** */ 
    14801476    public this(char[] label, void delegate(CheckButton) onClicked, bool mnemonic=true) 
    14811477    { 
    14821478        this(label, mnemonic); 
    …… 
    15041500code: start 
    15051501    /** 
    15061502     * Creates a new GtkRadioButton with a text label. 
    1507      * If mnemonic if true the label will be created using 
    1508      * gtk_label_new_with_mnemonic(), so underscores in label indicate the 
    1509      * mnemonic for the button. 
    1510      * an existing radio button group, or NULL if you are creating a new 
    1511      * group. 
    1512      * label: 
    1513      * the text label to display next to the radio button. 
    1514      * Returns: 
    1515      * a new radio button. 
     1503     * Params: 
     1504     *  group = an existing radio button group, or NULL if you are creating a new 
     1505     *  group. 
     1506     *  label = the text label to display next to the radio button. 
     1507     *  mnemonic = if true the label will be created using 
     1508     *  gtk_label_new_with_mnemonic(), so underscores in label indicate the 
     1509     *  mnemonic for the button. 
    15161510     */ 
    15171511    public this (ListSG group, char[] label, bool mnemonic=true) 
    15181512    { 
    …… 
    15371531    /** 
    15381532     * Creates a new GtkRadioButton with a text label, adding it to the same group 
    15391533     * as group. 
    1540      * It mnemonic it true the label 
    1541      * will be created using gtk_label_new_with_mnemonic(), so underscores 
    1542      * in label indicate the mnemonic for the button. 
    1543      * group: 
    1544      * an existing GtkRadioButton. 
    1545      * label: 
    1546      * a text string to display next to the radio button. 
    1547      * Returns: 
    1548      * a new radio button. 
     1534     * Params: 
     1535     *  group = an existing GtkRadioButton. 
     1536     *  label = a text string to display next to the radio button. 
     1537     *  mnemonic = if true the label 
     1538     *  will be created using gtk_label_new_with_mnemonic(), so underscores 
     1539     *  in label indicate the mnemonic for the button. 
    15491540     */ 
    15501541    public this (RadioButton radioButton, char[] label, bool mnemonic=true) 
    15511542    { 
    …… 
    15821573code: start 
    15831574    /** 
    15841575     * Creates a new toggle button with a text label. 
    1585      * If mnemonic is true the label 
    1586      * will be created using gtk_label_new_with_mnemonic(), so underscores 
    1587      * in label indicate the mnemonic for the button. 
    1588      * label: 
    1589      * a string containing the message to be placed in the toggle button. 
    1590      * Returns: 
    1591      * a new toggle button. 
     1576     * Params: 
     1577     *  label = a string containing the message to be placed in the toggle button. 
     1578     *  mnemonic =  if true the label 
     1579     *  will be created using gtk_label_new_with_mnemonic(), so underscores 
     1580     *  in label indicate the mnemonic for the button. 
    15921581     */ 
    15931582    public this (char[] label, bool mnemonic=true) 
    15941583    { 
    …… 
    16211610structWrap: GtkEntryCompletion* EntryCompletion 
    16221611 
    16231612code: start 
     1613    /** */ 
    16241614    public this (char[] text) 
    16251615    { 
    16261616        this(); 
    16271617        setText(text); 
    16281618    } 
    1629      
     1619 
     1620    /** */   
    16301621    public this (char[] text, int max) 
    16311622    { 
    16321623        this(max); 
    …… 
    17141705structWrap: GtkTextChildAnchor* TextChildAnchor 
    17151706 
    17161707code: start 
     1708    /** */ 
    17171709    public this() 
    17181710    { 
    17191711        this(new GtkTextIter); 
    …… 
    17821774    /** 
    17831775     * Deletes current contents of buffer, and inserts text instead. If 
    17841776     * len is -1, text must be nul-terminated. text must be valid UTF-8. 
    1785      * buffer: 
    1786      *  a GtkTextBuffer 
    1787      * text: 
    1788      *  UTF-8 text to insert 
    1789      * len: 
    1790      *  length of text in bytes 
     1777     * Params: 
     1778     *  text = UTF-8 text to insert 
    17911779     */ 
    17921780    public void setText(char[] text) 
    17931781    { 
    …… 
    17951783        gtk_text_buffer_set_text(gtkTextBuffer, Str.toStringz(text), text.length); 
    17961784    } 
    17971785     
    1798        /** 
     1786    /** 
    17991787     * Inserts len bytes of text at position iter. If len is -1, 
    18001788     * text must be nul-terminated and will be inserted in its 
    18011789     * entirety. Emits the "insert_text" signal; insertion actually occurs 
    …… 
    18031791     * insertion occurs (because the buffer contents change), but the 
    18041792     * default signal handler revalidates it to point to the end of the 
    18051793     * inserted text. 
    1806      * buffer: 
    1807      *  a GtkTextBuffer 
    1808      * iter: 
    1809      *  a position in the buffer 
    1810      * text: 
    1811      *  UTF-8 format text to insert 
    1812      * len: 
    1813      *  length of text in bytes, or -1 
     1794     * Params: 
     1795     *  iter = a position in the buffer 
     1796     *  text = UTF-8 format text to insert 
    18141797     */ 
    18151798    public void insert(TextIter iter, char[] text) 
    18161799    { 
    …… 
    18211804    /** 
    18221805     * Simply calls gtk_text_buffer_insert(), using the current 
    18231806     * cursor position as the insertion point. 
    1824      * buffer: 
    1825      *  a GtkTextBuffer 
    1826      * text: 
    1827      *  some text in UTF-8 format 
    1828      * len: 
    1829      *  length of text, in bytes 
     1807     * Params: 
     1808     *  text = some text in UTF-8 format 
    18301809     */ 
    18311810    public void insertAtCursor(char[] text) 
    18321811    { 
    …… 
    18421821     * default_editable indicates the editability of text that doesn't 
    18431822     * have a tag affecting editability applied to it. Typically the 
    18441823     * result of gtk_text_view_get_editable() is appropriate here. 
    1845      * buffer: 
    1846      *  a GtkTextBuffer 
    1847      * iter: 
    1848      *  a position in buffer 
    1849      * text: 
    1850      *  some UTF-8 text 
    1851      * len: 
    1852      *  length of text in bytes, or -1 
    1853      * default_editable: 
    1854      *  default editability of buffer 
     1824     * Params: 
     1825     *  iter = a position in buffer 
     1826     *  text = some UTF-8 text 
     1827     *  defaultEditable = default editability of buffer 
    18551828     * Returns: 
    18561829     *  whether text was actually inserted 
    18571830     */ 
    …… 
    18671840     * default_editable indicates the editability of text that doesn't 
    18681841     * have a tag affecting editability applied to it. Typically the 
    18691842     * result of gtk_text_view_get_editable() is appropriate here. 
    1870      * buffer: 
    1871      *  a GtkTextBuffer 
    1872      * text: 
    1873      *  text in UTF-8 format 
    1874      * len: 
    1875      *  length of text in bytes, or -1 
    1876      * default_editable: 
    1877      *  default editability of buffer 
     1843     * Params: 
     1844     *  text = text in UTF-8 format 
     1845     *  defaultEditable = default editability of buffer 
    18781846     * Returns: 
    18791847     *  whether text was actually inserted 
    18801848     */ 
    …… 
    18901858     * terminate the list. Equivalent to calling gtk_text_buffer_insert(), 
    18911859     * then gtk_text_buffer_apply_tag() on the inserted text; 
    18921860     * gtk_text_buffer_insert_with_tags() is just a convenience function. 
    1893      * buffer: 
    1894      *  a GtkTextBuffer 
    1895      * iter: 
    1896      *  an iterator in buffer 
    1897      * text: 
    1898      *  UTF-8 text 
    1899      * len: 
    1900      *  length of text, or -1 
    1901      * first_tag: 
    1902      *  first tag to apply to text 
    1903      * ...: 
    1904      *  NULL-terminated list of tags to apply 
     1861     * Params: 
     1862     *  iter = an iterator in buffer 
     1863     *  text = UTF-8 text 
     1864     *  ... = NULL-terminated list of tags to apply 
    19051865     */ 
    19061866    //version(Tango){} else -- still doesn't work on tango, but it compiles now 
    19071867    public void insertWithTags(TextIter iter, char[] text, ... ) 
    …… 
    19171877    /** 
    19181878     * Same as gtk_text_buffer_insert_with_tags(), but allows you 
    19191879     * to pass in tag names instead of tag objects. 
    1920      * buffer: 
    1921      *  a GtkTextBuffer 
    1922      * iter: 
    1923      *  position in buffer 
    1924      * text: 
    1925      *  UTF-8 text 
    1926      * len: 
    1927      *  length of text, or -1 
    1928      * first_tag_name: 
    1929      *  name of a tag to apply to text 
    1930      * ...: 
    1931      *  more tag names 
     1880     * Params: 
     1881     *  iter = position in buffer 
     1882     *  text = UTF-8 text 
     1883     *  ... = more tag names 
    19321884     */ 
    19331885    // version(Tango){} else  -- still doesn't work on tango, but it compiles now  
    19341886    public void insertWithTagsByName(TextIter iter, char[] text, ... ) 
    …… 
    19431895     
    19441896    /** 
    19451897     * Create a new tag for this buffer 
    1946      * @param tagName can be null for no name 
    1947      * @param propertyName 
    1948      * @param propertyValue 
    1949      */ 
     1898     * Params: 
     1899     *  tagName= can be null for no name 
     1900     *  propertyName= 
     1901     *  propertyValue= 
     1902     */  
    19501903    TextTag createTag(char[] tagName, char[] propertyName, int propertyValue,  
    19511904                                       char[] propertyName1, char[] propertyValue1) 
    19521905    { 
    …… 
    19621915    } 
    19631916    /** 
    19641917     * Create a new tag for this buffer 
    1965      * @param tagName can be null for no name 
    1966      * @param propertyName 
    1967      * @param propertyValue 
     1918     * Params: 
     1919     *  tagName= can be null for no name 
     1920     *  propertyName= 
     1921     *  propertyValue= 
    19681922     */ 
    19691923    TextTag createTag(char[] tagName, char[] propertyName, int propertyValue) 
    19701924    { 
    …… 
    19781932 
    19791933    /** 
    19801934     * Create a new tag for this buffer 
    1981      * @param tagName can be null for no name 
    1982      * @param propertyName 
    1983      * @param propertyValue 
     1935     * Params: 
     1936     *  tagName= can be null for no name 
     1937     *  propertyName= 
     1938     *  propertyValue= 
    19841939     */ 
    19851940    TextTag createTag(char[] tagName, char[] propertyName, double propertyValue) 
    19861941    { 
    …… 
    19921947     
    19931948    /** 
    19941949     * Create a new tag for this buffer 
    1995      * @param tagName can be null for no name 
    1996      * @param propertyName 
    1997      * @param propertyValue 
    1998      * @param propertyName2 
    1999      * @param propertyValue2 
     1950     * Params: 
     1951     *  tagName= can be null for no name 
     1952     *  propertyName= 
     1953     *  propertyValue= 
     1954     *  propertyName2= 
     1955     *  propertyValue2= 
    20001956     */ 
    20011957    TextTag createTag(char[] tagName, char[] propertyName, int propertyValue, char[] propertyName2, int propertyValue2) 
    20021958    { 
    …… 
    20051961        ); 
    20061962    } 
    20071963 
     1964    /** Create a new tag for this buffer */ 
    20081965    TextTag createTag(char[] tagName, char[] propertyName, int propertyValue, char[] propertyName2, int propertyValue2, char[] propertyName3, int propertyValue3, char[] propertyName4, int propertyValue4, char[] propertyName5, int propertyValue5) 
    20091966    { 
    20101967        return new TextTag( 
    20111968            gtk_text_buffer_create_tag(gtkTextBuffer, Str.toStringz(tagName), Str.toStringz(propertyName), propertyValue, Str.toStringz(propertyName2), propertyValue2, Str.toStringz(propertyName3), propertyValue3, Str.toStringz(propertyName4), propertyValue4, Str.toStringz(propertyName5), propertyValue5, null) 
    20121969        ); 
    20131970    } 
     1971 
    20141972    /** 
    20151973     * Create a new tag for this buffer 
    2016      * @param tagName can be null for no name 
    2017      * @param propertyName 
    2018      * @param propertyValue 
     1974     * Params: 
     1975     *  tagName= can be null for no name 
     1976     *  propertyName= 
     1977     *  propertyValue= 
    20191978     */ 
    20201979    TextTag createTag(char[] tagName, char[] propertyName, char[] propertyValue) 
    20211980    { 
    …… 
    20271986 
    20281987    /** 
    20291988     * Create a new tag for this buffer 
    2030      * @param tagName can be null for no name 
    2031      * @param propertyName 
    2032      * @param propertyValue 
    2033      * @return  
     1989     * Params: 
     1990     *  tagName = can be null for no name 
     1991     *  propertyName= 
     1992     *  propertyValue=  
    20341993     */ 
    20351994    TextTag createTag(char[] tagName, char[] propertyName, Bitmap propertyValue) 
    20361995    { 
    …… 
    20422001 
    20432002    /** 
    20442003     * Obtain the entire text  
    2045      * @return The text char[] 
     2004     * Returns: The text char[] 
    20462005     */ 
    20472006    char[] getText() 
    20482007    { 
    …… 
    20542013 
    20552014    /** 
    20562015     * Create a new tag for this buffer 
    2057      * @param tagName can be null for no name 
    2058      * @param propertyName 
    2059      * @param propertyValue 
    2060      * @param propertyName2 
    2061      * @param propertyValue2 
     2016     * Params: 
     2017     *  tagName= can be null for no name 
     2018     *  propertyName= 
     2019     *  propertyValue= 
     2020     *  propertyName2= 
     2021     *  propertyValue2= 
    20622022     */ 
    20632023    TextTag createTag(char[] tagName,  
    20642024            char[] propertyName, char[] propertyValue,  
    …… 
    21722132 
    21732133    /** 
    21742134     * Simply appends some on the cursor position 
    2175      * @param text the text to append 
     2135     * Params: 
     2136     *  text = the text to append 
    21762137     */ 
    21772138    void insertText(char[] text) 
    21782139    { 
    …… 
    21822143 
    21832144    /** 
    21842145     * Simply appends some text to this view 
    2185      * @param text the text to append 
     2146     * Params: 
     2147     *  text = the text to append 
    21862148     */ 
    21872149    void appendText(char[] text, bool ensureVisible=true) 
    21882150    body 
    …… 
    22472209     */ 
    22482210    int getValueInt(TreeIter iter, int column); 
    22492211 
     2212    /** */ 
    22502213    void setValue(TreeIter iter, int column, char[] value); 
    22512214 
     2215    /** */ 
    22522216    void setValue(TreeIter iter, int column, int value); 
    22532217 
    22542218interfaceCode: end 
    …… 
    22782242        return value.getInt(); 
    22792243    } 
    22802244 
    2281        /** 
     2245    /** 
    22822246     * Sets iter to a valid iterator pointing to path. 
    2283      * tree_model: 
    2284      *  A GtkTreeModel. 
    2285      * iter: 
    2286      *  The uninitialized GtkTreeIter. 
    2287      * path: 
    2288      *  The GtkTreePath. 
     2247     * Params: 
     2248     *  iter = The uninitialized GtkTreeIter. 
     2249     *  path = The GtkTreePath. 
    22892250     * Returns: 
    22902251     *  TRUE, if iter was set. 
    22912252     */ 
    …… 
    23222283     */ 
    23232284    GtkTreeModel *gtkTreeModel;  
    23242285 
     2286    /** */ 
    23252287    public void setModel(GtkTreeModel *gtkTreeModel) 
    23262288    { 
    23272289        this.gtkTreeModel = gtkTreeModel; 
    23282290    } 
    2329         
     2291 
     2292    /** */        
    23302293    public void setModel(TreeModel treeModel) 
    23312294    { 
    23322295        this.gtkTreeModel = treeModel.getTreeModelStruct(); 
    23332296    } 
    23342297        
     2298    /** */ 
    23352299    public this(TreeModel treeModel, TreePath treePath) 
    23362300    { 
    23372301        this(); 
    …… 
    23562320     
    23572321    /** 
    23582322     * Get Value 
    2359      * @param iter 
    2360      * @param column 
    2361      * @param value 
     2323     * Params: 
     2324     *  column = 
     2325     *  value = 
    23622326     */ 
    23632327    void getValue(int column, Value value) 
    23642328    { 
    …… 
    23712335 
    23722336    /** 
    23732337     * Get the value of a column as a string 
    2374      * @para column the column number 
    2375      * @return a string representing the value of the column 
     2338     * Params: 
     2339     *  column = the column number 
     2340     * Returns: a string representing the value of the column 
    23762341     */ 
    23772342    char[] getValueString(int column) 
    23782343    { 
    …… 
    23882353 
    23892354    /** 
    23902355     * Get the value of a column as an int 
    2391      * @para column the column number 
    2392      * @return a string representing the value of the column 
     2356     * Params: 
     2357     *  column = the column number 
     2358     * Returns: a string representing the value of the column 
    23932359     */ 
    23942360    int getValueInt(int column) 
    23952361    { 
    …… 
    24022368        return value.getInt(); 
    24032369    } 
    24042370 
     2371    /** */ 
    24052372    TreePath getTreePath() 
    24062373    { 
    24072374        if ( gtkTreeModel  is  null ) 
    …… 
    24112378        return new TreePath(gtk_tree_model_get_path(gtkTreeModel, gtkTreeIter)); 
    24122379    } 
    24132380 
    2414        /** 
     2381    /** 
    24152382     * This return the path visible to the user. 
    24162383     */ 
    24172384    char[] getVisiblePath(char[] separator) 
    …… 
    24382405     
    24392406    /** 
    24402407     * Gets the parent of this iter 
    2441      * @param child 
    2442      * @return the parent iter or null if can't get parent or an error occured 
     2408     * Returns: the parent iter or null if can't get parent or an error occured 
    24432409     */ 
    24442410    TreeIter getParent() 
    24452411    { 
    …… 
    24572423        return parent; 
    24582424    } 
    24592425 
    2460  
     2426    /** */ 
    24612427    TreeIter getGrandParent() 
    24622428    { 
    24632429        if ( gtkTreeModel  is  null ) 
    …… 
    25012467code: start 
    25022468    /** 
    25032469     * Creates a new GtkTreePath. This structure refers to a row. 
    2504      * if firstRow is true this is the string representation of this path is "0" 
    2505      * Returns: 
    2506      *  A newly created GtkTreePath. 
     2470     * Params: 
     2471     * firstRow = if true this is the string representation of this path is "0" 
    25072472     */ 
    25082473    public this (bool firstRow=false) 
    25092474    { 
    …… 
    25442509import(tango): tango.core.Exception 
    25452510 
    25462511code: start 
    2547 /** 
    2548  * A TreeIter error. 
    2549  * thrown<br> 
    2550  * - trying to access a method that requires a tree model and the tree model was never set 
    2551  */ 
     2512   /** 
     2513    * A TreeIter error. 
     2514    * thrown<br> 
     2515    * - trying to access a method that requires a tree model and the tree model was never set 
     2516    */ 
    25522517    public this(char[] method, char[] message) 
    25532518    { 
    25542519        super("TreeIter."~method~" : "~message); 
    …… 
    25862551     * just want to test if selection has any selected nodes. model is filled 
    25872552     * with the current model as a convenience. This function will not work if you 
    25882553     * use selection is GTK_SELECTION_MULTIPLE. 
    2589      * selection: 
    2590      *  A GtkTreeSelection. 
    2591      * model: 
    2592      *  A pointer to set to the GtkTreeModel, or NULL. 
    2593      * iter: 
    2594      *  The GtkTreeIter, or NULL. 
     2554     * Params: 
     2555     *  model = A pointer to set to the GtkTreeModel, or NULL. 
     2556     *  iter = The GtkTreeIter, or NULL. 
    25952557     * Returns: 
    25962558     *  TRUE, if there is a selected node. 
    25972559     */ 
    …… 
    26092571     * To free the return value, use: 
    26102572     * g_list_foreach (list, gtk_tree_path_free, NULL); 
    26112573     * g_list_free (list); 
    2612      * selection: 
    2613      *  A GtkTreeSelection. 
    2614      * model: 
    2615      *  A pointer to set to the GtkTreeModel, or NULL. 
     2574     * Since 2.2 
     2575     * Params: 
     2576     *  model = A pointer to set to the GtkTreeModel, or NULL. 
    26162577     * Returns: 
    26172578     *  A GList containing a GtkTreePath for each selected row. 
    2618      * Since 2.2 
    26192579     */ 
    26202580    TreePath[] getSelectedRows(TreeModel model) 
    26212581    { 
    …… 
    26622622code: start 
    26632623    /** 
    26642624     * Creates a new Tree view column 
    2665      * @param header th column header text 
    2666      * @param renderer the rederer for the column cells 
    2667      * @param type the type of data to be displayed (shouldn't this be on the renderer?) 
    2668      * @param column the column number 
     2625     * Params: 
     2626     *  header = th column header text 
     2627     *  renderer = the rederer for the column cells 
     2628     *  type = the type of data to be displayed (shouldn't this be on the renderer?) 
     2629     *  column = the column number 
    26692630     */ 
    26702631    this(char [] header, CellRenderer renderer, char [] type, int column) 
    26712632    { 
    …… 
    27222683code: start 
    27232684    /** 
    27242685     * Expands the row of the iter. 
    2725      * @param iter 
    2726      * @param openAll 
    2727      * @return 
     2686     * Params: 
     2687     *  iter = 
     2688     *  openAll = 
     2689     *  Returns = 
    27282690     */ 
    27292691    int expandRow(TreeIter iter, TreeModel model, int openAll) 
    27302692    { 
    27312693        return expandRow(model.getPath(iter), openAll); 
    27322694    } 
    27332695 
    2734        /** 
     2696    /** 
    27352697     * Finds the path at the point (x, y), relative to widget coordinates. That 
    27362698     * is, x and y are relative to an events coordinates. x and y must come 
    27372699     * from an event on the tree_view only where event->window == 
    …… 
    27422704     * cell_x and cell_y return the coordinates relative to the cell background 
    27432705     * (i.e. the background_area passed to gtk_cell_renderer_render()). This 
    27442706     * function is only meaningful if tree_view is realized. 
    2745      * tree_view: 
    2746      *  A GtkTreeView. 
    2747      * x: 
    2748      *  The x position to be identified. 
    2749      * y: 
    2750      *  The y position to be identified. 
    2751      * path: 
    2752&