int width, int height);
static void x_redraw_exposed_windows (Lisp_Object window, int x, int y,
int width, int height);
+static void x_clear_region (Lisp_Object window, face_index findex, int x,
+ int y, int width, int height);
static void x_output_eol_cursor (struct window *w, struct display_line *dl,
int xpos, face_index findex);
static void x_clear_frame (struct frame *f);
char_converter.reg[0] = XCHARSET_ID (charset);
char_converter.reg[1] = byte1;
char_converter.reg[2] = byte2;
- ccl_driver (&char_converter, 0, 0, 0, 0, CCL_MODE_ENCODING);
+ ccl_driver (&char_converter, 0, 0, 0, 0);
byte1 = char_converter.reg[1];
byte2 = char_converter.reg[2];
}
/* Clear in case a cursor was formerly here. */
int height = dl->ascent + dl->descent - dl->clip;
- redisplay_clear_region (window, findex, xpos, dl->ypos - dl->ascent,
+ x_clear_region (window, findex, xpos, dl->ypos - dl->ascent,
rb->width, height);
elt++;
}
case IMAGE_POINTER:
abort ();
- case IMAGE_WIDGET:
case IMAGE_SUBWINDOW:
- redisplay_output_subwindow (w, dl, instance, xpos,
- rb->object.dglyph.xoffset, start_pixpos,
- rb->width, findex, cursor_start,
- cursor_width, cursor_height);
+ /* #### implement me */
+ break;
case IMAGE_NOTHING:
/* nothing is as nothing does */
mask |= GCBackground;
}
- /* This special case comes from a request to draw text with a face which has
- the dim property. We'll use a stippled foreground GC. */
- if (EQ (bg_pmap, Qdim))
- {
- assert (DEVICE_X_GRAY_PIXMAP (d) != None);
-
- gcv.fill_style = FillStippled;
- gcv.stipple = DEVICE_X_GRAY_PIXMAP (d);
- mask |= (GCFillStyle | GCStipple);
- }
- else if (IMAGE_INSTANCEP (bg_pmap)
- && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
+ if (IMAGE_INSTANCEP (bg_pmap)
+ && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
{
if (XIMAGE_INSTANCE_PIXMAP_DEPTH (bg_pmap) == 0)
{
cachel = WINDOW_FACE_CACHEL (w, findex);
}
-#if defined(HAVE_XIM) && defined(XIM_XLIB)
+#ifdef HAVE_XIM
if (cursor && focus && (cursor_start == clip_start) && cursor_height)
- if (FRAME_X_XIC(f))
- XIM_SetSpotLocation (f, xpos - 2, dl->ypos + dl->descent - 2);
-#endif /* HAVE_XIM && XIM_XLIB */
+ XIM_SetSpotLocation (f, xpos - 2, dl->ypos + dl->descent - 2);
+#endif /* HAVE_XIM */
bg_pmap = cachel->background_pixmap;
if (!IMAGE_INSTANCEP (bg_pmap)
if (ypos1_line < ypos1_string)
{
- redisplay_clear_region (window, findex, clear_start, ypos1_line,
+ x_clear_region (window, findex, clear_start, ypos1_line,
clear_end - clear_start,
ypos1_string - ypos1_line);
}
if (ypos2_line > ypos2_string)
{
- redisplay_clear_region (window, findex, clear_start, ypos2_string,
+ x_clear_region (window, findex, clear_start, ypos2_string,
clear_end - clear_start,
ypos2_line - ypos2_string);
}
}
else
{
- redisplay_clear_region (window, findex, clear_start,
+ x_clear_region (window, findex, clear_start,
dl->ypos - dl->ascent, clear_end - clear_start,
height);
}
if (cursor && cursor_cachel && focus && NILP (bar_cursor_value))
gc = x_get_gc (d, font, cursor_cachel->foreground,
cursor_cachel->background, Qnil, Qnil);
- else if (cachel->dim)
- {
- /* Ensure the gray bitmap exists */
- if (DEVICE_X_GRAY_PIXMAP (d) == None)
- DEVICE_X_GRAY_PIXMAP (d) =
- XCreateBitmapFromData (dpy, x_win, (char *)gray_bits,
- gray_width, gray_height);
-
- /* Request a GC with the gray stipple pixmap to draw dimmed text */
- gc = x_get_gc (d, font, cachel->foreground, cachel->background,
- Qdim, Qnil);
- }
else
gc = x_get_gc (d, font, cachel->foreground, cachel->background,
Qnil, Qnil);
clear_width = width;
}
- redisplay_clear_region (window, findex, clear_x, clear_y,
+ x_clear_region (window, findex, clear_x, clear_y,
clear_width, clear_height);
}
unsigned long mask;
int x, y1, y2, width, shadow_thickness, spacing, line_width;
face_index div_face = get_builtin_face_cache_index (w, Vvertical_divider_face);
-
+
width = window_divider_width (w);
shadow_thickness = XINT (w->vertical_divider_shadow_thickness);
spacing = XINT (w->vertical_divider_spacing);
x = WINDOW_RIGHT (w) - width;
y1 = WINDOW_TOP (w);
y2 = WINDOW_BOTTOM (w);
-
+
memset (&gcv, ~0, sizeof (XGCValues));
-
+
tmp_pixel = WINDOW_FACE_CACHEL_BACKGROUND (w, div_face);
tmp_color = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (tmp_pixel));
-
+
/* First, get the GC's. */
top_shadow_pixel = tmp_color.pixel;
bottom_shadow_pixel = tmp_color.pixel;
background_pixel = tmp_color.pixel;
-
+
x_generate_shadow_pixels (f, &top_shadow_pixel, &bottom_shadow_pixel,
background_pixel, ef->core.background_pixel);
-
+
tmp_pixel = WINDOW_FACE_CACHEL_FOREGROUND (w, div_face);
tmp_color = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (tmp_pixel));
gcv.background = tmp_color.pixel;
mask = GCForeground | GCBackground | GCGraphicsExposures;
/* If we can't distinguish one of the shadows (the color is the same as the
- background), it's better to use a pixmap to generate a dithered gray. */
+ background), it's better to use a pixmap to generate a dithrered gray. */
if (top_shadow_pixel == background_pixel ||
bottom_shadow_pixel == background_pixel)
use_pixmap = 1;
-
+
if (use_pixmap)
{
if (DEVICE_X_GRAY_PIXMAP (d) == None)
XCreatePixmapFromBitmapData (dpy, x_win, (char *) gray_bits,
gray_width, gray_height, 1, 0, 1);
}
-
+
tmp_pixel = WINDOW_FACE_CACHEL_BACKGROUND (w, div_face);
tmp_color = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (tmp_pixel));
gcv.foreground = tmp_color.pixel;
gcv.stipple = DEVICE_X_GRAY_PIXMAP (d);
top_shadow_gc = gc_cache_lookup (DEVICE_X_GC_CACHE (d), &gcv,
(mask | GCStipple | GCFillStyle));
-
+
tmp_pixel = WINDOW_FACE_CACHEL_FOREGROUND (w, div_face);
tmp_color = COLOR_INSTANCE_X_COLOR (XCOLOR_INSTANCE (tmp_pixel));
bottom_shadow_pixel = tmp_color.pixel;
-
+
flip_gcs = (bottom_shadow_pixel ==
WhitePixelOfScreen (DefaultScreenOfDisplay (dpy)));
}
gcv.foreground = top_shadow_pixel;
top_shadow_gc = gc_cache_lookup (DEVICE_X_GC_CACHE (d), &gcv, mask);
}
-
+
gcv.foreground = bottom_shadow_pixel;
bottom_shadow_gc = gc_cache_lookup (DEVICE_X_GC_CACHE (d), &gcv, mask);
-
+
if (use_pixmap && flip_gcs)
{
GC tmp_gc = bottom_shadow_gc;
bottom_shadow_gc = top_shadow_gc;
top_shadow_gc = tmp_gc;
}
-
+
gcv.foreground = background_pixel;
background_gc = gc_cache_lookup (DEVICE_X_GC_CACHE (d), &gcv, mask);
-
+
/* possibly revert the GC's in case the shadow thickness is < 0.
This will give a depressed look to the divider */
if (shadow_thickness < 0)
temp = top_shadow_gc;
top_shadow_gc = bottom_shadow_gc;
bottom_shadow_gc = temp;
-
- /* better avoid a Bad Address XLib error ;-) */
+
+ /* better avoid a Bad Adress XLib error ;-) */
shadow_thickness = - shadow_thickness;
}
XClearArea (dpy, x_win, x, y1, width, y2 - y1, False);
/* Draw the divider line. */
- XFillRectangle (dpy, x_win, background_gc,
+ XFillRectangle (dpy, x_win, background_gc,
x + spacing + shadow_thickness, y1,
line_width, y2 - y1);
-
+
/* Draw the shadows around the divider line */
- x_output_shadows (f, x + spacing, y1,
+ x_output_shadows (f, x + spacing, y1,
width - 2 * spacing, y2 - y1,
top_shadow_gc, bottom_shadow_gc,
background_gc, shadow_thickness);
x_output_shadows
Draw a shadow around the given area using the given GC's. It is the
- callers responsibility to set the GC's appropriately.
+ callers responsibility to ste the GC's appropriately.
****************************************************************************/
void
x_output_shadows (struct frame *f, int x, int y, int width, int height,
XSETWINDOW (window, w);
if (window_is_leftmost (w))
- redisplay_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
+ x_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
ypos1, FRAME_BORDER_WIDTH (f), height);
if (bounds.left_in - bounds.left_out > 0)
- redisplay_clear_region (window,
+ x_clear_region (window,
get_builtin_face_cache_index (w, Vleft_margin_face),
bounds.left_out, ypos1,
bounds.left_in - bounds.left_out, height);
if (bounds.right_in - bounds.left_in > 0)
- redisplay_clear_region (window, DEFAULT_INDEX, bounds.left_in, ypos1,
+ x_clear_region (window, DEFAULT_INDEX, bounds.left_in, ypos1,
bounds.right_in - bounds.left_in, height);
if (bounds.right_out - bounds.right_in > 0)
- redisplay_clear_region (window,
+ x_clear_region (window,
get_builtin_face_cache_index (w, Vright_margin_face),
bounds.right_in, ypos1,
bounds.right_out - bounds.right_in, height);
if (window_is_rightmost (w))
- redisplay_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
+ x_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
ypos1, FRAME_BORDER_WIDTH (f), height);
}
}
given face.
****************************************************************************/
static void
-x_clear_region (Lisp_Object locale, struct device* d, struct frame* f, face_index findex,
- int x, int y,
- int width, int height, Lisp_Object fcolor, Lisp_Object bcolor,
- Lisp_Object background_pixmap)
+x_clear_region (Lisp_Object locale, face_index findex, int x, int y,
+ int width, int height)
{
+ struct window *w = NULL;
+ struct frame *f = NULL;
+ struct device *d;
+ Lisp_Object background_pixmap;
+
Display *dpy;
Window x_win;
- GC gc = NULL;
+ if (WINDOWP (locale))
+ {
+ w = XWINDOW (locale);
+ f = XFRAME (w->frame);
+ }
+ else if (FRAMEP (locale))
+ {
+ w = NULL;
+ f = XFRAME (locale);
+ }
+ else
+ abort ();
+
+ d = XDEVICE (f->device);
dpy = DEVICE_X_DISPLAY (d);
x_win = XtWindow (FRAME_X_TEXT_WIDGET (f));
- if (!UNBOUNDP (background_pixmap))
+ /* #### This function is going to have to be made cursor aware. */
+ if (width && height)
{
- gc = x_get_gc (d, Qnil, fcolor, bcolor, background_pixmap, Qnil);
- }
+ GC gc = NULL;
- if (gc)
- XFillRectangle (dpy, x_win, gc, x, y, width, height);
- else
- XClearArea (dpy, x_win, x, y, width, height, False);
+ /* #### This isn't quite right for when this function is called
+ from the toolbar code. */
+ background_pixmap = Qunbound;
+
+ /* Don't use a backing pixmap in the border area */
+ if (x >= FRAME_LEFT_BORDER_END (f)
+ && x < FRAME_RIGHT_BORDER_START (f)
+ && y >= FRAME_TOP_BORDER_END (f)
+ && y < FRAME_BOTTOM_BORDER_START (f))
+ {
+ Lisp_Object temp;
+
+ if (w)
+ {
+ temp = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, findex);
+
+ if (IMAGE_INSTANCEP (temp)
+ && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
+ {
+ /* #### maybe we could implement such that a string
+ can be a background pixmap? */
+ background_pixmap = temp;
+ }
+ }
+ else
+ {
+ temp = FACE_BACKGROUND_PIXMAP (Vdefault_face, locale);
+
+ if (IMAGE_INSTANCEP (temp)
+ && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (temp)))
+ {
+ background_pixmap = temp;
+ }
+ }
+
+ if (!UNBOUNDP (background_pixmap) &&
+ XIMAGE_INSTANCE_PIXMAP_DEPTH (background_pixmap) == 0)
+ {
+ Lisp_Object fcolor, bcolor;
+
+ if (w)
+ {
+ fcolor = WINDOW_FACE_CACHEL_FOREGROUND (w, findex);
+ bcolor = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
+ }
+ else
+ {
+ fcolor = FACE_FOREGROUND (Vdefault_face, locale);
+ bcolor = FACE_BACKGROUND (Vdefault_face, locale);
+ }
+
+ gc = x_get_gc (d, Qnil, fcolor, bcolor, background_pixmap, Qnil);
+ }
+ else
+ {
+ Lisp_Object color = (w ?
+ WINDOW_FACE_CACHEL_BACKGROUND (w, findex) :
+ FACE_BACKGROUND (Vdefault_face, locale));
+
+ if (UNBOUNDP (background_pixmap))
+ background_pixmap = Qnil;
+
+ gc = x_get_gc (d, Qnil, color, Qnil, background_pixmap, Qnil);
+ }
+ }
+
+ if (gc)
+ XFillRectangle (dpy, x_win, gc, x, y, width, height);
+ else
+ XClearArea (dpy, x_win, x, y, width, height, False);
+ }
}
/*****************************************************************************
int defheight, defascent;
XSETWINDOW (window, w);
- redisplay_clear_region (window, findex, x, y, width, height);
+ x_clear_region (window, findex, x, y, width, height);
if (NILP (w->text_cursor_visible_p))
return;
if (focus)
{
-#if defined(HAVE_XIM) && defined(XIM_XLIB)
- if (FRAME_X_XIC(f))
- XIM_SetSpotLocation (f, x - 2 , cursor_y + cursor_height - 2);
+#ifdef HAVE_XIM
+ XIM_SetSpotLocation (f, x - 2 , cursor_y + cursor_height - 2);
#endif /* HAVE_XIM */
if (NILP (bar_cursor_value))
projects / chise / xemacs-chise.git.1 / blobdiff