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 gsv.SourceGutterRenderer; 26 27 private import cairo.Context; 28 private import gdk.Event; 29 private import gdk.RGBA; 30 private import gobject.ObjectG; 31 private import gobject.Signals; 32 private import gsvc.gsv; 33 public import gsvc.gsvtypes; 34 private import gtk.TextIter; 35 private import gtk.TextView; 36 private import gtk.Tooltip; 37 public import gtkc.gdktypes; 38 39 40 public class SourceGutterRenderer : ObjectG 41 { 42 /** the main Gtk struct */ 43 protected GtkSourceGutterRenderer* gtkSourceGutterRenderer; 44 45 /** Get the main Gtk struct */ 46 public GtkSourceGutterRenderer* getSourceGutterRendererStruct() 47 { 48 return gtkSourceGutterRenderer; 49 } 50 51 /** the main Gtk struct as a void* */ 52 protected override void* getStruct() 53 { 54 return cast(void*)gtkSourceGutterRenderer; 55 } 56 57 protected override void setStruct(GObject* obj) 58 { 59 gtkSourceGutterRenderer = cast(GtkSourceGutterRenderer*)obj; 60 super.setStruct(obj); 61 } 62 63 /** 64 * Sets our main struct and passes it to the parent class. 65 */ 66 public this (GtkSourceGutterRenderer* gtkSourceGutterRenderer, bool ownedRef = false) 67 { 68 this.gtkSourceGutterRenderer = gtkSourceGutterRenderer; 69 super(cast(GObject*)gtkSourceGutterRenderer, ownedRef); 70 } 71 72 /** 73 */ 74 75 public static GType getType() 76 { 77 return gtk_source_gutter_renderer_get_type(); 78 } 79 80 /** 81 * Emits the #GtkSourceGutterRenderer::activate signal of the renderer. This is 82 * called from #GtkSourceGutter and should never have to be called manually. 83 * 84 * Params: 85 * iter = a #GtkTextIter at the start of the line where the renderer is activated 86 * area = a #GdkRectangle of the cell area where the renderer is activated 87 * event = the event that triggered the activation 88 */ 89 public void activate(TextIter iter, GdkRectangle* area, Event event) 90 { 91 gtk_source_gutter_renderer_activate(gtkSourceGutterRenderer, (iter is null) ? null : iter.getTextIterStruct(), area, (event is null) ? null : event.getEventStruct()); 92 } 93 94 /** 95 * Called when drawing a region begins. The region to be drawn is indicated 96 * by @start and @end. The purpose is to allow the implementation to precompute 97 * some state before the draw method is called for each cell. 98 * 99 * Params: 100 * cr = a #cairo_t 101 * backgroundArea = a #GdkRectangle 102 * cellArea = a #GdkRectangle 103 * start = a #GtkTextIter 104 * end = a #GtkTextIter 105 */ 106 public void begin(Context cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, TextIter start, TextIter end) 107 { 108 gtk_source_gutter_renderer_begin(gtkSourceGutterRenderer, (cr is null) ? null : cr.getContextStruct(), backgroundArea, cellArea, (start is null) ? null : start.getTextIterStruct(), (end is null) ? null : end.getTextIterStruct()); 109 } 110 111 /** 112 * Main renderering method. Implementations should implement this method to 113 * draw onto the cairo context. The @background_area indicates total area of 114 * the cell (without padding or margin) to be drawn. The @cell_area indicates 115 * the area where content can be drawn (text, images, etc). 116 * 117 * The @state argument indicates the current state of the renderer and should 118 * be taken into account to properly draw the different possible states 119 * (cursor, prelit, selected) if appropriate. 120 * 121 * Params: 122 * cr = the cairo render context 123 * backgroundArea = a #GdkRectangle indicating the total area to be drawn 124 * cellArea = a #GdkRectangle indicating the area to draw content 125 * start = a #GtkTextIter 126 * end = a #GtkTextIter 127 * state = a #GtkSourceGutterRendererState 128 */ 129 public void draw(Context cr, GdkRectangle* backgroundArea, GdkRectangle* cellArea, TextIter start, TextIter end, GtkSourceGutterRendererState state) 130 { 131 gtk_source_gutter_renderer_draw(gtkSourceGutterRenderer, (cr is null) ? null : cr.getContextStruct(), backgroundArea, cellArea, (start is null) ? null : start.getTextIterStruct(), (end is null) ? null : end.getTextIterStruct(), state); 132 } 133 134 /** 135 * Called when drawing a region of lines has ended. 136 */ 137 public void end() 138 { 139 gtk_source_gutter_renderer_end(gtkSourceGutterRenderer); 140 } 141 142 /** 143 * Get the x-alignment and y-alignment of the gutter renderer. 144 * 145 * Params: 146 * xalign = return location for the x-alignment (can be %NULL) 147 * yalign = return location for the y-alignment (can be %NULL) 148 */ 149 public void getAlignment(out float xalign, out float yalign) 150 { 151 gtk_source_gutter_renderer_get_alignment(gtkSourceGutterRenderer, &xalign, &yalign); 152 } 153 154 /** 155 * Get the alignment mode. The alignment mode describes the manner in which the 156 * renderer is aligned (see :xalign and :yalign). 157 * 158 * Return: a #GtkSourceGutterRendererAlignmentMode 159 */ 160 public GtkSourceGutterRendererAlignmentMode getAlignmentMode() 161 { 162 return gtk_source_gutter_renderer_get_alignment_mode(gtkSourceGutterRenderer); 163 } 164 165 /** 166 * Get the background color of the renderer. 167 * 168 * Params: 169 * color = return value for a #GdkRGBA 170 * 171 * Return: %TRUE if the background color is set, %FALSE otherwise 172 */ 173 public bool getBackground(out RGBA color) 174 { 175 GdkRGBA* outcolor = new GdkRGBA; 176 177 auto p = gtk_source_gutter_renderer_get_background(gtkSourceGutterRenderer, outcolor) != 0; 178 179 color = ObjectG.getDObject!(RGBA)(outcolor); 180 181 return p; 182 } 183 184 /** 185 * Get the x-padding and y-padding of the gutter renderer. 186 * 187 * Params: 188 * xpad = return location for the x-padding (can be %NULL) 189 * ypad = return location for the y-padding (can be %NULL) 190 */ 191 public void getPadding(out int xpad, out int ypad) 192 { 193 gtk_source_gutter_renderer_get_padding(gtkSourceGutterRenderer, &xpad, &ypad); 194 } 195 196 /** 197 * Get the size of the renderer. 198 * 199 * Return: the size of the renderer. 200 */ 201 public int getSize() 202 { 203 return gtk_source_gutter_renderer_get_size(gtkSourceGutterRenderer); 204 } 205 206 /** 207 * Get the view associated to the gutter renderer 208 * 209 * Return: a #GtkTextView 210 */ 211 public TextView getView() 212 { 213 auto p = gtk_source_gutter_renderer_get_view(gtkSourceGutterRenderer); 214 215 if(p is null) 216 { 217 return null; 218 } 219 220 return ObjectG.getDObject!(TextView)(cast(GtkTextView*) p); 221 } 222 223 /** 224 * Get whether the gutter renderer is visible. 225 * 226 * Return: %TRUE if the renderer is visible, %FALSE otherwise 227 */ 228 public bool getVisible() 229 { 230 return gtk_source_gutter_renderer_get_visible(gtkSourceGutterRenderer) != 0; 231 } 232 233 /** 234 * Get the #GtkTextWindowType associated with the gutter renderer. 235 * 236 * Return: a #GtkTextWindowType 237 */ 238 public GtkTextWindowType getWindowType() 239 { 240 return gtk_source_gutter_renderer_get_window_type(gtkSourceGutterRenderer); 241 } 242 243 /** 244 * Get whether the renderer is activatable at the location in @event. This is 245 * called from #GtkSourceGutter to determine whether a renderer is activatable 246 * using the mouse pointer. 247 * 248 * Params: 249 * iter = a #GtkTextIter at the start of the line to be activated 250 * area = a #GdkRectangle of the cell area to be activated 251 * event = the event that triggered the query 252 * 253 * Return: %TRUE if the renderer can be activated, %FALSE otherwise 254 */ 255 public bool queryActivatable(TextIter iter, GdkRectangle* area, Event event) 256 { 257 return gtk_source_gutter_renderer_query_activatable(gtkSourceGutterRenderer, (iter is null) ? null : iter.getTextIterStruct(), area, (event is null) ? null : event.getEventStruct()) != 0; 258 } 259 260 /** 261 * Emit the #GtkSourceGutterRenderer::query-data signal. This function is called 262 * to query for data just before rendering a cell. This is called from the 263 * #GtkSourceGutter. Implementations can override the default signal handler or 264 * can connect a signal handler externally to the 265 * #GtkSourceGutterRenderer::query-data signal. 266 * 267 * Params: 268 * start = a #GtkTextIter. 269 * end = a #GtkTextIter. 270 * state = a #GtkSourceGutterRendererState. 271 */ 272 public void queryData(TextIter start, TextIter end, GtkSourceGutterRendererState state) 273 { 274 gtk_source_gutter_renderer_query_data(gtkSourceGutterRenderer, (start is null) ? null : start.getTextIterStruct(), (end is null) ? null : end.getTextIterStruct(), state); 275 } 276 277 /** 278 * Emits the #GtkSourceGutterRenderer::query-tooltip signal. This function is 279 * called from #GtkSourceGutter. Implementations can override the default signal 280 * handler or can connect to the signal externally. 281 * 282 * Params: 283 * iter = a #GtkTextIter. 284 * area = a #GdkRectangle. 285 * x = The x position of the tooltip. 286 * y = The y position of the tooltip. 287 * tooltip = a #GtkTooltip. 288 * 289 * Return: %TRUE if the tooltip has been set, %FALSE otherwise 290 */ 291 public bool queryTooltip(TextIter iter, GdkRectangle* area, int x, int y, Tooltip tooltip) 292 { 293 return gtk_source_gutter_renderer_query_tooltip(gtkSourceGutterRenderer, (iter is null) ? null : iter.getTextIterStruct(), area, x, y, (tooltip is null) ? null : tooltip.getTooltipStruct()) != 0; 294 } 295 296 /** 297 * Emits the #GtkSourceGutterRenderer::queue-draw signal of the renderer. Call 298 * this from an implementation to inform that the renderer has changed such that 299 * it needs to redraw. 300 */ 301 public void queueDraw() 302 { 303 gtk_source_gutter_renderer_queue_draw(gtkSourceGutterRenderer); 304 } 305 306 /** 307 * Set the alignment of the gutter renderer. Both @xalign and @yalign can be 308 * -1, which means the values will not be changed (this allows changing only 309 * one of the values). 310 * 311 * @xalign is the horizontal alignment. Set to 0 for a left alignment. 1 for a 312 * right alignment. And 0.5 for centering the cells. @yalign is the vertical 313 * alignment. Set to 0 for a top alignment. 1 for a bottom alignment. 314 * 315 * Params: 316 * xalign = the x-alignment 317 * yalign = the y-alignment 318 */ 319 public void setAlignment(float xalign, float yalign) 320 { 321 gtk_source_gutter_renderer_set_alignment(gtkSourceGutterRenderer, xalign, yalign); 322 } 323 324 /** 325 * Set the alignment mode. The alignment mode describes the manner in which the 326 * renderer is aligned (see :xalign and :yalign). 327 * 328 * Params: 329 * mode = a #GtkSourceGutterRendererAlignmentMode 330 */ 331 public void setAlignmentMode(GtkSourceGutterRendererAlignmentMode mode) 332 { 333 gtk_source_gutter_renderer_set_alignment_mode(gtkSourceGutterRenderer, mode); 334 } 335 336 /** 337 * Set the background color of the renderer. If @color is set to %NULL, the 338 * renderer will not have a background color. 339 * 340 * Params: 341 * color = a #GdkRGBA or %NULL 342 */ 343 public void setBackground(RGBA color) 344 { 345 gtk_source_gutter_renderer_set_background(gtkSourceGutterRenderer, (color is null) ? null : color.getRGBAStruct()); 346 } 347 348 /** 349 * Set the padding of the gutter renderer. Both @xpad and @ypad can be 350 * -1, which means the values will not be changed (this allows changing only 351 * one of the values). 352 * 353 * @xpad is the left and right padding. @ypad is the top and bottom padding. 354 * 355 * Params: 356 * xpad = the x-padding 357 * ypad = the y-padding 358 */ 359 public void setPadding(int xpad, int ypad) 360 { 361 gtk_source_gutter_renderer_set_padding(gtkSourceGutterRenderer, xpad, ypad); 362 } 363 364 /** 365 * Sets the size of the renderer. A value of -1 specifies that the size 366 * is to be determined dynamically. 367 * 368 * Params: 369 * size = the size 370 */ 371 public void setSize(int size) 372 { 373 gtk_source_gutter_renderer_set_size(gtkSourceGutterRenderer, size); 374 } 375 376 /** 377 * Set whether the gutter renderer is visible. 378 * 379 * Params: 380 * visible = the visibility 381 */ 382 public void setVisible(bool visible) 383 { 384 gtk_source_gutter_renderer_set_visible(gtkSourceGutterRenderer, visible); 385 } 386 387 int[string] connectedSignals; 388 389 void delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer)[] onActivateListeners; 390 /** 391 * The ::activate signal is emitted when the renderer is 392 * activated. 393 * 394 * Params: 395 * iter = a #GtkTextIter 396 * area = a #GdkRectangle 397 * event = the event that caused the activation 398 */ 399 void addOnActivate(void delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 400 { 401 if ( "activate" !in connectedSignals ) 402 { 403 Signals.connectData( 404 this, 405 "activate", 406 cast(GCallback)&callBackActivate, 407 cast(void*)this, 408 null, 409 connectFlags); 410 connectedSignals["activate"] = 1; 411 } 412 onActivateListeners ~= dlg; 413 } 414 extern(C) static void callBackActivate(GtkSourceGutterRenderer* sourcegutterrendererStruct, GtkTextIter* iter, cairo_rectangle_int_t* area, GdkEvent* event, SourceGutterRenderer _sourcegutterrenderer) 415 { 416 foreach ( void delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer) dlg; _sourcegutterrenderer.onActivateListeners ) 417 { 418 dlg(ObjectG.getDObject!(TextIter)(iter), area, ObjectG.getDObject!(Event)(event), _sourcegutterrenderer); 419 } 420 } 421 422 bool delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer)[] onQueryActivatableListeners; 423 /** 424 * The ::query-activatable signal is emitted when the renderer 425 * can possibly be activated. 426 * 427 * Params: 428 * iter = a #GtkTextIter 429 * area = a #GdkRectangle 430 * event = the #GdkEvent that is causing the activatable query 431 */ 432 void addOnQueryActivatable(bool delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 433 { 434 if ( "query-activatable" !in connectedSignals ) 435 { 436 Signals.connectData( 437 this, 438 "query-activatable", 439 cast(GCallback)&callBackQueryActivatable, 440 cast(void*)this, 441 null, 442 connectFlags); 443 connectedSignals["query-activatable"] = 1; 444 } 445 onQueryActivatableListeners ~= dlg; 446 } 447 extern(C) static int callBackQueryActivatable(GtkSourceGutterRenderer* sourcegutterrendererStruct, GtkTextIter* iter, cairo_rectangle_int_t* area, GdkEvent* event, SourceGutterRenderer _sourcegutterrenderer) 448 { 449 foreach ( bool delegate(TextIter, cairo_rectangle_int_t*, Event, SourceGutterRenderer) dlg; _sourcegutterrenderer.onQueryActivatableListeners ) 450 { 451 if ( dlg(ObjectG.getDObject!(TextIter)(iter), area, ObjectG.getDObject!(Event)(event), _sourcegutterrenderer) ) 452 { 453 return 1; 454 } 455 } 456 457 return 0; 458 } 459 460 void delegate(TextIter, TextIter, GtkSourceGutterRendererState, SourceGutterRenderer)[] onQueryDataListeners; 461 /** 462 * The ::query-data signal is emitted when the renderer needs 463 * to be filled with data just before a cell is drawn. This can 464 * be used by general renderer implementations to allow render 465 * data to be filled in externally. 466 * 467 * Params: 468 * start = a #GtkTextIter 469 * end = a #GtkTextIter 470 * state = the renderer state 471 */ 472 void addOnQueryData(void delegate(TextIter, TextIter, GtkSourceGutterRendererState, SourceGutterRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 473 { 474 if ( "query-data" !in connectedSignals ) 475 { 476 Signals.connectData( 477 this, 478 "query-data", 479 cast(GCallback)&callBackQueryData, 480 cast(void*)this, 481 null, 482 connectFlags); 483 connectedSignals["query-data"] = 1; 484 } 485 onQueryDataListeners ~= dlg; 486 } 487 extern(C) static void callBackQueryData(GtkSourceGutterRenderer* sourcegutterrendererStruct, GtkTextIter* start, GtkTextIter* end, GtkSourceGutterRendererState state, SourceGutterRenderer _sourcegutterrenderer) 488 { 489 foreach ( void delegate(TextIter, TextIter, GtkSourceGutterRendererState, SourceGutterRenderer) dlg; _sourcegutterrenderer.onQueryDataListeners ) 490 { 491 dlg(ObjectG.getDObject!(TextIter)(start), ObjectG.getDObject!(TextIter)(end), state, _sourcegutterrenderer); 492 } 493 } 494 495 bool delegate(TextIter, cairo_rectangle_int_t*, int, int, Tooltip, SourceGutterRenderer)[] onQueryTooltipListeners; 496 /** 497 * The ::query-tooltip signal is emitted when the renderer can 498 * show a tooltip. 499 * 500 * Params: 501 * iter = a #GtkTextIter 502 * area = a #GdkRectangle 503 * x = the x position (in window coordinates) 504 * y = the y position (in window coordinates) 505 * tooltip = a #GtkTooltip 506 */ 507 void addOnQueryTooltip(bool delegate(TextIter, cairo_rectangle_int_t*, int, int, Tooltip, SourceGutterRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 508 { 509 if ( "query-tooltip" !in connectedSignals ) 510 { 511 Signals.connectData( 512 this, 513 "query-tooltip", 514 cast(GCallback)&callBackQueryTooltip, 515 cast(void*)this, 516 null, 517 connectFlags); 518 connectedSignals["query-tooltip"] = 1; 519 } 520 onQueryTooltipListeners ~= dlg; 521 } 522 extern(C) static int callBackQueryTooltip(GtkSourceGutterRenderer* sourcegutterrendererStruct, GtkTextIter* iter, cairo_rectangle_int_t* area, int x, int y, GtkTooltip* tooltip, SourceGutterRenderer _sourcegutterrenderer) 523 { 524 foreach ( bool delegate(TextIter, cairo_rectangle_int_t*, int, int, Tooltip, SourceGutterRenderer) dlg; _sourcegutterrenderer.onQueryTooltipListeners ) 525 { 526 if ( dlg(ObjectG.getDObject!(TextIter)(iter), area, x, y, ObjectG.getDObject!(Tooltip)(tooltip), _sourcegutterrenderer) ) 527 { 528 return 1; 529 } 530 } 531 532 return 0; 533 } 534 535 void delegate(SourceGutterRenderer)[] onQueueDrawListeners; 536 /** 537 * The ::queue-draw signal is emitted when the renderer needs 538 * to be redrawn. Use gtk_source_gutter_renderer_queue_draw() 539 * to emit this signal from an implementation of the 540 * #GtkSourceGutterRenderer interface. 541 */ 542 void addOnQueueDraw(void delegate(SourceGutterRenderer) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 543 { 544 if ( "queue-draw" !in connectedSignals ) 545 { 546 Signals.connectData( 547 this, 548 "queue-draw", 549 cast(GCallback)&callBackQueueDraw, 550 cast(void*)this, 551 null, 552 connectFlags); 553 connectedSignals["queue-draw"] = 1; 554 } 555 onQueueDrawListeners ~= dlg; 556 } 557 extern(C) static void callBackQueueDraw(GtkSourceGutterRenderer* sourcegutterrendererStruct, SourceGutterRenderer _sourcegutterrenderer) 558 { 559 foreach ( void delegate(SourceGutterRenderer) dlg; _sourcegutterrenderer.onQueueDrawListeners ) 560 { 561 dlg(_sourcegutterrenderer); 562 } 563 } 564 }