Java Font.ITALIC属性代码示例

long getGlyphImageFromWindows(int glyphCode) {
    String family = fileFont.getFamilyName(null);
    int style = desc.style & Font.BOLD | desc.style & Font.ITALIC
        | fileFont.getStyle();
    int size = intPtSize;
    long ptr = _getGlyphImageFromWindows
        (family, style, size, glyphCode,
         desc.fmHint == INTVAL_FRACTIONALMETRICS_ON);
    if (ptr != 0) {
        /* Get the advance from the JDK rasterizer. This is mostly
         * necessary for the fractional metrics case, but there are
         * also some very small number (<0.25%) of marginal cases where
         * there is some rounding difference between windows and JDK.
         * After these are resolved, we can restrict this extra
         * work to the FM case.
         */
        float advance = getGlyphAdvance(glyphCode, false);
        StrikeCache.unsafe.putFloat(ptr + StrikeCache.xAdvanceOffset,
                                    advance);
        return ptr;
    } else {
        return fileFont.getGlyphImage(pScalerContext, glyphCode);
    }
}
 

public Font2D getFontWithExactStyleMatch(int style) {

        switch (style) {

        case Font.PLAIN:
            return plain;

        case Font.BOLD:
            return bold;

        case Font.ITALIC:
            return italic;

        case Font.BOLD|Font.ITALIC:
            return bolditalic;

        default:
            return null;
        }
    }
 

/**
 * Changes the style (Bold, Italic ) of the selected text by checking the
 * style buttons
 */
public static void setStyle() {

    int style = Font.PLAIN;

    if (ckbbold.isSelected()) {
        style |= Font.BOLD;
    }

    if (ckbitalic.isSelected()) {
        style |= Font.ITALIC;
    }

    fOwner.tTree.setFont(fOwner.txtCommand.getFont().deriveFont(style));
    fOwner.txtCommand.setFont(
        fOwner.txtCommand.getFont().deriveFont(style));
    fOwner.txtResult.setFont(
        fOwner.txtResult.getFont().deriveFont(style));
}
 

protected void setStyle() {

        String fName = fullName.toLowerCase();

        for (int i=0; i < boldItalicNames.length; i++) {
            if (fName.indexOf(boldItalicNames[i]) != -1) {
                style = Font.BOLD|Font.ITALIC;
                return;
            }
        }

        for (int i=0; i < italicNames.length; i++) {
            if (fName.indexOf(italicNames[i]) != -1) {
                style = Font.ITALIC;
                return;
            }
        }

        for (int i=0; i < boldNames.length; i++) {
            if (fName.indexOf(boldNames[i]) != -1 ) {
                style = Font.BOLD;
                return;
            }
        }
    }
 

public Component getListCellRendererComponent(JList list, Object value, int index,
    boolean isSelected, boolean cellHasFocus) {

  super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

  if (standardFont == null) {
    standardFont = getFont();
    highlightFont = new Font(standardFont.getFamily(), Font.BOLD + Font.ITALIC, standardFont
        .getSize());
  }

  if (value instanceof AddressBookEntry) {
    final AddressBookEntry e = (AddressBookEntry) value;
    setIcon(e.getIcon(LEAF_ICON_SIZE));
    if (e.isCurrent()) {
      setFont(highlightFont);
      setText(e.toString() + Resources.getString("ServerAddressBook.current")); //$NON-NLS-1$
    }
    else {
      setFont(standardFont);
    }

  }
  return this;
}
 

/**
 * 
 */
protected void updateFont()
{
	int size = (int) Math.round(state.fontSize * state.scale);
	int style = ((state.fontStyle
			& mxConstants.FONT_BOLD) == mxConstants.FONT_BOLD) ? Font.BOLD
					: Font.PLAIN;
	style += ((state.fontStyle
			& mxConstants.FONT_ITALIC) == mxConstants.FONT_ITALIC)
					? Font.ITALIC : Font.PLAIN;

	if (lastFont == null || !lastFontFamily.equals(state.fontFamily)
			|| size != lastFontSize || style != lastFontStyle)
	{
		lastFont = createFont(state.fontFamily, style, size);
		lastFontFamily = state.fontFamily;
		lastFontStyle = style;
		lastFontSize = size;
	}

	state.g.setFont(lastFont);
}
 

