emacs: src/macterm.c comparison

comparison src/macterm.c @ 90242:5e2d3828e89f

Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-91 Merge from emacs--cvs-trunk--0 Patches applied: * emacs--cvs-trunk--0 (patch 581-597) - Update from CVS - Merge from gnus--rel--5.10 * gnus--rel--5.10 (patch 133-141) - Update from CVS - Merge from emacs--cvs-trunk--0 - Update from CVS: texi/gnus.texi (RSS): Fix key description. - Update from CVS: texi/gnus.texi (Document Server Internals): Addition.

author	Miles Bader <miles@gnu.org>
date	Sat, 15 Oct 2005 00:26:05 +0000
parents	aa89c814f853 abad34f080c4
children	c8c3c8dbe333

comparison

equal deleted inserted replaced

-:c293a93ebacf
+:5e2d3828e89f
 extern void menubar_selection_callback (FRAME_PTR, int);
 #define GC_FORE_COLOR(gc)	(&(gc)->fore_color)
 #define GC_BACK_COLOR(gc)	(&(gc)->back_color)
 #define GC_FONT(gc)		((gc)->xgcv.font)
+#define GC_CLIP_REGION(gc)	((gc)->clip_region)
 #define MAC_WINDOW_NORMAL_GC(w)	(((mac_output *) GetWRefCon (w))->normal_gc)
+static RgnHandle saved_port_clip_region = NULL;
+static void
+mac_begin_clip (region)
+RgnHandle region;
+{
+static RgnHandle new_region = NULL;
+if (saved_port_clip_region == NULL)
+saved_port_clip_region = NewRgn ();
+if (new_region == NULL)
+new_region = NewRgn ();
+if (region)
+{
+GetClip (saved_port_clip_region);
+SectRgn (saved_port_clip_region, region, new_region);
+SetClip (new_region);
+}
+}
+static void
+mac_end_clip (region)
+RgnHandle region;
+{
+if (region)
+SetClip (saved_port_clip_region);
+}
 /* X display function emulation */
 void
 {
 SetPortWindowPort (w);
 RGBForeColor (GC_FORE_COLOR (gc));
+mac_begin_clip (GC_CLIP_REGION (gc));
 MoveTo (x1, y1);
 LineTo (x2, y2);
+mac_end_clip (GC_CLIP_REGION (gc));
 }
 void
 mac_draw_line_to_pixmap (display, p, gc, x1, y1, x2, y2)
 Display *display;
 SetPortWindowPort (w);
 RGBBackColor (GC_BACK_COLOR (gc));
 SetRect (&r, x, y, x + width, y + height);
+mac_begin_clip (GC_CLIP_REGION (gc));
 EraseRect (&r);
+mac_end_clip (GC_CLIP_REGION (gc));
 RGBBackColor (GC_BACK_COLOR (MAC_WINDOW_NORMAL_GC (w)));
 }
 RGBForeColor (GC_FORE_COLOR (gc));
 RGBBackColor (GC_BACK_COLOR (gc));
 SetRect (&r, x, y, x + width, y + height);
+mac_begin_clip (GC_CLIP_REGION (gc));
 #if TARGET_API_MAC_CARBON
 LockPortBits (GetWindowPort (w));
 CopyBits (&bitmap, GetPortBitMapForCopyBits (GetWindowPort (w)),
 	    &(bitmap.bounds), &r, overlay_p ? srcOr : srcCopy, 0);
 UnlockPortBits (GetWindowPort (w));
 #else /* not TARGET_API_MAC_CARBON */
 CopyBits (&bitmap, &(w->portBits), &(bitmap.bounds), &r,
 	    overlay_p ? srcOr : srcCopy, 0);
 #endif /* not TARGET_API_MAC_CARBON */
+mac_end_clip (GC_CLIP_REGION (gc));
 RGBBackColor (GC_BACK_COLOR (MAC_WINDOW_NORMAL_GC (w)));
-}
-/* Mac replacement for XSetClipRectangles.  */
-static void
-mac_set_clip_rectangle (display, w, r)
-Display *display;
-WindowPtr w;
-Rect *r;
-{
-SetPortWindowPort (w);
-ClipRect (r);
-}
-/* Mac replacement for XSetClipMask.  */
-static void
-mac_reset_clipping (display, w)
-Display *display;
-WindowPtr w;
-{
-Rect r;
-SetPortWindowPort (w);
-SetRect (&r, -32767, -32767, 32767, 32767);
-ClipRect (&r);
 }
 /* Mac replacement for XCreateBitmapFromBitmapData.  */
 SetPortWindowPort (w);
 RGBForeColor (GC_FORE_COLOR (gc));
 SetRect (&r, x, y, x + width, y + height);
+mac_begin_clip (GC_CLIP_REGION (gc));
 PaintRect (&r); /* using foreground color of gc */
+mac_end_clip (GC_CLIP_REGION (gc));
 }
 #if 0 /* TODO: figure out if we need to do this on Mac.  */
 static void
 SetPortWindowPort (w);
 RGBForeColor (GC_FORE_COLOR (gc));
 SetRect (&r, x, y, x + width + 1, y + height + 1);
+mac_begin_clip (GC_CLIP_REGION (gc));
 FrameRect (&r); /* using foreground color of gc */
+mac_end_clip (GC_CLIP_REGION (gc));
 }
 #if 0 /* TODO: figure out if we need to do this on Mac.  */
 /* Mac replacement for XDrawRectangle: dest is a Pixmap.  */
 ByteCount sizes[] = {sizeof (ATSLineLayoutOptions)};
 static ATSLineLayoutOptions line_layout =
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
 	kATSLineDisableAllLayoutOperations  | kATSLineUseDeviceMetrics
 #else
