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