public static String decodeFontStyle(int style) {
    switch(style) {
        case Font.BOLD:
            return Editor.fromConfiguracao.getValor("Inspector.obj.font.bold");
        case Font.PLAIN:
            return Editor.fromConfiguracao.getValor("Inspector.obj.font.plain");
        case Font.ITALIC:
            return Editor.fromConfiguracao.getValor("Inspector.obj.font.italic");
        case Font.BOLD | Font.ITALIC:
            return Editor.fromConfiguracao.getValor("Inspector.obj.font.bolditalic");
    }
    return "";
}
 

/**
 * Get a styled version of a particular font family
 * 
 * @param familyName The name of the font family
 * @param style The style (@see java.awt.Font#PLAIN)
 * @return The styled font or null if no such font exists
 */
public static FontData getStyled(String familyName, int style) {
	boolean b = (style & Font.BOLD) != 0;
	boolean i = (style & Font.ITALIC) != 0;

	if (b & i) {
		return getBoldItalic(familyName);
	} else if (b) {
		return getBold(familyName);
	} else if (i) {
		return getItalic(familyName);
	} else {
		return getPlain(familyName);
	}
}
 

public static String toStyleDisplayString(int style) {
	switch (style) {
	case Font.PLAIN:
		return Strings.get("fontPlainStyle");
	case Font.ITALIC:
		return Strings.get("fontItalicStyle");
	case Font.BOLD:
		return Strings.get("fontBoldStyle");
	case Font.BOLD | Font.ITALIC:
		return Strings.get("fontBoldItalicStyle");
	default:
		return "??";
	}
}
 

protected static int getStyleIndex(int style) {
    switch (style) {
        case Font.PLAIN:
            return 0;
        case Font.BOLD:
            return 1;
        case Font.ITALIC:
            return 2;
        case Font.BOLD | Font.ITALIC:
            return 3;
        default:
            return 0;
    }
}
 

protected void doTest() {
    Font f = new Font(Font.SANS_SERIF, Font.ITALIC, 24);
    f.getNumGlyphs();
}
 

public Font2D getFont(int style) {

        switch (style) {

        case Font.PLAIN:
            return plain;

        case Font.BOLD:
            if (bold != null) {
                return bold;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }

        case Font.ITALIC:
            if (italic != null) {
                return italic;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }

        case Font.BOLD|Font.ITALIC:
            if (bolditalic != null) {
                return bolditalic;
            } else if (bold != null && bold.canDoStyle(style)) {
                return bold;
            } else if (italic != null && italic.canDoStyle(style)) {
                    return italic;
            } else if (plain != null && plain.canDoStyle(style)) {
                    return plain;
            } else {
                return null;
            }
        default:
            return null;
        }
    }
 

private void setStyle(ByteBuffer os_2Table) {
        if (os_2Table == null) {
            return;
        }
        if (os_2Table.capacity() >= 8) {
            fontWeight = os_2Table.getChar(4) & 0xffff;
            fontWidth  = os_2Table.getChar(6) & 0xffff;
        }
        /* fsSelection is unsigned short at buffer offset 62 */
        if (os_2Table.capacity() < 64) {
            super.setStyle();
            return;
        }
        int fsSelection = os_2Table.getChar(62) & 0xffff;
        int italic  = fsSelection & fsSelectionItalicBit;
        int bold    = fsSelection & fsSelectionBoldBit;
        int regular = fsSelection & fsSelectionRegularBit;
//      System.out.println("platname="+platName+" font="+fullName+
//                         " family="+familyName+
//                         " R="+regular+" I="+italic+" B="+bold);
        if (regular!=0 && ((italic|bold)!=0)) {
            /* This is inconsistent. Try using the font name algorithm */
            super.setStyle();
            return;
        } else if ((regular|italic|bold) == 0) {
            /* No style specified. Try using the font name algorithm */
            super.setStyle();
            return;
        }
        switch (bold|italic) {
        case fsSelectionItalicBit:
            style = Font.ITALIC;
            break;
        case fsSelectionBoldBit:
            if (FontUtilities.isSolaris && platName.endsWith("HG-GothicB.ttf")) {
                /* Workaround for Solaris's use of a JA font that's marked as
                 * being designed bold, but is used as a PLAIN font.
                 */
                style = Font.PLAIN;
            } else {
                style = Font.BOLD;
            }
            break;
        case fsSelectionBoldBit|fsSelectionItalicBit:
            style = Font.BOLD|Font.ITALIC;
        }
    }
 

