/* MS-DOS specific C utilities. -*- coding: raw-text -*-
- Copyright (C) 1993, 94, 95, 96, 97, 1999, 2000, 2001
+ Copyright (C) 1993, 94, 95, 96, 97, 1999, 2000, 01, 2003
Free Software Foundation, Inc.
This file is part of GNU Emacs.
{
struct time t;
unsigned long s;
-
+
gettime (&t);
s = t.ti_min;
s *= 60;
s += t.ti_sec;
s *= 1000;
s += t.ti_hund * 10;
-
+
return s;
}
/* A flag to control how to display unibyte 8-bit characters. */
extern int unibyte_display_via_language_environment;
-Lisp_Object Qbar;
+Lisp_Object Qbar, Qhbar;
-/* The screen colors of the curent frame, which serve as the default
+/* The screen colors of the current frame, which serve as the default
colors for newly-created frames. */
static int initial_screen_colors[2];
static void
dos_direct_output (y, x, buf, len)
- int y;
- int x;
+ int x, y;
char *buf;
int len;
{
int *rows, *cols;
{
char video_name[30];
- Lisp_Object video_mode;
- int video_mode_value;
- int have_vga = 0;
union REGS regs;
+ Lisp_Object video_mode;
+ int video_mode_value, have_vga = 0;
int current_rows = ScreenRows (), current_cols = ScreenCols ();
if (*rows == current_rows && *cols == current_cols)
else
{
static struct {
- int rows;
- int need_vga;
+ int rows, need_vga;
} std_dimension[] = {
{25, 0},
{28, 1},
mouse_off_maybe ()
{
int x, y;
-
+
if (!mouse_visible)
return;
-
+
mouse_get_xy (&x, &y);
if (y != new_pos_Y || x < new_pos_X)
return;
-
+
mouse_off ();
}
static void
IT_set_cursor_type (struct frame *f, Lisp_Object cursor_type)
{
- if (EQ (cursor_type, Qbar))
+ if (EQ (cursor_type, Qbar) || EQ (cursor_type, Qhbar))
{
/* Just BAR means the normal EGA/VGA cursor. */
msdos_set_cursor_shape (f, DEFAULT_CURSOR_START, DEFAULT_CURSOR_WIDTH);
}
- else if (CONSP (cursor_type) && EQ (XCAR (cursor_type), Qbar))
+ else if (CONSP (cursor_type)
+ && (EQ (XCAR (cursor_type), Qbar)
+ || EQ (XCAR (cursor_type), Qhbar)))
{
Lisp_Object bar_parms = XCDR (cursor_type);
int width;
int conversion_buffer_size = sizeof conversion_buffer;
if (str_len <= 0) return;
-
+
screen_buf = screen_bp = alloca (str_len * 2);
screen_buf_end = screen_buf + str_len * 2;
sf = SELECTED_FRAME();
face of the frame, before writing glyphs, and let the glyphs
set the right face if it's different from the default. */
IT_set_face (DEFAULT_FACE_ID);
-
+
/* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
the tail. */
terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
Mouse Highlight (and friends..)
************************************************************************/
-/* If non-nil, dos_rawgetc generates an event to display that string.
- (The display is done in keyboard.c:read_char, by calling
- show_help_echo.) */
-static Lisp_Object help_echo;
-static Lisp_Object previous_help_echo; /* a helper temporary variable */
-
-/* These record the window, the object and the position where the help
- echo string was generated. */
-static Lisp_Object help_echo_window;
-static Lisp_Object help_echo_object;
-static int help_echo_pos;
-
-/* Non-zero means automatically select any window when the mouse
- cursor moves into it. */
-int x_autoselect_window_p;
-
-/* Last window where we saw the mouse. Used by x-autoselect-window. */
+/* Last window where we saw the mouse. Used by mouse-autoselect-window. */
static Lisp_Object last_mouse_window;
static int mouse_preempted = 0; /* non-zero when XMenu gobbles mouse events */
int i;
struct face *fp;
-
+
/* If window is in the process of being destroyed, don't bother
doing anything. */
if (w->current_matrix == NULL)
row->mouse_face_p = hl > 0;
if (hl > 0)
{
- int vpos = row->y + WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
- int kstart = start_hpos + WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
+ int vpos = row->y + WINDOW_TOP_EDGE_Y (w);
+ int kstart = start_hpos + WINDOW_LEFT_EDGE_X (w);
int nglyphs = end_hpos - start_hpos;
int offset = ScreenPrimary + 2*(vpos*screen_size_X + kstart) + 1;
int start_offset = offset;
/* IT_write_glyphs writes at cursor position, so we need to
temporarily move cursor coordinates to the beginning of
the highlight region. */
- new_pos_X = start_hpos + WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
- new_pos_Y = row->y + WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
+ new_pos_X = start_hpos + WINDOW_LEFT_EDGE_X (w);
+ new_pos_Y = row->y + WINDOW_TOP_EDGE_Y (w);
if (termscript)
fprintf (termscript, "<MH- %d-%d:%d>",
}
set_cursor_shape:
-
/* Change the mouse pointer shape. */
IT_set_mouse_pointer (hl);
}
static int
fast_find_position (struct window *w, int pos, int *hpos, int *vpos)
{
- int i;
- int lastcol;
- int maybe_next_line_p = 0;
- int line_start_position;
+ int i, lastcol, line_start_position, maybe_next_line_p = 0;
int yb = window_text_bottom_y (w);
- struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0);
- struct glyph_row *best_row = row;
+ struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0), *best_row = row;
while (row->y < yb)
{
never-never land... */
if (row->y + 1 >= yb)
break;
-
+
++row;
}
-
+
/* Find the right column within BEST_ROW. */
lastcol = 0;
row = best_row;
row = MATRIX_MODE_LINE_ROW (w->current_matrix);
else
row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
-
+
if (row->enabled_p)
{
extern Lisp_Object Qhelp_echo;
struct glyph *glyph, *end;
Lisp_Object help, map;
-
+
/* Find the glyph under X. */
- glyph = row->glyphs[TEXT_AREA]
- + x - FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
+ glyph = (row->glyphs[TEXT_AREA]
+ + x
+ /* Does MS-DOG really support scroll-bars?? ++KFS */
+ - WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w));
end = glyph + row->used[TEXT_AREA];
if (glyph < end
&& STRINGP (glyph->object)
- && XSTRING (glyph->object)->intervals
+ && STRING_INTERVALS (glyph->object)
&& glyph->charpos >= 0
- && glyph->charpos < XSTRING (glyph->object)->size)
+ && glyph->charpos < SCHARS (glyph->object))
{
/* If we're on a string with `help-echo' text property,
arrange for the help to be displayed. This is done by
Qhelp_echo, glyph->object);
if (!NILP (help))
{
- help_echo = help;
+ help_echo_string = help;
XSETWINDOW (help_echo_window, w);
help_echo_object = glyph->object;
help_echo_pos = glyph->charpos;
IT_note_mouse_highlight (struct frame *f, int x, int y)
{
struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
- int portion = -1;
+ enum window_part part = ON_NOTHING;
Lisp_Object window;
struct window *w;
}
/* Which window is that in? */
- window = window_from_coordinates (f, x, y, &portion, 0);
+ window = window_from_coordinates (f, x, y, &part, &x, &y, 0);
/* If we were displaying active text in another window, clear that. */
if (! EQ (window, dpyinfo->mouse_face_window))
/* Convert to window-relative coordinates. */
w = XWINDOW (window);
- x -= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w);
- y -= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w);
- if (portion == 1 || portion == 3)
+ if (part == ON_MODE_LINE || part == ON_HEADER_LINE)
{
/* Mouse is on the mode or top line. */
- IT_note_mode_line_highlight (w, x, portion == 1);
+ IT_note_mode_line_highlight (w, x, part == ON_MODE_LINE);
return;
}
- else
- IT_set_mouse_pointer (0);
+
+ IT_set_mouse_pointer (0);
/* Are we in a window whose display is up to date?
And verify the buffer's text has not changed. */
- if (/* Within text portion of the window. */
- portion == 0
+ if (part == ON_TEXT
&& EQ (w->window_end_valid, w->buffer)
&& XFASTINT (w->last_modified) == BUF_MODIFF (XBUFFER (w->buffer))
&& (XFASTINT (w->last_overlay_modified)
== BUF_OVERLAY_MODIFF (XBUFFER (w->buffer))))
{
- int pos, i;
+ int pos, i, nrows = w->current_matrix->nrows;
struct glyph_row *row;
struct glyph *glyph;
- int nrows = w->current_matrix->nrows;
/* Find the glyph under X/Y. */
glyph = NULL;
/* Check for mouse-face and help-echo. */
{
extern Lisp_Object Qmouse_face;
- Lisp_Object mouse_face, overlay, position;
- Lisp_Object *overlay_vec;
- int len, noverlays;
+ Lisp_Object mouse_face, overlay, position, *overlay_vec;
+ int len, noverlays, obegv, ozv;;
struct buffer *obuf;
- int obegv, ozv;
/* If we get an out-of-range value, return now; avoid an error. */
if (pos > BUF_Z (XBUFFER (w->buffer)))
noverlays = overlays_at (pos,
0, &overlay_vec, &len, NULL, NULL, 0);
}
-
+
/* Sort overlays into increasing priority order. */
noverlays = sort_overlays (overlay_vec, noverlays, w);
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
- &ignore, pos + 1, 1);
+ &ignore, pos + 1,
+ !dpyinfo->mouse_face_hidden);
/* Display it as active. */
show_mouse_face (dpyinfo, 1);
dpyinfo->mouse_face_window = window;
dpyinfo->mouse_face_face_id
= face_at_buffer_position (w, pos, 0, 0,
- &ignore, pos + 1, 1);
+ &ignore, pos + 1,
+ !dpyinfo->mouse_face_hidden);
/* Display it as active. */
show_mouse_face (dpyinfo, 1);
overlay = overlay_vec[i];
help = Foverlay_get (overlay, Qhelp_echo);
}
-
+
if (!NILP (help))
{
- help_echo = help;
+ help_echo_string = help;
help_echo_window = window;
help_echo_object = overlay;
help_echo_pos = pos;
else if (NILP (help)
&& ((STRINGP (glyph->object)
&& glyph->charpos >= 0
- && glyph->charpos < XSTRING (glyph->object)->size)
+ && glyph->charpos < SCHARS (glyph->object))
|| (BUFFERP (glyph->object)
&& glyph->charpos >= BEGV
&& glyph->charpos < ZV)))
Qhelp_echo, glyph->object);
if (!NILP (help))
{
- help_echo = help;
+ help_echo_string = help;
help_echo_window = window;
help_echo_object = glyph->object;
help_echo_pos = glyph->charpos;
}
}
}
-
+
BEGV = obegv;
ZV = ozv;
current_buffer = obuf;
IT_clear_end_of_line (int first_unused)
{
char *spaces, *sp;
- int i, j;
- int offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
+ int i, j, offset = 2 * (new_pos_X + screen_size_X * new_pos_Y);
extern int fatal_error_in_progress;
if (new_pos_X >= first_unused || fatal_error_in_progress)
if (termscript)
fprintf (termscript, "<CLR:EOL[%d..%d)>", new_pos_X, first_unused);
spaces = sp = alloca (i);
-
+
while (--j >= 0)
{
*sp++ = ' ';
/* If we are in the echo area, put the cursor at the
end of the echo area message. */
if (!update_cursor_pos
- && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f))->top) <= new_pos_Y)
+ && WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f))) <= new_pos_Y)
{
int tem_X = current_pos_X, dummy;
screen_size_X = ScreenCols ();
screen_size_Y = ScreenRows ();
screen_size = screen_size_X * screen_size_Y;
-
+
new_pos_X = new_pos_Y = 0;
current_pos_X = current_pos_Y = -1;
if (term_setup_done)
return;
term_setup_done = 1;
-
+
startup_screen_size_X = screen_size_X;
startup_screen_size_Y = screen_size_Y;
startup_screen_attrib = ScreenAttrib;
{
int display_row_start = (int) ScreenPrimary;
int saved_row_len = startup_screen_size_X * 2;
- int update_row_len = ScreenCols () * 2;
- int current_rows = ScreenRows ();
+ int update_row_len = ScreenCols () * 2, current_rows = ScreenRows ();
int to_next_row = update_row_len;
unsigned char *saved_row = startup_screen_buffer;
- int cursor_pos_X = ScreenCols () - 1;
- int cursor_pos_Y = ScreenRows () - 1;
+ int cursor_pos_X = ScreenCols () - 1, cursor_pos_Y = ScreenRows () - 1;
if (termscript)
fprintf (termscript, "\n<RESET_TERM>");
if (!term_setup_done)
return;
-
+
mouse_off ();
/* Leave the video system in the same state as we found it,
Lisp_Object alist;
{
Lisp_Object tail;
- int length = XINT (Flength (alist));
- int i, j;
+ int i, j, length = XINT (Flength (alist));
Lisp_Object *parms
= (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
Lisp_Object *values
= (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
/* Do we have to reverse the foreground and background colors? */
int reverse = EQ (Fcdr (Fassq (Qreverse, f->param_alist)), Qt);
- int was_reverse = reverse;
+ int need_to_reverse, was_reverse = reverse;
int redraw = 0, fg_set = 0, bg_set = 0;
- int need_to_reverse;
- unsigned long orig_fg;
- unsigned long orig_bg;
+ unsigned long orig_fg, orig_bg;
Lisp_Object frame_bg, frame_fg;
extern Lisp_Object Qdefault, QCforeground, QCbackground;
/* Now process the alist elements in reverse of specified order. */
for (i--; i >= 0; i--)
{
- Lisp_Object prop, val;
- Lisp_Object frame;
+ Lisp_Object prop, val, frame;
prop = parms[i];
val = values[i];
{
x_set_title (f, val);
if (termscript)
- fprintf (termscript, "<TITLE: %s>\n", XSTRING (val)->data);
+ fprintf (termscript, "<TITLE: %s>\n", SDATA (val));
}
else if (EQ (prop, Qcursor_type))
{
IT_set_cursor_type (f, val);
if (termscript)
fprintf (termscript, "<CTYPE: %s>\n",
- EQ (val, Qbar) || CONSP (val) && EQ (XCAR (val), Qbar)
+ EQ (val, Qbar) || EQ (val, Qhbar)
+ || CONSP (val) && (EQ (XCAR (val), Qbar)
+ || EQ (XCAR (val), Qhbar))
? "bar" : "box");
}
store_frame_param (f, prop, val);
void
internal_terminal_init ()
{
- char *term = getenv ("TERM");
- char *colors;
+ char *term = getenv ("TERM"), *colors;
struct frame *sf = SELECTED_FRAME();
#ifdef HAVE_X_WINDOWS
if (getenv ("EMACSTEST"))
termscript = fopen (getenv ("EMACSTEST"), "wt");
-
+
#ifndef HAVE_X_WINDOWS
if (!internal_terminal || inhibit_window_system)
{
if (colors[1] >= 0 && colors[1] < 16)
the_only_x_display.background_pixel = colors[1];
}
- the_only_x_display.line_height = 1;
the_only_x_display.font = (XFontStruct *)1; /* must *not* be zero */
the_only_x_display.display_info.mouse_face_mouse_frame = NULL;
the_only_x_display.display_info.mouse_face_deferred_gc = 0;
return *screen != (char *)0;
#else
return 0;
-#endif
+#endif
}
#ifndef HAVE_X_WINDOWS
keyboard = keyboard_layout_list[0].keyboard_map;
keyboard_map_all = always;
dos_keyboard_layout = 1;
-
+
for (i = 0; i < (sizeof (keyboard_layout_list)/sizeof (struct keyboard_layout_list)); i++)
if (code == keyboard_layout_list[i].country_code)
{
Map | 23, /* 'o' */
Map | 24, /* 'p' */
Map | 25, /* '[' */
- Map | 26, /* ']' */
+ Map | 26, /* ']' */
ModFct | 0x0d, /* Return */
Ignore, /* Ctrl */
Map | 30, /* 'a' */
int *keymask;
{
union REGS regs;
- int mask;
- int modifiers = 0;
-
+ int mask, modifiers = 0;
+
/* Calculate modifier bits */
regs.h.ah = extended_kbd ? 0x12 : 0x02;
int86 (0x16, ®s, ®s);
if (!extended_kbd)
{
- mask = regs.h.al & (SHIFT_P | CTRL_P | ALT_P |
+ mask = regs.h.al & (SHIFT_P | CTRL_P | ALT_P |
SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
}
else
{
mask = regs.h.al & (SHIFT_P |
SCRLOCK_P | NUMLOCK_P | CAPSLOCK_P);
-
+
/* Do not break international keyboard support. */
/* When Keyb.Com is loaded, the right Alt key is */
/* used for accessing characters like { and } */
mask |= ALT_P;
}
}
-
+
if (regs.h.ah & 1) /* Left CTRL pressed ? */
mask |= CTRL_P;
and then the scan code. */)
()
{
- Lisp_Object *keys = XVECTOR (recent_doskeys)->contents;
- Lisp_Object val;
+ Lisp_Object val, *keys = XVECTOR (recent_doskeys)->contents;
if (total_doskeys < NUM_RECENT_DOSKEYS)
return Fvector (total_doskeys, keys);
struct input_event event;
union REGS regs;
struct display_info *dpyinfo = FRAME_X_DISPLAY_INFO (SELECTED_FRAME());
+ EVENT_INIT (event);
#ifndef HAVE_X_WINDOWS
/* Maybe put the cursor where it should be. */
{
union REGS regs;
register unsigned char c;
- int sc, code = -1, mask, kp_mode;
- int modifiers;
+ int modifiers, sc, code = -1, mask, kp_mode;
regs.h.ah = extended_kbd ? 0x10 : 0x00;
int86 (0x16, ®s, ®s);
recent_doskeys_index = 0;
modifiers = dos_get_modifiers (&mask);
-
+
#ifndef HAVE_X_WINDOWS
if (!NILP (Vdos_display_scancodes))
{
continue;
}
}
-
+
if (c == 0)
{
/* We only look at the keyboard Ctrl/Shift/Alt keys when
if (code & Shift)
modifiers |= shift_modifier;
}
-
+
switch (code & 0xf000)
{
case ModFct:
if (c && !(mask & (SHIFT_P | ALT_P | CTRL_P | HYPER_P | SUPER_P)))
return c;
c = 0; /* Special */
-
+
case FctKey:
if (c != 0)
return c;
-
+
case Special:
code |= 0xff00;
break;
-
+
case Normal:
if (sc == 0)
{
code = c;
break;
}
-
+
case Map:
if (c && !(mask & ALT_P) && !((mask & SHIFT_P) && (mask & CTRL_P)))
if (!keyboard_map_all)
code &= 0xff;
if (mask & ALT_P && code <= 10 && code > 0 && dos_keypad_mode & 0x200)
mask |= SHIFT_P; /* ALT-1 => M-! etc. */
-
+
if (mask & SHIFT_P)
{
code = keyboard->shifted[code];
kp_mode = dos_keypad_mode & 0x03;
else
kp_mode = (dos_keypad_mode >> 4) & 0x03;
-
+
switch (kp_mode)
{
case 0:
code = keypad_translate_map[code].meta_code;
modifiers = meta_modifier;
break;
-
+
case 3:
code = 0xff00 | keypad_translate_map[code].editkey_code;
break;
}
break;
-
+
case Grey:
code &= 0xff;
kp_mode = ((mask & (NUMLOCK_P|CTRL_P|SHIFT_P|ALT_P)) == NUMLOCK_P) ? 0x04 : 0x40;
code = grey_key_translate_map[code].char_code;
break;
}
-
+
make_event:
if (code == 0)
continue;
}
if (code >= 0x100)
- event.kind = non_ascii_keystroke;
+ event.kind = NON_ASCII_KEYSTROKE_EVENT;
else
- event.kind = ascii_keystroke;
+ event.kind = ASCII_KEYSTROKE_EVENT;
event.code = code;
event.modifiers = modifiers;
event.frame_or_window = selected_frame;
{
int but, press, x, y, ok;
int mouse_prev_x = mouse_last_x, mouse_prev_y = mouse_last_y;
+ Lisp_Object mouse_window = Qnil;
/* Check for mouse movement *before* buttons. */
mouse_check_moved ();
clear_mouse_face (dpyinfo);
}
- if (x_autoselect_window_p)
+ /* Generate SELECT_WINDOW_EVENTs when needed. */
+ if (mouse_autoselect_window)
{
- int mouse_area;
- Lisp_Object mouse_window;
-
mouse_window = window_from_coordinates (SELECTED_FRAME(),
mouse_last_x,
mouse_last_y,
- &mouse_area, 0);
+ 0, 0, 0, 0);
/* A window will be selected only when it is not
- selected now. A minubuffer window will be selected
- iff it is active. */
- if (!EQ (mouse_window, last_mouse_window)
- && !EQ (mouse_window, selected_window)
- && (!MINI_WINDOW_P (XWINDOW (mouse_window))
- || (EQ (mouse_window, minibuf_window)
- && minibuf_level > 0)))
+ selected now, and the last mouse movement event was
+ not in it. A minibuffer window will be selected iff
+ it is active. */
+ if (WINDOWP (mouse_window)
+ && !EQ (mouse_window, last_mouse_window)
+ && !EQ (mouse_window, selected_window))
{
- Fselect_window (mouse_window);
+ event.kind = SELECT_WINDOW_EVENT;
+ event.frame_or_window = mouse_window;
+ event.arg = Qnil;
+ event.timestamp = event_timestamp ();
+ kbd_buffer_store_event (&event);
}
last_mouse_window = mouse_window;
}
else
last_mouse_window = Qnil;
- previous_help_echo = help_echo;
- help_echo = help_echo_object = help_echo_window = Qnil;
+ previous_help_echo_string = help_echo_string;
+ help_echo_string = help_echo_object = help_echo_window = Qnil;
help_echo_pos = -1;
IT_note_mouse_highlight (SELECTED_FRAME(),
mouse_last_x, mouse_last_y);
/* If the contents of the global variable help_echo has
changed, generate a HELP_EVENT. */
- if (!NILP (help_echo) || !NILP (previous_help_echo))
+ if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
{
- /* HELP_EVENT takes 2 events in the event loop. */
event.kind = HELP_EVENT;
event.frame_or_window = selected_frame;
event.arg = help_echo_object;
- event.x = make_number (help_echo_pos);
+ event.x = WINDOWP (help_echo_window)
+ ? help_echo_window : selected_frame;
+ event.y = help_echo_string;
event.timestamp = event_timestamp ();
- event.code = 0;
- kbd_buffer_store_event (&event);
- if (WINDOWP (help_echo_window))
- event.frame_or_window = help_echo_window;
- event.arg = help_echo;
- event.code = 1;
+ event.code = help_echo_pos;
kbd_buffer_store_event (&event);
}
}
}
}
- event.kind = mouse_click;
+ event.kind = MOUSE_CLICK_EVENT;
event.code = button_num;
event.modifiers = dos_get_modifiers (0)
| (press ? down_modifier : up_modifier);
}
\f
#ifndef HAVE_X_WINDOWS
-/* See xterm.c for more info. */
-void
-pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
- FRAME_PTR f;
- register int pix_x, pix_y;
- register int *x, *y;
- XRectangle *bounds;
- int noclip;
-{
- if (bounds) abort ();
-
- /* Ignore clipping. */
-
- *x = pix_x;
- *y = pix_y;
-}
-void
-glyph_to_pixel_coords (f, x, y, pix_x, pix_y)
- FRAME_PTR f;
- register int x, y;
- register int *pix_x, *pix_y;
-{
- *pix_x = x;
- *pix_y = y;
-}
-\f
/* Simulation of X's menus. Nothing too fancy here -- just make it work
for now.
static void
IT_menu_display (XMenu *menu, int y, int x, int pn, int *faces, int disp_help)
{
- int i, j, face, width;
+ int i, j, face, width, mx, my, enabled, mousehere, row, col;
struct glyph *text, *p;
char *q;
- int mx, my;
- int enabled, mousehere;
- int row, col;
struct frame *sf = SELECTED_FRAME();
menu_help_message = NULL;
/* Report availability of menus. */
int
-have_menus_p ()
-{
- return 1;
-}
+have_menus_p () { return 1; }
/* Create a brand new menu structure. */
void (*help_callback)(char *, int, int))
{
struct IT_menu_state *state;
- int statecount;
- int x, y, i, b;
- int screensize;
- int faces[4];
- Lisp_Object selectface;
- int leave, result, onepane;
+ int statecount, x, y, i, b, screensize, leave, result, onepane;
int title_faces[4]; /* face to display the menu title */
- int buffers_num_deleted = 0;
+ int faces[4], buffers_num_deleted = 0;
struct frame *sf = SELECTED_FRAME();
- Lisp_Object saved_echo_area_message;
+ Lisp_Object saved_echo_area_message, selectface;
/* Just in case we got here without a mouse present... */
if (have_mouse <= 0)
/* Don't let the title for the "Buffers" popup menu include a
digit (which is ugly).
-
+
This is a terrible kludge, but I think the "Buffers" case is
the only one where the title includes a number, so it doesn't
seem to be necessary to make this more general. */
state[statecount].x
= state[i].x + state[i].menu->width + 2;
state[statecount].y = y;
- statecount++;
+ statecount++;
}
}
}
int
x_pixel_width (struct frame *f)
{
- return FRAME_WIDTH (f);
+ return FRAME_COLS (f);
}
int
x_pixel_height (struct frame *f)
{
- return FRAME_HEIGHT (f);
+ return FRAME_LINES (f);
}
#endif /* !HAVE_X_WINDOWS */
\f
int drive;
char *dst;
{
- char in_path[4], *p = in_path;
- int e = errno;
+ char in_path[4], *p = in_path, e = errno;;
/* Generate "X:." (when drive is X) or "." (when drive is 0). */
if (drive != 0)
register int n;
register unsigned char *buf;
{
- unsigned char *np = buf;
- unsigned char *startp = buf;
- unsigned char *endp = buf + n;
+ unsigned char *np = buf, *startp = buf, *endp = buf + n;
if (n == 0)
return n;
used when you compile with DJGPP v2.0. */
#include <io.h>
-
+
int _rename(const char *old, const char *new)
{
__dpmi_regs r;
return Qnil;
tem = Fcopy_sequence (filename);
- msdos_downcase_filename (XSTRING (tem)->data);
+ msdos_downcase_filename (SDATA (tem));
return tem;
}
\f
int skip_args;
{
char *s, *t, *root;
- int len;
+ int len, i;
static const char * const tempdirs[] = {
"$TMPDIR", "$TEMP", "$TMP", "c:/"
};
- int i;
const int imax = sizeof (tempdirs) / sizeof (tempdirs[0]);
/* Make sure they have a usable $TMPDIR. Many Emacs functions use
{
union REGS inregs, outregs;
static int first_time = 1;
-
+
break_stat = getcbrk ();
setcbrk (0);
#if __DJGPP__ < 2
inregs.h.ah = 0xc0;
int86 (0x15, &inregs, &outregs);
extended_kbd = (!outregs.x.cflag) && (outregs.h.ah == 0);
-
+
have_mouse = 0;
if (internal_terminal
{
char *saveargv1, *saveargv2, *lowcase_argv0, *pa, *pl;
char oldwd[MAXPATHLEN + 1]; /* Fixed size is safe on MSDOS. */
- int msshell, result = -1;
- int inbak, outbak, errbak;
- int x, y;
+ int msshell, result = -1, inbak, outbak, errbak, x, y;
Lisp_Object cmd;
/* Get current directory as MSDOS cwd is not per-process. */
mouse_get_xy (&x, &y);
dos_ttcooked (); /* do it here while 0 = stdin */
-
+
dup2 (tempin, 0);
dup2 (tempout, 1);
dup2 (temperr, 2);
#endif /* __DJGPP__ > 1 */
result = spawnve (P_WAIT, argv[0], argv, envv);
-
+
dup2 (inbak, 0);
dup2 (outbak, 1);
dup2 (errbak, 2);
text attribute byte, so we get blinking characters instead of the
bright background colors. Restore that. */
bright_bg ();
-
+
done:
chdir (oldwd);
if (msshell)
return result;
}
+void
croak (badfunc)
char *badfunc;
{
/* When time zones are set from Ms-Dos too many C-libraries are playing
tricks with time values. We solve this by defining our own version
of `gettimeofday' bypassing GO32. Our version needs to be initialized
- once and after each call to `tzset' with TZ changed. That is
+ once and after each call to `tzset' with TZ changed. That is
accomplished by aliasing tzset to init_gettimeofday. */
static struct tm time_rec;
{
struct time t;
struct tm tm;
-
+
gettime (&t);
if (t.ti_hour < time_rec.tm_hour) /* midnight wrap */
{
time_rec.tm_mon = d.da_mon - 1;
time_rec.tm_mday = d.da_day;
}
-
+
time_rec.tm_hour = t.ti_hour;
time_rec.tm_min = t.ti_min;
time_rec.tm_sec = t.ti_sec;
tm = time_rec;
tm.tm_gmtoff = dos_timezone_offset;
-
+
tp->tv_sec = mktime (&tm); /* may modify tm */
tp->tv_usec = t.ti_hund * (1000000 / 100);
}
nice (p) int p; {}
void volatile pause () {}
sigsetmask (x) int x; { return 0; }
-sigblock (mask) int mask; { return 0; }
+sigblock (mask) int mask; { return 0; }
#endif
void request_sigio (void) {}
void unrequest_sigio (void) {}
#if __DJGPP__ > 1
+#if __DJGPP_MINOR__ < 2
#ifdef POSIX_SIGNALS
typedef void (*sighandler_t)(int);
static sighandler_t prev_handlers[320];
-/* A signal handler which just records that a signal occured
+/* A signal handler which just records that a signal occurred
(it will be raised later, if and when the signal is unblocked). */
static void
sig_suspender (signo)
#else /* not POSIX_SIGNALS */
sigsetmask (x) int x; { return 0; }
-sigblock (mask) int mask; { return 0; }
+sigblock (mask) int mask; { return 0; }
#endif /* not POSIX_SIGNALS */
+#endif /* not __DJGPP_MINOR__ < 2 */
#endif /* __DJGPP__ > 1 */
#ifndef HAVE_SELECT
if (nfds != 1)
abort ();
-
+
/* If we are looking only for the terminal, with no timeout,
just read it and wait -- that's more efficient. */
if (!timeout)
dos_yield_time_slice ();
}
}
-
+
FD_SET (0, rfds);
return 1;
}
tmp += 2; /* strip drive: KFS 1995-07-06 */
len -= 2;
}
-
+
if (len > 1 && (tmp[len - 1] == '/'))
{
char *tmp1 = (char *) alloca (len + 1);
{
char buffer1[200], buffer2[400];
int i, j;
-
+
sprintf (buffer1, "<EMACS FATAL ERROR IN %s LINE %d>", file, line);
for (i = j = 0; buffer1[i]; i++) {
buffer2[j++] = buffer1[i];
{
recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
staticpro (&recent_doskeys);
+
#ifndef HAVE_X_WINDOWS
- help_echo = Qnil;
- staticpro (&help_echo);
- help_echo_object = Qnil;
- staticpro (&help_echo_object);
- help_echo_window = Qnil;
- staticpro (&help_echo_window);
- previous_help_echo = Qnil;
- staticpro (&previous_help_echo);
- help_echo_pos = -1;
/* The following two are from xfns.c: */
Qbar = intern ("bar");
staticpro (&Qbar);
+ Qhbar = intern ("hbar");
+ staticpro (&Qhbar);
Qcursor_type = intern ("cursor-type");
staticpro (&Qcursor_type);
Qreverse = intern ("reverse");
This variable is used only by MSDOS terminals. */);
Vdos_unsupported_char_glyph = '\177';
- DEFVAR_BOOL ("x-autoselect-window", &x_autoselect_window_p,
- doc: /* *Non-nil means autoselect window with mouse pointer. */);
- x_autoselect_window_p = 0;
#endif
#ifndef subprocesses
DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
}
#endif /* MSDOS */
-