自学教程：C++ GIMP_RULER_GET_PRIVATE函数代码示例

/** * gimp_ruler_get_unit: * @ruler: a #GimpRuler * * Return value: the unit currently used in the @ruler widget. * * Since: GIMP 2.8 **/GimpUnitgimp_ruler_get_unit (GimpRuler *ruler){  g_return_val_if_fail (GIMP_IS_RULER (ruler), 0);  return GIMP_RULER_GET_PRIVATE (ruler)->unit;}

/** * gimp_ruler_set_range: * @ruler: a #GimpRuler * @lower: the lower limit of the ruler * @upper: the upper limit of the ruler * @max_size: the maximum size of the ruler used when calculating the space to * leave for the text * * This sets the range of the ruler. * * Since: GIMP 2.8 */voidgimp_ruler_set_range (GimpRuler *ruler,                      gdouble    lower,                      gdouble    upper,                      gdouble    max_size){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  g_object_freeze_notify (G_OBJECT (ruler));  if (priv->lower != lower)    {      priv->lower = lower;      g_object_notify (G_OBJECT (ruler), "lower");    }  if (priv->upper != upper)    {      priv->upper = upper;      g_object_notify (G_OBJECT (ruler), "upper");    }  if (priv->max_size != max_size)    {      priv->max_size = max_size;      g_object_notify (G_OBJECT (ruler), "max-size");    }  g_object_thaw_notify (G_OBJECT (ruler));  gtk_widget_queue_draw (GTK_WIDGET (ruler));}

/** * gimp_ruler_get_position: * @ruler: a #GimpRuler * * Return value: the current position of the @ruler widget. * * Since: GIMP 2.8 **/gdoublegimp_ruler_get_position (GimpRuler *ruler){  g_return_val_if_fail (GIMP_IS_RULER (ruler), 0.0);  return GIMP_RULER_GET_PRIVATE (ruler)->position;}

static voidgimp_ruler_queue_pos_redraw (GimpRuler *ruler){  GimpRulerPrivate  *priv = GIMP_RULER_GET_PRIVATE (ruler);  const GdkRectangle rect = gimp_ruler_get_pos_rect (ruler, priv->position);  gtk_widget_queue_draw_area (GTK_WIDGET(ruler),                              rect.x,                              rect.y,                              rect.width,                              rect.height);  if (priv->last_pos_rect.width != 0 || priv->last_pos_rect.height != 0)    {      gtk_widget_queue_draw_area (GTK_WIDGET(ruler),                                  priv->last_pos_rect.x,                                  priv->last_pos_rect.y,                                  priv->last_pos_rect.width,                                  priv->last_pos_rect.height);      priv->last_pos_rect.x      = 0;      priv->last_pos_rect.y      = 0;      priv->last_pos_rect.width  = 0;      priv->last_pos_rect.height = 0;    }}

static voidgimp_ruler_init (GimpRuler *ruler){  GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler);  gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE);  priv->orientation         = GTK_ORIENTATION_HORIZONTAL;  priv->unit                = GIMP_UNIT_PIXEL;  priv->lower               = 0;  priv->upper               = 0;  priv->position            = 0;  priv->max_size            = 0;  priv->backing_store       = NULL;  priv->backing_store_valid = FALSE;  priv->last_pos_rect.x      = 0;  priv->last_pos_rect.y      = 0;  priv->last_pos_rect.width  = 0;  priv->last_pos_rect.height = 0;  priv->pos_redraw_idle_id   = 0;  priv->font_scale          = DEFAULT_RULER_FONT_SCALE;}

static voidgimp_ruler_unrealize (GtkWidget *widget){  GimpRuler        *ruler = GIMP_RULER (widget);  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  if (priv->backing_store)    {      cairo_surface_destroy (priv->backing_store);      priv->backing_store = NULL;    }  if (priv->layout)    {      g_object_unref (priv->layout);      priv->layout = NULL;    }  if (priv->input_window)    {      gdk_window_destroy (priv->input_window);      priv->input_window = NULL;    }  GTK_WIDGET_CLASS (gimp_ruler_parent_class)->unrealize (widget);}