-	kATSLineIsDisplayOnly
+	kATSLineIsDisplayOnly | kATSLineFractDisable
 #endif
 	;
 ATSUAttributeValuePtr values[] = {&line_layout};
 err = ATSUCreateTextLayoutWithTextPtr (text,
 	{
 #ifdef MAC_OSX
 	  if (NILP (Vmac_use_core_graphics))
 	    {
 #endif
+	      mac_begin_clip (GC_CLIP_REGION (gc));
 	      MoveTo (x, y);
 	      ATSUDrawText (text_layout,
 			    kATSUFromTextBeginning, kATSUToTextEnd,
 			    kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc);
+	      mac_end_clip (GC_CLIP_REGION (gc));
 #ifdef MAC_OSX
 	    }
 	  else
 	    {
 	      CGrafPtr port;
 	      CGContextRef context;
 	      Rect rect;
-	      RgnHandle region = NewRgn ();
 	      float port_height;
 	      ATSUAttributeTag tags[] = {kATSUCGContextTag};
 	      ByteCount sizes[] = {sizeof (CGContextRef)};
 	      ATSUAttributeValuePtr values[] = {&context};
 	      GetPort (&port);
 	      QDBeginCGContext (port, &context);
 	      GetPortBounds (port, &rect);
 	      port_height = rect.bottom - rect.top;
-	      GetClip (region);
+	      if (gc->n_clip_rects)
-	      GetRegionBounds (region, &rect);
+		{
-	      /* XXX: This is not correct if the clip region is not a
+		  CGContextTranslateCTM (context, 0, port_height);
-		 simple rectangle.  */
+		  CGContextScaleCTM (context, 1, -1);
-	      CGContextClipToRect (context,
+		  CGContextClipToRects (context, gc->clip_rects,
-				   CGRectMake (rect.left,
+					gc->n_clip_rects);
-					       port_height - rect.bottom,
+		  CGContextScaleCTM (context, 1, -1);
-					       rect.right - rect.left,
+		  CGContextTranslateCTM (context, 0, -port_height);
-					       rect.bottom - rect.top));
+		}
-	      DisposeRgn (region);
 	      CGContextSetRGBFillColor
 		(context,
 		 RED_FROM_ULONG (gc->xgcv.foreground) / 255.0,
 		 GREEN_FROM_ULONG (gc->xgcv.foreground) / 255.0,
 		 BLUE_FROM_ULONG (gc->xgcv.foreground) / 255.0,
 TextFont (GC_FONT (gc)->mac_fontnum);
 TextSize (GC_FONT (gc)->mac_fontsize);
 TextFace (GC_FONT (gc)->mac_fontface);
 TextMode (mode);
+mac_begin_clip (GC_CLIP_REGION (gc));
 MoveTo (x, y);
 DrawText (buf, 0, nchars * bytes_per_char);
+mac_end_clip (GC_CLIP_REGION (gc));
 #if USE_ATSUI
 }
 #endif
 if (mode != srcOr)
 SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
 ForeColor (blackColor);
 BackColor (whiteColor);
+mac_begin_clip (GC_CLIP_REGION (gc));
 LockPixels (GetGWorldPixMap (src));
 #if TARGET_API_MAC_CARBON
 LockPortBits (GetWindowPort (dest));
 CopyBits (GetPortBitMapForCopyBits (src),
 	    GetPortBitMapForCopyBits (GetWindowPort (dest)),
 #else /* not TARGET_API_MAC_CARBON */
 CopyBits (&(((GrafPtr)src)->portBits), &(dest->portBits),
 	    &src_r, &dest_r, srcCopy, 0);
 #endif /* not TARGET_API_MAC_CARBON */
 UnlockPixels (GetGWorldPixMap (src));
+mac_end_clip (GC_CLIP_REGION (gc));
 RGBBackColor (GC_BACK_COLOR (MAC_WINDOW_NORMAL_GC (dest)));
 }
 SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
 ForeColor (blackColor);
 BackColor (whiteColor);
+mac_begin_clip (GC_CLIP_REGION (gc));
 LockPixels (GetGWorldPixMap (src));
 LockPixels (GetGWorldPixMap (mask));
 #if TARGET_API_MAC_CARBON
 LockPortBits (GetWindowPort (dest));
 CopyMask (GetPortBitMapForCopyBits (src), GetPortBitMapForCopyBits (mask),
 CopyMask (&(((GrafPtr)src)->portBits), &(((GrafPtr)mask)->portBits),
 	    &(dest->portBits), &src_r, &src_r, &dest_r);
 #endif /* not TARGET_API_MAC_CARBON */
 UnlockPixels (GetGWorldPixMap (mask));
 UnlockPixels (GetGWorldPixMap (src));
+mac_end_clip (GC_CLIP_REGION (gc));
 RGBBackColor (GC_BACK_COLOR (MAC_WINDOW_NORMAL_GC (dest)));
 }
 /* In Color QuickDraw, set ForeColor and BackColor as follows to avoid
 color mapping in CopyBits.  Otherwise, it will be slow.  */
 ForeColor (blackColor);
 BackColor (whiteColor);
+mac_begin_clip (GC_CLIP_REGION (gc));
 CopyBits (&(w->portBits), &(w->portBits), &src_r, &dest_r, srcCopy, 0);
+mac_end_clip (GC_CLIP_REGION (gc));
 RGBBackColor (GC_BACK_COLOR (MAC_WINDOW_NORMAL_GC (w)));
 #endif /* not TARGET_API_MAC_CARBON */
 }
 void
 XFreeGC (display, gc)
 Display *display;
 GC gc;
 {
+if (gc->clip_region)
+DisposeRgn (gc->clip_region);
 xfree (gc);
 }
 /* Mac replacement for XGetGCValues.  */
 Display *display;
 GC gc;
 XFontStruct *font;
 {
 gc->xgcv.font = font;
+}
+/* Mac replacement for XSetClipRectangles.  */
+static void
+mac_set_clip_rectangles (display, gc, rectangles, n)
+Display *display;
+GC gc;
+Rect *rectangles;
+int n;
+{
+int i;
+if (n < 0 || n > MAX_CLIP_RECTS)
+abort ();
+if (n == 0)
+{
+if (gc->clip_region)
+	{
+	  DisposeRgn (gc->clip_region);
+	  gc->clip_region = NULL;
+	}
+}
+else
+{
+if (gc->clip_region == NULL)
+	gc->clip_region = NewRgn ();
+RectRgn (gc->clip_region, rectangles);
+if (n > 1)
+	{
+	  RgnHandle region = NewRgn ();
+	  for (i = 1; i < n; i++)
+	    {
+	      RectRgn (region, rectangles + i);
+	      UnionRgn (gc->clip_region, region, gc->clip_region);
+	    }
+	  DisposeRgn (region);
+	}
+}
+#if defined (MAC_OSX) && USE_ATSUI
+gc->n_clip_rects = n;
+for (i = 0; i < n; i++)
+{
+Rect *rect = rectangles + i;
+gc->clip_rects[i] = CGRectMake (rect->left, rect->top,
+				      rect->right - rect->left,
+				      rect->bottom - rect->top);
+}
+#endif
+}
+/* Mac replacement for XSetClipMask.  */
+static INLINE void
+mac_reset_clip_rectangles (display, gc)
+Display *display;
+GC gc;
+{
+mac_set_clip_rectangles (display, gc, NULL, 0);
 }
 /* Mac replacement for XSetWindowBackground.  */
 mac_draw_bitmap (display, window, face->gc, p->x, p->y,
 		       p->wd, p->h, bits, p->overlay_p);
 XSetForeground (display, face->gc, gcv.foreground);
 }
-mac_reset_clipping (display, window);
+mac_reset_clip_rectangles (display, gc);
 }
 /* This is called when starting Emacs and when restarting after
 /* Function prototypes of this page.  */
 static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
 static int mac_encode_char P_ ((int, XChar2b *, struct font_info *,
 				struct charset *, int *));
-/* Return a pointer to per-char metric information in FONT of a
-character pointed by B which is a pointer to an XChar2b.  */
-#define PER_CHAR_METRIC(font, b)					   \
-((font)->per_char							   \
-? ((font)->per_char + (b)->byte2 - (font)->min_char_or_byte2		   \
-+ (((font)->min_byte1 || (font)->max_byte1)			   \
-	 ? (((b)->byte1 - (font)->min_byte1)				   \
-	    * ((font)->max_char_or_byte2 - (font)->min_char_or_byte2 + 1)) \
-	 : 0))								   \
-: &((font)->max_bounds))
 /* Get metrics of character CHAR2B in FONT.  Value is null if CHAR2B
 is not contained in the font.  */
 static INLINE void
 x_set_glyph_string_clipping (s)
 struct glyph_string *s;
 {
-Rect r;
+Rect rects[MAX_CLIP_RECTS];
-get_glyph_string_clip_rect (s, &r);
+int n;
-mac_set_clip_rectangle (s->display, s->window, &r);
+n = get_glyph_string_clip_rects (s, rects, MAX_CLIP_RECTS);
+mac_set_clip_rectangles (s->display, s->gc, rects, n);
 }
 /* RIF:
 Compute left and right overhang of glyph string S.  If S is a glyph
 /* Draw text with XDrawString if background has already been
 	 filled.  Otherwise, use XDrawImageString.  (Note that
 	 XDrawImageString is usually faster than XDrawString.)  Always
 	 use XDrawImageString when drawing the cursor so that there is
 	 no chance that characters under a box cursor are invisible.  */
