#include <TextUtils.h>
#include <LowMem.h>
#include <Controls.h>
+#include <Windows.h>
#if defined (__MRC__) || (__MSL__ >= 0x6000)
#include <ControlDefinitions.h>
#endif
-#include <Gestalt.h>
#if __profile__
#include <profiler.h>
static Time last_mouse_movement_time;
-enum mouse_tracking_type {
- mouse_tracking_none,
- mouse_tracking_mouse_movement,
- mouse_tracking_scroll_bar
-};
-
-enum mouse_tracking_type mouse_tracking_in_progress = mouse_tracking_none;
-
struct scroll_bar *tracked_scroll_bar = NULL;
/* Incremented by XTread_socket whenever it really tries to read
extern int extra_keyboard_modifiers;
+/* The keysyms to use for the various modifiers. */
+
+static Lisp_Object Qalt, Qhyper, Qsuper, Qmodifier_value;
+
static Lisp_Object Qvendor_specific_keysyms;
#if 0
static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
enum text_cursor_kinds));
-static void x_clip_to_row P_ ((struct window *, struct glyph_row *, GC));
+static void x_clip_to_row P_ ((struct window *, struct glyph_row *, int, GC));
static void x_flush P_ ((struct frame *f));
static void x_update_begin P_ ((struct frame *));
static void x_update_window_begin P_ ((struct window *));
static int is_emacs_window (WindowPtr);
-extern int image_ascent (struct image *, struct face *);
int x_bitmap_icon (struct frame *, Lisp_Object);
void x_make_frame_visible (struct frame *);
Display *display; /* not used */
Pixmap pixmap;
{
- DisposeGWorld (pixmap);
+ DisposeGWorld (pixmap);
}
GC gc;
int x1, y1, x2, y2;
{
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (gc);
GC gc;
int x1, y1, x2, y2;
{
+ CGrafPtr old_port;
+ GDHandle old_gdh;
+
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (p, NULL);
mac_set_colors (gc);
MoveTo (x1, y1);
LineTo (x2, y2);
UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
}
/* Mac version of XClearArea. */
xgc.foreground = mwp->x_compatible.foreground_pixel;
xgc.background = mwp->x_compatible.background_pixel;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (&xgc);
SetRect (&r, x, y, x + width, y + height);
xgc.foreground = mwp->x_compatible.foreground_pixel;
xgc.background = mwp->x_compatible.background_pixel;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (&xgc);
bitmap.baseAddr = (char *)bits;
SetRect (&(bitmap.bounds), 0, 0, width, height);
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (gc);
SetRect (&r, x, y, x + width, y + height);
WindowPtr w;
Rect *r;
{
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
ClipRect (r);
}
{
Rect r;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
SetRect (&r, -32767, -32767, 32767, 32767);
ClipRect (&r);
Rect r;
QDErr err;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
SetRect (&r, 0, 0, width, height);
err = NewGWorld (&pixmap, depth, &r, NULL, NULL, 0);
{
Pixmap pixmap;
BitMap bitmap;
+ CGrafPtr old_port;
+ GDHandle old_gdh;
pixmap = XCreatePixmap (display, w, width, height, depth);
if (pixmap == NULL)
return NULL;
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (pixmap, NULL);
mac_create_bitmap_from_bitmap_data (&bitmap, data, width, height);
mac_set_forecolor (fg);
&bitmap.bounds, &bitmap.bounds, srcCopy, 0);
#endif /* not TARGET_API_MAC_CARBON */
UnlockPixels (GetGWorldPixMap (pixmap));
+ SetGWorld (old_port, old_gdh);
mac_free_bitmap (&bitmap);
return pixmap;
{
Rect r;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (gc);
SetRect (&r, x, y, x + width, y + height);
int x, y;
unsigned int width, height;
{
+ CGrafPtr old_port;
+ GDHandle old_gdh;
Rect r;
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (p, NULL);
mac_set_colors (gc);
SetRect (&r, x, y, x + width, y + height);
LockPixels (GetGWorldPixMap (p));
PaintRect (&r); /* using foreground color of gc */
UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
}
{
Rect r;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (gc);
SetRect (&r, x, y, x + width + 1, y + height + 1);
int x, y;
unsigned int width, height;
{
+ CGrafPtr old_port;
+ GDHandle old_gdh;
Rect r;
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (p, NULL);
mac_set_colors (gc);
SetRect (&r, x, y, x + width + 1, y + height + 1);
LockPixels (GetGWorldPixMap (p));
FrameRect (&r); /* using foreground color of gc */
UnlockPixels (GetGWorldPixMap (p));
+
+ SetGWorld (old_port, old_gdh);
}
char *buf;
int nchars, mode, bytes_per_char;
{
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ SetPortWindowPort (w);
mac_set_colors (gc);
{
Rect src_r, dest_r;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (dest));
-#else
- SetPort (dest);
-#endif
+ SetPortWindowPort (dest);
SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
{
Rect src_r, dest_r;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (dest));
-#else
- SetPort (dest);
-#endif
+ SetPortWindowPort (dest);
SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
- SetPort (GetWindowPort (w));
+ SetPortWindowPort (w);
ForeColor (blackColor);
BackColor (whiteColor);
unsigned int width, height;
int dest_x, dest_y;
{
+ CGrafPtr old_port;
+ GDHandle old_gdh;
Rect src_r, dest_r;
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (dest, NULL);
ForeColor (blackColor);
BackColor (whiteColor);
#endif /* not TARGET_API_MAC_CARBON */
UnlockPixels (GetGWorldPixMap (dest));
UnlockPixels (GetGWorldPixMap (src));
+
+ SetGWorld (old_port, old_gdh);
}
unsigned int width, height;
int dest_x, dest_y;
{
+ CGrafPtr old_port;
+ GDHandle old_gdh;
Rect src_r, dest_r;
+ GetGWorld (&old_port, &old_gdh);
SetGWorld (dest, NULL);
ForeColor (blackColor);
BackColor (whiteColor);
UnlockPixels (GetGWorldPixMap (dest));
UnlockPixels (GetGWorldPixMap (mask));
UnlockPixels (GetGWorldPixMap (src));
+
+ SetGWorld (old_port, old_gdh);
}
FOR_EACH_FRAME (rest, frame)
x_flush (XFRAME (frame));
}
- else if (FRAME_X_P (f))
+ else if (FRAME_MAC_P (f))
XFlush (FRAME_MAC_DISPLAY (f));
UNBLOCK_INPUT;
#endif /* TARGET_API_MAC_CARBON */
{
int i;
- for (i = 0; i < w->desired_matrix->nrows; ++i)
+ for (i = 0; i < w->desired_matrix->nrows; ++i)
if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
break;
int x, y0, y1;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
-
+
XDrawLine (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f),
f->output_data.mac->normal_gc, x, y0, x, y1);
}
output_cursor.vpos,
output_cursor.x, output_cursor.y);
- x_draw_vertical_border (w);
-
- draw_window_fringes (w);
+ if (draw_window_fringes (w, 1))
+ x_draw_vertical_border (w);
UNBLOCK_INPUT;
}
x_update_end (f)
struct frame *f;
{
+ /* Mouse highlight may be displayed again. */
+ FRAME_MAC_DISPLAY_INFO (f)->mouse_face_defer = 0;
+
+ BLOCK_INPUT;
/* Reset the background color of Mac OS Window to that of the frame after
update so that it is used by Mac Toolbox to clear the update region before
an update event is generated. */
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (FRAME_MAC_WINDOW (f)));
-#else
- SetPort (FRAME_MAC_WINDOW (f));
-#endif
+ SetPortWindowPort (FRAME_MAC_WINDOW (f));
mac_set_backcolor (FRAME_BACKGROUND_PIXEL (f));
- /* Mouse highlight may be displayed again. */
- FRAME_MAC_DISPLAY_INFO (f)->mouse_face_defer = 0;
-
- BLOCK_INPUT;
XFlush (FRAME_MAC_DISPLAY (f));
UNBLOCK_INPUT;
}
XTframe_up_to_date (f)
struct frame *f;
{
- if (FRAME_X_P (f))
+ if (FRAME_MAC_P (f))
{
struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
int oldVH = row->visible_height;
row->visible_height = p->h;
row->y -= rowY - p->y;
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, -1, gc);
row->y = oldY;
row->visible_height = oldVH;
}
else
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, -1, gc);
if (p->bx >= 0 && !p->overlay_p)
{
: face->foreground);
gcv.background = face->background;
- mac_draw_bitmap (display, window, &gcv, p->x, p->y,
+ mac_draw_bitmap (display, window, &gcv, p->x, p->y,
p->wd, p->h, bits, p->overlay_p);
}
static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
int, int, int));
static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
- int, int, int, int, Rect *));
+ int, int, int, int, int, int,
+ Rect *));
static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
int, int, int, Rect *));
static void
x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
- raised_p, left_p, right_p, clip_rect)
+ raised_p, top_p, bot_p, left_p, right_p, clip_rect)
struct frame *f;
- int left_x, top_y, right_x, bottom_y, width, left_p, right_p, raised_p;
+ int left_x, top_y, right_x, bottom_y, width;
+ int top_p, bot_p, left_p, right_p, raised_p;
Rect *clip_rect;
{
Display *dpy = FRAME_MAC_DISPLAY (f);
mac_set_clip_rectangle (dpy, window, clip_rect);
/* Top. */
- for (i = 0; i < width; ++i)
- XDrawLine (dpy, window, gc,
- left_x + i * left_p, top_y + i,
- right_x - i * right_p, top_y + i);
+ if (top_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ left_x + i * left_p, top_y + i,
+ right_x - i * right_p, top_y + i);
/* Left. */
if (left_p)
clip_rect);
/* Bottom. */
- for (i = 0; i < width; ++i)
- XDrawLine (dpy, window, gc,
- left_x + i * left_p, bottom_y - i,
- right_x - i * right_p, bottom_y - i);
+ if (bot_p)
+ for (i = 0; i < width; ++i)
+ XDrawLine (dpy, window, gc,
+ left_x + i * left_p, bottom_y - i,
+ right_x - i * right_p, bottom_y - i);
/* Right. */
if (right_p)
{
x_setup_relief_colors (s);
x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
- width, raised_p, left_p, right_p, &clip_rect);
+ width, raised_p, 1, 1, left_p, right_p, &clip_rect);
}
}
x_draw_image_foreground (s)
struct glyph_string *s;
{
- int x;
- int y = s->ybase - image_ascent (s->img, s->face);
+ int x = s->x;
+ int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
if (s->face->box != FACE_NO_BOX
- && s->first_glyph->left_box_line_p)
- x = s->x + abs (s->face->box_line_width);
- else
- x = s->x;
+ && s->first_glyph->left_box_line_p
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- x += s->img->hmargin;
- y += s->img->vmargin;
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ y += s->img->vmargin;
if (s->img->pixmap)
{
CONVERT_TO_XRECT (clip_rect, nr);
image_rect.x = x;
image_rect.y = y;
- image_rect.width = s->img->width;
- image_rect.height = s->img->height;
+ image_rect.width = s->slice.width;
+ image_rect.height = s->slice.height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
mac_copy_area_with_mask (s->display, s->img->pixmap, s->img->mask,
- s->window, s->gc, r.x - x, r.y - y,
+ s->window, s->gc,
+ s->slice.x + r.x - x, s->slice.y + r.y - y,
r.width, r.height, r.x, r.y);
}
else
CONVERT_TO_XRECT (clip_rect, nr);
image_rect.x = x;
image_rect.y = y;
- image_rect.width = s->img->width;
- image_rect.height = s->img->height;
+ image_rect.width = s->slice.width;
+ image_rect.height = s->slice.height;
if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
mac_copy_area (s->display, s->img->pixmap, s->window, s->gc,
- r.x - x, r.y - y, r.width, r.height, r.x, r.y);
+ s->slice.x + r.x - x, s->slice.y + r.y - y,
+ r.width, r.height, r.x, r.y);
/* When the image has a mask, we can expect that at
least part of a mouse highlight or a block cursor will
{
int r = s->img->relief;
if (r < 0) r = -r;
- mac_draw_rectangle (s->display, s->window, s->gc, x - r, y - r,
- s->img->width + r*2 - 1, s->img->height + r*2 - 1);
+ mac_draw_rectangle (s->display, s->window, s->gc,
+ x - r, y - r,
+ s->slice.width + r*2 - 1,
+ s->slice.height + r*2 - 1);
}
}
}
else
/* Draw a rectangle if image could not be loaded. */
mac_draw_rectangle (s->display, s->window, s->gc, x, y,
- s->img->width - 1, s->img->height - 1);
+ s->slice.width - 1, s->slice.height - 1);
}
{
int x0, y0, x1, y1, thick, raised_p;
Rect r;
- int x;
- int y = s->ybase - image_ascent (s->img, s->face);
+ int x = s->x;
+ int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
if (s->face->box != FACE_NO_BOX
- && s->first_glyph->left_box_line_p)
- x = s->x + abs (s->face->box_line_width);
- else
- x = s->x;
+ && s->first_glyph->left_box_line_p
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- x += s->img->hmargin;
- y += s->img->vmargin;
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ y += s->img->vmargin;
if (s->hl == DRAW_IMAGE_SUNKEN
|| s->hl == DRAW_IMAGE_RAISED)
x0 = x - thick;
y0 = y - thick;
- x1 = x + s->img->width + thick - 1;
- y1 = y + s->img->height + thick - 1;
+ x1 = x + s->slice.width + thick - 1;
+ y1 = y + s->slice.height + thick - 1;
x_setup_relief_colors (s);
get_glyph_string_clip_rect (s, &r);
- x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
+ x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
+ s->slice.y == 0,
+ s->slice.y + s->slice.height == s->img->height,
+ s->slice.x == 0,
+ s->slice.x + s->slice.width == s->img->width,
+ &r);
}
struct glyph_string *s;
Pixmap pixmap;
{
- int x;
- int y = s->ybase - s->y - image_ascent (s->img, s->face);
+ int x = 0;
+ int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
/* If first glyph of S has a left box line, start drawing it to the
right of that line. */
if (s->face->box != FACE_NO_BOX
- && s->first_glyph->left_box_line_p)
- x = abs (s->face->box_line_width);
- else
- x = 0;
+ && s->first_glyph->left_box_line_p
+ && s->slice.x == 0)
+ x += abs (s->face->box_line_width);
/* If there is a margin around the image, adjust x- and y-position
by that margin. */
- x += s->img->hmargin;
- y += s->img->vmargin;
+ if (s->slice.x == 0)
+ x += s->img->hmargin;
+ if (s->slice.y == 0)
+ y += s->img->vmargin;
if (s->img->pixmap)
{
if (s->img->mask)
mac_copy_area_with_mask_to_pixmap (s->display, s->img->pixmap,
s->img->mask, pixmap, s->gc,
- 0, 0, s->img->width, s->img->height,
+ s->slice.x, s->slice.y,
+ s->slice.width, s->slice.height,
x, y);
else
{
mac_copy_area_to_pixmap (s->display, s->img->pixmap, pixmap, s->gc,
- 0, 0, s->img->width, s->img->height, x, y);
+ s->slice.x, s->slice.y,
+ s->slice.width, s->slice.height,
+ x, y);
/* When the image has a mask, we can expect that at
least part of a mouse highlight or a block cursor will
int r = s->img->relief;
if (r < 0) r = -r;
mac_draw_rectangle (s->display, s->window, s->gc, x - r, y - r,
- s->img->width + r*2 - 1,
- s->img->height + r*2 - 1);
+ s->slice.width + r*2 - 1,
+ s->slice.height + r*2 - 1);
}
}
}
else
/* Draw a rectangle if image could not be loaded. */
mac_draw_rectangle_to_pixmap (s->display, pixmap, s->gc, x, y,
- s->img->width - 1, s->img->height - 1);
+ s->slice.width - 1, s->slice.height - 1);
}
taller than image or if image has a clip mask to reduce
flickering. */
s->stippled_p = s->face->stipple != 0;
- if (height > s->img->height
+ if (height > s->slice.height
|| s->img->hmargin
|| s->img->vmargin
|| s->img->mask
|| s->img->pixmap == 0
|| s->width != s->background_width)
{
- if (box_line_hwidth && s->first_glyph->left_box_line_p)
- x = s->x + box_line_hwidth;
- else
- x = s->x;
+ x = s->x;
+ if (s->first_glyph->left_box_line_p
+ && s->slice.x == 0)
+ x += box_line_hwidth;
- y = s->y + box_line_vwidth;
+ y = s->y;
+ if (s->slice.y == 0)
+ y += box_line_vwidth;
if (s->img->mask)
{
mouseLoc = event->where;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (FRAME_MAC_WINDOW (f)));
-#else
- SetPort (FRAME_MAC_WINDOW (f));
-#endif
+ SetPortWindowPort (FRAME_MAC_WINDOW (f));
GlobalToLocal (&mouseLoc);
XSETINT (result->x, mouseLoc.h);
FRAME_PTR frame;
Point *pos;
{
+ struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (frame);
#if TARGET_API_MAC_CARBON
Rect r;
#endif
if (!PtInRect (*pos, &FRAME_MAC_WINDOW (frame)->portRect))
#endif
{
- frame->mouse_moved = 1;
- last_mouse_scroll_bar = Qnil;
- note_mouse_highlight (frame, -1, -1);
+ if (frame == dpyinfo->mouse_face_mouse_frame)
+ /* This case corresponds to LeaveNotify in X11. */
+ {
+ /* If we move outside the frame, then we're certainly no
+ longer on any text in the frame. */
+ clear_mouse_face (dpyinfo);
+ dpyinfo->mouse_face_mouse_frame = 0;
+ if (!dpyinfo->grabbed)
+ rif->define_frame_cursor (frame,
+ frame->output_data.mac->nontext_cursor);
+ }
}
/* Has the mouse moved off the glyph it was on at the last sighting? */
else if (pos->h < last_mouse_glyph.left
/* x is to the right of the last glyph in the row. */
rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
- /* Shouldn't this be a pixel value?
+ /* Shouldn't this be a pixel value?
WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
++KFS */
rect->right = WINDOW_RIGHT_EDGE_COL (w);
}
+static WindowPtr
+front_emacs_window ()
+{
+#if TARGET_API_MAC_CARBON
+ WindowPtr wp = GetFrontWindowOfClass (kDocumentWindowClass, true);
+
+ while (wp && !is_emacs_window (wp))
+ wp = GetNextWindowOfClass (wp, kDocumentWindowClass, true);
+#else
+ WindowPtr wp = FrontWindow ();
+
+ while (wp && (wp == tip_window || !is_emacs_window (wp)))
+ wp = GetNextWindow (wp);
+#endif
+
+ return wp;
+}
+
+#define mac_window_to_frame(wp) (((mac_output *) GetWRefCon (wp))->mFP)
+
/* Return the current position of the mouse.
*fp should be a frame which indicates which display to ask about.
{
Point mouse_pos;
int ignore1, ignore2;
- WindowPtr wp = FrontWindow ();
+ WindowPtr wp = front_emacs_window ();
struct frame *f;
Lisp_Object frame, tail;
if (is_emacs_window(wp))
- f = ((mac_output *) GetWRefCon (wp))->mFP;
+ f = mac_window_to_frame (wp);
BLOCK_INPUT;
last_mouse_scroll_bar = Qnil;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (wp));
-#else
- SetPort (wp);
-#endif
+ SetPortWindowPort (wp);
GetMouse (&mouse_pos);
if (button_event->what == mouseDown)
handle_tool_bar_click (f, x, y, 1, 0);
else
- handle_tool_bar_click (f, x, y, 0,
+ handle_tool_bar_click (f, x, y, 0,
x_mac_to_emacs_modifiers (FRAME_MAC_DISPLAY_INFO (f),
button_event->modifiers));
}
EventRecord *er;
struct input_event *bufp;
{
+ int win_y, top_range;
+
if (! GC_WINDOWP (bar->window))
abort ();
bufp->part = scroll_bar_handle;
break;
}
+
+ win_y = XINT (bufp->y) - XINT (bar->top);
+ top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (0/*dummy*/, XINT (bar->height));
+
+ win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
+
+ win_y -= 24;
+
+ if (! NILP (bar->dragging))
+ win_y -= XINT (bar->dragging);
+
+ if (win_y < 0)
+ win_y = 0;
+ if (win_y > top_range)
+ win_y = top_range;
+
+ XSETINT (bufp->x, win_y);
+ XSETINT (bufp->y, top_range);
}
unsigned long *time;
{
struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
- WindowPtr wp = FrontWindow ();
+ WindowPtr wp = front_emacs_window ();
Point mouse_pos;
- struct frame *f = ((mac_output *) GetWRefCon (wp))->mFP;
+ struct frame *f = mac_window_to_frame (wp);
int win_y, top_range;
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (wp));
-#else
- SetPort (wp);
-#endif
+ SetPortWindowPort (wp);
GetMouse (&mouse_pos);
mode lines must be clipped to the whole window. */
static void
-x_clip_to_row (w, row, gc)
+x_clip_to_row (w, row, area, gc)
struct window *w;
struct glyph_row *row;
+ int area;
GC gc;
{
struct frame *f = XFRAME (WINDOW_FRAME (w));
Rect clip_rect;
- int window_y, window_width;
+ int window_x, window_y, window_width;
- window_box (w, -1, 0, &window_y, &window_width, 0);
+ window_box (w, area, &window_x, &window_y, &window_width, 0);
- clip_rect.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+ clip_rect.left = window_x;
clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
clip_rect.top = max (clip_rect.top, window_y);
clip_rect.right = clip_rect.left + window_width;
/* Compute the proper height and ascent of the rectangle, based
on the actual glyph. Using the full height of the row looks
bad when there are tall images on that row. */
- h = max (FRAME_LINE_HEIGHT (f), cursor_glyph->ascent + cursor_glyph->descent);
+ h = max (min (FRAME_LINE_HEIGHT (f), row->height),
+ cursor_glyph->ascent + cursor_glyph->descent);
if (h < row->height)
y += row->ascent /* - w->phys_cursor_ascent */ + cursor_glyph->descent - h;
h--;
gc = dpyinfo->scratch_cursor_gc;
/* Set clipping, draw the rectangle, and reset clipping again. */
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, TEXT_AREA, gc);
mac_draw_rectangle (dpy, FRAME_MAC_WINDOW (f), gc, x, y, wd, h);
mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
}
width = min (cursor_glyph->pixel_width, width);
w->phys_cursor_width = width;
- x_clip_to_row (w, row, gc);
+ x_clip_to_row (w, row, TEXT_AREA, gc);
if (kind == BAR_CURSOR)
XFillRectangle (dpy, window, gc,
struct frame *f;
Cursor cursor;
{
- /* MAC TODO */
+#if TARGET_API_MAC_CARBON
+ SetThemeCursor (cursor);
+#else
+ SetCursor (*cursor);
+#endif
}
if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
{
int wid = FRAME_COLUMN_WIDTH (f);
- FRAME_CONFIG_SCROLL_BAR_COLS (f)
+ FRAME_CONFIG_SCROLL_BAR_COLS (f)
= (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid;
}
else
*/
\f
+void
+mac_get_window_bounds (f, inner, outer)
+ struct frame *f;
+ Rect *inner, *outer;
+{
+#if TARGET_API_MAC_CARBON
+ GetWindowBounds (FRAME_MAC_WINDOW (f), kWindowContentRgn, inner);
+ GetWindowBounds (FRAME_MAC_WINDOW (f), kWindowStructureRgn, outer);
+#else /* not TARGET_API_MAC_CARBON */
+ RgnHandle region = NewRgn ();
+
+ GetWindowRegion (FRAME_MAC_WINDOW (f), kWindowContentRgn, region);
+ *inner = (*region)->rgnBBox;
+ GetWindowRegion (FRAME_MAC_WINDOW (f), kWindowStructureRgn, region);
+ *outer = (*region)->rgnBBox;
+ DisposeRgn (region);
+#endif /* not TARGET_API_MAC_CARBON */
+}
+
+
/* Calculate the absolute position in frame F
from its current recorded position values and gravity. */
x_calc_absolute_position (f)
struct frame *f;
{
- Point pt;
+ int width_diff = 0, height_diff = 0;
int flags = f->size_hint_flags;
+ Rect inner, outer;
- pt.h = pt.v = 0;
+ /* We have nothing to do if the current position
+ is already for the top-left corner. */
+ if (! ((flags & XNegative) || (flags & YNegative)))
+ return;
- /* Find the position of the outside upper-left corner of
+ /* Find the offsets of the outside upper-left corner of
the inner window, with respect to the outer window. */
- if (f->output_data.mac->parent_desc != FRAME_MAC_DISPLAY_INFO (f)->root_window)
- {
- GrafPtr savePort;
- GetPort (&savePort);
+ mac_get_window_bounds (f, &inner, &outer);
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (FRAME_MAC_WINDOW (f)));
-#else
- SetPort (FRAME_MAC_WINDOW (f));
-#endif
-
-#if TARGET_API_MAC_CARBON
- {
- Rect r;
-
- GetWindowPortBounds (FRAME_MAC_WINDOW (f), &r);
- SetPt(&pt, r.left, r.top);
- }
-#else /* not TARGET_API_MAC_CARBON */
- SetPt(&pt, FRAME_MAC_WINDOW (f)->portRect.left, FRAME_MAC_WINDOW (f)->portRect.top);
-#endif /* not TARGET_API_MAC_CARBON */
- LocalToGlobal (&pt);
- SetPort (savePort);
- }
+ width_diff = (outer.right - outer.left) - (inner.right - inner.left);
+ height_diff = (outer.bottom - outer.top) - (inner.bottom - inner.top);
/* Treat negative positions as relative to the leftmost bottommost
position that fits on the screen. */
if (flags & XNegative)
f->left_pos = (FRAME_MAC_DISPLAY_INFO (f)->width
- - 2 * f->border_width - pt.h
+ - width_diff
- FRAME_PIXEL_WIDTH (f)
+ f->left_pos);
- /* NTEMACS_TODO: Subtract menubar height? */
+
if (flags & YNegative)
f->top_pos = (FRAME_MAC_DISPLAY_INFO (f)->height
- - 2 * f->border_width - pt.v
+ - height_diff
- FRAME_PIXEL_HEIGHT (f)
+ f->top_pos);
+
/* The left_pos and top_pos
are now relative to the top and left screen edges,
so the flags should correspond. */
register int xoff, yoff;
int change_gravity;
{
- int modified_top, modified_left;
-
if (change_gravity > 0)
{
f->top_pos = yoff;
BLOCK_INPUT;
x_wm_set_size_hint (f, (long) 0, 0);
- modified_left = f->left_pos;
- modified_top = f->top_pos;
-
- MoveWindow (f->output_data.mac->mWP, modified_left + 6,
- modified_top + 42, false);
+#if TARGET_API_MAC_CARBON
+ MoveWindowStructure (FRAME_MAC_WINDOW (f), f->left_pos, f->top_pos);
+ /* If the title bar is completely outside the screen, adjust the
+ position. */
+ ConstrainWindowToScreen (FRAME_MAC_WINDOW (f), kWindowTitleBarRgn,
+ kWindowConstrainMoveRegardlessOfFit
+ | kWindowConstrainAllowPartial, NULL, NULL);
+ x_real_positions (f, &f->left_pos, &f->top_pos);
+#else
+ {
+ Rect inner, outer, screen_rect, dummy;
+ RgnHandle region = NewRgn ();
+
+ mac_get_window_bounds (f, &inner, &outer);
+ f->x_pixels_diff = inner.left - outer.left;
+ f->y_pixels_diff = inner.top - outer.top;
+ MoveWindow (FRAME_MAC_WINDOW (f), f->left_pos + f->x_pixels_diff,
+ f->top_pos + f->y_pixels_diff, false);
+
+ /* If the title bar is completely outside the screen, adjust the
+ position. The variable `outer' holds the title bar rectangle.
+ The variable `inner' holds slightly smaller one than `outer',
+ so that the calculation of overlapping may not become too
+ strict. */
+ GetWindowRegion (FRAME_MAC_WINDOW (f), kWindowTitleBarRgn, region);
+ outer = (*region)->rgnBBox;
+ DisposeRgn (region);
+ inner = outer;
+ InsetRect (&inner, 8, 8);
+ screen_rect = qd.screenBits.bounds;
+ screen_rect.top += GetMBarHeight ();
+
+ if (!SectRect (&inner, &screen_rect, &dummy))
+ {
+ if (inner.right <= screen_rect.left)
+ f->left_pos = screen_rect.left;
+ else if (inner.left >= screen_rect.right)
+ f->left_pos = screen_rect.right - (outer.right - outer.left);
+
+ if (inner.bottom <= screen_rect.top)
+ f->top_pos = screen_rect.top;
+ else if (inner.top >= screen_rect.bottom)
+ f->top_pos = screen_rect.bottom - (outer.bottom - outer.top);
+
+ MoveWindow (FRAME_MAC_WINDOW (f), f->left_pos + f->x_pixels_diff,
+ f->top_pos + f->y_pixels_diff, false);
+ }
+ }
+#endif
UNBLOCK_INPUT;
}
struct frame *f;
{
if (f->async_visible)
- SelectWindow (FRAME_MAC_WINDOW (f));
+ {
+ BLOCK_INPUT;
+ SelectWindow (FRAME_MAC_WINDOW (f));
+ UNBLOCK_INPUT;
+ }
}
/* Lower frame F. */
struct frame *f;
{
if (f->async_visible)
- SendBehind (FRAME_MAC_WINDOW (f), nil);
+ {
+ BLOCK_INPUT;
+ SendBehind (FRAME_MAC_WINDOW (f), nil);
+ UNBLOCK_INPUT;
+ }
}
static void
XFlush (FRAME_MAC_DISPLAY (f));
-#if 0 /* MAC_TODO */
/* Synchronize to ensure Emacs knows the frame is visible
before we do anything else. We do this loop with input not blocked
so that incoming events are handled. */
FRAME_SAMPLE_VISIBILITY (f);
}
}
-#else
- UNBLOCK_INPUT;
-#endif /* MAC_TODO */
}
/* Change from mapped state to withdrawn state. */
struct frame *f;
{
struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
+ WindowPtr wp = FRAME_MAC_WINDOW (f);
BLOCK_INPUT;
- DisposeWindow (FRAME_MAC_WINDOW (f));
+ DisposeWindow (wp);
+ if (wp == tip_window)
+ /* Neither WaitNextEvent nor ReceiveNextEvent receives `window
+ closed' event. So we reset tip_window here. */
+ tip_window = NULL;
free_frame_menubar (f);
break;
case smKorean:
coding_system = Qeuc_kr;
- break;
+ break;
default:
return;
}
if (fast_string_match (pattern_regex, fontname) >= 0)
{
font_list = Fcons (fontname, font_list);
-
+
n_fonts++;
if (maxnames > 0 && n_fonts >= maxnames)
break;
/* true when cannot handle any Mac OS events */
static int handling_window_update = 0;
+#if 0
/* the flag appl_is_suspended is used both for determining the sleep
time to be passed to WaitNextEvent and whether the cursor should be
drawn when updating the display. The cursor is turned off when
suspended. */
static Boolean app_is_suspended = false;
static long app_sleep_time = WNE_SLEEP_AT_RESUME;
+#endif
#define EXTRA_STACK_ALLOC (256 * 1024)
/* True if using command key as meta key. */
Lisp_Object Vmac_command_key_is_meta;
+/* Modifier associated with the option key, or nil for normal behavior. */
+Lisp_Object Vmac_option_modifier;
+
/* True if the ctrl and meta keys should be reversed. */
Lisp_Object Vmac_reverse_ctrl_meta;
Point saved_menu_event_location;
+#if !TARGET_API_MAC_CARBON
+/* Place holder for the default arrow cursor. */
+CursPtr arrow_cursor;
+#endif
+
/* Apple Events */
static void init_required_apple_events (void);
static pascal OSErr
result |= meta_modifier;
if (NILP (Vmac_command_key_is_meta) && (mods & macAltKey))
result |= alt_modifier;
+ if (!NILP (Vmac_option_modifier) && (mods & optionKey)) {
+ Lisp_Object val = Fget(Vmac_option_modifier, Qmodifier_value);
+ if (!NILP(val))
+ result |= XUINT(val);
+ }
+
return result;
}
mac_get_emulated_btn ( UInt32 modifiers )
{
int result = 0;
- if (Vmac_emulate_three_button_mouse != Qnil) {
- int cmdIs3 = (Vmac_emulate_three_button_mouse != Qreverse);
- if (modifiers & controlKey)
+ if (!NILP (Vmac_emulate_three_button_mouse)) {
+ int cmdIs3 = !EQ (Vmac_emulate_three_button_mouse, Qreverse);
+ if (modifiers & cmdKey)
result = cmdIs3 ? 2 : 1;
else if (modifiers & optionKey)
- result = cmdIs3 ? 1 : 2;
+ result = cmdIs3 ? 1 : 2;
}
return result;
}
UInt32 mods = 0;
GetEventParameter (eventRef, kEventParamKeyModifiers, typeUInt32, NULL,
sizeof (UInt32), NULL, &mods);
- if (Vmac_emulate_three_button_mouse != Qnil &&
+ if (!NILP (Vmac_emulate_three_button_mouse) &&
GetEventClass(eventRef) == kEventClassMouse)
{
- mods &= ~(optionKey & cmdKey);
+ mods &= ~(optionKey | cmdKey);
}
return mac_to_emacs_modifiers (mods);
}
switch (result)
{
case kEventMouseButtonPrimary:
- if (Vmac_emulate_three_button_mouse == Qnil)
+ if (NILP (Vmac_emulate_three_button_mouse))
return 0;
else {
UInt32 mods = 0;
InitCursor ();
#if !TARGET_API_MAC_CARBON
+ arrow_cursor = &qd.arrow;
+
/* set up some extra stack space for use by emacs */
SetApplLimit ((Ptr) ((long) GetApplLimit () - EXTRA_STACK_ALLOC));
static void
do_window_update (WindowPtr win)
{
- struct mac_output *mwp = (mac_output *) GetWRefCon (win);
- struct frame *f = mwp->mFP;
+ struct frame *f = mac_window_to_frame (win);
+
+ if (win == tip_window)
+ /* The tooltip has been drawn already. Avoid the
+ SET_FRAME_GARBAGED below. */
+ return;
if (f)
{
return 0;
}
-static void
-do_window_activate (WindowPtr win)
-{
- mac_output *mwp;
- struct frame *f;
-
- if (is_emacs_window (win))
- {
- mwp = (mac_output *) GetWRefCon (win);
- f = mwp->mFP;
-
- if (f)
- {
- x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f), f);
- activate_scroll_bars (f);
- }
- }
-}
-
-static void
-do_window_deactivate (WindowPtr win)
-{
- mac_output *mwp;
- struct frame *f;
-
- if (is_emacs_window (win))
- {
- mwp = (mac_output *) GetWRefCon (win);
- f = mwp->mFP;
-
- if (f == FRAME_MAC_DISPLAY_INFO (f)->x_focus_frame)
- {
- x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f), 0);
- deactivate_scroll_bars (f);
- }
- }
-}
-
static void
do_app_resume ()
{
+ /* Window-activate events will do the job. */
+#if 0
WindowPtr wp;
- mac_output *mwp;
struct frame *f;
- wp = FrontWindow();
- if (is_emacs_window (wp))
+ wp = front_emacs_window ();
+ if (wp)
{
- mwp = (mac_output *) GetWRefCon (wp);
- f = mwp->mFP;
+ f = mac_window_to_frame (wp);
if (f)
{
app_is_suspended = false;
app_sleep_time = WNE_SLEEP_AT_RESUME;
+#endif
}
static void
do_app_suspend ()
{
+ /* Window-deactivate events will do the job. */
+#if 0
WindowPtr wp;
- mac_output *mwp;
struct frame *f;
- wp = FrontWindow();
- if (is_emacs_window (wp))
+ wp = front_emacs_window ();
+ if (wp)
{
- mwp = (mac_output *) GetWRefCon (wp);
- f = mwp->mFP;
+ f = mac_window_to_frame (wp);
if (f == FRAME_MAC_DISPLAY_INFO (f)->x_focus_frame)
{
app_is_suspended = true;
app_sleep_time = WNE_SLEEP_AT_SUSPEND;
+#endif
}
static void
-do_mouse_moved (Point mouse_pos)
+do_mouse_moved (mouse_pos, f)
+ Point mouse_pos;
+ FRAME_PTR *f;
{
- WindowPtr wp = FrontWindow ();
- struct frame *f;
+ WindowPtr wp = front_emacs_window ();
+ struct x_display_info *dpyinfo;
- if (is_emacs_window (wp))
+ if (wp)
{
- f = ((mac_output *) GetWRefCon (wp))->mFP;
+ *f = mac_window_to_frame (wp);
+ dpyinfo = FRAME_MAC_DISPLAY_INFO (*f);
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (wp));
-#else
- SetPort (wp);
-#endif
+ if (dpyinfo->mouse_face_hidden)
+ {
+ dpyinfo->mouse_face_hidden = 0;
+ clear_mouse_face (dpyinfo);
+ }
+
+ SetPortWindowPort (wp);
GlobalToLocal (&mouse_pos);
- note_mouse_movement (f, &mouse_pos);
+ if (dpyinfo->grabbed && tracked_scroll_bar)
+ x_scroll_bar_note_movement (tracked_scroll_bar,
+ mouse_pos.v
+ - XINT (tracked_scroll_bar->top),
+ TickCount() * (1000 / 60));
+ else
+ note_mouse_movement (*f, &mouse_pos);
}
}
static void
-do_os_event (EventRecord *erp)
+do_apple_menu (SInt16 menu_item)
{
- switch((erp->message >> 24) & 0x000000FF)
- {
- case suspendResumeMessage:
- if((erp->message & resumeFlag) == 1)
- do_app_resume ();
- else
- do_app_suspend ();
- break;
+#if !TARGET_API_MAC_CARBON
+ Str255 item_name;
+ SInt16 da_driver_refnum;
- case mouseMovedMessage:
- do_mouse_moved (erp->where);
- break;
+ if (menu_item == I_ABOUT)
+ NoteAlert (ABOUT_ALERT_ID, NULL);
+ else
+ {
+ GetMenuItemText (GetMenuHandle (M_APPLE), menu_item, item_name);
+ da_driver_refnum = OpenDeskAcc (item_name);
}
+#endif /* !TARGET_API_MAC_CARBON */
}
-static void
-do_events (EventRecord *erp)
-{
- switch (erp->what)
- {
- case updateEvt:
- do_window_update ((WindowPtr) erp->message);
- break;
-
- case osEvt:
- do_os_event (erp);
- break;
-
- case activateEvt:
- if ((erp->modifiers & activeFlag) != 0)
- do_window_activate ((WindowPtr) erp->message);
- else
- do_window_deactivate ((WindowPtr) erp->message);
- break;
- }
-}
-
-static void
-do_apple_menu (SInt16 menu_item)
-{
-#if !TARGET_API_MAC_CARBON
- Str255 item_name;
- SInt16 da_driver_refnum;
-
- if (menu_item == I_ABOUT)
- NoteAlert (ABOUT_ALERT_ID, NULL);
- else
- {
- GetMenuItemText (GetMenuHandle (M_APPLE), menu_item, item_name);
- da_driver_refnum = OpenDeskAcc (item_name);
- }
-#endif /* !TARGET_API_MAC_CARBON */
-}
-
-void
-do_menu_choice (SInt32 menu_choice)
+void
+do_menu_choice (SInt32 menu_choice)
{
SInt16 menu_id, menu_item;
default:
{
- WindowPtr wp = FrontWindow ();
- struct frame *f = ((mac_output *) GetWRefCon (wp))->mFP;
+ struct frame *f = mac_window_to_frame (front_emacs_window ());
MenuHandle menu = GetMenuHandle (menu_id);
if (menu)
{
long grow_size;
Rect limit_rect;
int rows, columns;
- mac_output *mwp = (mac_output *) GetWRefCon (w);
- struct frame *f = mwp->mFP;
+ struct frame *f = mac_window_to_frame (w);
SetRect(&limit_rect, MIN_DOC_SIZE, MIN_DOC_SIZE, MAX_DOC_SIZE, MAX_DOC_SIZE);
GrafPtr save_port;
Rect zoom_rect, port_rect;
Point top_left;
- int w_title_height, columns, rows, width, height, dummy, x, y;
- mac_output *mwp = (mac_output *) GetWRefCon (w);
- struct frame *f = mwp->mFP;
-
- GetPort (&save_port);
-
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (w));
-#else
- SetPort (w);
-#endif
+ int w_title_height, columns, rows;
+ struct frame *f = mac_window_to_frame (w);
- /* Clear window to avoid flicker. */
#if TARGET_API_MAC_CARBON
{
- Rect r;
- BitMap bm;
+ Point standard_size;
- GetWindowPortBounds (w, &r);
- EraseRect (&r);
+ standard_size.h = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, DEFAULT_NUM_COLS);
+ standard_size.v = FRAME_MAC_DISPLAY_INFO (f)->height;
- if (zoom_in_or_out == inZoomOut)
+ if (IsWindowInStandardState (w, &standard_size, &zoom_rect))
+ zoom_in_or_out = inZoomIn;
+ else
{
- /* calculate height of window's title bar (hard card it for now). */
- w_title_height = 20 + GetMBarHeight ();
-
- /* get maximum height of window into zoom_rect.bottom -
- zoom_rect.top */
- GetQDGlobalsScreenBits (&bm);
- zoom_rect = bm.bounds;
- zoom_rect.top += w_title_height;
- InsetRect (&zoom_rect, 8, 4); /* not too tight */
-
- zoom_rect.right = zoom_rect.left
- + FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, DEFAULT_NUM_COLS);
-
- SetWindowStandardState (w, &zoom_rect);
+ /* Adjust the standard size according to character boundaries. */
+
+ columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, zoom_rect.right - zoom_rect.left);
+ rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, zoom_rect.bottom - zoom_rect.top);
+ standard_size.h = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, columns);
+ standard_size.v = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+ GetWindowBounds (w, kWindowContentRgn, &port_rect);
+ if (IsWindowInStandardState (w, &standard_size, &zoom_rect)
+ && port_rect.left == zoom_rect.left
+ && port_rect.top == zoom_rect.top)
+ zoom_in_or_out = inZoomIn;
+ else
+ zoom_in_or_out = inZoomOut;
}
+
+ ZoomWindowIdeal (w, zoom_in_or_out, &standard_size);
}
#else /* not TARGET_API_MAC_CARBON */
+ GetPort (&save_port);
+
+ SetPortWindowPort (w);
+
+ /* Clear window to avoid flicker. */
EraseRect (&(w->portRect));
if (zoom_in_or_out == inZoomOut)
{
zoom_rect.right = zoom_rect.left
+ FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, DEFAULT_NUM_COLS);
+ /* Adjust the standard size according to character boundaries. */
+ rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, zoom_rect.bottom - zoom_rect.top);
+ zoom_rect.bottom =
+ zoom_rect.top + FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
+
(**((WStateDataHandle) ((WindowPeek) w)->dataHandle)).stdState
= zoom_rect;
}
-#endif /* not TARGET_API_MAC_CARBON */
- ZoomWindow (w, zoom_in_or_out, w == FrontWindow ());
+ ZoomWindow (w, zoom_in_or_out, w == front_emacs_window ());
+
+ SetPort (save_port);
+#endif /* not TARGET_API_MAC_CARBON */
/* retrieve window size and update application values */
#if TARGET_API_MAC_CARBON
#endif
rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, port_rect.bottom - port_rect.top);
columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, port_rect.right - port_rect.left);
- x_set_window_size (mwp->mFP, 0, columns, rows);
-
- SetPort (save_port);
+ x_set_window_size (f, 0, columns, rows);
+ x_real_positions (f, &f->left_pos, &f->top_pos);
}
/* Initialize Drag And Drop to allow files to be dropped onto emacs frames */
{
struct input_event event;
Lisp_Object frame;
- struct frame *f = ((mac_output *) GetWRefCon(window))->mFP;
- SetPort (GetWindowPort (window));
+ struct frame *f = mac_window_to_frame (window);
+ SetPortWindowPort (window);
GlobalToLocal (&mouse);
event.kind = DRAG_N_DROP_EVENT;
/* Emacs calls this whenever it wants to read an input event from the
user. */
int
-XTread_socket (int sd, int expected, struct input_event *hold_quit)
+XTread_socket (sd, expected, hold_quit)
+ int sd, expected;
+ struct input_event *hold_quit;
{
struct input_event inev;
int count = 0;
#if USE_CARBON_EVENTS
- OSStatus rneResult;
EventRef eventRef;
- EventMouseButton mouseBtn;
+ EventTargetRef toolbox_dispatcher = GetEventDispatcherTarget ();
+#else
+ EventMask event_mask;
#endif
EventRecord er;
- int the_modifiers;
- EventMask event_mask;
+ struct mac_display_info *dpyinfo = &one_mac_display_info;
-#if 0
if (interrupt_input_blocked)
{
interrupt_input_pending = 1;
return -1;
}
-#endif
interrupt_input_pending = 0;
BLOCK_INPUT;
if (terminate_flag)
Fkill_emacs (make_number (1));
- /* It is necessary to set this (additional) argument slot of an
- event to nil because keyboard.c protects incompletely processed
- event from being garbage collected by placing them in the
- kbd_buffer_gcpro vector. */
- EVENT_INIT (inev);
- inev.kind = NO_EVENT;
- inev.arg = Qnil;
-
+#if !USE_CARBON_EVENTS
event_mask = everyEvent;
if (NILP (Fboundp (Qmac_ready_for_drag_n_drop)))
event_mask -= highLevelEventMask;
-#if USE_CARBON_EVENTS
- rneResult = ReceiveNextEvent (0, NULL,
- expected
- ? TicksToEventTime (app_sleep_time)
- : 0,
- kEventRemoveFromQueue, &eventRef);
- if (!rneResult)
+ while (WaitNextEvent (event_mask, &er, 0L, NULL))
+#else /* USE_CARBON_EVENTS */
+ while (!ReceiveNextEvent (0, NULL, kEventDurationNoWait,
+ kEventRemoveFromQueue, &eventRef))
+#endif /* USE_CARBON_EVENTS */
{
+ int do_help = 0;
+ struct frame *f;
+
+ /* It is necessary to set this (additional) argument slot of an
+ event to nil because keyboard.c protects incompletely
+ processed event from being garbage collected by placing them
+ in the kbd_buffer_gcpro vector. */
+ EVENT_INIT (inev);
+ inev.kind = NO_EVENT;
+ inev.arg = Qnil;
+
+#if USE_CARBON_EVENTS
/* Handle new events */
if (!mac_convert_event_ref (eventRef, &er))
switch (GetEventClass (eventRef))
{
+ case kEventClassWindow:
+ if (GetEventKind (eventRef) == kEventWindowBoundsChanged)
+ {
+ WindowPtr window_ptr;
+ GetEventParameter(eventRef, kEventParamDirectObject,
+ typeWindowRef, NULL, sizeof(WindowPtr),
+ NULL, &window_ptr);
+ f = mac_window_to_frame (window_ptr);
+ if (f && !f->async_iconified)
+ x_real_positions (f, &f->left_pos, &f->top_pos);
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
+ }
+ break;
case kEventClassMouse:
if (GetEventKind (eventRef) == kEventMouseWheelMoved)
{
SInt32 delta;
Point point;
- WindowPtr window_ptr = FrontNonFloatingWindow ();
- struct mac_output *mwp = (mac_output *) GetWRefCon (window_ptr);
+ WindowPtr window_ptr = front_emacs_window ();
+
if (!IsValidWindowPtr (window_ptr))
{
SysBeep(1);
- UNBLOCK_INPUT;
- return 0;
+ break;
}
GetEventParameter(eventRef, kEventParamMouseWheelDelta,
NULL, &point);
inev.kind = WHEEL_EVENT;
inev.code = 0;
- inev.modifiers = (mac_event_to_emacs_modifiers(eventRef)
+ inev.modifiers = (mac_event_to_emacs_modifiers (eventRef)
| ((delta < 0) ? down_modifier
: up_modifier));
- SetPort (GetWindowPort (window_ptr));
+ SetPortWindowPort (window_ptr);
GlobalToLocal (&point);
XSETINT (inev.x, point.h);
XSETINT (inev.y, point.v);
- XSETFRAME (inev.frame_or_window, mwp->mFP);
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (window_ptr));
inev.timestamp = EventTimeToTicks (GetEventTime (eventRef))*(1000/60);
}
else
- SendEventToEventTarget (eventRef, GetEventDispatcherTarget ());
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
break;
default:
/* Send the event to the appropriate receiver. */
- SendEventToEventTarget (eventRef, GetEventDispatcherTarget ());
+ SendEventToEventTarget (eventRef, toolbox_dispatcher);
}
else
-#else
- if (WaitNextEvent (event_mask, &er, (expected ? app_sleep_time : 0L), NULL))
#endif /* USE_CARBON_EVENTS */
- switch (er.what)
- {
- case mouseDown:
- case mouseUp:
+ switch (er.what)
{
- WindowPtr window_ptr = FrontWindow ();
- SInt16 part_code;
+ case mouseDown:
+ case mouseUp:
+ {
+ WindowPtr window_ptr;
+ SInt16 part_code;
+ int tool_bar_p = 0;
#if USE_CARBON_EVENTS
- /* This is needed to send mouse events like aqua window buttons
- to the correct handler. */
- if (eventNotHandledErr != SendEventToEventTarget (eventRef, GetEventDispatcherTarget ())) {
- break;
- }
-
- if (!is_emacs_window(window_ptr))
- break;
-#endif
-
- if (mouse_tracking_in_progress == mouse_tracking_scroll_bar
- && er.what == mouseUp)
- {
- struct mac_output *mwp = (mac_output *) GetWRefCon (window_ptr);
- Point mouse_loc = er.where;
-
- /* Convert to local coordinates of new window. */
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (window_ptr));
-#else
- SetPort (window_ptr);
+ /* This is needed to send mouse events like aqua window
+ buttons to the correct handler. */
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
#endif
- GlobalToLocal (&mouse_loc);
+ if (dpyinfo->grabbed && last_mouse_frame
+ && FRAME_LIVE_P (last_mouse_frame))
+ {
+ window_ptr = FRAME_MAC_WINDOW (last_mouse_frame);
+ part_code = inContent;
+ }
+ else
+ {
+ part_code = FindWindow (er.where, &window_ptr);
+ if (tip_window && window_ptr == tip_window)
+ {
+ HideWindow (tip_window);
+ part_code = FindWindow (er.where, &window_ptr);
+ }
+ }
-#if USE_CARBON_EVENTS
- inev.code = mac_get_mouse_btn (eventRef);
-#else
- inev.code = mac_get_emulate_btn (er.modifiers);
-#endif
- inev.kind = SCROLL_BAR_CLICK_EVENT;
- inev.frame_or_window = tracked_scroll_bar->window;
- inev.part = scroll_bar_handle;
-#if USE_CARBON_EVENTS
- inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
-#else
- inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
-#endif
- inev.modifiers |= up_modifier;
- inev.timestamp = er.when * (1000 / 60);
- /* ticks to milliseconds */
-
- XSETINT (inev.x, tracked_scroll_bar->left + 2);
- XSETINT (inev.y, mouse_loc.v - 24);
- tracked_scroll_bar->dragging = Qnil;
- mouse_tracking_in_progress = mouse_tracking_none;
- tracked_scroll_bar = NULL;
- break;
- }
+ if (er.what != mouseDown && part_code != inContent)
+ break;
- part_code = FindWindow (er.where, &window_ptr);
+ switch (part_code)
+ {
+ case inMenuBar:
+ f = mac_window_to_frame (front_emacs_window ());
+ saved_menu_event_location = er.where;
+ inev.kind = MENU_BAR_ACTIVATE_EVENT;
+ XSETFRAME (inev.frame_or_window, f);
+ break;
- switch (part_code)
- {
- case inMenuBar:
- if (er.what == mouseDown)
- {
- struct frame *f = ((mac_output *)
- GetWRefCon (FrontWindow ()))->mFP;
- saved_menu_event_location = er.where;
- inev.kind = MENU_BAR_ACTIVATE_EVENT;
- XSETFRAME (inev.frame_or_window, f);
- }
- break;
+ case inContent:
+ if (window_ptr != front_emacs_window ())
+ SelectWindow (window_ptr);
+ else
+ {
+ SInt16 control_part_code;
+ ControlHandle ch;
+ Point mouse_loc = er.where;
- case inContent:
- if (window_ptr != FrontWindow ())
- SelectWindow (window_ptr);
- else
- {
- SInt16 control_part_code;
- ControlHandle ch;
- struct mac_output *mwp = (mac_output *)
- GetWRefCon (window_ptr);
- Point mouse_loc = er.where;
-
- /* convert to local coordinates of new window */
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (window_ptr));
-#else
- SetPort (window_ptr);
-#endif
+ f = mac_window_to_frame (window_ptr);
+ /* convert to local coordinates of new window */
+ SetPortWindowPort (window_ptr);
- GlobalToLocal (&mouse_loc);
+ GlobalToLocal (&mouse_loc);
#if TARGET_API_MAC_CARBON
- ch = FindControlUnderMouse (mouse_loc, window_ptr,
- &control_part_code);
+ ch = FindControlUnderMouse (mouse_loc, window_ptr,
+ &control_part_code);
#else
- control_part_code = FindControl (mouse_loc, window_ptr, &ch);
+ control_part_code = FindControl (mouse_loc, window_ptr,
+ &ch);
#endif
#if USE_CARBON_EVENTS
- inev.code = mac_get_mouse_btn (eventRef);
+ inev.code = mac_get_mouse_btn (eventRef);
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
#else
- inev.code = mac_get_emulate_btn (er.modifiers);
+ inev.code = mac_get_emulated_btn (er.modifiers);
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
#endif
- XSETINT (inev.x, mouse_loc.h);
- XSETINT (inev.y, mouse_loc.v);
- inev.timestamp = er.when * (1000 / 60);
+ XSETINT (inev.x, mouse_loc.h);
+ XSETINT (inev.y, mouse_loc.v);
+ inev.timestamp = er.when * (1000 / 60);
/* ticks to milliseconds */
+ if (dpyinfo->grabbed && tracked_scroll_bar
#if TARGET_API_MAC_CARBON
- if (ch != 0)
+ || ch != 0
#else
- if (control_part_code != 0)
+ || control_part_code != 0
#endif
- {
- struct scroll_bar *bar = (struct scroll_bar *)
- GetControlReference (ch);
- x_scroll_bar_handle_click (bar, control_part_code, &er,
- &inev);
- if (er.what == mouseDown
- && control_part_code == kControlIndicatorPart)
- {
- mouse_tracking_in_progress
- = mouse_tracking_scroll_bar;
- tracked_scroll_bar = bar;
- }
- else
- {
- mouse_tracking_in_progress = mouse_tracking_none;
- tracked_scroll_bar = NULL;
- }
- }
- else
- {
- Lisp_Object window;
-
- inev.kind = MOUSE_CLICK_EVENT;
- XSETFRAME (inev.frame_or_window, mwp->mFP);
- if (er.what == mouseDown)
- mouse_tracking_in_progress
- = mouse_tracking_mouse_movement;
- else
- mouse_tracking_in_progress = mouse_tracking_none;
- window = window_from_coordinates (mwp->mFP, inev.x, inev.y, 0, 0, 0, 1);
-
- if (EQ (window, mwp->mFP->tool_bar_window))
- {
- if (er.what == mouseDown)
- handle_tool_bar_click (mwp->mFP, inev.x, inev.y, 1, 0);
- else
- handle_tool_bar_click (mwp->mFP, inev.x, inev.y, 0,
+ )
+ {
+ struct scroll_bar *bar;
+
+ if (dpyinfo->grabbed && tracked_scroll_bar)
+ {
+ bar = tracked_scroll_bar;
+ control_part_code = kControlIndicatorPart;
+ }
+ else
+ bar = (struct scroll_bar *) GetControlReference (ch);
+ x_scroll_bar_handle_click (bar, control_part_code,
+ &er, &inev);
+ if (er.what == mouseDown
+ && control_part_code == kControlIndicatorPart)
+ tracked_scroll_bar = bar;
+ else
+ tracked_scroll_bar = NULL;
+ }
+ else
+ {
+ Lisp_Object window;
+ int x = mouse_loc.h;
+ int y = mouse_loc.v;
+
+ window = window_from_coordinates (f, x, y, 0, 0, 0, 1);
+ if (EQ (window, f->tool_bar_window))
+ {
+ if (er.what == mouseDown)
+ handle_tool_bar_click (f, x, y, 1, 0);
+ else
+ handle_tool_bar_click (f, x, y, 0,
+ inev.modifiers);
+ tool_bar_p = 1;
+ }
+ else
+ {
+ XSETFRAME (inev.frame_or_window, f);
+ inev.kind = MOUSE_CLICK_EVENT;
+ }
+ }
+
+ if (er.what == mouseDown)
+ {
+ dpyinfo->grabbed |= (1 << inev.code);
+ last_mouse_frame = f;
+ /* Ignore any mouse motion that happened
+ before this event; any subsequent
+ mouse-movement Emacs events should reflect
+ only motion after the ButtonPress. */
+ if (f != 0)
+ f->mouse_moved = 0;
+
+ if (!tool_bar_p)
+ last_tool_bar_item = -1;
+ }
+ else
+ {
+ if ((dpyinfo->grabbed & (1 << inev.code)) == 0)
+ /* If a button is released though it was not
+ previously pressed, that would be because
+ of multi-button emulation. */
+ dpyinfo->grabbed = 0;
+ else
+ dpyinfo->grabbed &= ~(1 << inev.code);
+ }
+
+ switch (er.what)
+ {
+ case mouseDown:
+ inev.modifiers |= down_modifier;
+ break;
+ case mouseUp:
+ inev.modifiers |= up_modifier;
+ break;
+ }
+ }
+ break;
+
+ case inDrag:
+#if TARGET_API_MAC_CARBON
+ DragWindow (window_ptr, er.where, NULL);
+#else /* not TARGET_API_MAC_CARBON */
+ DragWindow (window_ptr, er.where, &qd.screenBits.bounds);
+#endif /* not TARGET_API_MAC_CARBON */
+ /* Update the frame parameters. */
+ {
+ struct frame *f = mac_window_to_frame (window_ptr);
+
+ if (f && !f->async_iconified)
+ x_real_positions (f, &f->left_pos, &f->top_pos);
+ }
+ break;
+
+ case inGoAway:
+ if (TrackGoAway (window_ptr, er.where))
+ {
+ inev.kind = DELETE_WINDOW_EVENT;
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (window_ptr));
+ }
+ break;
+
+ /* window resize handling added --ben */
+ case inGrow:
+ do_grow_window (window_ptr, &er);
+ break;
+
+ /* window zoom handling added --ben */
+ case inZoomIn:
+ case inZoomOut:
+ if (TrackBox (window_ptr, er.where, part_code))
+ do_zoom_window (window_ptr, part_code);
+ break;
+
+ default:
+ break;
+ }
+ }
+ break;
+
+ case updateEvt:
#if USE_CARBON_EVENTS
- mac_event_to_emacs_modifiers (eventRef)
-#else
- er.modifiers
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
#endif
- );
- break;
- }
- }
+ do_window_update ((WindowPtr) er.message);
+ break;
+ case osEvt:
#if USE_CARBON_EVENTS
- inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
-#else
- inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
#endif
-
- switch (er.what)
- {
- case mouseDown:
- inev.modifiers |= down_modifier;
- break;
- case mouseUp:
- inev.modifiers |= up_modifier;
- break;
- }
- }
+ switch ((er.message >> 24) & 0x000000FF)
+ {
+ case suspendResumeMessage:
+ if ((er.message & resumeFlag) == 1)
+ do_app_resume ();
+ else
+ do_app_suspend ();
break;
- case inDrag:
-#if TARGET_API_MAC_CARBON
- if (er.what == mouseDown)
- {
- BitMap bm;
-
- GetQDGlobalsScreenBits (&bm);
- DragWindow (window_ptr, er.where, &bm.bounds);
- }
-#else /* not TARGET_API_MAC_CARBON */
- DragWindow (window_ptr, er.where, &qd.screenBits.bounds);
-#endif /* not TARGET_API_MAC_CARBON */
- break;
+ case mouseMovedMessage:
+ previous_help_echo_string = help_echo_string;
+ help_echo_string = help_echo_object = help_echo_window = Qnil;
+ help_echo_pos = -1;
- case inGoAway:
- if (TrackGoAway (window_ptr, er.where))
- {
- inev.kind = DELETE_WINDOW_EVENT;
- XSETFRAME (inev.frame_or_window,
- ((mac_output *) GetWRefCon (window_ptr))->mFP);
- }
+ do_mouse_moved (er.where, &f);
+
+ /* If the contents of the global variable
+ help_echo_string has changed, generate a
+ HELP_EVENT. */
+ if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
+ do_help = 1;
break;
+ }
+ break;
- /* window resize handling added --ben */
- case inGrow:
- if (er.what == mouseDown)
- {
- do_grow_window(window_ptr, &er);
- break;
- }
+ case activateEvt:
+ {
+ WindowPtr window_ptr = (WindowPtr) er.message;
- /* window zoom handling added --ben */
- case inZoomIn:
- case inZoomOut:
- if (TrackBox (window_ptr, er.where, part_code))
- do_zoom_window (window_ptr, part_code);
+#if USE_CARBON_EVENTS
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
break;
+#endif
+ if (window_ptr == tip_window)
+ {
+ HideWindow (tip_window);
+ break;
+ }
- default:
+ if (!is_emacs_window (window_ptr))
break;
- }
- }
- break;
- case updateEvt:
- case osEvt:
- case activateEvt:
-#if USE_CARBON_EVENTS
- if (eventNotHandledErr == SendEventToEventTarget (eventRef, GetEventDispatcherTarget ()))
-#endif
- do_events (&er);
- break;
+ f = mac_window_to_frame (window_ptr);
- case keyDown:
- case autoKey:
- {
- int keycode = (er.message & keyCodeMask) >> 8;
- int xkeysym;
+ if ((er.modifiers & activeFlag) != 0)
+ {
+ /* A window has been activated */
+ Point mouse_loc = er.where;
+
+ x_new_focus_frame (dpyinfo, f);
+ activate_scroll_bars (f);
+
+ SetPortWindowPort (window_ptr);
+ GlobalToLocal (&mouse_loc);
+ /* Window-activated event counts as mouse movement,
+ so update things that depend on mouse position. */
+ note_mouse_movement (mac_window_to_frame (window_ptr),
+ &mouse_loc);
+ }
+ else
+ {
+ /* A window has been deactivated */
+ dpyinfo->grabbed = 0;
-#if USE_CARBON_EVENTS
- /* When using Carbon Events, we need to pass raw keyboard events
- to the TSM ourselves. If TSM handles it, it will pass back
- noErr, otherwise it will pass back "eventNotHandledErr" and
- we can process it normally. */
- if ((!NILP (Vmac_pass_command_to_system)
- || !(er.modifiers & cmdKey))
- && (!NILP (Vmac_pass_control_to_system)
- || !(er.modifiers & controlKey)))
- {
- OSStatus err;
- err = SendEventToEventTarget (eventRef,
- GetEventDispatcherTarget ());
- if (err != eventNotHandledErr)
- break;
- }
-#endif
+ if (f == dpyinfo->x_focus_frame)
+ {
+ x_new_focus_frame (dpyinfo, 0);
+ deactivate_scroll_bars (f);
+ }
- if (!IsValidWindowPtr (FrontNonFloatingWindow ()))
- {
- SysBeep (1);
- UNBLOCK_INPUT;
- return 0;
- }
- ObscureCursor ();
+ if (f == dpyinfo->mouse_face_mouse_frame)
+ {
+ /* If we move outside the frame, then we're
+ certainly no longer on any text in the
+ frame. */
+ clear_mouse_face (dpyinfo);
+ dpyinfo->mouse_face_mouse_frame = 0;
+ }
- if (keycode_to_xkeysym (keycode, &xkeysym))
- {
- inev.code = 0xff00 | xkeysym;
- inev.kind = NON_ASCII_KEYSTROKE_EVENT;
- }
- else
- {
- if (er.modifiers & (controlKey |
- (NILP (Vmac_command_key_is_meta) ? optionKey
- : cmdKey)))
- {
- /* This code comes from Keyboard Resource, Appendix
- C of IM - Text. This is necessary since shift is
- ignored in KCHR table translation when option or
- command is pressed. It also does not translate
- correctly control-shift chars like C-% so mask off
- shift here also */
- int new_modifiers = er.modifiers & 0xe600;
- /* mask off option and command */
- int new_keycode = keycode | new_modifiers;
- Ptr kchr_ptr = (Ptr) GetScriptManagerVariable (smKCHRCache);
- unsigned long some_state = 0;
- inev.code = KeyTranslate (kchr_ptr, new_keycode,
- &some_state) & 0xff;
- }
- else
- inev.code = er.message & charCodeMask;
- inev.kind = ASCII_KEYSTROKE_EVENT;
- }
- }
+ /* Generate a nil HELP_EVENT to cancel a help-echo.
+ Do it only if there's something to cancel.
+ Otherwise, the startup message is cleared when the
+ mouse leaves the frame. */
+ if (any_help_event_p)
+ do_help = -1;
+ }
+ }
+ break;
- /* If variable mac-convert-keyboard-input-to-latin-1 is non-nil,
- convert non-ASCII characters typed at the Mac keyboard
- (presumed to be in the Mac Roman encoding) to iso-latin-1
- encoding before they are passed to Emacs. This enables the
- Mac keyboard to be used to enter non-ASCII iso-latin-1
- characters directly. */
- if (mac_keyboard_text_encoding != kTextEncodingMacRoman
- && inev.kind == ASCII_KEYSTROKE_EVENT && inev.code >= 128)
+ case keyDown:
+ case autoKey:
{
- static TECObjectRef converter = NULL;
- OSStatus the_err = noErr;
- OSStatus convert_status = noErr;
+ int keycode = (er.message & keyCodeMask) >> 8;
+ int xkeysym;
+
+#if USE_CARBON_EVENTS
+ /* When using Carbon Events, we need to pass raw keyboard
+ events to the TSM ourselves. If TSM handles it, it
+ will pass back noErr, otherwise it will pass back
+ "eventNotHandledErr" and we can process it
+ normally. */
+ if ((!NILP (Vmac_pass_command_to_system)
+ || !(er.modifiers & cmdKey))
+ && (!NILP (Vmac_pass_control_to_system)
+ || !(er.modifiers & controlKey)))
+ if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
+ != eventNotHandledErr)
+ break;
+#endif
- if (converter == NULL)
+#if TARGET_API_MAC_CARBON
+ if (!IsValidWindowPtr (front_emacs_window ()))
{
- the_err = TECCreateConverter (&converter,
- kTextEncodingMacRoman,
- mac_keyboard_text_encoding);
- current_mac_keyboard_text_encoding
- = mac_keyboard_text_encoding;
+ SysBeep (1);
+ break;
}
- else if (mac_keyboard_text_encoding
- != current_mac_keyboard_text_encoding)
+#endif
+
+ ObscureCursor ();
+
+ if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
{
- /* Free the converter for the current encoding before
- creating a new one. */
- TECDisposeConverter (converter);
- the_err = TECCreateConverter (&converter,
- kTextEncodingMacRoman,
- mac_keyboard_text_encoding);
- current_mac_keyboard_text_encoding
- = mac_keyboard_text_encoding;
+ clear_mouse_face (dpyinfo);
+ dpyinfo->mouse_face_hidden = 1;
}
- if (the_err == noErr)
+ if (keycode_to_xkeysym (keycode, &xkeysym))
+ {
+ inev.code = 0xff00 | xkeysym;
+ inev.kind = NON_ASCII_KEYSTROKE_EVENT;
+ }
+ else
{
- unsigned char ch = inev.code;
- ByteCount actual_input_length, actual_output_length;
- unsigned char outch;
-
- convert_status = TECConvertText (converter, &ch, 1,
- &actual_input_length,
- &outch, 1,
- &actual_output_length);
- if (convert_status == noErr
- && actual_input_length == 1
- && actual_output_length == 1)
- inev.code = outch;
+ if (er.modifiers & (controlKey |
+ (NILP (Vmac_command_key_is_meta) ? optionKey
+ : cmdKey)))
+ {
+ /* This code comes from Keyboard Resource,
+ Appendix C of IM - Text. This is necessary
+ since shift is ignored in KCHR table
+ translation when option or command is pressed.
+ It also does not translate correctly
+ control-shift chars like C-% so mask off shift
+ here also */
+ int new_modifiers = er.modifiers & 0xe600;
+ /* mask off option and command */
+ int new_keycode = keycode | new_modifiers;
+ Ptr kchr_ptr = (Ptr) GetScriptManagerVariable (smKCHRCache);
+ unsigned long some_state = 0;
+ inev.code = KeyTranslate (kchr_ptr, new_keycode,
+ &some_state) & 0xff;
+ } else if (!NILP(Vmac_option_modifier) && (er.modifiers & optionKey))
+ {
+ /* When using the option key as an emacs modifier, convert
+ the pressed key code back to one without the Mac option
+ modifier applied. */
+ int new_modifiers = er.modifiers & ~optionKey;
+ int new_keycode = keycode | new_modifiers;
+ Ptr kchr_ptr = (Ptr) GetScriptManagerVariable (smKCHRCache);
+ unsigned long some_state = 0;
+ inev.code = KeyTranslate (kchr_ptr, new_keycode,
+ &some_state) & 0xff;
+ }
+ else
+ inev.code = er.message & charCodeMask;
+ inev.kind = ASCII_KEYSTROKE_EVENT;
}
}
+ /* If variable mac-convert-keyboard-input-to-latin-1 is
+ non-nil, convert non-ASCII characters typed at the Mac
+ keyboard (presumed to be in the Mac Roman encoding) to
+ iso-latin-1 encoding before they are passed to Emacs.
+ This enables the Mac keyboard to be used to enter
+ non-ASCII iso-latin-1 characters directly. */
+ if (mac_keyboard_text_encoding != kTextEncodingMacRoman
+ && inev.kind == ASCII_KEYSTROKE_EVENT && inev.code >= 128)
+ {
+ static TECObjectRef converter = NULL;
+ OSStatus the_err = noErr;
+ OSStatus convert_status = noErr;
+
+ if (converter == NULL)
+ {
+ the_err = TECCreateConverter (&converter,
+ kTextEncodingMacRoman,
+ mac_keyboard_text_encoding);
+ current_mac_keyboard_text_encoding
+ = mac_keyboard_text_encoding;
+ }
+ else if (mac_keyboard_text_encoding
+ != current_mac_keyboard_text_encoding)
+ {
+ /* Free the converter for the current encoding
+ before creating a new one. */
+ TECDisposeConverter (converter);
+ the_err = TECCreateConverter (&converter,
+ kTextEncodingMacRoman,
+ mac_keyboard_text_encoding);
+ current_mac_keyboard_text_encoding
+ = mac_keyboard_text_encoding;
+ }
+
+ if (the_err == noErr)
+ {
+ unsigned char ch = inev.code;
+ ByteCount actual_input_length, actual_output_length;
+ unsigned char outch;
+
+ convert_status = TECConvertText (converter, &ch, 1,
+ &actual_input_length,
+ &outch, 1,
+ &actual_output_length);
+ if (convert_status == noErr
+ && actual_input_length == 1
+ && actual_output_length == 1)
+ inev.code = outch;
+ }
+ }
+
#if USE_CARBON_EVENTS
- inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
#else
- inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
#endif
+ XSETFRAME (inev.frame_or_window,
+ mac_window_to_frame (front_emacs_window ()));
+ inev.timestamp = er.when * (1000 / 60); /* ticks to milliseconds */
+ break;
- {
- mac_output *mwp
- = (mac_output *) GetWRefCon (FrontNonFloatingWindow ());
- XSETFRAME (inev.frame_or_window, mwp->mFP);
- }
-
- inev.timestamp = er.when * (1000 / 60); /* ticks to milliseconds */
- break;
-
- case kHighLevelEvent:
- drag_and_drop_file_list = Qnil;
+ case kHighLevelEvent:
+ drag_and_drop_file_list = Qnil;
- AEProcessAppleEvent(&er);
+ AEProcessAppleEvent(&er);
- /* Build a DRAG_N_DROP_EVENT type event as is done in
- constuct_drag_n_drop in w32term.c. */
- if (!NILP (drag_and_drop_file_list))
- {
- struct frame *f = NULL;
- WindowPtr wp;
- Lisp_Object frame;
+ /* Build a DRAG_N_DROP_EVENT type event as is done in
+ constuct_drag_n_drop in w32term.c. */
+ if (!NILP (drag_and_drop_file_list))
+ {
+ struct frame *f = NULL;
+ WindowPtr wp;
+ Lisp_Object frame;
- wp = FrontNonFloatingWindow ();
+ wp = front_emacs_window ();
- if (!wp)
- {
- struct frame *f = XFRAME (XCAR (Vframe_list));
- CollapseWindow (FRAME_MAC_WINDOW (f), false);
- wp = FrontNonFloatingWindow ();
- }
+ if (!wp)
+ {
+ struct frame *f = XFRAME (XCAR (Vframe_list));
+ CollapseWindow (FRAME_MAC_WINDOW (f), false);
+ wp = front_emacs_window ();
+ }
- if (wp && is_emacs_window(wp))
- f = ((mac_output *) GetWRefCon (wp))->mFP;
+ if (wp)
+ f = mac_window_to_frame (wp);
- inev.kind = DRAG_N_DROP_EVENT;
- inev.code = 0;
- inev.timestamp = er.when * (1000 / 60);
+ inev.kind = DRAG_N_DROP_EVENT;
+ inev.code = 0;
+ inev.timestamp = er.when * (1000 / 60);
/* ticks to milliseconds */
#if USE_CARBON_EVENTS
- inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
+ inev.modifiers = mac_event_to_emacs_modifiers (eventRef);
#else
- inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
+ inev.modifiers = mac_to_emacs_modifiers (er.modifiers);
#endif
- XSETINT (inev.x, 0);
- XSETINT (inev.y, 0);
+ XSETINT (inev.x, 0);
+ XSETINT (inev.y, 0);
- XSETFRAME (frame, f);
- inev.frame_or_window = Fcons (frame, drag_and_drop_file_list);
+ XSETFRAME (frame, f);
+ inev.frame_or_window = Fcons (frame, drag_and_drop_file_list);
- /* Regardless of whether Emacs was suspended or in the
- foreground, ask it to redraw its entire screen.
- Otherwise parts of the screen can be left in an
- inconsistent state. */
- if (wp)
+ /* Regardless of whether Emacs was suspended or in the
+ foreground, ask it to redraw its entire screen.
+ Otherwise parts of the screen can be left in an
+ inconsistent state. */
+ if (wp)
#if TARGET_API_MAC_CARBON
- {
- Rect r;
+ {
+ Rect r;
- GetWindowPortBounds (wp, &r);
- InvalWindowRect (wp, &r);
- }
+ GetWindowPortBounds (wp, &r);
+ InvalWindowRect (wp, &r);
+ }
#else /* not TARGET_API_MAC_CARBON */
- InvalRect (&(wp->portRect));
+ InvalRect (&(wp->portRect));
#endif /* not TARGET_API_MAC_CARBON */
- }
- default:
- break;
- }
+ }
+ default:
+ break;
+ }
#if USE_CARBON_EVENTS
ReleaseEvent (eventRef);
- }
#endif
+ if (inev.kind != NO_EVENT)
+ {
+ kbd_buffer_store_event_hold (&inev, hold_quit);
+ count++;
+ }
+
+ if (do_help
+ && !(hold_quit && hold_quit->kind != NO_EVENT))
+ {
+ Lisp_Object frame;
+
+ if (f)
+ XSETFRAME (frame, f);
+ else
+ frame = Qnil;
+
+ if (do_help > 0)
+ {
+ any_help_event_p = 1;
+ gen_help_event (help_echo_string, frame, help_echo_window,
+ help_echo_object, help_echo_pos);
+ }
+ else
+ {
+ help_echo_string = Qnil;
+ gen_help_event (Qnil, frame, Qnil, Qnil, 0);
+ }
+ count++;
+ }
+
+ }
+
/* If the focus was just given to an autoraising frame,
raise it now. */
/* ??? This ought to be able to handle more than one such frame. */
check_alarm (); /* simulate the handling of a SIGALRM */
#endif
- {
- static Point old_mouse_pos = { -1, -1 };
-
- if (app_is_suspended)
- {
- old_mouse_pos.h = -1;
- old_mouse_pos.v = -1;
- }
- else
- {
- Point mouse_pos;
- WindowPtr wp;
- struct frame *f;
- Lisp_Object bar;
- struct scroll_bar *sb;
-
- wp = FrontWindow ();
- if (is_emacs_window (wp))
- {
- f = ((mac_output *) GetWRefCon (wp))->mFP;
-
-#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (wp));
-#else
- SetPort (wp);
-#endif
-
- GetMouse (&mouse_pos);
-
- if (!EqualPt (mouse_pos, old_mouse_pos))
- {
- if (mouse_tracking_in_progress == mouse_tracking_scroll_bar
- && tracked_scroll_bar)
- x_scroll_bar_note_movement (tracked_scroll_bar,
- mouse_pos.v
- - XINT (tracked_scroll_bar->top),
- TickCount() * (1000 / 60));
- else
- note_mouse_movement (f, &mouse_pos);
-
- old_mouse_pos = mouse_pos;
- }
- }
- }
- }
-
- if (inev.kind != NO_EVENT)
- {
- kbd_buffer_store_event_hold (&inev, hold_quit);
- count++;
- }
-
UNBLOCK_INPUT;
return count;
}
ROWS Macintosh window, using font with name FONTNAME and size
FONTSIZE. */
void
-NewMacWindow (FRAME_PTR fp)
+make_mac_frame (FRAME_PTR fp)
{
mac_output *mwp;
#if TARGET_API_MAC_CARBON
mwp = fp->output_data.mac;
+ BLOCK_INPUT;
if (making_terminal_window)
{
if (!(mwp->mWP = GetNewCWindow (TERM_WINDOW_RESOURCE, NULL,
making_terminal_window = 0;
}
else
- if (!(mwp->mWP = GetNewCWindow (WINDOW_RESOURCE, NULL, (WindowPtr) -1)))
- abort ();
-
- SetWRefCon (mwp->mWP, (long) mwp);
- /* so that update events can find this mac_output struct */
- mwp->mFP = fp; /* point back to emacs frame */
-
+ {
#if TARGET_API_MAC_CARBON
- SetPort (GetWindowPort (mwp->mWP));
+ Rect r;
+
+ SetRect (&r, 0, 0, 1, 1);
+ if (CreateNewWindow (kDocumentWindowClass,
+ kWindowStandardDocumentAttributes
+ /* | kWindowToolbarButtonAttribute */,
+ &r, &mwp->mWP) != noErr)
#else
- SetPort (mwp->mWP);
+ if (!(mwp->mWP = GetNewCWindow (WINDOW_RESOURCE, NULL, (WindowPtr) -1)))
#endif
+ abort ();
+ }
- mwp->fontset = -1;
+ SetWRefCon (mwp->mWP, (long) mwp);
+ /* so that update events can find this mac_output struct */
+ mwp->mFP = fp; /* point back to emacs frame */
SizeWindow (mwp->mWP, FRAME_PIXEL_WIDTH (fp), FRAME_PIXEL_HEIGHT (fp), false);
- ShowWindow (mwp->mWP);
-
+ UNBLOCK_INPUT;
}
void
-make_mac_frame (struct frame *f)
+make_mac_terminal_frame (struct frame *f)
{
- FRAME_DESIRED_CURSOR (f) = FILLED_BOX_CURSOR;
+ Lisp_Object frame;
+
+ XSETFRAME (frame, f);
+
+ f->output_method = output_mac;
+ f->output_data.mac = (struct mac_output *)
+ xmalloc (sizeof (struct mac_output));
+ bzero (f->output_data.mac, sizeof (struct mac_output));
+
+ XSETFRAME (FRAME_KBOARD (f)->Vdefault_minibuffer_frame, f);
+
+ FRAME_COLS (f) = 96;
+ FRAME_LINES (f) = 4;
+
+ FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
+ FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_right;
- NewMacWindow(f);
+ FRAME_DESIRED_CURSOR (f) = FILLED_BOX_CURSOR;
f->output_data.mac->cursor_pixel = 0;
f->output_data.mac->border_pixel = 0x00ff00;
f->output_data.mac->cursor_foreground_pixel = 0x0000ff;
FRAME_FONTSET (f) = -1;
- f->output_data.mac->scroll_bar_foreground_pixel = -1;
- f->output_data.mac->scroll_bar_background_pixel = -1;
f->output_data.mac->explicit_parent = 0;
f->left_pos = 4;
f->top_pos = 4;
f->internal_border_width = 0;
- f->output_method = output_mac;
-
f->auto_raise = 1;
f->auto_lower = 1;
f->new_text_cols = 0;
f->new_text_lines = 0;
-}
-
-void
-make_mac_terminal_frame (struct frame *f)
-{
- Lisp_Object frame;
-
- XSETFRAME (frame, f);
-
- f->output_method = output_mac;
- f->output_data.mac = (struct mac_output *)
- xmalloc (sizeof (struct mac_output));
- bzero (f->output_data.mac, sizeof (struct mac_output));
- FRAME_FONTSET (f) = -1;
- f->output_data.mac->scroll_bar_foreground_pixel = -1;
- f->output_data.mac->scroll_bar_background_pixel = -1;
-
- XSETFRAME (FRAME_KBOARD (f)->Vdefault_minibuffer_frame, f);
-
- FRAME_COLS (f) = 96;
- FRAME_LINES (f) = 4;
-
- FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
- FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_right;
make_mac_frame (f);
Fmodify_frame_parameters (frame,
Fcons (Fcons (Qbackground_color,
build_string ("white")), Qnil));
+
+ ShowWindow (f->output_data.mac->mWP);
}
\f
dpyinfo->resx = 75.0;
dpyinfo->resy = 75.0;
dpyinfo->color_p = TestDeviceAttribute (main_device_handle, gdDevType);
+#ifdef MAC_OSX
+ /* HasDepth returns true if it is possible to have a 32 bit display,
+ but this may not be what is actually used. Mac OSX can do better.
+ CGMainDisplayID is only available on OSX 10.2 and higher, but the
+ header for CGGetActiveDisplayList says that the first display returned
+ is the active one, so we use that. */
+ {
+ CGDirectDisplayID disp_id[1];
+ CGDisplayCount disp_count;
+ CGDisplayErr error_code;
+
+ error_code = CGGetActiveDisplayList (1, disp_id, &disp_count);
+ if (error_code != 0)
+ error ("No display found, CGGetActiveDisplayList error %d", error_code);
+
+ dpyinfo->n_planes = CGDisplayBitsPerPixel (disp_id[0]);
+ }
+#else
for (dpyinfo->n_planes = 32; dpyinfo->n_planes > 0; dpyinfo->n_planes >>= 1)
if (HasDepth (main_device_handle, dpyinfo->n_planes,
gdDevType, dpyinfo->color_p))
break;
+#endif
dpyinfo->height = (**main_device_handle).gdRect.bottom;
dpyinfo->width = (**main_device_handle).gdRect.right;
dpyinfo->grabbed = 0;
dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
dpyinfo->mouse_face_window = Qnil;
+ dpyinfo->mouse_face_overlay = Qnil;
+ dpyinfo->mouse_face_hidden = 0;
}
struct mac_display_info *
mac_determine_quit_char_modifiers ();
/* Fill the queue with events */
+ BLOCK_INPUT;
ReceiveNextEvent (0, NULL, kEventDurationNoWait, false, &event);
event = FindSpecificEventInQueue (GetMainEventQueue (), quit_char_comp,
NULL);
+ UNBLOCK_INPUT;
if (event)
{
struct input_event e;
- struct mac_output *mwp =
- (mac_output *) GetWRefCon (FrontNonFloatingWindow ());
+
/* Use an input_event to emulate what the interrupt handler does. */
EVENT_INIT (e);
e.kind = ASCII_KEYSTROKE_EVENT;
e.code = quit_char;
- e.arg = NULL;
+ e.arg = Qnil;
e.modifiers = NULL;
e.timestamp = EventTimeToTicks (GetEventTime (event)) * (1000/60);
- XSETFRAME (e.frame_or_window, mwp->mFP);
+ XSETFRAME (e.frame_or_window, mac_window_to_frame (front_emacs_window ()));
/* Remove event from queue to prevent looping. */
RemoveEventFromQueue (GetMainEventQueue (), event);
ReleaseEvent (event);
signal (SIGPIPE, x_connection_signal);
#endif
+ BLOCK_INPUT;
mac_initialize_display_info ();
#if TARGET_API_MAC_CARBON
if (!inhibit_window_system)
MakeMeTheFrontProcess ();
#endif
+ UNBLOCK_INPUT;
}
x_error_message_string = Qnil;
#endif
+ Qmodifier_value = intern ("modifier-value");
+ Qalt = intern ("alt");
+ Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
+ Qhyper = intern ("hyper");
+ Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
+ Qsuper = intern ("super");
+ Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
+
Fprovide (intern ("mac-carbon"), Qnil);
staticpro (&Qreverse);
Otherwise the option key is used. */);
Vmac_command_key_is_meta = Qt;
+ DEFVAR_LISP ("mac-option-modifier", &Vmac_option_modifier,
+ doc: /* Modifier to use for the Mac alt/option key. The value can
+be alt, hyper, or super for the respective modifier. If the value is
+nil then the key will act as the normal Mac option modifier. */);
+ Vmac_option_modifier = Qnil;
+
DEFVAR_LISP ("mac-reverse-ctrl-meta", &Vmac_reverse_ctrl_meta,
doc: /* Non-nil means that the control and meta keys are reversed. This is
useful for non-standard keyboard layouts. */);
Vmac_reverse_ctrl_meta = Qnil;
- DEFVAR_LISP ("mac-emulate-three-button-mouse",
+ DEFVAR_LISP ("mac-emulate-three-button-mouse",
&Vmac_emulate_three_button_mouse,
doc: /* t means that when the option-key is held down while pressing the
- mouse button, the click will register as mouse-2 and while the
+ mouse button, the click will register as mouse-2 and while the
command-key is held down, the click will register as mouse-3.
'reverse means that the the option-key will register for mouse-3
and the command-key will register for mouse-2. nil means that