void ScrollbarThemeGtk::paintButton(GraphicsContext* context, ScrollbarThemeClient* scrollbar, const IntRect& rect, ScrollbarPart part)
{
    GtkStyleContext* styleContext = gtkScrollbarStyleContext();
    gtk_style_context_save(styleContext);

    ScrollbarOrientation orientation = scrollbar->orientation();
    applyScrollbarStyleContextClasses(styleContext, orientation);

    guint flags = 0;
    if ((BackButtonStartPart == part && scrollbar->currentPos())
        || (BackButtonEndPart == part && scrollbar->currentPos())
        || (ForwardButtonEndPart == part && scrollbar->currentPos() != scrollbar->maximum())
        || (ForwardButtonStartPart == part && scrollbar->currentPos() != scrollbar->maximum())) {
        if (part == scrollbar->pressedPart())
            flags |= GTK_STATE_FLAG_ACTIVE;
        if (part == scrollbar->hoveredPart())
            flags |= GTK_STATE_FLAG_PRELIGHT;
    } else
        flags |= GTK_STATE_FLAG_INSENSITIVE;
    gtk_style_context_set_state(styleContext, static_cast<GtkStateFlags>(flags));

    gtk_style_context_add_class(styleContext, GTK_STYLE_CLASS_BUTTON);
    gtk_render_background(styleContext, context->platformContext()->cr(), rect.x(), rect.y(), rect.width(), rect.height());
    gtk_render_frame(styleContext, context->platformContext()->cr(), rect.x(), rect.y(), rect.width(), rect.height());

    gfloat arrowScaling;
    gtk_style_context_get_style(styleContext, "arrow-scaling", &arrowScaling, nullptr);

    double arrowSize = std::min(rect.width(), rect.height()) * arrowScaling;
    FloatPoint arrowPoint(
        rect.x() + (rect.width() - arrowSize) / 2,
        rect.y() + (rect.height() - arrowSize) / 2);

    if (flags & GTK_STATE_FLAG_ACTIVE) {
        gint arrowDisplacementX, arrowDisplacementY;
        gtk_style_context_get_style(styleContext, "arrow-displacement-x", &arrowDisplacementX, "arrow-displacement-y", &arrowDisplacementY, nullptr);
        arrowPoint.move(arrowDisplacementX, arrowDisplacementY);
    }

    gdouble angle;
    if (orientation == VerticalScrollbar)
        angle = (part == ForwardButtonEndPart || part == ForwardButtonStartPart) ? G_PI : 0;
    else
        angle = (part == ForwardButtonEndPart || part == ForwardButtonStartPart) ? G_PI / 2 : 3 * (G_PI / 2);

    gtk_render_arrow(styleContext, context->platformContext()->cr(), angle, arrowPoint.x(), arrowPoint.y(), arrowSize);

    gtk_style_context_restore(styleContext);
}
Example #2
0
/* When can_focus is true, GtkButton allocates larger size than requested *
 * and causes the panel image to grow indefinitely.                       *
 * This workaround compensates for this difference.                       *
 * Details in https://bugzilla.gnome.org/show_bug.cgi?id=698030           *
 */