static voidgimp_ruler_realize (GtkWidget *widget){  GimpRuler        *ruler = GIMP_RULER (widget);  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  GtkAllocation     allocation;  GdkWindowAttr     attributes;  gint              attributes_mask;  GTK_WIDGET_CLASS (gimp_ruler_parent_class)->realize (widget);  gtk_widget_get_allocation (widget, &allocation);  attributes.window_type = GDK_WINDOW_CHILD;  attributes.x           = allocation.x;  attributes.y           = allocation.y;  attributes.width       = allocation.width;  attributes.height      = allocation.height;  attributes.wclass      = GDK_INPUT_ONLY;  attributes.event_mask  = (gtk_widget_get_events (widget) |                            GDK_EXPOSURE_MASK              |                            GDK_POINTER_MOTION_MASK);  attributes_mask = GDK_WA_X | GDK_WA_Y;  priv->input_window = gdk_window_new (gtk_widget_get_window (widget),                                       &attributes, attributes_mask);  gdk_window_set_user_data (priv->input_window, ruler);  gimp_ruler_make_pixmap (ruler);}

static voidgimp_ruler_size_request (GtkWidget      *widget,                         GtkRequisition *requisition){  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (widget);  GtkStyle         *style = gtk_widget_get_style (widget);  PangoLayout      *layout;  PangoRectangle    ink_rect;  gint              size;  layout = gimp_ruler_get_layout (widget, "0123456789");  pango_layout_get_pixel_extents (layout, &ink_rect, NULL);  size = 2 + ink_rect.height * 1.7;  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)    {      requisition->width  = style->xthickness * 2 + 1;      requisition->height = style->ythickness * 2 + size;    }  else    {      requisition->width  = style->xthickness * 2 + size;      requisition->height = style->ythickness * 2 + 1;    }}

static voidgimp_ruler_update_position (GimpRuler *ruler,                            gdouble    x,                            gdouble    y){  GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler);  GtkAllocation     allocation;  gdouble           lower;  gdouble           upper;  gtk_widget_get_allocation (GTK_WIDGET (ruler), &allocation);  gimp_ruler_get_range (ruler, &lower, &upper, NULL);  if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)    {      gimp_ruler_set_position (ruler,                               lower +                               (upper - lower) * x / allocation.width);    }  else    {      gimp_ruler_set_position (ruler,                               lower +                               (upper - lower) * y / allocation.height);    }}

static gbooleangimp_ruler_expose (GtkWidget      *widget,                   GdkEventExpose *event){  if (gtk_widget_is_drawable (widget))    {      GimpRuler        *ruler = GIMP_RULER (widget);      GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);      GtkAllocation     allocation;      cairo_t          *cr;      gimp_ruler_draw_ticks (ruler);      cr = gdk_cairo_create (gtk_widget_get_window (widget));      gdk_cairo_region (cr, event->region);      cairo_clip (cr);      gtk_widget_get_allocation (widget, &allocation);      cairo_translate (cr, allocation.x, allocation.y);      cairo_set_source_surface (cr, priv->backing_store, 0, 0);      cairo_paint (cr);      gimp_ruler_draw_pos (ruler);      cairo_destroy (cr);    }  return FALSE;}

static voidgimp_ruler_unmap (GtkWidget *widget){  GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget);  if (priv->input_window)    gdk_window_hide (priv->input_window);  GTK_WIDGET_CLASS (parent_class)->unmap (widget);}

static voidgimp_ruler_dispose (GObject *object){  GimpRuler        *ruler = GIMP_RULER (object);  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  while (priv->track_widgets)    gimp_ruler_remove_track_widget (ruler, priv->track_widgets->data);  G_OBJECT_CLASS (parent_class)->dispose (object);}

static gbooleangimp_ruler_idle_queue_pos_redraw (gpointer data){  GimpRuler        *ruler = data;  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  gimp_ruler_queue_pos_redraw (ruler);  priv->pos_redraw_idle_id = 0;  return G_SOURCE_REMOVE;}

static voidgimp_ruler_set_property (GObject      *object,                         guint         prop_id,                         const GValue *value,                         GParamSpec   *pspec){  GimpRuler        *ruler = GIMP_RULER (object);  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  switch (prop_id)    {    case PROP_ORIENTATION:      priv->orientation = g_value_get_enum (value);      gtk_widget_queue_resize (GTK_WIDGET (ruler));      break;    case PROP_UNIT:      gimp_ruler_set_unit (ruler, g_value_get_int (value));      break;    case PROP_LOWER:      gimp_ruler_set_range (ruler,                            g_value_get_double (value),                            priv->upper,                            priv->max_size);      break;    case PROP_UPPER:      gimp_ruler_set_range (ruler,                            priv->lower,                            g_value_get_double (value),                            priv->max_size);      break;    case PROP_POSITION:      gimp_ruler_set_position (ruler, g_value_get_double (value));      break;    case PROP_MAX_SIZE:      gimp_ruler_set_range (ruler,                            priv->lower,                            priv->upper,                            g_value_get_double (value));      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;    }}

