msw_style.c

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

 * It doesn't work correctly when the scrollbar is squished
 * to the point we don't have room for full-sized steppers.
 */
static void
reverse_engineer_stepper_box (GtkWidget * range,
			      GtkArrowType arrow_type,
			      gint * x, gint * y, gint * width, gint * height)
{
    gint slider_width = 14, stepper_size = 14;
    gint box_width;
    gint box_height;

    if (range)
	{
	    gtk_widget_style_get (range,
				  "slider_width", &slider_width,
				  "stepper_size", &stepper_size, NULL);
	}

    if (arrow_type == GTK_ARROW_UP || arrow_type == GTK_ARROW_DOWN)
	{
	    box_width = slider_width;
	    box_height = stepper_size;
	}
    else
	{
	    box_width = stepper_size;
	    box_height = slider_width;
	}

    *x = *x - (box_width - *width) / 2;
    *y = *y - (box_height - *height) / 2;
    *width = box_width;
    *height = box_height;
}

static XpThemeElement
to_xp_arrow (GtkArrowType arrow_type)
{
    XpThemeElement xp_arrow;

    switch (arrow_type)
	{
	case GTK_ARROW_UP:
	    xp_arrow = XP_THEME_ELEMENT_ARROW_UP;
	    break;
	case GTK_ARROW_DOWN:
	    xp_arrow = XP_THEME_ELEMENT_ARROW_DOWN;
	    break;
	case GTK_ARROW_LEFT:
	    xp_arrow = XP_THEME_ELEMENT_ARROW_LEFT;
	    break;
	default:
	    xp_arrow = XP_THEME_ELEMENT_ARROW_RIGHT;
	    break;
	}

    return xp_arrow;
}

static void
draw_arrow (GtkStyle * style,
	    GdkWindow * window,
	    GtkStateType state,
	    GtkShadowType shadow,
	    GdkRectangle * area,
	    GtkWidget * widget,
	    const gchar * detail,
	    GtkArrowType arrow_type,
	    gboolean fill, gint x, gint y, gint width, gint height)
{
    const gchar *name;
    HDC dc;
    RECT rect;

    name = gtk_widget_get_name (widget);

    sanitize_size (window, &width, &height);

    if (GTK_IS_ARROW(widget) && is_combo_box_child(widget))
        {
	    if (combo_box_draw_arrow (style, window, state, area, widget))
		{
		    return;
		}
        }

    if (detail && strcmp (detail, "spinbutton") == 0)
	{
	    if (xp_theme_is_drawable (XP_THEME_ELEMENT_SPIN_BUTTON_UP))
		{
		    return;
		}

            width -= 2;
            --height;
            if( arrow_type == GTK_ARROW_DOWN )
                ++y;
	    ++x;

            if( state == GTK_STATE_ACTIVE ) {
                ++x;
                ++y;
		}
	    draw_varrow (window, style->fg_gc[state], shadow, area,
			 arrow_type, x, y, width, height);
            return;
	}
    else if (detail && (!strcmp (detail, "vscrollbar")
			|| !strcmp (detail, "hscrollbar")))
	{
	    gboolean is_disabled = FALSE;
            UINT btn_type = 0;
	    GtkScrollbar *scrollbar = GTK_SCROLLBAR (widget);

	    gint box_x = x;
	    gint box_y = y;
	    gint box_width = width;
	    gint box_height = height;

	    reverse_engineer_stepper_box (widget, arrow_type,
					  &box_x, &box_y, &box_width,
					  &box_height);

	    if (scrollbar->range.adjustment->page_size >=
		(scrollbar->range.adjustment->upper -
		 scrollbar->range.adjustment->lower))
		is_disabled = TRUE;

	    if (xp_theme_draw
		(window, to_xp_arrow (arrow_type), style, box_x, box_y,
		 box_width, box_height, state, area))
		{
		}
	    else
		{
                switch (arrow_type)
                {
                case GTK_ARROW_UP:
                    btn_type = DFCS_SCROLLUP;
                    break;
                case GTK_ARROW_DOWN:
                    btn_type = DFCS_SCROLLDOWN;
                    break;
                case GTK_ARROW_LEFT:
                    btn_type = DFCS_SCROLLLEFT;
                    break;
                case GTK_ARROW_RIGHT:
                    btn_type = DFCS_SCROLLRIGHT;
                    break;
                case GTK_ARROW_NONE:
					break;
                }
                if( state == GTK_STATE_INSENSITIVE )
                    btn_type |= DFCS_INACTIVE;
                if( widget ) {
                    sanitize_size (window, &width, &height);

                    dc = get_window_dc( style, window, state, 
                                        box_x, box_y, box_width, box_height, &rect );
                    DrawFrameControl( dc, &rect, DFC_SCROLL, 
                        btn_type|(shadow == GTK_SHADOW_IN ? (DFCS_PUSHED|DFCS_FLAT) : 0) );
                    release_window_dc( style, window, state );
                }
		}
	}
    else
	{
	    /* draw the toolbar chevrons - waiting for GTK 2.4 */
	    if (name && !strcmp (name, "gtk-toolbar-arrow"))
		{
		    if (xp_theme_draw
			(window, XP_THEME_ELEMENT_REBAR_CHEVRON, style, x, y,
			 width, height, state, area))
			return;
		}
	    /* probably a gtk combo box on a toolbar */
	    else if (0		/* widget->parent && GTK_IS_BUTTON
				   (widget->parent) */ )
		{
		    if (xp_theme_draw
			(window, XP_THEME_ELEMENT_COMBOBUTTON, style, x - 3,
			 widget->allocation.y + 1, width + 5,
			 widget->allocation.height - 4, state, area))
			return;
		}

	    if (arrow_type == GTK_ARROW_UP || arrow_type == GTK_ARROW_DOWN)
		{
		    x += (width - 7) / 2;
		    y += (height - 5) / 2;

		    draw_varrow (window, style->fg_gc[state], shadow, area,
				 arrow_type, x, y, 7, 5);
		}
	    else
		{
		    x += (width - 5) / 2;
		    y += (height - 7) / 2;

		    draw_harrow (window, style->fg_gc[state], shadow, area,
				 arrow_type, x, y, 5, 7);
		}
	}
}