-if (s->for_overlaps_p
+if (s->for_overlaps
 	  || (s->background_filled_p && s->hl != DRAW_CURSOR))
 #endif
 	{
 	  /* Draw characters with 16-bit or 8-bit functions.  */
 	  if (s->two_byte_p
 #if defined (MAC_OS8) && !USE_ATSUI
 else
 	{
 	  if (s->two_byte_p)
 	    XDrawImageString16 (s->display, s->window, s->gc, x,
-			        s->ybase - boff, s->char2b, s->nchars);
+				s->ybase - boff, s->char2b, s->nchars);
 	  else
 	    XDrawImageString (s->display, s->window, s->gc, x,
 			      s->ybase - boff, char1b, s->nchars);
 	}
 #endif
 if (raised_p)
 gc = f->output_data.mac->white_relief.gc;
 else
 gc = f->output_data.mac->black_relief.gc;
-mac_set_clip_rectangle (dpy, window, clip_rect);
+mac_set_clip_rectangles (dpy, gc, clip_rect, 1);
 /* Top.  */
 if (top_p)
 for (i = 0; i < width; ++i)
 XDrawLine (dpy, window, gc,
 if (left_p)
 for (i = 0; i < width; ++i)
 XDrawLine (dpy, window, gc,
 		 left_x + i, top_y + i, left_x + i, bottom_y - i);
-mac_reset_clipping (dpy, window);
+mac_reset_clip_rectangles (dpy, gc);
 if (raised_p)
 gc = f->output_data.mac->black_relief.gc;
 else
 gc = f->output_data.mac->white_relief.gc;
-mac_set_clip_rectangle (dpy, window,
+mac_set_clip_rectangles (dpy, gc, clip_rect, 1);
-			  clip_rect);
 /* Bottom.  */
 if (bot_p)
 for (i = 0; i < width; ++i)
 XDrawLine (dpy, window, gc,
 if (right_p)
 for (i = 0; i < width; ++i)
 XDrawLine (dpy, window, gc,
 		 right_x - i, top_y + i + 1, right_x - i, bottom_y - i - 1);
-mac_reset_clipping (dpy, window);
+mac_reset_clip_rectangles (dpy, gc);
 }
 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
 RIGHT_X, and BOTTOM_Y.  WIDTH is the thickness of the lines to
 {
 XGCValues xgcv;
 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
 XSetForeground (s->display, s->gc, s->face->box_color);
-mac_set_clip_rectangle (s->display, s->window, clip_rect);
+mac_set_clip_rectangles (s->display, s->gc, clip_rect, 1);
 /* Top.  */
 XFillRectangle (s->display, s->window, s->gc,
 		  left_x, top_y, right_x - left_x + 1, width);
 if (right_p)
 XFillRectangle (s->display, s->window, s->gc,
 		    right_x - width + 1, top_y, width, bottom_y - top_y + 1);
 XSetForeground (s->display, s->gc, xgcv.foreground);
-mac_reset_clipping (s->display, s->window);
+mac_reset_clip_rectangles (s->display, s->gc);
 }
 /* Draw a box around glyph string S.  */
 {
 x_draw_image_foreground_1 (s, pixmap);
 x_set_glyph_string_clipping (s);
 mac_copy_area (s->display, pixmap, s->window, s->gc,
 		     0, 0, s->background_width, s->height, s->x, s->y);
-mac_reset_clipping (s->display, s->window);
 XFreePixmap (s->display, pixmap);
 }
 else
 #endif
 x_draw_image_foreground (s);
 	    }
 	  else
 	    gc = s->face->gc;
 	  get_glyph_string_clip_rect (s, &r);
-	  mac_set_clip_rectangle (s->display, s->window, &r);
+	  mac_set_clip_rectangles (s->display, gc, &r, 1);
 #if 0 /* MAC_TODO: stipple */
 	  if (s->face->stipple)
 	    {
 	      /* Fill background with a stipple pattern.  */
 	      XSetFillStyle (s->display, gc, FillSolid);
 	    }
 	  else
 #endif /* MAC_TODO */
 	    mac_erase_rectangle (s->window, gc, x, y, w, h);
-	  mac_reset_clipping (s->display, s->window);
 	}
 }
 else if (!s->background_filled_p)
 x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
 				 s->height);
 /* If S draws into the background of its successor that does not
 draw a cursor, draw the background of the successor first so that
 S can draw into it.  This makes S->next use XDrawString instead
 of XDrawImageString.  */
-if (s->next && s->right_overhang && !s->for_overlaps_p
+if (s->next && s->right_overhang && !s->for_overlaps
 && s->next->hl != DRAW_CURSOR)
 {
 xassert (s->next->img == NULL);
 x_set_glyph_string_gc (s->next);
 x_set_glyph_string_clipping (s->next);
 /* Set up S->gc, set clipping and draw S.  */
 x_set_glyph_string_gc (s);
 /* Draw relief (if any) in advance for char/composition so that the
 glyph string can be drawn over it.  */
-if (!s->for_overlaps_p
+if (!s->for_overlaps
 && s->face->box != FACE_NO_BOX
 && (s->first_glyph->type == CHAR_GLYPH
 	  || s->first_glyph->type == COMPOSITE_GLYPH))
 {
 case STRETCH_GLYPH:
 x_draw_stretch_glyph_string (s);
 break;
 case CHAR_GLYPH:
-if (s->for_overlaps_p)
+if (s->for_overlaps)
 	s->background_filled_p = 1;
 else
 	x_draw_glyph_string_background (s, 0);
 x_draw_glyph_string_foreground (s);
 break;
 case COMPOSITE_GLYPH:
-if (s->for_overlaps_p || s->gidx > 0)
+if (s->for_overlaps || s->gidx > 0)
 	s->background_filled_p = 1;
 else
 	x_draw_glyph_string_background (s, 1);
 x_draw_composite_glyph_string_foreground (s);
 break;
 default:
 abort ();
 }
-if (!s->for_overlaps_p)
+if (!s->for_overlaps)
 {
 /* Draw underline.  */
 if (s->face->underline_p)
 	{
 unsigned long h = 1;
 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
 	x_draw_glyph_string_box (s);
 }
 /* Reset clipping.  */
-mac_reset_clipping (s->display, s->window);
+mac_reset_clip_rectangles (s->display, s->gc);
 }
 /* Shift display to make room for inserted glyphs.   */
 void
 another motion event, so we can check again the next time it moves.  */
 static Point last_mouse_motion_position;
 static Lisp_Object last_mouse_motion_frame;
-static void
+static int
 note_mouse_movement (frame, pos)
 FRAME_PTR frame;
 Point *pos;
 {
 struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (frame);
 	  dpyinfo->mouse_face_mouse_frame = 0;
 	  if (!dpyinfo->grabbed)
 	    rif->define_frame_cursor (frame,
 				      frame->output_data.mac->nontext_cursor);
 	}
+return 1;
 }
 /* Has the mouse moved off the glyph it was on at the last sighting?  */
-else if (pos->h < last_mouse_glyph.left
+if (pos->h < last_mouse_glyph.left
-	   || pos->h >= last_mouse_glyph.right
+|| pos->h >= last_mouse_glyph.right
-	   || pos->v < last_mouse_glyph.top
+|| pos->v < last_mouse_glyph.top
-	   || pos->v >= last_mouse_glyph.bottom)
+|| pos->v >= last_mouse_glyph.bottom)
 {
 frame->mouse_moved = 1;
 last_mouse_scroll_bar = Qnil;
 note_mouse_highlight (frame, pos->h, pos->v);
-}
+/* Remember which glyph we're now on.  */
+remember_mouse_glyph (frame, pos->h, pos->v, &last_mouse_glyph);
+return 1;
+}
+return 0;
 }
 /************************************************************************
 			      Mouse Face
 ************************************************************************/
