Quelle  mini-graph.c

#include <math.h>
#include "mini-graph.h"


static float
apply_easing_params (float *params,
                     float  progress)
{
  static const float epsilon = 0.00001;
  float tmin, t, tmax;
  float x1, y1, x2, y2;

  x1 = params[0];
  y1 = params[1];
  x2 = params[2];
  y2 = params[3];

  if (progress <= 0)
    return 0;
  if (progress >= 1)
    return 1;

  tmin = 0.0;
  tmax = 1.0;
  t = progress;

  while (tmin < tmax)
    {
      float sample;

      sample = (((1.0 + 3 * x1 - 3 * x2) * t
                +      -6 * x1 + 3 * x2) * t
                +       3 * x1         ) * t;
      if (fabsf (sample - progress) < epsilon)
        break;

      if (progress > sample)
        tmin = t;
      else
        tmax = t;
      t = (tmax + tmin) * .5;
    }
  return (((1.0 + 3 * y1 - 3 * y2) * t
          +      -6 * y1 + 3 * y2) * t
          +       3 * y1         ) * t;
}

struct _MiniGraph
{
  GtkWidget parent_instance;

  GpaEasing easing;

  int path_size;
  GskPath *path;
};

static float
compute_value (MiniGraph *self,
               float      t)
{
  static struct {
    float params[4];
  } easing[] = {
    { .params = { 0, 0, 1, 1 } },
    { .params = { 0.42, 0, 0.58, 1 } },
    { .params = { 0.42, 0, 1, 1 } },
    { .params = { 0, 0, 0.58, 1 } },
    { .params = { 0.25, 0.1, 0.25, 1 } },
  };

  return apply_easing_params (easing[self->easing].params, t);
}

static GskPath *
create_path (MiniGraph *self,
             int        size)
{
  GskPathBuilder *builder = gsk_path_builder_new ();

  for (int i = 0; i <= size; i++)
    {
      float x = i / (float) size;
      float y = compute_value (self, x);
      y = CLAMP (y, 0, 1);

      if (i == 0)
        gsk_path_builder_move_to (builder, x * size, (1 - y) * size);
      else
        gsk_path_builder_line_to (builder, x * size, (1 - y) * size);
    }

  return gsk_path_builder_free_to_path (builder);
}

static GskPath *
ensure_path (MiniGraph *self,
             int        size)
{
  if (self->path_size != size)
    g_clear_pointer (&self->path, gsk_path_unref);

  if (!self->path)
    {
      self->path = create_path (self, size);
      self->path_size = size;
    }

  return self->path;
}

static void
mini_graph_snapshot (GtkWidget   *widget,
                     GtkSnapshot *snapshot)
{
  MiniGraph *self = MINI_GRAPH (widget);
  int width, height, size;
  GskPath *path;
  GskStroke *stroke;

  width = gtk_widget_get_width (widget);
  height = gtk_widget_get_height (widget);

  size = MIN (width, height);

  gtk_snapshot_save (snapshot);
  gtk_snapshot_translate (snapshot,
                          &GRAPHENE_POINT_INIT ((width - size) / 2,
                                                (height - size) / 2));

  gtk_snapshot_append_color (snapshot,
                             &(GdkRGBA) { 1, 1, 1, 1 },
                             &GRAPHENE_RECT_INIT (0, 0, size, size));
  gtk_snapshot_append_border (snapshot,
                              &GSK_ROUNDED_RECT_INIT (0, 0, size, size),
                              (float [4]) { 1, 1, 1, 1 },
                              (GdkRGBA[4]) {
                                { 0, 0, 0, 0.75 },
                                { 0, 0, 0, 0.75 },
                                { 0, 0, 0, 0.75 },
                                { 0, 0, 0, 0.75 },
                              });

  path = ensure_path (self, size);

  stroke = gsk_stroke_new (2);

  gtk_snapshot_append_stroke (snapshot, path, stroke, &(GdkRGBA) { 0, 0, 1, 1 });

  gsk_stroke_free (stroke);

  gtk_snapshot_restore (snapshot);
}

struct _MiniGraphClass
{
  GtkWidgetClass parent_class;
};

enum {
  PROP_EASING = 1,
  NUM_PROPERTIES,
};

static GParamSpec *properties[NUM_PROPERTIES] = { NULL, };

G_DEFINE_TYPE (MiniGraph, mini_graph, GTK_TYPE_WIDGET)

static void
mini_graph_init (MiniGraph *self)
{
  self->easing = GPA_EASING_LINEAR;
}

static void
mini_graph_finalize (GObject *object)
{
  MiniGraph *self = MINI_GRAPH (object);

  g_clear_pointer (&self->path, gsk_path_unref);

  G_OBJECT_CLASS (mini_graph_parent_class)->finalize (object);
}

static void
mini_graph_set_property (GObject      *object,
                         unsigned int  prop_id,
                         const GValue *value,
                         GParamSpec   *pspec)
{
  MiniGraph *self = MINI_GRAPH (object);

  switch (prop_id)
    {
    case PROP_EASING:
      mini_graph_set_easing (self, g_value_get_uint (value));
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
mini_graph_get_property (GObject      *object,
                         unsigned int  prop_id,
                         GValue       *value,
                         GParamSpec   *pspec)
{
  MiniGraph *self = MINI_GRAPH (object);

  switch (prop_id)
    {
    case PROP_EASING:
      g_value_set_uint (value, self->easing);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
mini_graph_class_init (MiniGraphClass *class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (class);
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);

  object_class->finalize = mini_graph_finalize;
  object_class->set_property = mini_graph_set_property;
  object_class->get_property = mini_graph_get_property;

  properties[PROP_EASING] =
    g_param_spec_uint ("easing", NULL, NULL,
                       0, G_MAXUINT, 0,
                       G_PARAM_READWRITE | G_PARAM_STATIC_NAME);

  g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);

  widget_class->snapshot = mini_graph_snapshot;
}

GtkWidget *
mini_graph_new (void)
{
  return g_object_new (mini_graph_get_type (), NULL);
}

void
mini_graph_set_easing (MiniGraph *self,
                       GpaEasing  easing)
{
  if (self->easing == easing)
    return;

  self->easing = easing;

  g_clear_pointer (&self->path, gsk_path_unref);
  gtk_widget_queue_draw (GTK_WIDGET (self));

  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_EASING]);
}