1 // -*- c++ -*- 2 // Generated by gmmproc 2.45.3 -- DO NOT MODIFY! 3 #ifndef _GDKMM_GC_H 4 #define _GDKMM_GC_H 5 6 7 #include <glibmm/ustring.h> 8 #include <sigc++/sigc++.h> 9 10 /* $Id: gc.hg,v 1.8 2006/04/12 11:11:24 murrayc Exp $ */ 11 12 /* gc.h 13 * 14 * Copyright (C) 1998-2002 The gtkmm Development Team 15 * 16 * This library is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU Lesser General Public 18 * License as published by the Free Software Foundation; either 19 * version 2.1 of the License, or (at your option) any later version. 20 * 21 * This library is distributed in the hope that it will be useful, 22 * but WITHOUT ANY WARRANTY; without even the implied warranty of 23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 24 * Lesser General Public License for more details. 25 * 26 * You should have received a copy of the GNU Lesser General Public 27 * License along with this library; if not, write to the Free 28 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 29 */ 30 31 #include <glibmm/object.h> 32 #include <gdkmm/region.h> 33 #include <gdkmm/drawable.h> 34 #include <gdkmm/types.h> 35 #include <gdkmm/rectangle.h> 36 #include <gdkmm/screen.h> 37 38 39 #ifndef DOXYGEN_SHOULD_SKIP_THIS 40 typedef struct _GdkGC GdkGC; 41 typedef struct _GdkGCClass GdkGCClass; 42 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 43 44 45 #ifndef DOXYGEN_SHOULD_SKIP_THIS 46 namespace Gdk 47 { class GC_Class; } // namespace Gdk 48 #endif //DOXYGEN_SHOULD_SKIP_THIS 49 50 namespace Gdk 51 { 52 53 /** @addtogroup gdkmmEnums gdkmm Enums and Flags */ 54 55 /** 56 * 57 * @ingroup gdkmmEnums 58 */ 59 enum LineStyle 60 { 61 LINE_SOLID, 62 LINE_ON_OFF_DASH, 63 LINE_DOUBLE_DASH 64 }; 65 66 } // namespace Gdk 67 68 69 #ifndef DOXYGEN_SHOULD_SKIP_THIS 70 namespace Glib 71 { 72 73 template <> 74 class Value<Gdk::LineStyle> : public Glib::Value_Enum<Gdk::LineStyle> 75 { 76 public: 77 static GType value_type() G_GNUC_CONST; 78 }; 79 80 } // namespace Glib 81 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 82 83 84 namespace Gdk 85 { 86 87 /** 88 * 89 * @ingroup gdkmmEnums 90 */ 91 enum CapStyle 92 { 93 CAP_NOT_LAST, 94 CAP_BUTT, 95 CAP_ROUND, 96 CAP_PROJECTING 97 }; 98 99 } // namespace Gdk 100 101 102 #ifndef DOXYGEN_SHOULD_SKIP_THIS 103 namespace Glib 104 { 105 106 template <> 107 class Value<Gdk::CapStyle> : public Glib::Value_Enum<Gdk::CapStyle> 108 { 109 public: 110 static GType value_type() G_GNUC_CONST; 111 }; 112 113 } // namespace Glib 114 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 115 116 117 namespace Gdk 118 { 119 120 /** 121 * 122 * @ingroup gdkmmEnums 123 */ 124 enum JoinStyle 125 { 126 JOIN_MITER, 127 JOIN_ROUND, 128 JOIN_BEVEL 129 }; 130 131 } // namespace Gdk 132 133 134 #ifndef DOXYGEN_SHOULD_SKIP_THIS 135 namespace Glib 136 { 137 138 template <> 139 class Value<Gdk::JoinStyle> : public Glib::Value_Enum<Gdk::JoinStyle> 140 { 141 public: 142 static GType value_type() G_GNUC_CONST; 143 }; 144 145 } // namespace Glib 146 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 147 148 149 namespace Gdk 150 { 151 152 /** 153 * 154 * @ingroup gdkmmEnums 155 */ 156 enum Fill 157 { 158 SOLID, 159 TILED, 160 STIPPLED, 161 OPAQUE_STIPPLED 162 }; 163 164 } // namespace Gdk 165 166 167 #ifndef DOXYGEN_SHOULD_SKIP_THIS 168 namespace Glib 169 { 170 171 template <> 172 class Value<Gdk::Fill> : public Glib::Value_Enum<Gdk::Fill> 173 { 174 public: 175 static GType value_type() G_GNUC_CONST; 176 }; 177 178 } // namespace Glib 179 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 180 181 182 namespace Gdk 183 { 184 185 /** 186 * 187 * @ingroup gdkmmEnums 188 */ 189 enum Function 190 { 191 COPY, 192 INVERT, 193 XOR, 194 CLEAR, 195 AND, 196 AND_REVERSE, 197 AND_INVERT, 198 NOOP, 199 OR, 200 EQUIV, 201 OR_REVERSE, 202 COPY_INVERT, 203 OR_INVERT, 204 NAND, 205 NOR, 206 SET 207 }; 208 209 } // namespace Gdk 210 211 212 #ifndef DOXYGEN_SHOULD_SKIP_THIS 213 namespace Glib 214 { 215 216 template <> 217 class Value<Gdk::Function> : public Glib::Value_Enum<Gdk::Function> 218 { 219 public: 220 static GType value_type() G_GNUC_CONST; 221 }; 222 223 } // namespace Glib 224 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 225 226 227 namespace Gdk 228 { 229 230 /** 231 * 232 * @ingroup gdkmmEnums 233 */ 234 enum SubwindowMode 235 { 236 CLIP_BY_CHILDREN, 237 INCLUDE_INFERIORS 238 }; 239 240 } // namespace Gdk 241 242 243 #ifndef DOXYGEN_SHOULD_SKIP_THIS 244 namespace Glib 245 { 246 247 template <> 248 class Value<Gdk::SubwindowMode> : public Glib::Value_Enum<Gdk::SubwindowMode> 249 { 250 public: 251 static GType value_type() G_GNUC_CONST; 252 }; 253 254 } // namespace Glib 255 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 256 257 258 namespace Gdk 259 { 260 261 /** 262 * 263 * @ingroup gdkmmEnums 264 * @par Bitwise operators: 265 * <tt>%GCValuesMask operator|(GCValuesMask, GCValuesMask)</tt><br> 266 * <tt>%GCValuesMask operator&(GCValuesMask, GCValuesMask)</tt><br> 267 * <tt>%GCValuesMask operator^(GCValuesMask, GCValuesMask)</tt><br> 268 * <tt>%GCValuesMask operator~(GCValuesMask)</tt><br> 269 * <tt>%GCValuesMask& operator|=(GCValuesMask&, GCValuesMask)</tt><br> 270 * <tt>%GCValuesMask& operator&=(GCValuesMask&, GCValuesMask)</tt><br> 271 * <tt>%GCValuesMask& operator^=(GCValuesMask&, GCValuesMask)</tt><br> 272 */ 273 enum GCValuesMask 274 { 275 GC_FOREGROUND = 1 << 0, 276 GC_BACKGROUND = 1 << 1, 277 GC_FONT = 1 << 2, 278 GC_FUNCTION = 1 << 3, 279 GC_FILL = 1 << 4, 280 GC_TILE = 1 << 5, 281 GC_STIPPLE = 1 << 6, 282 GC_CLIP_MASK = 1 << 7, 283 GC_SUBWINDOW = 1 << 8, 284 GC_TS_X_ORIGIN = 1 << 9, 285 GC_TS_Y_ORIGIN = 1 << 10, 286 GC_CLIP_X_ORIGIN = 1 << 11, 287 GC_CLIP_Y_ORIGIN = 1 << 12, 288 GC_EXPOSURES = 1 << 13, 289 GC_LINE_WIDTH = 1 << 14, 290 GC_LINE_STYLE = 1 << 15, 291 GC_CAP_STYLE = 1 << 16, 292 GC_JOIN_STYLE = 1 << 17 293 }; 294 295 /** @ingroup gdkmmEnums */ 296 inline GCValuesMask operator|(GCValuesMask lhs, GCValuesMask rhs) 297 { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); } 298 299 /** @ingroup gdkmmEnums */ 300 inline GCValuesMask operator&(GCValuesMask lhs, GCValuesMask rhs) 301 { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); } 302 303 /** @ingroup gdkmmEnums */ 304 inline GCValuesMask operator^(GCValuesMask lhs, GCValuesMask rhs) 305 { return static_cast<GCValuesMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); } 306 307 /** @ingroup gdkmmEnums */ 308 inline GCValuesMask operator~(GCValuesMask flags) 309 { return static_cast<GCValuesMask>(~static_cast<unsigned>(flags)); } 310 311 /** @ingroup gdkmmEnums */ 312 inline GCValuesMask& operator|=(GCValuesMask& lhs, GCValuesMask rhs) 313 { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); } 314 315 /** @ingroup gdkmmEnums */ 316 inline GCValuesMask& operator&=(GCValuesMask& lhs, GCValuesMask rhs) 317 { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); } 318 319 /** @ingroup gdkmmEnums */ 320 inline GCValuesMask& operator^=(GCValuesMask& lhs, GCValuesMask rhs) 321 { return (lhs = static_cast<GCValuesMask>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); } 322 323 } // namespace Gdk 324 325 326 #ifndef DOXYGEN_SHOULD_SKIP_THIS 327 namespace Glib 328 { 329 330 template <> 331 class Value<Gdk::GCValuesMask> : public Glib::Value_Flags<Gdk::GCValuesMask> 332 { 333 public: 334 static GType value_type() G_GNUC_CONST; 335 }; 336 337 } // namespace Glib 338 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 339 340 341 namespace Gdk 342 { 343 344 345 class Drawable; 346 347 /** All drawing operations in GDK take a graphics context (GC) argument. 348 * A graphics context encapsulates information about the way things are drawn, such as the foreground color or line width. 349 * By using graphics contexts, the number of arguments to each drawing call is greatly reduced, and communication overhead 350 * is minimized, since identical arguments do not need to be passed repeatedly. 351 */ 352 353 class GC : public Glib::Object 354 { 355 356 #ifndef DOXYGEN_SHOULD_SKIP_THIS 357 358 public: 359 typedef GC CppObjectType; 360 typedef GC_Class CppClassType; 361 typedef GdkGC BaseObjectType; 362 typedef GdkGCClass BaseClassType; 363 364 private: friend class GC_Class; 365 static CppClassType gc_class_; 366 367 private: 368 // noncopyable 369 GC(const GC&); 370 GC& operator=(const GC&); 371 372 protected: 373 explicit GC(const Glib::ConstructParams& construct_params); 374 explicit GC(GdkGC* castitem); 375 376 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 377 378 public: 379 virtual ~GC(); 380 381 /** Get the GType for this class, for use with the underlying GObject type system. 382 */ 383 static GType get_type() G_GNUC_CONST; 384 385 #ifndef DOXYGEN_SHOULD_SKIP_THIS 386 387 388 static GType get_base_type() G_GNUC_CONST; 389 #endif 390 391 ///Provides access to the underlying C GObject. gobj()392 GdkGC* gobj() { return reinterpret_cast<GdkGC*>(gobject_); } 393 394 ///Provides access to the underlying C GObject. gobj()395 const GdkGC* gobj() const { return reinterpret_cast<GdkGC*>(gobject_); } 396 397 ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs. 398 GdkGC* gobj_copy(); 399 400 private: 401 402 403 protected: 404 GC(); 405 explicit GC(const Glib::RefPtr<Drawable>& drawable); 406 407 public: 408 409 static Glib::RefPtr<GC> create(); 410 411 412 static Glib::RefPtr<GC> create(const Glib::RefPtr<Drawable>& drawable); 413 414 415 // Custom wrap these?, maybe with a Gdk::GC::Value class. Need to do take care of refcounts of GdkGCValue's fields. 416 // Actually, I don't see the need for these methods. murrayc. 417 //_WRAP_METHOD(void get_values(GdkGCValues& values) const, gdk_gc_get_values) 418 //_WRAP_METHOD(void set_values(const GdkGCValues& values, GCValuesMask values_mask), gdk_gc_set_values) 419 //__IGNORE(gdk_gc_get_values, gdk_gc_set_values) 420 421 422 /** Sets the foreground color for a graphics context. 423 * Note that this function uses @a color->pixel, use 424 * set_rgb_fg_color() to specify the foreground 425 * color as red, green, blue components. 426 * 427 * Deprecated: 2.22: Use gdk_cairo_set_source_color() to use a Gdk::Color 428 * as the source in Cairo. 429 * 430 * @param color The new foreground color. 431 */ 432 void set_foreground(const Color& color); 433 434 /** Sets the background color for a graphics context. 435 * Note that this function uses @a color->pixel, use 436 * set_rgb_bg_color() to specify the background 437 * color as red, green, blue components. 438 * 439 * Deprecated: 2.22: Use gdk_cairo_set_source_color() to use a Gdk::Color 440 * as the source in Cairo. Note that if you want to draw a background and a 441 * foreground in Cairo, you need to call drawing functions (like cairo_fill()) 442 * twice. 443 * 444 * @param color The new background color. 445 */ 446 void set_background(const Color& color); 447 448 /** Determines how the current pixel values and the 449 * pixel values being drawn are combined to produce 450 * the final pixel values. 451 * 452 * Deprecated: 2.22: Use cairo_set_operator() with Cairo. 453 * 454 * @param function The Gdk::Function to use. 455 */ 456 void set_function(Function function); 457 458 /** Set the fill mode for a graphics context. 459 * 460 * Deprecated: 2.22: You can achieve tiling in Cairo by using 461 * cairo_pattern_set_extend() on the source. For stippling, see the 462 * deprecation comments on set_stipple(). 463 * 464 * @param fill The new fill mode. 465 */ 466 void set_fill(Fill fill); 467 468 /** Set a tile pixmap for a graphics context. 469 * This will only be used if the fill mode 470 * is Gdk::TILED. 471 * 472 * Deprecated: 2.22: The following code snippet sets a tiling Gdk::Pixmap 473 * as the source in Cairo: 474 * 475 * [C example ellipted] 476 * 477 * @param tile The new tile pixmap. 478 */ 479 void set_tile(const Glib::RefPtr<Pixmap>& tile); 480 481 /** Set the stipple bitmap for a graphics context. The 482 * stipple will only be used if the fill mode is 483 * Gdk::STIPPLED or Gdk::OPAQUE_STIPPLED. 484 * 485 * Deprecated: 2.22: Stippling has no direct replacement in Cairo. If you 486 * want to achieve an identical look, you can use the stipple bitmap as a 487 * mask. Most likely, this involves rendering the source to an intermediate 488 * surface using cairo_push_group() first, so that you can then use 489 * cairo_mask() to achieve the stippled look. 490 * 491 * @param stipple The new stipple bitmap. 492 */ 493 void set_stipple(const Glib::RefPtr<Pixmap>& stipple); 494 495 /** Set the origin when using tiles or stipples with 496 * the GC. The tile or stipple will be aligned such 497 * that the upper left corner of the tile or stipple 498 * will coincide with this point. 499 * 500 * Deprecated: 2.22: You can set the origin for tiles and stipples in Cairo 501 * by changing the source's matrix using cairo_pattern_set_matrix(). Or you 502 * can specify it with gdk_cairo_set_source_pixmap() as shown in the example 503 * for set_tile(). 504 * 505 * @param x The x-coordinate of the origin. 506 * @param y The y-coordinate of the origin. 507 */ 508 void set_ts_origin(int x, int y); 509 510 /** Sets the origin of the clip mask. The coordinates are 511 * interpreted relative to the upper-left corner of 512 * the destination drawable of the current operation. 513 * 514 * Deprecated: 2.22: Use cairo_translate() before applying the clip path in 515 * Cairo. 516 * 517 * @param x The x-coordinate of the origin. 518 * @param y The y-coordinate of the origin. 519 */ 520 void set_clip_origin(int x, int y); 521 522 /** Sets the clip mask for a graphics context from a bitmap. 523 * The clip mask is interpreted relative to the clip 524 * origin. (See set_clip_origin()). 525 * 526 * Deprecated: 2.22: Use cairo_mask() instead. 527 * 528 * @param mask A bitmap. 529 */ 530 void set_clip_mask(const Glib::RefPtr<Bitmap>& mask); 531 532 //Note: The rectangle parameter was made const in GTK+ 2.16, but we can't change that in our C++ API. TODO: Change it when we can do an ABI break. 533 534 535 #ifndef GDKMM_DISABLE_DEPRECATED 536 537 /** Sets the clip mask for a graphics context from a 538 * rectangle. The clip mask is interpreted relative to the clip 539 * origin. (See set_clip_origin()). 540 * 541 * Deprecated: 2.22: Use cairo_rectangle() and cairo_clip() in Cairo. 542 * 543 * @deprecated Use set_clip_rectangle(const Rectangle& rectangle) instead. 544 * 545 * @param rectangle The rectangle to clip to. 546 */ 547 void set_clip_rectangle(Rectangle& rectangle); 548 #endif // GDKMM_DISABLE_DEPRECATED 549 550 551 /** Sets the clip mask for a graphics context from a 552 * rectangle. The clip mask is interpreted relative to the clip 553 * origin. (See set_clip_origin()). 554 * 555 * Deprecated: 2.22: Use cairo_rectangle() and cairo_clip() in Cairo. 556 * 557 * @param rectangle The rectangle to clip to. 558 */ 559 void set_clip_rectangle(const Rectangle& rectangle); 560 561 562 /** Sets the clip mask for a graphics context from a region structure. 563 * The clip mask is interpreted relative to the clip origin. (See 564 * set_clip_origin()). 565 * 566 * Deprecated: 2.22: Use gdk_cairo_region() and cairo_clip() in Cairo. 567 * 568 * @param region The Gdk::Region. 569 */ 570 void set_clip_region(const Region& region); 571 572 /** Sets how drawing with this GC on a window will affect child 573 * windows of that window. 574 * 575 * Deprecated: 2.22: There is no replacement. If you need to control 576 * subwindows, you must use drawing operations of the underlying window 577 * system manually. Cairo will always use Gdk::INCLUDE_INFERIORS on sources 578 * and masks and Gdk::CLIP_BY_CHILDREN on targets. 579 * 580 * @param mode The subwindow mode. 581 */ 582 void set_subwindow(SubwindowMode mode); 583 584 /** Sets whether copying non-visible portions of a drawable 585 * using this graphics context generate exposure events 586 * for the corresponding regions of the destination 587 * drawable. (See gdk_draw_drawable()). 588 * 589 * Deprecated: 2.22: There is no replacement. If you need to control 590 * exposures, you must use drawing operations of the underlying window 591 * system or use Gdk::Window::invalidate_rect(). Cairo will never 592 * generate exposures. 593 * 594 * @param exposures If <tt>true</tt>, exposure events will be generated. 595 */ 596 void set_exposures(bool exposures); 597 598 /** Sets various attributes of how lines are drawn. See 599 * the corresponding members of Gdk::GCValues for full 600 * explanations of the arguments. 601 * 602 * Deprecated: 2.22: Use the Cairo functions cairo_set_line_width(), 603 * cairo_set_line_join(), cairo_set_line_cap() and cairo_set_dash() 604 * to affect the stroking behavior in Cairo. Keep in mind that the default 605 * attributes of a #cairo_t are different from the default attributes of 606 * a Gdk::GC. 607 * 608 * @param line_width The width of lines. 609 * @param line_style The dash-style for lines. 610 * @param cap_style The manner in which the ends of lines are drawn. 611 * @param join_style The in which lines are joined together. 612 */ 613 void set_line_attributes(int line_width, LineStyle line_style, CapStyle cap_style, JoinStyle join_style); 614 615 /** Sets the way dashed-lines are drawn. Lines will be 616 * drawn with alternating on and off segments of the 617 * lengths specified in @a dash_list. The manner in 618 * which the on and off segments are drawn is determined 619 * by the @a line_style value of the GC. (This can 620 * be changed with set_line_attributes().) 621 * 622 * The @a dash_offset defines the phase of the pattern, 623 * specifying how many pixels into the dash-list the pattern 624 * should actually begin. 625 * 626 * Deprecated: 2.22: Use cairo_set_dash() to set the dash in Cairo. 627 * 628 * @param dash_offset The phase of the dash pattern. 629 * @param dash_list An array of dash lengths. 630 * @param n The number of elements in @a dash_list. 631 */ 632 void set_dashes(int dash_offset, gint8* dash_list, int n); 633 634 /** Offset attributes such as the clip and tile-stipple origins 635 * of the GC so that drawing at x - x_offset, y - y_offset with 636 * the offset GC has the same effect as drawing at x, y with the original 637 * GC. 638 * 639 * Deprecated: 2.22: There is no direct replacement, as this is just a 640 * convenience function for gdk_gc_set_ts_origin and set_clip_origin(). 641 * 642 * @param x_offset Amount by which to offset the GC in the X direction. 643 * @param y_offset Amount by which to offset the GC in the Y direction. 644 */ 645 void offset(int x_offset, int y_offset); 646 647 /** Sets the colormap for the GC to the given colormap. The depth 648 * of the colormap's visual must match the depth of the drawable 649 * for which the GC was created. 650 * 651 * Deprecated: 2.22: There is no replacement. Cairo handles colormaps 652 * automatically, so there is no need to care about them. 653 * 654 * @param colormap A Gdk::Colormap. 655 */ 656 void set_colormap(const Glib::RefPtr<Colormap>& colormap); 657 658 /** Retrieves the colormap for a given GC, if it exists. 659 * A GC will have a colormap if the drawable for which it was created 660 * has a colormap, or if a colormap was set explicitely with 661 * gdk_gc_set_colormap. 662 * 663 * Deprecated: 2.22: There is no replacement. Cairo handles colormaps 664 * automatically, so there is no need to care about them. 665 * 666 * @return The colormap of @a gc, or <tt>0</tt> if @a gc doesn't have one. 667 */ 668 Glib::RefPtr<Colormap> get_colormap(); 669 670 /** Set the foreground color of a GC using an unallocated color. The 671 * pixel value for the color will be determined using GdkRGB. If the 672 * colormap for the GC has not previously been initialized for GdkRGB, 673 * then for pseudo-color colormaps (colormaps with a small modifiable 674 * number of colors), a colorcube will be allocated in the colormap. 675 * 676 * Calling this function for a GC without a colormap is an error. 677 * 678 * Deprecated: 2.22: Use gdk_cairo_set_source_color() instead. 679 * 680 * @param color An unallocated Gdk::Color. 681 */ 682 void set_rgb_fg_color(const Color& color); 683 684 /** Set the background color of a GC using an unallocated color. The 685 * pixel value for the color will be determined using GdkRGB. If the 686 * colormap for the GC has not previously been initialized for GdkRGB, 687 * then for pseudo-color colormaps (colormaps with a small modifiable 688 * number of colors), a colorcube will be allocated in the colormap. 689 * 690 * Calling this function for a GC without a colormap is an error. 691 * 692 * Deprecated: 2.22: Use gdk_cairo_set_source_color() instead. 693 * 694 * @param color An unallocated Gdk::Color. 695 */ 696 void set_rgb_bg_color(const Color& color); 697 698 699 /** Gets the Gdk::Screen for which @a gc was created 700 * 701 * @newin{2,2} 702 * 703 * @return The Gdk::Screen for @a gc. 704 */ 705 Glib::RefPtr<Screen> get_screen(); 706 707 /** Gets the Gdk::Screen for which @a gc was created 708 * 709 * @newin{2,2} 710 * 711 * @return The Gdk::Screen for @a gc. 712 */ 713 Glib::RefPtr<const Screen> get_screen() const; 714 715 716 public: 717 718 public: 719 //C++ methods used to invoke GTK+ virtual functions: 720 721 protected: 722 //GTK+ Virtual Functions (override these to change behaviour): 723 724 //Default Signal Handlers:: 725 726 727 }; 728 729 } /* namespace Gdk */ 730 731 732 namespace Glib 733 { 734 /** A Glib::wrap() method for this object. 735 * 736 * @param object The C instance. 737 * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref. 738 * @result A C++ instance that wraps this C instance. 739 * 740 * @relates Gdk::GC 741 */ 742 Glib::RefPtr<Gdk::GC> wrap(GdkGC* object, bool take_copy = false); 743 } 744 745 746 #endif /* _GDKMM_GC_H */ 747 748