1 /* 2 * This file is part of gtkD. 3 * 4 * gtkD is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU Lesser General Public License 6 * as published by the Free Software Foundation; either version 3 7 * of the License, or (at your option) any later version, with 8 * some exceptions, please read the COPYING file. 9 * 10 * gtkD is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public License 16 * along with gtkD; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA 18 */ 19 20 // generated automatically - do not change 21 // find conversion definition on APILookup.txt 22 // implement new conversion functionalities on the wrap.utils pakage 23 24 25 module gtk.WidgetClass; 26 27 private import glib.Bytes; 28 private import glib.Str; 29 private import gobject.ObjectG; 30 private import gobject.ParamSpec; 31 private import gtkc.gtk; 32 public import gtkc.gtktypes; 33 34 35 public class WidgetClass 36 { 37 /** the main Gtk struct */ 38 protected GtkWidgetClass* gtkWidgetClass; 39 40 /** Get the main Gtk struct */ 41 public GtkWidgetClass* getWidgetClassStruct() 42 { 43 return gtkWidgetClass; 44 } 45 46 /** the main Gtk struct as a void* */ 47 protected void* getStruct() 48 { 49 return cast(void*)gtkWidgetClass; 50 } 51 52 /** 53 * Sets our main struct and passes it to the parent class. 54 */ 55 public this (GtkWidgetClass* gtkWidgetClass) 56 { 57 this.gtkWidgetClass = gtkWidgetClass; 58 } 59 60 /** 61 */ 62 63 /** 64 * Declares a @callback_symbol to handle @callback_name from the template XML 65 * defined for @widget_type. See gtk_builder_add_callback_symbol(). 66 * 67 * Note that this must be called from a composite widget classes class 68 * initializer after calling gtk_widget_class_set_template(). 69 * 70 * Params: 71 * callbackName = The name of the callback as expected in the template XML 72 * callbackSymbol = The callback symbol 73 * 74 * Since: 3.10 75 */ 76 public void bindTemplateCallbackFull(string callbackName, GCallback callbackSymbol) 77 { 78 gtk_widget_class_bind_template_callback_full(gtkWidgetClass, Str.toStringz(callbackName), callbackSymbol); 79 } 80 81 /** 82 * Automatically assign an object declared in the class template XML to be set to a location 83 * on a freshly built instance’s private data, or alternatively accessible via gtk_widget_get_template_child(). 84 * 85 * The struct can point either into the public instance, then you should use G_STRUCT_OFFSET(WidgetType, member) 86 * for @struct_offset, or in the private struct, then you should use G_PRIVATE_OFFSET(WidgetType, member). 87 * 88 * An explicit strong reference will be held automatically for the duration of your 89 * instance’s life cycle, it will be released automatically when #GObjectClass.dispose() runs 90 * on your instance and if a @struct_offset that is != 0 is specified, then the automatic location 91 * in your instance public or private data will be set to %NULL. You can however access an automated child 92 * pointer the first time your classes #GObjectClass.dispose() runs, or alternatively in 93 * #GtkWidgetClass.destroy(). 94 * 95 * If @internal_child is specified, #GtkBuildableIface.get_internal_child() will be automatically 96 * implemented by the #GtkWidget class so there is no need to implement it manually. 97 * 98 * The wrapper macros gtk_widget_class_bind_template_child(), gtk_widget_class_bind_template_child_internal(), 99 * gtk_widget_class_bind_template_child_private() and gtk_widget_class_bind_template_child_internal_private() 100 * might be more convenient to use. 101 * 102 * Note that this must be called from a composite widget classes class 103 * initializer after calling gtk_widget_class_set_template(). 104 * 105 * Params: 106 * name = The “id” of the child defined in the template XML 107 * internalChild = Whether the child should be accessible as an “internal-child” 108 * when this class is used in GtkBuilder XML 109 * structOffset = The structure offset into the composite widget’s instance public or private structure 110 * where the automated child pointer should be set, or 0 to not assign the pointer. 111 * 112 * Since: 3.10 113 */ 114 public void bindTemplateChildFull(string name, bool internalChild, ptrdiff_t structOffset) 115 { 116 gtk_widget_class_bind_template_child_full(gtkWidgetClass, Str.toStringz(name), internalChild, structOffset); 117 } 118 119 /** 120 * Finds a style property of a widget class by name. 121 * 122 * Params: 123 * propertyName = the name of the style property to find 124 * 125 * Return: the #GParamSpec of the style property or 126 * %NULL if @class has no style property with that name. 127 * 128 * Since: 2.2 129 */ 130 public ParamSpec findStyleProperty(string propertyName) 131 { 132 auto p = gtk_widget_class_find_style_property(gtkWidgetClass, Str.toStringz(propertyName)); 133 134 if(p is null) 135 { 136 return null; 137 } 138 139 return ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p); 140 } 141 142 /** 143 * Installs a style property on a widget class. The parser for the 144 * style property is determined by the value type of @pspec. 145 * 146 * Params: 147 * pspec = the #GParamSpec for the property 148 */ 149 public void installStyleProperty(ParamSpec pspec) 150 { 151 gtk_widget_class_install_style_property(gtkWidgetClass, (pspec is null) ? null : pspec.getParamSpecStruct()); 152 } 153 154 /** 155 * Installs a style property on a widget class. 156 * 157 * Params: 158 * pspec = the #GParamSpec for the style property 159 * parser = the parser for the style property 160 */ 161 public void installStylePropertyParser(ParamSpec pspec, GtkRcPropertyParser parser) 162 { 163 gtk_widget_class_install_style_property_parser(gtkWidgetClass, (pspec is null) ? null : pspec.getParamSpecStruct(), parser); 164 } 165 166 /** 167 * Returns all style properties of a widget class. 168 * 169 * Params: 170 * nProperties = location to return the number of style properties found 171 * 172 * Return: a 173 * newly allocated array of #GParamSpec*. The array must be 174 * freed with g_free(). 175 * 176 * Since: 2.2 177 */ 178 public ParamSpec[] listStyleProperties() 179 { 180 uint nProperties; 181 182 auto p = gtk_widget_class_list_style_properties(gtkWidgetClass, &nProperties); 183 184 if(p is null) 185 { 186 return null; 187 } 188 189 ParamSpec[] arr = new ParamSpec[nProperties]; 190 for(int i = 0; i < nProperties; i++) 191 { 192 arr[i] = ObjectG.getDObject!(ParamSpec)(cast(GParamSpec*) p[i]); 193 } 194 195 return arr; 196 } 197 198 /** 199 * Sets the default #AtkRole to be set on accessibles created for 200 * widgets of @widget_class. Accessibles may decide to not honor this 201 * setting if their role reporting is more refined. Calls to 202 * gtk_widget_class_set_accessible_type() will reset this value. 203 * 204 * In cases where you want more fine-grained control over the role of 205 * accessibles created for @widget_class, you should provide your own 206 * accessible type and use gtk_widget_class_set_accessible_type() 207 * instead. 208 * 209 * If @role is #ATK_ROLE_INVALID, the default role will not be changed 210 * and the accessible’s default role will be used instead. 211 * 212 * This function should only be called from class init functions of widgets. 213 * 214 * Params: 215 * role = The role to use for accessibles created for @widget_class 216 * 217 * Since: 3.2 218 */ 219 public void setAccessibleRole(AtkRole role) 220 { 221 gtk_widget_class_set_accessible_role(gtkWidgetClass, role); 222 } 223 224 /** 225 * Sets the type to be used for creating accessibles for widgets of 226 * @widget_class. The given @type must be a subtype of the type used for 227 * accessibles of the parent class. 228 * 229 * This function should only be called from class init functions of widgets. 230 * 231 * Params: 232 * type = The object type that implements the accessible for @widget_class 233 * 234 * Since: 3.2 235 */ 236 public void setAccessibleType(GType type) 237 { 238 gtk_widget_class_set_accessible_type(gtkWidgetClass, type); 239 } 240 241 /** 242 * For use in lanuage bindings, this will override the default #GtkBuilderConnectFunc to be 243 * used when parsing GtkBuilder xml from this class’s template data. 244 * 245 * Note that this must be called from a composite widget classes class 246 * initializer after calling gtk_widget_class_set_template(). 247 * 248 * Params: 249 * connectFunc = The #GtkBuilderConnectFunc to use when connecting signals in the class template 250 * connectData = The data to pass to @connect_func 251 * connectDataDestroy = The #GDestroyNotify to free @connect_data, this will only be used at 252 * class finalization time, when no classes of type @widget_type are in use anymore. 253 * 254 * Since: 3.10 255 */ 256 public void setConnectFunc(GtkBuilderConnectFunc connectFunc, void* connectData, GDestroyNotify connectDataDestroy) 257 { 258 gtk_widget_class_set_connect_func(gtkWidgetClass, connectFunc, connectData, connectDataDestroy); 259 } 260 261 /** 262 * This should be called at class initialization time to specify 263 * the GtkBuilder XML to be used to extend a widget. 264 * 265 * For convenience, gtk_widget_class_set_template_from_resource() is also provided. 266 * 267 * Note that any class that installs templates must call gtk_widget_init_template() 268 * in the widget’s instance initializer. 269 * 270 * Params: 271 * templateBytes = A #GBytes holding the #GtkBuilder XML 272 * 273 * Since: 3.10 274 */ 275 public void setTemplate(Bytes templateBytes) 276 { 277 gtk_widget_class_set_template(gtkWidgetClass, (templateBytes is null) ? null : templateBytes.getBytesStruct()); 278 } 279 280 /** 281 * A convenience function to call gtk_widget_class_set_template(). 282 * 283 * Note that any class that installs templates must call gtk_widget_init_template() 284 * in the widget’s instance initializer. 285 * 286 * Params: 287 * resourceName = The name of the resource to load the template from 288 * 289 * Since: 3.10 290 */ 291 public void setTemplateFromResource(string resourceName) 292 { 293 gtk_widget_class_set_template_from_resource(gtkWidgetClass, Str.toStringz(resourceName)); 294 } 295 }