msw_style.c

This GTK+ version 2.12.3. GTK+ is a multi-platform toolkit for creating graphical user interfaces.

    sys_color_to_gtk_color (XP_THEME_CLASS_TEXT, COLOR_HIGHLIGHT,
			    &style->bg[GTK_STATE_SELECTED]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNFACE,
			    &style->bg[GTK_STATE_INSENSITIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNFACE,
			    &style->bg[GTK_STATE_ACTIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNFACE,
			    &style->bg[GTK_STATE_PRELIGHT]);

    /* Default base */
    sys_color_to_gtk_color (XP_THEME_CLASS_WINDOW, COLOR_WINDOW,
			    &style->base[GTK_STATE_NORMAL]);
    sys_color_to_gtk_color (XP_THEME_CLASS_TEXT, COLOR_HIGHLIGHT,
			    &style->base[GTK_STATE_SELECTED]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNFACE,
			    &style->base[GTK_STATE_INSENSITIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNFACE,
			    &style->base[GTK_STATE_ACTIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_WINDOW, COLOR_WINDOW,
			    &style->base[GTK_STATE_PRELIGHT]);

    /* Default text */
    sys_color_to_gtk_color (XP_THEME_CLASS_WINDOW, COLOR_WINDOWTEXT,
			    &style->text[GTK_STATE_NORMAL]);
    sys_color_to_gtk_color (XP_THEME_CLASS_TEXT, COLOR_HIGHLIGHTTEXT,
			    &style->text[GTK_STATE_SELECTED]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_GRAYTEXT,
			    &style->text[GTK_STATE_INSENSITIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNTEXT,
			    &style->text[GTK_STATE_ACTIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_WINDOW, COLOR_WINDOWTEXT,
			    &style->text[GTK_STATE_PRELIGHT]);

    /* Default foreground */
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNTEXT,
			    &style->fg[GTK_STATE_NORMAL]);
    sys_color_to_gtk_color (XP_THEME_CLASS_TEXT, COLOR_HIGHLIGHTTEXT,
			    &style->fg[GTK_STATE_SELECTED]);
    sys_color_to_gtk_color (XP_THEME_CLASS_TEXT, COLOR_GRAYTEXT,
			    &style->fg[GTK_STATE_INSENSITIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_BTNTEXT,
			    &style->fg[GTK_STATE_ACTIVE]);
    sys_color_to_gtk_color (XP_THEME_CLASS_WINDOW, COLOR_WINDOWTEXT,
			    &style->fg[GTK_STATE_PRELIGHT]);

    for (i = 0; i < 5; i++)
	{
	    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_3DSHADOW,
				    &style->dark[i]);
	    sys_color_to_gtk_color (XP_THEME_CLASS_BUTTON, COLOR_3DHILIGHT,
				    &style->light[i]);

	    style->mid[i].red =
		(style->light[i].red + style->dark[i].red) / 2;
	    style->mid[i].green =
		(style->light[i].green + style->dark[i].green) / 2;
	    style->mid[i].blue =
		(style->light[i].blue + style->dark[i].blue) / 2;

	    style->text_aa[i].red =
		(style->text[i].red + style->base[i].red) / 2;
	    style->text_aa[i].green =
		(style->text[i].green + style->base[i].green) / 2;
	    style->text_aa[i].blue =
		(style->text[i].blue + style->base[i].blue) / 2;
	}
}

static gboolean
sanitize_size (GdkWindow * window, gint * width, gint * height)
{
    gboolean set_bg = FALSE;

    if ((*width == -1) && (*height == -1))
	{
	    set_bg = GDK_IS_WINDOW (window);
	    gdk_drawable_get_size (window, width, height);
	}
    else if (*width == -1)
	gdk_drawable_get_size (window, width, NULL);
    else if (*height == -1)
	gdk_drawable_get_size (window, NULL, height);

    return set_bg;
}

static XpThemeElement
map_gtk_progress_bar_to_xp (GtkProgressBar * progress_bar, gboolean trough)
{
    XpThemeElement ret;

    switch (progress_bar->orientation)
	{
	case GTK_PROGRESS_LEFT_TO_RIGHT:
	case GTK_PROGRESS_RIGHT_TO_LEFT:
	    ret = trough
		? XP_THEME_ELEMENT_PROGRESS_TROUGH_H
		: XP_THEME_ELEMENT_PROGRESS_BAR_H;
	    break;
	default:
	    ret = trough
		? XP_THEME_ELEMENT_PROGRESS_TROUGH_V
		: XP_THEME_ELEMENT_PROGRESS_BAR_V;
	    break;
	}
    return ret;
}

static gboolean
is_combo_box_child (GtkWidget* w)
{
    GtkWidget* tmp;

    if (w == NULL)
	return FALSE;

    for (tmp = w->parent; tmp; tmp = tmp->parent)
	{
	    if (GTK_IS_COMBO_BOX(tmp))
		return TRUE;
	}

    return FALSE;
}

static gboolean
combo_box_draw_arrow (GtkStyle * style,
	    GdkWindow * window,
	    GtkStateType state,
	    GdkRectangle * area,
	    GtkWidget * widget)
{
    if (xp_theme_is_active ())
        return TRUE;

    if (widget && GTK_IS_TOGGLE_BUTTON(widget->parent) )
    {
	DWORD border;
        RECT rect;
        HDC dc;

        dc = get_window_dc( style, window, state, area->x, area->y, area->width, area->height, &rect );
	border = (GTK_TOGGLE_BUTTON(widget->parent)->active ? DFCS_PUSHED|DFCS_FLAT : 0);

        InflateRect( &rect, 1, 1 );
        DrawFrameControl (dc, &rect, DFC_SCROLL, DFCS_SCROLLDOWN | border);

        release_window_dc( style, window, state );
        return TRUE;
    }

    return FALSE;
}

static void
draw_part (GdkDrawable * drawable,
	   GdkGC * gc, GdkRectangle * area, gint x, gint y, Part part)
{
    if (area)
	gdk_gc_set_clip_rectangle (gc, area);

    if (!parts[part].bmap)
	parts[part].bmap = gdk_bitmap_create_from_data (drawable,
							parts[part].bits,
							PART_SIZE, PART_SIZE);

    gdk_gc_set_ts_origin (gc, x, y);
    gdk_gc_set_stipple (gc, parts[part].bmap);
    gdk_gc_set_fill (gc, GDK_STIPPLED);

    gdk_draw_rectangle (drawable, gc, TRUE, x, y, PART_SIZE, PART_SIZE);

    gdk_gc_set_fill (gc, GDK_SOLID);

    if (area)
	gdk_gc_set_clip_rectangle (gc, NULL);
}

static void
draw_check (GtkStyle * style,
	    GdkWindow * window,
	    GtkStateType state,
	    GtkShadowType shadow,
	    GdkRectangle * area,
	    GtkWidget * widget,
	    const gchar * detail, gint x, gint y, gint width, gint height)
{
    x -= (1 + PART_SIZE - width) / 2;
    y -= (1 + PART_SIZE - height) / 2;

    if (detail && strcmp (detail, "check") == 0)	/* Menu item */
	{
	    if (shadow == GTK_SHADOW_IN)
		{
		    draw_part (window, style->black_gc, area, x, y,
			       CHECK_TEXT);
		    draw_part (window, style->dark_gc[state], area, x, y,
			       CHECK_AA);
		}
	}
    else
	{
	  XpThemeElement theme_elt = XP_THEME_ELEMENT_CHECKBOX;
	  switch (shadow)
	    {
	    case GTK_SHADOW_ETCHED_IN:
	      theme_elt = XP_THEME_ELEMENT_INCONSISTENT_CHECKBOX;
	      break;

	    case GTK_SHADOW_IN:
	      theme_elt = XP_THEME_ELEMENT_PRESSED_CHECKBOX;
	      break;

	    default:
	      break;
	    }

	  if (!xp_theme_draw (window, theme_elt,
			      style, x, y, width, height, state, area))
		{
                    if( detail && !strcmp(detail, "cellcheck") )
                        state = GTK_STATE_NORMAL;

		    draw_part (window, style->black_gc, area, x, y,
			       CHECK_BLACK);
		    draw_part (window, style->dark_gc[state], area, x, y,
			       CHECK_DARK);
		    draw_part (window, style->mid_gc[state], area, x, y,
			       CHECK_MID);
		    draw_part (window, style->light_gc[state], area, x, y,
			       CHECK_LIGHT);
		    draw_part (window, style->base_gc[state], area, x, y,
			       CHECK_BASE);

		    if (shadow == GTK_SHADOW_IN)
			{
			    draw_part (window, style->text_gc[state], area, x,
				       y, CHECK_TEXT);
			    draw_part (window, style->text_aa_gc[state], area,
				       x, y, CHECK_AA);
			}
		    else if (shadow == GTK_SHADOW_ETCHED_IN)
		      {
			draw_part (window, style->text_gc[state], area, x, y, CHECK_INCONSISTENT);
			draw_part (window, style->text_aa_gc[state], area, x, y, CHECK_AA);
		      }
		}
	}
}

static void
draw_expander (GtkStyle * style,
	       GdkWindow * window,
	       GtkStateType state,
	       GdkRectangle * area,
	       GtkWidget * widget,
	       const gchar * detail,
	       gint x, gint y, GtkExpanderStyle expander_style)
{
    gint expander_size;
    gint expander_semi_size;
    XpThemeElement xp_expander;

    gtk_widget_style_get (widget, "expander_size", &expander_size, NULL);

    switch (expander_style)
	{
	case GTK_EXPANDER_COLLAPSED:
	case GTK_EXPANDER_SEMI_COLLAPSED:
	    xp_expander = XP_THEME_ELEMENT_TREEVIEW_EXPANDER_CLOSED;
	    break;
	default:
	    xp_expander = XP_THEME_ELEMENT_TREEVIEW_EXPANDER_OPENED;
	    break;
	}

    if ((expander_size % 2) == 0)
	expander_size--;

    if (expander_size > 2)
	expander_size -= 2;

    if (area)
	gdk_gc_set_clip_rectangle (style->fg_gc[state], area);

    expander_semi_size = expander_size / 2;
    x -= expander_semi_size;
    y -= expander_semi_size;

    if (!xp_theme_draw (window, xp_expander, style,
			x, y, expander_size, expander_size, state, area))
	{
        HDC dc;
        RECT rect;
        HPEN pen;
        HGDIOBJ old_pen;

        dc = get_window_dc( style, window, state, x, y, expander_size, expander_size, &rect );
        FrameRect( dc, &rect, GetSysColorBrush(COLOR_GRAYTEXT) );
        InflateRect( &rect, -1, -1 );
        FillRect( dc, &rect, GetSysColorBrush(state == GTK_STATE_INSENSITIVE ? COLOR_BTNFACE : COLOR_WINDOW) );

        InflateRect( &rect, -1, -1 );

        pen = CreatePen( PS_SOLID, 1, GetSysColor(COLOR_WINDOWTEXT) );
        old_pen = SelectObject( dc, pen );

        MoveToEx( dc, rect.left, rect.top - 2 + expander_semi_size, NULL );
        LineTo( dc, rect.right, rect.top - 2 + expander_semi_size );

        if( expander_style == GTK_EXPANDER_COLLAPSED ||
            expander_style == GTK_EXPANDER_SEMI_COLLAPSED )
        {
            MoveToEx( dc, rect.left - 2 + expander_semi_size, rect.top, NULL );
            LineTo( dc, rect.left - 2 + expander_semi_size, rect.bottom );
		}

        SelectObject( dc, old_pen );
	DeleteObject( pen );
        release_window_dc( style, window, state );
	}

    if (area)
	gdk_gc_set_clip_rectangle (style->fg_gc[state], NULL);
}

static void
draw_option (GtkStyle * style,
	     GdkWindow * window,
	     GtkStateType state,
	     GtkShadowType shadow,
	     GdkRectangle * area,
	     GtkWidget * widget,
	     const gchar * detail, gint x, gint y, gint width, gint height)
{
    x -= (1 + PART_SIZE - width) / 2;
    y -= (1 + PART_SIZE - height) / 2;

    if (detail && strcmp (detail, "option") == 0)	/* Menu item */
	{
	    if (shadow == GTK_SHADOW_IN)
		draw_part (window, style->fg_gc[state], area, x, y,
			   RADIO_TEXT);
	}
    else
	{
	    if (xp_theme_draw (window, shadow == GTK_SHADOW_IN
			       ? XP_THEME_ELEMENT_PRESSED_RADIO_BUTTON
			       : XP_THEME_ELEMENT_RADIO_BUTTON,
			       style, x, y, width, height, state, area))
		{
		}
	    else
		{
                    if( detail && !strcmp(detail, "cellradio") )
                        state = GTK_STATE_NORMAL;

		    draw_part (window, style->black_gc, area, x, y,
			       RADIO_BLACK);
		    draw_part (window, style->dark_gc[state], area, x, y,
			       RADIO_DARK);
		    draw_part (window, style->mid_gc[state], area, x, y,
			       RADIO_MID);
		    draw_part (window, style->light_gc[state], area, x, y,
			       RADIO_LIGHT);
		    draw_part (window, style->base_gc[state], area, x, y,
			       RADIO_BASE);

		    if (shadow == GTK_SHADOW_IN)
			draw_part (window, style->text_gc[state], area, x, y,
				   RADIO_TEXT);
		}
	}
}

static void
draw_varrow (GdkWindow * window,
	     GdkGC * gc,
	     GtkShadowType shadow_type,
	     GdkRectangle * area,
	     GtkArrowType arrow_type, gint x, gint y, gint width, gint height)
{
    gint steps, extra;
    gint y_start, y_increment;
    gint i;

    if (area)
	gdk_gc_set_clip_rectangle (gc, area);

    width = width + width % 2 - 1;	/* Force odd */
    steps = 1 + width / 2;
    extra = height - steps;

    if (arrow_type == GTK_ARROW_DOWN)
	{
	    y_start = y;
	    y_increment = 1;
	}
    else
	{
	    y_start = y + height - 1;
	    y_increment = -1;
	}

    for (i = extra; i < height; i++)
	{
	    gdk_draw_line (window, gc,
			   x + (i - extra), y_start + i * y_increment,
			   x + width - (i - extra) - 1,
			   y_start + i * y_increment);
	}

    if (area)
	gdk_gc_set_clip_rectangle (gc, NULL);
}

static void
draw_harrow (GdkWindow * window,
	     GdkGC * gc,
	     GtkShadowType shadow_type,
	     GdkRectangle * area,
	     GtkArrowType arrow_type, gint x, gint y, gint width, gint height)
{
    gint steps, extra;
    gint x_start, x_increment;
    gint i;

    if (area)
	gdk_gc_set_clip_rectangle (gc, area);

    height = height + height % 2 - 1;	/* Force odd */
    steps = 1 + height / 2;
    extra = width - steps;

    if (arrow_type == GTK_ARROW_RIGHT)
	{
	    x_start = x;
	    x_increment = 1;
	}
    else
	{
	    x_start = x + width - 1;
	    x_increment = -1;
	}

    for (i = extra; i < width; i++)
	{
	    gdk_draw_line (window, gc,
			   x_start + i * x_increment, y + (i - extra),
			   x_start + i * x_increment,
			   y + height - (i - extra) - 1);
	}


    if (area)
	gdk_gc_set_clip_rectangle (gc, NULL);
}

/* This function makes up for some brokeness in gtkrange.c
 * where we never get the full arrow of the stepper button
 * and the type of button in a single drawing function.
 *