-static int glyph_rect P_ ((struct frame *f, int, int, Rect *));
 /* MAC TODO:  This should be called from somewhere (or removed)  ++KFS */
 static void
 redo_mouse_highlight ()
 if (!NILP (last_mouse_motion_frame)
 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
 			  last_mouse_motion_position.h,
 			  last_mouse_motion_position.v);
-}
-/* Try to determine frame pixel position and size of the glyph under
-frame pixel coordinates X/Y on frame F .  Return the position and
-size in *RECT.  Value is non-zero if we could compute these
-values.  */
-static int
-glyph_rect (f, x, y, rect)
-struct frame *f;
-int x, y;
-Rect *rect;
-{
-Lisp_Object window;
-window = window_from_coordinates (f, x, y, 0, &x, &y, 0);
-if (!NILP (window))
-{
-struct window *w = XWINDOW (window);
-struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
-struct glyph_row *end = r + w->current_matrix->nrows - 1;
-for (; r < end && r->enabled_p; ++r)
-	if (r->y <= y && r->y + r->height > y)
-	  {
-	    /* Found the row at y.  */
-	    struct glyph *g = r->glyphs[TEXT_AREA];
-	    struct glyph *end = g + r->used[TEXT_AREA];
-	    int gx;
-	    rect->top = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
-	    rect->bottom = rect->top + r->height;
-	    if (x < r->x)
-	      {
-		/* x is to the left of the first glyph in the row.  */
-		/* Shouldn't this be a pixel value?
-		   WINDOW_LEFT_EDGE_X (w) seems to be the right value.
-		   ++KFS */
-		rect->left = WINDOW_LEFT_EDGE_COL (w);
-		rect->right = WINDOW_TO_FRAME_PIXEL_X (w, r->x);
-		return 1;
-	      }
-	    for (gx = r->x; g < end; gx += g->pixel_width, ++g)
-	      if (gx <= x && gx + g->pixel_width > x)
-		{
-		  /* x is on a glyph.  */
-		  rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
-		  rect->right = rect->left + g->pixel_width;
-		  return 1;
-		}
-	    /* 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?
-	       WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
-	       ++KFS */
-	    rect->right = WINDOW_RIGHT_EDGE_COL (w);
-	    return 1;
-	  }
-}
-/* The y is not on any row.  */
-return 0;
-}
-/* MAC TODO:  This should be called from somewhere (or removed)  ++KFS */
-/* Record the position of the mouse in last_mouse_glyph.  */
-static void
-remember_mouse_glyph (f1, gx, gy)
-struct frame * f1;
-int gx, gy;
-{
-if (!glyph_rect (f1, gx, gy, &last_mouse_glyph))
-{
-int width = FRAME_SMALLEST_CHAR_WIDTH (f1);
-int height = FRAME_SMALLEST_FONT_HEIGHT (f1);
-/* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
-	 round down even for negative values.  */
-if (gx < 0)
-	gx -= width - 1;
-if (gy < 0)
-	gy -= height - 1;
-#if 0
-/* This was the original code from XTmouse_position, but it seems
-	 to give the position of the glyph diagonally next to the one
-	 the mouse is over.  */
-gx = (gx + width - 1) / width * width;
-gy = (gy + height - 1) / height * height;
-#else
-gx = gx / width * width;
-gy = gy / height * height;
-#endif
-last_mouse_glyph.left = gx;
-last_mouse_glyph.top = gy;
-last_mouse_glyph.right  = gx + width;
-last_mouse_glyph.bottom = gy + height;
-}
 }
 static struct frame *
 mac_focus_frame (dpyinfo)
 return SELECTED_FRAME ();
 }
 /* Return the current position of the mouse.
-*fp should be a frame which indicates which display to ask about.
+*FP should be a frame which indicates which display to ask about.
-If the mouse movement started in a scroll bar, set *fp, *bar_window,
+If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
-and *part to the frame, window, and scroll bar part that the mouse
+and *PART to the frame, window, and scroll bar part that the mouse
-is over.  Set *x and *y to the portion and whole of the mouse's
+is over.  Set *X and *Y to the portion and whole of the mouse's
 position on the scroll bar.
-If the mouse movement started elsewhere, set *fp to the frame the
+If the mouse movement started elsewhere, set *FP to the frame the
-mouse is on, *bar_window to nil, and *x and *y to the character cell
+mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
 the mouse is over.
-Set *time to the server time-stamp for the time at which the mouse
+Set *TIME to the server time-stamp for the time at which the mouse
 was at this position.
 Don't store anything if we don't have a valid set of values to report.
 This clears the mouse_moved flag, so we can wait for the next mouse
 Lisp_Object *bar_window;
 enum scroll_bar_part *part;
 Lisp_Object *x, *y;
 unsigned long *time;
 {
-Point mouse_pos;
+FRAME_PTR f1;
-int ignore1, ignore2;
-struct frame *f = mac_focus_frame (FRAME_MAC_DISPLAY_INFO (*fp));
-WindowPtr wp = FRAME_MAC_WINDOW (f);
-Lisp_Object frame, tail;
 BLOCK_INPUT;
 if (! NILP (last_mouse_scroll_bar) && insist == 0)
 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
 else
 {
+Lisp_Object frame, tail;
 /* Clear the mouse-moved flag for every frame on this display.  */
 FOR_EACH_FRAME (tail, frame)
-XFRAME (frame)->mouse_moved = 0;
+	XFRAME (frame)->mouse_moved = 0;
 last_mouse_scroll_bar = Qnil;