public RadioButtonFrame()
{
   super("RadioButton Test");
   setLayout(new FlowLayout()); 

   textField = new JTextField("Watch the font style change", 25);
   add(textField); // add textField to JFrame

   // create radio buttons
   plainJRadioButton = new JRadioButton("Plain", true);
   boldJRadioButton = new JRadioButton("Bold", false);
   italicJRadioButton = new JRadioButton("Italic", false);
   boldItalicJRadioButton = new JRadioButton("Bold/Italic", false);
   add(plainJRadioButton); // add plain button to JFrame
   add(boldJRadioButton); // add bold button to JFrame
   add(italicJRadioButton); // add italic button to JFrame
   add(boldItalicJRadioButton); // add bold and italic button

   // create logical relationship between JRadioButtons
   radioGroup = new ButtonGroup(); // create ButtonGroup
   radioGroup.add(plainJRadioButton); // add plain to group
   radioGroup.add(boldJRadioButton); // add bold to group
   radioGroup.add(italicJRadioButton); // add italic to group
   radioGroup.add(boldItalicJRadioButton); // add bold and italic

   // create font objects
   plainFont = new Font("Serif", Font.PLAIN, 14);
   boldFont = new Font("Serif", Font.BOLD, 14);
   italicFont = new Font("Serif", Font.ITALIC, 14);
   boldItalicFont = new Font("Serif", Font.BOLD + Font.ITALIC, 14);
   textField.setFont(plainFont);

   // register events for JRadioButtons
   plainJRadioButton.addItemListener(
      new RadioButtonHandler(plainFont));
   boldJRadioButton.addItemListener(
      new RadioButtonHandler(boldFont));
   italicJRadioButton.addItemListener(
      new RadioButtonHandler(italicFont));
   boldItalicJRadioButton.addItemListener(
      new RadioButtonHandler(boldItalicFont));
}
 

protected Expression instantiate(Object oldInstance, Encoder out) {
    Font font = (Font) oldInstance;

    int count = 0;
    String family = null;
    int style = Font.PLAIN;
    int size = 12;

    Map<TextAttribute, ?> basic = font.getAttributes();
    Map<TextAttribute, Object> clone = new HashMap<>(basic.size());
    for (TextAttribute key : basic.keySet()) {
        Object value = basic.get(key);
        if (value != null) {
            clone.put(key, value);
        }
        if (key == TextAttribute.FAMILY) {
            if (value instanceof String) {
                count++;
                family = (String) value;
            }
        }
        else if (key == TextAttribute.WEIGHT) {
            if (TextAttribute.WEIGHT_REGULAR.equals(value)) {
                count++;
            } else if (TextAttribute.WEIGHT_BOLD.equals(value)) {
                count++;
                style |= Font.BOLD;
            }
        }
        else if (key == TextAttribute.POSTURE) {
            if (TextAttribute.POSTURE_REGULAR.equals(value)) {
                count++;
            } else if (TextAttribute.POSTURE_OBLIQUE.equals(value)) {
                count++;
                style |= Font.ITALIC;
            }
        } else if (key == TextAttribute.SIZE) {
            if (value instanceof Number) {
                Number number = (Number) value;
                size = number.intValue();
                if (size == number.floatValue()) {
                    count++;
                }
            }
        }
    }
    Class<?> type = font.getClass();
    if (count == clone.size()) {
        return new Expression(font, type, "new", new Object[]{family, style, size});
    }
    if (type == Font.class) {
        return new Expression(font, type, "getFont", new Object[]{clone});
    }
    return new Expression(font, type, "new", new Object[]{Font.getFont(clone)});
}