Package ch.bailu.gtk.gtk

Class DrawingArea

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gobject.InitiallyUnowned
ch.bailu.gtk.gtk.Widget
ch.bailu.gtk.gtk.DrawingArea
All Implemented Interfaces:
PointerInterface
public class DrawingArea extends Widget
`GtkDrawingArea` is a widget that allows drawing with cairo.

![An example GtkDrawingArea](drawingarea.png)

It’s essentially a blank widget; you can draw on it. After
creating a drawing area, the application may want to connect to:

- The [signal@Gtk.Widget::realize] signal to take any necessary actions
when the widget is instantiated on a particular display.
(Create GDK resources in response to this signal.)

- The [signal@Gtk.DrawingArea::resize] signal to take any necessary
actions when the widget changes size.

- Call [method@Gtk.DrawingArea.set_draw_func] to handle redrawing the
contents of the widget.

The following code portion demonstrates using a drawing
area to display a circle in the normal widget foreground
color.

## Simple GtkDrawingArea usage

```c
static void
draw_function (GtkDrawingArea *area,
cairo_t *cr,
int width,
int height,
gpointer data)
{
GdkRGBA color;
GtkStyleContext *context;

context = gtk_widget_get_style_context (GTK_WIDGET (area));

cairo_arc (cr,
width / 2.0, height / 2.0,
MIN (width, height) / 2.0,
0, 2 * G_PI);

gtk_style_context_get_color (context,
&color);
gdk_cairo_set_source_rgba (cr, &color);

cairo_fill (cr);
}

int
main (int argc, char **argv)
{
gtk_init ();

GtkWidget *area = gtk_drawing_area_new ();
gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 100);
gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 100);
gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area),
draw_function,
NULL, NULL);
return 0;
}
```

The draw function is normally called when a drawing area first comes
onscreen, or when it’s covered by another window and then uncovered.
You can also force a redraw by adding to the “damage region” of the
drawing area’s window using [method@Gtk.Widget.queue_draw].
This will cause the drawing area to call the draw function again.

The available routines for drawing are documented in the
[Cairo documentation](https://www.cairographics.org/manual/); GDK
offers additional API to integrate with Cairo, like [func@Gdk.cairo_set_source_rgba]
or [func@Gdk.cairo_set_source_pixbuf].

To receive mouse events on a drawing area, you will need to use
event controllers. To receive keyboard events, you will need to set
the “can-focus” property on the drawing area, and you should probably
draw some user-visible indication that the drawing area is focused.

If you need more complex control over your widget, you should consider
creating your own `GtkWidget` subclass.

https://docs.gtk.org/gtk4/class.DrawingArea.html

  • Field Details

  • Constructor Details

    • DrawingArea

      public DrawingArea(PointerContainer pointer)

    • DrawingArea

      public DrawingArea()
      Creates a new drawing area.

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • getContentHeight

      public int getContentHeight()
      Retrieves the content height of the `GtkDrawingArea`.
      Returns:
      The height requested for content of the drawing area

    • getContentWidth

      public int getContentWidth()
      Retrieves the content width of the `GtkDrawingArea`.
      Returns:
      The width requested for content of the drawing area

    • setContentHeight

      public void setContentHeight(int height)
      Sets the desired height of the contents of the drawing area.

      Note that because widgets may be allocated larger sizes than they
      requested, it is possible that the actual height passed to your draw
      function is larger than the height set here. You can use
      [method@Gtk.Widget.set_valign] to avoid that.

      If the height is set to 0 (the default), the drawing area may disappear.
      Parameters:
      height - the height of contents

    • setContentWidth

      public void setContentWidth(int width)
      Sets the desired width of the contents of the drawing area.

      Note that because widgets may be allocated larger sizes than they
      requested, it is possible that the actual width passed to your draw
      function is larger than the width set here. You can use
      [method@Gtk.Widget.set_halign] to avoid that.

      If the width is set to 0 (the default), the drawing area may disappear.
      Parameters:
      width - the width of contents

    • setDrawFunc

      public void setDrawFunc(DrawingArea.OnDrawingAreaDrawFunc draw_func, @Nullable Pointer user_data, DrawingArea.OnDestroyNotify destroy)
      Setting a draw function is the main thing you want to do when using
      a drawing area.

      The draw function is called whenever GTK needs to draw the contents
      of the drawing area to the screen.

      The draw function will be called during the drawing stage of GTK.
      In the drawing stage it is not allowed to change properties of any
      GTK widgets or call any functions that would cause any properties
      to be changed. You should restrict yourself exclusively to drawing
      your contents in the draw function.

      If what you are drawing does change, call [method@Gtk.Widget.queue_draw]
      on the drawing area. This will cause a redraw and will call @draw_func again.
      Parameters:
      draw_func - callback that lets you draw the drawing area's contents
      user_data - user data passed to @draw_func
      destroy - destroy notifier for @user_data

    • onResize

      public SignalHandler onResize(DrawingArea.OnResize signal)
      Connect to signal "resize".
      See DrawingArea.OnResize.onResize(int, int) for signal description.
      Field SIGNAL_ON_RESIZE contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • asAccessible

      public Accessible asAccessible()
      Implements interface Accessible. Call this to get access to interface functions.
      Overrides:
      asAccessible in class Widget
      Returns:
      Accessible

    • asBuildable

      public Buildable asBuildable()
      Implements interface Buildable. Call this to get access to interface functions.
      Overrides:
      asBuildable in class Widget
      Returns:
      Buildable

    • asConstraintTarget

      public ConstraintTarget asConstraintTarget()
      Implements interface ConstraintTarget. Call this to get access to interface functions.
      Overrides:
      asConstraintTarget in class Widget
      Returns:
      ConstraintTarget

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()