static void
option_menu_get_props (GtkWidget * widget,
		       GtkRequisition * indicator_size,
		       GtkBorder * indicator_spacing)
{
    GtkRequisition *tmp_size = NULL;
    GtkBorder *tmp_spacing = NULL;

    if (widget)
	gtk_widget_style_get (widget,
			      "indicator_size", &tmp_size,
			      "indicator_spacing", &tmp_spacing, NULL);

    if (tmp_size)
	{
	    *indicator_size = *tmp_size;
	    gtk_requisition_free (tmp_size);
	}
    else
	*indicator_size = default_option_indicator_size;

    if (tmp_spacing)
	{
	    *indicator_spacing = *tmp_spacing;
	    gtk_border_free (tmp_spacing);
	}
    else
	*indicator_spacing = default_option_indicator_spacing;
}

static gboolean
is_toolbar_child (GtkWidget * wid)
{
    while (wid)
	{
	    if (GTK_IS_TOOLBAR (wid) || GTK_IS_HANDLE_BOX (wid))
		return TRUE;
	    else
		wid = wid->parent;
	}

    return FALSE;
}

static gboolean
is_menu_tool_button_child (GtkWidget * wid)
{
    while (wid)
	{
	    if (GTK_IS_MENU_TOOL_BUTTON (wid) )
		return TRUE;
	    else
		wid = wid->parent;
	}
    return FALSE;
}

HDC get_window_dc(GtkStyle * style, GdkWindow * window, GtkStateType state_type, gint x, gint y, gint width, gint height, RECT *rect)
{
	int xoff, yoff;
	GdkDrawable *drawable;

	if (!GDK_IS_WINDOW (window))
		{
		    xoff = 0;
		    yoff = 0;
		    drawable = window;
		}
	else
		{
		    gdk_window_get_internal_paint_info (window, &drawable, &xoff, &yoff);
		}

	rect->left = x - xoff;
	rect->top = y - yoff;
	rect->right = rect->left + width;
    rect->bottom = rect->top + height;

	return gdk_win32_hdc_get (drawable, style->dark_gc[state_type], 0);
}

void release_window_dc(GtkStyle * style, GdkWindow * window, GtkStateType state_type)
{
	GdkDrawable *drawable;

	if (!GDK_IS_WINDOW (window))
		{
		    drawable = window;
		}
	else
		{
		    gdk_window_get_internal_paint_info (window, &drawable, NULL, NULL);
		}

	gdk_win32_hdc_release (drawable, style->dark_gc[state_type], 0);
}

static HPEN get_light_pen()
{
    if( ! g_light_pen ) {
    	g_light_pen = CreatePen( PS_SOLID|PS_INSIDEFRAME, 1, GetSysColor(COLOR_BTNHIGHLIGHT) );
    }
    return g_light_pen;
}

static HPEN get_dark_pen()
{
    if( ! g_dark_pen ) {
    	g_dark_pen = CreatePen( PS_SOLID|PS_INSIDEFRAME, 1, GetSysColor(COLOR_BTNSHADOW) );
    }
    return g_dark_pen;
}

