Coverage Report

Coverage Report - net.sourceforge.jeuclid.elements.support.attributes.MathVariant

Classes in this File

Line Coverage

Branch Coverage

Complexity

MathVariant

72%

65/90

43%

13/30

3,75

 /*
  * Copyright 2002 - 2008 JEuclid, http://jeuclid.sf.net
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 /* $Id: MathVariant.java,v e6bd6c2d9bf4 2008/11/28 15:02:26 maxberger $ */
 
 package net.sourceforge.jeuclid.elements.support.attributes;
 
 import java.awt.Font;
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 import net.sourceforge.jeuclid.LayoutContext;
 import net.sourceforge.jeuclid.context.Parameter;
 import net.sourceforge.jeuclid.elements.support.text.CharacterMapping;
 import net.sourceforge.jeuclid.font.FontFactory;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
 /**
  * Class to represent and use MathVariants.
  * 
  * @version $Revision: e6bd6c2d9bf4 $
  */
 public final class MathVariant implements Serializable {
 
     /**
      * Mathvariant constant. Bold style.
      */
     public static final MathVariant BOLD = new MathVariant(Font.BOLD,
             FontFamily.SERIF);
 
     /**
      * Mathvariant constant. Bold fraktur style.
      */
     public static final MathVariant BOLD_FRAKTUR = new MathVariant(Font.BOLD,
             FontFamily.FRAKTUR);
 
     /**
      * Mathvariant constant. Bold-italic style.
      */
     public static final MathVariant BOLD_ITALIC = new MathVariant(Font.BOLD
             | Font.ITALIC, FontFamily.SERIF);
 
     /**
      * Mathvariant constant. Bold sans-serif style.
      */
     public static final MathVariant BOLD_SANS_SERIF = new MathVariant(
             Font.BOLD, FontFamily.SANSSERIF);
 
     /**
      * Mathvariant constant. Bold script style.
      */
     public static final MathVariant BOLD_SCRIPT = new MathVariant(Font.BOLD,
             FontFamily.SCRIPT);
 
     /**
      * Mathvariant constant. Double struck style.
      */
     public static final MathVariant DOUBLE_STRUCK = new MathVariant(
             Font.PLAIN, FontFamily.DOUBLE_STRUCK);
 
     /**
      * Mathvariant constant. Fraktur style.
      */
     public static final MathVariant FRAKTUR = new MathVariant(Font.PLAIN,
             FontFamily.FRAKTUR);
 
     /**
      * Mathvariant constant. Italic style.
      */
     public static final MathVariant ITALIC = new MathVariant(Font.ITALIC,
             FontFamily.SERIF);
 
     /**
      * Mathvariant constant. Monospace style.
      */
     public static final MathVariant MONOSPACE = new MathVariant(Font.PLAIN,
             FontFamily.MONOSPACED);
 
     /**
      * Mathvariant constant. Normal style.
      */
     public static final MathVariant NORMAL = new MathVariant(Font.PLAIN,
             FontFamily.SERIF);
 
     /**
      * Mathvariant constant. Sans-serif style.
      */
     public static final MathVariant SANS_SERIF = new MathVariant(Font.PLAIN,
             FontFamily.SANSSERIF);
 
     /**
      * Mathvariant constant. Bold italic sans-serif style.
      */
     public static final MathVariant SANS_SERIF_BOLD_ITALIC = new MathVariant(
             Font.BOLD | Font.ITALIC, FontFamily.SANSSERIF);
 
     /**
      * Mathvariant constant. Italic sans-serif style.
      */
     public static final MathVariant SANS_SERIF_ITALIC = new MathVariant(
             Font.ITALIC, FontFamily.SANSSERIF);
 
     /**
      * Mathvariant constant. Script style.
      */
     public static final MathVariant SCRIPT = new MathVariant(Font.PLAIN,
             FontFamily.SCRIPT);
 
     private static final Map<String, MathVariant> ATTRIBUTEMAP = new HashMap<String, MathVariant>();
 
     private static final Map<FontFamily, Parameter> PARAMFORFONT = new HashMap<FontFamily, Parameter>();
 
     /**
      * 
      */
     private static final long serialVersionUID = 1L;
 
     /**
      * Logger for this class.
      */
     private static final Log LOGGER = LogFactory
             .getLog(CharacterMapping.class);
 
     private static final Set<Integer> WARNED = new HashSet<Integer>();
 
     private final int awtStyle;
 
     private final FontFamily fontFamily;
 
     /**
      * Creates a Mathvariant with the given AWT-Style and font-family.
      * 
      * @param awtstyle
      *            the awt Style
      * @param family
      *            the font family
      */
     public MathVariant(final int awtstyle, final FontFamily family) {
         this.awtStyle = awtstyle;
         this.fontFamily = family;
     };
 
     /**
      * Creates a Mathvariant object from an attribute value.
      * 
      * @param variant
      *            the string representation of the attribute value
      * @return a mathVariant object or null if none is found.
      */
     public static MathVariant stringToMathVariant(final String variant) {
         synchronized (MathVariant.ATTRIBUTEMAP) {
             // Needs to be initialized late due to chicken-egg problem.
             if (MathVariant.ATTRIBUTEMAP.isEmpty()) {
                 MathVariant.ATTRIBUTEMAP.put("normal", MathVariant.NORMAL);
                 MathVariant.ATTRIBUTEMAP.put("bold", MathVariant.BOLD);
                 MathVariant.ATTRIBUTEMAP.put("italic", MathVariant.ITALIC);
                 MathVariant.ATTRIBUTEMAP.put("bold-italic",
                         MathVariant.BOLD_ITALIC);
                 MathVariant.ATTRIBUTEMAP.put("double-struck",
                         MathVariant.DOUBLE_STRUCK);
                 MathVariant.ATTRIBUTEMAP.put("bold-fraktur",
                         MathVariant.BOLD_FRAKTUR);
                 MathVariant.ATTRIBUTEMAP.put("script", MathVariant.SCRIPT);
                 MathVariant.ATTRIBUTEMAP.put("bold-script",
                         MathVariant.BOLD_SCRIPT);
                 MathVariant.ATTRIBUTEMAP.put("fraktur", MathVariant.FRAKTUR);
                 MathVariant.ATTRIBUTEMAP.put("sans-serif",
                         MathVariant.SANS_SERIF);
                 MathVariant.ATTRIBUTEMAP.put("bold-sans-serif",
                         MathVariant.BOLD_SANS_SERIF);
                 MathVariant.ATTRIBUTEMAP.put("sans-serif-italic",
                         MathVariant.SANS_SERIF_ITALIC);
                 MathVariant.ATTRIBUTEMAP.put("sans-serif-bold-italic",
                         MathVariant.SANS_SERIF_BOLD_ITALIC);
                 MathVariant.ATTRIBUTEMAP.put("monospace",
                         MathVariant.MONOSPACE);
             }
             return MathVariant.ATTRIBUTEMAP.get(variant
                     .toLowerCase(Locale.ENGLISH));
         }
     }
 
     /**
      * Create a font for the given attributes.
      * 
      * @param size
      *            size of the font to create
      * @param codepoint
      *            a character that must exist in this font
      * @param context
      *            LayoutContext to use.
      * @param force
      *            if true will always return a font, otherwise will return
      *            null.
      * @return a font object.
      */
     @SuppressWarnings("unchecked")
     public Font createFont(final float size, final int codepoint,
             final LayoutContext context, final boolean force) {
 
         final Parameter theParam = MathVariant.PARAMFORFONT
                 .get(this.fontFamily);
         final Font font = FontFactory.getInstance().getFont(
                 (List<String>) context.getParameter(theParam), codepoint,
                 this.awtStyle, size);
         if (force && font == null) {
             if (!MathVariant.WARNED.contains(codepoint)) {
                 MathVariant.WARNED.add(codepoint);
                 final String hexString = Integer.toHexString(codepoint);
                 MathVariant.LOGGER
                         .warn("No font available to display character "
                                 + hexString);
                 MathVariant.LOGGER
                         .info("Find a font at  http://www.fileformat.info/info/unicode/char/"
                                 + hexString
                                 + "/fontsupport.htm or "
                                 + "http://www.alanwood.net/unicode/search.html");
             }
             return FontFactory.getInstance().getFont(FontFactory.SANSSERIF,
                     this.awtStyle, size);
         }
         return font;
     }
 
     /**
      * @return the awtStyle
      */
     public int getAwtStyle() {
         return this.awtStyle;
     }
 
     /**
      * @return the fontFamily
      */
     public FontFamily getFontFamily() {
         return this.fontFamily;
     }
 
     static {
         MathVariant.PARAMFORFONT.put(FontFamily.SERIF, Parameter.FONTS_SERIF);
         MathVariant.PARAMFORFONT.put(FontFamily.SANSSERIF,
                 Parameter.FONTS_SANSSERIF);
         MathVariant.PARAMFORFONT.put(FontFamily.MONOSPACED,
                 Parameter.FONTS_MONOSPACED);
         MathVariant.PARAMFORFONT.put(FontFamily.SCRIPT,
                 Parameter.FONTS_SCRIPT);
         MathVariant.PARAMFORFONT.put(FontFamily.FRAKTUR,
                 Parameter.FONTS_FRAKTUR);
         MathVariant.PARAMFORFONT.put(FontFamily.DOUBLE_STRUCK,
                 Parameter.FONTS_DOUBLESTRUCK);
     }
 
     /** {@inheritDoc} */
     @Override
     public int hashCode() {
         final int prime = 31;
         int result;
         if (this.fontFamily == null) {
             result = 0;
         } else {
             result = this.fontFamily.hashCode();
         }
         result = prime * result + this.awtStyle;
         return result;
     }
 
     /** {@inheritDoc} */
     @Override
     public boolean equals(final Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null) {
             return false;
         }
         if (this.getClass() != obj.getClass()) {
             return false;
         }
         final MathVariant other = (MathVariant) obj;
         if (this.awtStyle != other.awtStyle) {
             return false;
         }
         if (this.fontFamily == null) {
             if (other.fontFamily != null) {
                 return false;
             }
         } else if (!this.fontFamily.equals(other.fontFamily)) {
             return false;
         }
         return true;
     }
 
     /** {@inheritDoc} */
     @Override
     public String toString() {
         final StringBuilder b = new StringBuilder();
         b.append('[');
         b.append(this.fontFamily);
         if (this.awtStyle > 0) {
             b.append(' ');
         }
         if ((this.awtStyle & Font.BOLD) > 0) {
             b.append('B');
         }
         if ((this.awtStyle & Font.ITALIC) > 0) {
             b.append('I');
         }
         b.append(']');
         return b.toString();
     }
 }

