src/atk/RelationSet.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = AtkRelationSet.html
  26  * outPack = atk
  27  * outFile = RelationSet
  28  * strct   = AtkRelationSet
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = RelationSet
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - atk_relationSet_
  40  * omit structs:
  41  * omit prefixes:
  42  * omit code:
  43  * imports:
  44  *      - glib.PtrArray
  45  * structWrap:
  46  *      - GPtrArray* -> PtrArray
  47  * local aliases:
  48  */
  49
  50 module atk.RelationSet;
  51
  52 private import atk.atktypes;
  53
  54 private import lib.atk;
  55
  56 private import glib.PtrArray;
  57
  58 /**
  59  * Description
  60  * The AtkRelationSet held by an object establishes its relationships with
  61  * objects beyond the normal "parent/child" hierarchical relationships that all
  62  * user interface objects have. AtkRelationSets establish whether objects are
  63  * labelled or controlled by other components, share group membership with other
  64  * components (for instance within a radio-button group), or share content which
  65  * "flows" between them, among other types of possible relationships.
  66  */
  67 private import gobject.ObjectG;
  68 public class RelationSet : ObjectG
  69 {
  70
  71         /** the main Gtk struct */
  72         protected AtkRelationSet* atkRelationSet;
  73
  74
  75         public AtkRelationSet* getRelationSetStruct()
  76         {
  77                 return atkRelationSet;
  78         }
  79
  80
  81         /** the main Gtk struct as a void* */
  82         protected void* getStruct()
  83         {
  84                 return cast(void*)atkRelationSet;
  85         }
  86
  87         /**
  88          * Sets our main struct and passes it to the parent class
  89          */
  90         public this (AtkRelationSet* atkRelationSet)
  91         {
  92                 super(cast(GObject*)atkRelationSet);
  93                 this.atkRelationSet = atkRelationSet;
  94         }
  95
  96         /**
  97          */
  98
  99
 100         /**
 101          * Creates a new empty relation set.
 102          * Returns:
 103          *  a new AtkRelationSet
 104          */
 105         public static AtkRelationSet* atkRelationSetNew()
 106         {
 107                 // AtkRelationSet* atk_relation_set_new (void);
 108                 return atk_relation_set_new();
 109         }
 110
 111         /**
 112          * Determines whether the relation set contains a relation that matches the
 113          * specified type.
 114          * set:
 115          *  an AtkRelationSet
 116          * relationship:
 117          *  an AtkRelationType
 118          * Returns:
 119          *  TRUE if relationship is the relationship type of a relation
 120          * in set, FALSE otherwise
 121          */
 122         public int atkRelationSetContains(AtkRelationType relationship)
 123         {
 124                 // gboolean atk_relation_set_contains (AtkRelationSet *set,  AtkRelationType relationship);
 125                 return atk_relation_set_contains(atkRelationSet, relationship);
 126         }
 127
 128         /**
 129          * Removes a relation from the relation set.
 130          * This function unref's the AtkRelation so it will be deleted unless there
 131          * is another reference to it.
 132          * set:
 133          *  an AtkRelationSet
 134          * relation:
 135          *  an AtkRelation
 136          */
 137         public void atkRelationSetRemove(AtkRelation* relation)
 138         {
 139                 // void atk_relation_set_remove (AtkRelationSet *set,  AtkRelation *relation);
 140                 atk_relation_set_remove(atkRelationSet, relation);
 141         }
 142
 143         /**
 144          * Add a new relation to the current relation set if it is not already
 145          * present.
 146          * This function ref's the AtkRelation so the caller of this function
 147          * should unref it to ensure that it will be destroyed when the AtkRelationSet
 148          * is destroyed.
 149          * set:
 150          *  an AtkRelationSet
 151          * relation:
 152          *  an AtkRelation
 153          */
 154         public void atkRelationSetAdd(AtkRelation* relation)
 155         {
 156                 // void atk_relation_set_add (AtkRelationSet *set,  AtkRelation *relation);
 157                 atk_relation_set_add(atkRelationSet, relation);
 158         }
 159
 160         /**
 161          * Determines the number of relations in a relation set.
 162          * set:
 163          *  an AtkRelationSet
 164          * Returns:
 165          *  an integer representing the number of relations in the set.
 166          */
 167         public int atkRelationSetGetNRelations()
 168         {
 169                 // gint atk_relation_set_get_n_relations  (AtkRelationSet *set);
 170                 return atk_relation_set_get_n_relations(atkRelationSet);
 171         }
 172
 173         /**
 174          * Determines the relation at the specified position in the relation set.
 175          * set:
 176          *  an AtkRelationSet
 177          * i:
 178          *  a gint representing a position in the set, starting from 0.
 179          * Returns:
 180          *  a AtkRelation, which is the relation at position i in the set.
 181          */
 182         public AtkRelation* atkRelationSetGetRelation(int i)
 183         {
 184                 // AtkRelation* atk_relation_set_get_relation (AtkRelationSet *set,  gint i);
 185                 return atk_relation_set_get_relation(atkRelationSet, i);
 186         }
 187
 188         /**
 189          * Finds a relation that matches the specified type.
 190          * set:
 191          *  an AtkRelationSet
 192          * relationship:
 193          *  an AtkRelationType
 194          * Returns:
 195          *  an AtkRelation, which is a relation matching the specified type.
 196          */
 197         public AtkRelation* atkRelationSetGetRelationByType(AtkRelationType relationship)
 198         {
 199                 // AtkRelation* atk_relation_set_get_relation_by_type  (AtkRelationSet *set,  AtkRelationType relationship);
 200                 return atk_relation_set_get_relation_by_type(atkRelationSet, relationship);
 201         }
 202
 203         /**
 204          * Add a new relation of the specified type with the specified target to
 205          * the current relation set if the relation set does not contain a relation
 206          * of that type. If it is does contain a relation of that typea the target
 207          * is added to the relation.
 208          * set:
 209          *  an AtkRelationSet
 210          * relationship:
 211          *  an AtkRelationType
 212          * target:
 213          *  an AtkObject
 214          * Since ATK 1.9
 215          */
 216         public void atkRelationSetAddRelationByType(AtkRelationType relationship, AtkObject* target)
 217         {
 218                 // void atk_relation_set_add_relation_by_type  (AtkRelationSet *set,  AtkRelationType relationship,  AtkObject *target);
 219                 atk_relation_set_add_relation_by_type(atkRelationSet, relationship, target);
 220         }
 221 }