static gint
xfce_panel_image_padding_correction (GtkWidget *widget)
{
  GtkWidget             *parent;
  GtkStyleContext       *context;
  gint                   focus_width;
  gint                   focus_pad;
  gint                   correction;

  parent = gtk_widget_get_parent (widget);
  if (parent != NULL &&
      GTK_IS_BUTTON (parent) &&
      !gtk_widget_get_can_focus (parent))
    {
      context = gtk_widget_get_style_context (parent);
      gtk_style_context_get_style (context,
                                   "focus-line-width", &focus_width,
                                   "focus-padding", &focus_pad,
                                   NULL);
      correction = (focus_width + focus_pad) * 2;
    }
  else
    {
      correction = 0;
    }

  return correction;
}
void ScrollbarThemeGtk::updateThemeProperties()
{
    gtk_style_context_get_style(
        gtkScrollbarStyleContext(),
        "min-slider-length", &m_minThumbLength,
        "slider-width", &m_thumbFatness,
        "trough-border", &m_troughBorderWidth,
        "stepper-size", &m_stepperSize,
        "stepper-spacing", &m_stepperSpacing,
        "trough-under-steppers", &m_troughUnderSteppers,
        "has-backward-stepper", &m_hasBackButtonStartPart,
        "has-forward-stepper", &m_hasForwardButtonEndPart,
        "has-secondary-backward-stepper", &m_hasBackButtonEndPart,
        "has-secondary-forward-stepper", &m_hasForwardButtonStartPart,
        nullptr);
    updateScrollbarsFrameThickness();
}
Example #4
0
static void
gtk_level_bar_get_min_block_size (GtkLevelBar *self,
                                  gint        *block_width,
                                  gint        *block_height)
{
  GtkWidget *widget = GTK_WIDGET (self);
  GtkStyleContext *context;
  GtkStateFlags state;
  GtkBorder border, tmp, tmp2;
  gint min_width, min_height;

  context = gtk_widget_get_style_context (widget);
  gtk_style_context_save_to_node (context, self->priv->block_node[0]);
  state = gtk_style_context_get_state (context);
  gtk_style_context_get_border (context, state, &border);
  gtk_style_context_get_padding (context, state, &tmp);
  gtk_style_context_get_margin (context, state, &tmp2);
  gtk_style_context_restore (context);

  gtk_style_context_get_style (context,
                               "min-block-width", &min_width,
                               "min-block-height", &min_height,
                               NULL);

  border.top += tmp.top;
  border.right += tmp.right;
  border.bottom += tmp.bottom;
  border.left += tmp.left;

  border.top += tmp2.top;
  border.right += tmp2.right;
  border.bottom += tmp2.bottom;
  border.left += tmp2.left;

  if (block_width)
    *block_width = MAX (border.left + border.right, min_width);
  if (block_height)
    *block_height = MAX (border.top + border.bottom, min_height);
}
Example #5
0
static void
gtk_level_bar_get_min_block_size (GtkLevelBar *self,
                                  gint        *block_width,
                                  gint        *block_height)
{
  GtkWidget *widget = GTK_WIDGET (self);
  GtkStyleContext *context = gtk_widget_get_style_context (widget);
  GtkStateFlags flags = gtk_widget_get_state_flags (widget);
  GtkBorder border, tmp, tmp2;
  gint min_width, min_height;

  gtk_style_context_save (context);
  gtk_style_context_add_class (context, STYLE_CLASS_FILL_BLOCK);
  gtk_style_context_get_border (context, flags, &border);
  gtk_style_context_get_padding (context, flags, &tmp);
  gtk_style_context_get_margin (context, flags, &tmp2);
  gtk_style_context_restore (context);

  gtk_style_context_get_style (context,
                               "min-block-width", &min_width,
                               "min-block-height", &min_height,
                               NULL);

  border.top += tmp.top;
  border.right += tmp.right;
  border.bottom += tmp.bottom;
  border.left += tmp.left;

  border.top += tmp2.top;
  border.right += tmp2.right;
  border.bottom += tmp2.bottom;
  border.left += tmp2.left;

  if (block_width)
    *block_width = MAX (border.left + border.right, min_width);
  if (block_height)
    *block_height = MAX (border.top + border.bottom, min_height);
}
Example #6
0
MetaTilePreview *
meta_tile_preview_new (int      screen_number,
                       gboolean composited)
{
  MetaTilePreview *preview;
  GdkScreen *screen;

  screen = gdk_display_get_screen (gdk_display_get_default (), screen_number);

  preview = g_new (MetaTilePreview, 1);

  preview->preview_window = gtk_window_new (GTK_WINDOW_POPUP);

  gtk_window_set_screen (GTK_WINDOW (preview->preview_window), screen);
  gtk_widget_set_app_paintable (preview->preview_window, TRUE);

  preview->preview_color = NULL;

  preview->tile_rect.x = preview->tile_rect.y = 0;
  preview->tile_rect.width = preview->tile_rect.height = 0;

  preview->has_alpha = composited &&
                       (gdk_screen_get_rgba_visual (screen) != NULL);

  if (preview->has_alpha)
    {
      GtkStyleContext *context;
      GtkWidgetPath *path;
      guchar selection_alpha = 0xFF;

      gtk_widget_set_visual (preview->preview_window,
                             gdk_screen_get_rgba_visual (screen));

      path = gtk_widget_path_new ();
      gtk_widget_path_append_type (path, GTK_TYPE_ICON_VIEW);

      context = gtk_style_context_new ();
      gtk_style_context_set_path (context, path);
      gtk_style_context_add_class (context,
                                   GTK_STYLE_CLASS_RUBBERBAND);

      gtk_widget_path_free (path);

      gtk_style_context_get (context, GTK_STATE_FLAG_SELECTED,
                             "background-color", &preview->preview_color,
                             NULL);

      /* The background-color for the .rubberband class should probably
       * contain the correct alpha value - unfortunately, at least for now
       * it doesn't. Hopefully the following workaround can be removed
       * when GtkIconView gets ported to GtkStyleContext.
       */
      gtk_style_context_get_style (context,
                                   "selection-box-alpha", &selection_alpha,
                                   NULL);
      preview->preview_color->alpha = (double)selection_alpha / 0xFF;

      g_object_unref (context);
    }

  /* We make an assumption that XCreateWindow will be the first operation
   * when calling gtk_widget_realize() (via gdk_window_new()), or that it
   * is at least "close enough".
   */
  preview->create_serial = XNextRequest (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
  gtk_widget_realize (preview->preview_window);
  g_signal_connect (preview->preview_window, "draw",
                    G_CALLBACK (meta_tile_preview_draw), preview);

  return preview;
}
static void
nemo_cell_renderer_disk_render (GtkCellRenderer       *cell,
                                cairo_t               *cr,
                                GtkWidget             *widget,
                                const GdkRectangle    *background_area,
                                const GdkRectangle    *cell_area,
                                GtkCellRendererState   flags)
{
    NemoCellRendererDisk *cellprogress = NEMO_CELL_RENDERER_DISK (cell);
    gint                        x, y, w;
    gint                        xpad, ypad;
    gint                        full;
    gboolean                    show = cellprogress->show_disk_full_percent;
    GtkStyleContext *context;

    if (show) {
        context = gtk_widget_get_style_context (widget);
        GdkColor *gdk_bg_color, *gdk_fg_color;
        GdkRGBA bg_color, fg_color;
        gint bar_width, bar_radius, bottom_padding, max_length;

        gtk_style_context_get_style (context,
                                     "disk-full-bg-color",       &gdk_bg_color,
                                     "disk-full-fg-color",       &gdk_fg_color,
                                     "disk-full-bar-width",      &bar_width,
                                     "disk-full-bar-radius",     &bar_radius,
                                     "disk-full-bottom-padding", &bottom_padding,
                                     "disk-full-max-length",     &max_length,
                                     NULL);

        if (gdk_bg_color) {
            convert_color (gdk_bg_color, &bg_color);
            gdk_color_free (gdk_bg_color);
        } else {
            use_default_color (&bg_color);
        }
        if (gdk_fg_color) {
            convert_color (gdk_fg_color, &fg_color);
            gdk_color_free (gdk_fg_color);
        } else {
            use_default_color (&fg_color);
        }

        gtk_cell_renderer_get_padding (cell, &xpad, &ypad);
        x = cell_area->x + xpad;
        y = cell_area->y + cell_area->height - bar_width - bottom_padding;
        w = cell_area->width - xpad * 2;
        w = w < max_length ? w : max_length;
        full = (int) (((float) cellprogress->disk_full_percent / 100.0) * (float) w);

        gtk_style_context_save (context);

        cairo_save (cr);

        gdk_cairo_set_source_rgba (cr, &bg_color);
        cairo_rectangle_with_radius_corners (cr, x, y, w, bar_width, bar_radius);
        cairo_fill (cr);

        cairo_restore (cr);
        cairo_save (cr);

        gdk_cairo_set_source_rgba (cr, &fg_color);
        cairo_rectangle_with_radius_corners (cr, x, y, full, bar_width, bar_radius);
        cairo_fill (cr);

        cairo_restore (cr);

        gtk_style_context_restore (context);
    }

    GTK_CELL_RENDERER_CLASS (parent_class)->render (cell,
                                                    cr,
                                                    widget,
                                                    background_area,
                                                    cell_area,
                                                    flags);
}
Example #8
0
static void update_icon(ShowDesktopData* sdd)
{
    GtkStyleContext *context;
    GtkStateFlags    state;
    GtkBorder        padding;
    int width, height;
    GdkPixbuf* icon;
    GdkPixbuf* scaled;
    int icon_size;
    GError* error;
#if !GTK_CHECK_VERSION (3, 20, 0)
    int focus_width = 0;
    int focus_pad = 0;
#endif
    int thickness = 0;

    if (!sdd->icon_theme)
        return;

    state = gtk_widget_get_state_flags (sdd->button);
    context = gtk_widget_get_style_context (sdd->button);
    gtk_style_context_get_padding (context, state, &padding);
#if !GTK_CHECK_VERSION (3, 20, 0)
    gtk_style_context_get_style (context,
                                 "focus-line-width", &focus_width,
                                 "focus-padding", &focus_pad,
                                 NULL);
#endif

    switch (sdd->orient) {
    case GTK_ORIENTATION_HORIZONTAL:
        thickness = padding.top + padding.bottom;
        break;
    case GTK_ORIENTATION_VERTICAL:
        thickness = padding.left + padding.right;
        break;
    }
#if GTK_CHECK_VERSION (3, 20, 0)
    icon_size = sdd->size - thickness;
#else
    icon_size = sdd->size - 2 * (focus_width + focus_pad) - thickness;
#endif

    if (icon_size < 22)
        icon_size = 16;
    else if (icon_size < 32)
        icon_size = 22;
    else if (icon_size < 48)
        icon_size = 32;

    error = NULL;
    icon = gtk_icon_theme_load_icon (sdd->icon_theme, SHOW_DESKTOP_ICON, icon_size, 0, &error);

    if (icon == NULL)
    {
        g_printerr(_("Failed to load %s: %s\n"), SHOW_DESKTOP_ICON, error ? error->message : _("Icon not found"));

        if (error)
        {
            g_error_free(error);
            error = NULL;
        }

        gtk_image_set_from_icon_name (GTK_IMAGE (sdd->image), "image-missing", GTK_ICON_SIZE_SMALL_TOOLBAR);
        return;
    }

    width = gdk_pixbuf_get_width(icon);
    height = gdk_pixbuf_get_height(icon);

    scaled = NULL;

    /* Make it fit on the given panel */
    switch (sdd->orient)
    {
    case GTK_ORIENTATION_HORIZONTAL:
        width = (icon_size * width) / height;
        height = icon_size;
        break;
    case GTK_ORIENTATION_VERTICAL:
        height = (icon_size * height) / width;
        width = icon_size;
        break;
    }

    scaled = gdk_pixbuf_scale_simple(icon, width, height, GDK_INTERP_BILINEAR);

    if (scaled != NULL)
    {
        gtk_image_set_from_pixbuf(GTK_IMAGE(sdd->image), scaled);
        g_object_unref(scaled);
    }
    else
    {
        gtk_image_set_from_pixbuf (GTK_IMAGE (sdd->image), icon);
    }

    g_object_unref (icon);
}