1		/*
2		* Copyright 2002 - 2008 JEuclid, http://jeuclid.sf.net
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		/* $Id: MathVariant.java,v e6bd6c2d9bf4 2008/11/28 15:02:26 maxberger $ */
18
19		package net.sourceforge.jeuclid.elements.support.attributes;
20
21		import java.awt.Font;
22		import java.io.Serializable;
23		import java.util.HashMap;
24		import java.util.HashSet;
25		import java.util.List;
26		import java.util.Locale;
27		import java.util.Map;
28		import java.util.Set;
29
30		import net.sourceforge.jeuclid.LayoutContext;
31		import net.sourceforge.jeuclid.context.Parameter;
32		import net.sourceforge.jeuclid.elements.support.text.CharacterMapping;
33		import net.sourceforge.jeuclid.font.FontFactory;
34
35		import org.apache.commons.logging.Log;
36		import org.apache.commons.logging.LogFactory;
37
38		/**
39		* Class to represent and use MathVariants.
40		*
41		* @version $Revision: e6bd6c2d9bf4 $
42		*/
43		public final class MathVariant implements Serializable {
44
45		/**
46		* Mathvariant constant. Bold style.
47		*/
48	209	public static final MathVariant BOLD = new MathVariant(Font.BOLD,
49		FontFamily.SERIF);
50
51		/**
52		* Mathvariant constant. Bold fraktur style.
53		*/
54	209	public static final MathVariant BOLD_FRAKTUR = new MathVariant(Font.BOLD,
55		FontFamily.FRAKTUR);
56
57		/**
58		* Mathvariant constant. Bold-italic style.
59		*/
60	209	public static final MathVariant BOLD_ITALIC = new MathVariant(Font.BOLD
61		\| Font.ITALIC, FontFamily.SERIF);
62
63		/**
64		* Mathvariant constant. Bold sans-serif style.
65		*/
66	209	public static final MathVariant BOLD_SANS_SERIF = new MathVariant(
67		Font.BOLD, FontFamily.SANSSERIF);
68
69		/**
70		* Mathvariant constant. Bold script style.
71		*/
72	209	public static final MathVariant BOLD_SCRIPT = new MathVariant(Font.BOLD,
73		FontFamily.SCRIPT);
74
75		/**
76		* Mathvariant constant. Double struck style.
77		*/
78	209	public static final MathVariant DOUBLE_STRUCK = new MathVariant(
79		Font.PLAIN, FontFamily.DOUBLE_STRUCK);
80
81		/**
82		* Mathvariant constant. Fraktur style.
83		*/
84	209	public static final MathVariant FRAKTUR = new MathVariant(Font.PLAIN,
85		FontFamily.FRAKTUR);
86
87		/**
88		* Mathvariant constant. Italic style.
89		*/
90	209	public static final MathVariant ITALIC = new MathVariant(Font.ITALIC,
91		FontFamily.SERIF);
92
93		/**
94		* Mathvariant constant. Monospace style.
95		*/
96	209	public static final MathVariant MONOSPACE = new MathVariant(Font.PLAIN,
97		FontFamily.MONOSPACED);
98
99		/**
100		* Mathvariant constant. Normal style.
101		*/
102	209	public static final MathVariant NORMAL = new MathVariant(Font.PLAIN,
103		FontFamily.SERIF);
104
105		/**
106		* Mathvariant constant. Sans-serif style.
107		*/
108	209	public static final MathVariant SANS_SERIF = new MathVariant(Font.PLAIN,
109		FontFamily.SANSSERIF);
110
111		/**
112		* Mathvariant constant. Bold italic sans-serif style.
113		*/
114	209	public static final MathVariant SANS_SERIF_BOLD_ITALIC = new MathVariant(
115		Font.BOLD \| Font.ITALIC, FontFamily.SANSSERIF);
116
117		/**
118		* Mathvariant constant. Italic sans-serif style.
119		*/
120	209	public static final MathVariant SANS_SERIF_ITALIC = new MathVariant(
121		Font.ITALIC, FontFamily.SANSSERIF);
122
123		/**
124		* Mathvariant constant. Script style.
125		*/
126	209	public static final MathVariant SCRIPT = new MathVariant(Font.PLAIN,
127		FontFamily.SCRIPT);
128
129	209	private static final Map<String, MathVariant> ATTRIBUTEMAP = new HashMap<String, MathVariant>();
130
131	209	private static final Map<FontFamily, Parameter> PARAMFORFONT = new HashMap<FontFamily, Parameter>();
132
133		/**
134		*
135		*/
136		private static final long serialVersionUID = 1L;
137
138		/**
139		* Logger for this class.
140		*/
141	209	private static final Log LOGGER = LogFactory
142		.getLog(CharacterMapping.class);
143
144	209	private static final Set<Integer> WARNED = new HashSet<Integer>();
145
146		private final int awtStyle;
147
148		private final FontFamily fontFamily;
149
150		/**
151		* Creates a Mathvariant with the given AWT-Style and font-family.
152		*
153		* @param awtstyle
154		* the awt Style
155		* @param family
156		* the font family
157		*/
158	4598	public MathVariant(final int awtstyle, final FontFamily family) {
159	4598	this.awtStyle = awtstyle;
160	4598	this.fontFamily = family;
161	4598	};
162
163		/**
164		* Creates a Mathvariant object from an attribute value.
165		*
166		* @param variant
167		* the string representation of the attribute value
168		* @return a mathVariant object or null if none is found.
169		*/
170		public static MathVariant stringToMathVariant(final String variant) {
171	17982	synchronized (MathVariant.ATTRIBUTEMAP) {
172		// Needs to be initialized late due to chicken-egg problem.
173	17982	if (MathVariant.ATTRIBUTEMAP.isEmpty()) {
174	209	MathVariant.ATTRIBUTEMAP.put("normal", MathVariant.NORMAL);
175	209	MathVariant.ATTRIBUTEMAP.put("bold", MathVariant.BOLD);
176	209	MathVariant.ATTRIBUTEMAP.put("italic", MathVariant.ITALIC);
177	209	MathVariant.ATTRIBUTEMAP.put("bold-italic",
178		MathVariant.BOLD_ITALIC);
179	209	MathVariant.ATTRIBUTEMAP.put("double-struck",
180		MathVariant.DOUBLE_STRUCK);
181	209	MathVariant.ATTRIBUTEMAP.put("bold-fraktur",
182		MathVariant.BOLD_FRAKTUR);
183	209	MathVariant.ATTRIBUTEMAP.put("script", MathVariant.SCRIPT);
184	209	MathVariant.ATTRIBUTEMAP.put("bold-script",
185		MathVariant.BOLD_SCRIPT);
186	209	MathVariant.ATTRIBUTEMAP.put("fraktur", MathVariant.FRAKTUR);
187	209	MathVariant.ATTRIBUTEMAP.put("sans-serif",
188		MathVariant.SANS_SERIF);
189	209	MathVariant.ATTRIBUTEMAP.put("bold-sans-serif",
190		MathVariant.BOLD_SANS_SERIF);
191	209	MathVariant.ATTRIBUTEMAP.put("sans-serif-italic",
192		MathVariant.SANS_SERIF_ITALIC);
193	209	MathVariant.ATTRIBUTEMAP.put("sans-serif-bold-italic",
194		MathVariant.SANS_SERIF_BOLD_ITALIC);
195	209	MathVariant.ATTRIBUTEMAP.put("monospace",
196		MathVariant.MONOSPACE);
197		}
198	17982	return MathVariant.ATTRIBUTEMAP.get(variant
199		.toLowerCase(Locale.ENGLISH));
200	0	}
201		}
202
203		/**
204		* Create a font for the given attributes.
205		*
206		* @param size
207		* size of the font to create
208		* @param codepoint
209		* a character that must exist in this font
210		* @param context
211		* LayoutContext to use.
212		* @param force
213		* if true will always return a font, otherwise will return
214		* null.
215		* @return a font object.
216		*/
217		@SuppressWarnings("unchecked")
218		public Font createFont(final float size, final int codepoint,
219		final LayoutContext context, final boolean force) {
220
221	81108	final Parameter theParam = MathVariant.PARAMFORFONT
222		.get(this.fontFamily);
223	81108	final Font font = FontFactory.getInstance().getFont(
224		(List<String>) context.getParameter(theParam), codepoint,
225		this.awtStyle, size);
226	81108	if (force && font == null) {
227	0	if (!MathVariant.WARNED.contains(codepoint)) {
228	0	MathVariant.WARNED.add(codepoint);
229	0	final String hexString = Integer.toHexString(codepoint);
230	0	MathVariant.LOGGER
231		.warn("No font available to display character "
232		+ hexString);
233	0	MathVariant.LOGGER
234		.info("Find a font at http://www.fileformat.info/info/unicode/char/"
235		+ hexString
236		+ "/fontsupport.htm or "
237		+ "http://www.alanwood.net/unicode/search.html");
238		}
239	0	return FontFactory.getInstance().getFont(FontFactory.SANSSERIF,
240		this.awtStyle, size);
241		}
242	81108	return font;
243		}
244
245		/**
246		* @return the awtStyle
247		*/
248		public int getAwtStyle() {
249	13168	return this.awtStyle;
250		}
251
252		/**
253		* @return the fontFamily
254		*/
255		public FontFamily getFontFamily() {
256	19562	return this.fontFamily;
257		}
258
259		static {
260	209	MathVariant.PARAMFORFONT.put(FontFamily.SERIF, Parameter.FONTS_SERIF);
261	209	MathVariant.PARAMFORFONT.put(FontFamily.SANSSERIF,
262		Parameter.FONTS_SANSSERIF);
263	209	MathVariant.PARAMFORFONT.put(FontFamily.MONOSPACED,
264		Parameter.FONTS_MONOSPACED);
265	209	MathVariant.PARAMFORFONT.put(FontFamily.SCRIPT,
266		Parameter.FONTS_SCRIPT);
267	209	MathVariant.PARAMFORFONT.put(FontFamily.FRAKTUR,
268		Parameter.FONTS_FRAKTUR);
269	209	MathVariant.PARAMFORFONT.put(FontFamily.DOUBLE_STRUCK,
270		Parameter.FONTS_DOUBLESTRUCK);
271	209	}
272
273		/** {@inheritDoc} */
274		@Override
275		public int hashCode() {
276		final int prime = 31;
277		int result;
278	85511	if (this.fontFamily == null) {
279	0	result = 0;
280		} else {
281	85511	result = this.fontFamily.hashCode();
282		}
283	85511	result = prime * result + this.awtStyle;
284	85511	return result;
285		}
286
287		/** {@inheritDoc} */
288		@Override
289		public boolean equals(final Object obj) {
290	58115	if (this == obj) {
291	57279	return true;
292		}
293	836	if (obj == null) {
294	0	return false;
295		}
296	836	if (this.getClass() != obj.getClass()) {
297	0	return false;
298		}
299	836	final MathVariant other = (MathVariant) obj;
300	836	if (this.awtStyle != other.awtStyle) {
301	0	return false;
302		}
303	836	if (this.fontFamily == null) {
304	0	if (other.fontFamily != null) {
305	0	return false;
306		}
307	836	} else if (!this.fontFamily.equals(other.fontFamily)) {
308	0	return false;
309		}
310	836	return true;
311		}
312
313		/** {@inheritDoc} */
314		@Override
315		public String toString() {
316	0	final StringBuilder b = new StringBuilder();
317	0	b.append('[');
318	0	b.append(this.fontFamily);
319	0	if (this.awtStyle > 0) {
320	0	b.append(' ');
321		}
322	0	if ((this.awtStyle & Font.BOLD) > 0) {
323	0	b.append('B');
324		}
325	0	if ((this.awtStyle & Font.ITALIC) > 0) {
326	0	b.append('I');
327		}
328	0	b.append(']');
329	0	return b.toString();
330		}
331		}