static PangoLayout *gimp_ruler_get_layout (GtkWidget   *widget,                       const gchar *text){  GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (widget);  if (priv->layout)    {      pango_layout_set_text (priv->layout, text, -1);      return priv->layout;    }  priv->layout = gimp_ruler_create_layout (widget, text);  return priv->layout;}

static voidgimp_ruler_init (GimpRuler *ruler){  GimpRulerPrivate *priv = GIMP_RULER_GET_PRIVATE (ruler);  gtk_widget_set_has_window (GTK_WIDGET (ruler), FALSE);  priv->orientation   = GTK_ORIENTATION_HORIZONTAL;  priv->unit          = GIMP_PIXELS;  priv->lower         = 0;  priv->upper         = 0;  priv->position      = 0;  priv->max_size      = 0;  priv->backing_store = NULL;  priv->font_scale    = DEFAULT_RULER_FONT_SCALE;}

/** * gimp_ruler_set_position: * @ruler: a #GimpRuler * @position: the position to set the ruler to * * This sets the position of the ruler. * * Since: 2.8 */voidgimp_ruler_set_position (GimpRuler *ruler,                         gdouble    position){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  if (priv->position != position)    {      GdkRectangle rect;      gint xdiff, ydiff;      priv->position = position;      g_object_notify (G_OBJECT (ruler), "position");      rect = gimp_ruler_get_pos_rect (ruler, priv->position);      xdiff = rect.x - priv->last_pos_rect.x;      ydiff = rect.y - priv->last_pos_rect.y;      /*       * If the position has changed far enough, queue a redraw immediately.       * Otherwise, we only queue a redraw in a low priority idle handler, to       * allow for other things (like updating the canvas) to run.       *       * TODO: This might not be necessary any more in GTK3 with the frame       *       clock. Investigate this more after the port to GTK3.       */      if (priv->last_pos_rect.width  != 0 &&          priv->last_pos_rect.height != 0 &&          (ABS (xdiff) > IMMEDIATE_REDRAW_THRESHOLD ||           ABS (ydiff) > IMMEDIATE_REDRAW_THRESHOLD))        {          gimp_ruler_queue_pos_redraw (ruler);        }      else if (! priv->pos_redraw_idle_id)        {          priv->pos_redraw_idle_id =            g_idle_add_full (G_PRIORITY_LOW,                             gimp_ruler_idle_queue_pos_redraw,                             ruler, NULL);        }    }}

static voidgimp_ruler_make_pixmap (GimpRuler *ruler){  GtkWidget        *widget = GTK_WIDGET (ruler);  GimpRulerPrivate *priv   = GIMP_RULER_GET_PRIVATE (ruler);  GtkAllocation     allocation;  gtk_widget_get_allocation (widget, &allocation);  if (priv->backing_store)    cairo_surface_destroy (priv->backing_store);  priv->backing_store =    gdk_window_create_similar_surface (gtk_widget_get_window (widget),                                       CAIRO_CONTENT_COLOR,                                       allocation.width,                                       allocation.height);}

/** * gimp_ruler_set_unit: * @ruler: a #GimpRuler * @unit:  the #GimpUnit to set the ruler to * * This sets the unit of the ruler. * * Since: GIMP 2.8 */voidgimp_ruler_set_unit (GimpRuler *ruler,                     GimpUnit   unit){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  if (priv->unit != unit)    {      priv->unit = unit;      g_object_notify (G_OBJECT (ruler), "unit");      gtk_widget_queue_draw (GTK_WIDGET (ruler));    }}

/** * gimp_ruler_set_position: * @ruler: a #GimpRuler * @position: the position to set the ruler to * * This sets the position of the ruler. * * Since: GIMP 2.8 */voidgimp_ruler_set_position (GimpRuler *ruler,                         gdouble    position){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  if (priv->position != position)    {      priv->position = position;      g_object_notify (G_OBJECT (ruler), "position");      gimp_ruler_draw_pos (ruler);    }}

/** * gimp_ruler_get_range: * @ruler: a #GimpRuler * @lower: location to store lower limit of the ruler, or %NULL * @upper: location to store upper limit of the ruler, or %NULL * @max_size: location to store the maximum size of the ruler used when *            calculating the space to leave for the text, or %NULL. * * Retrieves values indicating the range and current position of a #GimpRuler. * See gimp_ruler_set_range(). * * Since: GIMP 2.8 **/voidgimp_ruler_get_range (GimpRuler *ruler,                      gdouble   *lower,                      gdouble   *upper,                      gdouble   *max_size){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  if (lower)    *lower = priv->lower;  if (upper)    *upper = priv->upper;  if (max_size)    *max_size = priv->max_size;}

