/* GTK - The GIMP Toolkit
* Copyright (C) 2016 Benjamin Otte <otte@gnome.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include "gtkwin32drawprivate.h"
typedef enum {
ICON_CLOSE,
ICON_MINIMIZE,
ICON_MAXIMIZE,
ICON_RESTORE
} Icon;
const guchar icon_close_pixels[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x0c, 0x06, 0x00, 0x00,
0x1c, 0x07, 0x00, 0x00,
0xb8, 0x03, 0x00, 0x00,
0xf0, 0x01, 0x00, 0x00,
0xe0, 0x00, 0x00, 0x00,
0xf0, 0x01, 0x00, 0x00,
0xb8, 0x03, 0x00, 0x00,
0x1c, 0x07, 0x00, 0x00,
0x0c, 0x06, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
const guchar icon_minimize_pixels[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xfc, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
const guchar icon_maximize_pixels[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xfe, 0x07, 0x00, 0x00,
0xfe, 0x07, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0x02, 0x04, 0x00, 0x00,
0xfe, 0x07, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
const guchar icon_restore_pixels[] = {
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xf8, 0x07, 0x00, 0x00,
0xf8, 0x07, 0x00, 0x00,
0x08, 0x04, 0x00, 0x00,
0x08, 0x04, 0x00, 0x00,
0xfe, 0x04, 0x00, 0x00,
0x82, 0x07, 0x00, 0x00,
0x82, 0x00, 0x00, 0x00,
0x82, 0x00, 0x00, 0x00,
0xfe, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
static struct {
int width;
int height;
gsize pixels_size;
const guchar *pixels;
} icon_masks[] = {
{ 13, 13, sizeof (icon_close_pixels), icon_close_pixels },
{ 13, 13, sizeof (icon_minimize_pixels), icon_minimize_pixels },
{ 13, 13, sizeof (icon_maximize_pixels), icon_maximize_pixels },
{ 13, 13, sizeof (icon_restore_pixels), icon_restore_pixels }
};
static void
mask_icon (cairo_t *cr,
Icon icon,
double x,
double y,
double width,
double height)
{
cairo_surface_t *surface;
surface = cairo_image_surface_create_for_data ((guchar *) icon_masks[icon].pixels,
CAIRO_FORMAT_A1,
icon_masks[icon].width,
icon_masks[icon].height,
icon_masks[icon].pixels_size / icon_masks[icon].height);
cairo_mask_surface (cr,
surface,
x + (width - icon_masks[icon].width) / 2,
y + (height - icon_masks[icon].height) / 2);
cairo_surface_destroy (surface);
}
static void
gtk_cairo_set_source_sys_color (cairo_t *cr,
gint id)
{
GdkRGBA rgba;
gtk_win32_get_sys_color (id, &rgba);
gdk_cairo_set_source_rgba (cr, &rgba);
}
static void
draw_outline (cairo_t *cr,
int top_color_id,
int bottom_color_id,
int x,
int y,
int width,
int height)
{
gtk_cairo_set_source_sys_color (cr, top_color_id);
cairo_rectangle (cr, x, y, width, 1);
cairo_rectangle (cr, x, y, 1, height);
cairo_fill (cr);
gtk_cairo_set_source_sys_color (cr, bottom_color_id);
cairo_rectangle (cr, x + width, y + height, -1, -height);
cairo_rectangle (cr, x + width, y + height, -width, -1);
cairo_fill (cr);
}
typedef enum {
EDGE_RAISED_OUTER = 1 << 0,
EDGE_SUNKEN_OUTER = 1 << 1,
EDGE_RAISED_INNER = 1 << 2,
EDGE_SUNKEN_INNER = 1 << 3,
EDGE_RAISED = (EDGE_RAISED_OUTER | EDGE_RAISED_INNER),
EDGE_SUNKEN = (EDGE_SUNKEN_OUTER | EDGE_SUNKEN_INNER),
EDGE_ETCHED = (EDGE_SUNKEN_OUTER | EDGE_RAISED_INNER),
EDGE_BUMP = (EDGE_RAISED_OUTER | EDGE_SUNKEN_INNER)
} GtkWin32Edge;
static void
draw_edge (cairo_t *cr,
GtkWin32Edge edge,
gboolean soft,
int x,
int y,
int width,
int height)
{
switch (edge & (EDGE_RAISED_OUTER | EDGE_SUNKEN_OUTER))
{
case EDGE_RAISED_OUTER:
draw_outline (cr,
soft ? GTK_WIN32_SYS_COLOR_BTNHIGHLIGHT : GTK_WIN32_SYS_COLOR_3DLIGHT,
GTK_WIN32_SYS_COLOR_3DDKSHADOW,
x, y, width, height);
break;
case EDGE_SUNKEN_OUTER:
draw_outline (cr,
soft ? GTK_WIN32_SYS_COLOR_3DDKSHADOW : GTK_WIN32_SYS_COLOR_BTNSHADOW,
GTK_WIN32_SYS_COLOR_BTNHIGHLIGHT,
x, y, width, height);
break;
case (EDGE_RAISED_OUTER | EDGE_SUNKEN_OUTER):
return;
default:
break;
}
x += 1;
y += 1;
width -= 2;
height -= 2;
switch (edge & (EDGE_RAISED_INNER | EDGE_SUNKEN_INNER))
{
case EDGE_RAISED_INNER:
draw_outline (cr,
soft ? GTK_WIN32_SYS_COLOR_3DLIGHT : GTK_WIN32_SYS_COLOR_BTNHIGHLIGHT,
GTK_WIN32_SYS_COLOR_BTNSHADOW,
x, y, width, height);
break;
case EDGE_SUNKEN_INNER:
draw_outline (cr,
soft ? GTK_WIN32_SYS_COLOR_BTNSHADOW : GTK_WIN32_SYS_COLOR_3DDKSHADOW,
GTK_WIN32_SYS_COLOR_3DLIGHT,
x, y, width, height);
break;
case (EDGE_RAISED_INNER | EDGE_SUNKEN_INNER):
return;
default:
break;
}
}
static void
draw_button (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, state == 3 ? EDGE_SUNKEN : EDGE_RAISED, TRUE, 0, 0, width, height);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 2, width - 4, height - 4);
cairo_fill (cr);
}
static void
draw_frame (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_ETCHED, FALSE, 0, 0, width, height);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 2, width - 4, height - 4);
cairo_fill (cr);
}
static void
draw_check (cairo_t *cr,
int part,
int state,
int width,
int height)
{
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNHIGHLIGHT);
cairo_set_line_width (cr, 1.0);
cairo_rectangle (cr, 0.5, 0.5, width - 1.0, height - 1.0);
cairo_stroke (cr);
}
static void
draw_radio (cairo_t *cr,
int part,
int state,
int width,
int height)
{
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNHIGHLIGHT);
cairo_set_line_width (cr, 1.0);
cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0 - 0.5, 0, G_PI * 2);
cairo_stroke (cr);
}
static void
draw_edit (cairo_t *cr,
int part,
int state,
int width,
int height)
{
int xborder = gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CXBORDER);
int yborder = gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CYBORDER);
cairo_rectangle (cr, 0, 0, width, height);
gtk_cairo_set_source_sys_color (cr, (state == 6 || state == 4) ? GTK_WIN32_SYS_COLOR_BTNFACE
: GTK_WIN32_SYS_COLOR_WINDOW);
cairo_fill_preserve (cr);
cairo_rectangle (cr, width - xborder, yborder,
- (width - 2 * xborder), height - 2 * yborder);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_WINDOWFRAME);
cairo_fill (cr);
}
static void
draw_edit_noborder (cairo_t *cr,
int part,
int state,
int width,
int height)
{
cairo_rectangle (cr, 0, 0, width, height);
gtk_cairo_set_source_sys_color (cr, (state == 6 || state == 4) ? GTK_WIN32_SYS_COLOR_BTNFACE
: GTK_WIN32_SYS_COLOR_WINDOW);
cairo_fill (cr);
}
static void
draw_window (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, 0, 0, width, height + 2);
gtk_cairo_set_source_sys_color (cr, state == 2 ? GTK_WIN32_SYS_COLOR_INACTIVECAPTION
: GTK_WIN32_SYS_COLOR_ACTIVECAPTION);
cairo_rectangle (cr, 2, 2, width - 4, height - 2);
cairo_fill (cr);
}
static void
draw_window_left (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, 0, -2, width + 2, height + 4);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 0, width - 2, height);
cairo_fill (cr);
}
static void
draw_window_right (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, -2, -2, width + 2, height + 4);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 0, 0, width - 2, height);
cairo_fill (cr);
}
static void
draw_window_bottom (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, 0, -2, width, height + 2);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 0, width - 4, height - 2);
cairo_fill (cr);
}
static void
draw_window_button (cairo_t *cr,
int part,
int state,
int width,
int height)
{
Icon icon;
switch (part)
{
case 15: /* minimize */
icon = ICON_MINIMIZE;
break;
case 17: /* maximize */
icon = ICON_MAXIMIZE;
break;
default:
g_assert_not_reached ();
case 18: /* close */
icon = ICON_CLOSE;
break;
case 21: /* restore */
icon = ICON_RESTORE;
break;
}
draw_button (cr, 0, state, width, height);
gtk_cairo_set_source_sys_color (cr, state == 4 ? GTK_WIN32_SYS_COLOR_BTNSHADOW
: GTK_WIN32_SYS_COLOR_BTNTEXT);
mask_icon (cr, icon, 1, 1, width - 2, height - 2);
}
static void
draw_tab_item (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, 0, 0, width, height + 2);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 2, width - 4, height - 2);
cairo_fill (cr);
}
static void
draw_tab_pane (cairo_t *cr,
int part,
int state,
int width,
int height)
{
draw_edge (cr, EDGE_RAISED, TRUE, 0, 0, width, height);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_BTNFACE);
cairo_rectangle (cr, 2, 2, width - 4, height - 4);
cairo_fill (cr);
}
static void
draw_tooltip (cairo_t *cr,
int part,
int state,
int width,
int height)
{
int xborder = gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CXDLGFRAME) -
gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CXEDGE);
int yborder = gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CYDLGFRAME) -
gtk_win32_get_sys_metric (GTK_WIN32_SYS_METRIC_CYEDGE);
cairo_rectangle (cr, 0, 0, width, height);
cairo_rectangle (cr, width - xborder, yborder,
- (width - 2 * xborder), height - 2 * yborder);
gtk_cairo_set_source_sys_color (cr, GTK_WIN32_SYS_COLOR_WINDOWFRAME);
cairo_fill (cr);
}
typedef struct _GtkWin32ThemePart GtkWin32ThemePart;
struct _GtkWin32ThemePart {
const char *class_name;
gint part;
gint size;
GtkBorder margins;
void (* draw_func) (cairo_t *cr,
int part,
int state,
int width,
int height);
};
static GtkWin32ThemePart theme_parts[] = {
{ "button", 1, 0, { 3, 3, 3, 3 }, draw_button },
{ "button", 2, 13, { 0, 0, 0, 0 }, draw_radio },
{ "button", 3, 13, { 0, 0, 0, 0 }, draw_check },
{ "button", 4, 0, { 3, 3, 3, 3 }, draw_frame },
{ "edit", 1, 0, { 0, 0, 0, 0 }, draw_edit },
{ "edit", 3, 0, { 0, 0, 0, 0 }, draw_edit_noborder },
{ "edit", 6, 0, { 0, 0, 0, 0 }, draw_edit },
{ "edit", 7, 0, { 0, 0, 0, 0 }, draw_edit },
{ "edit", 8, 0, { 0, 0, 0, 0 }, draw_edit },
{ "edit", 9, 0, { 0, 0, 0, 0 }, draw_edit },
{ "tab", 1, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 2, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 3, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 4, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 5, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 6, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 7, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 8, 0, { 0, 0, 0, 0 }, draw_tab_item },
{ "tab", 9, 0, { 0, 0, 0, 0 }, draw_tab_pane },
{ "tooltip", 1, 0, { 0, 0, 0, 0 }, draw_tooltip },
{ "window", 1, 0, { 0, 0, 0, 0 }, draw_window },
{ "window", 7, 0, { 0, 0, 0, 0 }, draw_window_left },
{ "window", 8, 0, { 0, 0, 0, 0 }, draw_window_right },
{ "window", 9, 0, { 0, 0, 0, 0 }, draw_window_bottom },
{ "window", 15, 0, { 0, 0, 0, 0 }, draw_window_button },
{ "window", 17, 0, { 0, 0, 0, 0 }, draw_window_button },
{ "window", 18, 0, { 0, 0, 0, 0 }, draw_window_button },
{ "window", 21, 0, { 0, 0, 0, 0 }, draw_window_button }
};
static const GtkWin32ThemePart *
get_theme_part (const char *class_name,
gint part)
{
gsize i;
for (i = 0; i < G_N_ELEMENTS (theme_parts); i++)
{
if (g_str_equal (theme_parts[i].class_name, class_name) &&
theme_parts[i].part == part)
return &theme_parts[i];
}
return NULL;
}
void
gtk_win32_draw_theme_background (cairo_t *cr,
const char *class_name,
int part,
int state,
int width,
int height)
{
const GtkWin32ThemePart *theme_part;
theme_part = get_theme_part (class_name, part);
if (theme_part)
{
theme_part->draw_func (cr, part, state, width, height);
}
else
{
g_warning ("No fallback code to draw background for class \"%s\", part %d", class_name, part);
}
}
void
gtk_win32_get_theme_part_size (const char *class_name,
int part,
int state,
int *width,
int *height)
{
const GtkWin32ThemePart *theme_part;
theme_part = get_theme_part (class_name, part);
if (theme_part)
{
if (width)
*width = theme_part->size;
if (height)
*height = theme_part->size;
}
else
{
if (width)
*width = 1;
if (height)
*height = 1;
}
}
void
gtk_win32_get_theme_margins (const char *class_name,
int part,
int state,
GtkBorder *out_margins)
{
const GtkWin32ThemePart *theme_part;
theme_part = get_theme_part (class_name, part);
if (theme_part)
{
*out_margins = theme_part->margins;
}
else
{
out_margins->top = out_margins->bottom = out_margins->left = out_margins->right = 0;
}
}
static int
FIXME_IMPLEMENT (int id)
{
g_warning ("win32 sys metric %d not implemented", id);
return 0;
}
static struct {
const char *name;
int value;
int (* get_value) (int id);
} win32_default_metrics[] = {
{ "cxscreen", 0, FIXME_IMPLEMENT },
{ "cyscreen", 0, FIXME_IMPLEMENT },
{ "cxvscroll", 16, NULL },
{ "cyhscroll", 16, NULL },
{ "cycaption", 16, NULL },
{ "cxborder", 1, NULL },
{ "cyborder", 1, NULL },
{ "cxdlgframe", 3, NULL },
{ "cydlgframe", 3, NULL },
{ "cyvthumb", 16, NULL },
{ "cxhthumb", 16, NULL },
{ "cxicon", 32, NULL },
{ "cyicon", 32, NULL },
{ "cxcursor", 32, NULL },
{ "cycursor", 32, NULL },
{ "cymenu", 19, NULL },
{ "cxfullscreen", 0, FIXME_IMPLEMENT },
{ "cyfullscreen", 0, FIXME_IMPLEMENT },
{ "cykanjiwindow", 0, NULL },
{ "mousepresent", 1, NULL },
{ "cyvscroll", 16, NULL },
{ "cxhscroll", 16, NULL },
{ "debug", 0, NULL },
{ "swapbutton", 0, NULL },
{ "reserved1", 0, NULL },
{ "reserved2", 0, NULL },
{ "reserved3", 0, NULL },
{ "reserved4", 0, NULL },
{ "cxmin", 112, NULL },
{ "cymin", 24, NULL },
{ "cxsize", 18, NULL },
{ "cysize", 15, NULL },
{ "cxframe", 4, NULL },
{ "cyframe", 4, NULL },
{ "cxmintrack", 112, NULL },
{ "cymintrack", 24, NULL },
{ "cxdoubleclk", 0, FIXME_IMPLEMENT },
{ "cydoubleclk", 0, FIXME_IMPLEMENT },
{ "cxiconspacing", 75, NULL },
{ "cyiconspacing", 75, NULL },
{ "menudropalignment", 0, NULL },
{ "penwindows", 0, NULL },
{ "dbcsenabled", 1, NULL },
{ "cmousebuttons", 3, NULL },
{ "secure", 0, NULL },
{ "cxedge", 2, NULL },
{ "cyedge", 2, NULL },
{ "cxminspacing", 160, NULL },
{ "cyminspacing", 21, NULL },
{ "cxsmicon", 16, NULL },
{ "cysmicon", 16, NULL },
{ "cysmcaption", 16, NULL },
{ "cxsmsize", 15, NULL },
{ "cysmsize", 15, NULL },
{ "cxmenusize", 18, NULL },
{ "cymenusize", 18, NULL },
{ "arrange", 8, NULL },
{ "cxminimized", 160, NULL },
{ "cyminimized", 21, NULL },
{ "cxmaxtrack", 0, FIXME_IMPLEMENT },
{ "cymaxtrack", 0, FIXME_IMPLEMENT },
{ "cxmaximized", 0, FIXME_IMPLEMENT },
{ "cymaximized", 0, FIXME_IMPLEMENT },
{ "network", 3, NULL },
{ NULL, 0, NULL },
{ NULL, 0, NULL },
{ NULL, 0, NULL },
{ "cleanboot", 0, NULL },
{ "cxdrag", 4, NULL },
{ "cydrag", 4, NULL },
{ "showsounds", 0, NULL },
{ "cxmenucheck", 13, NULL },
{ "cymenucheck", 13, NULL },
{ "slowmachine", 0, NULL },
{ "mideastenabled", 0, NULL },
{ "mousewheelpresent", 1, NULL },
{ "xvirtualscreen", 0, FIXME_IMPLEMENT },
{ "yvirtualscreen", 0, FIXME_IMPLEMENT },
{ "cxvirtualscreen", 0, FIXME_IMPLEMENT },
{ "cyvirtualscreen", 0, FIXME_IMPLEMENT },
{ "cmonitors", 0, FIXME_IMPLEMENT },
{ "samedisplayformat", 1, NULL },
{ "immenabled", 1, NULL },
{ "cxfocusborder", 1, NULL },
{ "cyfocusborder", 1, NULL },
{ NULL, 0, NULL },
{ "tabletpc", 0, NULL },
{ "mediacenter", 0, NULL },
{ "starter", 0, NULL },
{ "serverr2", 0, NULL },
{ "cmetrics", 90, NULL },
{ "mousehorizontalwheelpresent", 0, NULL },
{ "cxpaddedborder", 0, NULL }
};
const char *
gtk_win32_get_sys_metric_name_for_id (gint id)
{
if (id >= 0 && id < G_N_ELEMENTS (win32_default_metrics))
return win32_default_metrics[id].name;
else
return NULL;
}
int
gtk_win32_get_sys_metric_id_for_name (const char *name)
{
int i;
g_return_val_if_fail (name != NULL, -1);
for (i = 0; i < G_N_ELEMENTS (win32_default_metrics); i++)
{
if (win32_default_metrics[i].name == NULL)
continue;
if (g_str_equal (name, win32_default_metrics[i].name))
return i;
}
return -1;
}
int
gtk_win32_get_sys_metric (gint id)
{
if (id < 0 || id >= G_N_ELEMENTS (win32_default_metrics))
return 0;
if (win32_default_metrics[id].get_value)
return win32_default_metrics[id].get_value (id);
return win32_default_metrics[id].value;
}
static struct {
const char *name;
GdkRGBA rgba;
} win32_default_colors[] = {
#define RGB(r, g, b) { (r)/255.0, (g)/255.0, (b)/255., 1.0 }
{ "scrollbar", RGB(212, 208, 200) },
{ "background", RGB(58, 110, 165) },
{ "activecaption", RGB(10, 36, 106) },
{ "inactivecaption", RGB(128, 128, 128) },
{ "menu", RGB(212, 208, 200) },
{ "window", RGB(255, 255, 255) },
{ "windowframe", RGB(0, 0, 0) },
{ "menutext", RGB(0, 0, 0) },
{ "windowtext", RGB(0, 0, 0) },
{ "captiontext", RGB(255, 255, 255) },
{ "activeborder", RGB(212, 208, 200) },
{ "inactiveborder", RGB(212, 208, 200) },
{ "appworkspace", RGB(128, 128, 128) },
{ "highlight", RGB(10, 36, 106) },
{ "highlighttext", RGB(255, 255, 255) },
{ "btnface", RGB(212, 208, 200) },
{ "btnshadow", RGB(128, 128, 128) },
{ "graytext", RGB(128, 128, 128) },
{ "btntext", RGB(0, 0, 0) },
{ "inactivecaptiontext", RGB(212, 208, 200) },
{ "btnhighlight", RGB(255, 255, 255) },
{ "3ddkshadow", RGB(64, 64, 64) },
{ "3dlight", RGB(212, 208, 200) },
{ "infotext", RGB(0, 0, 0) },
{ "infobk", RGB(255, 255, 225) },
{ "alternatebtnface", RGB(181, 181, 181) },
{ "hotlight", RGB(0, 0, 200) },
{ "gradientactivecaption", RGB(166, 202, 240) },
{ "gradientinactivecaption", RGB(192, 192, 192) },
{ "menuhilight", RGB(10, 36, 106) },
{ "menubar", RGB(212, 208, 200) }
#undef RGB
};
const char *
gtk_win32_get_sys_color_name_for_id (gint id)
{
if (id >= 0 && id < G_N_ELEMENTS (win32_default_colors))
return win32_default_colors[id].name;
else
return NULL;
}
int
gtk_win32_get_sys_color_id_for_name (const char *name)
{
int i;
g_return_val_if_fail (name != NULL, -1);
for (i = 0; i < G_N_ELEMENTS (win32_default_colors); i++)
{
if (g_str_equal (name, win32_default_colors[i].name))
return i;
}
return -1;
}
void
gtk_win32_get_sys_color (gint id,
GdkRGBA *color)
{
if (id < 0 || id >= G_N_ELEMENTS (win32_default_colors))
{
gdk_rgba_parse (color, "black");
return;
}
*color = win32_default_colors[id].rgba;
}