-SetPortWindowPort (wp);
+if (FRAME_MAC_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
+	  && FRAME_LIVE_P (last_mouse_frame))
-GetMouse (&mouse_pos);
+	f1 = last_mouse_frame;
+else
-pixel_to_glyph_coords (f, mouse_pos.h, mouse_pos.v, &ignore1, &ignore2,
+	f1 = mac_focus_frame (FRAME_MAC_DISPLAY_INFO (*fp));
-&last_mouse_glyph, insist);
+if (f1)
-*bar_window = Qnil;
+	{
-*part = scroll_bar_handle;
+	  /* Ok, we found a frame.  Store all the values.
-*fp = f;
+	     last_mouse_glyph is a rectangle used to reduce the
-XSETINT (*x, mouse_pos.h);
+	     generation of mouse events.  To not miss any motion
-XSETINT (*y, mouse_pos.v);
+	     events, we must divide the frame into rectangles of the
-*time = last_mouse_movement_time;
+	     size of the smallest character that could be displayed
+	     on it, i.e. into the same rectangles that matrices on
+	     the frame are divided into.  */
+	  Point mouse_pos;
+	  SetPortWindowPort (FRAME_MAC_WINDOW (f1));
+	  GetMouse (&mouse_pos);
+	  remember_mouse_glyph (f1, mouse_pos.h, mouse_pos.v,
+				&last_mouse_glyph);
+	  *bar_window = Qnil;
+	  *part = 0;
+	  *fp = f1;
+	  XSETINT (*x, mouse_pos.h);
+	  XSETINT (*y, mouse_pos.v);
+	  *time = last_mouse_movement_time;
+	}
 }
 UNBLOCK_INPUT;
 }
 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;
 clip_rect.bottom = clip_rect.top + row->visible_height;
-mac_set_clip_rectangle (FRAME_MAC_DISPLAY (f), FRAME_MAC_WINDOW (f), &clip_rect);
+mac_set_clip_rectangles (FRAME_MAC_DISPLAY (f), gc, &clip_rect, 1);
 }
 /* Draw a hollow box cursor on window W in glyph row ROW.  */
 gc = dpyinfo->scratch_cursor_gc;
 /* Set clipping, draw the rectangle, and reset clipping again.  */
 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));
+mac_reset_clip_rectangles (dpy, gc);
 }
 /* Draw a bar cursor on window W in glyph row ROW.
 			WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
 						 row->height - width),
 			cursor_glyph->pixel_width,
 			width);
-mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
+mac_reset_clip_rectangles (dpy, gc);
 }
 }
 /* RIF: Define cursor CURSOR on frame F.  */
 /* the global font name table */
 static char **font_name_table = NULL;
 static int font_name_table_size = 0;
 static int font_name_count = 0;
+/* Alist linking font family names to Font Manager font family
+references (which can also be used as QuickDraw font IDs).  We use
+an alist because hash tables are not ready when the terminal frame
+for Mac OS Classic is created.  */
+static Lisp_Object fm_font_family_alist;
 #if USE_ATSUI
+/* Hash table linking font family names to ATSU font IDs.  */
 static Lisp_Object atsu_font_id_hash;
 #endif
 /* Alist linking character set strings to Mac text encoding and Emacs
 coding system. */
 Lisp_Object coding_system;
 {
 struct coding_system coding;
 char *buf, *p;
+if (!NILP (coding_system) && !NILP (Fcoding_system_p (coding_system)))
+{
+for (p = name; *p; p++)
+	if (!isascii (*p) || iscntrl (*p))
+	  break;
+if (*p)
+	{
+#if 0
+/* MAC_TODO: Fix encoding system... */
+	  setup_coding_system (coding_system, &coding);
+	  coding.src_multibyte = 0;
+	  coding.dst_multibyte = 1;
+	  coding.mode |= CODING_MODE_LAST_BLOCK;
+	  coding.composing = COMPOSITION_DISABLED;
+	  buf = (char *) alloca (size);
+	  decode_coding (&coding, name, buf, strlen (name), size - 1);
+	  bcopy (buf, name, coding.produced);
+	  name[coding.produced] = '\0';
+#endif
+	}
+}
+/* If there's just one occurrence of '-' in the family name, it is
+replaced with '_'.  (More than one occurrence of '-' means a
+"FOUNDRY-FAMILY-CHARSET"-style name.)  */
+p = strchr (name, '-');
+if (p && strchr (p + 1, '-') == NULL)
+*p = '_';
 for (p = name; *p; p++)
-if (!isascii (*p) || iscntrl (*p))
+/* On Mac OS X 10.3, tolower also converts non-ASCII characters
-break;
+for some locales.  */
+if (isascii (*p))
-if (*p == '\0'
+*p = tolower (*p);
-|| NILP (coding_system) || NILP (Fcoding_system_p (coding_system)))
-return;
-#if 0
-/* MAC_TODO: Fix encoding system... */
-setup_coding_system (coding_system, &coding);
-coding.src_multibyte = 0;
-coding.dst_multibyte = 1;
-coding.mode |= CODING_MODE_LAST_BLOCK;
-coding.dst_bytes = MAX_MULTsize;
-coding.destination = (char *) alloca (size);
-coding_decode_c_string(&coding, name, strlen(name), qNil);
-decode_coding (&coding, name, buf, strlen (name), size - 1);
-bcopy (buf, name, coding.produced);
-name[coding.produced] = '\0';
-#endif
 }
 static char *
 mac_to_x_fontname (name, size, style, charset)
 *p = tolower (*p);
 return result;
 }
-/* Convert an X font spec to the corresponding mac font name, which
+/* Parse fully-specified and instantiated X11 font spec XF, and store
-can then be passed to GetFNum after conversion to a Pascal string.
+the results to FAMILY, *SIZE, *STYLE, and CHARSET.  Return 1 if the
-For ordinary Mac fonts, this should just be their names, like
+parsing succeeded, and 0 otherwise.  For FAMILY and CHARSET, the
-"monaco", "Taipei", etc.  Fonts converted from the GNU intlfonts
+caller must allocate at least 256 and 32 bytes respectively.  For
-collection contain their charset designation in their names, like
+ordinary Mac fonts, the value stored to FAMILY should just be their
-"ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc.  Both types of font
+names, like "monaco", "Taipei", etc.  Fonts converted from the GNU
-names are handled accordingly.  */
+intlfonts collection contain their charset designation in their
-static void
+names, like "ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc.  Both
-x_font_name_to_mac_font_name (xf, mf, mf_decoded, style, cs)
+types of font names are handled accordingly.  */
-char *xf, *mf, *mf_decoded;
+const int kDefaultFontSize = 12;
+static int
+parse_x_font_name (xf, family, size, style, charset)
+char *xf, *family;
+int *size;
 Style *style;
-char *cs;
+char *charset;
 {
-Str31 foundry;
+Str31 foundry, weight;
-Str255 family;
+int point_size, avgwidth;
-char weight[20], slant[2], *p;
+char slant[2], *p;
-Lisp_Object charset_info, coding_system = Qnil;
-struct coding_system coding;
+if (sscanf (xf, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]-%*[^-]-%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
+foundry, family, weight, slant, size,
-strcpy (mf, "");
+	      &point_size, &avgwidth, charset) != 8
+&& sscanf (xf, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]--%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
-if (sscanf (xf, "-%31[^-]-%255[^-]-%19[^-]-%1[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
+		 foundry, family, weight, slant, size,
-foundry, family, weight, slant, cs) != 5 &&
+		 &point_size, &avgwidth, charset) != 8)
-sscanf (xf, "-%31[^-]-%255[^-]-%19[^-]-%1[^-]-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
+return 0;
-foundry, family, weight, slant, cs) != 5)
-return;
+if (*size == 0)
+{
+if (point_size > 0)
+	*size = point_size / 10;
+else if (avgwidth > 0)
+	*size = avgwidth / 10;
+}
+if (*size == 0)
+*size = kDefaultFontSize;
 *style = normal;
 if (strcmp (weight, "bold") == 0)
 *style |= bold;
 if (*slant == 'i')
 *style |= italic;
