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.ColorSelection; 26 27 private import gdk.Color; 28 private import gdk.RGBA; 29 private import glib.ConstructionException; 30 private import glib.Str; 31 private import gobject.ObjectG; 32 private import gobject.Signals; 33 private import gtk.Box; 34 private import gtk.Widget; 35 private import gtkc.gtk; 36 public import gtkc.gtktypes; 37 private import std.algorithm; 38 39 40 /** */ 41 public class ColorSelection : Box 42 { 43 /** the main Gtk struct */ 44 protected GtkColorSelection* gtkColorSelection; 45 46 /** Get the main Gtk struct */ 47 public GtkColorSelection* getColorSelectionStruct() 48 { 49 return gtkColorSelection; 50 } 51 52 /** the main Gtk struct as a void* */ 53 protected override void* getStruct() 54 { 55 return cast(void*)gtkColorSelection; 56 } 57 58 protected override void setStruct(GObject* obj) 59 { 60 gtkColorSelection = cast(GtkColorSelection*)obj; 61 super.setStruct(obj); 62 } 63 64 /** 65 * Sets our main struct and passes it to the parent class. 66 */ 67 public this (GtkColorSelection* gtkColorSelection, bool ownedRef = false) 68 { 69 this.gtkColorSelection = gtkColorSelection; 70 super(cast(GtkBox*)gtkColorSelection, ownedRef); 71 } 72 73 74 /** */ 75 public static GType getType() 76 { 77 return gtk_color_selection_get_type(); 78 } 79 80 /** 81 * Creates a new GtkColorSelection. 82 * 83 * Returns: a new #GtkColorSelection 84 * 85 * Throws: ConstructionException GTK+ fails to create the object. 86 */ 87 public this() 88 { 89 auto p = gtk_color_selection_new(); 90 91 if(p is null) 92 { 93 throw new ConstructionException("null returned by new"); 94 } 95 96 this(cast(GtkColorSelection*) p); 97 } 98 99 /** 100 * Parses a color palette string; the string is a colon-separated 101 * list of color names readable by gdk_color_parse(). 102 * 103 * Params: 104 * str = a string encoding a color palette 105 * colors = return location for 106 * allocated array of #GdkColor 107 * nColors = return location for length of array 108 * 109 * Returns: %TRUE if a palette was successfully parsed 110 */ 111 public static bool paletteFromString(string str, out Color[] colors) 112 { 113 GdkColor* outcolors = null; 114 int nColors; 115 116 auto p = gtk_color_selection_palette_from_string(Str.toStringz(str), &outcolors, &nColors) != 0; 117 118 colors = new Color[nColors]; 119 for(size_t i = 0; i < nColors; i++) 120 { 121 colors[i] = ObjectG.getDObject!(Color)(cast(GdkColor*) &outcolors[i]); 122 } 123 124 return p; 125 } 126 127 /** 128 * Encodes a palette as a string, useful for persistent storage. 129 * 130 * Params: 131 * colors = an array of colors 132 * nColors = length of the array 133 * 134 * Returns: allocated string encoding the palette 135 */ 136 public static string paletteToString(Color[] colors) 137 { 138 GdkColor[] colorsArray = new GdkColor[colors.length]; 139 for ( int i = 0; i < colors.length; i++ ) 140 { 141 colorsArray[i] = *(colors[i].getColorStruct()); 142 } 143 144 auto retStr = gtk_color_selection_palette_to_string(colorsArray.ptr, cast(int)colors.length); 145 146 scope(exit) Str.freeString(retStr); 147 return Str.toString(retStr); 148 } 149 150 /** 151 * Installs a global function to be called whenever the user 152 * tries to modify the palette in a color selection. 153 * 154 * This function should save the new palette contents, and update 155 * the #GtkSettings:gtk-color-palette GtkSettings property so all 156 * GtkColorSelection widgets will be modified. 157 * 158 * Params: 159 * func = a function to call when the custom palette needs saving 160 * 161 * Returns: the previous change palette hook (that was replaced) 162 * 163 * Since: 2.2 164 */ 165 public static GtkColorSelectionChangePaletteWithScreenFunc setChangePaletteWithScreenHook(GtkColorSelectionChangePaletteWithScreenFunc func) 166 { 167 return gtk_color_selection_set_change_palette_with_screen_hook(func); 168 } 169 170 /** 171 * Returns the current alpha value. 172 * 173 * Returns: an integer between 0 and 65535 174 */ 175 public ushort getCurrentAlpha() 176 { 177 return gtk_color_selection_get_current_alpha(gtkColorSelection); 178 } 179 180 /** 181 * Sets @color to be the current color in the GtkColorSelection widget. 182 * 183 * Deprecated: Use gtk_color_selection_get_current_rgba() instead. 184 * 185 * Params: 186 * color = a #GdkColor to fill in with the current color 187 */ 188 public void getCurrentColor(out Color color) 189 { 190 GdkColor* outcolor = gMalloc!GdkColor(); 191 192 gtk_color_selection_get_current_color(gtkColorSelection, outcolor); 193 194 color = ObjectG.getDObject!(Color)(outcolor, true); 195 } 196 197 /** 198 * Sets @rgba to be the current color in the GtkColorSelection widget. 199 * 200 * Params: 201 * rgba = a #GdkRGBA to fill in with the current color 202 * 203 * Since: 3.0 204 */ 205 public void getCurrentRgba(out RGBA rgba) 206 { 207 GdkRGBA* outrgba = gMalloc!GdkRGBA(); 208 209 gtk_color_selection_get_current_rgba(gtkColorSelection, outrgba); 210 211 rgba = ObjectG.getDObject!(RGBA)(outrgba, true); 212 } 213 214 /** 215 * Determines whether the colorsel has an opacity control. 216 * 217 * Returns: %TRUE if the @colorsel has an opacity control, 218 * %FALSE if it does't 219 */ 220 public bool getHasOpacityControl() 221 { 222 return gtk_color_selection_get_has_opacity_control(gtkColorSelection) != 0; 223 } 224 225 /** 226 * Determines whether the color selector has a color palette. 227 * 228 * Returns: %TRUE if the selector has a palette, %FALSE if it hasn't 229 */ 230 public bool getHasPalette() 231 { 232 return gtk_color_selection_get_has_palette(gtkColorSelection) != 0; 233 } 234 235 /** 236 * Returns the previous alpha value. 237 * 238 * Returns: an integer between 0 and 65535 239 */ 240 public ushort getPreviousAlpha() 241 { 242 return gtk_color_selection_get_previous_alpha(gtkColorSelection); 243 } 244 245 /** 246 * Fills @color in with the original color value. 247 * 248 * Deprecated: Use gtk_color_selection_get_previous_rgba() instead. 249 * 250 * Params: 251 * color = a #GdkColor to fill in with the original color value 252 */ 253 public void getPreviousColor(out Color color) 254 { 255 GdkColor* outcolor = gMalloc!GdkColor(); 256 257 gtk_color_selection_get_previous_color(gtkColorSelection, outcolor); 258 259 color = ObjectG.getDObject!(Color)(outcolor, true); 260 } 261 262 /** 263 * Fills @rgba in with the original color value. 264 * 265 * Params: 266 * rgba = a #GdkRGBA to fill in with the original color value 267 * 268 * Since: 3.0 269 */ 270 public void getPreviousRgba(out RGBA rgba) 271 { 272 GdkRGBA* outrgba = gMalloc!GdkRGBA(); 273 274 gtk_color_selection_get_previous_rgba(gtkColorSelection, outrgba); 275 276 rgba = ObjectG.getDObject!(RGBA)(outrgba, true); 277 } 278 279 /** 280 * Gets the current state of the @colorsel. 281 * 282 * Returns: %TRUE if the user is currently dragging 283 * a color around, and %FALSE if the selection has stopped 284 */ 285 public bool isAdjusting() 286 { 287 return gtk_color_selection_is_adjusting(gtkColorSelection) != 0; 288 } 289 290 /** 291 * Sets the current opacity to be @alpha. 292 * 293 * The first time this is called, it will also set 294 * the original opacity to be @alpha too. 295 * 296 * Params: 297 * alpha = an integer between 0 and 65535 298 */ 299 public void setCurrentAlpha(ushort alpha) 300 { 301 gtk_color_selection_set_current_alpha(gtkColorSelection, alpha); 302 } 303 304 /** 305 * Sets the current color to be @color. 306 * 307 * The first time this is called, it will also set 308 * the original color to be @color too. 309 * 310 * Deprecated: Use gtk_color_selection_set_current_rgba() instead. 311 * 312 * Params: 313 * color = a #GdkColor to set the current color with 314 */ 315 public void setCurrentColor(Color color) 316 { 317 gtk_color_selection_set_current_color(gtkColorSelection, (color is null) ? null : color.getColorStruct()); 318 } 319 320 /** 321 * Sets the current color to be @rgba. 322 * 323 * The first time this is called, it will also set 324 * the original color to be @rgba too. 325 * 326 * Params: 327 * rgba = A #GdkRGBA to set the current color with 328 * 329 * Since: 3.0 330 */ 331 public void setCurrentRgba(RGBA rgba) 332 { 333 gtk_color_selection_set_current_rgba(gtkColorSelection, (rgba is null) ? null : rgba.getRGBAStruct()); 334 } 335 336 /** 337 * Sets the @colorsel to use or not use opacity. 338 * 339 * Params: 340 * hasOpacity = %TRUE if @colorsel can set the opacity, %FALSE otherwise 341 */ 342 public void setHasOpacityControl(bool hasOpacity) 343 { 344 gtk_color_selection_set_has_opacity_control(gtkColorSelection, hasOpacity); 345 } 346 347 /** 348 * Shows and hides the palette based upon the value of @has_palette. 349 * 350 * Params: 351 * hasPalette = %TRUE if palette is to be visible, %FALSE otherwise 352 */ 353 public void setHasPalette(bool hasPalette) 354 { 355 gtk_color_selection_set_has_palette(gtkColorSelection, hasPalette); 356 } 357 358 /** 359 * Sets the “previous” alpha to be @alpha. 360 * 361 * This function should be called with some hesitations, 362 * as it might seem confusing to have that alpha change. 363 * 364 * Params: 365 * alpha = an integer between 0 and 65535 366 */ 367 public void setPreviousAlpha(ushort alpha) 368 { 369 gtk_color_selection_set_previous_alpha(gtkColorSelection, alpha); 370 } 371 372 /** 373 * Sets the “previous” color to be @color. 374 * 375 * This function should be called with some hesitations, 376 * as it might seem confusing to have that color change. 377 * Calling gtk_color_selection_set_current_color() will also 378 * set this color the first time it is called. 379 * 380 * Deprecated: Use gtk_color_selection_set_previous_rgba() instead. 381 * 382 * Params: 383 * color = a #GdkColor to set the previous color with 384 */ 385 public void setPreviousColor(Color color) 386 { 387 gtk_color_selection_set_previous_color(gtkColorSelection, (color is null) ? null : color.getColorStruct()); 388 } 389 390 /** 391 * Sets the “previous” color to be @rgba. 392 * 393 * This function should be called with some hesitations, 394 * as it might seem confusing to have that color change. 395 * Calling gtk_color_selection_set_current_rgba() will also 396 * set this color the first time it is called. 397 * 398 * Params: 399 * rgba = a #GdkRGBA to set the previous color with 400 * 401 * Since: 3.0 402 */ 403 public void setPreviousRgba(RGBA rgba) 404 { 405 gtk_color_selection_set_previous_rgba(gtkColorSelection, (rgba is null) ? null : rgba.getRGBAStruct()); 406 } 407 408 protected class OnColorChangedDelegateWrapper 409 { 410 static OnColorChangedDelegateWrapper[] listeners; 411 void delegate(ColorSelection) dlg; 412 gulong handlerId; 413 414 this(void delegate(ColorSelection) dlg) 415 { 416 this.dlg = dlg; 417 this.listeners ~= this; 418 } 419 420 void remove(OnColorChangedDelegateWrapper source) 421 { 422 foreach(index, wrapper; listeners) 423 { 424 if (wrapper.handlerId == source.handlerId) 425 { 426 listeners[index] = null; 427 listeners = std.algorithm.remove(listeners, index); 428 break; 429 } 430 } 431 } 432 } 433 434 /** 435 * This signal is emitted when the color changes in the #GtkColorSelection 436 * according to its update policy. 437 */ 438 gulong addOnColorChanged(void delegate(ColorSelection) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 439 { 440 auto wrapper = new OnColorChangedDelegateWrapper(dlg); 441 wrapper.handlerId = Signals.connectData( 442 this, 443 "color-changed", 444 cast(GCallback)&callBackColorChanged, 445 cast(void*)wrapper, 446 cast(GClosureNotify)&callBackColorChangedDestroy, 447 connectFlags); 448 return wrapper.handlerId; 449 } 450 451 extern(C) static void callBackColorChanged(GtkColorSelection* colorselectionStruct, OnColorChangedDelegateWrapper wrapper) 452 { 453 wrapper.dlg(wrapper.outer); 454 } 455 456 extern(C) static void callBackColorChangedDestroy(OnColorChangedDelegateWrapper wrapper, GClosure* closure) 457 { 458 wrapper.remove(wrapper); 459 } 460 }