static void
draw_3d_border( HDC hdc, RECT* rc, gboolean sunken )
{
    HPEN pen1, pen2;
    HGDIOBJ old_pen;

    if( sunken ){
        pen1 = get_dark_pen();
        pen2 = get_light_pen();
    }
    else{
        pen1 = get_light_pen();
        pen2 = get_dark_pen();
    }

    MoveToEx( hdc, rc->left, rc->bottom - 1, NULL);

    old_pen = SelectObject( hdc, pen1 );
    LineTo( hdc, rc->left, rc->top );
    LineTo( hdc, rc->right-1, rc->top );
    SelectObject( hdc, old_pen );

    old_pen = SelectObject( hdc, pen2 );
    LineTo( hdc, rc->right-1, rc->bottom-1 );
    LineTo( hdc, rc->left, rc->bottom-1 );
    SelectObject( hdc, old_pen );
}

static gboolean 
draw_menu_item(GdkWindow* window, GtkWidget* widget, GtkStyle* style, 
               gint x, gint y, gint width, gint height, 
               GtkStateType state_type, GdkRectangle* area )
{
    GtkWidget* parent;
    GtkMenuShell* bar;
    HDC dc;
    RECT rect;

    if( (parent = gtk_widget_get_parent(widget))
        && GTK_IS_MENU_BAR(parent)
        && !xp_theme_is_active() )
    {
        bar = GTK_MENU_SHELL(parent);

        dc = get_window_dc( style, window, state_type, x, y, width, height, &rect );
        if( state_type == GTK_STATE_PRELIGHT ){
            draw_3d_border( dc, &rect, bar->active );
        }
        release_window_dc( style, window, state_type );
        return TRUE;
    }
    return FALSE;
}

static HBRUSH
get_dither_brush( void )
{
    WORD pattern[8];
    HBITMAP pattern_bmp;
    int i;

    if( g_dither_brush )
        return g_dither_brush;
    for ( i = 0; i < 8; i++ )
        pattern[i] = (WORD)(0x5555 << (i & 1));
    pattern_bmp = CreateBitmap(8, 8, 1, 1, &pattern);
    if (pattern_bmp) {
        g_dither_brush = CreatePatternBrush(pattern_bmp);
        DeleteObject(pattern_bmp);
    }
    return g_dither_brush;
}

static gboolean 
draw_tool_button(GdkWindow* window, GtkWidget* widget, GtkStyle* style, 
                 gint x, gint y, gint width, gint height, 
                 GtkStateType state_type, GdkRectangle* area )
{
    HDC dc;
    RECT rect;
    gboolean is_toggled = FALSE;

    if ( xp_theme_is_active() ) {
		return (xp_theme_draw (window, XP_THEME_ELEMENT_TOOLBAR_BUTTON, style,
                               x, y, width, height, state_type, area) );
    }

    if( GTK_IS_TOGGLE_BUTTON(widget) ){
        if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) ) {
            is_toggled = TRUE;
        }
    }

    if( state_type != GTK_STATE_PRELIGHT
        && state_type != GTK_STATE_ACTIVE && !is_toggled )
        return FALSE;

    dc = get_window_dc( style, window, state_type, x, y, width, height, &rect );
    if( state_type == GTK_STATE_PRELIGHT ){
        if( is_toggled ) {
            FillRect( dc, &rect, GetSysColorBrush(COLOR_BTNFACE));
        }
        draw_3d_border( dc, &rect, is_toggled);
    }
    else if ( state_type == GTK_STATE_ACTIVE ){
        if( is_toggled && ! is_menu_tool_button_child(widget->parent) ){
	    SetTextColor( dc, GetSysColor(COLOR_3DHILIGHT) );
	    SetBkColor( dc, GetSysColor(COLOR_BTNFACE) );
            FillRect( dc, &rect, get_dither_brush() );
        }
        draw_3d_border( dc, &rect, TRUE );
    }
    release_window_dc( style, window, state_type );
    return TRUE;
}

static void
draw_push_button( GdkWindow* window, GtkWidget* widget, GtkStyle* style, gint x, gint y,
		  gint width, gint height, 
		  GtkStateType state_type, gboolean is_default )
{
	HDC dc;
	RECT rect;

	dc = get_window_dc( style, window, state_type, 
			x, y, width, height, &rect );
        if( GTK_IS_TOGGLE_BUTTON(widget) )  {
            if( state_type == GTK_STATE_PRELIGHT &&
                gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)) )
            {
                state_type = GTK_STATE_ACTIVE;
            }
        }

	if( state_type == GTK_STATE_ACTIVE ) {
            if( GTK_IS_TOGGLE_BUTTON(widget) ) {
                DrawEdge( dc, &rect, EDGE_SUNKEN, BF_RECT|BF_ADJUST);
                SetTextColor( dc, GetSysColor(COLOR_3DHILIGHT) );
                SetBkColor( dc, GetSysColor(COLOR_BTNFACE) );
                FillRect( dc, &rect, get_dither_brush() );
            }
            else {
                FrameRect( dc, &rect, GetSysColorBrush(COLOR_WINDOWFRAME) );