-charset_info = Fassoc (build_string (cs), Vmac_charset_info_alist);
+if (NILP (Fassoc (build_string (charset), Vmac_charset_info_alist)))
-if (!NILP (charset_info))
+{
-{
+int foundry_len = strlen (foundry), family_len = strlen (family);
-strcpy (mf_decoded, family);
-coding_system = Fcar (Fcdr (Fcdr (charset_info)));
+if (foundry_len + family_len + strlen (charset) + 2 < sizeof (Str255))
-}
+	{
-else
+	  /* Like sprintf (family, "%s-%s-%s", foundry, family, charset),
-sprintf (mf_decoded, "%s-%s-%s", foundry, family, cs);
+	     but take overlap into account.  */
+	  memmove (family + foundry_len + 1, family, family_len);
-for (p = mf_decoded; *p; p++)
+	  memcpy (family, foundry, foundry_len);
-if (!isascii (*p) || iscntrl (*p))
+	  family[foundry_len] = '-';
-break;
+	  family[foundry_len + 1 + family_len] = '-';
+	  strcpy (family + foundry_len + 1 + family_len + 1, charset);
-if (*p == '\0'
+	}
-|| NILP (coding_system) || NILP (Fcoding_system_p (coding_system)))
+else
-strcpy (mf, mf_decoded);
+	return 0;
-#if 0
+}
-/* MAC_TODO: Fix coding system to use objects */
-else
+for (p = family; *p; p++)
-{
+/* On Mac OS X 10.3, tolower also converts non-ASCII characters
-setup_coding_system (coding_system, &coding);
+for some locales.  */
-coding.src_multibyte = 1;
+if (isascii (*p))
-coding.dst_multibyte = 0;
+*p = tolower (*p);
-coding.mode |= CODING_MODE_LAST_BLOCK;
-encode_coding (&coding, mf_decoded, mf,
+return 1;
-		     strlen (mf_decoded), sizeof (Str255) - 1);
-mf[coding.produced] = '\0';
-}
-#endif
 }
 static void
 add_font_name_table_entry (char *font_name)
 	    name[name_len] = '\0';
 	    err = ATSUFindFontName (font_ids[i], kFontFamilyName,
 				    kFontMacintoshPlatform, kFontNoScript,
 				    kFontNoLanguage, name_len, name,
 				    NULL, NULL);
+	    if (err == noErr)
+	      decode_mac_font_name (name, name_len + 1, Qnil);
 	    if (err == noErr
 		&& *name != '.'
 		&& (prev_name == NULL
 		    || strcmp (name, prev_name) != 0))
 	      {
 							      italic, cs));
 		add_font_name_table_entry (mac_to_x_fontname (name, 0,
 							      bold, cs));
 		add_font_name_table_entry (mac_to_x_fontname (name, 0,
 							      italic | bold, cs));
-		Fputhash (Fdowncase (make_unibyte_string (name, name_len)),
+		Fputhash (make_unibyte_string (name, name_len),
 			  long_to_cons (font_ids[i]), atsu_font_id_hash);
 		xfree (prev_name);
 		prev_name = name;
 	      }
 	    else
 if (FMGetFontFamilyTextEncoding (ff, &encoding) != noErr)
 	break;
 sc = GetTextEncodingBase (encoding);
 text_encoding_info = assq_no_quit (make_number (sc),
 					 text_encoding_info_alist);
-if (!NILP (text_encoding_info))
+if (NILP (text_encoding_info))
-	decode_mac_font_name (name, sizeof (name),
-			      XCAR (XCDR (text_encoding_info)));
-else
 	text_encoding_info = assq_no_quit (make_number (kTextEncodingMacRoman),
 					   text_encoding_info_alist);
+decode_mac_font_name (name, sizeof (name),
+			    XCAR (XCDR (text_encoding_info)));
+fm_font_family_alist = Fcons (Fcons (build_string (name),
+					   make_number (ff)),
+				    fm_font_family_alist);
 /* Point the instance iterator at the current font family.  */
 if (FMResetFontFamilyInstanceIterator (ff, &ffii) != noErr)
 	break;
 TextFont (fontnum);
 scriptcode = FontToScript (fontnum);
 text_encoding_info = assq_no_quit (make_number (scriptcode),
 					 text_encoding_info_alist);
-if (!NILP (text_encoding_info))
+if (NILP (text_encoding_info))
-	decode_mac_font_name (name, sizeof (name),
-			      XCAR (XCDR (text_encoding_info)));
-else
 	text_encoding_info = assq_no_quit (make_number (smRoman),
 					   text_encoding_info_alist);