static voidgimp_ruler_get_property (GObject    *object,                         guint       prop_id,                         GValue     *value,                         GParamSpec *pspec){  GimpRuler        *ruler = GIMP_RULER (object);  GimpRulerPrivate *priv  = GIMP_RULER_GET_PRIVATE (ruler);  switch (prop_id)    {    case PROP_ORIENTATION:      g_value_set_enum (value, priv->orientation);      break;    case PROP_UNIT:      g_value_set_int (value, priv->unit);      break;    case PROP_LOWER:      g_value_set_double (value, priv->lower);      break;    case PROP_UPPER:      g_value_set_double (value, priv->upper);      break;    case PROP_POSITION:      g_value_set_double (value, priv->position);      break;    case PROP_MAX_SIZE:      g_value_set_double (value, priv->max_size);      break;    default:      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);      break;    }}

/** * gimp_ruler_add_track_widget: * @ruler: a #GimpRuler * @widget: the track widget to add * * Adds a "track widget" to the ruler. The ruler will connect to * GtkWidget:motion-notify-event: on the track widget and update its * position marker accordingly. The marker is correctly updated also * for the track widget's children, regardless of whether they are * ordinary children of off-screen children. * * Since: GIMP 2.8 */voidgimp_ruler_add_track_widget (GimpRuler *ruler,                             GtkWidget *widget){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  g_return_if_fail (GTK_IS_WIDGET (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  g_return_if_fail (g_list_find (priv->track_widgets, widget) == NULL);  priv->track_widgets = g_list_prepend (priv->track_widgets, widget);  g_signal_connect (widget, "motion-notify-event",                    G_CALLBACK (gimp_ruler_track_widget_motion_notify),                    ruler);  g_signal_connect_swapped (widget, "destroy",                            G_CALLBACK (gimp_ruler_remove_track_widget),                            ruler);}

/** * gimp_ruler_remove_track_widget: * @ruler: a #GimpRuler * @widget: the track widget to remove * * Removes a previously added track widget from the ruler. See * gimp_ruler_add_track_widget(). * * Since: GIMP 2.8 */voidgimp_ruler_remove_track_widget (GimpRuler *ruler,                                GtkWidget *widget){  GimpRulerPrivate *priv;  g_return_if_fail (GIMP_IS_RULER (ruler));  g_return_if_fail (GTK_IS_WIDGET (ruler));  priv = GIMP_RULER_GET_PRIVATE (ruler);  g_return_if_fail (g_list_find (priv->track_widgets, widget) != NULL);  priv->track_widgets = g_list_remove (priv->track_widgets, widget);  g_signal_handlers_disconnect_by_func (widget,                                        gimp_ruler_track_widget_motion_notify,                                        ruler);  g_signal_handlers_disconnect_by_func (widget,                                        gimp_ruler_remove_track_widget,                                        ruler);}

static voidgimp_ruler_draw_pos (GimpRuler *ruler, cairo_t *cr){  GtkWidget        *widget = GTK_WIDGET (ruler);  GtkStyle         *style  = gtk_widget_get_style (widget);  GimpRulerPrivate *priv   = GIMP_RULER_GET_PRIVATE (ruler);  GtkStateType      state  = gtk_widget_get_state (widget);  GdkRectangle      pos_rect;  if (! gtk_widget_is_drawable (widget))    return;  pos_rect = gimp_ruler_get_pos_rect (ruler, gimp_ruler_get_position (ruler));  if ((pos_rect.width > 0) && (pos_rect.height > 0))    {      gdk_cairo_set_source_color (cr, &style->fg[state]);      cairo_move_to (cr, pos_rect.x, pos_rect.y);      if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)        {          cairo_line_to (cr, pos_rect.x + pos_rect.width / 2.0,                             pos_rect.y + pos_rect.height);          cairo_line_to (cr, pos_rect.x + pos_rect.width,                             pos_rect.y);        }      else        {          cairo_line_to (cr, pos_rect.x + pos_rect.width,                             pos_rect.y + pos_rect.height / 2.0);          cairo_line_to (cr, pos_rect.x,                             pos_rect.y + pos_rect.height);        }      cairo_fill (cr);    }}