| package org.eclipse.swt.graphics; |
| |
| /* |
| * (c) Copyright IBM Corp. 2000, 2001. |
| * All Rights Reserved |
| */ |
| |
| import org.eclipse.swt.*; |
| import org.eclipse.swt.internal.*; |
| import org.eclipse.swt.internal.gtk.*; |
| import org.eclipse.swt.widgets.*; |
| |
| /** |
| * Instances of this class manage operating system resources that |
| * define how text looks when it is displayed. Fonts may be constructed |
| * by providing a device and either name, size and style information |
| * or a <code>FontData</code> object which encapsulates this data. |
| * <p> |
| * Application code must explicitly invoke the <code>Font.dispose()</code> |
| * method to release the operating system resources managed by each instance |
| * when those instances are no longer required. |
| * </p> |
| * |
| * @see FontData |
| */ |
| public final class Font { |
| /** |
| * the handle to the OS font resource |
| * (Warning: This field is platform dependent) |
| */ |
| public int handle; |
| Font() { |
| } |
| /** |
| * Constructs a new font given a device and font data |
| * which describes the desired font's appearance. |
| * <p> |
| * You must dispose the font when it is no longer required. |
| * </p> |
| * |
| * @param device the device to create the font on |
| * @param fd the FontData that describes the desired font (must not be null) |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the fd argument is null</li> |
| * </ul> |
| * @exception SWTError <ul> |
| * <li>ERROR_NO_HANDLES - if a font could not be created from the given font data</li> |
| * </ul> |
| */ |
| public Font(Device display, FontData fd) { |
| if (fd == null) error(SWT.ERROR_NULL_ARGUMENT); |
| |
| String xlfd = fd.getXlfd(); |
| byte[] buffer = Converter.wcsToMbcs(null, xlfd, true); |
| handle = OS.gdk_font_load(buffer); |
| if (handle == 0) { |
| int hStyle = OS.gtk_widget_get_default_style(); |
| GtkStyle gtkStyle = new GtkStyle(); |
| OS.memmove(gtkStyle, hStyle, GtkStyle.sizeof); |
| handle = OS.gdk_font_ref(gtkStyle.font); |
| } |
| } |
| /** |
| * Constructs a new font given a device, a font name, |
| * the height of the desired font in points, and a font |
| * style. |
| * <p> |
| * You must dispose the font when it is no longer required. |
| * </p> |
| * |
| * @param device the device to create the font on |
| * @param name the name of the font (must not be null) |
| * @param height the font height in points |
| * @param style a bit or combination of NORMAL, BOLD, ITALIC |
| * |
| * @exception IllegalArgumentException <ul> |
| * <li>ERROR_NULL_ARGUMENT - if the name argument is null</li> |
| * <li>ERROR_INVALID_ARGUMENT - if the height is negative</li> |
| * </ul> |
| * @exception SWTError <ul> |
| * <li>ERROR_NO_HANDLES - if a font could not be created from the given arguments</li> |
| * </ul> |
| */ |
| public Font(Device display, String fontFamily, int height, int style) { |
| if (fontFamily == null) error(SWT.ERROR_NULL_ARGUMENT); |
| FontData fd = new FontData(fontFamily, height, style); |
| byte[] buffer = Converter.wcsToMbcs(null, fd.getXlfd(), true); |
| handle = OS.gdk_font_load(buffer); |
| if (handle == 0) { |
| int hStyle = OS.gtk_widget_get_default_style(); |
| GtkStyle gtkStyle = new GtkStyle(); |
| OS.memmove(gtkStyle, hStyle, GtkStyle.sizeof); |
| handle = OS.gdk_font_ref(gtkStyle.font); |
| } |
| } |
| /** |
| * Disposes of the operating system resources associated with |
| * the font. Applications must dispose of all fonts which |
| * they allocate. |
| */ |
| public void dispose() { |
| if (handle != 0) OS.gdk_font_unref(handle); |
| handle = 0; |
| } |
| /** |
| * Compares the argument to the receiver, and returns true |
| * if they represent the <em>same</em> object using a class |
| * specific comparison. |
| * |
| * @param object the object to compare with this object |
| * @return <code>true</code> if the object is the same as this object and <code>false</code> otherwise |
| * |
| * @see #hashCode |
| */ |
| public boolean equals(Object object) { |
| if (object == this) return true; |
| if (!(object instanceof Font)) return false; |
| return OS.gdk_font_equal(handle, ((Font)object).handle); |
| } |
| void error(int code) { |
| throw new SWTError (code); |
| } |
| |
| /** |
| * Returns an array of <code>FontData</code>s representing the receiver. |
| * On Windows, only one FontData will be returned per font. On X however, |
| * a <code>Font</code> object <em>may</em> be composed of multiple X |
| * fonts. To support this case, we return an array of font data objects. |
| * |
| * @return an array of font data objects describing the receiver |
| * |
| * @exception SWTException <ul> |
| * <li>ERROR_GRAPHIC_DISPOSED - if the receiver has been disposed</li> |
| * </ul> |
| */ |
| public FontData[] getFontData() { |
| int index=0; |
| int fnames = getFontNameList(handle); |
| int nfonts = OS.g_slist_length(fnames); |
| FontData[] answer = new FontData[nfonts]; |
| for (int i=0; i<nfonts; i++) { |
| FontData data = new FontData(); |
| |
| int name = OS.g_slist_nth_data(fnames, index); |
| int length = OS.strlen(name); |
| byte [] buffer1 = new byte[length]; |
| OS.memmove(buffer1, name, length); |
| char [] buffer2 = Converter.mbcsToWcs (null, buffer1); |
| String fontname = new String (buffer2, 0, buffer2.length); |
| data.setXlfd(fontname); |
| |
| // Wild guess, 'a' looks average enough |
| data.averageWidth = OS.gdk_char_width(handle, (byte)'a'); |
| |
| // Wild guess, a progressive font should probably have A wider than l |
| int widthA = OS.gdk_char_width(handle, (byte)'A'); |
| int widthl = OS.gdk_char_width(handle, (byte)'l'); |
| if (widthA == widthl) data.spacing = "m"; |
| else data.spacing = "p"; |
| |
| answer[i] = data; |
| } |
| return answer; |
| } |
| static int getFontNameList(int handle) { |
| int[] mem = new int[7]; |
| OS.memmove(mem, handle, 7*4); |
| int type = mem[0]; |
| int ascent = mem[1]; |
| int descent = mem[2]; |
| int xfont =mem [3]; |
| int xdisplay = mem[4]; |
| int ref_count = mem[5]; |
| int names = mem[6]; |
| return names; |
| } |
| public static Font gtk_new(int handle) { |
| Font font = new Font(); |
| font.handle = handle; |
| return font; |
| } |
| /** |
| * Returns an integer hash code for the receiver. Any two |
| * objects which return <code>true</code> when passed to |
| * <code>equals</code> must return the same value for this |
| * method. |
| * |
| * @return the receiver's hash |
| * |
| * @see #equals |
| */ |
| public int hashCode() { |
| return handle; |
| } |
| /** |
| * Returns <code>true</code> if the font has been disposed, |
| * and <code>false</code> otherwise. |
| * <p> |
| * This method gets the dispose state for the font. |
| * When a font has been disposed, it is an error to |
| * invoke any other method using the font. |
| * |
| * @return <code>true</code> when the font is disposed and <code>false</code> otherwise |
| */ |
| public boolean isDisposed() { |
| return handle == 0; |
| } |
| |
| /** |
| * Returns a string containing a concise, human-readable |
| * description of the receiver. |
| * |
| * @return a string representation of the receiver |
| */ |
| public String toString () { |
| if (isDisposed()) return "Font {*DISPOSED*}"; |
| return "Font {" + handle + "}"; |
| } |
| |
| } |