+decode_mac_font_name (name, sizeof (name),
+			    XCAR (XCDR (text_encoding_info)));
+fm_font_family_alist = Fcons (Fcons (build_string (name),
+					   make_number (fontnum)),
+				    fm_font_family_alist);
 do
 	{
 	  HLock (font_handle);
 	  if (GetResourceSizeOnDisk (font_handle)
 for (i = 0; i < font_name_count; i++)
 xfree (font_name_table[i]);
 xfree (font_name_table);
 font_name_table = NULL;
 font_name_table_size = font_name_count = 0;
+fm_font_family_alist = Qnil;
 }
 enum xlfd_scalable_field_index
 {
 return 1;
 }
-const int kDefaultFontSize = 12;
 /* XLoadQueryFont creates and returns an internal representation for a
 font in a MacFontStruct struct.  There is really no concept
 corresponding to "loading" a font on the Mac.  But we check its
 existence and find the font number and all other information for it
 and store them in the returned MacFontStruct.  */
 static MacFontStruct *
 XLoadQueryFont (Display *dpy, char *fontname)
 {
-int i, size, point_size, avgwidth, is_two_byte_font, char_width;
+int i, size, char_width;
 char *name;
-GrafPtr port;
+Str255 family;
-SInt16 old_fontnum, old_fontsize;
-Style old_fontface;
-Str255 mfontname, mfontname_decoded;
 Str31 charset;
 SInt16 fontnum;
 #if USE_ATSUI
 ATSUStyle mac_style = NULL;
 #endif
 int scriptcode;
 #else
 short scriptcode;
 #endif
 MacFontStruct *font;
-FontInfo the_fontinfo;
-#ifdef MAC_OSX
-UInt32 old_flags, new_flags;
-#endif
 if (is_fully_specified_xlfd (fontname))
 name = fontname;
 else
 {
 if (NILP (matched_fonts))
 	return NULL;
 name = SDATA (XCAR (matched_fonts));
 }
-GetPort (&port);  /* save the current font number used */
+if (parse_x_font_name (name, family, &size, &fontface, charset) == 0)
-#if TARGET_API_MAC_CARBON
+return NULL;
-old_fontnum = GetPortTextFont (port);
-old_fontsize = GetPortTextSize (port);
-old_fontface = GetPortTextFace (port);
-#else
-old_fontnum = port->txFont;
-old_fontsize = port->txSize;
-old_fontface = port->txFace;
-#endif
-if (sscanf (name, "-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]--%d-%d-%*[^-]-%*[^-]-%*c-%d-%*s", &size, &point_size, &avgwidth) != 3)
-size = 0;
-else
-{
-if (size == 0)
-	if (point_size > 0)
-	  size = point_size / 10;
-	else if (avgwidth > 0)
-	  size = avgwidth / 10;
-}
-if (size == 0)
-size = kDefaultFontSize;
-x_font_name_to_mac_font_name (name, mfontname, mfontname_decoded,
-				&fontface, charset);
 #if USE_ATSUI
 if (strcmp (charset, "iso10646-1") == 0) /* XXX */
 {
 OSErr err;
 ATSUAttributeTag tags[] = {kATSUFontTag, kATSUSizeTag,
 ATSUAttributeValuePtr values[] = {&font_id, &size_fixed,
 					&bold_p, &italic_p};
 ATSUFontFeatureType types[] = {kAllTypographicFeaturesType};
 ATSUFontFeatureSelector selectors[] = {kAllTypeFeaturesOffSelector};
 Lisp_Object font_id_cons;
-font_id_cons = Fgethash (Fdowncase
+font_id_cons = Fgethash (make_unibyte_string (family, strlen (family)),
-			       (make_unibyte_string (mfontname,
-						     strlen (mfontname))),
 			       atsu_font_id_hash, Qnil);
 if (NILP (font_id_cons))
 	return NULL;
 font_id = cons_to_long (font_id_cons);
 size_fixed = Long2Fix (size);
 			       tags, sizes, values);
 fontnum = -1;
 scriptcode = kTextEncodingMacUnicode;
 }
 else
-{
+#endif
-#endif
+{
-c2pstr (mfontname);
+Lisp_Object tmp = Fassoc (build_string (family), fm_font_family_alist);
+if (NILP (tmp))
+	return NULL;
+fontnum = XINT (XCDR (tmp));
 #if TARGET_API_MAC_CARBON
-fontnum = FMGetFontFamilyFromName (mfontname);
+if (FMGetFontFamilyTextEncoding (fontnum, &encoding) != noErr)
-if (fontnum == kInvalidFontFamily
+	return NULL;
-|| FMGetFontFamilyTextEncoding (fontnum, &encoding) != noErr)
+scriptcode = GetTextEncodingBase (encoding);
-return NULL;
-scriptcode = GetTextEncodingBase (encoding);
 #else
-GetFNum (mfontname, &fontnum);
+scriptcode = FontToScript (fontnum);
-if (fontnum == 0)
+#endif
-return NULL;
+}
-scriptcode = FontToScript (fontnum);
-#endif
-#if USE_ATSUI
-}
-#endif
 font = (MacFontStruct *) xmalloc (sizeof (struct MacFontStruct));
 font->mac_fontnum = fontnum;
 font->mac_fontsize = size;
 (Roman script) in init_font_name_table ().  The latter should be
 treated as a one-byte font.  */
 if (scriptcode == smJapanese && strcmp (charset, "jisx0201.1976-0") == 0)
 font->mac_scriptcode = smRoman;
-font->full_name = mac_to_x_fontname (mfontname_decoded, size, fontface, charset);
+font->full_name = mac_to_x_fontname (family, size, fontface, charset);
 #if USE_ATSUI
 if (font->mac_style)
 {
 OSErr err;
 font->max_byte1 = 0xff;
 font->min_char_or_byte2 = 0;
 font->max_char_or_byte2 = 0xff;
 }
 else
-{
+#endif
-#endif
+{
-is_two_byte_font = font->mac_scriptcode == smJapanese ||
+GrafPtr port;
-font->mac_scriptcode == smTradChinese ||
+SInt16 old_fontnum, old_fontsize;
-font->mac_scriptcode == smSimpChinese ||
+Style old_fontface;
-font->mac_scriptcode == smKorean;
+FontInfo the_fontinfo;
+int is_two_byte_font;
-TextFont (fontnum);
-TextSize (size);
+/* Save the current font number used.  */
-TextFace (fontface);
+GetPort (&port);
+#if TARGET_API_MAC_CARBON
-GetFontInfo (&the_fontinfo);
+old_fontnum = GetPortTextFont (port);
+old_fontsize = GetPortTextSize (port);
-font->ascent = the_fontinfo.ascent;
+old_fontface = GetPortTextFace (port);
-font->descent = the_fontinfo.descent;
+#else
+old_fontnum = port->txFont;
-if (is_two_byte_font)
+old_fontsize = port->txSize;
-{
+old_fontface = port->txFace;
-font->min_byte1 = 0xa1;
+#endif
-font->max_byte1 = 0xfe;
-font->min_char_or_byte2 = 0xa1;
+TextFont (fontnum);
-font->max_char_or_byte2 = 0xfe;
+TextSize (size);
+TextFace (fontface);
-/* Use the width of an "ideographic space" of that font because
-the_fontinfo.widMax returns the wrong width for some fonts.  */
+GetFontInfo (&the_fontinfo);
-switch (font->mac_scriptcode)
-{
+font->ascent = the_fontinfo.ascent;
-case smJapanese:
+font->descent = the_fontinfo.descent;
-	  font->min_byte1 = 0x81;
-	  font->max_byte1 = 0xfc;
+is_two_byte_font = (font->mac_scriptcode == smJapanese
-	  font->min_char_or_byte2 = 0x40;
+			  || font->mac_scriptcode == smTradChinese
-	  font->max_char_or_byte2 = 0xfc;
+			  || font->mac_scriptcode == smSimpChinese
-char_width = StringWidth("\p\x81\x40");
+			  || font->mac_scriptcode == smKorean);
-break;
-case smTradChinese:
+if (is_two_byte_font)
-	  font->min_char_or_byte2 = 0x40;
-char_width = StringWidth("\p\xa1\x40");
-break;
-case smSimpChinese:
-char_width = StringWidth("\p\xa1\xa1");
-break;
-case smKorean:
-char_width = StringWidth("\p\xa1\xa1");
-break;
-}
-}
-else
-{
-font->min_byte1 = font->max_byte1 = 0;
-font->min_char_or_byte2 = 0x20;
-font->max_char_or_byte2 = 0xff;
-/* Do this instead of use the_fontinfo.widMax, which incorrectly
-	 returns 15 for 12-point Monaco! */
-char_width = CharWidth ('m');
-}
-if (is_two_byte_font)
-{
-font->per_char = NULL;
-if (fontface & italic)
-	font->max_bounds.rbearing = char_width + 1;
-else
-	font->max_bounds.rbearing = char_width;
-font->max_bounds.lbearing = 0;
-font->max_bounds.width = char_width;
-font->max_bounds.ascent = the_fontinfo.ascent;
-font->max_bounds.descent = the_fontinfo.descent;
-font->min_bounds = font->max_bounds;
-}
-else
-{
-int c, min_width, max_width;
-Rect char_bounds, min_bounds, max_bounds;
-char ch;
-font->per_char = xmalloc (sizeof (XCharStruct) * (0xff - 0x20 + 1));
-min_width = max_width = char_width;
-SetRect (&min_bounds, -32767, -32767, 32767, 32767);
-SetRect (&max_bounds, 0, 0, 0, 0);
-for (c = 0x20; c <= 0xff; c++)
 	{
-	  ch = c;
+	  font->min_byte1 = 0xa1;
-	  char_width = CharWidth (ch);
+	  font->max_byte1 = 0xfe;
-	  QDTextBounds (1, &ch, &char_bounds);
+	  font->min_char_or_byte2 = 0xa1;
-	  STORE_XCHARSTRUCT (font->per_char[c - 0x20],
+	  font->max_char_or_byte2 = 0xfe;
-			     char_width, char_bounds);
-	  /* Some Japanese fonts (in SJIS encoding) return 0 as the
+	  /* Use the width of an "ideographic space" of that font
-	     character width of 0x7f.  */
+	     because the_fontinfo.widMax returns the wrong width for
-	  if (char_width > 0)
+	     some fonts.  */
+	  switch (font->mac_scriptcode)
 	    {
-	      min_width = min (min_width, char_width);
+	    case smJapanese:
-	      max_width = max (max_width, char_width);
+	      font->min_byte1 = 0x81;
-	    }
+	      font->max_byte1 = 0xfc;
-	  if (!EmptyRect (&char_bounds))
+	      font->min_char_or_byte2 = 0x40;
-	    {
+	      font->max_char_or_byte2 = 0xfc;
-	      SetRect (&min_bounds,
+	      char_width = StringWidth("\p\x81\x40");
-		       max (min_bounds.left, char_bounds.left),
+	      break;
-		       max (min_bounds.top, char_bounds.top),
+	    case smTradChinese:
-		       min (min_bounds.right, char_bounds.right),
+	      font->min_char_or_byte2 = 0x40;
-		       min (min_bounds.bottom, char_bounds.bottom));
+	      char_width = StringWidth("\p\xa1\x40");
-	      UnionRect (&max_bounds, &char_bounds, &max_bounds);
+	      break;
+	    case smSimpChinese:
+	      char_width = StringWidth("\p\xa1\xa1");
+	      break;
+	    case smKorean:
+	      char_width = StringWidth("\p\xa1\xa1");
+	      break;
 	    }
 	}
-STORE_XCHARSTRUCT (font->min_bounds, min_width, min_bounds);
+else
-STORE_XCHARSTRUCT (font->max_bounds, max_width, max_bounds);
-if (min_width == max_width
-	  && max_bounds.left >= 0 && max_bounds.right <= max_width)
 	{
-	  /* Fixed width and no overhangs.  */
+	  font->min_byte1 = font->max_byte1 = 0;
-	  xfree (font->per_char);
+	  font->min_char_or_byte2 = 0x20;
+	  font->max_char_or_byte2 = 0xff;
+	  /* Do this instead of use the_fontinfo.widMax, which
+	     incorrectly returns 15 for 12-point Monaco! */
+	  char_width = CharWidth ('m');
+	}
+if (is_two_byte_font)
+	{
 	  font->per_char = NULL;
+	  if (fontface & italic)
+	    font->max_bounds.rbearing = char_width + 1;
+	  else
+	    font->max_bounds.rbearing = char_width;
+	  font->max_bounds.lbearing = 0;
+	  font->max_bounds.width = char_width;
+	  font->max_bounds.ascent = the_fontinfo.ascent;
+	  font->max_bounds.descent = the_fontinfo.descent;
+	  font->min_bounds = font->max_bounds;
 	}
-}
+else
+	{
-TextFont (old_fontnum);  /* restore previous font number, size and face */
+	  int c, min_width, max_width;
-TextSize (old_fontsize);
+	  Rect char_bounds, min_bounds, max_bounds;
-TextFace (old_fontface);
+	  char ch;
-#if USE_ATSUI
-}
+	  font->per_char = xmalloc (sizeof (XCharStruct) * (0xff - 0x20 + 1));
-#endif
+	  bzero (font->per_char, sizeof (XCharStruct) * (0xff - 0x20 + 1));
+	  min_width = max_width = char_width;
+	  SetRect (&min_bounds, -32767, -32767, 32767, 32767);
+	  SetRect (&max_bounds, 0, 0, 0, 0);
+	  for (c = 0x20; c <= 0xff; c++)
+	    {
+	      ch = c;
+	      char_width = CharWidth (ch);
+	      QDTextBounds (1, &ch, &char_bounds);
+	      STORE_XCHARSTRUCT (font->per_char[c - 0x20],
+				 char_width, char_bounds);
+	      /* Some Japanese fonts (in SJIS encoding) return 0 as
+		 the character width of 0x7f.  */
+	      if (char_width > 0)
+		{
+		  min_width = min (min_width, char_width);
+		  max_width = max (max_width, char_width);
+		}
+	      if (!EmptyRect (&char_bounds))
+		{
+		  SetRect (&min_bounds,
+			   max (min_bounds.left, char_bounds.left),
+			   max (min_bounds.top, char_bounds.top),
+			   min (min_bounds.right, char_bounds.right),
+			   min (min_bounds.bottom, char_bounds.bottom));
+		  UnionRect (&max_bounds, &char_bounds, &max_bounds);
+		}
+	    }
+	  STORE_XCHARSTRUCT (font->min_bounds, min_width, min_bounds);
+	  STORE_XCHARSTRUCT (font->max_bounds, max_width, max_bounds);
+	  if (min_width == max_width
+	      && max_bounds.left >= 0 && max_bounds.right <= max_width)
+	    {
+	      /* Fixed width and no overhangs.  */
+	      xfree (font->per_char);
+	      font->per_char = NULL;
+	    }
+	}
+/* Restore previous font number, size and face.  */
+TextFont (old_fontnum);
+TextSize (old_fontsize);
+TextFace (old_fontface);
+}
 return font;
 }
 #if !USE_CARBON_EVENTS
 	      SetRectRgn (mouse_region, er.where.h, er.where.v,
 			  er.where.h + 1, er.where.v + 1);
 #endif
 	      previous_help_echo_string = help_echo_string;
-	      help_echo_string = help_echo_object = help_echo_window = Qnil;
+	      help_echo_string = Qnil;
-	      help_echo_pos = -1;
 	      if (dpyinfo->grabbed && last_mouse_frame
 		  && FRAME_LIVE_P (last_mouse_frame))
 		f = last_mouse_frame;
 	      else
 			      inev.frame_or_window = window;
 			    }
 			  last_window=window;
 			}
-		      note_mouse_movement (f, &mouse_pos);
+		      if (!note_mouse_movement (f, &mouse_pos))
+			help_echo_string = previous_help_echo_string;
 		    }
 		}
 	      /* If the contents of the global variable
 		 help_echo_string has changed, generate a
 #endif
 staticpro (&Qreverse);
 Qreverse = intern ("reverse");
+staticpro (&Qmac_ready_for_drag_n_drop);
+Qmac_ready_for_drag_n_drop = intern ("mac-ready-for-drag-n-drop");
 staticpro (&x_display_name_list);
 x_display_name_list = Qnil;
 staticpro (&last_mouse_scroll_bar);
 last_mouse_scroll_bar = Qnil;
-Qmac_ready_for_drag_n_drop = intern ("mac-ready-for-drag-n-drop");
+staticpro (&fm_font_family_alist);
-staticpro (&Qmac_ready_for_drag_n_drop);
+fm_font_family_alist = Qnil;
 #if USE_ATSUI
 staticpro (&atsu_font_id_hash);
 atsu_font_id_hash = Qnil;
 #endif

Mercurial > emacs

comparison src/macterm.c @ 90242:5e2d3828e89f