#include "faces.h"
#include "frame.h"
#include "glyphs-msw.h"
-#include "gutter.h"
#include "redisplay.h"
#include "sysdep.h"
#include "window.h"
#define MSWINDOWS_EOL_CURSOR_WIDTH 5
/*
- * Random forward declarations
+ * Random forward delarations
*/
static void mswindows_update_dc (HDC hdc, Lisp_Object font, Lisp_Object fg,
Lisp_Object bg, Lisp_Object bg_pmap);
+static void mswindows_clear_region (Lisp_Object locale, face_index findex,
+ int x, int y, int width, int height);
static void mswindows_output_vertical_divider (struct window *w, int clear);
static void mswindows_redraw_exposed_windows (Lisp_Object window, int x,
int y, int width, int height);
face_index findex, int cursor_start,
int cursor_width, int cursor_height,
int offset_bitmap);
-void bevel_modeline (struct window *w, struct display_line *dl);
typedef struct textual_run
{
char_converter.reg[1] = byte1;
char_converter.reg[2] = byte2;
char_converter.ic = 0; /* start at beginning each time */
- 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];
}
struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, rb->findex);
Lisp_Object bg_pmap = WINDOW_FACE_CACHEL_BACKGROUND_PIXMAP (w, rb->findex);
-
+
if (!IMAGE_INSTANCEP (bg_pmap)
|| !IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (bg_pmap)))
bg_pmap = Qnil;
{
struct frame *f = XFRAME (w->frame);
struct device *d = XDEVICE (f->device);
- struct face_cachel *cachel=0;
+ struct face_cachel *cachel;
Lisp_Object font = Qnil;
int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d));
HDC hdc = FRAME_MSWINDOWS_DC (f);
xpos -= xoffset;
/* sort out the destination rectangle */
- height = DISPLAY_LINE_HEIGHT (dl);
+ height = dl->ascent + dl->descent - dl->clip;
rect.left = clip_start;
rect.top = dl->ypos - dl->ascent;
rect.right = clip_end;
int clear_end = min (xpos + this_width, clip_end);
{
- redisplay_clear_region (window, findex, clear_start,
+ mswindows_clear_region (window, findex, clear_start,
dl->ypos - dl->ascent,
clear_end - clear_start,
height);
int need_clipping = (clip_x || clip_y);
int yoffset=0;
int xoffset=0;
-
/* do we need to offset the pixmap vertically? this is necessary
for background pixmaps. */
if (offset_bitmap)
struct Lisp_Image_Instance *p = XIMAGE_INSTANCE (image_instance);
Lisp_Object window;
- int lheight = DISPLAY_LINE_HEIGHT (dl);
+ int lheight = dl->ascent + dl->descent - dl->clip;
int pheight = ((int) IMAGE_INSTANCE_PIXMAP_HEIGHT (p) > lheight ? lheight :
IMAGE_INSTANCE_PIXMAP_HEIGHT (p));
int clip_x, clip_y, clip_width, clip_height;
}
if (!offset_bitmap) /* i.e. not a bg pixmap */
- redisplay_clear_region (window, findex, clear_x, clear_y,
+ mswindows_clear_region (window, findex, clear_x, clear_y,
clear_width, clear_height);
}
redraw anyhow. */
MAYBE_FRAMEMETH (f, redraw_exposed_toolbars, (f, x, y, width, height));
#endif
- redraw_exposed_gutters (f, x, y, width, height);
if (!f->window_face_cache_reset)
{
/*****************************************************************************
- mswindows_bevel_area
+ mswindows_bevel_modeline
- Draw a 3d border around the specified area on window W.
+ Draw a 3d border around the modeline on window W.
****************************************************************************/
static void
-mswindows_bevel_area (struct window *w, face_index findex, int x, int y,
- int width, int height, int shadow_thickness)
+mswindows_bevel_modeline (struct window *w, struct display_line *dl)
{
struct frame *f = XFRAME (w->frame);
+ Lisp_Object color;
+ int shadow_width = MODELINE_SHADOW_THICKNESS (w);
+ RECT rect = { WINDOW_MODELINE_LEFT (w),
+ dl->ypos - dl->ascent - shadow_width,
+ WINDOW_MODELINE_RIGHT (w),
+ dl->ypos + dl->descent + shadow_width};
UINT edge;
- if (shadow_thickness < -1)
+ color = WINDOW_FACE_CACHEL_BACKGROUND (w, MODELINE_INDEX);
+ mswindows_update_dc (FRAME_MSWINDOWS_DC (f), Qnil, Qnil, color, Qnil);
+
+ if (XINT (w->modeline_shadow_thickness) < 0)
+ shadow_width = -shadow_width;
+
+ if (shadow_width < -1)
edge = EDGE_SUNKEN;
- else if (shadow_thickness < 0)
+ else if (shadow_width < 0)
edge = BDR_SUNKENINNER;
- else if (shadow_thickness == 1)
+ else if (shadow_width == 1)
edge = BDR_RAISEDINNER;
else
edge = EDGE_RAISED;
-
- if (shadow_thickness < 0)
- shadow_thickness = -shadow_thickness;
-
- {
- RECT rect = { x, y, x + width, y + height };
- Lisp_Object color = WINDOW_FACE_CACHEL_BACKGROUND (w, findex);
- mswindows_update_dc (FRAME_MSWINDOWS_DC (f), Qnil, Qnil, color, Qnil);
-
- DrawEdge (FRAME_MSWINDOWS_DC (f), &rect, edge, BF_RECT);
- }
+
+ DrawEdge (FRAME_MSWINDOWS_DC (f), &rect, edge, BF_RECT);
}
\f
Given a display line, a block number for that start line, output all
runes between start and end in the specified display block.
- Ripped off with minimal thought from the corresponding X routine.
+ Ripped off with mininmal thought from the corresponding X routine.
****************************************************************************/
static void
mswindows_output_display_block (struct window *w, struct display_line *dl, int block,
rb = Dynarr_atp (rba, start);
if (!rb)
+ {
/* Nothing to do so don't do anything. */
return;
-
- findex = rb->findex;
- xpos = rb->xpos;
- width = 0;
- if (rb->type == RUNE_CHAR)
- charset = CHAR_CHARSET (rb->object.chr.ch);
+ }
+ else
+ {
+ findex = rb->findex;
+ xpos = rb->xpos;
+ width = 0;
+ if (rb->type == RUNE_CHAR)
+ charset = CHAR_CHARSET (rb->object.chr.ch);
+ }
if (end < 0)
end = Dynarr_length (rba);
else if (rb->object.chr.ch == '\n')
{
/* Clear in case a cursor was formerly here. */
- int height = DISPLAY_LINE_HEIGHT (dl);
+ int height = dl->ascent + dl->descent - dl->clip;
- redisplay_clear_region (window, findex, xpos, dl->ypos - dl->ascent,
+ mswindows_clear_region (window, findex, xpos, dl->ypos - dl->ascent,
rb->width, height);
elt++;
}
abort ();
case IMAGE_SUBWINDOW:
- case IMAGE_WIDGET:
- redisplay_output_subwindow (w, dl, instance, xpos,
- rb->object.dglyph.xoffset, start_pixpos,
- rb->width, findex, cursor_start,
- cursor_width, cursor_height);
- if (rb->cursor_type == CURSOR_ON)
- mswindows_output_cursor (w, dl, xpos, cursor_width,
- findex, 0, 1);
+ /* #### implement me */
break;
case IMAGE_NOTHING:
&& (f->clear
|| f->windows_structure_changed
|| w->shadow_thickness_changed))
- bevel_modeline (w, dl);
+ mswindows_bevel_modeline (w, dl);
Dynarr_free (buf);
}
int abs_shadow = abs (shadow);
int line_width = XINT (w->vertical_divider_line_width);
int div_left = WINDOW_RIGHT (w) - window_divider_width (w);
- int y1 = WINDOW_TOP (w) + FRAME_TOP_GUTTER_BOUNDS (f);
- int y2 = WINDOW_BOTTOM (w) + FRAME_BOTTOM_GUTTER_BOUNDS (f);
/* Clear left and right spacing areas */
if (spacing)
{
- rect.top = y1;
- rect.bottom = y2;
+ rect.top = WINDOW_TOP (w);
+ rect.bottom = WINDOW_BOTTOM (w);
mswindows_update_dc (FRAME_MSWINDOWS_DC (f), Qnil, Qnil,
WINDOW_FACE_CACHEL_BACKGROUND (w, DEFAULT_INDEX), Qnil);
rect.right = WINDOW_RIGHT (w);
}
/* Clear divider face */
- rect.top = y1 + abs_shadow;
- rect.bottom = y2 - abs_shadow;
+ rect.top = WINDOW_TOP (w) + abs_shadow;
+ rect.bottom = WINDOW_BOTTOM (w) - abs_shadow;
rect.left = div_left + spacing + abs_shadow;
rect.right = rect.left + line_width;
if (rect.left < rect.right)
/* Draw a shadow around the divider */
if (shadow != 0)
{
- /* #### This will be fixed to support arbitrary thickness */
+ /* #### This will be fixed to support arbitrary thichkness */
InflateRect (&rect, abs_shadow, abs_shadow);
DrawEdge (FRAME_MSWINDOWS_DC (f), &rect,
shadow > 0 ? EDGE_RAISED : EDGE_SUNKEN, BF_RECT);
given face.
****************************************************************************/
static void
-mswindows_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)
+mswindows_clear_region (Lisp_Object locale, face_index findex, int x, int y,
+ int width, int height)
{
+ struct window *w;
+ struct frame *f;
+ Lisp_Object background_pixmap = Qunbound;
+ Lisp_Object temp;
RECT rect = { x, y, x+width, y+height };
- if (!NILP (background_pixmap))
+ if (!(width && height)) /* We often seem to get called with width==0 */
+ return;
+
+ if (WINDOWP (locale))
+ {
+ w = XWINDOW (locale);
+ f = XFRAME (w->frame);
+ }
+ else if (FRAMEP (locale))
{
+ w = NULL;
+ f = XFRAME (locale);
+ }
+ else
+ abort ();
+
+ 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))
+ {
+ 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);
+ }
+
mswindows_update_dc (FRAME_MSWINDOWS_DC (f),
Qnil, fcolor, bcolor, background_pixmap);
}
else
{
- mswindows_update_dc (FRAME_MSWINDOWS_DC (f), Qnil, Qnil, fcolor, Qnil);
- ExtTextOut (FRAME_MSWINDOWS_DC (f), 0, 0, ETO_OPAQUE,
- &rect, NULL, 0, NULL);
+ Lisp_Object color = (w ? WINDOW_FACE_CACHEL_BACKGROUND (w, findex) :
+ FACE_BACKGROUND (Vdefault_face, locale));
+ mswindows_update_dc (FRAME_MSWINDOWS_DC (f), Qnil, Qnil, color, Qnil);
+ ExtTextOut (FRAME_MSWINDOWS_DC (f), 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
}
#ifdef HAVE_SCROLLBARS
if (WINDOWP (locale))
- mswindows_redisplay_deadbox_maybe (XWINDOW (locale), &rect);
+ mswindows_redisplay_deadbox_maybe (w, &rect);
#endif
}
+/*****************************************************************************
+ mswindows_clear_to_window_end
+
+ Clear the area between ypos1 and ypos2. Each margin area and the
+ text area is handled separately since they may each have their own
+ background color.
+ ****************************************************************************/
+static void
+mswindows_clear_to_window_end (struct window *w, int ypos1, int ypos2)
+{
+ int height = ypos2 - ypos1;
+
+ if (height)
+ {
+ struct frame *f = XFRAME (w->frame);
+ Lisp_Object window;
+ int bflag = (window_needs_vertical_divider (w) ? 0 : 1);
+ layout_bounds bounds;
+
+ bounds = calculate_display_line_boundaries (w, bflag);
+ XSETWINDOW (window, w);
+
+ if (window_is_leftmost (w))
+ mswindows_clear_region (window, DEFAULT_INDEX, FRAME_LEFT_BORDER_START (f),
+ ypos1, FRAME_BORDER_WIDTH (f), height);
+
+ if (bounds.left_in - bounds.left_out > 0)
+ mswindows_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)
+ mswindows_clear_region (window, DEFAULT_INDEX, bounds.left_in, ypos1,
+ bounds.right_in - bounds.left_in, height);
+
+ if (bounds.right_out - bounds.right_in > 0)
+ mswindows_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))
+ mswindows_clear_region (window, DEFAULT_INDEX, FRAME_RIGHT_BORDER_START (f),
+ ypos1, FRAME_BORDER_WIDTH (f), height);
+ }
+
+}
+
+
/* XXX Implement me! */
static void
mswindows_clear_frame (struct frame *f)
CONSOLE_HAS_METHOD (mswindows, divider_height);
CONSOLE_HAS_METHOD (mswindows, eol_cursor_width);
CONSOLE_HAS_METHOD (mswindows, output_vertical_divider);
+ CONSOLE_HAS_METHOD (mswindows, clear_to_window_end);
CONSOLE_HAS_METHOD (mswindows, clear_region);
CONSOLE_HAS_METHOD (mswindows, clear_frame);
CONSOLE_HAS_METHOD (mswindows, output_begin);
CONSOLE_HAS_METHOD (mswindows, output_end);
CONSOLE_HAS_METHOD (mswindows, flash);
CONSOLE_HAS_METHOD (mswindows, ring_bell);
- CONSOLE_HAS_METHOD (mswindows, bevel_area);
}