static void gtk_plot_gdk_draw_pixmap (GtkPlotPC *pc,
GdkPixmap *pixmap,
GdkBitmap *mask,
gint xsrc, gint ysrc,
gint xdest, gint ydest,
gint width,
gint height,
gdouble scale_x,
gdouble scale_y)
{
GdkGC *gc;
GdkPixmap *new_pixmap;
GdkBitmap *new_mask = NULL;
if(!GTK_PLOT_GDK(pc)->drawable) return;
if(!GTK_PLOT_GDK(pc)->window) return;
if(!GTK_PLOT_GDK(pc)->gc) return;
gc = GTK_PLOT_GDK(pc)->gc;
if(!gc) return;
new_pixmap = scale_pixmap(GTK_PLOT_GDK(pc)->window, pixmap, scale_x, scale_y);
if(mask)
new_mask = scale_bitmap(GTK_PLOT_GDK(pc)->window, mask, scale_x, scale_y);
gtk_plot_pc_clip_mask(pc, xdest, ydest, new_mask);
gdk_draw_pixmap(GTK_PLOT_GDK(pc)->drawable, gc, new_pixmap,
xsrc, ysrc, xdest, ydest, width*scale_x, height*scale_y);
gtk_plot_pc_clip_mask(pc, xdest, ydest, NULL);
if(new_mask) gdk_bitmap_unref(new_mask);
gdk_pixmap_unref(new_pixmap);
}
/*
* XTerm escape sequences: ESC ] Ps;Pt BEL
* 0 = change iconName/title
* 1 = change iconName
* 2 = change title
* 46 = change logfile (not implemented)
* 50 = change font
*
* rxvt extensions:
* 10 = menu
* 20 = bg pixmap
* 39 = change default fg color
* 49 = change default bg color
*/
void
xterm_seq (int op, char *str)
{
int changed = 0;
assert (str != NULL);
switch (op)
{
case XTerm_name:
set_title (str); /* drop */
case XTerm_iconName:
set_iconName (str);
break;
case XTerm_title:
set_title (str);
break;
case XTerm_Menu:
menubar_dispatch (str);
break;
case XTerm_Pixmap:
#ifdef XPM_BACKGROUND
if (*str != ';')
set_bgPixmap (str);
while ((str = strchr (str, ';')) != NULL)
{
str++;
changed += scale_pixmap (str);
}
if (changed)
{
resize_pixmap ();
scr_touch ();
}
#endif /* XPM_BACKGROUND */
break;
case XTerm_restoreFG:
set_window_color (fgColor, str);
break;
case XTerm_restoreBG:
set_window_color (bgColor, str);
break;
case XTerm_logfile:
break;
case XTerm_font:
change_font (0, str);
break;
}
}
static void
set_content_size (grub_gfxmenu_box_t self,
int width, int height)
{
self->content_width = width;
self->content_height = height;
/* Resize sides to match the width and height. */
/* It is assumed that the corners width/height match the adjacent sides. */
/* Resize N and S sides to match width. */
if (scale_pixmap(self, BOX_PIXMAP_N, width, -1) != GRUB_ERR_NONE)
return;
if (scale_pixmap(self, BOX_PIXMAP_S, width, -1) != GRUB_ERR_NONE)
return;
/* Resize E and W sides to match height. */
if (scale_pixmap(self, BOX_PIXMAP_E, -1, height) != GRUB_ERR_NONE)
return;
if (scale_pixmap(self, BOX_PIXMAP_W, -1, height) != GRUB_ERR_NONE)
return;
/* Don't scale the corners--they are assumed to match the sides. */
if (scale_pixmap(self, BOX_PIXMAP_NW, -1, -1) != GRUB_ERR_NONE)
return;
if (scale_pixmap(self, BOX_PIXMAP_SW, -1, -1) != GRUB_ERR_NONE)
return;
if (scale_pixmap(self, BOX_PIXMAP_NE, -1, -1) != GRUB_ERR_NONE)
return;
if (scale_pixmap(self, BOX_PIXMAP_SE, -1, -1) != GRUB_ERR_NONE)
return;
/* Scale the center area. */
if (scale_pixmap(self, BOX_PIXMAP_CENTER, width, height) != GRUB_ERR_NONE)
return;
}
/*{{{ Create_Windows() - Open and map the window */
static void
Create_Windows (int argc, char *argv[])
{
Cursor cursor;
XClassHint classHint;
XWMHints wmHint;
int i, x, y, flags;
unsigned int width, height;
/*
* grab colors before netscape does
*/
for (i = 0;
i < (Xdepth <= 2 ? 2 : NRS_COLORS);
i++)
{
const char *const msg = "can't load color \"%s\"";
XColor xcol;
if (!rs_color[i])
continue;
if (!XParseColor (Xdisplay, Xcmap, rs_color[i], &xcol) ||
!XAllocColor (Xdisplay, Xcmap, &xcol))
{
print_error (msg, rs_color[i]);
rs_color[i] = def_colorName[i];
if (!rs_color[i])
continue;
if (!XParseColor (Xdisplay, Xcmap, rs_color[i], &xcol) ||
!XAllocColor (Xdisplay, Xcmap, &xcol))
{
print_error (msg, rs_color[i]);
switch (i)
{
case fgColor:
case bgColor:
/* fatal: need bg/fg color */
print_error ("aborting");
exit (EXIT_FAILURE);
break;
#ifndef NO_CURSORCOLOR
case cursorColor:
xcol.pixel = PixColors[bgColor];
break;
case cursorColor2:
xcol.pixel = PixColors[fgColor];
break;
#endif /* NO_CURSORCOLOR */
default:
xcol.pixel = PixColors[bgColor]; /* None */
break;
}
}
}
PixColors[i] = xcol.pixel;
}
#ifndef NO_CURSORCOLOR
if (Xdepth <= 2 || !rs_color[cursorColor])
PixColors[cursorColor] = PixColors[bgColor];
if (Xdepth <= 2 || !rs_color[cursorColor2])
PixColors[cursorColor2] = PixColors[fgColor];
#endif /* NO_CURSORCOLOR */
#ifndef NO_BOLDUNDERLINE
if (Xdepth <= 2 || !rs_color[colorBD])
PixColors[colorBD] = PixColors[fgColor];
if (Xdepth <= 2 || !rs_color[colorUL])
PixColors[colorUL] = PixColors[fgColor];
#endif /* NO_BOLDUNDERLINE */
/*
* get scrollBar/menuBar shadow colors
*
* The calculations of topShadow/bottomShadow values are adapted
* from the fvwm window manager.
*/
#ifndef XTERM_SCROLLBAR
if (Xdepth <= 2) /* Monochrome */
{
PixColors[scrollColor] = PixColors[bgColor];
PixColors[topShadowColor] = PixColors[fgColor];
PixColors[bottomShadowColor] = PixColors[fgColor];
}
else
{
XColor xcol, white;
/* bottomShadowColor */
xcol.pixel = PixColors[scrollColor];
XQueryColor (Xdisplay, Xcmap, &xcol);
xcol.red = ((xcol.red) / 2);
xcol.green = ((xcol.green) / 2);
xcol.blue = ((xcol.blue) / 2);
if (!XAllocColor (Xdisplay, Xcmap, &xcol))
{
print_error ("can't allocate %s", "bottomShadowColor");
xcol.pixel = PixColors[minColor];
}
PixColors[bottomShadowColor] = xcol.pixel;
/* topShadowColor */
white.pixel = WhitePixel (Xdisplay, Xscreen);
XQueryColor (Xdisplay, Xcmap, &white);
xcol.pixel = PixColors[scrollColor];
XQueryColor (Xdisplay, Xcmap, &xcol);
#ifndef min
#define min(a,b) (((a)<(b)) ? (a) : (b))
#define max(a,b) (((a)>(b)) ? (a) : (b))
#endif
xcol.red = max ((white.red / 5), xcol.red);
xcol.green = max ((white.green / 5), xcol.green);
xcol.blue = max ((white.blue / 5), xcol.blue);
xcol.red = min (white.red, (xcol.red * 7) / 5);
xcol.green = min (white.green, (xcol.green * 7) / 5);
xcol.blue = min (white.blue, (xcol.blue * 7) / 5);
if (!XAllocColor (Xdisplay, Xcmap, &xcol))
{
print_error ("can't allocate %s", "topShadowColor");
xcol.pixel = PixColors[whiteColor];
}
PixColors[topShadowColor] = xcol.pixel;
}
#endif /* XTERM_SCROLLBAR */
szHint.base_width = (2 * TermWin_internalBorder +
(Options & Opt_scrollBar ? SB_WIDTH : 0));
szHint.base_height = (2 * TermWin_internalBorder);
flags = (rs_geometry ?
XParseGeometry (rs_geometry, &x, &y, &width, &height) : 0);
if (flags & WidthValue)
{
szHint.width = width;
szHint.flags |= USSize;
}
if (flags & HeightValue)
{
szHint.height = height;
szHint.flags |= USSize;
}
TermWin.ncol = szHint.width;
TermWin.nrow = szHint.height;
change_font (1, NULL);
if (flags & XValue)
{
if (flags & XNegative)
{
x += (DisplayWidth (Xdisplay, Xscreen)
- (szHint.width + TermWin_internalBorder));
szHint.win_gravity = NorthEastGravity;
}
szHint.x = x;
szHint.flags |= USPosition;
}
if (flags & YValue)
{
if (flags & YNegative)
{
y += (DisplayHeight (Xdisplay, Xscreen)
- (szHint.height + TermWin_internalBorder));
szHint.win_gravity = (szHint.win_gravity == NorthEastGravity ?
SouthEastGravity : SouthWestGravity);
}
szHint.y = y;
szHint.flags |= USPosition;
}
/* parent window - reverse video so we can see placement errors
* sub-window placement & size in resize_subwindows()
*/
TermWin.parent = XCreateSimpleWindow (Xdisplay, Xroot,
szHint.x, szHint.y,
szHint.width, szHint.height,
BORDERWIDTH,
PixColors[bgColor],
PixColors[fgColor]);
xterm_seq (XTerm_title, rs_title);
xterm_seq (XTerm_iconName, rs_iconName);
/* ignore warning about discarded `const' */
classHint.res_name = rs_name;
classHint.res_class = APL_CLASS;
wmHint.input = True;
wmHint.initial_state = (Options & Opt_iconic ? IconicState : NormalState);
wmHint.flags = (InputHint | StateHint);
XSetWMProperties (Xdisplay, TermWin.parent, NULL, NULL, argv, argc,
&szHint, &wmHint, &classHint);
XSelectInput (Xdisplay, TermWin.parent,
(KeyPressMask | FocusChangeMask |
StructureNotifyMask | VisibilityChangeMask)
);
/* vt cursor: Black-on-White is standard, but this is more popular */
TermWin_cursor = XCreateFontCursor (Xdisplay, XC_xterm);
{
XColor fg, bg;
fg.pixel = PixColors[fgColor];
XQueryColor (Xdisplay, Xcmap, &fg);
bg.pixel = PixColors[bgColor];
XQueryColor (Xdisplay, Xcmap, &bg);
XRecolorCursor (Xdisplay, TermWin_cursor, &fg, &bg);
}
/* cursor (menuBar/scrollBar): Black-on-White */
cursor = XCreateFontCursor (Xdisplay, XC_left_ptr);
/* the vt window */
TermWin.vt = XCreateSimpleWindow (Xdisplay, TermWin.parent,
0, 0,
szHint.width, szHint.height,
0,
PixColors[fgColor],
PixColors[bgColor]);
XDefineCursor (Xdisplay, TermWin.vt, TermWin_cursor);
XSelectInput (Xdisplay, TermWin.vt,
(ExposureMask | ButtonPressMask | ButtonReleaseMask |
Button1MotionMask | Button3MotionMask));
XMapWindow (Xdisplay, TermWin.vt);
XMapWindow (Xdisplay, TermWin.parent);
/* scrollBar: size doesn't matter */
scrollBar.win = XCreateSimpleWindow (Xdisplay, TermWin.parent,
0, 0,
1, 1,
0,
PixColors[fgColor],
PixColors[bgColor]);
XDefineCursor (Xdisplay, scrollBar.win, cursor);
XSelectInput (Xdisplay, scrollBar.win,
(ExposureMask | ButtonPressMask | ButtonReleaseMask |
Button1MotionMask | Button2MotionMask | Button3MotionMask)
);
#ifndef NO_MENUBAR
/* menuBar: size doesn't matter */
menuBar.win = XCreateSimpleWindow (Xdisplay, TermWin.parent,
0, 0,
1, 1,
0,
PixColors[fgColor],
PixColors[scrollColor]);
XDefineCursor (Xdisplay, menuBar.win, cursor);
XSelectInput (Xdisplay, menuBar.win,
(ExposureMask | ButtonPressMask | ButtonReleaseMask |
Button1MotionMask)
);
#endif /* NO_MENUBAR */
#ifdef XPM_BACKGROUND
if (rs_backgroundPixmap != NULL)
{
char *p = rs_backgroundPixmap;
if ((p = strchr (p, ';')) != NULL)
{
p++;
scale_pixmap (p);
}
set_bgPixmap (rs_backgroundPixmap);
}
#endif /* XPM_BACKGROUND */
/* graphics context for the vt window */
{
XGCValues gcvalue;
gcvalue.font = TermWin.font->fid;
gcvalue.foreground = PixColors[fgColor];
gcvalue.background = PixColors[bgColor];
TermWin.gc = XCreateGC (Xdisplay, TermWin.vt,
GCForeground | GCBackground | GCFont,
&gcvalue);
}
}
